Federated Learning for Connected and Automated Vehicles: A Survey of Existing Approaches and Challenges

In plain words

Self-driving and connected cars record a lot of sensor data: camera images, laser scans, radar and the car's own driving signals. Much of it is private, and sending all of it to one place to train a model is slow and raises privacy concerns. Federated learning changes the flow. Each car trains on its own data and sends back only the model's settings, and a server or neighbouring cars combine those settings into a shared model.

This survey explains how that idea is used for connected and automated vehicles. It looks at two layouts: one where a central server combines the updates, and one where cars share updates with each other and no server is needed. It then covers the sensors and model types involved, privacy tools that can be added on top, eight application areas such as driver monitoring, path prediction and traffic flow, and open problems such as uneven data across cars, forgetting and fairness.

TL;DR

• A 2023 survey (journal version of the authors' earlier conference survey) on federated learning (FL) for connected and automated vehicles (CAV) §1.
• Reviews centralized and decentralized FL, sensor data types, base model families, privacy techniques, eight application areas and open challenges §1 tab. 1.
• It proposes no method and runs no experiments; its algorithms are generic sketches alg. 1 alg. 2.
• Useful as a map of the literature and for finding primary sources. It is not an implementation reference: most details an implementer needs are not stated.

Problem

Connected and automated vehicles generate very large data volumes. The paper cites a figure of 20 to 40 TB per vehicle per day §1. Training perception, planning and control models on this data raises privacy concerns, and regulation such as the GDPR is cited as a constraint on collecting personal data §1. Uploading raw data also costs communication capacity. The paper argues that FL keeps raw data on the vehicle and sends only model parameters, which are smaller than the data §1.

The data from vehicles are typically non-independent and non-identically distributed. A single global model may then fit individual vehicles poorly, and several local update steps can make updates drift away from the global objective §2.1.1.

Method

The paper describes FL in four steps, applied to K vehicles §2:

1. Distribution. The edge server sends the global model parameters to the vehicles.
2. Local update. Each vehicle trains on its own data, usually with plain SGD. Compute on vehicles is limited.
3. Upload. Each vehicle may add privacy noise (differential privacy) and sends its parameters to a central server (centralized FL, CFL) or to other vehicles (decentralized FL, DFL) §2.
4. Aggregation. The server (or each vehicle, in DFL) combines the received parameters. The server also tests the resulting model §2.

The paper's section numbers are Arabic here (§2 = Section II in the PDF). Its tables are printed as TABLE I to IV, which this card cites as tab. 1 to tab. 4.

Centralized FL (§2.1). FedAvg is the aggregation method most of the surveyed literature uses. Each vehicle runs SGD and the server takes a weighted average, with multiple local steps per round to reduce the number of communication rounds §2.1.1 alg. 1. Variants named in the text are FedProx (a proximal term), Dynamic Federated Proximal (DFP, which varies the learning rate and the regularisation coefficient during training) and FedAdam (Adam-style server optimisation) §2.1.1. Knowledge distillation exchanges model outputs instead of parameters: Federated Distillation (FD), FD for CAV (FDCAV), where vehicles share outputs such as bounding boxes and the server averages them §2.1.2, and teacher-student schemes such as FedGKT and FedKD, where the server holds a larger model and clients hold a smaller one §2.1.2.

Decentralized FL (§2.2). Vehicles exchange models only with neighbours through a non-negative mixing (gossip) matrix W that is symmetric and doubly stochastic §2.2 eq. 3. Each round, every vehicle takes a local SGD step and then averages its neighbours' results with the weights in W alg. 2. The paper lists DFL advantages (no single point of failure, scale, robustness) and disadvantages (slower convergence under heterogeneous data, network latency, and the need to synchronise under changing topology) §2.2. Figure 3 shows a ring and a fully connected topology for four vehicles fig. 3.

The core equations as the paper writes them:

\min_{x \in \mathbb{R}^{d}} f(x) = \frac{1}{K} \sum_{i=1}^{K} f_i(x_i) eq. 1

f_i(x_i) = \mathbb{E}_{\xi_i \sim \mathcal{D}_i}\left[\ell(x_i, \xi_i)\right] eq. 2

\theta_i^{(t+1)} = \sum_{j} w_{ij}^{(t)} \, \theta_j^{(t)} eq. 3

The pseudocode below follows the two algorithm boxes. Where the paper's text and its box disagree, the choice is noted in the comment and in Pitfalls.

# Centralized FL round (averaging)  [alg. 1] [§2.1.1]
# Input:  vehicles V, learning rate eta_t, local epochs E
# Output: global model for the next round

def centralized_round(global_model, vehicles, eta_t, epochs):
    # Start each vehicle from the server's model, as in the step list  [§2]
    # Algorithm 1 starts from each vehicle's own model; see Pitfalls
    updates = []
    for vehicle in vehicles:
        # Local SGD on the vehicle's own data for E epochs  [alg. 1]
        local_model = run_sgd(global_model, vehicle.data, eta_t, epochs)
        updates.append((len(vehicle.data), local_model))
    # Server: average weighted by each vehicle's data count  [alg. 1]
    total = sum(count for count, _ in updates)
    return sum(count / total * model for count, model in updates)

# Decentralized FL round (gossip averaging)  [alg. 2] [eq. 3]
# Input:  vehicles V, mixing matrix W, learning rate eta_t, local epochs E
# Output: one model per vehicle

def decentralized_round(models, W, eta_t, epochs):
    # Local SGD step per vehicle; the result is sent to neighbours  [alg. 2]
    half_models = {}
    for vehicle in vehicles:
        half_models[vehicle] = run_sgd(
            models[vehicle], vehicle.data, eta_t, epochs
        )
    # Mix: average neighbours' half-step models with weights w_vu  [alg. 2]
    for vehicle in vehicles:
        models[vehicle] = sum(
            W[vehicle][other] * half_models[other] for other in vehicles
        )
    return models

Hyperparameters

The paper gives no training configuration. Every value an implementer needs is either symbolic or not stated.

Results

The paper reports no experiments of its own. Results it does state are secondary (quoted from other works or from the authors' own classification).

• Raw data: 20 to 40 TB per vehicle per day, citing a single source §1.
• Prior surveys compared: six, from 2020 to 2023 tab. 1. The authors' row claims eight vehicle applications and challenges in four categories with 11 subcategories tab. 1 §5.
• Literature table: 25 surveyed FL-for-CAV works, 23 marked centralized and 2 decentralized tab. 3. Application table: data modality, task and dataset per work tab. 4.
• Qualitative comparison of learning paradigms, with the authors' own ratings and no measurements tab. 2:

Paper vs code

No official code.

The paper's source has no code, repository or project-page link §1–§6. The arXiv metadata has no code link. A GitHub repository search for the title words returned no repositories, and none belongs to the authors. No code was cloned.

Pitfalls

• Survey, not method. Claims such as "improves privacy", "reduces communication" and "DFL is more robust" are summaries of other works §2.2 §3.3. Check the primary source before relying on any of them.
• Algorithm 1 start point. The loop trains from each vehicle's own model \theta_v^{(t)}, but the step list says the server sends the global model first §2 alg. 1. The sketch above starts from the global model. Confirm which one your implementation uses.
• Algorithm 1 notation. The box writes \theta^{(t+1)} in the aggregate but \theta_v^{t+1} on the right side, and returns \theta^{(T)}. The sum weights are |\xi_v^{(t)}| / |\xi^{(t)}|, which is data-count weighting even though the text calls it only "weighted averaging" §2.1.1.
• Eq. 1 is ambiguous. It minimises over one shared x but writes local terms f_i(x_i) and states x_i = x^*. This implies all vehicles converge to one model. The paper also uses K in Eq. 1 and V or n in the algorithms.
• Algorithm 2 versus Eq. 3. Algorithm 2 mixes the half-step models \theta_u^{(t+1/2)} with W, but writes the sum over u without an index on W; Eq. 3 mixes the pre-step iterates \theta^{(t)} with w_{ij}^{(t)}. The sketch above follows Algorithm 2 with w_{vu}.
• "Personalized" DFL output. Algorithm 2 returns a personalised model per vehicle, but the paper gives no personalisation step. The mixing step alone pulls models together. Personalisation has to come from elsewhere.
• Mixing matrix construction. The properties are given, but no weight rule for ring or fully connected topologies, and no way to keep W doubly stochastic on a changing graph §2.2 fig. 3.
• Differential privacy is described, not specified. The paper says vehicles add noise before upload, with no clipping, noise scale or privacy budget §2 step 3 §3.3.
• Loose cryptography wording. Homomorphic encryption is described as computation "with decrypted results", and the secure multi-party computation paragraph does not give a protocol §3.3. Use primary sources.
• Blockchain incentives. Incentive and reward mechanisms are claimed with no mechanism, token model or measurement §3.3.
• Table 2 direction. The row "communication (data transmission) requirement" rates edge learning "very high" and centralized "low". The rating direction is not defined, so read it as the paper's opinion only.
• Version. The card follows arXiv v2 (updated 2023-11-11). The published date is the v1 date, copied from the metadata.

Lineage

• Builds on: the authors' conference survey of FL for CAV, which this journal version extends §1. Its arXiv id is not stated in the paper.
• Compared against: six prior surveys in tab. 1: Du et al. (2020), Jiang et al. (2020), Savazzi et al. (2021), Nguyen et al. (2021), Javed et al. (2022) and Yuan et al. (2023).
• Superseded by: not stated.