Paper · 2026-08-12 · cs.LG, cs.AI
Hierarchical Federated Transfer Learning in Digital Twin-Based Vehicular Networks
Hierarchical federated transfer learning (HFTL) for digital-twin vehicular networks: vehicles are grouped by type, each cluster fine-tunes a pre-trained model along a head, route and edge chain, and the cloud weights cluster updates by a data-quality score. Author-reported on a vehicle mobility trace: accuracy 0.822 vs 0.708 to 0.752 for centralized, federated and clustered federated baselines.
Federated learningTransfer learningClustered federated learningDigital twinvehicular-networksfederated-learningdigital-twin
AI-compiled by claude-haiku-5-5 on 2026-11-13, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.
In plain words
Cars, buses and other vehicles each collect their own data, and a prediction model is wanted that learns from all of them without moving the raw data to one place. That is federated learning. It works poorly when the vehicles differ a lot in type and some have little data. This paper sorts vehicles into groups by type. Each group starts from a model that was prepared for that kind of vehicle and fine-tunes it on its own data. Inside a group, the models are passed along a chain of vehicles and merged on the way, and the result goes to a cloud server. The server gives more weight to vehicles whose data it scores as higher quality, so that unreliable or malicious vehicles have less influence on the shared model.
The authors report that this beats centralized training and two other federated methods in their tests. Those tests are simulations, and several parts of the design are described only loosely.
TL;DR
HFTL groups digital-twin vehicles by type and fine-tunes a pre-trained model inside each group along a head, route and edge chain. The cloud then folds in each group's update, with weights from a data-quality score §3.1 §3.5 §3.6. The reported gains (accuracy 0.822 against 0.708 to 0.752) are author-reported on simulated topologies §4.1.1 tab. 3. The paper leaves out the pre-trained source, the merge rule, and the trust parameters. Its blockchain and malicious-vehicle defence are described but not evaluated §3.3 §3.4 §4. Treat the idea as a starting point; do not reproduce the numbers without the missing details.
Problem
Federated learning struggles to train a good global model when vehicles have heterogeneous data and sparse data, which the authors say yields poor accuracy across vehicle types §1. They also name slow convergence and weak accuracy when vehicle types and per-vehicle data vary §1. Centralized training is ruled out for privacy reasons §1. Earlier hierarchical federated work for VANETs groups vehicles by fixed attributes, which the authors consider too rigid for fast-changing traffic §2.1. Clustered and multi-hop VANET clustering papers are discussed but do not address model training §2.3.
Assumptions: the network is a digital-twin VANET with base stations, vehicles, and a cloud server that holds a digital twin of each vehicle §3. Each cluster has one head vehicle, zero or more route vehicles, and an edge vehicle; clusters that do not fit this shape are discarded §3.6, Assumption 1.
Method
Architecture. Two layers: a physical layer (base stations and vehicles) and a digital-twin layer on the cloud, made of a storage component, a twin manager, a model-mapping component and a distributed ledger §3 fig. 1. The blockchain records trust scores and rewards §3.3 §3.4.
Step 1: group vehicles by type. Vehicles are assigned to clusters by type. Table 2 lists six categories: regular cars, emergency vehicles, public transport buses, delivery vehicles, specialised vehicles, and two-wheel vehicles tab. 2. Types are defined by size, purpose and computing resources §3.1. The vehicle with the most advanced features in a cluster becomes its head §3.1. The selection procedure is not stated.
A pre-trained model is shared per vehicle type and target application, such as traffic flow, collision risk or parking prediction §3.1. Each vehicle fine-tunes it on local data §3.1. The source of the pre-trained model is not stated.
Equation 1 is meant to say that each cluster holds one vehicle type eq. 1 §3.1. As typeset, it is not a well-formed sum (see Pitfalls).
Step 2: score each vehicle's data. Each vehicle computes a data-quality score from six factors: data completeness, sensor collaboration, recorded events, adherence to standard data formats, general health, and safe driving patterns §3.4 eq. 2:
DTS_z = w_1 DTC_z + w_2 SRC_z + w_3 E_z + w_4 CSF_z + w_5 GRHL_z + w_6 SFR_z eq. 2
The weights w_1 to w_6 are not stated.
A reputation score is then updated each round with a reward term for the score and a penalty for malicious behaviour eq. 3:
RPS_z(t+1) = RPS_z(t) + \alpha\, DQS_z - \beta\, M_z eq. 3
Here M_z is 0 or 1 §3.4. The values of \alpha and \beta are not stated.
Reputation is normalised across vehicles to give a weight eq. 4:
Wt_z = \frac{RPS_z}{\sum_{m=1}^{n} RPS_m} eq. 4
A vehicle whose reputation falls below a threshold \theta is excluded eq. 7. The value of \theta is not stated. A reward RW_z = \gamma\, RPS_z is described, but \gamma is not given a value §3.4.
Step 3: cloud loop. The cloud sends the current global model to one pending cluster at a time, receives its update, and removes that cluster from the pending set alg. 1 §3.5. Each cluster's update is scored by the mean vehicle score in that cluster eq. 8 §3.5.3:
F_{weight} = \frac{\sum_{v} Sr_v}{|v|} eq. 8
A single-vehicle cluster uses that vehicle's score alone §3.5.3.
# Weighted cloud server cycling model update [alg. 1]
# Input: W_exist (global parameters); C_n (pending clusters)
# Output: final global parameters W_exist
def cloud_update(W_exist, pending_clusters):
# Repeat for each update j [alg. 1]
for update in range(num_updates):
# Snapshot the current global model [alg. 1]
W_minus = W_exist
# Choose one pending cluster; the rule is not stated [§3.5.2]
cluster = select_cluster(pending_clusters)
# Run inner-cluster training and get the fine-tuned model
# and the cluster's mean vehicle score [alg. 1] [alg. 2]
W_plus, score = inner_cluster(cluster, W_minus)
# Weight is the mean vehicle score [eq. 8] [§3.5.3]
weight = score
# The cluster is removed from the pending set [alg. 1]
pending_clusters.remove(cluster)
# Update only if the weight passes a threshold; the
# threshold and the merge rule are not stated [§3.5.3]
if weight >= threshold:
W_exist = merge_global(W_exist, W_plus, weight)
return W_existStep 4: inner-cluster training. The base station passes the global model to the head vehicle. The head collects updates from its successors, merges them, fine-tunes on its own data, and returns the result with the cluster score alg. 2 §3.6.1 §3.6.2. Route vehicles do the same for their successors and pass the result back to their predecessor. Edge vehicles fine-tune only and return alg. 2 §3.6.3 §3.6.4.
# Inner-cluster HFTL, roles per vehicle [alg. 2]
# Input: W_minus (parameters from the base station)
# Output: W_plus (fine-tuned parameters) and cluster score
def inner_cluster(cluster, W_minus):
# The base station gives the model to the head [alg. 2 (I)]
head_model, head_score = chain_update(cluster.head, W_minus)
return head_model, head_score
def chain_update(vehicle, incoming):
# Edge vehicle: no successors, fine-tune and return [§3.6.4]
if not vehicle.successors:
model = fine_tune(incoming, vehicle.local_data)
return model, vehicle.score
# Head or route vehicle: merge each successor's result [§3.6.2] [§3.6.3]
merged = incoming
for successor in vehicle.successors:
child_model, child_score = chain_update(successor, merged)
# Merge rule is not stated; inputs are data quantity and score
merged = combine(merged, child_model,
successor.data_quantity, child_score)
# Fine-tune on the vehicle's own data [alg. 2 (II)] [alg. 2 (III)]
model = fine_tune(merged, vehicle.local_data)
return model, vehicle.scoreThe paper describes the combine step as weighted by the amount of data and the quality score §3.6.2. The exact formula and the fine-tuning procedure are not stated.
Hyperparameters
| Name | Value | Where | Notes |
|---|---|---|---|
| clusters | 12 | §4.1.2 | one cluster per random topology |
| vehicles per cluster | "more than a random ten" | §4.1.2 | exact counts not stated |
| epochs | 200 | §4.1.4 | stated for HFTL and all baselines |
| learning rate | 0.1 | §4.1.4 | stated for HFTL and all baselines; fine-tuning rate not stated |
| batch size | 128 | §4.1.4 | stated for HFTL and all baselines |
| train / test split | 80 % / 20 % | §4.1.3 | |
| cross-validation folds | not stated | §4.1.3 | cross-validation said to be used |
| feature scaling | standard scaler | §4.1.3 | fitted on which split not stated |
| outlier handling | replace with extreme values | §4.1.3 | threshold not stated |
| missing data | interpolation | §4.1.3 | method not stated |
| simulation runs | 100 | §4.1.6 | averaged results |
| trust weights w_1 to w_6 | not stated | eq. 2 | |
| \alpha, \beta, \gamma, \theta | not stated | eq. 3 eq. 7 §3.4 | |
| merge threshold for cluster weight | not stated | §3.5.3 | |
| number of cloud updates j | not stated | alg. 1 | |
| pre-trained model source | not stated | §3.1 | |
| model architecture, optimizer, loss | not stated | §4.1.1 | framework named as Torch |
| hardware | not stated | §4.1.1 | Google Colab named |
| scalability vehicle counts | not stated | §4.1.7 | "gradually increase" only |
Results
Author-reported. Setup: 12 random topologies generated with NetworkX, vehicles assigned by type §4.1.1 §4.1.2 fig. 3. Data: a vehicle mobility trace §4.1.3. Baselines: three comparison methods, abbreviated CL, FL and CFL §4.1.4. Metrics are averages over 100 simulations §4.1.6.
Table 3, average performance on the main setting tab. 3:
| Algorithm | Model accuracy | Train time (s) | Resource use (%) | Comm. overhead (messages) | Latency (s) | Convergence time (s) | Throughput (messages) |
|---|---|---|---|---|---|---|---|
| Centralized Learning | 0.708 | 2.03 | 20.19 | 6.19 | 2.323 | 0.23 | 6.20 |
| Federated Learning | 0.721 | 1.53 | 15.65 | 6.25 | 2.314 | 0.12 | 6.23 |
| Clustered Federated Learning | 0.752 | 1.46 | 14.96 | 6.21 | 2.304 | 0.08 | 6.24 |
| Federated Transfer Learning (HFTL) | 0.822 | 1.02 | 8.30 | 6.28 | 2.240 | 0.04 | 6.35 |
Table 4, average scalability results tab. 4:
| Algorithm | Model accuracy | Train time (s) | Resource use (%) | Comm. overhead (messages) | Latency (s) | Convergence time (s) | Throughput (messages) |
|---|---|---|---|---|---|---|---|
| Centralized Learning | 0.682 | 6.01 | 54.06 | 6.77 | 2.47 | 45.82 | 6.79 |
| Federated Learning | 0.689 | 6.07 | 54.73 | 6.82 | 2.46 | 45.72 | 6.81 |
| Clustered Federated Learning | 0.68 | 5.96 | 53.61 | 6.81 | 2.45 | 45.46 | 6.84 |
| Federated Transfer Learning (HFTL) | 0.823 | 2.78 | 25.87 | 6.90 | 2.42 | 29.29 | 6.91 |
Headline claims: HFTL has the highest accuracy, lowest training time and resource use, and the lowest latency and convergence time in the main setting §4.1.6 tab. 3. It has slightly higher communication overhead than the three baselines §4.1.6 tab. 3. Figures 4 to 7 show the performance and scalability results as graphs and bar charts fig. 4 fig. 5 fig. 6 fig. 7; their values were not extracted for this card. The paper's text attributes the gains to pre-trained fine-tuning §4.1.6.
Paper vs code
No official code. The paper names no code repository or project page, and the arXiv metadata has no code link. GitHub repository searches for "HFTL", "hierarchical federated transfer learning vehicular", and "zia digital twin vehicular" returned no repository that belonged to the authors. The paper names NetworkX and PyTorch and Google Colab §4.1.1, but publishes no code, so the merge rule, fine-tuning procedure and trust parameters cannot be checked against an implementation.
Pitfalls
- Merge rule is missing. Algorithm 1 computes the cluster weight and then says "Update W_{exist}" with no formula alg. 1. The text says the global model is updated only when the weight passes a threshold, and the threshold is not stated §3.5.3. The merge formula, the algorithm box (unconditional) and the text (conditional) disagree. Choose a rule, say so, and report it.
- Two weighting schemes. Reputation weights eq. 4 §3.4, data-quantity and score weights in the inner merge alg. 2 §3.6.2, and the cluster weight eq. 8 are three different weights. The paper does not say which one governs the global update.
- Cluster selection and update count. The rule for choosing the next cluster §3.5.2 and the number of updates j are not stated. Algorithm 1 also removes each cluster once it has been used, so the number of updates depends on |C_n| alg. 1 §3.5.2.
- Fine-tuning is undefined. The
Fine_Tunstep in Algorithm 2 has no specified epochs, optimizer, learning rate or frozen layers alg. 2. The 200 epochs and learning rate 0.1 are stated for all methods §4.1.4; whether fine-tuning uses the same values is not stated. - Algorithm 2 notation is inconsistent. It mixes w^- and w^+ on the same variable, assigns a fine-tuned value to a minus-labelled variable, updates DtQ_r without defining it, and uses Data_{ev} without defining it alg. 2.
- Equation 1 is malformed. The outer sum index j is unused, the expression sums over vehicles where the text says it describes clusters, and the set notation is incomplete eq. 1 §3.1.
- Symbols drift between equations. The data-quality score is DTS in eq. 2 and DQS in eq. 3. The reputation difference uses RS_z in eq. 5 and RPS_z elsewhere. The normalised weight is written Wt_z and then WT_z eq. 4. Read these as the same quantities, and say so.
- Trust parameters are not given. The six weights, \alpha, \beta, \gamma, \theta and the merge threshold are all not stated eq. 2 eq. 3 eq. 7 §3.5.3. Any implementation must pick values and report them as its own choices.
- The pre-trained model is unspecified. The source data, architecture and training recipe for the pre-trained models are not described §3.1. The baselines are trained from scratch §4.1.6. The reported gain therefore mixes the effect of pre-training with the effect of clustering and the hierarchy. The paper contains no ablation that separates them.
- Accuracy and convergence are undefined. The paper does not say what the model predicts or how accuracy is computed for the vehicle trace §4.1.5. The table footnote calls accuracy a percentage, but the values are fractions (0.822 = 82.2 %) tab. 3. Convergence time is defined as reaching 90 % accuracy §4.1.5, yet the reported average accuracies are below that level tab. 3. The criterion behind the convergence column is therefore unclear.
- Small gaps, no spread. The text calls HFTL's latency lower §4.1.6. The difference from the baselines is about 3 to 4 % (2.240 s against 2.304 to 2.323 s) tab. 3. No standard deviation or confidence interval is reported over the 100 runs.
- Overhead is higher. HFTL's communication overhead is higher in both settings (6.28 against 6.19 to 6.25 in Table 3, and 6.90 against 6.77 to 6.82 in Table 4) tab. 3 tab. 4. The paper calls this slight. The authors' own explanation is that fine-tuning a pre-trained model needs more exchanges §4.1.6.
- Data pipeline is unclear. The paper calls the vehicle mobility trace real-world data §4.1.3, but the topologies are randomly generated §4.1.2. It does not say how trace rows map to vehicles, clusters and vehicle types. Outlier and interpolation methods, and the number of cross-validation folds, are not stated §4.1.3.
- Cluster sizes are vague. "More than a random ten" vehicles per cluster §4.1.2 does not give a range or distribution.
- Malicious-vehicle protection is not tested. The abstract, the introduction and Section 3.4 claim the global model is protected from malicious vehicles. The experiments contain no attack or malicious-vehicle scenario §4. Treat this as untested.
- Blockchain is not implemented. The design places the trust scores and rewards on a blockchain §3.3 §3.4. The evaluation measures no blockchain component, and the conclusion lists lightweight blockchain implementation as future work §6.
- Scalability settings are missing. The vehicle counts and step sizes are not stated §4.1.7. The paper itself says communication overhead grows with the number of vehicles and may limit scaling §4.1.7.
- Partial clusters are dropped. Clusters that do not contain the expected head, route and edge roles are discarded §3.6, Assumption 1. How often this happens, and how much data it removes, is not reported.
- Hardware and runtime context are missing. Only "Google Colab" is named §4.1.1. The reported training and latency numbers therefore cannot be compared with other hardware.
Lineage
- Builds on: HaghighiFard and Coleri, arXiv:2401.10361, for the idea of splitting each cluster into a head and members §3.6 and the hierarchical VANET design §2.1.
- Compared against: the three baselines in the results, CL, FL and CFL §4.1.4 tab. 3. The paper cites Liu et al. (2020) and Otoum et al. (2022) as related federated transfer work §2.2.
- Superseded by: not stated.
Source and license
Adapted from “Hierarchical Federated Transfer Learning in Digital Twin-Based Vehicular Networks” by Qasim Zia, Saide Zhu, Haoxin Wang, Zafar Iqbal, Yingshu Li (arXiv:2608.11532), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors.