Paper deep dive
Hierarchical Multi-Task Federated Learning in VANETs
M. Saeid HaghighiFard, Sinem Coleri
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%
Last extracted: 8/11/2026, 5:14:59 AM
Summary
The paper proposes AERO-HMTFL, a hierarchical multi-task federated learning framework for Vehicular Ad hoc Networks (VANETs) that addresses non-IID data, high mobility, and intermittent connectivity. It utilizes a split-model architecture with shared autoencoders and local task-specific heads, employing a tri-weighted clustering metric (mobility, model similarity, task affinity) and reliability-aware aggregation at cluster heads and the Evolved Packet Core (EPC). Simulations show significant improvements in accuracy and communication efficiency over benchmarks.
Entities (8)
Relation Signals (7)
AERO-HMTFL → appliesto → VANETs
confidence 98% · proposes an AutoEncoder-based Reliability-Optimized Hierarchical Multi-Task Federated Learning (AERO-HMTFL) framework for dynamic multi-hop clustered VANETs
AERO-HMTFL → uses → Autoencoder
confidence 95% · Each vehicle employs a split-model architecture comprising a shared autoencoder-based representation module
Evolved Packet Core → performs → global shared-autoencoder fusion
confidence 90% · the Evolved Packet Core (EPC) conducts global shared-autoencoder fusion across clusters
AERO-HMTFL → utilizes → Tri-weighted clustering metric
confidence 90% · The proposed framework introduces a tri-weighted clustering metric that jointly considers vehicular mobility, shared-model similarity, and task affinity
Cluster Head → performs → reliability-aware aggregation
confidence 88% · cluster heads perform reliability-aware aggregation based on historical validation performance and participation frequency
AERO-HMTFL → improves → EPC-level accuracy
confidence 85% · AERO-HMTFL achieves up to 13% higher sustained EPC-level accuracy
AERO-HMTFL → reduces → packet transmissions
confidence 85% · reduces EPC-level packet transmissions by approximately 87-97%
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Vehicular Ad hoc Networks (VANETs) increasingly rely on federated learning (FL) to enable collaborative intelligence without sharing raw sensory data. However, most existing vehicular FL frameworks assume that all vehicles train a single global model for a common task, which limits their applicability in practical vehicular environments where vehicles may perform heterogeneous learning tasks under non-independent and identically distributed (non-IID) data, intermittent connectivity, and high mobility. To address these challenges, this paper proposes an AutoEncoder-based Reliability-Optimized Hierarchical Multi-Task Federated Learning (AERO-HMTFL) framework for dynamic multi-hop clustered VANETs. The proposed framework introduces a tri-weighted clustering metric that jointly considers vehicular mobility, shared-model similarity, and task affinity to produce mobility-stable, semantically aligned clusters. Each vehicle employs a split-model architecture comprising a shared autoencoder-based representation module and multiple task-specific heads, with only the shared autoencoder parameters exchanged while the task heads remain local. To improve robustness, cluster heads perform reliability-aware aggregation based on historical validation performance and participation frequency, while the Evolved Packet Core (EPC) conducts global shared-autoencoder fusion across clusters. Extensive simulations demonstrate that, compared with the multi-task federated learning benchmarks, AERO-HMTFL achieves up to 13% higher sustained EPC-level accuracy, exhibits more stable learning dynamics, and reduces EPC-level packet transmissions by approximately 87-97%. Under short-range connectivity, it also requires approximately 13-29% fewer communication rounds to converge.
Tags
Links
- Source: https://arxiv.org/abs/2608.08111v1
- Canonical: https://arxiv.org/abs/2608.08111v1
Trouble viewing inline? Open PDF directly →
Full Text
78,865 characters extracted from source content.
Expand or collapse full text
Hierarchical Multi-Task Federated Learning in VANETs M. Saeid HaghighiFard, and Sinem Coleri M. Saeid Haghighifard and Sinem Coleri are with the Department of Electrical and Electronics Engineering, Koc University, Istanbul, Turkey, email: mhaghighifard21, scoleri@ku.edu.tr. This work is supported by the Scientific and Technological Research Council of Turkey, Grant number 119C058, and Ford Otosan. Abstract Vehicular Ad hoc Networks (VANETs) increasingly rely on federated learning (FL) to enable collaborative intelligence without sharing raw sensory data. However, most existing vehicular FL frameworks assume that all vehicles train a single global model for a common task, which limits their applicability in practical vehicular environments where vehicles may perform heterogeneous learning tasks under non-independent and identically distributed (non-IID) data, intermittent connectivity, and high mobility. To address these challenges, this paper proposes an AutoEncoder-based Reliability-Optimized Hierarchical Multi-Task Federated Learning (AERO-HMTFL) framework for dynamic multi-hop clustered VANETs. The proposed framework introduces a tri-weighted clustering metric that jointly considers vehicular mobility, shared-model similarity, and task affinity to produce mobility-stable, semantically aligned clusters. Each vehicle employs a split-model architecture comprising a shared autoencoder-based representation module and multiple task-specific heads, with only the shared autoencoder parameters exchanged while the task heads remain local. To improve robustness, cluster heads perform reliability-aware aggregation based on historical validation performance and participation frequency, while the Evolved Packet Core (EPC) conducts global shared-autoencoder fusion across clusters. Extensive simulations demonstrate that, compared with the multi-task federated learning benchmarks, AERO-HMTFL achieves up to 13% higher sustained EPC-level accuracy, exhibits more stable learning dynamics, and reduces EPC-level packet transmissions by approximately 87-97%. Under short-range connectivity, it also requires approximately 13-29% fewer communication rounds to converge. I Introduction Vehicular Ad hoc Networks (VANETs) increasingly rely on machine learning (ML) to support safety- and mobility-critical services, including object detection, trajectory prediction, traffic-flow estimation, and driving-scene understanding. These services exploit the rich sensory information generated by onboard cameras, LiDAR, radar, and other vehicular sensing systems [32]. Conventional centralized learning requires vehicles to transmit their locally generated data to a central server, which raises substantial concerns regarding raw-data exposure, communication overhead, and scalability. Federated learning (FL) has emerged as a promising alternative in which vehicles train models locally and exchange model parameters or updates instead of raw data. By retaining raw observations at the vehicles, FL limits their direct exposure and supports distributed learning across mobile edge and vehicular environments [16, 21, 9, 8]. However, most conventional FL methods assume that all participating clients optimize a single shared model for a common learning objective. This assumption is restrictive in practical VANETs, where vehicles may perform heterogeneous but related sensing and learning tasks. These tasks may differ in their input modalities, label spaces, data distributions, and optimization objectives [32, 28, 4]. Forcing heterogeneous objectives into a single global model can therefore be ineffective because incompatible output spaces, conflicting gradients, and task-dependent feature requirements may interfere during aggregation, degrading task-specific performance. I-A Related Work Multi-task federated learning (MTFL) replaces the single-global-model assumption with coordinated learning among heterogeneous but related tasks [27, 19, 15, 31]. Existing MTFL methods generally assign a separate model to each client or learning task and exploit relationships among these models during training. The seminal formulation in [27] treats each client as a distinct but related task and jointly optimizes the client models while accounting for communication cost, stragglers, and fault tolerance. The mixture-based method in [19] learns several shared models and constructs a personalized model for each client by weighting them according to how well they represent the client’s local data. Ditto [15] learns a global reference model together with a personalized model for each client. Ditto is applied independently to each learning task and therefore represents personalized federated learning without cross-task collaboration. RHFedMTL [31] considers multiple tasks in a terminal-based station-cloud hierarchy and controls the number of local and intermediate iterations according to the available resource budget. Although these methods support personalized or task-specific learning, they maintain a separate complete model for each task. Consequently, they either coordinate complete task models or train them independently, rather than jointly learning an explicit shared component through which vehicles performing different tasks can exchange transferable knowledge. Recent MTFL methods address this limitation by dividing the learning model into common and task-dependent components and sharing only the components that are compatible across tasks. FedHCA2 [18] aggregates encoder parameters across heterogeneous clients and separately coordinates their task-dependent decoders to address model dissimilarity. FedBone [5] places a general model at the server and retains task-specific models at the clients, while using gradient projection to reduce conflicts among heterogeneous tasks. M-Fed [33] shares encoder-based knowledge among clients performing different tasks and preserves task-dependent components locally. However, these methods assume direct client-server or fixed terminal-edge-cloud coordination. They do not support shared representation learning over a dynamically vehicular environment, where vehicle associations change with mobility and task availability, and model updates may arrive intermittently. Hierarchical federated learning (HFL) alleviates the high communication overhead and central-server bottleneck of flat FL by introducing intermediate aggregation tiers. HiFlash [29] lets edge servers synchronously aggregate updates from nearby clients and asynchronously forward the edge models to the cloud, while controlling stale updates and client-edge associations. ShapeFL [7] selects the nodes that act as edge aggregators and assigns clients to them to reduce communication cost while maintaining diverse data at each aggregator. CPFedAvg [17] removes the single cloud aggregation server and allows multiple upper-tier servers to exchange and mix their model parameters. Heal [30] assigns clients to edge servers and transmits only selected model layers for aggregation. DaWa [23] uses reinforcement learning to select participating clients and determine their aggregation weights according to model accuracy and training cost. Despite employing different mechanisms to improve efficiency, conventional HFL methods generally rely on relatively stable client-edge associations and hierarchically train a single shared model for a common task. They are therefore not designed for dynamic vehicular networks, where mobility continuously changes connectivity and vehicle participation. The vehicular HFL frameworks in [11, 12] enable mobility-aware multi-hop coordination by dynamically organizing vehicles into clusters, aggregating local updates at cluster heads, and forwarding cluster-level models to the edge cloud. However, they assume that all vehicles optimize the same model for a common learning objective and therefore do not support heterogeneous tasks, cross-task knowledge sharing, or task-aware vehicle association. I-B Main Contributions To address these limitations, this paper develops an AutoEncoder-based Reliability-Optimized Hierarchical Multi-Task Federated Learning (AERO-HMTFL) framework for dynamic multi-hop clustered VANETs. The framework enables vehicles with heterogeneous learning objectives to exchange and hierarchically aggregate a shared autoencoder that captures transferable representations, while retaining raw data and task-specific components locally. By integrating task-aware clustering and reliability-weighted aggregation, it supports scalable and robust collaboration under mobility, intermittent connectivity, and time-varying participation. The main contributions of this paper are summarized as follows. • We propose a vehicular HFL that shifts from conventional single-task hierarchical learning to a multi-task architecture that supports heterogeneous learning objectives for vehicles in a privacy-preserving and scalable manner, for the first time in the literature. • We introduce, for the first time, task-related information into vehicle clustering for hierarchical multi-task learning in multi-hop VANETs. Specifically, the proposed tri-weighted metric jointly captures mobility and task-set dissimilarities, allowing vehicles to form clusters that are both mobility-stable and learning-compatible. • We incorporate, for the first time in the literature, reliability-aware hierarchical aggregation into a task-aware MTFL framework for dynamic multi-hop VANETs. The mechanism gives greater influence to vehicles with consistently strong validation performance and regular participation, thereby limiting the influence of unstable, low-quality, or sporadic updates. • We introduce a split-model MTFL architecture tailored to hierarchical multi-hop VANETs. Shared autoencoder parameters are exchanged and hierarchically aggregated, while task-specific components remain local. This is the first framework to combine this architecture with task-aware clustering and reliability-weighted hierarchical aggregation in dynamic multi-hop VANETs. • We validate the effectiveness of the proposed framework through a comprehensive evaluation of task-aware and reliability-guided hierarchical MTFL in dynamic multi-hop VANETs. The results demonstrate consistent improvements in learning performance, convergence, robustness, and communication efficiency over representative MTFL baselines. The remainder of this paper is organized as follows. Section I presents the system model. Section I describes the proposed hierarchical MTFL framework and its operation across vehicles, local aggregators, and the EPC. Section IV provides the convergence analysis. Section V presents the simulation setup and performance evaluation. Section VI concludes the paper. I System Model We consider a dynamic vehicular network comprising vehicles equipped with vehicle-to-vehicle (V2V), vehicle-to-infrastructure (V2I), and vehicle-to-network (V2N) communication interfaces. V2V communication may be supported by IEEE 802.11p [14], IEEE 802.11bd [22], or LTE-based Device-to-Device communication [24], whereas V2I/V2N connectivity is provided through 5G New Radio V2X [3]. Vehicles are organized into dynamic multi-hop clusters, each comprising one Cluster Head (CH) and a set of Cluster Members (CMs). Cluster membership and vehicle roles are updated based on network topology and mobility changes. The clustering procedure employs a tri-weighted association criterion based on relative mobility, similarity between shared encoder parameters, and task affinity derived from the active task sets of neighboring vehicles. This criterion promotes mobility-stable and task-coherent clusters. Each vehicle owns a private non-IID dataset and supports a set of learning tasks. Its local model consists of a shared autoencoder, parameterized by encoder and decoder parameters, and a set of task-specific heads associated with learning tasks. The autoencoder learns a transferable latent representation across vehicles and tasks, while the task-specific heads remain local to preserve personalization and task-specific information. The learning architecture follows a two-level hierarchy. CMs train their local autoencoder and task-specific heads and transmit only the updated autoencoder parameters and the required task and quality information to their CH. Each CH aggregates the received autoencoder updates to construct a cluster-level model. In every communication round, the CHs forward their cluster-level autoencoders to the Evolved Packet Core (EPC), which produces the global shared autoencoder and returns it to the CHs. Each CH then disseminates the received global autoencoder to its associated CMs, which use it to initialize the shared autoencoder in the next learning round. Raw data and task-specific head parameters are not exchanged. Each vehicle maintains a Vehicle Information Base (VIB) containing its cluster role, hop count, mobility information, neighboring-vehicle information, active task set, and local model parameters. CHs additionally maintain participation and model-quality information for their associated CMs. The VIB is updated through vehicle state transitions and periodic “HELLO_PACKET” exchanges, enabling distributed cluster formation and maintenance in the dynamic vehicular network. I Multi-Task Federated Learning (MTFL) in Hierarchical Multi-Hop Clustered VANETs The proposed hierarchical MTFL framework comprises three interacting components: shared-representation learning at the vehicles, task-aware multi-hop cluster formation, and reliability-aware hierarchical aggregation. Vehicles are dynamically organized into multi-hop clusters according to a tri-weighted association metric that jointly considers relative mobility, shared-encoder similarity, and task-set affinity. Within each cluster, every participating CM jointly trains its shared autoencoder and local task-specific heads on its private non-IID data, while only the updated autoencoder parameters, the active task set, and the aggregate validation score are transmitted to the associated CH. The CH evaluates the reliability of the received updates based on historical validation performance and participation frequency, and constructs a reliability-weighted cluster-level autoencoder. In every communication round, the active CHs forward their cluster-level autoencoders to the EPC, where they are fused into a shared global autoencoder and then disseminated back through the hierarchy. I-A Shared Autoencoder and Task-Specific Learning Each participating CM i supports a nonempty set of learning tasks iT_i. Since different tasks may have different inputs and outputs, xi,tx_i,t and yi,ty_i,t denote, respectively, the input and target associated with task t∈it _i. The task-dependent preprocessing used by the corresponding local learner maps each raw sample to the common input representation accepted by the shared autoencoder. The shared autoencoder contains an encoder and a decoder with parameters θienc _i^enc and θidec _i^dec, respectively, while ϕi,tt∈i\ _i,t\_t _i denotes the local task-specific heads [33, 6, 18]. To make the round dependence explicit, let r denote the communication round and s∈0,…,τ−1s∈\0,…,τ-1\ the local SGD-step index. Define the shared-autoencoder parameter block and the local task-head block as θiAE,(r,s)=θienc,(r,s),θidec,(r,s) _i^AE,(r,s)=\ _i^enc,(r,s), _i^dec,(r,s)\ and Φi(r,s)=ϕi,t(r,s)t∈i _i^(r,s)=\ _i,t^(r,s)\_t _i, respectively. For task t, the encoder, decoder, and local task head operate as zi,t(r,s) z_i,t^(r,s) =Enc(xi,t;θienc,(r,s)), =Enc(x_i,t; _i^enc,(r,s)), (1) x^i,t(r,s) x_i,t^(r,s) =Dec(zi,t(r,s);θidec,(r,s)), =Dec(z_i,t^(r,s); _i^dec,(r,s)), (2) y^i,t(r,s) y_i,t^(r,s) =Headt(zi,t(r,s);ϕi,t(r,s)),t∈i. =Head_t(z_i,t^(r,s); _i,t^(r,s)), t _i. (3) For task t, ℓt(y^i,t(r,s),yi,t) _t( y_i,t^(r,s),y_i,t) denotes the task-appropriate prediction loss, and Li,t(r,s)=ℓt(y^i,t(r,s),yi,t).L_i,t^(r,s)= _t( y_i,t^(r,s),y_i,t). (4) Let ξi(r,s) _i^(r,s) denote the collection of mini-batches sampled by CM i at local step s in communication round r. The reconstruction loss is ℓrec(x^i,t(r,s),xi,t) _rec( x_i,t^(r,s),x_i,t), and the local multi-task objective is Li(r,s)(θiAE,(r,s),Φi(r,s);ξi(r,s))=∑t∈i[Li,t(r,s)+μℓrec(x^i,t(r,s),xi,t)], split&L_i^(r,s)\! ( _i^AE,(r,s), _i^(r,s); _i^(r,s) )\\ & = _t _i [L_i,t^(r,s)+μ\, _rec( x_i,t^(r,s),x_i,t) ], split (5) where μ≥0μ≥ 0 controls the contribution of reconstruction learning. With learning rate η>0η>0, and with ∇ϑ _ denoting the gradient with respect to parameter block ϑ , the local SGD updates are θienc,(r,s+1) _i^enc,(r,s+1) ←θienc,(r,s)−η∇θiencLi(r,s), ← _i^enc,(r,s)-η _ _i^encL_i^(r,s), (6) θidec,(r,s+1) _i^dec,(r,s+1) ←θidec,(r,s)−η∇θidecLi(r,s), ← _i^dec,(r,s)-η _ _i^decL_i^(r,s), (7) ϕi,t(r,s+1) _i,t^(r,s+1) ←ϕi,t(r,s)−η∇ϕi,tLi,t(r,s),t∈i. ← _i,t^(r,s)-η _ _i,tL_i,t^(r,s), t _i. (8) After completing the τ local SGD steps in the communication round r, CM i sets θiAE,(r)=θiAE,(r,τ)=θienc,(r,τ),θidec,(r,τ) _i^AE,(r)= _i^AE,(r,τ)= \ _i^enc,(r,τ), _i^dec,(r,τ) \ (9) and evaluates each supported task head on the task-matched portion of the public validation buffer pubD_pub. Let Acci,t(r)Acc_i,t^(r) denote the resulting validation accuracy for task t. The aggregate validation score is qi(r)=∑t∈iωi,tAcci,t(r)∑t∈iωi,t.q_i^(r)= _t _i _i,t\,Acc_i,t^(r) _t _i _i,t. (10) Here, ωi,t=1 _i,t=1 gives equal task weighting, whereas ωi,t=ni,tval _i,t=n_i,t^val gives validation-sample weighting, where ni,tvaln_i,t^val is the number of public validation samples for task t. CM i then transmits (θiAE,(r),qi(r),i) ( _i^AE,(r),q_i^(r),T_i ) to its CH. The raw training data and the task-specific heads remain local. For each CM, the CH maintains a participation-count-weighted historical validation average and the participation frequency: HistAcci(r) _i^(r) =(κi(r)−1)HistAcci(r−1)+qi(r)κi(r), = ( _i^(r)-1)HistAcc_i^(r-1)+q_i^(r) _i^(r), (11) Freqi(r) _i^(r) =κi(r)r, = _i^(r)r, (12) where κi(r) _i^(r) is the number of communication rounds in which CM i has participated up to and including round r, with HistAcci(0)=0HistAcc_i^(0)=0. Its reliability score is then given by Reli(r)=λaccHistAcci(r)+λfreqFreqi(r),λacc+λfreq=1.Rel_i^(r)= _accHistAcc_i^(r)+ _freqFreq_i^(r), _acc+ _freq=1. (13) In communication round r, let C denote the set of participating CMs in the considered cluster. The CH obtains the reliability-normalized weights and the cluster-level autoencoder as wi(r)=Reli(r)∑j∈CRelj(r),θ¯CAE,(r)=∑i∈Cwi(r)θiAE,(r).w_i^(r)= Rel_i^(r) _j∈ CRel_j^(r), θ_C^AE,(r)= _i∈ Cw_i^(r) _i^AE,(r). (14) The CH then forwards the aggregated cluster-level autoencoder θ¯CAE,(r) θ_C^AE,(r) to the EPC. Let rC_r denote the set of active clusters participating in communication round r. The EPC computes the global shared autoencoder as θEPCAE,(r)=1|r|∑C∈rθ¯CAE,(r). _EPC^AE,(r)= 1|C_r| _C _r θ_C^AE,(r). (15) The EPC returns θEPCAE,(r) _EPC^AE,(r) to the active CHs in the same communication round. Each CH then sets θinit,CAE,(r+1)←θEPCAE,(r) _init,C^AE,(r+1)← _EPC^AE,(r) (16) and disseminates this initialization to its associated CMs. Therefore, CM training, CH-level aggregation, and EPC-level aggregation are all indexed by the same communication-round index r, and the resulting global autoencoder initializes the shared autoencoder for communication round r+1r+1. The task-specific heads ϕi,tt∈i\ _i,t\_t _i are neither transmitted nor modified during CH-level or EPC-level aggregation and therefore remain local throughout the hierarchical learning procedure. I-B Task-Aware Multi-Hop Clustering Cluster formation follows the distributed multi-hop clustering procedure introduced in [11]. A vehicle starts in the INITIAL state, constructs its Vehicle Information Base through periodic “HELLO_PACKET” exchanges, and then enters the STATE ELECTION (SE) state. In SE, it first requests an association with a reachable CH and joins the accepting CH with the lowest association cost. If no direct CH is available, it requests association through eligible CMs whose current hop count is below the maximum hop limit and joins the lowest-cost accepted route. If neither a direct nor a multi-hop route is available, the vehicle becomes a CH only when its election cost is lower than that of the neighboring SE vehicles; otherwise, it remains in SE and repeats the decision after its VIB is updated. A CM returns to SE when its connection to its parent CM or CH is not maintained for the prescribed timeout period. A CH evaluates neighboring CHs and merges with a more suitable one by becoming a CM only if that neighboring CH has a lower association cost and accepts the connection request; otherwise, it remains a CH. A CH that remains disconnected from all CMs for the CH timeout also returns to SE. Compared with the mobility- and model-similarity criterion in [11], the association criterion used here additionally incorporates active-task similarity. For vehicles i and j, the tri-weighted association cost is AvgCoSimij=αΔvij+β(1−cos(θienc,θjenc))+γ(1−TaskSimij), splitAvgCoSim_ij&=α\, v_ij\\ & +β (1- \! ( _i^enc, _j^enc ) )\\ & +γ (1-TaskSim_ij ), split (17) where: • Δvij v_ij is the average relative speed between vehicles i and j, capturing their mobility dissimilarity. • cos(θienc,θjenc) (θ^enc_i,θ^enc_j) is the cosine similarity between the shared encoder parameters of vehicles i and j, quantifying their alignment in feature representation learning. Therefore, 1−cos(θienc,θjenc)1- (θ^enc_i,θ^enc_j) represents their shared-encoder dissimilarity. • TaskSimijTaskSim_ij is the task affinity score, computed as the Jaccard similarity between the sets of active tasks: TaskSimij=|i∩j||i∪j|TaskSim_ij= |T_i _j||T_i _j| (18) where iT_i and jT_j are the sets of active tasks supported by vehicles i and j, respectively. Accordingly, 1−TaskSimij1-TaskSim_ij represents the task-set dissimilarity between the two vehicles. • α,βα,β, and γ∈[0,1]γ∈[0,1] are tunable weights with α+β+γ=1α+β+γ=1, enabling flexible balancing between the influence of mobility dissimilarity, shared-encoder dissimilarity, and task-set dissimilarity in cluster formation. A lower value of AvgCoSimijAvgCoSim_ij indicates a more suitable association between vehicles i and j. The balance between these weights can be adjusted according to application requirements: increasing α places greater emphasis on mobility stability by penalizing associations between vehicles with high relative speeds, while a higher γ places greater emphasis on matching learning objectives by penalizing vehicles with dissimilar active task sets, which is beneficial in environments with high task heterogeneity. The shared-encoder dissimilarity term ensures that vehicles grouped together are aligned not only in their mobility behavior but also in the structure of their learned representations, thereby fostering efficient collaborative learning. The inherited clustering procedure is thereby adapted to form clusters that are mobility-stable, representation-aligned, and task-compatible for hierarchical MTFL. I-C Hierarchical Multi-Task Federated Learning Procedure After the clusters are formed and maintained by the task-aware multi-hop clustering mechanism described above, the proposed hierarchical MTFL procedure is executed through Algorithms 1–3. Algorithm 1 is executed independently at each participating CM. At the beginning of communication round r, the CM receives the shared-autoencoder initialization θinit,CMAE,(r) _init,CM^AE,(r) from its associated CH and uses it to initialize its local shared autoencoder θCMAE,(r,0) _CM^AE,(r,0) (Lines 1–2). Since the task-specific heads are not exchanged through the hierarchy, each local head ϕCM,t(r,0) _CM,t^(r,0) is initialized using its locally retained value from the preceding communication round (Line 3). The CM then performs τ local SGD steps on its private non-IID data (Lines 4–12). At each local step s, it samples a mini-batch for every supported task t∈CMt _CM (Lines 4–5). For each supported task, the CM maps the task input xCM,tx_CM,t to the latent representation zCM,tz_CM,t using the shared encoder, reconstructs the input through the shared decoder, and applies the corresponding local task-specific head to obtain the task prediction y^CM,t y_CM,t (Lines 6–9). The task-specific prediction loss LCM,tL_CM,t is then evaluated using the loss function associated with task t (Line 10). After processing all supported tasks, the CM constructs the complete local multi-task objective by summing the task-specific prediction losses and their corresponding reconstruction-loss terms, as given in (5) (Line 11). The shared encoder and decoder are updated using the complete local objective, whereas each task-specific head is updated using only its corresponding task loss, according to (6)–(8) (Line 12). After completing the τ local updates, the CM sets its round-r shared-autoencoder output to θCMAE,(r)=θCMAE,(r,τ) _CM^AE,(r)= _CM^AE,(r,τ) and evaluates all supported task heads on the task-matched portions of the public validation buffer pubD_pub (Line 13). The resulting task-specific validation accuracies AccCM,t(r)Acc_CM,t^(r) are combined into the aggregate validation score qCM(r)q_CM^(r) according to (10) (Line 14). Finally, the CM transmits only (θCMAE,(r),qCM(r),CM) ( _CM^AE,(r),q_CM^(r),T_CM ) to its associated CH (Line 15). The raw local data and the task-specific heads remain at the CM and are not included in the transmitted update. Algorithm 2 is executed at each CH during every communication round. The CH first identifies the set C of CMs that participate in round r and collects their updated shared autoencoders, aggregate validation scores, and active task sets (Lines 1–3). For each participating CM, the CH updates the participation-count-weighted historical validation average using the newly received score qCM(r)q_CM^(r) according to (11) (Lines 4–5). It also updates the participation frequency based on the number of rounds in which that CM has participated, relative to the current round index (Line 6). The CH then combines the historical validation score and participation frequency to compute the reliability score RelCM(r)Rel_CM^(r) using (13) (Line 7). After the reliability scores have been computed for all participating CMs, the CH normalizes them to obtain the aggregation weights wCM(r)w_CM^(r) and performs reliability-weighted aggregation of the received shared-autoencoder parameters to construct the cluster-level autoencoder θ¯CAE,(r) θ_C^AE,(r) according to (14) (Line 8). The CH then sends θ¯CAE,(r) θ_C^AE,(r) to the EPC and receives the global shared autoencoder θEPCAE,(r) _EPC^AE,(r) generated in the same communication round (Line 9). It assigns the received global autoencoder to θinit,CAE,(r+1) _init,C^AE,(r+1) (Line 10) and broadcasts it to all associated CMs for initialization of communication round r+1r+1 (Line 11). The task-specific heads are not involved in the CH-level or EPC-level aggregation and remain local. Algorithm 3 is executed at the EPC during every communication round r. The EPC first collects the cluster-level autoencoders θ¯CAE,(r)C∈r\ θ_C^AE,(r)\_C _r from the active CHs, where rC_r denotes the set of active clusters in round r (Lines 1–2). It then uniformly averages the received cluster-level autoencoders to construct the global shared autoencoder θEPCAE,(r) _EPC^AE,(r) according to (15) (Line 3). Finally, the EPC sends the resulting global autoencoder to every active CH in the same round, and each CH disseminates it to its associated CMs via Algorithm 2 to initialize round r+1r+1 (Line 4). All task-specific heads remain local and unchanged under hierarchical aggregation. 1for each communication round r do 2 Receive θinit,CMAE,(r) _init,CM^AE,(r) from the associated CH and initialize θCMAE,(r,0)←θinit,CMAE,(r) _CM^AE,(r,0)← _init,CM^AE,(r); 3 Initialize ϕCM,t(r,0)←ϕCM,t(r−1,τ) _CM,t^(r,0)← _CM,t^(r-1,τ) for every supported task t∈CMt _CM; 4 for s=0,…,τ−1s=0,…,τ-1 do 5 Sample a mini-batch for every supported task t∈CMt _CM; 6 for each local task t∈CMt _CM do 7 zCM,t=Enc(xCM,t;θCMenc,(r,s))z_CM,t=Enc(x_CM,t; _CM^enc,(r,s)); 8 x^CM,t=Dec(zCM,t;θCMdec,(r,s)) x_CM,t=Dec(z_CM,t; _CM^dec,(r,s)); 9 y^CM,t=Headt(zCM,t;ϕCM,t(r,s)) y_CM,t=Head_t(z_CM,t; _CM,t^(r,s)); 10 LCM,t=ℓt(y^CM,t,yCM,t)L_CM,t= _t( y_CM,t,y_CM,t); 11 12 LCM=∑t∈CM[LCM,t+μℓrec(x^CM,t,xCM,t)]L_CM= _t _CM [L_CM,t+μ _rec( x_CM,t,x_CM,t) ]; 13 Update θCMenc,(r,s+1) _CM^enc,(r,s+1), θCMdec,(r,s+1) _CM^dec,(r,s+1), and ϕCM,t(r,s+1)t∈CM\ _CM,t^(r,s+1)\_t _CM using (6)–(8); 14 15 Set θCMAE,(r)←θCMAE,(r,τ) _CM^AE,(r)← _CM^AE,(r,τ) and evaluate all supported heads on the task-matched portions of pubD_pub; 16 Compute AccCM,t(r)Acc_CM,t^(r) and qCM(r)q_CM^(r) using (10); 17 Send (θCMAE,(r),qCM(r),CM) ( _CM^AE,(r),q_CM^(r),T_CM ) to the CH; 18 Algorithm 1 Local Training and Validation at Cluster Member (CM) with Shared Autoencoder 1for each communication round r do 2 Let C denote the set of participating CMs in the cluster during round r; 3 Collect (θCMAE,(r),qCM(r),CM) ( _CM^AE,(r),q_CM^(r),T_CM ) from every CM∈CCM∈ C; 4 for each participating CM∈CCM∈ C do 5 Update HistAccCM(r)HistAcc_CM^(r) using (11); 6 Update FreqCM(r)←κCM(r)/rFreq_CM^(r)← _CM^(r)/r; 7 Compute RelCM(r)Rel_CM^(r) using (13); 8 9 Compute wCM(r)w_CM^(r) and θ¯CAE,(r) θ_C^AE,(r) using (14); 10 Send θ¯CAE,(r) θ_C^AE,(r) to the EPC and receive θEPCAE,(r) _EPC^AE,(r); 11 θinit,CAE,(r+1)←θEPCAE,(r) _init,C^AE,(r+1)← _EPC^AE,(r); 12 Broadcast θinit,CAE,(r+1) _init,C^AE,(r+1) to all associated CMs; 13 Algorithm 2 Reliability-Weighted Aggregation at Cluster Head (CH) 1for each communication round r do 2 Collect θ¯CAE,(r)C∈r\ θ_C^AE,(r)\_C _r from all active CHs; 3 Compute θEPCAE,(r)=|r|−1∑C∈rθ¯CAE,(r) _EPC^AE,(r)=|C_r|^-1 _C _r θ_C^AE,(r); 4 Send θEPCAE,(r) _EPC^AE,(r) to every active CH for dissemination to its associated CMs; 5 Algorithm 3 Global Autoencoder Aggregation at EPC IV Convergence Analysis This section studies the convergence of the shared-autoencoder sequence generated at the EPC. In Algorithms 1–3, the same index r=1,2,…r=1,2,… denotes the communication round at the CM, CH, and EPC levels. Let θ(r)θ^(r) denote the shared-autoencoder initialization used by the CMs at the beginning of round r, with θ(1)θ^(1) denoting the initial shared autoencoder. The EPC output generated in round r is denoted by θ(r+1)≡θEPCAE,(r)θ^(r+1)≡ _EPC^AE,(r) and initializes the CMs in round r+1r+1. The active cluster partition is assumed to remain fixed during each communication round, although it may change between rounds. The analysis establishes an ergodic first-order stationarity guarantee for the EPC-level shared-autoencoder sequence. IV-1 Global Objective and Relation to the Local Loss Let Φi=ϕi,tt∈i _i=\ _i,t\_t _i denote the current local task-head block of CM i. In the generic objective and shared-gradient-oracle definitions below, the communication-round index r and local-step index s are omitted only for notational compactness; they are retained for all round- and step-dependent iterates, mini-batches, and aggregation weights. For the complete shared-autoencoder parameter block θ=θenc,θdecθ=\θ^enc,θ^dec\, define Fi(θ)=ξi[Li(θ,Φi;ξi)],F_i(θ)=E_ _i [L_i(θ, _i; _i) ], (19) where Li(θ,Φi;ξi)L_i(θ, _i; _i) is the parameterized local objective in (5). Only θ is the optimization variable in FiF_i; the effect of the concurrently updated local-head block Φi _i is incorporated through the shared-gradient oracle and the assumptions below. Throughout this section, ξiE_ _i denotes expectation over a mini-batch ξi∼i _i _i drawn from CM i’s local data distribution. An unsubscripted E denotes expectation over all algorithmic randomness, including mini-batch sampling, time-varying participation, cluster evolution, and adaptive aggregation weights, whereas [⋅∣ℱr]E[· _r] denotes conditional expectation given the pre-round history ℱrF_r defined below. Define the mini-batch shared-gradient direction as vi(θ;ξi)≜∇θLi(θ,Φi;ξi),v_i(θ; _i) _θL_i(θ, _i; _i), (20) whereas ∇θFi(θ) _θF_i(θ) denotes the exact gradient of FiF_i with respect to the shared-autoencoder parameter block θ. Let N denote the total number of CMs in the vehicular population. For fixed target weights pi≥0p_i≥ 0 satisfying ∑i=1Npi=1 _i=1^Np_i=1, define F(θ)=∑i=1NpiFi(θ).F(θ)= _i=1^Np_iF_i(θ). (21) For any integer R≥1R≥ 1, let R denote the total number of communication rounds considered in the convergence analysis. The objective is to bound 1R∑r=1R[‖∇θF(θ(r))‖2]. 1R _r=1^RE [ \| _θF(θ^(r)) \|^2 ]. (22) IV-2 Equivalent EPC Update At the beginning of communication round r, participating CM i initializes θi(r,0)=θ(r) _i^(r,0)=θ^(r) and performs τ local SGD steps: θi(r,s+1)=θi(r,s)−ηvi(θi(r,s);ξi(r,s)),s=0,…,τ−1. _i^(r,s+1)= _i^(r,s)-η\,v_i\! ( _i^(r,s); _i^(r,s) ), s=0,…,τ-1. (23) Let rC_r denote the set of active clusters in round r, and let wi,C(r)w_i,C^(r) denote the reliability-normalized CH weight of CM i in cluster C. Since all participating CMs are initialized by θ(r)θ^(r), the cluster-level autoencoder is θ¯C(r) θ_C^(r) =∑i∈Cwi,C(r)θi(r,τ) = _i∈ Cw_i,C^(r) _i^(r,τ) =θ(r)−η∑i∈Cwi,C(r)∑s=0τ−1vi(θi(r,s);ξi(r,s)). =θ^(r)-η _i∈ Cw_i,C^(r) _s=0^τ-1v_i\! ( _i^(r,s); _i^(r,s) ). (24) The EPC aggregates the cluster-level autoencoders in the same communication round: θ(r+1)=1|r|∑C∈rθ¯C(r).θ^(r+1)= 1|C_r| _C _r θ_C^(r). (25) For CM i belonging to cluster C, define its effective EPC weight as ai(r)=wi,C(r)|r|,a_i^(r)= w_i,C^(r)|C_r|, (26) and set ai(r)=0a_i^(r)=0 for a nonparticipating CM. Then ai(r)≥0a_i^(r)≥ 0 and ∑i=1Nai(r)=1 _i=1^Na_i^(r)=1. Substitution gives the equivalent EPC update θ(r+1)=θ(r)−ηH(r),θ^(r+1)=θ^(r)-η H^(r), (27) where H(r)=∑i=1Nai(r)∑s=0τ−1vi(θi(r,s);ξi(r,s)).H^(r)= _i=1^Na_i^(r) _s=0^τ-1v_i\! ( _i^(r,s); _i^(r,s) ). (28) IV-3 Assumptions Assumption 1 (Smoothness): Each FiF_i is differentiable and L-smooth: ‖∇θFi(θ)−∇θFi(θ′)‖≤L‖θ−θ′‖. \| _θF_i(θ)- _θF_i(θ ) \|≤ L \|θ-θ \|. (29) Assumption 2 (Stochastic Shared-Gradient Regularity): For some G<∞G<∞, ξi[vi(θ;ξi)∣θ] E_ _i [v_i(θ; _i) θ ] =∇θFi(θ), = _θF_i(θ), (30) ξi[‖vi(θ;ξi)‖2∣θ] E_ _i [ \|v_i(θ; _i) \|^2 θ ] ≤G2. ≤ G^2. Both conditional expectations are taken over the mini-batch draw ξi∼i _i _i with a fixed shared autoencoder parameter θ. Consequently, ‖∇θFi(θ)‖≤G\| _θF_i(θ)\|≤ G. Assumption 3 (Adaptive Aggregate-Noise Regularity): Define H~(r)=∑i=1Nai(r)∑s=0τ−1∇θFi(θi(r,s)). H^(r)= _i=1^Na_i^(r) _s=0^τ-1 _θF_i\! ( _i^(r,s) ). (31) Let ℱrF_r denote the sigma-algebra generated by the initial shared autoencoder and by all cluster states, participation decisions, local task-head states, mini-batch samples, model iterates, validation scores, and reliability quantities from rounds 1,…,r−11,…,r-1, together with the active-cluster and participating-CM sets selected at the beginning of round r. The reliability-weighted stochastic error satisfies [H(r)−H~(r)∣ℱr]=0E [H^(r)- H^(r) _r ]=0 (32) and, for some σagg2<∞ _agg^2<∞, [∥H(r)−[H(r)∣ℱr]∥2|ℱr]≤τσagg2.E [ \|H^(r)-E [H^(r) _r ] \|^2 |F_r ]≤τ _agg^2. (33) This assumption allows the adaptive reliability weights to depend on the current local updates. Assumption 4 (Reliability-Weight Regularity): Define the conditional mean effective weight as a¯i(r)=[ai(r)∣ℱr] a_i^(r)=E [a_i^(r) _r ] (34) and the mismatch between the effective reliability weights and the target objective weights as δr=∑i=1N|a¯i(r)−pi|. _r= _i=1^N | a_i^(r)-p_i |. (35) Assumption 5 (Lower-Bounded Objective): There exists F⋆>−∞F_ >-∞ such that F(θ)≥F⋆,∀θ.F(θ)≥ F_ , ∀θ. (36) IV-4 Auxiliary Bounds Lemma 1 (Local Drift) Under Assumption 2, for every participating CM i, round r, and s∈0,…,τs∈\0,…,τ\, where s=τs=τ denotes the post-update model produced by the final local update at s=τ−1s=τ-1, [‖θi(r,s)−θ(r)‖2]≤η2s2G2≤η2τ2G2.E [ \| _i^(r,s)-θ^(r) \|^2 ]≤η^2s^2G^2≤η^2τ^2G^2. (37) Proof: Summing the first s local updates in (23) gives θi(r,s)−θ(r)=−η∑u=0s−1vi(θi(r,u);ξi(r,u)). _i^(r,s)-θ^(r)=-η _u=0^s-1v_i\! ( _i^(r,u); _i^(r,u) ). (38) Minkowski’s inequality and Assumption 2 yield ([‖θi(r,s)−θ(r)‖2])1/2≤ηsG. (E [ \| _i^(r,s)-θ^(r) \|^2 ] )^1/2≤η sG. (39) Squaring both sides and using s≤τs≤τ proves the result. ∎ Define the conditional mean direction and its error as m(r)=1τ[H(r)∣ℱr],e(r)=m(r)−∇θF(θ(r)).m^(r)= 1τE [H^(r) _r ], e^(r)=m^(r)- _θF(θ^(r)). (40) Lemma 2 (Gradient-Direction Error) Under Assumptions 1–4, [‖e(r)‖2]≤2L2η2τ2G2+2G2δr2.E [ \|e^(r) \|^2 ]≤ 2L^2η^2τ^2G^2+2G^2 _r^2. (41) Proof: Add and subtract ∑ia¯i(r)∇θFi(θ(r)) _i a_i^(r) _θF_i(θ^(r)). By Assumption 1 and (37), the local-drift component is bounded in root mean square by LητGLητ G. By Assumption 2 and the definition of δr _r, the reliability-weight mismatch component is bounded by GδrG _r. Applying ‖u+v‖2≤2‖u‖2+2‖v‖2\|u+v\|^2≤ 2\|u\|^2+2\|v\|^2 proves (41). ∎ IV-5 Main Convergence Result Theorem 1 (Shared-Autoencoder Stationarity Bound) Suppose Assumptions 1–5 hold and ητ≤14L.ητ≤ 14L. (42) Then the EPC iterates generated by (27) satisfy 1R∑r=1R[‖∇θF(θ(r))‖2]≤4(F(θ(1))−F⋆)ητR+6L2η2τ2G2+6G2R∑r=1Rδr2+2Lησagg2. 1R _r=1^RE\! [ \| _θF\! (θ^(r) ) \|^2 ]\\ ≤ 4 (F\! (θ^(1) )-F_ )ητ R+6L^2η^2τ^2G^2\\ + 6G^2R _r=1^R _r^2+2Lη _agg^2. (43) Proof: By the smoothness of F and (27), F(θ(r+1)) F(θ^(r+1)) ≤F(θ(r))−η⟨∇θF(θ(r)),H(r)⟩ ≤ F(θ^(r))-η _θF(θ^(r)),H^(r) +Lη22‖H(r)‖2. + Lη^22 \|H^(r) \|^2. (44) Let h(r)=∇θF(θ(r))h^(r)= _θF(θ^(r)). Conditioning on ℱrF_r gives [H(r)∣ℱr]=τ(h(r)+e(r)).E [H^(r) _r ]=τ (h^(r)+e^(r) ). (45) Assumption 3 and the conditional variance decomposition give [∥H(r)∥2|ℱr] [ \|H^(r) \|^2 |F_r ] ≤2τ2‖h(r)‖2+2τ2‖e(r)‖2 ≤ 2τ^2 \|h^(r) \|^2+2τ^2 \|e^(r) \|^2 +τσagg2. +τ _agg^2. (46) Using ⟨h,h+e⟩≥12‖h‖2−12‖e‖2 h,h+e ≥ 12\|h\|^2- 12\|e\|^2 and ητ≤(4L)−1ητ≤(4L)^-1 yields [F(θ(r+1))] [F(θ^(r+1)) ] ≤[F(θ(r))]−ητ4[‖∇θF(θ(r))‖2] [F(θ^(r)) ]- ητ4E [ \| _θF(θ^(r)) \|^2 ] +3ητ4[‖e(r)‖2]+Lη2τ2σagg2. + 3ητ4E [ \|e^(r) \|^2 ]+ Lη^2τ2 _agg^2. (47) Summing over r=1,…,Rr=1,…,R, applying Assumption 5, and substituting (41) prove (43). ∎ Convergence Remark: Theorem 1 shows that, with a constant learning rate, the EPC-level shared autoencoder approaches a stationary neighborhood of F. The term 6L2η2τ2G26L^2η^2τ^2G^2 represents the local-model drift caused by the τ CM updates performed before CH and EPC aggregation in each communication round. The term 6G2R−1∑r=1Rδr26G^2R^-1 _r=1^R _r^2 represents the mismatch between the adaptive reliability weights and the target objective weights, whereas 2Lησagg22Lη _agg^2 represents aggregate stochastic variation. The exact vanishing of the average squared gradient norm can be established by considering a sequence of constant learning rates ηRR≥1\ _R\_R≥ 1, where ηR _R is the learning rate selected for an execution analyzed over R communication rounds. For fixed τ, if η=ηR→0η= _R→ 0, ηRR→∞ _RR→∞, and 1R∑r=1Rδr2→0, 1R _r=1^R _r^2→ 0, (48) then limR→∞1R∑r=1R[‖∇θF(θ(r))‖2]=0. _R→∞ 1R _r=1^RE [ \| _θF(θ^(r)) \|^2 ]=0. (49) Therefore, as the number of communication rounds grows, the average expected stationarity measure of the EPC-level shared autoencoder vanishes, implying convergence to first-order stationary points of F in the ergodic sense. V Performance Evaluation The simulations evaluate the performance of the proposed AutoEncoder-based Reliability-Optimized Hierarchical Multi-Task Federated Learning (AERO-HMTFL) algorithm against three representative benchmarks. RHFedMTL [31] performs hierarchical multi-task learning without a shared autoencoder by assigning each task to a base station. Vehicles within the corresponding coverage area transmit their task-specific model updates to that base station, which performs task-level aggregation, while the central server coordinates training across the hierarchy. For the personalized FL benchmark, the optimization principle of Ditto [15] is adapted to the underlying structure of the proposed framework. Independent Ditto processes are executed in parallel for the different tasks, with each process learning a task-specific reference model and personalized local models for the vehicles performing that task. The third benchmark is M-Fed [33], an autoencoder-based multi-task federated learning approach that employs an encoder–decoder architecture to facilitate deep feature extraction but does not utilize clustering. All clients participate in a single global aggregation stage without CH-level coordination or mobility-aware grouping. Together, these baselines enable a systematic evaluation of the individual contributions of autoencoder-based feature learning, hierarchical and mobility-aware clustering, and reliability-weighted multi-tier aggregation. V-A Simulation Setup The simulations are implemented in Python, with vehicular mobility traces generated using the Simulation of Urban Mobility (SUMO) [26] and real-time data streaming handled through KAFKA [2]. This integrated setup provides a realistic and dynamically evolving vehicular network environment for federated learning experiments. SUMO accurately models individual driver behaviors, traffic flows, and mobility patterns, while KAFKA streams data packets and model parameters to emulate communication exchanges among vehicles in a distributed network. All federated learning models, including the proposed AERO-HMTFL and the benchmark baselines, are developed using PyTorch, ensuring efficient training, reproducibility, and seamless integration with mobility and communication components [13]. V-B Simulation Environment For communication modeling, IEEE 802.11p is used for vehicle-to-vehicle (V2V) communication, while 5G NR links support vehicle-to-infrastructure (V2I) communication. V2V channels follow the Winner+ B1 propagation model, as described in [25], ensuring realistic characterization of short-range vehicular communication. For V2I communication, the Friis propagation model is used, following [1], which provides accurate path-loss estimation between vehicles and the 5G NR base station. To evaluate learning performance across multiple perception and classification tasks, we employ three widely used datasets, CIFAR-10, GTSRB, and MNIST, each representing a distinct level of complexity and non-IID data characteristics. CIFAR-10 consists of 60,000 RGB images across 10 object categories and serves as a benchmark for general-purpose vision tasks under moderate visual variability. GTSRB contains over 50,000 traffic sign images spanning 43 classes, capturing real-world conditions with variations in illumination, occlusion, and viewpoint, and is well aligned with vehicular perception scenarios. MNIST provides 70,000 handwritten digit images (28×28) representing digits 0–9 and is used as a lightweight baseline to assess classification performance under low computational cost. For the CIFAR-10 and GTSRB tasks, a lightweight convolutional neural network (LightCNN) is employed. The model comprises two convolutional layers (3→ 16 and 16→ 32), batch normalization, ReLU activations, max pooling, global average pooling, dropout, and a fully connected output layer. Training is performed using stochastic gradient descent (SGD) with a learning rate of 0.01 (decayed by 0.95 every 10 communication rounds), momentum of 0.9, and batch sizes of 64 and 128 for training and testing, respectively. For the MNIST task, a linear SGDClassifier is used, trained with an adaptive learning-rate schedule and incremental updates via the partial_fit mechanism for up to 100 iterations. This configuration allows efficient adaptation to client-specific non-IID data streams. Additionally, for the model compression task, a linear autoencoder is employed. The autoencoder consists of encoder and decoder matrices, WencW_enc and WdecW_dec, with a latent dimension not exceeding 256. Training is conducted using SGD with a learning rate of 10−310^-3, minimizing mean squared error (MSE) to learn compact latent representations that support shared feature extraction across heterogeneous tasks. To reproduce the task heterogeneity, each vehicle i is randomly assigned a nonempty subset i⊆MNIST,CIFAR-10,GTSRB,1≤|i|≤3.T_i \MNIST,CIFAR -10,GTSRB \, 1≤|T_i|≤ 3. (50) Accordingly, some vehicles support only one learning task, some support two, and the remaining support all three. For each vehicle, the number of supported tasks is first determined by the adopted random seed, after which the corresponding tasks are sampled without replacement from the three available tasks. This random subset assignment creates task heterogeneity across the vehicular population while still allowing vehicles with partially overlapping task sets to exchange transferable representations through the shared autoencoder. The EPC aggregates only the shared-autoencoder parameters and does not store or aggregate task-specific heads. Therefore, the “EPC accuracy” reported for task t in Figs. 1–4 is an offline task-wise evaluation metric associated with the EPC-generated shared autoencoder, rather than the output of a task classifier located at the EPC. Let t(r)V_t^(r) denote the set of participating CMs that support task t in round r. After the global autoencoder is disseminated, each CM i∈t(r)i _t^(r) combines it with its locally retained task head and evaluates its task-matched test data. The reported value is AccEPC,t(r)=1|t(r)|∑i∈t(r)Acci,t(θEPCAE,(r),ϕi,t(r,τ);i,ttest).Acc_EPC,t^(r)= 1|V_t^(r)| _i _t^(r)Acc_i,t\! ( _EPC^AE,(r), _i,t^(r,τ);D_i,t^test ). (51) This evaluation is performed by the simulation evaluator and does not require transmitting the local task heads to the EPC or introducing additional protocol packets. The performance of AERO-HMTFL and all benchmark methods is evaluated using two primary metrics: model accuracy, which measures predictive performance [10], and convergence behavior, defined as the number of communication rounds required for stabilization. Convergence is declared when the improvement in model accuracy falls below a threshold ϵε for 5 consecutive rounds [20]. V-C Performance Comparison of Proposed Algorithm with Benchmark Algorithms (a) (a) (b) (b) (c) (c) Figure 1: Comparison of EPC accuracy across different tasks in the 20-vehicle scenario, with a 100 m transmission range and single-hop communication links. a) MNIST, b) GTSRB, c) CIFAR-10. (a) (a) (b) (b) (c) (c) Figure 2: Comparison of EPC accuracy across different tasks in the 50-vehicle scenario, with a 100 m transmission range and single-hop communication links. a) MNIST, b) GTSRB, c) CIFAR-10. Figures 1 and 2 present the EPC accuracy trajectories of AERO-HMTFL and the three baselines (RHFedMTL, Ditto, and M-Fed) across communication rounds on MNIST, GTSRB, and CIFAR-10 at two vehicular densities (20 and 50 vehicles). For MNIST, AERO-HMTFL quickly stabilizes in a high-accuracy region and sustains this plateau with limited variance under both densities. By contrast, RHFedMTL, Ditto, and M-Fed exhibit longer-lasting transient behavior and recurrent drops in accuracy. These instabilities reflect their limited ability to control update inconsistency under mobility. RHFedMTL is more affected by representation mismatch across clients, Ditto is sensitive to highly heterogeneous client updates without task-aligned coordination, and M-Fed is vulnerable to unstable clients because it lacks mechanisms to down-weight unreliable contributions. As a result, AERO-HMTFL maintains approximately 5% higher sustained EPC accuracy than the strongest baseline in the denser scenario while remaining noticeably smoother. For GTSRB, the separation is clearer due to the greater perceptual complexity and stronger heterogeneity. RHFedMTL exhibits higher variance before stabilizing. Ditto displays sharper oscillations as client participation changes, and M-Fed suffers from repeated collapses when inconsistent updates propagate into aggregation. In contrast, AERO-HMTFL suppresses these failure modes by jointly reducing feature inconsistency and mitigating unreliable updates through reliability-aware aggregation, resulting in approximately 2% higher sustained accuracy than the best baseline with 20 vehicles and around 12% higher with 50 vehicles. On CIFAR-10, the most challenging dataset, baseline limitations become more apparent because gradient diversity is greater and the cost of unmanaged heterogeneity is higher. RHFedMTL and Ditto intermittently approach competitive accuracy but remain volatile, settling into less stable regimes, while M-Fed continues to experience pronounced drops. AERO-HMTFL remains stable and achieves the highest sustained EPC accuracy, reaching approximately 13% improvement over the strongest baseline at the final plateau across both densities. Overall, the results confirm that AERO-HMTFL provides superior convergence quality and predictive accuracy under short-range, single-hop vehicular communication. The baselines are primarily limited by (i) weaker robustness to representation mismatch (RHFedMTL), (i) higher sensitivity to heterogeneous and time-varying client participation without coordination (Ditto), and (i) susceptibility to unstable updates due to the absence of reliability-aware aggregation (M-Fed), whereas AERO-HMTFL explicitly addresses these issues through latent feature learning, reliability weighting, and hierarchical task-aware coordination. (a) (a) (b) (b) (c) (c) Figure 3: Comparison of EPC accuracy across different tasks in the 20-vehicle scenario, with a 500 m transmission range and single-hop communication link. a) MNIST, b) GTSRB, c) CIFAR-10. Figure 3 evaluates the EPC accuracy of AERO-HMTFL against RHFedMTL, Ditto, and M-Fed in the 20-vehicle scenario when the transmission range is increased to 500 m under single-hop communication. In shorter-range settings, the wider coverage yields a denser, less fragmented communication graph, enabling more vehicles to participate consistently in each aggregation step. In MNIST, all methods operate in a high-accuracy regime, but AERO-HMTFL exhibits the tightest late-round variance. Ditto and M-Fed still experience intermittent drops during the transient phase, as expected, because denser connectivity also increases exposure to heterogeneous client updates, and methods without reliability control remain sensitive to inconsistent gradients. Consequently, AERO-HMTFL maintains a modest yet consistent advantage, achieving roughly 5–8% higher sustained accuracy than the weakest baseline. For GTSRB, the separation is more pronounced. AERO-HMTFL sustains the highest stable accuracy band, while RHFedMTL settles lower, and Ditto and M-Fed remain noticeably more oscillatory. The stronger gains on GTSRB are consistent with the task’s higher heterogeneity and perception complexity, where dense neighborhoods help only if the aggregation mechanism can suppress unreliable updates. In the final regime, AERO-HMTFL is about 8–12% higher than RHFedMTL and can exceed 25% over M-Fed. On CIFAR-10, AERO-HMTFL again achieves the most stable and highest sustained EPC accuracy. Although RHFedMTL and Ditto occasionally approach similar levels, they remain more variable and typically plateau below AERO-HMTFL, while M-Fed exhibits larger fluctuations. This is consistent with CIFAR-10’s higher gradient diversity, where reliability-aware hierarchical aggregation is critical to dampen oscillations. In late rounds, AERO-HMTFL attains roughly 10–15% higher sustained accuracy than M-Fed. Overall, Figure 3 indicates that increasing the range to 500 m improves connectivity and reduces fragmentation. However, AERO-HMTFL benefits the most, as denser neighborhoods enhance reliability estimation and stabilize hierarchical aggregation, resulting in consistently higher EPC accuracy and smoother convergence behavior across MNIST, GTSRB, and CIFAR-10. (a) (a) (b) (b) (c) (c) Figure 4: Comparison of EPC accuracy across different tasks in the 20-vehicle scenario, with a 100 m transmission range for different numbers of hops. a) MNIST, b) GTSRB, c) CIFAR-10. Figure 4 compares EPC accuracy across MNIST, GTSRB, and CIFAR-10 in the 20-vehicle scenario with a 100 m transmission range, while varying the maximum hop count for AERO-HMTFL (Hop = 1, 2, 3) and benchmarking against RHFedMTL, Ditto, and M-Fed. Increasing the hop limit expands the effective neighborhood and reduces short-range fragmentation, thereby typically improving information flow and stabilizing the aggregation process. However, overly large hop counts can also spread heterogeneous updates across a wider portion of the network, increasing gradient variance and inducing additional oscillations. For MNIST, AERO-HMTFL with Hop = 2 achieves the highest and most stable accuracy plateau. Hop = 1 and Hop = 3 remain competitive but exhibit slightly larger fluctuations, which is consistent with the trade-off between connectivity and heterogeneity. Hop = 1 provides limited mixing for links under 100 m, while Hop = 3 broadens mixing enough to introduce stronger update inconsistencies. The baselines show deeper oscillations and lower sustained accuracy, indicating higher sensitivity to non-IID updates. In particular, RHFedMTL remains affected by residual feature mismatch; Ditto is more sensitive to heterogeneous and time-varying participation; and M-Fed exhibits greater instability due to the lack of mechanisms for hierarchical clustering and for suppressing unreliable updates. For GTSRB, the benefit of multi-hop connectivity is more pronounced due to higher task heterogeneity. AERO-HMTFL achieves the cleanest stabilization, especially with Hop = 2, since multi-hop communication improves the representativeness of aggregation by connecting vehicles that would otherwise remain isolated at 100 m under single-hop communication. Hop = 1 shows slower, noisier improvement, consistent with a limited neighborhood size, whereas Hop = 3 can introduce additional variance by propagating mismatched updates across broader neighborhoods. The baselines remain more oscillatory, with M-Fed showing particularly unstable behavior, reflecting its vulnerability to inconsistent gradients under heterogeneous perception data, and Ditto exhibiting pronounced fluctuations due to uncontrolled mixing of diverse client updates. On CIFAR-10, AERO-HMTFL again achieves the highest sustained EPC accuracy and the most stable late-round regime with Hop = 2. Hop = 1 tends to be constrained by reduced mixing, whereas Hop = 3 can amplify the propagation of heterogeneity, which is more costly for CIFAR-10 due to its higher gradient diversity. RHFedMTL, Ditto, and M-Fed remain below AERO-HMTFL in sustained accuracy and exhibit larger fluctuations, consistent with their weaker ability to control mobility and address update inconsistency under complex vision tasks. Overall, Figure 4 shows that expanding connectivity via multi-hop communication can improve stability in short-range links, provided the hop count is carefully chosen. Hop = 2 consistently provides the best balance between improved neighborhood coverage and controlled heterogeneity propagation. This aligns with the design of AERO-HMTFL, where reliability-aware aggregation and hierarchical coordination benefit from richer connectivity, while excessive propagation can introduce additional variance. TABLE I: Convergence time (in communication rounds) as a function of the number of vehicles and transmission ranges for different datasets and algorithms within the first 200 communication rounds, assuming single-hop connectivity. Scenario Algorithm MNIST GTSRB CIFAR-10 20 Vehicles Tx = 100 m AERO-HMTFL 138 141 141 RHFedMTL 164 164 163 Ditto 174 174 174 M-Fed 194 184 184 50 Vehicles Tx = 100 m AERO-HMTFL 142 142 154 RHFedMTL 185 185 180 Ditto 189 195 188 M-Fed N/A N/A 195 20 Vehicles Tx = 500 m AERO-HMTFL 174 179 184 RHFedMTL 162 171 167 Ditto 178 174 181 M-Fed N/A 189 N/A Table I summarizes the convergence time (in communication rounds) as a function of the number of vehicles and transmission ranges for single-hop connectivity on MNIST, GTSRB, and CIFAR-10. Across all datasets and both densities, AERO-HMTFL consistently converges faster than RHFedMTL and Ditto, and it is also more reliable than M-Fed, which fails to converge in some dense settings. With 20 vehicles, AERO-HMTFL converges approximately 13–16% fewer rounds than RHFedMTL and 19–21% fewer rounds than Ditto, depending on the dataset. Compared to M-Fed, AERO-HMTFL reduces the convergence time by roughly 23–29%, indicating substantially more stable learning under short-range, mobility-affected participation. With 50 vehicles, the performance gap widens. AERO-HMTFL converges in about 14–23% fewer rounds than RHFedMTL and 18–27% fewer rounds than Ditto. Notably, M-Fed does not converge within the first 200 rounds for MNIST and GTSRB, highlighting its sensitivity to increased heterogeneity and mobility when learning is performed without hierarchical coordination and reliability-aware suppression of unstable updates. Overall, Table I confirms that AERO-HMTFL maintains superior scalability as the number of vehicles increases from 20 to 50 across different transmission ranges; its convergence time increases only marginally, whereas the baselines degrade more noticeably, and M-Fed may fail to converge. Although AERO-HMTFL does not achieve the minimum convergence time at Tx = 500 m, its behavior is consistent with the accuracy trajectories observed in Fig. 3. In the 500 m regime, the communication graph becomes significantly denser and less fragmented, so the main bottleneck shifts from connectivity limitations to heterogeneity management. As a result, RHFedMTL can satisfy the convergence criterion earlier by stabilizing at a plateau under dense participation, thanks to base-station aggregation. However, Fig. 3 indicates that this earlier stabilization does not necessarily correspond to the best sustained accuracy or the most stable late-round dynamics. Dense single-hop connectivity diminishes the relative advantage of communication-aware coordination in terms of speed, allowing RHFedMTL to stabilize faster, whereas AERO-HMTFL prioritizes robustness and sustained predictive performance. This explains why AERO-HMTFL remains near the best convergence times while delivering improvements in stability and accuracy. TABLE I: Convergence time (in communication rounds) for different numbers of hops and different datasets within the first 200 communication rounds, assuming 20 vehicles with 100 m transmission range. Scenario Algorithm MNIST GTSRB CIFAR-10 20 Vehicles Tx = 100 m AERO-HMTFL with Hop = 1 161 176 159 AERO-HMTFL with Hop = 2 131 128 124 AERO-HMTFL with Hop = 3 150 149 151 RHFedMTL 161 168 179 Ditto 171 174 171 M-Fed N/A 188 N/A Table I compares convergence time within the first 200 rounds for different hop limits under Tx = 100 with 20 vehicles across MNIST, GTSRB, and CIFAR-10. The best configuration is consistently AERO-HMTFL with Hop = 2, which converges fastest on all datasets. Relative to Hop = 1, Hop = 2 reduces convergence time by 18.6% (MNIST), 27.3% (GTSRB), and 22.0% (CIFAR-10). It also outperforms Hop = 3 by 12.7%, 14.1%, and 17.9%, respectively. Compared with RHFedMTL and Ditto, Hop = 2 improves convergence by roughly 19–31% and 23–28%, respectively, while M-Fed fails to converge for MNIST and CIFAR-10 within 200 rounds. Figure 5: Cellular packet overhead as a function of the number of vehicles Figure 5 shows cellular packet overhead measured as the total number of packets sent to the EPC as a function of the number of vehicles at a transmission range of 100 m. Two key observations arise. First, Ditto and RHFedMTL incur the highest overhead and scale almost linearly with the network size. Both methods rely on frequent client-level transmissions without effective mobility-aware communication localization. Second, M-Fed exhibits lower overhead than Ditto and RHFedMTL, as expected, since autoencoder-based latent representations can reduce the update footprint. However, M-Fed still requires substantially more packets than AERO-HMTFL as the system scales because it lacks clustering and hierarchical coordination to localize aggregation. Across all vehicle densities, AERO-HMTFL achieves the lowest packet count and the best scalability. At 50 vehicles, AERO-HMTFL reduces packet transmissions by approximately 87-97% relative to Ditto/RHFedMTL, depending on the hop setting (about 3.8×1033.8× 10^3, 2.2×1032.2× 10^3, and 1.0×1031.0× 10^3 packets for Hop = 1, 2, and 3, respectively). This reduction directly follows from addressing the baseline limitations: hierarchical, task-aware coordination localizes aggregation and limits redundant network-wide exchanges. VI Conclusion This paper proposed AERO-HMTFL, an AutoEncoder-based Reliability-Optimized Hierarchical Multi-Task Federated Learning framework for dynamic multi-hop clustered VANETs. Unlike conventional vehicular HFL methods that assume a single common task, AERO-HMTFL enables vehicles with heterogeneous learning objectives to collaborate through a shared autoencoder-based representation while retaining task-specific heads locally. The framework integrates task-aware multi-hop clustering, split-model representation sharing, reliability-aware aggregation, and hierarchical coordination to support scalable and privacy-preserving multi-task learning under mobility, intermittent connectivity, and time-varying participation. By incorporating task affinity into the clustering criterion, the proposed method promotes both mobility stability and semantic alignment among collaborating vehicles. Moreover, exchanging only shared autoencoder parameters, task identifiers, and aggregate validation scores preserves raw-data and task-model privacy, while reliability-based weighting limits the influence of unstable or low-quality updates. Simulation results demonstrate that AERO-HMTFL outperforms RHFedMTL, Ditto, and M-Fed in convergence speed, learning stability, accuracy, and communication efficiency. Across the evaluated scenarios, it reduces convergence time by up to approximately 29% and communication overhead by about 87-97% in dense settings. The multi-hop analysis further indicates that controlled connectivity is essential, with the two-hop configuration providing the most effective balance between information exchange and heterogeneity propagation. Overall, AERO-HMTFL provides an integrated learning architecture that jointly addresses task heterogeneity, mobility, communication constraints, and update reliability in VANETs. Future work will consider more complex perception tasks, multimodal sensor data, adaptive task scheduling, and security-aware aggregation under adversarial conditions. Disclosure of AI-Assisted Writing The authors used Open AI ChatGPT to assist with grammar correction, English-language editing, and improving the clarity and readability of the manuscript. All AI-assisted content was reviewed and approved by the authors, who take full responsibility for the final manuscript. References [1] 3rd Generation Partnership Project (3GPP) (2026-07) Study on channel model for frequencies from 0.5 to 100 ghz. Technical report Technical Report TR 38.901 V19.4.0 (Release 19), 3GPP. External Links: Link Cited by: §V-B. [2] APACHE KAFKA. [Online]. Available: https://kafka.apache.org/(Website) External Links: Link Cited by: §V-A. [3] H. Bagheri, M. Noor-A-Rahim, Z. Liu, H. Lee, D. Pesch, K. Moessner, and P. Xiao (2021) 5G nr-v2x: toward connected and cooperative autonomous driving. IEEE Communications Standards Magazine 5 (1), p. 48–54. External Links: Document Cited by: §I. [4] V. P. Chellapandi, L. Yuan, C. G. Brinton, S. H. Żak, and Z. Wang (2024) Federated learning for connected and automated vehicles: a survey of existing approaches and challenges. IEEE Transactions on Intelligent Vehicles 9 (1), p. 119–137. External Links: Document Cited by: §I. [5] Y. Chen, T. Zhang, X. Jiang, Q. Chen, C. Gao, and W. Huang (2024) FedBone: towards large-scale federated multi-task learning. Journal of Computer Science and Technology 39 (5), p. 1040–1057. External Links: Document Cited by: §I-A. [6] L. Collins, H. Hassani, A. Mokhtari, and S. Shakkottai (2021) Exploiting shared representations for personalized federated learning. In Proceedings of the 38th International Conference on Machine Learning (ICML), Proceedings of Machine Learning Research, Vol. 139, p. 2089–2099. Note: FedRep External Links: Link Cited by: §I-A. [7] Y. Deng, F. Lyu, T. Xia, Y. Zhou, Y. Zhang, J. Ren, and Y. Yang (2024) A communication-efficient hierarchical federated learning framework via shaping data distribution at edge. IEEE/ACM Transactions on Networking 32 (3), p. 2600–2615. External Links: Document Cited by: §I-A. [8] A. M. Elbir and S. Coleri (2022) Federated learning for channel estimation in conventional and RIS-assisted massive MIMO. IEEE Transactions on Wireless Communications 21 (6), p. 4255–4268. External Links: Document Cited by: §I. [9] A. M. Elbir, B. Soner, S. Coleri, D. Gündüz, and M. Bennis (2022) Federated learning in vehicular networks. In 2022 IEEE International Mediterranean Conference on Communications and Networking (MeditCom), p. 72–77. External Links: Document Cited by: §I. [10] I. Goodfellow, Y. Bengio, and A. Courville (2016) Deep learning. MIT Press. External Links: ISBN 9780262035613 Cited by: §V-B. [11] M. S. HaghighiFard and S. Coleri (2025) Hierarchical federated learning in multi-hop cluster-based vanets. IEEE Transactions on Vehicular Technology 74 (10), p. 15371–15385. External Links: Document Cited by: §I-A, §I-B, §I-B. [12] M. S. HaghighiFard and S. Coleri (2026) Secure cluster-based hierarchical federated learning in vehicular networks. Vehicular Communications 60, p. 101055. External Links: Document Cited by: §I-A. [13] M. S. HaghighiFard (2026) AERO-HMTFL: autoencoder-based reliability-optimized hierarchical multi-task federated learning. Note: GitHub repository. [Online]. Available: https://github.com/SaeedHaghighi/AERO-HMTFL Cited by: §V-A. [14] J. B. Kenney (2011) Dedicated short-range communications (dsrc) standards in the united states. Proceedings of the IEEE 99 (7), p. 1162–1182. External Links: Document Cited by: §I. [15] T. Li, S. Hu, A. Beirami, and V. Smith (2021) Ditto: fair and robust federated learning through personalization. In Proceedings of the 38th International Conference on Machine Learning (ICML), Proceedings of Machine Learning Research, Vol. 139, p. 6357–6368. External Links: Link Cited by: §I-A, §V. [16] W. Y. B. Lim, N. C. Luong, D. T. Hoang, Y. Jiao, Y. Liang, Q. Yang, D. Niyato, and C. Miao (2020) Federated learning in mobile edge networks: a comprehensive survey. IEEE Communications Surveys & Tutorials 22 (3), p. 2031–2063. External Links: Document Cited by: §I. [17] X. Liu, Y. Zhou, D. Wu, M. Hu, M. Chen, M. Guizani, and Q. Z. Sheng (2025) CPFedAvg: enhancing hierarchical federated learning via optimized local aggregation and parameter mixing. IEEE Transactions on Networking 33 (3), p. 1160–1173. External Links: Document Cited by: §I-A. [18] Y. Lu, S. Huang, Y. Yang, S. Sirejiding, Y. Ding, and H. Lu (2024) FedHCA2: towards hetero-client federated multi-task learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), p. 5599–5609. External Links: Document Cited by: §I-A, §I-A. [19] O. Marfoq, G. Neglia, A. Bellet, L. Kameni, and R. Vidal (2021) Federated multi-task learning under a mixture of distributions. In Advances in Neural Information Processing Systems (NeurIPS), Vol. 34, p. 15434–15447. Cited by: §I-A. [20] B. McMahan, E. Moore, D. Ramage, S. Hampson, and B. A. y Arcas (2017) Communication-efficient learning of deep networks from decentralized data. In Proceedings of the 20th International Conference on Artificial Intelligence and Statistics (AISTATS), Proceedings of Machine Learning Research, Vol. 54, p. 1273–1282. External Links: Link Cited by: §V-B. [21] D. C. Nguyen, M. Ding, P. N. Pathirana, A. Seneviratne, J. Li, and H. V. Poor (2021) Federated learning for internet of things: a comprehensive survey. IEEE Communications Surveys & Tutorials 23 (3), p. 1622–1658. External Links: Document Cited by: §I. [22] Md. Noor-A-Rahim, Z. Liu, H. Lee, M. O. Khyam, J. He, D. Pesch, K. Moessner, W. Saad, and H. V. Poor (2022) 6G for vehicle-to-everything (v2x) communications: enabling technologies, challenges, and opportunities. Proceedings of the IEEE 110 (6), p. 712–734. External Links: Document Cited by: §I. [23] Y. Sai, X. Wu, J. Jiang, Y. Huang, Q. Yan, Z. Li, and H. Huang (2025) Optimizing hierarchical federated learning: a reinforcement learning approach. IEEE Transactions on Consumer Electronics 71 (2), p. 4076–4086. External Links: Document Cited by: §I-A. [24] H. Seo, K. Lee, S. Yasukawa, Y. Peng, and P. Sartori (2016) LTE evolution for vehicle-to-everything services. IEEE Communications Magazine 54 (6), p. 22–28. External Links: Document Cited by: §I. [25] M. Sepulcre, M. Gonzalez-Martín, J. Gozalvez, R. Molina-Masegosa, and B. Coll-Perales (2022) Analytical models of the performance of ieee 802.11p vehicle to vehicle communications. IEEE Transactions on Vehicular Technology 71 (1), p. 713–724. External Links: Document Cited by: §V-B. [26] Simulation of Urban MObility, SUMO. [Online]. Available: http:// sumo.sourceforge.net(Website) External Links: Link Cited by: §V-A. [27] V. Smith, C. Chiang, M. Sanjabi, and A. S. Talwalkar (2017) Federated multi-task learning. In Advances in Neural Information Processing Systems (NeurIPS), Vol. 30, p. 4424–4434. Cited by: §I-A. [28] S. Wang, C. Li, D. W. K. Ng, Y. C. Eldar, H. V. Poor, Q. Hao, and C. Xu (2023) Federated deep learning meets autonomous vehicle perception: design and verification. IEEE Network 37 (3), p. 16–25. External Links: Document Cited by: §I. [29] Q. Wu, X. Chen, T. Ouyang, Z. Zhou, X. Zhang, S. Yang, and J. Zhang (2023) HiFlash: communication-efficient hierarchical federated learning with adaptive staleness control and heterogeneity-aware client-edge association. IEEE Transactions on Parallel and Distributed Systems 34 (5), p. 1560–1579. External Links: Document Cited by: §I-A. [30] Y. Xu, Y. Zhu, Z. Wang, H. Xu, and Y. Liao (2025) Enhancing federated learning through layer-wise aggregation over Non-IID data. IEEE Transactions on Services Computing 18 (2), p. 798–811. External Links: Document Cited by: §I-A. [31] X. Yi, R. Li, C. Peng, F. Wang, J. Wu, and Z. Zhao (2024) RHFedMTL: resource-aware hierarchical federated multitask learning. IEEE Internet of Things Journal 11 (14), p. 25227–25238. External Links: Document Cited by: §I-A, §V. [32] S. Zhang, J. Li, L. Shi, M. Ding, D. C. Nguyen, W. Tan, J. Weng, and Z. Han (2024) Federated learning in intelligent transportation systems: recent applications and open problems. IEEE Transactions on Intelligent Transportation Systems 25 (5), p. 3259–3285. External Links: Document Cited by: §I. [33] J. Zhou, W. Bao, J. Wang, D. Zhang, X. Zhang, and Y. Zhang (2025) Multi-task federated learning with encoder–decoder structure: enabling collaborative learning across different tasks. International Journal of Machine Learning and Cybernetics 16 (12), p. 10403–10420. External Links: Document Cited by: §I-A, §I-A, §V.