Federated Learning-Based Location Similarity Model for Location Privacy Preserving Recommendation

Abstract

With the proliferation of mobile devices and wireless communications, Location-Based Social Networks (LBSNs) have seen tremendous growth. Location recommendation, as an important service in LBSNs, can provide users with locations of interest by analyzing their complex check-in information. Currently, most location recommendations use centralized learning strategies, which carry the risk of user privacy breaches. As an emerging learning strategy, federated learning is widely applied in the field of location recommendation to address privacy concerns. We propose a Federated Learning-Based Location Similarity Model for Location Privacy Preserving Recommendation (FedLSM-LPR) scheme. First, the location-based similarity model is used to capture the differences between locations and make location recommendations. Second, the penalty term is added to the loss function to constrain the distance between the local model parameters and the global model parameters. Finally, we use the REPAgg method, which is based on clustering for client selection, to perform global model aggregation to address data heterogeneity issues. Extensive experiments demonstrate that the proposed FedLSM-LPR scheme not only delivers superior performance but also effectively protects the privacy of users.

1. Introduction

With the exponential growth of global positioning system (GPS) trajectory data as a result of technological advances and the popularity of mobile devices, researchers have begun to focus on how to efficiently utilize this data to gain a deeper understanding of users’ complex mobile behaviors. As a result, location-based social networks (LBSNs) have been vigorously developed [1]. Through the location check-in function of mobile users, LBSNs closely integrate online virtual socialization with the offline real world [2], thus giving rise to a variety of location-based services. Among them, location recommendation plays a key role in providing superior user experience.

In the field of location-based recommendation, there are various alternative recommendation techniques such as content-based recommendation [3], collaborative filtering (CF), association rules [4], and utility-based recommendation [5]. CF is a widely used method in the recommendation field, known for its simplicity and efficiency. The method provides personalized recommendations to users by analyzing the similarities between their behaviors and preferences [6]. Specifically, CF-based location recommendation works by mapping user, location, and context information into a shared implicit space and using an inner product operation to compute the predictive score. Ultimately, the computed predictive scores are used to recommend tasks. Liu et al. [7] used a CF approach and considered groups as users to construct a group preference model by aggregating the preferences of each group member in order to improve the performance of the recommendation system. Zhang et al. [8] proposed a location-aware deep CF scheme. By using high-dimensional embedding vectors, a multi-layer perceptron, and a similarity adaptive corrector, this approach addresses the limitations of traditional CF methods, which are often constrained by low-dimensional and linear interactions.

However, for highly private and sensitive user information, the centralized information storage method used in the above study may carry the risk of leaking private user information. Especially after the enactment of the general data protection regulation (GDPR) [9] the requirements for personal data protection have become more stringent. Location service providers face the challenge of being unable to centrally store user data, making personalized recommendations difficult [10,11]. This situation is driving researchers and companies to seek new solutions that comply with the regulations. In recent years, federated learning within the field of distributed machine learning has garnered significant attention and become a central focus of extensive research [12,13,14,15]. This approach offers innovative solutions for location-based recommendations by enabling multiple participants to collaboratively train a shared machine learning model while maintaining data privacy. Federated learning effectively addresses the challenges of privacy, security, and distributed data, which are inherent in traditional machine learning methods. The core idea of federated learning is to enable participants to update model parameters using their local data and then send the updated model parameters to a central server for aggregation, thereby achieving continuous optimization and improvement of the model. In a federated learning framework, model parameters are transmitted between clients and the central server, effectively safeguarding user privacy. In order to protect users’ location data, this article uses a federated learning framework on the server side. However, in location-based recommendations using federated learning, each client has its own local dataset. Due to differences among clients, such as variations in user behavior and geographic locations, these local datasets exhibit different data distributions. In the case of non-independent and identically distributed (non-IID) data, the accuracy of the final aggregated global model is usually less than ideal. Due to the differences in data distribution among clients, each node tends to converge to a local optimum during local training, which may deviate from the direction of the global optimum. This can lead to biases in the models learned by individual nodes, thus severely affecting the accuracy of the aggregated global model [16,17]. Therefore, addressing the issue of data heterogeneity in location-based recommendations using federated learning becomes crucial.

Based on the above analysis, we propose a Federated Learning-Based Location Similarity Model for Location Privacy Preserving Recommendation (FedLSM-LPR) scheme. The scheme involves the collaborative work of a central server and multiple edge clients working together to carry out the training process on local data. First, each client uses a location-based similarity model for location recommendation. At the same time, a two-stage perturbation approach is used to protect the user’s data privacy. Second, the L2 norm regularization term between the local and global models is added to the loss function as a penalty to constrain the difference between the two models. Finally, we propose a clustering-based client selection method for the impact of non-IID data on federated learning location recommendation. By combining this method with the REPAgg aggregation method, the performance of federated learning location recommendation is effectively improved.

The main contributions of this paper are as follows:

• The location similarity model based on federated learning is constructed to provide personalized location-related services for target users. The model will be employed on the client side in order to capture the subtle differences between locations and enhance the performance of location recommendations. Federated learning is utilized on the server side to ensure data privacy while aggregating the model.
• The clustering-based client selected algorithm is proposed to further mitigate the impact of non-IID data on the framework of location recommendation. The algorithm performs client clustering and combines client selection based on local loss and model similarity. Additionally, the penalty term is utilized in the client loss function to constrain the difference between the local model and the global model.
• Extensive experiments and analysis are conducted on two real datasets to validate the effectiveness of the proposed FedLSM-LPR scheme. The experimental results demonstrate that the performance is better than that of the other existing schemes.

2. Related Work

Location-based recommendations are a key application of location-based services (LBS), aiming to suggest places that align with users’ interests and preferences [18,19,20]. This helps users discover and better understand their surroundings. Location-based recommendations have garnered significant attention from researchers, with CF-based approaches being particularly noteworthy [21]. CF methods can be categorized into two types: user-based and location-based. User-based CF methods make recommendations by finding other users with similar interests and behavior patterns. This approach leverages the historical behaviors and preferences of users to identify those most similar to the target user and recommends locations that these similar users have liked to the target user. User-based CF methods are simple and intuitive, leveraging the similarities between users to make recommendations. This approach is well-suited for scenarios where user behaviors and preferences are relatively clear. Ye et al. [22] proposed a user-based CF recommendation scheme that utilizes location evaluation data and combines it with machine learning algorithms to compute friends with similarity to the target user to achieve location recommendation. However, user-based CF recommendation schemes have certain limitations. For instance, when dealing with new users, the lack of sufficient personal behavioral data makes it difficult to find similar users, thereby reducing the accuracy and reliability of the recommendations. In contrast, location-based CF methods make recommendations by analyzing the similarities between locations. This approach focuses on the relationships between locations rather than the similarities between users. By calculating the similarity between locations, it recommends locations similar to those the user has liked in the past. Zheng et al. [23] proposed a personalized location recommendation system utilizing GPS trajectory data. This system reveals the correlations between locations by learning users’ travel experiences and the sequence of location visits. As a location-based CF method, it overcomes the issues encountered in user-based CF methods. However, in today’s data-driven society, data security and privacy protection have become crucial [24]. The aforementioned research utilizes traditional centralized data storage methods, which may pose potential issues regarding data privacy and security. Traditional encryption methods, such as homomorphic encryption [25] and secret sharing [26], are challenging to implement widely in systems due to their computational costs.

To address the aforementioned limitations, McMahan et al. [27] first proposed the federated learning framework, introducing the Federated Averaging (FedAvg) algorithm to enable collaborative training of data distributed across different devices. As an emerging machine learning paradigm, federated learning aims to achieve collaborative learning on distributed data while protecting data privacy and security. In federated learning, data holders (e.g., personal devices, edge servers, institutional servers) retain their original data locally and perform model training, thereby avoiding the risk of sensitive data leakage caused by centralized storage. The basic process of federated learning is illustrated in Figure 1.

Federated learning faces several challenges in location-based recommendation systems. First, since user data is dispersed across different devices, it is a key challenge to efficiently integrate these data to improve the accuracy of the model. Second, federated learning models may also face the problem of model bias, i.e., the difference in distribution between local and global models, which can lead to bias in the model training process and reduce the generalization ability and recommendation accuracy of the models. In addition, although federated learning aims to enhance privacy protection, there may still be a risk of information leakage. How to ensure model performance and recommendation quality while guaranteeing user privacy still needs to be continuously explored. Together, these factors increase the complexity of realizing an efficient and accurate federated learning location recommendation system. In federated learning recommendation systems, Ammad-ud-din et al. [28] were the first to combine federated learning with CF to protect client data privacy, laying the foundation for further research. Chai et al. [29] proposed a scheme named FedMF, which combines federated learning and homomorphic encryption to protect user privacy. This scheme utilizes matrix factorization on the client side to make recommendations. Perifanis et al. [30] implemented federated learning recommendations using neural CF and proposed a privacy-preserving aggregation method to ensure the security of model training. Experimental results demonstrated the effectiveness of this system in both recommendation quality and privacy protection. Huang et al. [31] proposed a position recommendation scheme that combines matrix factorization and federated learning. This scheme constructs a geographic information matrix to quantify location information and combines it with a scoring matrix for matrix decomposition using the singular value decomposition technique. Lin et al. [32] proposed a federated recommendation scheme called FedRec for solving the rating prediction problem with explicit feedback. The scheme uses explicit feedback to extend the probability matrix decomposition to both batch and random styles. However, due to the non-IID nature of location data, the use of simple weighted averaging to aggregate client model parameters in the aforementioned studies may result in decreased model performance when handling such data. Dong et al. [33] proposed a personalized federated learning method using locality-sensitive hashing to address the impact of non-IID data in federated learning-based location recommendations. Li et al. [34] proposed a federated aggregation algorithm with dynamic loss to enhance the performance of weaker clients. Ding et al. [35] proposed a meta-learning inspired federated aggregation method for fast convergence, aiming to address data heterogeneity issues in federated recommendation systems and accelerate the convergence of global training. This method draws inspiration from the REPTILE algorithm, approximating global updates through Taylor expansion while maintaining gradient direction consistency to accelerate convergence. However, despite improving the efficiency of server-side aggregation, the federated aggregation method REPAgg still has limitations. First, it does not explicitly constrain the divergence between local client models and the global model, which may lead to bias accumulation in highly heterogeneous data environments. Second, the uniform random sampling strategy for client selection overlooks differences in data quality, potentially affecting model performance under extreme non-IID conditions.

3. Preliminaries

In this section, we provide a detailed explanation of the location-based similarity model. Following this, we introduce the core mechanism of the REPAgg aggregation method. Finally, we define the problem addressed in this study.

Table 1. Glossary of notations.

Symbol	Definition
$p,q$	Number of users and locations
$u,U$	User and the user set
$i,L$	Location and the location set
$L_u^{+}$	Historical interacted locations of user u
$M,N$	Location feature matrix
$m_i,n_i$	Location feature vector of location i
E	Number of iterations for local training
T	Number of global training iterations
${\widehat{y}}_{ui}$	Prediction of user u for location i
${\Delta }_k^t$	Updates of client k at tth epoch
$w_G^t$	Global model parameters at tth epoch
$w_k^t$	Local model parameters at tth epoch

summarizes the key symbols used in this paper and their respective meanings.

3.1. Location-Based Similarity Model

The core idea of standard location-based CF [36] is that the similarity between location i and all the locations the user has interacted with in the past determines the user u’s prediction of the target location i. Such models infer users’ preferences and interests in unknown locations by mining the interaction patterns between users and locations. The formula for the prediction model of CF based on standard locations is shown as follows:

$${\widehat{y}}_{ui}=\sum _{j\in L_u^{+}}{l}_{uj}{S}_{ij},$$

(1)

where $L_u^{+}$ is the set of historical locations that the user interacted with, $S_{ij}$ is the similarity between location i and location j, and $l_{uj}$ is user u’s preference for location j. User preferences for locations are typically represented as implicit and explicit feedback. Implicit feedback consists of indirect signals generated during the user’s interaction with the system, such as clicks, browsing history, and purchase records, which infer the user’s preferences. Explicit feedback is directly provided by the user, including ratings, reviews, likes, and dislikes.

Ning et al. [37] proposed the SLIM model, which learns location similarity by optimizing a recommendation-aware objective function. SLIM optimizes by minimizing the loss between two matrices: the original user-location interaction matrix and the reconstructed user-location interaction matrix generated by the location-based similarity model. However, this model is limited to learning similarity only between location pairs that share ratings and cannot identify transitive relationships between locations.

To address the limitations of the SLIM model, Kabbur et al. [38] proposed the FISM model. This model represents locations as low-dimensional embedding vectors and uses the inner product of the embedding vectors i and j to represent the similarity score. However, the FISM model overlooks the heterogeneity between different locations by assigning the same weight to all interacting locations. Treating all of a user’s historical locations equally can limit the model’s performance.

To address the aforementioned issues, He et al. [39] proposed the NAIS model, which possesses stronger representational capabilities. By incorporating an attention mechanism network, the NAIS model introduces additional parameters that better capture the differences between various locations. The NAIS prediction model can be represented by the following formula:

$${\widehat{y}}_{ui}=m_i^T\left(\sum _{j\in L_u^{+}\setminus \left\{i\right\}}{\alpha }_{ij}{n}_j\right),$$

(2)

$${\alpha }_{ij}={\displaystyle \frac{exp\left(f\left(m_i,n_j\right)\right)}{{\left[{\sum }_{k\in L_u^{+}\setminus \left\{i\right\}}exp\left(f\left(m_i,n_k\right)\right)\right]}^{\tau }}},$$

(3)

where ${\alpha }_{ij}$ is the similarity weights of location i and location j when predicting user u’s preference for target location i, $\tau$ is the smoothing index in the range of [0, 1], and $f\left(m_i,n_j\right)$ is the attention function of location i and location j. Because NAIS effectively identifies the heterogeneity between locations, we adopt it as the client model in federated learning for location-based recommendations.

3.2. Server Aggregation with REPAgg

REPTILE [40] is a meta-learning algorithm that iteratively optimizes model parameters through a combination of inner and outer updates. Its core objective is to achieve rapid adaptation to new tasks. Specifically, in the inner update phase, the algorithm performs multiple rounds of gradient descent on each specific task’s dataset to reduce the loss function value. This process mimics single-task training to facilitate rapid adaptation to new tasks. Following this, in the outer update phase, the model adjusts its parameters based on the differences between the parameters after the inner update and the initial parameters. By adding a proportion of these differences to the initial parameters, the model’s generalization ability to unknown tasks is enhanced. The internal and external updates can be represented by the following formula:

$$w_z=w_0-\alpha {\nabla }_{w_0}L\left(w_0,D_z\right),$$

(4)

$$w_0=w_0+\beta {\displaystyle \frac{1}{\left|Z\right|}}\sum _{z\in Z}\left(w_z-w_0\right),$$

(5)

where $w_0$ is the initialized model parameters of task $z\in Z$, $w_z$ is the updated model parameters of task z, $\alpha$ is the internally updated learning rate, $\beta$ is the learning rate for external updates. ${\nabla }_{w_0}L\left(w_0,D_z\right)$ is the gradient of the loss function $L\left(w_0,D_z\right)$ with respect to the model parameter $w_0$, and $D_z$ is the training dataset of task z.

Ding et al. [35] applied the idea of REPTILE to federated learning and changed the traditional federated aggregation method, which is formulated as follows:

$$w_G^{t+1}=w_k^t+\lambda {\displaystyle \frac{1}{\left|S\right|}}\sum _{k\in S}{\Delta }_k^t,$$

(6)

where $w_k^t$ is the model parameter of client k, which is the global model obtained by the server via the federated aggregation algorithm at $t-1$ epoch, ${\Delta }_k^t$ is the model update obtained by client k via local training, $\lambda$ is the learning rate, S is the set of selected clients, and $w_G^{t+1}$ is the global model obtained by the server via the federated aggregation algorithm at t epoch. Due to the server’s inability to grasp the overall distribution of user characteristics, this method may reduce the impact of model parameter updates for locations that are infrequently interacted with. Therefore, this federated aggregation approach is not suitable for recommendation tasks based on a location similarity model. Ding et al. [35] modified the above federated aggregation method and proposed the REPAgg aggregation method to better fit the needs of recommendation tasks based on a location similarity model. The formula for the REPAgg aggregation method is shown as follows:

$$\begin{array}{cc}\hfill M^{t+1}=& M^t+\lambda \left[\sum _{k\in S}{\Delta }_k^t\left(m_1\right),\sum _{k\in S}{\Delta }_k^t\left(m_2\right),\dots ,\sum _{k\in S}{\Delta }_k^t\left(m_q\right)\right],\hfill \end{array}$$

(7)

$$\begin{array}{cc}\hfill N^{t+1}=& N^t+\lambda \left[\sum _{k\in S}{\Delta }_k^t\left(n_1\right),\sum _{k\in S}{\Delta }_k^t\left(n_2\right),\dots ,\sum _{k\in S}{\Delta }_k^t\left(n_q\right)\right],\hfill \end{array}$$

(8)

where M and N are the location feature matrices, and the update of the location feature vectors for client k is denoted by ${\Delta }_k^t\left(m_i\right)$ and ${\Delta }_k^t\left(n_i\right)$.

3.3. Problem Definition

To protect the privacy of each client’s data, this paper employs a federated learning framework. In federated learning-based location recommendation, each client independently stores and processes its own interaction data, which is never uploaded to the server. The server’s role is to organize and coordinate the work of the clients without directly accessing their data. This allows clients to collaboratively train a global model while ensuring that personal data remains private, thus achieving the goal of providing personalized location recommendations without compromising privacy. To further enhance privacy, clients apply a two-stage perturbation process, which disturbs both location data and model updates, preventing attackers from inferring sensitive information or reconstructing the original data from the model updates. We assume that clients trust each other in this federated learning setup. In federated learning-based location recommendation, we let $u\in U$ denote the user, $i\in L$ denote the location, with the number of users as p and the number of locations as q. The interactions between users and locations are represented in a simple binary manner: 1 indicates that the user has interacted with the location in the past, and 0 indicates otherwise. The formula for user interaction is shown as follows:

$$y_{ui}=\left\{\begin{array}{cc}1,\hfill & i\in L_u^{+}\hfill \\ 0,\hfill & i\notin L_u^{+}\hfill \end{array}\right.,$$

(9)

where $y_{ui}$ is the interaction between user u and location i, and $L_u^{+}$ is the historical interaction position of user u.

4. Proposed Framework

In this section, we will provide a detailed overview of the overall architecture and methods used in the FedLSM-LPR scheme.

4.1. Model Overview

The overall architecture of the FedLSM-LPR scheme is illustrated in Figure 2. This architecture combines a location similarity model with federated learning to train on decentralized data, thereby constructing a global model while ensuring the privacy and security of user data.

The overall implementation steps of FedLSM-LPR are as follows: Step 1: Before federated learning begins, all clients calculate the rating frequency distribution based on their local data and send this information to the server. Upon receiving the rating frequency distributions from the clients, the server uses the K-means algorithm to cluster these distributions, resulting in the clients’ cluster labels C. Step 2: The server initializes the global model using a Gaussian distribution and randomly samples clients in each epoch to participate in the model training. The server then distributes the initialized global model $w_G^0$ to the selected clients. Step 3: After receiving the initialized model from the server, each client employs a loss function with a penalty term and trains the model on its local dataset using a location similarity model. During the training process, clients protect their local data with label perturbation. After E local optimization steps, clients apply model update perturbation to the generated model updates and upload the locally computed loss and the perturbed model updates to the server. Step 4: Upon receiving the local losses and perturbed model updates from each client, the server employs the REPAgg aggregation method, which is based on cluster-based client selection, to aggregate the global model. Step 5: The server distributes the aggregated global model to each client. Repeat steps 3–5 until the model converges. The pseudo-code of the FedLSM-LPR scheme is shown in Algorithm 1.

Algorithm 1 FedLSM-LPR

Input:  Client set U, Number of Iterations for Local Training E, Number of Iterations for Global Training T, Local and Global learning rates $\eta$ and $\lambda$, Clusters c, Number of selected clients K, Selection of client ratio based on model similarity $f_1$, Selection of client ratio based on loss $f_2$ Output:  Global model $w_G$   1: for each client $k\in U$ do   2:    Receive rating frequency distribution $Q_k$ from client k   3: end for   4: Cluster clients into $C=\left\{C_1,C_2,\dots ,C_c\right\}$ via K-means($Q_k$)   5: Server initializes global model $w_G^0=\{M,N,f(.,.)\}$ and other hyper-parameters   6: for each global epoch $t=0,1,\dots ,T$ do   7:    $S\leftarrow$ Randomly sample K clients from U   8:    Broadcast $w_G^t$ to all $k\in S$   9:    for each client $k\in S$ do 10:      ${\overline{\Delta }}_k^t,{{\mathcal{L}}_k}^{\prime }\leftarrow \mathrm{ClientLocalUpdate}(k,w_G^t)$ 11:    end for 12:    for cluster $C_i\in C$ do 13:      //Obtain selected client set ${\mathrm{Sel}}_{C_i}$ using Client Selection algorithm 14:      $Se{l}_{C_i}\leftarrow ClientSelection(C_i,f_1,f_2)$ 15:      Aggregate model updates for selected clients 16:    end for 17:    //Aggregation of REPAgg model using Formulas (14) and (15) 18:    $w_G^{t+1}\leftarrow ModelAggregation(w_G^t,{\overline{\Delta }}_{C_i}^t,\lambda )$ 19: end for 20: Function ClientLocalUpdate($k,w_G^t$): 21:    //Accept server model 22:    $w_k^t\leftarrow w_G^t$ 23:    for each local epoch $e=0,1,\dots ,E$ do 24:       Use label perturbation to perturb training data 25:       $w_G^t\leftarrow LocalOptimization(w_G^t,L_u^{+},\eta )$ 26:    end for 27:    ${\Delta }_k^t=w_k^t-w_G^t$ 28:    Obtain ${\overline{\Delta }}_k^t$ through using model update perturbation to perturb ${\Delta }_k^t$ 29:    ${{\mathcal{L}}_k}^{\prime }=ComputeLoss(D_k,w_k^t)$ 30:    return ${\overline{\Delta }}_k^t,{{\mathcal{L}}_k}^{\prime }$

4.2. Client-Side Regularization

FedIS does not take into account the potential differences between the local model and the global model when dealing with client-side local optimization. In FedIS, for the local data of client $k\in S$, the following formula is used for optimization:

$$\begin{array}{cc}\hfill \mathcal{L}=& -{\displaystyle \frac{1}{H}}\left[\sum _{i\in L_u^{+}}log\sigma \left({\widehat{y}}_{ui}\right)+\sum _{i\in L_u^{-}}log\sigma \left(1-{\widehat{y}}_{ui}\right)\right]+\psi {∥w_k^t∥}^2\hfill \end{array},$$

(10)

where $w_k^t$ is the local model of client k which is initialized by the global model $w_G^t$ obtained from the previous epoch through model aggregation, H is the number of training samples, $\sigma (·)$ is a sigmoid function, and $\psi$ is a parameter controlling the strength of regularization.

Since each client trains its model based solely on its own data without considering consistency with the global model, this can result in significant deviations between the locally optimized models and the global model. In practical applications, such deviations can cause instability in the global model’s performance, especially when dealing with highly non-IID data.

To solve the above problem, we use the L2 norm regularization term between the local and global models as a penalty term to prevent the local models from drifting too far from the global model. We incorporate this penalty term into Formula (10) to address the issue of local model drift. Consequently, client k uses its local data and optimizes the local model using the loss function specified in the following formula:

$$\begin{array}{cc}\hfill {\mathcal{L}}^{\prime }=& -{\displaystyle \frac{1}{H}}\left[\sum _{i\in L_u^{+}}log\sigma \left({\widehat{y}}_{ui}\right)+\sum _{i\in L_u^{-}}log\sigma \left(1-{\widehat{y}}_{ui}\right)\right]+\psi {∥w_k^t∥}^2+{\displaystyle \frac{\tau }{2}}{∥w_G^t-w_k^t∥}^2\hfill \end{array},$$

(11)

where $w_k^t$ is the local model of the client k, $w_G^t$ is the global model, and $\tau$ is the regularization parameter used to control the degree of difference between the local model and the global model. It helps avoid overfitting on local data and improves the model’s generalization ability in federated learning environments. The value of parameter $\tau$ will affect the performance of the model: if the value of $\tau$ is too high, it will excessively restrict local updates and reduce personalization ability; if the $\tau$ value is too small, it may make it difficult for the global model to converge.

Overall, the above approach provides the following key benefits: (i) Constraining the extent of model updates. In a federated learning environment, each client trains its model locally based on its own dataset. Due to the differences in the characteristics and distributions of the datasets across clients, the extent of model updates can vary, leading to significant changes in model parameters at certain nodes. The penalty term can constrain the extent of these personalized model updates, preventing excessive parameter adjustments and more effectively managing the scope of model updates. (ii) Enhancing model generalization. By introducing regularization techniques into the loss function, the growth of model parameters can be effectively constrained, reducing the model’s sensitivity to specific training samples. This approach not only helps to mitigate the issue of overfitting but also enhances the model’s predictive capabilities when dealing with unseen data.

4.3. Clustering-Based Client-Selected REPAgg Aggregation Approach

In practical applications, differences in client identity, behavior, and environment often result in data that exhibits non-IID characteristics. These characteristics can lead to significant variations in model performance across different devices, thereby affecting the effectiveness of model training. In this paper, we use a clustering-based client-selected REPAgg aggregation method to address the above challenges. The method consists of three parts: (i) Client Clustering; (ii) Client Selection; (iii) Model Aggregation. Next, we will introduce each of these three parts in detail.

(i)

Client Clustering

Each client k calculates the frequency distribution of different ratings based on its local data and sends this distribution to the server. Upon receiving the rating frequency distributions from each client, the server uses these rating frequency distributions $Q_k$ as the basis for clustering, dividing the clients into c different clusters, denoted as $C=\left\{C_1,C_2,\dots ,C_c\right\}$. Specifically, the server computes the Euclidean distance between the rating frequency distributions $Q_k$ of each client and uses a K-means clustering algorithm to categorize the clients into c clusters. The rating frequency distributions collected by the server do not include the historical location ids of user interactions, which means that the server cannot determine at which locations the users have rated. The Euclidean distance with respect to different rating frequency distributions $Q_k$ is defined as follows:

$$dist\left(Q_i,Q_j\right)=\sqrt{{\sum }_{d=1}^D{\left(Q_i^d-Q_j^d\right)}^2}.$$

(12)

(ii)

Client Selection

In the client selection phase, we primarily base the selection on model similarity and local loss. Specifically, for client k within a cluster, the model similarity is measured by calculating the cosine similarity between the local model and the global model. The cosine similarity ranges from −1 to 1. A value close to 1 indicates that the angle between the two vectors is close to 0 degrees, suggesting that the two models are very similar. Unlike the Euclidean distance metric, cosine similarity emphasizes consistency in the direction of the parameters rather than differences in numerical magnitude or location. The cosine similarity between the local model and the global model is calculated using the following formula:

$$cos\left(w_k^t,w_G^t\right)={\displaystyle \frac{〈w_k^t,w_G^t〉}{∥w_k^t∥∥w_G^t∥}},$$

(13)

where $w_k^t$ is the local model of client k, $w_G^t$ is the global model, and $cos(·,·)$ is the cosine similarity function. The larger the cosine similarity, the more the local model $w_k^t$ tends to favor the global model $w_G^t$ in direction. Local loss is the loss value computed by the client based on its own data. For cluster $C_i\in C$, the server selects clients using a proportional method based on two metrics: the local loss uploaded by the clients and the model similarity. Algorithm 2 summarizes the process of client selection by the server.

Algorithm 2 Client Selection

Input:  Client model similarity set $\left\{{sim}_k\mid k\in C_i\right\}$, Client loss set $\left\{{loss}_k\mid k\in C_i\right\}$, Selection of client ratio based on model similarity $f_1$, Selection of client ratio based on loss $f_2$ Output:  Selected client set $Se{l}_{C_i}=\left\{Selected\right\}$ 1: $\left\{{sim}_k^{\prime }\mid k\in C_i\right\}\leftarrow Sort\left(\left\{{sim}_k\mid k\in C_i\right\}\right)$ // Sort the client model similarity set 2: $\left\{{loss}_k^{\prime }\mid k\in C_i\right\}\leftarrow Sort\left(\left\{{loss}_k\mid k\in C_i\right\}\right)$ // Sort the client loss set 3: $\left\{{sim}^{*}\right\}\leftarrow f_1·\left\{{sim}_k^{\prime }\mid k\in C_i\right\}$ // Select clients with high similarity in the top $f_1$ 4: if${loss}_k^{\prime }\notin \left\{{sim}^{*}\right\}$ then 5:    $\left\{{loss}^{\prime \prime }\right\}\leftarrow {loss}_k^{\prime }$ 6: end if 7: $\left\{{loss}^{*}\right\}\leftarrow f_2·\left\{{loss}^{\prime \prime }\right\}$ // Select clients with high loss in the top $f_2$ 8: $\left\{Selected\right\}\leftarrow \left\{{sim}^{*}\right\}+\left\{{loss}^{*}\right\}$

When selecting clients, a strategy of choosing clients with larger losses can be used to quickly optimize the weakest parts of the model, promoting overall convergence. Clients with larger losses typically indicate that the model performs poorly on their data. Therefore, by training more on these clients, the model can learn features that are difficult to capture. However, only selecting clients with larger losses for aggregation may lead to a decline in model performance. To address this issue, we can use model similarity to guide the client selection process. High model similarity means that the direction of the local model is closer to the global model. This indicates that these clients typically have better local data representation and training effectiveness. Therefore, selecting clients with high model similarity to participate in global model updates can improve the overall model performance.

In addition, client selection on the basis of clustering has the following advantage: by clustering the frequency distribution of clients’ ratings, clients with similar rating habits are grouped into the same cluster. This operation allows for the clustering of clients that may have similar data distributions into a single cluster. Subsequently, representative clients are selected from the cluster based on the metrics. This approach ensures that a variety of data types are included in each iteration and mitigates the effects of non-IID data.

(iii)

Model Aggregation

In the model aggregation phase, we use the REPAgg aggregation method for global model aggregation. Unlike FedIS’s REPAgg-only approach, while REPAgg can mitigate the impact of non-IID data on model performance to some extent, it is not as effective when dealing with data with high heterogeneity. To address this issue, we combine client clustering, a client selection method based on loss function and model similarity, with REPAgg. Specifically, by clustering clients, FedLSM-LPR groups clients with similar data distributions and selects representative clients within each cluster to participate in model aggregation. This approach can better handle the differences in individual client data, thus effectively reducing the impact of non-IID data on model performance. We implement client clustering and selection methods, which necessitates modifying Formulas (7) and (8). Below are the revised formulas:

$$\begin{array}{cc}\hfill M^{t+1}=& M^t+\lambda ·\left\{\sum _{C_i\in C}\left[\sum _{k\in {Sel}_{C_i}}{\Delta }_k^t\left(m_1\right),\right.\right.\sum _{k\in {Sel}_{C_i}}{\Delta }_k^t\left(m_2\right),\dots ,\left.\left.\sum _{k\in {Sel}_{C_i}}{\Delta }_k^t\left(m_q\right)\right]\right\}\hfill \end{array},$$

(14)

$$\begin{array}{cc}\hfill N^{t+1}=& N^t+\lambda ·\left\{\sum _{C_i\in C}\left[\sum _{k\in {Sel}_{C_i}}{\Delta }_k^t\left(n_1\right),\right.\right.\sum _{k\in {Sel}_{C_i}}{\Delta }_k^t\left(n_2\right),\dots ,\left.\left.\sum _{k\in {Sel}_{C_i}}{\Delta }_k^t\left(n_q\right)\right]\right\}\hfill \end{array},$$

(15)

where ${\Delta }_k^t\left(m_i\right)$ and ${\Delta }_k^t\left(n_i\right)$ are updates to the location feature vectors, $C=\left\{C_1,C_2,\dots ,C_c\right\}$ is the set with c client clusters, and $\lambda$ denotes the learning rate.

4.4. Two-Stage Perturbation

For federated learning location recommendation, if the model updates received by the server are not properly processed or encrypted, then malicious server administrators or third parties may infer user interaction information from these model updates through reverse engineering techniques. Therefore, we use a two-stage perturbation approach to protect the model updates uploaded from the client to the server to ensure the security and privacy of user data. Two-stage perturbation consists of label perturbation and model update perturbation.

In the client training phase, label perturbation is used to flip some of the basic fact labels by using randomized answer methods. Randomized answer methods can be used to protect input data in sensitive domains. We perform label perturbation by using the following formula:

$$\psi \left(y_i^{*}=1\right)=\left\{\begin{array}{cc}{\phi }_0,\hfill & y_i=0\hfill \\ {\phi }_1,\hfill & y_i=1\hfill \end{array}\right.,$$

(16)

where $y_i$ is the true label, ${\phi }_0$ and ${\phi }_1$ are the perturbation rates of $y_i=0$ and $y_i=1$, ${\phi }_1=1-{\phi }_0$, $y_i^{*}$ is the perturbation labels; and $\psi \left(y_i^{*}=1\right)$ is the probability of $y_i^{*}=1$.

Label perturbation perturbs the client’s raw data, which in turn perturbs the client’s model updates. Despite the above measures, the direct uploading of model updates from the client to the server may still lead to the leakage of user privacy. In order to further improve the level of client privacy protection, we use the model update perturbation technique to perturb the model updates, as shown in the following formula:

$${\overline{\Delta }}_k^t={\Delta }_k^t·Bernoulli\left({\phi }_2\right),$$

(17)

where ${\phi }_2$ is the model update perturbation rate, $Bernoulli(·)$ is the Bernoulli function that generates the Bernoulli matrix with a certain stochastic probability and has the same shape as ${\Delta }_k^t$, and ${\Delta }_k^t$ is the client’s model update.

4.5. Privacy Analysis

We will use differential privacy [41] to provide formal privacy protection for label perturbation and model update perturbation. The definition of local differential privacy is as follows:

Definition 1.

There are two adjacent datasets W and $W^{\prime }$, as well as a mechanism $M^{\prime }$ that outputs certain results. For any output set Y, $(ϵ,\delta )$-differential privacy requires the following inequality to hold:

$$Pr[M^{\prime }\left(W\right)=Y]\le e^{ϵ}Pr[M^{\prime }\left(W^{\prime }\right)=Y]+\delta ,$$

(18)

where $Pr[M^{\prime }\left(W\right)=Y]$ and $Pr[M^{\prime }\left(W^{\prime }\right)=Y]$ denote the probability that mechanism $M^{\prime }$ outputs a certain outcome Y on dataset W and $W^{\prime }$, ϵ is the privacy budget, δ is an additional parameter that controls the probability of allowed privacy leakage.

By controlling the size of $ϵ$, it is possible to adjust the balance between privacy protection and accuracy of data analysis results. A smaller $ϵ$ provides stronger privacy protection but may reduce query accuracy; a larger $ϵ$ provides weaker privacy protection but better preserves the precision of the data. Label perturbation uses instantaneous random responses to perturb the training labels and satisfies differential privacy [42]. The theorem is as follows:

Theorem 1.

The label perturbation method satisfies $({ϵ}^{\prime },0)$-local difference privacy and its privacy budget ${ϵ}^{\prime }$ can be expressed as follows:

$${ϵ}^{\prime }=ln\left({\displaystyle \frac{1-{\phi }_0}{{\phi }_0}}\right),$$

(19)

where ${\phi }_0$ is the perturbation rate, which controls the intensity of the perturbation.

The above formula shows that there is a relationship between privacy budget ${ϵ}^{\prime }$ and perturbation rate ${\phi }_0$. The higher the perturbation rate, the lower the privacy budget. In addition, the model update perturbation also ensures differential privacy [43], and the specific theorem is as follows:

Theorem 2.

For dataset $V=\{v_1,v_2,\dots ,v_n\}$, we define $s\left(j\right)={min}_{k\in \left[n\right]}{\displaystyle \frac{1}{n}}{\sum }_{i=1,i\ne k}^n{v}_i\left(j\right)$ and $\mathsf{\Gamma }={min}_{j\in \left[{\phi }_2\right]}s\left(j\right)$. Then, $({ϵ}_m,{\delta }_m)$-local differential privacy is satisfied on V, and the model update perturbation is conditioned on:

$${\delta }_m={\phi }_2·e^{-\mathsf{\Omega }\left({ϵ}_m^2\mathsf{\Gamma }n\right)},$$

(20)

where ${\phi }_2$ is the model update perturbation rate.

According to the extended optimal combination theorem [44], the combination of label perturbation and model update perturbation still satisfies the differential privacy requirement. The theorem is shown below:

Theorem 3.

Suppose there is a sequence of randomization algorithms $({M_1}^{\prime },{M_2}^{\prime },\dots ,{M_n}^{\prime })$, each of which ${M_j}^{\prime }$ is capable of guaranteeing $({ϵ}_j,{\delta }_j)$-differential privacy. Under these conditions, the entire sequence of algorithms will satisfy $\left({\sum }_{j=1}^n{ϵ}_j,{\delta }_w\right)$-differential privacy, where the total privacy loss ${\delta }_w$ can be calculated by the following formula:

$${\delta }_w=n{e}^{{\sum }_{j=1}^n{ϵ}_j}max{\left\{{\delta }_j\right\}}_{j=1}^n.$$

(21)

We control the privacy intensity by adjusting the label perturbation rate and the model update perturbation rate. In this process, it is crucial to introduce perturbations rationally, both to ensure the effectiveness of the model and to ensure that data privacy is effectively protected.

5. Experiment

5.1. Experimental Settings

5.1.1. Dataset

In this study, the Foursquare dataset is utilized as the foundation for our experiments. This dataset encompasses 2,153,471 users, 1,143,092 locations, 1,021,970 check-ins, 27,098,490 social connections, and 2,809,581 user ratings. We selected the segment of the dataset that pertains to New York, USA, covering user check-ins from 12 April 2012 to 16 February 2013, approximately 10 months. This portion provides detailed records of user check-ins in New York City, including related business information and social activities across various locations such as restaurants, cafes, museums, and more. To ensure the accuracy of our analysis, we excluded users with fewer than five check-ins. After filtering, the dataset contains 1083 users and 38,333 unique locations, totaling 91,024 interactions between users and locations, with a data sparsity of 0.9978.

5.1.2. Evaluation Metrics

In terms of performance evaluation, this study employs two classical evaluation metrics for location recommendation systems: Hit Rate (HR) and Normalized Discounted Cumulative Gain (NDCG). These metrics measure whether the locations of interest to users appear at the top positions of a given recommendation list. NDCG is an evaluation metric used for ranking and recommendation systems, taking into account the position and relevance of the locations. We report the HR and NDCG at $X=10$. For testing, the data from the client’s last interaction is used, along with all previous interaction data for training. Additionally, we randomly select 99 locations from those that have not interacted with the client and add them to the test set for evaluation.

5.1.3. Parameter Settings

In our experiments, we set the number of sampled clients in federated learning K to 100, the local learning rate $\eta$ to 0.01, the global model learning rate $\lambda$ in model aggregation to 0.9, the number of local training iterations E to 5, the number of global training iterations T to 1000, the clustering size c to 4, client selection parameter $f_1$ based on model similarity is set to 50%, client selection parameter $f_2$ based on loss function is set to 50%, label perturbation rate ${\phi }_0$ is set to 0.1, and model update perturbation rate ${\phi }_2$ is set to 0.6. We searched for values of $\tau$ from {0.001, 0.01, 0.1, 0.5} and ultimately determined that the model performs best when $\tau$ is 0.01.

5.1.4. Baseline Schemes

In order to demonstrate the effectiveness of the FedLSM-LPR scheme, the following eight schemes are selected for comparison in this paper:

• MF-ALS [45]: This scheme builds on the traditional matrix factorization algorithm by considering the problem of modeling the user’s implicit feedback and using singular value decomposition inside the implicit feedback dataset.
• NAIS [39]: This scheme introduces an attention mechanism to compute the attention weights between locations, which improves the recommendation performance based on the location similarity model.
• FCF [28]: This scheme integrates CF and federated learning for the first time, and at the same time confirms the applicability of federated learning in the field of personalized recommendation, which lays the foundation for subsequent research.
• FedMF [29]: This scheme is a privacy-preserving recommendation system based on security matrix factorization, which protects the user’s privacy and security by using federated learning and homomorphic encryption.
• FedNCF [30]: This scheme uses neural CF to generate high-quality recommendations and employs SecAvg, a secure aggregation protocol, to protect the security of user privacy.
• FedBPR [46]: This scheme introduces a factorization model based on matrix factorization within the federated learning framework, allowing users to retain control over their data, thereby effectively enhancing data privacy protection.
• FedVAE [47]: This scheme combines a variational auto-encoder(VAE) with federated learning techniques to build a distributed CF recommendation system by learning deep feature representations of users and locations on individual clients.
• FedIS [35]: This scheme proposes a novel federated learning aggregation method, REPAgg, to address the heterogeneity of data characteristics across different clients in federated learning.

5.2. Experimental Results and Comparative Analysis

This article provides a comprehensive comparison of various solutions, with their performance detailed in

Table 2. Performance of different schemes on Foursquare.

Schemes	HR@10	NDCG@10
MF-ALS	0.4294	0.2751
NAIS	0.4303	0.2773
FCF	0.4285	0.2748
FedMF	0.4275	0.2749
FedNCF	0.4109	0.2560
FedBPR	0.4257	0.2754
FedVAE	0.4284	0.2756
FedIS	0.4294	0.2758
FedLSM-LPR	0.4342	0.2776

.

The analysis of the experimental data leads us to the following conclusions:

By comparing two solutions using centralized data storage: MF-ALS and NAIS, the experimental results indicate that the NAIS solution, which employs attention mechanisms and neural networks, outperforms the traditional matrix factorization MF-ALS solution. This result suggests that NAIS, by leveraging neural networks to learn positional similarity, can uncover more complex nonlinear relationships and latent patterns, making it more effective than traditional models when handling complex data. However, it is important to note that both solutions utilize centralized data storage, which may pose a risk to user privacy.

In federated learning schemes, the FedVAE scheme demonstrates superior performance compared to traditional matrix factorization-based recommendation schemes by utilizing VAE. As a powerful generative model, VAE can learn the latent distribution of input data and generate new data instances. This characteristic enables FeVAE to more effectively handle various data types and complex data distributions.

The FedIS scheme was compared with two schemes for centralized storage, MF-ALS and NAIS. The results show that FedIS does not differ much from MF-ALS in two performance metrics, HR@10 and NDCG@10, but FedIS performs significantly worse than NAIS in the comparison with NAIS. This is due to the fact that NAIS employs a centralized data storage, which enables direct access to the complete global data, and utilizes the attention mechanism and neural network to fully explore the user-item complex interactions between users and items, thus obtaining more accurate recommendation results. In contrast, FedIS, as a federated learning scheme, relies on decentralized local data for its training process and cannot directly share the original data, so it has a natural disadvantage in data utilization efficiency. A deeper look reveals that our proposed FedLSM-LPR outperforms the NAIS scheme in two performance metrics, HR@10 and NDCG@10. The main reasons are as follows: (1) Through clustering-based client selection, clients with similar data distributions are grouped together, making the data within each client group in each training round more homogeneous and significantly reducing gradient conflict during aggregation. In contrast, although NAIS can utilize centralized data for global optimization, it cannot adapt to the heterogeneous nature of distributed data that naturally exists in real-world scenarios. (2) By analyzing the training loss and model similarity of clients, it prioritizes clients with consistent and reliable contributions to participate in aggregation, effectively filtering out low-quality or malicious local updates, whereas centralized NAIS lacks this ability to dynamically assess data quality. (3) Introducing a regularization term in the client loss function to force local training to balance personalization and global consistency. This design retains the privacy advantage of federated learning and circumvents the problem of global performance degradation due to local overfitting in traditional federated learning. The centralized training of NAIS is unable to achieve this distributed regularization effect, although it can directly optimize the global objective.

The FedIS scheme demonstrates superior performance compared to other federated learning baseline schemes. This is primarily because, unlike FedIS, the other schemes only use a simple weighted average aggregation method on the server side, failing to fully consider the impact of data heterogeneity on model performance in federated learning for location recommendation tasks. Additionally, the FedIS scheme employs a more advanced NAIS model on the client side, effectively enhancing the model’s recommendation performance.

We compared the scheme proposed in this paper with the FedIS scheme and found that our proposed scheme exhibits significant advantages based on the experimental results. FedIS only adopts the REPAgg aggregation method, which alleviates the impact of data heterogeneity on federated learning location recommendation systems to a certain extent, but its recommendation accuracy may decrease when the data from different clients varies greatly, and it cannot adequately cope with complex real-world data scenarios. Our proposed FedLSM-LPR scheme improves the deficiencies in FedIS by introducing a client regularization method. This regularization technique helps to control the discrepancy between the local model and the global model, especially when facing highly heterogeneous datasets, and can effectively reduce the excessive deviation of the local model from the global model.FedLSM-LPR also further optimizes the client-side clustering and selection strategies. Based on clustering, the scheme selects clients to participate in aggregation by evaluating the loss of clients and the similarity between models, thus ensuring that the data features within each subgroup are relatively consistent. This approach allows models to be aggregated in such a way that updates do not cancel each other out due to excessive data differences, thus improving the efficiency of aggregation. In addition, selecting high-loss clients is equivalent to automatically identifying the “shortcomings” of the current model during the training process and focusing resources on optimizing the poorly performing local models. At the same time, choosing clients with high model similarity ensures the stability of the update and prevents individual abnormal clients from deviating from the global model.

Figure 3 and Figure 4 compare the performance of FedLSM-LPR and FedIS on the evaluation dataset as the number of federated learning epochs increases. The figure shows that as the number of epochs increases, the global model better captures the location features distributed across various edge clients, leading to improved performance. During the initial training phase, both FedLSM-LPR and FedIS exhibit rapid performance improvements. However, FedLSM-LPR converges significantly faster, achieving high performance with fewer epochs. This indicates that FedLSM-LPR can more efficiently learn and integrate local data from different clients.

5.3. Model Efficiency

FedLSM-LPR and FedIS are trained from the same initial model, and both eventually converge. Under identical training settings, as illustrated in Figure 3 and Figure 4, FedLSM-LPR achieves convergence with fewer epochs and outperforms FedIS in terms of recommendation performance. Thanks to the clustering-based client selection method and the L2 norm regularization term, the model achieves stable performance in fewer training epochs.

In addition, we calculated the communication cost of FedLSM-LPR. Compared to FedIS’s 952 KB, our scheme achieves a lower communication cost of 933 KB. This advantage is due to the introduction of a clustering-based client selection mechanism, which selects only representative clients for training in each round, effectively reducing communication burden while ensuring model performance.

5.4. Analysis of Parameters

In this paper, we analyze the impact of the main hyperparameters on the performance of FedLSM-LPR, which include, the number of local training iterations E, the percentage of clients selected based on model similarity $f_1$, the percentage of clients selected based on loss $f_2$, the label perturbation rate ${\phi }_0$, and the model updating perturbation rate ${\phi }_2$. By tuning these hyperparameters, we can investigate their impact on the performance of the scheme.

In FedLSM-LPR, the hyperparameter E is used to control the number of iterations during local training for each client. The client receives the global model from the server in each round of federated learning and then performs E iterations locally to update the local model parameters. After completing E iterations, the client uploads the model update parameters to the server for the next round of federated learning. This hyperparameter can affect how much each client contributes to the model in each round of federated learning, which in turn affects the overall model performance and speed of convergence. A larger value of E results in each client training more times, resulting in a more adequate update of the model in each round of federated learning, which helps to increase the convergence speed of the model. However, a larger E value means that more model parameters need to be transmitted per training round, increasing the communication overhead. In addition, too many iterations per client in local training may lead to overfitting on local training data, reducing the generalization ability of the model. Conversely, a smaller value of E may result in insufficient updates during each training round, delaying the model’s convergence and affecting its performance. In addition, insufficient contribution from each client may lead to underutilization of some client data, affecting the overall model performance improvement. Therefore, in this paper, we find a balance point by adjusting the size of E to fit the FedLSM-LPR scheme. As shown in Figure 5, the FedLSM-LPR scheme obtains the highest performance when E is 5.

In distributed learning systems, the values of hyperparameters $f_1$ and $f_2$ play a key role. $f_1$ denotes the client with high similarity between the local and global models in the pre-selection $f_1$. $f_2$ denotes the client with high local loss in the pre-selection $f_2$. If these parameters are set too small, it may make it difficult for the model to perform well in environments containing heterogeneous data. This is because not enough samples can be captured to reflect the global data characteristics. Conversely, if these parameters are set too large, this will incur more communication costs and potentially increase the proportion of noisy and unreliable data, thus reducing model performance. Therefore, choosing the right $f_1$ and $f_2$ is crucial for obtaining good model performance. In this paper, we keep $f_1$ at 50% to analyze the effect of different $f_2$ on the model performance. In addition, when the parameter $f_1$ is set to 100%, all clients are selected to participate in the global model aggregation. This is a special case, i.e., there is no additional processing for client selection. Figure 6 shows that FedLSM-LPR obtains the highest performance when parameter $f_1$ is set to 50% and $f_2$ is set to 50%.

To more effectively protect user privacy and prevent information leakage, this paper adopts a two-stage perturbation method. Parameter ${\phi }_0$ represents the client label perturbation rate, while parameter ${\phi }_2$ represents the model update perturbation rate. These two parameters respectively control the degree of perturbation applied to client data and model updates. This study analyzes the impact of parameters ${\phi }_0$ and ${\phi }_2$ on the performance of FedLSM-LPR by varying their values. From Figure 7, it can be observed that when the model update perturbation rate remains constant, the performance of FedLSM-LPR significantly decreases as the label perturbation rate increases. This decline occurs because label perturbation alters user information, negatively impacting FedLSM-LPR’s performance. On the other hand, when the label perturbation rate is kept constant, the performance of FedLSM-LPR first decreases and then increases as the model update perturbation rate rises. This is because a higher model update perturbation rate results in more parameters being discarded, which weakens the impact of label perturbation. Excessive perturbation can effectively reduce the risk of user privacy breaches but inevitably harm FedLSM-LPR’s performance. Conversely, if the perturbation rate is set too low, the model’s performance level can be maintained, but user privacy is exposed to higher risks and becomes more vulnerable to malicious attackers. Therefore, balancing privacy protection and model performance is crucial.

6. Conclusions

LBSNs greatly enhance users’ lives. However, due to privacy concerns and stringent legal regulations, location recommendation faces substantial challenges. We propose a Federated Learning-Based Location Similarity Model for Location Privacy Preserving Recommendation (FedLSM-LPR) scheme. Unlike traditional centralized data storage, the FedLSM-LPR scheme utilizes users’ local data for collaborative learning, addressing privacy leakage issues. We employ a location similarity model on the client side and incorporate an L2 norm regularization term in the loss function. To protect client data and model updates, we use a two-stage perturbation method, ensuring user privacy. To mitigate the impact of non-IID data, we propose a clustering-based client selection method that selects representative clients within clusters for global model aggregation. Experimental results show that the FedLSM-LPR scheme outperforms other federated learning-based location recommendation schemes in terms of recommendation performance. Future research will focus on incorporating the temporal features of user-location interactions as these interactions change over time. This approach can enhance the model’s ability to predict user behavior and provide personalized recommendations. In addition, future work will focus on further enhancing privacy protection. We will focus on potentially malicious server attacks, such as those masquerading as a non-existent federation, data poisoning attacks, and member extrapolation, and design appropriate protection mechanisms against these attacks.