Reputation-Driven Asynchronous Federated Learning for Enhanced Trajectory Prediction with Blockchain

To begin with, we propose integrating the task of trajectory prediction into a practical scenario of distributed data sharing that involves multiple participants. Each participant has their own data and is willing to share it to realize the collaborative task, but we cannot exclude the existence of malicious sharers who try to interfere with the trajectory prediction task. In addition, the vehicular network comprises vehicles, RSUs, and Macro Base Stations (MBSs), primarily utilizing vehicle-to-vehicle (V2V) and vehicle-to-RSU (V2R) communication. RSUs are equipped with Mobile Edge Computing (MEC) servers, providing computational and storage capabilities. The proposed data sharing architecture comprises a permissioned blockchain module and a FL module, illustrated in Fig. 1. The permissioned blockchain handles retrieval and data-sharing transactions. We utilize the permissioned blockchain solely for retrieving relevant data and managing data accessibility, without recording the raw data.

We consider $N$ vehicle participants and a joint dataset $D=\{D_{1},D_{2},\ldots,D_{n}\}$. For any vehicle $v_{\text{req}}\in v_{i}$ that participates in the request for data sharing, its local dataset $D_{i}\in D$, which contains the historical trajectory $X\in\mathbb{R}^{\tau\times n\times 2}$ of all observations at time step observations at time step $\mathcal{T}$:

where $\mathcal{P}^{(t)}=\left[\left[x_{0}^{t},y_{0}^{t}\right],\left[x_{1}^{t},y_{1}^{t}\right],\ldots,\left[x_{n}^{t},y_{n}^{t}\right]\right]\in\mathbb{R}^{n\times 2}$ are the coordinates of all observations at time $t$ and $n$ is the number of observations. We employ a coordinate system based on the measured relative values of the self-vehicle with reference to [45]. And the output $\mathcal{Y}^{\prime}\in\mathbb{R}^{T\times n\times 2}$, which predicts the future positions of all observations from time step $\mathcal{T}+1$ to $\mathcal{T}+\mathcal{T}_{f}$:

where $\mathcal{T}_{f}$ is the predicted range.

To improve computational and storage efficiency while facing limited resources, and to ensure secure and robust vehicle interactions, we implement a graph-based approach for model training and data sharing. Initially, vehicles must undergo authentication to become legitimate nodes in the permissioned blockchain, obtaining certificates for participating in V2V data sharing, and enabling them to download the global model locally for training purposes. Subsequently, vehicles transmit data sharing requests to nearby super nodes (such as MBS and RSU) for processing. Upon verifying their public keys, the super nodes commence the collection of weighted graph models perturbed with differential privacy noise from vehicles within the community for federated learning training. Participating vehicles compute reputation values based on the original data to assess the quality of their trajectory data. These values are recorded as shared transactions and in the local models of other participating vehicles within each vehicle’s local Directed Acyclic Graph (DAG). To mitigate the global aggregation latency and optimize the aggregation results, we use the PPO algorithm to group vehicles based on the reputation evaluation mechanism. Therefore, the high-quality vehicle clusters receive priority in deep aggregation. The super nodes collaborate to train the global model $M$ through asynchronous FL and broadcast the results to all committee nodes, which are charged with driving the consensus process for the permissioned blockchain. The committee nodes collect the transactions into blocks and verify the blocks to further add them to the permissioned blockchain. The vehicles optimize their local models by integrating the global model, thereby achieving increased accuracy in predicting trajectories. Fig. 2 shows the working mechanism of our scheme.

Our approach transforms object trajectories into weighted graphs for interaction modeling. Referring to the trajectory prediction model GRIP++[45], each object trajectory is organized as a 3D array, computed for improved speed to enhance prediction accuracy. We use undirected graphs $G=\{V,E\}$ to depict the interactions between objects. The input data is processed by graph convolution network (GCN). Graph operations handle spatial interactions and temporal convolution captures time-based features. Both the encoder and decoder used for the trajectory prediction model are two-layer GRU (Gated Recurrent Unit) networks. Based on this, $G=\{V,E\}$ is converted into a weighted graph of vehicle trajectories. The set of nodes $V$ is defined as $V=\left\{v_{it}\mid i=1,\cdots,n,t=1,\cdots,\mathcal{T}\right\}$, with $n$ denoting the total number of objects observed in the scene. Each node $v_{it}$ contains its own weights $w_{i}^{n}$. The weights $w_{v_{it}}$ are determined based on the similarity of trajectories between vehicles, including direction, speed, and tilt angle, as described in the following subsection. Subsequently, $G$ is serialized into ordered vectors that are then mapped onto linear vectors. These maps are combined to form a global vehicle network graph $\mathcal{G}=\left\{G_{1}\cup G_{2},\dots,\cup G_{n}\right\}$. For the overall graph $\mathcal{G}=\{\mathcal{V},\mathcal{E}\}$, the number of representative vertices is denoted as $k$. Afterwards, the size of the normalization property of the vertices will be $k$ and the size of the normalization property of the edges will be $k\times(k-1)/2$. Eventually, the normalized vector $Seq=\mathcal{V}\cup\mathcal{E}=\left\{\mathcal{V}_{1},\ldots,\mathcal{V}_{k}\right\}\cup$$\left\{\mathcal{E}_{1},\mathcal{E}_{2},\ldots,\mathcal{E}_{k(k-1)/2}\right\}$.

After that, we use cosine similarity as a distance function to compare vehicle matrices sequentially in temporal order, and confidence levels above 80% will fail validation, as well as new weighted graphs added in future moments with confidence levels above a preset threshold will fail validation. By using weighted graphs and the PPO algorithm, the set of vehicles $\left\{V_{1},\ldots,V_{n}\right\}$ is divided into high and low reputation groups. Through this differential privacy federation learning mechanism, instead of sharing local vehicle model parameters, the shared graph neural network model is used to retrieve and compare confidence levels thus filtering out the series of graphs with high trustworthiness as well as low similarity, which prevents the model parameters from leaking the vehicle trajectory information and improves the efficiency of the next global aggregation.

Our objective is to develop a secure mechanism for data sharing in trajectory prediction scenarios that intelligently facilitates data sharing among distributed multi-users while effectively safeguarding data privacy. Our approach involves considering $\mathcal{N}$ parties or data holders, along with a joint data set $\mathbb{D}$. For each party $P_{i}$, there exists a local data set $\mathbb{D}_{i}$ in $\mathbb{D}$. All $\mathcal{N}$ parties unanimously agree to share data without compromising confidential information. Let $R=\left\{r_{1},r_{2},\ldots,r_{m}\right\}$ represent requests for data sharing. Requesters submit queries $r_{i}$, and we provide computed results rather than raw data to fulfill sharing requirements. Finally, the trained global model $M$ is returned to the committee node. Recipients can leverage the received global aggregation model to respond to data sharing requests locally.

Considering the large size and sensitivity of the data, inspired by previous work[46], we utilize the blockchain for data retrieval, while the actual data remains stored on local vehicles. We combine graph neural networks and differential privacy for quality verification. Using a graph representation of the raw data improves computational and storage efficiency under resource constraints, preserving more structural and contextual information for validation while also preventing privacy leakage. Once new data providers join, their uniqueness (vehicle ID) is recorded on the blockchain, alongside an overview of their data, including trajectory data, vehicle types, and data sizes. All data profiles from multiple participants are recorded as transactions and verified by blockchain nodes using Merkle trees[47]. Each data sharing event is also stored as a transaction on the blockchain. All participants (denoted as $\left\{P_{1},P_{2},\ldots,P_{n}\right\}$) are selected through multi-party searches in the blockchain and are divided into communities based on their reputation values. These communities consist of members with similar data quality. Given the limited communication resources of IoT devices, the retrieval process should also consider the matrix cosine similarity between the two participants. When a user submits a request to share data with a nearby node $P_{i}$, all nodes within the identical community as $P_{i}$ broadcast this request to other vehicles that are observing the target during that timestamp to commence the retrieval process. The process is recursively executed until all trajectory graphs for that timestamp have been executed. At the end of the retrieval process, we will procure a collection of vehicles $P_{s}\subseteq\mathbb{P}$ that pertain to the request. These vehicles exhibit structural stability, the absence of anomalous data, and minimized redundancy in trajectory graphs within the community, addressing the constraints posed by limited communication resources. To ensure privacy protection for the shared model, we employ differential privacy for each local model $m_{i}$ using the Laplace mechanism. Here, we add calibrated noise with sensitivity $s$ to the local data to train $\hat{m}_{i}$, expressed as:

where $\epsilon$ denotes the privacy budget. Subsequently, participant $P_{i}$ transmits the model $\hat{m}_{i}$ as a blockchain transaction broadcast to other participants for federated learning. Upon receiving $\hat{m}_{i}$, participant $P_{i+1}$ trains a new local data model $\hat{m}_{i+1}$ based on the received $\hat{m}_{i}$ and its local data, and subsequently broadcasts $\hat{m}_{i+1}$ to other participants. This iterative process continues among participants. Finally, a global model $M$ is generated, given by $\mathcal{M}=\left\{\hat{m}_{1}\cup\hat{m}_{2}\ldots\cup\hat{m}_{n}\right\}$.

The use of Mean Absolute Error (MAE) as an evaluation metric may not be practical in real-world trajectory prediction scenarios. We employ a novel evaluation metric: the reputation value derived from trajectory similarity among vehicles. The locally collected vehicle data is spatially correlated and exhibits a spatial extent. Incorporating trajectory similarity into reputation calculations when sharing data between vehicles enables location awareness and enhances data relevance. The more similar the trajectories, the more relevant the shared data from the data provider, resulting in improved quality, accuracy, and reliability of the shared data. Trajectory coefficients of a vehicle are represented as $v=\{$velocity, position, orientation$\}$. The weights of each coefficient in $v$ are $\rho_{1}$, $\rho_{2}$, and $\rho_{3}$, and $\rho_{1}+\rho_{2}+\rho_{3}=1$. The similarity between two trajectory segments, $\mathcal{J}_{i}$ and $\mathcal{J}_{j}$, of vehicles $i$ and $j$, can be expressed as $\mathcal{SIM}\left(\mathcal{J}_{i},\mathcal{J}_{j}\right)$. This is calculated using the Eq.(4),

The normalized dissimilarity for $L_{i}$ and $L_{j}$, denoted as $\mathcal{DISS}\left(\mathcal{J}_{i},\mathcal{J}_{j}\right)$, is used to calculate this similarity, as Eq.(5),

We assert that $\mathcal{DISS}\left(\mathcal{J}_{i},\mathcal{J}_{j}\right)$ relies on the disparity in velocity, position, and orientation of the two trajectory segments. The velocity difference between the two segments of the trajectory is given by

where $W\left(\mathcal{J}_{i}\right)$ and $W\left(\mathcal{J}_{j}\right)$ are the velocities of vehicles $i$ and $j$ during their trajectory segments, respectively. $W_{\text{ave }}\left(\mathcal{J}_{i}\right)$ and $W_{\text{ave }}\left(\mathcal{J}_{j}\right)$ are the average velocities of these two vehicles. The position$\left(\mathcal{J}_{i},\mathcal{J}_{j}\right)$ shows the variance in the position between the trajectory segments. The number of sampled points for $\mathcal{J}_{i}$ and $\mathcal{J}_{j}$ during the time window $T$ are denoted as $e$ and $k$, respectively. The set of sampled points in temporal order are $\left\{P_{i1},P_{i2},\ldots,P_{ie}\right\}$ and $\left\{P_{j1},P_{j2},\ldots,P_{jk}\right\}$. We employ the Longest Common Sequence (LCS) method to measure the similarity of trajectory segments. For trajectory segments $\mathcal{J}_{i}$ and $\mathcal{J}_{j}$, the LCS is described as $\operatorname{LCS}\left(\mathcal{J}_{i},\mathcal{J}_{j}\right)=\left\{P_{ie}=\right.$$\left.P_{jk}\mid e=k\right\}$, where $e\in\{1,2,\ldots,E\},k\in\{1,2,\ldots,K\}$. Therefore, the equation for the difference in position between the trajectory segment position$\left(\mathcal{J}_{i},\mathcal{J}_{j}\right)$ is provided as follows:

where $\operatorname{num}\left[\operatorname{LCS}\left(\mathcal{J}_{i},\mathcal{J}_{j}\right)\right]$ is the number of points in the LCS of the trajectory segments $\mathcal{J}_{i}$ and $\mathcal{J}_{j}$. The directory difference between the two trajectory segments is the angle between the two trajectory segments. Here, we employ $\varphi$ as the angle between the trajectories $\mathcal{J}_{i}$ and $\mathcal{J}_{j}$ to represent the direction. More precisely,

By transforming the data sharing problem into a model sharing problem, the privacy of data holders is enhanced. Moreover, the data model of the graph neural network efficiently provides essential information for new sharing requests, as well as better-preserved vehicle trajectory features during data fusion. However, the use of prevailing consensus mechanisms like Proof-of-Work (PoW) in data sharing may lead to high computational and communication costs. To resolve this matter, implementing the FL Authorised Consensus Proof of Reputation (PoR) protocol is suggested. PoR combines vehicle reputation values with the consensus process, enhancing node computational resources. When data sharing requests occur, consensus committee members are chosen by retrieving the relevant blockchain nodes. The committee oversees the consensus process and acquires knowledge of the data model of the requested data. Asynchronous FL seeks to develop a worldwide information model $M$, which delivers an effective response $M$(Req) to inquiries concerning data sharing, thereby achieving the intended objective.

Sending consensus messages to only the committee nodes can lower communication overhead. However, reducing the number of nodes increases the challenge of reaching agreement. We offer reputation proof for consensus in data sharing to balance security and overhead. We choose committee leaders based on their reputation scores. As each committee node trains a local data model, it is imperative to verify and measure the quality of the model during the consensus process. Prediction accuracy is deemed essential to evaluate the performance of the trained local models. More precisely, we train the model as a regression task each time during trajectory prediction training. The total loss can be calculated as

where $\mathcal{T}$ is the future time step, and $Y_{pred}^{t}$ and $Y_{GT}^{t}$ are the predicted position and ground truth at time step $t$, respectively.

For each committee node, a trained global model $M$ and a local model $m_{i}$ are obtained after asynchronous training. The committee executes the consensus process, during which committee node $P_{i}$ sends its trained model $m_{i}$ to the next committee node while responding to a data sharing request. The transmission is recorded as a model transaction $t_{m_{i}}$ along with its corresponding loss ($m_{i}$). $P_{i}$ has a pair of public and private keys ($PK_{i}$, $SK_{i}$) to encrypt and sign the message. $P_{i}$ then sends the encrypted message $E\left(\mathrm{SK}_{i}\left(t_{m}\right),\mathrm{PK}_{i}\right)$ to the other committee nodes. All model transactions are then collected and stored locally as potential blocks by the committee node $P_{j}$. As part of the training procedure, $P_{j}$ validates all transactions it receives by computing the loss defined in Eq.14. ${Loss}^{u}\left(P_{j}\right)$, the loss of $P_{j}$, is calculated through the following equation:

where $\gamma$ represents a weight parameter indicating the contribution of $P_{j}$ to the global model and ${Loss}\left(M_{j}\right)$ represents the loss of the local training model $m_{j}$, determined by the size of the training data of $P_{j}$ and other participants $\gamma=1+\left|d_{j}\right|/\sum_{i}\left|d_{i}\right|$.

Using the aforementioned approach, we achieve effective interpretable federal learning for the trajectory prediction task. Specifically, by characterizing the vehicle trajectory data as a normalized weighted graph, the important private parameters are preserved. Preventing data redundancy, we achieve the elimination of vehicles with high similarity in the set of neighboring nodes using a multi-party query approach while protecting privacy. We are well aware that the quality of vehicle improvement data directly affects the results of parameter fusion in the federal learning model, so we introduce a reputation mechanism to solve this problem well by using the reputation values calculated from the private track data of the vehicles that are not eliminated and submit them to the reviewer for further grouping. The grouping method will be further described in section V.

In IoV, the computational power and dynamic communication conditions of each vehicle result in different learning times. As a result, the slowest participant determines the running time of each learning iteration, while the other participants must wait to keep in sync. Existing work on trajectory prediction using FL essentially uses the synchronous federated algorithm FedAvg[48], which improves data security for multi-client model training. However, synchronous FL leads to increased communication costs and longer waiting times for idle nodes. For tasks with spatial timing dependencies, it can cause training difficulties leading to untimely global aggregation. Several studies have investigated asynchronous learning mechanisms to improve the learning performance[39, 49]. However, implementing these mechanisms for trajectory prediction may lead to suboptimal node selection, as their lack of interpretability can introduce biases in vehicle evaluations. Therefore, this paper proposes a method to predict trajectories via asynchronous FL. It utilizes the proposed reputation evaluation mechanism to group nodes with the PPO algorithm, enabling the asynchronous training of trusted vehicle clusters.

With the filtering and reputation value calculations of the previous section, we obtained a set of vehicles with unique features. Local aggregation on each vehicle $v_{i}$ is performed asynchronously within the range to enhance the quality of the locally trained model. The vehicles preserve and update the DAG locally to achieve asynchronous consistency with the other vehicle nodes. Asynchronous consensus enables vehicles to reach an agreement based on historical states rather than the current state. Vehicle $i$ sends updates to its local $DAG_{i}$ and then transmits the updates to nearby vehicles using a gossip scheme to achieve synchronization. Each vehicle randomly scatters its latest $DAG_{i}$ to neighboring vehicles. The gossip scheme propagates the DAG updates and maintains loose consistency between vehicles. This approach is less computationally intensive and globally robust. While asynchronous FL has improved aggregation efficiency, the issue of vehicle grouping remains unresolved. Limitations arise from exclusively conducting asynchronous local aggregation on nearby local vehicles to obtain a global model, as it fails to adapt to dynamic traffic conditions and thus cannot effectively optimize local prediction models. Therefore, as illustrated in Fig. 4, we employ the PPO algorithm with an innovative reward feedback mechanism driven by reputation evaluation. This mechanism prioritizes the deep aggregation of high-reputation vehicles, leading to a superior global aggregation model.

We aim to minimize execution time and enhance model accuracy by precisely categorizing the vehicle nodes according to their reputation values. During the global aggregation phase, the disparate computational resources and fluctuating communication conditions among different vehicles hinder the attainment of efficient execution. Therefore, we propose an approach where participating vehicles within a specific timestamp are selected based on reputation values until each grouping contains no more than $n$ vehicles. This approach prioritizes the aggregation of trajectory graphs with high reputation representing high data quality and improves the global aggregation.

Unlike conventional reinforcement learning, which evaluates the performance of an agent in a specific slot primarily based on accuracy loss alone, we consider the characteristics of the data during node clustering. For this purpose, we introduce the Reputation of Learning (RoL) to describe the high or low reputation value of vehicle $i$ in the aggregation process of slot $t$ as follows,

where $w^{t}$ represents the completed combined model in slot $t$, and $\mathfrak{d}_{i}=\left\{\left(x_{j},y_{j}\right)\right\}$ represents the training data of vehicle $i$. Furthermore, we define the local learning time cost of vehicle $i$ in slot $t$ and the communication cost of vehicle $i$ as follows,

where $\beta_{m}$ denotes the necessary CPU cycles to train model $m$ per iteration. Thus, the function of time consumption is

In this way, the total cost of FL in time slot $t$ can be given by the following equation:

where $\lambda^{t}=\left[\lambda_{i}^{t}\right]$ in the time step $t$ is an indicator vector for vehicle selection, with $\lambda_{i}^{t}=1$ indicating activation and $\lambda_{i}^{t}=0$ indicating the opposite. We formulate the combinatorial optimization problem using a Markov Decision Process, which we denote as $\mathcal{M}=\left(S,V,P_{v},C_{v}\right)$. The task of node selection can be expressed in the following way:

where the constraint Eq.20c ensures that the distance between the selected participating vehicles and the computed centroid cannot exceed a finite distance $r_{0}$. We use PPO to solve the problem Eq.20a. The fundamental principle involves updating the system policy with a value function.

We utilize PPO to ascertain the optimal resolution for vehicle reputation categorization in asynchronous FL. PPO operates on a well-defined Markov decision process $\mathcal{M}=\left(S,V,P_{v},C_{v}\right)$. At each time slot $t$ in FL, the system state is represented by $s_{t}=\{\boldsymbol{\tau}(t),\boldsymbol{\xi}(t),\boldsymbol{\gamma}(t),\boldsymbol{\lambda}(t-1)\}$. Here, $\boldsymbol{\tau}(t)$ denotes the wireless data rate between vehicles, $\boldsymbol{\xi}(t)$ represents the available computing resources of the vehicles, $\boldsymbol{\gamma}(t)$ indicates the reputation of the vehicles, and $\boldsymbol{\lambda}(t-1)$ signifies the selection state of the vehicles. The action taken at time slot $t$, denoted by $\lambda^{t}=\left(\lambda_{1}^{t},\lambda_{2}^{t},\ldots,\lambda_{n}^{t}\right)$, corresponds to a vehicle selection decision and can be framed as a 0-1 problem. Specifically, $\lambda_{i}^{t}=1$ when vehicle $i$ is selected as a node with a high reputation value, otherwise $\lambda_{i}^{t}=0$. Our improvement is mainly in the reward function. Specifically, we customize the reward function to add 1 to the reward value for choosing a vehicle with a high reputation value, subtract 1 from the reward value for choosing a low reputation value, subtract 10 from the reward value for choosing a low reputation value for 5 consecutive times, and end the round; if the number of vehicles chosen with a high reputation value reaches the threshold, then 20 points are rewarded; and end the round. The system assesses the impact of an action using a reward function called $R$. At iteration $t$, the agent carrying out the task of selecting the vehicle reputation takes action $\lambda_{t}$ while in state $s_{t}$. Subsequently, the action is appraised via the established reward function in the ensuing manner:

The reward function $R\left(s_{t},\lambda_{t}\right)$ assesses the standing of taking action $\lambda_{t}$ at time interval $t$. The overall cumulative reward can be presented as:

where $\gamma\in(0,1]$ is the reward discount factor.

For the PPO algorithm, the objective is to determine the value of lambda that maximizes reputation accumulation, as shown in the following Eq.23.

Through algorithm 1, the corresponding groups with high and low reputations can be obtained. Next, the vehicle feature parameters of each group are combined, followed by global fusion, with priority given to the high reputation group for deep aggregation.

We evaluated our proposed method RAFLTP on well-known real-world datasets: NGSIM[51, 50], and ApolloScape Trajectory dataset[52], as shown in Fig. 5. The basic info is listed in Table I. NGSIM contains two road segment datasets, US-101 and I-80. Referring to the method[53, 54, 19] for data segmentation of the training set and testing set, a quarter of each of the three road condition data is selected as the test set. Each trajectory is segmented into 8 s, the first 3 s are used as training data, and the last 5 s are used as training labels. The ApolloScape Trajectory dataset was gathered in an urban area during rush hour by a vehicle called the Apollo acquisition car. The data primarily comprises vehicle trajectories that are based on object detection and tracking algorithms. During the initial phase, we adopt GRIP++[45] to select 20$\%$ of the sequences for validation purposes, while the remaining 80$\%$ is utilized as the training set.

This subsection highlights several established metrics that demonstrate the validity and merits of the proposed methodology. Specifically, we adopt the Root Mean Square Error (RMSE), Average Displacement Error (ADE), and Final Displacement Error (FDE) to evaluate the performance with reference to Social-GAN[55].

To demonstrate the advantage of the proposed approach, several subsequent ablation experiments were performed in this subsection.

With regard to the latest findings in DGInet[56], we have compared our model with seven baseline methods consisting of state-of-the-art trajectory prediction methods:

1. 1.

   Encoder–Decoder[8]: This approach employs an enc-dec architecture based on LSTM.

2. 2.

   CS-LSTM[19]: This approach combines CNN and LSTM to extract spatio-temporal features.

3. 3.

   TraPHic[57]: This approach employs spatial attention pooling in combination with CNNs and LSTMs to predict the trajectory.

4. 4.

   Social-GAN[55]: It employs the encoder-decoder architecture as a generator and subsequently trains an additional encoder to serve as a discriminator for trajectory prediction.

5. 5.

   GRIP[7]: This method uses graph convolution for trajectory prediction. The resulting features from the enc-dec network facilitate trajectory prediction.

6. 6.

   Spectral[8]: The approach forecasts both paths and actions and utilizes an additional network founded on spectral clustering to adapt the LSTM-based enc-dec network.

7. 7.

   DGInet[56]: This approach combines a semi-global graph mechanism with a convolutional graph network based on M-products for predicting trajectories.

In Table II, we compare the ADE and FDE of our predicted trajectory with the previous methods. Unfortunately, our solution did not achieve state-of-the-art results. However, compared to the GRIP method, we managed to reduce the ADE by 11.2% and the FDE by 10.2% on the ApolloScape dataset, surpassing even the Spectral result. It’s important to note that our approaches, like GRIP and DGInet, predict trajectories for all vehicles in a traffic scenario, as opposed to Spectral, which predicts only a single vehicle’s trajectory. Fortunately, our approach, which enhances the security and robustness of data sharing among vehicles in a distributed trajectory prediction scenario, aligns more closely with real-world traffic situations and stands out as a unique contribution.

In Fig. 15, we use the NGSIM datasets to show several prediction results under different traffic conditions, where the circled vehicles are those that GRIP++ tries to predict, the purple solid line is the observed history, the red solid line is the future ground truth, the blue dashed line is the prediction result of our model (5 seconds), the green dashed line is the GRIP++ prediction (5 seconds). The range from -90 to 90 feet is the observation range. After observing the 3-second historical trajectories, our model predicts the trajectories over the 5-second horizon in the future. As can be seen in Fig. 15, in various scenarios, when feeding the model with identical historical trajectories, our proposed model (blue dashed line) shows a closer match with the actual trajectories represented by the red solid line compared to GRIP++ (green dashed line), especially at the endpoints of the dashed lines. This further substantiates the superior predictive performance of our approach over GRIP++.

The computational efficiency of the algorithm is a critical performance metric for autonomous vehicles. The computation time of our proposed approach is reported in Table III, implemented using PyTorch. We evaluate the prediction time for 1000 vehicles with batch sizes of 128 and 1, respectively. Our trajectory prediction model is an enhancement based on GRIP++. Although our computational time exhibits a delay compared to the GRIP++ model, it remains acceptable compared to other methods. Despite the latency incurred by our approach, it provides data privacy protection and higher prediction accuracy in return. Notably, our proposed PPO method for grouping vehicles operates on the server. The pre-trained PPO grouping model is deployed on the server, requiring only periodic experience replay[58] and asynchronous updates, without impacting the prediction efficiency of the vehicles themselves.