FedTULGAC: A Federated Learning Method for Trajectory User Linking Based on Graph Attention and Clustering

Abstract

Trajectory User Linking (TUL) is a pivotal technology for identifying and associating the trajectory information from the same user across various data sources. To address the privacy leakage challenges inherent in traditional TUL methods, this study introduces a novel federated learning-based TUL method: FedTULGAC. This approach utilizes a federated learning framework to aggregate model parameters, thereby avoiding the sharing of local data. Within this framework, a Graph Attention-based Trajectory User Linking and Embedding Regression (GATULER) model and an FL-DBSCAN clustering algorithm are designed and integrated to capture short-term temporal dependencies in user movement trajectories and to handle the non-independent and identically distributed (Non-IID) characteristics of client-side data. Experimental results on the synthesized datasets demonstrate that the proposed method achieves the highest prediction accuracy compared to the baseline models and maintains stable performance with minimal sensitivity to variations in client selection ratios, which reveals its effectiveness in bandwidth-constrained real-world applications.

1. Introduction

With the proliferation of mobile applications and personal intelligent devices, location-based application services have grown rapidly, giving rise to a variety of applications covering location services: Location-Based Social Networks (LBSNs) [1], such as Gowalla and Facebook Places, have accumulated a substantial amount of user geographic check-in data. These data provide a rich source of information for trajectory user linking (TUL). TUL refers to the process of identifying and establishing direct associations between trajectory data and corresponding users [2], which plays a role in the field of social security, such as preventing crime by identifying suspicious behavioral patterns [3,4].

Deep learning-based TUL methods have been widely studied. Q. Gao first introduced TUL via Embedding and RNN (TULER) [5], which applies word embedding and RNNs to achieve semi-supervised spatial learning. Subsequent studies integrated RNN-based models with semi-supervised learning, such as TUL via Variational AutoEncoder (TULVAE) by Zhou et al. [6]; the Semisupervised Trajectory-User Linking model with Interpretable representation and Gaussian mixture prior (STULIG) by Zhou et al. [7]; the Trajectory Generative Adversarial Network (TGAN) by Zhou and Yin et al. [8]; and attention-based models such as DeepTUL by Miao et al. [9] and Trajectory-User Link with Attention Recurrent Networks (TULAR) by Sun et al. [10]. Recent approaches utilize graph neural networks (GNNs) and graph attention networks (GATs) to effectively capture spatio-temporal dependencies. For example, GNNTUL by Zhou and Chen et al. [11] applied GraphSAGE to model trajectory structures; TULAM by Li et al. [12] adopted approximate one-hot encoding and multi-head attention for efficient learning with limited data. Further improvements in spatial reasoning were achieved through hierarchical attention models, such as AttnTUL by Chen et al. [4] and TUL via the Multi-Scale Graph Attention Network (TULMGAT) by Li et al. [13]. These deep learning-based trajectory user linking methods encounter the challenges of data privacy protection, as the methods’ model training requires a large number of centralized datasets. The centralized training strategies cannot strictly ensure the security of this data during transmission and centralized processing, thereby increasing the risk of privacy leakage [14,15]. Meanwhile, growing concerns over privacy protection have prompted numerous departments to issue relevant privacy and security regulations [16], which have further impeded the integration of diverse data sources. Therefore, how to ensure user data privacy to perform TUL tasks has become a key issue that needs to be addressed urgently.

Google’s proposed federated learning framework offers a new approach to address this problem [17]. The framework allows multiple clients to collaboratively train a global model without sharing local data, which preserves data privacy. Specifically, each client trains a model locally using their data and transmits the model’s gradients to a server. The server then aggregates these gradients to achieve a global model, which is then sent back to each client to iterate until convergence [18]. As an emerging distributed machine learning method, federated learning has begun to attract the attention of researchers in the field of trajectory data analysis. Zhang et al. proposed a federated learning and clustering method for trajectory data of intelligent networked vehicles, which uses a differential privacy federated learning framework to construct a sequence autoencoding network [19]. Wang proposed the ATPFL algorithm, which integrates the advantages of automatic machine learning and federated learning to solve the data silo problem [20].

Although the existing methods have achieved advancements, they cannot be tailored to directly address the challenges of trajectory user linking (TUL) due to the following limitations:

• These traditional deep learning-based trajectory user linking methods primarily focus on capturing short-term temporal dependencies in user movement trajectories. This hinders their ability to accurately model the evolution of user behavior over extended periods and to capture complex movement patterns.
• These existing federated learning methods in the trajectory data analysis field cannot effectively handle Non-IID characteristics [21,22] and the spatiotemporal distribution heterogeneity of clients’ trajectory data, which results in a degradation of model accuracy.

Therefore, this paper explores a novel federated learning method for trajectory user linking, which aims to fill the gap in the existing methods. The primary contributions of this paper are as follows:

• We propose a novel federated learning-based TUL method named FedTULGAC to address the challenge of privacy preservation in trajectory user linking. Our method enables distributed data processing by exchanging model parameters instead of sharing raw trajectory data. Under the coordination of a central server, the FedTULGAC framework enables multiple clients to collaboratively optimize a global model.
• We design the GATULER model and the FL-DBSCAN algorithm and integrate them into FedTULGAC. The GATULER model uses the dynamic graph attention mechanism to capture the complex features of trajectory data. The FL-DBSCAN algorithm optimizes the aggregation of model parameters across clients to mitigate the Non-IID characteristics and the spatiotemporal distribution heterogeneity of client-side data.
• We conducted extensive experiments on the synthesized Gowalla and Foursquare datasets. The results indicate that the FedTULGAC method achieves the highest prediction accuracy compared to baseline models while safeguarding user privacy, and it maintains the training model’s stability and robustness.

The rest of this paper is organized as follows: Section 2 defines the preliminary preparation of the proposed method. Section 3 outlines the federated learning framework of the FedTULGAC method and details the GATULER model and the FL-DBSCAN algorithm. Section 4 evaluates the proposed method’s performance with experiments conducted on the synthesized datasets. Finally, Section 5 summarizes the contributions of this study and suggests directions for future research.

2. Preliminary Preparation

In this section, we begin with a formulation of the trajectory user linking problem. Subsequently, we provide a detailed description of the trajectory user linking within the context of federated learning.

2.1. Trajectory User Link Problem

The set of users, locations, and times is represented as $U=\{u_1,u_2,\dots ,u_m\};P=\{p_1,p_2,\dots ,p_g\};$ and $T=\{t_1,t_2,\dots ,t_h\}$. Each user’s trajectory $T_r$ is a sequence composed of a series of check-ins, where each check-in includes the user’s location at a specific time. Therefore, for a user $u_i$, the trajectory $T_r$ can be represented as

$$T_r=\left\{\right(u_{\mathrm{i}} ,p_{i_1} , t_{i_1}), (u_{\mathrm{i}} ,p_{i_2} , t_{i_2}),\dots , (u_{\mathrm{i}} ,p_{i_n} ,t_{i_n}\left)\right\}$$

(1)

where $p_{i_j}=(x_{i_j}, y_{i_j})$ represents the spatial location of user $u_i$ at time $t_{i_j}$, and $(x_{i_j}, y_{i_j})$ specifies the longitude and latitude coordinates of the spatial location $p_{i_j}$.

For the trajectory user linking, we need to match the trajectory sequence $Tr$ with a user in the user set $U$. This matching process needs to consider the overall characteristics of the trajectory sequence. To capture this linking relationship, we define a model $M$. The input of model $M$ includes the trajectory $Tr$ as well as the information of user set $U$. The output of the model $M$ is the user $u$ that best matches the trajectory $Tr$, which is represented as

$$u=M(T_r, U)$$

(2)

2.2. Federated Learning of Trajectory User Linking

The objective of a trajectory user linking problem in federated learning mode is to associate the trajectory $Tr$ with the user set $U=\{u_1,u_2,\dots ,u_m\}$ across $K$ clients. Each client possesses a user dataset and a trajectory dataset, and locally enables the training of the trajectory user linking model. To optimize the local model, the model parameter $w$ of $M$ is adjusted by minimizing the loss function $l\left(w\right)$ with the mean squared error loss function. The loss function $l\left(w\right)$ is defined as follows:

$$\begin{array}{c}l(w)={\displaystyle \frac{1}{m-1}}{\displaystyle \sum _{i=1}^{m-1}}{\left(u_i-f\left(T_r; w\right)\right)}^2\end{array}$$

(3)

where $w$ represents the model parameter, $T_r$ represents the trajectory sequence, and $u_i$ represents the user associated with the trajectory sequence $T_r$. The function $f\left(T_r; w\right)$ is the specific implementation of the model $M$, which takes the trajectory sequence $T_r$ and model parameters $w$ as inputs.

Each client $\mathrm{K}$ performs a local model update using Stochastic Gradient Descent (SGD) on its parameters ${\omega }_t^{\left(k\right)}$, as follows:

$$\begin{array}{c}{\omega }_t^{\left(k\right)}={\omega }_{t-1}^{\left(k\right)}-\eta {\nabla }_{\omega }l({\omega }_{t-1}^{\left(k\right)})\end{array}$$

(4)

where ${\omega }_t^{\left(k\right)}$ represents the model parameters of the $k$-th client during the $t$-th round of training, $\eta$ represents the learning rate and ${\nabla }_{\omega }$ represents the gradient of the loss function $l\left(w\right)$ with respect to the model parameters $\omega$. After $E$ rounds of SGD iterations, the server performs model aggregation to achieve the global parameters from all clients $K$, as follows:

$$\begin{array}{c}{\omega }_{mE}^{\left(f\right)}={\displaystyle \sum _{k=1}^K}{p}_k{\omega }_{mE}^{\left(k\right)}\end{array}$$

(5)

where $p_k={\displaystyle \frac{n_k}{\sum _{i=1}^k{n}_i}}$ represents the proportion of the trajectory data size of client $K$ relative to the total trajectory data volume, serving as the weight for model aggregation; ${\omega }_{mE}^{\left(k\right)}$ represents the local model parameters of client $\mathrm{K}$ after $mE$ local training iterations. Once the model aggregation is completed, the server distributes the updated global model parameters ${\omega }_{mE}^{\left(f\right)}$ to all clients for the subsequent training round.

3. Methods

In this study, we propose an innovative federated learning-based solution for trajectory user linking. As illustrated in Figure 1, the proposed framework comprises three key components: a central server, terminal databases, and terminal clients. The central server is responsible for model distribution, aggregation, communication coordination, and system monitoring. Each terminal client hosts a local database, which manages data storage, access, and protection. The clients collect user and trajectory datasets, perform local model training, and transmit the updated model parameters to the central server.

3.1. Model: GATULER

To improve the accuracy of trajectory user linking, we present a Graph Attention-based Trajectory User Linking and Embedding Regression (GATULER) model. Each terminal client collects user and trajectory datasets and trains a local GATULER model. The central server aggregates the model parameters transmitted by the clients to obtain a global GATULER model. By employing a dynamic graph attention mechanism, GATULER captures complex interactions among users. The architecture of the model is illustrated in Figure 2. The implementation of this model consists of four phases:

• Trajectory Graph Construction: Two types of trajectory graphs are constructed: the undirected graph $G_c$ and the directed graph $G_t$. $G_c$ is used to represent interactions or movement relationships between users, while $G_t$ further captures the directionality of user interactions or movement. Finally, these two graphs are fused to obtain the final trajectory graph $\theta$, which incorporates both geographical proximity and temporal movement order. The fusion is defined by the following equation:

$$\begin{array}{c}\theta =⟨G_c,G_t⟩=G_c\cup G_t\end{array}$$

(6)

• Node Graph Embedding and Graph Attention Computation: The trajectory graph is used to construct initial embeddings for user and location through their respective embedding layers. This process generates embeddings for users and locations, denoted as ${\mathrm{e}}^{\mathrm{u}}\left(\mathrm{u}\right)\in {\mathbb{R}}^{{\mathrm{d}}_{\mathrm{u}}}$ and ${\mathrm{e}}^{\mathrm{p}}\left(\mathrm{p}\right)\in {\mathbb{R}}^{{\mathrm{d}}_{\mathrm{p}}}$, respectively. These embeddings are subsequently transformed into one-dimensional vectors using the “Flatten” operation, as follows:

$$\begin{array}{c}\begin{array}{ll}{e}^u\left(u\right)=Flatten\left(E_U\left(u\right)\right), \forall u\in U& \\ e^p\left(p\right)=Flatten\left(E_P\left(p\right)\right), \forall p\in P& \end{array}\end{array}$$

(7)

where ${\mathrm{E}}_{\mathrm{U}}$ and ${\mathrm{E}}_{\mathrm{P}}$ denote the embedding layers that map user and location IDs to low-dimensional embedding spaces.

Next, this process computes the graph attention weights between nodes utilizing a softmax function and the LeakyReLU activation function. The attention weight is formally defined as follows:

$$\begin{array}{c}{\alpha }_{ij}={\displaystyle \frac{exp\left(LeakyReLU\right(a^T[W\cdot h_i\Vert W\cdot h_j]\left)\right)}{\sum _{k\in N\left(i\right)}exp\left(LeakyReLU\right(a^T[W\cdot h_i\Vert W\cdot h_k]\left)\right)}}\end{array}$$

(8)

where ${\alpha }_{ij}$ denotes the graph attention weight of node $i$ to node $j$, $a$ represents a learnable attention mechanism parameter, $W$ represents the feature transformation matrix, $h_i$ represents the feature vector of node $i$, and $N\left(i\right)$ represents the set of neighboring nodes of node $i$.

Finally, using the computed attention weight ${\alpha }_{ij}$, the updated embedding representation $H\left(i\right)$ of node $p_i$ is obtained by aggregating the embeddings of its neighbors $e_{p_j}$:

$$\begin{array}{c}H\left(i\right)={\displaystyle \sum _{j\in N\left(i\right)}}{\alpha }_{ij}{e}_{p_j} \end{array}$$

(9)

• Trajectory Vector Representation, for a given user trajectory $Tr$, this phase first retrieves $e^u\left(u\right)$, $H\left(p_i\right)$, an $e^t\left(t_i\right)$ corresponding to each check-in point $r_i$ in $Tr$, and concatenates them to form $V_{con}^{\left(i\right)}$. The computation for the $i$-th node in the trajectory is as follows:

$$\begin{array}{c}{V}_{con}^{\left(i\right)}=Concatenate\left(e^u\left(u\right),H\left(p_i\right),e^t\left(t_i\right)\right)\end{array}$$

(10)

where $e^t\left(t_i\right)$ represents the temporal feature for the $t_i$ check-in point.

Next, to capture the temporal and user behavioral patterns within the trajectory sequence, a sequence of concatenated vectors for all nodes in the trajectory, $\{V_{con}^{\left(1\right)}, V_{con}^{\left(2\right)}, \dots , V_{con}^{\left(n\right)}\}$, is fed into the Recurrent Neural Networks (RNNs). This network processes each concatenated vector sequentially, maintaining a hidden state $h_i$ that encodes the trajectory information up to the current time step.

$$\begin{array}{c}{h}_i=RNN(v_{con}^{\left(i\right)},h_{i-1}) \end{array}$$

(11)

where $h_i$ denotes the hidden state of the RNN after processing the $i$-th node in the trajectory, and $h_0$ is initialized as a zero vector.

Once the RNN processes the entire trajectory sequence, the final trajectory graph embedding vector $V_{tra}$ is obtained by averaging the hidden states across all time steps. The computation is as follows:

$$\begin{array}{c}{V}_{tra}={\displaystyle \frac{1}{n}}{\displaystyle \sum _{i=1}^n}{h}_i\end{array}$$

(12)

where $n$ is the number of check-ins in the trajectory $Tr$.

• Trajectory-User Linking: The model leverages the features extracted and integrated from preceding stages to predict the association probability between each user and a given trajectory. The computation is as follows:

$$\begin{array}{c}P(u_j^{\prime }|T_r)=softmax(ReLU\left(W[V_{tra},e^u(u),{\displaystyle \frac{1}{n}}{\displaystyle \sum _{i=1}^n}{H}_{(p_i)}]+b\right))\end{array}$$

(13)

where $P(u_j^{\prime }|T_r)$ indicates the probability that the trajectory $Tr$ belongs to the $j$-th user $u_j^{\prime },W$ and $b$ denote the weights and biases of the fully connected layer, respectively, ${\displaystyle \frac{1}{n}}\sum _{i=1}^n{H}_{\left(p_i\right)}$ reflects the user’s overall preference for visited locations.

3.2. FL-DBSCAN

3.2.1. Design of Implementation Algorithm

Within the federated learning framework, each terminal client functions as an independent node with its own distinct datasets. These datasets typically exhibit Non-IID characteristics and spatiotemporal heterogeneity. To effectively handle these characteristics and mitigate the accuracy deterioration of the FedTULGAC method, we developed an innovative model aggregation strategy, namely the Algorithm 1 FL-DBSCAN algorithm. Specifically, the terminal clients calculated the local density of their respective datasets, while the central server adjusted the global density threshold based on the local density information provided by each client. This process ensured that the global model effectively reflects the data characteristics of all clients.

Algorithm 1: FL-DBSCAN Input: Total number of clients $K$, Client selection ratio $q$, Number of communication rounds $T$, Number of local epochs $E$, Batch size $B$ Output: $W_g^T$

$W_g^0\leftarrow \mathrm{I}\mathrm{n}\mathrm{i}\mathrm{t}\mathrm{i}\mathrm{a}\mathrm{l}\mathrm{i}\mathrm{z}\mathrm{e}()$ $\mathit{f}\mathit{o}\mathit{r} t=0 to T-1 \mathit{d}\mathit{o}$          $s\leftarrow \max (q\times K, 1)$          $S_t\leftarrow \mathrm{R}\mathrm{a}\mathrm{n}\mathrm{d}\mathrm{o}\mathrm{m}\mathrm{S}\mathrm{e}\mathrm{l}\mathrm{e}\mathrm{c}\mathrm{t}(s, K)$          $\mathit{f}\mathit{o}\mathit{r} each client i\in S_t \mathit{d}\mathit{o}$          $W_{p_i}\leftarrow W_g^t$          $W_i^t\leftarrow \mathrm{L}\mathrm{o}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{T}\mathrm{r}\mathrm{a}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{n}\mathrm{g}(D_i, W_{p_i}, \eta , E, B)$          $Y_i\leftarrow \mathrm{T}\mathrm{e}\mathrm{s}\mathrm{t}\mathrm{A}\mathrm{c}\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{y}(W_i^t, T_i)$          $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$          $D^t\leftarrow \mathrm{C}\mathrm{a}\mathrm{l}\mathrm{c}\mathrm{u}\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{D}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e}\mathrm{M}\mathrm{a}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{x}\left(S_t\right)$          $\mathrm{G}\mathrm{r}\mathrm{o}\mathrm{u}\mathrm{p}\mathrm{L}\mathrm{i}\mathrm{s}\mathrm{t}\leftarrow \mathrm{D}\mathrm{B}\mathrm{S}\mathrm{C}\mathrm{A}\mathrm{N}\mathrm{C}\mathrm{l}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{n}\mathrm{g}(D^t, ϵ, c)$          $W_{c_i}\leftarrow \mathrm{U}\mathrm{p}\mathrm{d}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{C}\mathrm{l}\mathrm{i}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{M}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{s}(W_i^t, \mathrm{G}\mathrm{r}\mathrm{o}\mathrm{u}\mathrm{p}\mathrm{L}\mathrm{i}\mathrm{s}\mathrm{t}, D^t, Y_i)$          $\mathit{f}\mathit{o}\mathit{r} each client i\in S_t \mathit{d}\mathit{o}$          $W_g^{t+1}\leftarrow \mathrm{A}\mathrm{d}\mathrm{j}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{G}\mathrm{l}\mathrm{o}\mathrm{b}\mathrm{a}\mathrm{l}\mathrm{M}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{W}\mathrm{e}\mathrm{i}\mathrm{g}\mathrm{h}\mathrm{t}\mathrm{s}(W_{c_i}, D_i)$          $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$ $\mathit{e}\mathit{n}\mathit{d} \mathit{f}\mathit{o}\mathit{r}$ $\mathit{r}\mathit{e}\mathit{t}\mathit{u}\mathit{r}\mathit{n} W_g^T$

This algorithm begins by initializing the global model weights $W_g^0$. It then proceeds iteratively for a total of $T$ communication rounds. In each round $t$, the algorithm determines the number of clients $s$ to be randomly selected, where $s$ satisfies $1\le s\le q\times K$. Subsequently, through the $\mathrm{R}\mathrm{a}\mathrm{n}\mathrm{d}\mathrm{o}\mathrm{m}\mathrm{S}\mathrm{e}\mathrm{l}\mathrm{e}\mathrm{c}\mathrm{t}$ subroutine, the algorithm randomly selects $s$ clients from all $K$ clients to get the set $S_t$.

For each client $i$ in $S_t$, the algorithm transmits the global model weights $W_g^t$ to the client. The $\mathrm{L}\mathrm{o}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{T}\mathrm{r}\mathrm{a}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{n}\mathrm{g}$ subroutine is then invoked, wherein each client performs $E$ local iterations using a learning rate $\eta$ and a batch size $B$ to get the model weights $W_i^t$. Following local training, the $\mathrm{T}\mathrm{e}\mathrm{s}\mathrm{t}\mathrm{A}\mathrm{c}\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{y}$ subroutine evaluates $W_i^t$ on client $i$ local test dataset $T_i$ to get the accuracy metric $Y_i$. After all, $K$ clients have completed their local training, the server computes a distance matrix $D^t$ among the models of the selected clients using the Algorithm 2 $\mathrm{C}\mathrm{a}\mathrm{l}\mathrm{c}\mathrm{u}\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{D}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e}\mathrm{M}\mathrm{a}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{x}$ subroutine.

Algorithm 2: Subroutine: CalculateDistanceMatrix

Input: Set of selected clients $S_t$ Output: $D^t$     $D^t\leftarrow CreateMatrix\left(\right|S_t|, |S_t|, 0)$     $\mathit{f}\mathit{o}\mathit{r} i\leftarrow 0 to \left|S_t\right|-1 do$               $\mathit{f}\mathit{o}\mathit{r} j\leftarrow i+1 to \left|S_t\right|-1 do$               $W_i, W_j\leftarrow RetrieveModelWeights(S_t[i], S_t[j])$                                       $distance=1-\Sigma \mathrm{ₖ}\left(W\mathrm{ᵢ}\right[k]·W\mathrm{ⱼ}[k\left]\right)/(\Vert W\mathrm{ᵢ}\Vert ·\Vert W\mathrm{ⱼ}\Vert )$               $D^t[i][j]\leftarrow distance$               $D^t[j][i]\leftarrow distance$               $\mathit{e}\mathit{n}\mathit{d}\mathit{f}\mathit{o}\mathit{r}$     $\mathit{e}\mathit{n}\mathit{d}\mathit{f}\mathit{o}\mathit{r}$     $\mathit{r}\mathit{e}\mathit{t}\mathit{u}\mathit{r}\mathit{n}{ D}^t$

This subroutine takes as input a set of clients $S_t$ and outputs a distance matrix $D^t$. The subroutine initiates by constructing a zero matrix $D^t$ of size $\left|S_t\right| \times \left|S_t\right|$, where $\left|S_t\right|$ denotes the cardinality of clients in set $S_t$.

The $\mathrm{D}\mathrm{B}\mathrm{S}\mathrm{C}\mathrm{A}\mathrm{N}\mathrm{C}\mathrm{l}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{n}\mathrm{g}$ subroutine focuses on the consistency of the “direction” of client model updates, rather than the magnitude of the “step size”. Consistent update directions indicate that the clients are learning similar patterns. In this paper, the cosine distance is employed to quantify the angular difference between update vectors. The formula for computing the distance is given by:

$$\begin{array}{c}distance=1-\Sigma ₖ\left(Wᵢ\right[k]·Wⱼ[k\left]\right)/(\Vert Wᵢ\Vert ·\Vert Wⱼ\Vert )\end{array}$$

(14)

Then, the $\mathrm{C}\mathrm{a}\mathrm{l}\mathrm{c}\mathrm{u}\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{D}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e}\mathrm{M}\mathrm{a}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{x}$ subroutine iterates over each unique pair of clients $i$ and $j$ within the set $S_t$ by calculating the cosine distance between their model weights and populating the corresponding entries in the distance matrix $D^t$. Due to the symmetry of the distance matrix, the subroutine only computes the upper triangular portion and mirrors the values to the lower triangular portion. Ultimately, the subroutine returns the complete distance matrix $D^t$, which provides distance information for subsequent clustering and global model aggregation steps.

Next, the Algorithm 3 executes the $\mathrm{D}\mathrm{B}\mathrm{S}\mathrm{C}\mathrm{A}\mathrm{N}\mathrm{C}\mathrm{l}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{n}\mathrm{g}$ subroutine to cluster the clients and get a cluster list $\mathrm{G}\mathrm{r}\mathrm{o}\mathrm{u}\mathrm{p}\mathrm{L}\mathrm{i}\mathrm{s}\mathrm{t}$.

Algorithm 3: Subroutine: DBSCANClustering

Input: Distance matrix $D^t$, Neighborhood radius $ϵ$, Minimum number of points $c$ Output: GroupList     visited ← InitializeVisitedSet()     for each client $i$ do         if client $i$ is not visited then Mark $i$ as visited             Ni ← FindNeighbors($i, {D^t}^{\mathrm{t}}$, $ϵ$)             if $\left|N_i\right| \ge$ $ϵ$ then                 Form and expand cluster             else                  Mark $i$ as noise             end if         end if     end for     return GroupList

This subroutine accepts three input parameters: the dataset $D^t$, neighborhood radius $ϵ$, and the minimum number of points $c$ and outputs a list of cluster assignments: GroupList. The subroutine initializes a visited set to keep track of visited clients. It then iterates through each client in the selected client set. For each unvisited client $i$, the subroutine finds its neighbors $N_i$ within the $ϵ$ range. If the number of points in $N_i$ reaches or exceeds $c$, a cluster is formed and expanded. Finally, the subroutine returns the GroupList containing the cluster identifier for each client.

Subsequently, the algorithm updates the client model weights $W_{c_i}$ through the Algorithm 4 $\mathrm{U}\mathrm{p}\mathrm{d}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{C}\mathrm{l}\mathrm{i}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{M}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{s}$ subroutine. This subroutine accepts the following inputs: the model parameters ${\mathbf{W}}_i^t$ of each client at time step $t$, the client grouping list GroupList, the global dataset $D^t$, and the performance metrics $Yi$ of each client. It outputs the updated client model parameters ${\mathbf{W}}_{c_i}$. The core process of the subroutine involves iterating over each cluster $k$ in GroupList. The cluster center ${\mathbf{W}}_{\mathrm{c}\mathrm{c},k}$ is first calculated using the CalculateClusterCenter function according to the following formula:

$$\begin{array}{c}{\mathbf{W}}_{\mathrm{c}\mathrm{c},k}={\displaystyle \frac{1}{\left|k\right|}}{\displaystyle \sum _{i\in k}}{\mathbf{W}}_i^t\end{array}$$

(15)

where $\left|k\right|$ is the number of clients in cluster $k$.

For each client $i$ within the cluster, this subroutine invokes the CalculateDistance function to determine the distance $d_i$ between its model parameters and the cluster center as per the following formula:

$$\begin{array}{c}{d}_i=1-\Sigma ₖ({\mathbf{W}}_i^t\cdot {\mathbf{W}}_{cc,k})/(\Vert {\mathbf{W}}_i^t\Vert ·\Vert {\mathbf{W}}_{cc,k}\Vert )\end{array}$$

(16)

The performance metric $Y_i$ of each client and $d_i$ are combined to achieve the weight ${\alpha }_i$ as per the following formula:

$$\begin{array}{c}{\alpha }_i={\displaystyle \frac{Y_i}{\max (Y)}}\cdot {\displaystyle \frac{1}{1+d_i}}\end{array}$$

(17)

where $\max (Y)$ is the maximum performance metric among all clients.

The client model parameters ${\mathbf{W}}_{c_i}$ are updated through a weighted average by combining the current model parameters ${\mathbf{W}}_i^t$, the cluster center parameters ${\mathbf{W}}_{\mathrm{c}\mathrm{c},k}$ and the weight ${\alpha }_i$ as per the following formula:

$$\begin{array}{c}{\mathrm{W}}_{c_i}\leftarrow {\alpha }_i{\mathrm{W}}_i^t+(1-{\alpha }_i){\mathrm{W}}_{\mathrm{c}\mathrm{c},k}\end{array}$$

(18)

Algorithm 4: Subroutine: UpdateClientModels

Input: Current global model weights at time step ${\mathit{W}}^t$, List of clusters GroupList, Distance matrix $D^t$, Performance metrics $Y_i$ Output: ${\mathbf{W}}_{c_i}$ for each client $i \in$ all clients do         for each cluster $k \in$ GroupList do             if cluster $k$ is not noise then                   ${\mathbf{W}}_{\mathrm{c}\mathrm{c},k}\leftarrow \mathrm{C}\mathrm{a}\mathrm{l}\mathrm{c}\mathrm{u}\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{C}\mathrm{l}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{C}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{e}\mathrm{r}({\mathbf{W}}^t,k)$                   $d_i\leftarrow \mathrm{C}\mathrm{a}\mathrm{l}\mathrm{c}\mathrm{u}\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{D}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e}({\mathbf{W}}_i^t, {\mathbf{W}}_{\mathrm{c}\mathrm{c},k})$                   $Y_i\leftarrow \mathrm{T}\mathrm{e}\mathrm{s}\mathrm{t}\mathrm{A}\mathrm{c}\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{y}({\mathbf{W}}_i^t, T_i)$                   ${\beta }_i\leftarrow {\displaystyle \frac{Y_i}{\max (Y)}}$                   ${\alpha }_i\leftarrow {\displaystyle \frac{1}{1+d_i}}\cdot {\beta }_i$                   ${\mathbf{W}}_{c_i}\leftarrow {\alpha }_i{\mathbf{W}}_i^t+(1-{\alpha }_i){\mathbf{W}}_{\mathrm{c}\mathrm{c},k}$             end if         end for end for

Finally, for each client $i$ in $S_t$, the algorithm adjusts the global model weights using the $\mathrm{A}\mathrm{d}\mathrm{j}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{G}\mathrm{l}\mathrm{o}\mathrm{b}\mathrm{a}\mathrm{l}\mathrm{M}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{W}\mathrm{e}\mathrm{i}\mathrm{g}\mathrm{h}\mathrm{t}\mathrm{s}$ subroutine to achieve the new global model weights $W_g^{t+1}$. After $T$ rounds of iteration, the algorithm returns the final global model weights $W_g^T$. The detailed descriptions of subroutines $\mathrm{R}\mathrm{a}\mathrm{n}\mathrm{d}\mathrm{o}\mathrm{m}\mathrm{S}\mathrm{e}\mathrm{l}\mathrm{e}\mathrm{c}\mathrm{t}$, $\mathrm{L}\mathrm{o}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{T}\mathrm{r}\mathrm{a}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{n}\mathrm{g}$, and $\mathrm{T}\mathrm{e}\mathrm{s}\mathrm{t}\mathrm{A}\mathrm{c}\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{a}\mathrm{c}\mathrm{y}$ are in Appendix A.

3.2.2. Computational Complexity Analysis

The server-side clustering process in the FL-DBSCAN algorithm contains three key subroutines: $\mathrm{C}\mathrm{a}\mathrm{l}\mathrm{c}\mathrm{u}\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{D}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e}\mathrm{M}\mathrm{a}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{x}$, $\mathrm{D}\mathrm{B}\mathrm{S}\mathrm{C}\mathrm{A}\mathrm{N}\mathrm{C}\mathrm{l}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{n}\mathrm{g}$ and $\mathrm{U}\mathrm{p}\mathrm{d}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{C}\mathrm{l}\mathrm{i}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{M}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{s}$. The computational complexity analysis of these subroutines is a critical factor for assessing the FedTULGAC method’s training time performance. Let $s=\left|S_t\right|$ denote the number of clients selected in the communication round $t$, let $d$ represent the dimensionality of the model parameter vector $W_i$ and let $k$ be the number of clusters found by DBSCAN.

• The $\mathrm{C}\mathrm{a}\mathrm{l}\mathrm{c}\mathrm{u}\mathrm{l}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{D}\mathrm{i}\mathrm{s}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{c}\mathrm{e}\mathrm{M}\mathrm{a}\mathrm{t}\mathrm{r}\mathrm{i}\mathrm{x}$ subroutine is responsible for computing the pairwise cosine distance matrix $D^t$, which serves as the foundation for the FL-DBSCAN algorithm. This subroutine initializes an $s\times s$ matrix and employs a nested loop structure. The outer loop iterates $s$ times, while the inner loop iterates over $s^2$ clients, resulting in $O\left(s^2\right)$ unique client pairs $(i, j)$. For each pair, it retrieves two model vectors of size $d$ and computes the cosine distance between them. The cosine distance calculation, given by $1-\Sigma \mathrm{ₖ}\left(W\mathrm{ᵢ}\right[k]·W\mathrm{ⱼ}[k\left]\right)/(\Vert W\mathrm{ᵢ}\Vert ·\Vert W\mathrm{ⱼ}\Vert$, involves a dot product and norm calculations, each of which is an $O\left(d\right)$ operation. Therefore, the time complexity of this subroutine is $O(s^2\cdot d)$, which indicates its complexity is quadratic in the number of clients $s$ and linear in the model dimensionality $d$.
• The $\mathrm{D}\mathrm{B}\mathrm{S}\mathrm{C}\mathrm{A}\mathrm{N}\mathrm{C}\mathrm{l}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{e}\mathrm{r}\mathrm{i}\mathrm{n}\mathrm{g}$ subroutine performs density-based clustering on the clients using the precomputed distance matrix $D^t$. This subroutine iterates through each of the $s$ clients. For each unvisited client, it performs a query to find all neighbors within a radius $ϵ$. Each query requires scanning a row of the matrix to find entries where $D^t\left[i\right]\left[j\right]\le ϵ$, which is an $O\left(s\right)$ operation. In the worst case, every client is a core point, and its neighborhood must be expanded, which potentially requires a query for all $s$ clients. Then, the worst-case time complexity of this subroutine is $O\left(s^2\right)$, which indicates this subroutine’s complexity is independent of the model dimensionality $d$.
• The $\mathrm{U}\mathrm{p}\mathrm{d}\mathrm{a}\mathrm{t}\mathrm{e}\mathrm{C}\mathrm{l}\mathrm{i}\mathrm{e}\mathrm{n}\mathrm{t}\mathrm{M}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{s}$ subroutine contains a nested loop structure. The outer loop iterates over all $s$ clients. For each client, the inner loop iterates over the $k$ clusters in the GroupList to identify the client’s assignment. Once the correct cluster $k$ is found, the subroutine calculates the cluster centroid, computes the distance $d_i$ from the client’s model to the centroid and performs a weighted average of the client’s model and the cluster centroid. Then, this subroutine’s time complexity is $O(s\cdot k\cdot d)$. In the worst case, where each client forms its own cluster ($k=s$), the complexity becomes $O(s^2\cdot d)$. However, in practice, $k$ is expected to be much smaller than $s$.

Finally, the total computational cost for the server-side clustering process in one communication round is the sum of the complexities of the three subroutines: $O(s^2\cdot d)+O\left(s^2\right)+O(s\cdot k\cdot d)$. For the trajectory user linking federated learning setting, as the proposed GATULER model ($d$) is large, the overall complexity of the server-side clustering process can be approximated as quadratic in the number of selected clients $s$ and linear in the model dimensionality $d$.

4. Results and Discussion

4.1. Experimental Environment Settings

4.1.1. Experimental Environment

The proposed FedTULGAC method is implemented using the Keras deep learning framework.

Table 1. Experimental Software Environment Configurations.

Name	Version	Description
Ubuntu	18.04.4 LTS	Operating System
Python	3.11	Programming Environment
TensorFlow	2.4.1	Deep Learning Framework
NumPy	1.26.2	Matrix Operations
Pandas	2.1.3	Data Preprocessing

lists the version of the selected operating system, programming environment, and data processing library.

Table 2. Experimental Hardware Environment Configurations.

Device	Configuration	Description
CPU	Model	12th Gen Intel(R) Core(TM) i5-12450H
	Cores/Number	8
	Threads/Number	12
GPU	Model	NVIDIA GeForce RTX 3060 Laptop GPU
	Memory/GB	6
	Quantity/Number	1

details the configuration of the hardware environment, including the CPU model, the number of cores and threads, as well as the GPU model, the memory size, and the quantity.

4.1.2. Experimental Dataset

Our experiments used two representative real-world datasets of check-in data from location-based social applications: Gowalla and Foursquare, which are publicly available resources for geographic location data mining and social network research. The two datasets include user IDs, location IDs, and check-in timestamps, which provide a rich source of user movement data. To evaluate the robustness of the proposed model against Non-IID data characteristics and spatiotemporal heterogeneity, we synthesized an experimental dataset by randomly selecting 250 users with their initial 40 trajectories from Gowalla and 300 users with their 20 trajectories from Foursquare.

Furthermore, we used regional coverage, location overlap, KL divergence, and Top-5 location overlap to measure the heterogeneity of the geographical distribution of experimental data. Detailed information on the metrics is shown in

Table 3. Heterogeneity Index of Geographic Spatial Distribution of Experimental Data.

Evaluation Metric	Mean Value		Measurement Method
	Gowalla	Foursquare
Client-side Area Coverage Rate	82.3%	78.6%	Kernel Density Estimation
Client-side Location Overlap Rate	21.4%	18.7%	Jaccard Index
Client-side KL Divergence	0.89	0.92	Relative Entropy Calculation
Top-5 Location Coincidence Rate	2.3	1.8	Set Intersection

.

Then, the two synthesized datasets were randomly mixed and partitioned among 10 terminal clients. The user counts of the mixed datasets on 10 clients follow a Zipf distribution with parameter $\alpha =1.8$, as shown in

Table 4. User Counts for Mixed Datasets Across 10 Clients.

Clients No	Mixed Dataset (Total Users: 750)
	User Count	Percent (%)
1	103	13.73
2	74	9.87
3	55	7.33
4	44	5.87
5	37	4.93
6	32	4.27
7	28	3.73
8	25	3.33
9	23	3.07
10	75	10.00

, which indicates a significant variation among clients’ datasets. Therefore, the experimental data further simulated the Non-IID characteristics and spatiotemporal heterogeneity of the client datasets in a federated learning environment.

In terms of experimental setup, the common hyperparameters for the proposed method and baseline methods were initialized as follows:

• The local learning rate $\eta$ was set to 0.01, a standard value for SGD-based optimizers when training deep learning models on relatively homogeneous data subsets. Coupled with a batch size $B=32$, this configuration ensures stable local updates without excessive noise. The number of local epochs $E=10$ allows for local progress on each client’s dataset.
• The global training epochs $T=\{100, 200\}$ allowed the following experiments: Comparison of Model Performance and Variation with sampling rates, respectively, which provides insight into the proposed method’s stability and efficiency in the training process.

4.2. Experimental Results and Discussion

4.2.1. GATULER Model Performance

• Comparison between GATULER and Traditional TUL Models

The GATULER model and the FL-DBSCAN algorithm are two innovations of the FedTULGAC method. We first conducted experiments in a centralized training mode to compare the performance of the GATULER model against traditional deep-learning-based TUL models. To benchmark GATULER’s performance, we compared it with several TUL approaches with the temporal and semantic modeling of individual trajectories: TULER, TULVAE and STULIG, and several TUL approaches with graph-based spatial relationships or advanced attention mechanisms: GTUL, TULMGAT and TULAM.

Following the standard evaluation criteria, this study used Accuracy ($\mathrm{A}\mathrm{c}\mathrm{c}$), Precision ($\mathrm{P}\mathrm{r}\mathrm{e}\mathrm{c}$), Recall ($\mathrm{R}\mathrm{e}\mathrm{c}$), and $\mathrm{F}1$ score to evaluate the performance of the TUL task. To validate statistical significance, we performed independent t-tests ($p<0.05$) comparing GATULER against all baseline models. All performance metrics were reported as the mean $\pm$ standard deviation over five independent runs.

Table 5. Accuracy Comparison of GATULER and Traditional TUL Models.

Model	Gowalla					Foursquare
	Acc (%)	±Std	Prec (%)	Rec (%)	F1 (%)	Acc (%)	±Std	Prec (%)	Rec (%)	F1 (%)
TULER	40.22	0.58	31.70	28.45	29.99	50.42	0.62	48.15	44.49	47.51
TULVAE	43.40	0.51	33.43	34.31	33.91	53.78	0.57	49.27	43.87	48.33
STULIG	44.84	0.49	34.13	35.25	34.68	56.12	0.53	53.36	46.82	50.21
GTUL	46.01	0.46	36.86	36.17	36.51	58.23	0.48	54.76	52.47	52.12
TULMGAT	50.09	0.42	42.95	42.65	40.25	60.22	0.43	56.47	56.57	54.01
TULAM	49.85	0.44	43.15	38.55	39.85	59.22	0.45	57.27	54.73	56.11
GATULER	50.56	0.38	44.22	41.96	39.58	60.21	0.36	58.29	55.18	55.33

presents a detailed comparison of the model accuracy of GATULER with other models on the two synthesized datasets.

From the experimental results, we can observe the following two points:

• GATULER achieved significant improvements with the highest accuracy (50.56%) and the lowest standard deviation (0.38) on the Gowalla dataset. Although GATULER’s accuracy (60.21%) on the Foursquare dataset is nearly on par with TULMGAT’s highest accuracy (60.22%), it achieved significant improvement with a lower standard deviation (0 vs. 0.43). This improvement underscores the efficacy of GATULER’s graph attention mechanism in capturing key information in user trajectory data. Both GATULER and TULMGAT design graph-based embedding and attention mechanisms to achieve high prediction accuracy, but GATULER adopts a dynamic attention mechanism that does not rely on random walks or sampling to calculate attention values.
• Compared with all baseline models, GATULER achieved top performance on both the synthesized datasets with the highest Prec of 44.22% and 58.29%, respectively. However, GATULER’s Recall and F1-score are lower than TULMGAT and TULAM. These experimental results demonstrate a trade-off between accuracy and recall in GATULER. In fact, GATULER uses an attention mechanism and embedded history to achieve high confidence prediction, but it will also miss some samples.

• Ablation Analysis

We conducted ablation studies by designing the following variants of the model: M-GCN, which replaced the graph attention mechanism with a traditional GNN; M-GC, which used only the spatial graph to learn the embedding representations of check-in points; and M-GT, which employed only the temporal graph to learn the embedding representations of check-in points. The comparison of the accuracy of GATULER with that of M-GCN, M-GC, and M-GT is depicted in Figure 3.

GATULER consistently outperforms the other three models across all evaluation metrics (Accuracy, Precision, Recall, and F1-Score) on both datasets. GATULER outperforms M-GCN, highlighting the advantage of the graph attention mechanism in capturing the complex inter-node dependencies beyond what traditional GNNs offer. GATULER yields a significant performance gain over both M-GC and M-GT on both datasets. The main reason is that M-GC relies solely on the spatial graph $G_c$, overlooking the critical temporal graph $G_t$ to learn embedding representations of check-in points, while M-GT relies exclusively on the temporal graph $G_t$, missing spatial context.

4.2.2. FL-DBSCAN Algorithm Performance

• Comparison between FedTULGAC and typical federated learning method

In this experiment, we examined the advantages of the FL-DBSCAN algorithm within the FedTULGA method. We consider two traditional model aggregation methods: FedAvg [17] and FedProx [23]. FedAvg is a classical federated learning algorithm where clients train models locally on their data and the server aggregates these local models by computing a weighted average of their parameters. FedProx, a variant of FedAvg, is specifically designed to address the challenge of statistical heterogeneity (non-IID data). FedProx introduces a proximal term to the local objective function, which constrains local updates by penalizing significant deviation from the global model. To ensure a fair comparison, we integrated each aggregation method with the GATULER model to construct two baseline methods: FedAvg + GATULER, FedProx + GATULER. In terms of the evaluation metrics, we adopted the standard evaluation criteria for the federated learning setting: training loss, training time and accuracy. The experimental results are shown in Figure 4 and Figure 5.

As illustrated in Figure 4, the evaluated models exhibit significant differences in both convergence speed and final performance. Among the federated learning models, the proposed FedTULGAC model demonstrates a superior convergence curve compared to the baseline models, FedAvg and FedProx. After an initial phase, the loss value of FedTULGAC decreases more steadily and reaches a lower final value than both FedAvg and FedProx. This improvement stems from the FL-DBSCAN algorithm; specifically, by clustering clients with similar data distributions, it effectively mitigates the performance degradation typically caused by data heterogeneity in federated settings.

Figure 5 illustrates the comparative training time efficiency among the evaluated models. Although the FedTULGAC model’s computational cost increases linearly with the number of epochs, it exhibits a marginally longer training time compared to the FedAvg and FedProx models. According to the analysis in Section 3.2.2, the FL-DBSCAN algorithm’s computational complexity is approximately quadratic in the number of selected clients $s$ and linear in the model dimensionality $d$. Thus, while the FL-DBSCAN algorithm introduces a sophisticated server-side clustering mechanism to improve learning in non-IID settings, it comes at the cost of significant server-side computation. Future work may need to investigate approximate distance calculations to alleviate this bottleneck for very large values of $s$ and $d$, and achieve an optimal trade-off between the algorithmic benefit of client clustering and the computational scalability on the server.

• Analysis of Hyperparameters

• Accuracy variation and clustering factor

This experiment analyzes the performance variation in the FedTULGAC model with respect to the two hyperparameters in DBSCAN clustering: the neighborhood radius (ε) and the minimum number of points ($c$). ε defines the maximum distance between two update vectors for them to be considered part of the same neighborhood. The ε value can moderate angular separation and effectively group clients whose model updates are directionally similar in the high-dimensional parameter space. The parameter $c$ specifies the minimum number of clients required to form a cluster. The optimal values of ε and $c$ can be determined empirically. The experimental results are presented in Figure 6 and Figure 7.

As illustrated in Figure 6, the test accuracy improves as the number of training rounds increases for all the neighborhood radii (ε = 0.3, 0.5, 0.8). The green dashed line (ε = 0.3) consistently shows the lowest accuracy throughout the training process. After 100 rounds, it reaches a test accuracy of only about 0.6, which is significantly lower than the other settings. The red solid line (ε = 0.5) demonstrates the highest accuracy. It achieves nearly 0.8 test accuracy by round 40 and maintains this performance through round 100. The blue dotted line (ε = 0.8) starts with an initial accuracy similar to ε = 0.3 but is gradually outperformed after 20–30 rounds, and eventually plateaus at about 0.75 accuracy. The results strongly support selecting ε = 0.5 for this federated learning setup, as it maximizes test accuracy while maintaining stable convergence.

As illustrated in Figure 7, all the test accuracies improve with increasing training rounds. Specifically, the blue curve–diamonds line (c = 1) achieves the lowest accuracy throughout training and plateaus at a modest level significantly below the other settings. The orange curve–stars line (c = 3) demonstrates the highest accuracy and outperforms both other configurations from early rounds and maintains a clear lead throughout. The green curve–crosses line (c = 5) shows intermediate performance, and it performs better than c = 1 but consistently worse than c = 3. The results indicate that c = 3 strikes an optimal balance: the threshold is high enough to require sufficient clients for a robust cluster, yet not so high as to impede timely cluster formation during training.

2.

Loss variation with client selection ratios

The client selection ratio is the actual number of clients participating in each round of training by the total number of clients, which is also an important indicator reflecting the Non-IID characteristics of the experimental datasets.

The client selection ratio is defined as the ratio of the actual number of clients participating in each training round to the total number of clients. It serves as an important indicator reflecting the Non-IID characteristics of the experimental datasets. We further evaluate the scalability of the proposed FedTULGAC model by adjusting this ratio. The experimental results are shown in Figure 8.

As shown in Figure 8, we observed that as the client selection ratio decreased across the four different settings, the model’s loss value decreased at a slower rate. This was attributed to the limited representativeness of a small sample size. However, this trend became less pronounced after 100 training rounds. Specifically, between rounds 100 and 200, the training processes of all models stabilized, exhibiting smoother convergence curves and smaller fluctuations. Beyond 200 rounds, all models achieved good predictive performance with very low final loss values. The experimental results indicate that the FedTULGAC model is insensitive to the client selection ratio and maintains high prediction accuracy even at low ratios.

5. Conclusions

In this study, we proposed an innovative federated learning-based trajectory user linking method named FedTULGAC, which was designed to overcome the limitations of traditional methods. By introducing the GATULER model and the FL-DBSCAN clustering algorithm, this method enhances the security of data processing and improves the performance of trajectory user linking tasks. Extensive experimental results on synthesized datasets indicated that while safeguarding user privacy, FedTULGAC achieves significantly higher predictive accuracy compared to both traditional TUL models and typical federated learning methods. Furthermore, the analysis of the clustering factor hyperparameter provides guidance for determining its optimal value. The experimental results on loss variation with different client selection ratios indicate that FedTULGAC can consistently achieve high prediction accuracy even at low ratios, which reveals its effectiveness and practicality in real-world applications with bandwidth limitations.

Future research will focus on enhancing the computational efficiency of FedTULGAC to better balance accuracy and training costs, particularly by reducing the overhead associated with its clustering algorithm. Additionally, with the advancement of multimodal fusion technologies [24] and generative Large Language Models (LLMs) [25,26], integrating FedTULGAC with these techniques represents a promising direction, which could significantly enhance the model’s ability to perform large-scale and semantic-aware trajectory user linking.