A Hardware-Oriented Federated GNN Approach for Wireless Localization and Misuser Detection

Abstract

Wireless edge systems increasingly rely on on-device learning for tasks such as user localization and misuser detection, but centralized training is often infeasible because of privacy and bandwidth constraints. In this work, we study communication-efficient federated learning schemes that jointly train lightweight neural models across clients. We compare a multi-task shared-backbone strategy with mid-training backbone freezing against task-separate baselines. Using a wireless graph simulator, we prototype both multilayer perceptrons (MLPs) and an edge-aware graph neural network (GNN) encoder trained with FedAvg, and we evaluate localization error, misuser F1-score, and byte-level communication over training rounds. The results show that the GNN-Shared model achieves a 28.9% lower localization error than the MLP-Shared baseline and a 17.7% lower localization error than the GNN-Loc_only baseline, while improving the best misuser F1-score by 2.7% compared with GNN-Mis_only. In terms of communication, the GNN-Shared model reduces the total communication cost by 40.1% compared with MLP-Shared over 40 federated rounds. Additional experiments with FedProx, GraphSAGE, and GAT baselines show that the proposed federated graph-learning framework is flexible across different graph backbones. Multi-seed experiments over five random seeds further confirm the robustness of graph-based federated learning, with GraphSAGE-FedAvg achieving strong average localization and misuser detection performance. Scalability experiments with up to 20 clients, 150 nodes, and different Dirichlet non-IID parameters show that the framework remains stable under larger graph sizes, while communication cost grows mainly with the number of participating clients. To move the framework closer to edge deployment, this paper also introduces a lightweight hardware-oriented GNN-Lite inference prototype with multi-neighbor accumulation, finite-state-machine-based sequential computation, and read-only-memory-based coefficient storage. The prototype achieved timing closure on an Artix-7 field-programmable gate array with 213 LUTs, 111 FFs, 18 DSPs, 0 BRAMs, and 0.106 W estimated total on-chip power. The dynamic power was only 0.001 W, and the estimated total energy consumption was 10.6 nJ per inference. Overall, the results show that federated graph learning is a promising direction for wireless edge intelligence, and that different graph backbones can be selected depending on the target trade-off among localization accuracy, misuser detection performance, communication cost, robustness, and hardware deployment.

1. Introduction

Graph neural networks (GNNs) generalize deep learning to graph-structured data by letting each node iteratively aggregate and transform messages from its neighbors, so that representations reflect both local attributes and relational context [1,2,3,4]. In the popular message-passing view, a layer updates every node by combining neighbor features through learned functions and edge-dependent weights; stacking such layers grows each node’s “receptive field” over the topology. Foundational instances include spectral/spatial graph convolution (GCN) for semi-supervised node prediction, inductive neighborhood sampling (GraphSAGE) for large and evolving graphs, attention-based aggregation (GAT), and the unifying message-passing framework (MPNN) that formalizes many of these models under a common paradigm. Together, these families have become the standard toolkit to learn on graphs across domains [5,6]. Federated learning (FL) has become a promising approach for wireless edge intelligence by allowing distributed clients to collaboratively train a shared model without exchanging raw local data [7,8,9,10]. In FL, each client performs local training on its private observations and sends only model updates to a central server for aggregation, which helps preserve privacy while reducing the need for centralized data collection. This paradigm is particularly well-suited to wireless systems, where sensing data are naturally distributed across devices, access points, or edge nodes, and where bandwidth and data-sharing constraints often limit centralized learning. As a result, FL provides a practical foundation for communication-aware learning in applications such as wireless localization, spectrum monitoring, and distributed network management [11]. Among the model families that can benefit from wireless edge intelligence, GNNs are especially attractive because wireless systems are naturally represented as graphs, with devices or infrastructure nodes connected through communication, interference, or proximity relationships. Wireless networks are naturally graph-shaped: devices and access points form nodes; links, interference, and mobility induce time-varying edges; and edge features capture distances, SNR, ETX, or traffic. As a result, recent work has adapted GNNs to diverse wireless problems: scheduling and resource allocation, beamforming and CSI compression, link-level performance prediction, topology inference, and network management—often under the “GNN-for-communications” umbrella. Surveys consistently report that modeling relational structure improves sample efficiency and generalization, especially under irregular topologies and non-IID dynamics, and they outline practical considerations for deploying GNNs at the edge [12,13,14]. Although GNNs are attractive for wireless systems, their performance is not guaranteed under all deployment conditions. In practical wireless environments, graph structure can be highly dynamic because of node mobility, changing communication links, fading, shadowing, and interference. Sparse connectivity may limit the amount of useful neighborhood information available to each node, while noisy or unreliable edge attributes, such as distance estimates, signal-to-noise ratio values, or received-signal-strength residues, can propagate errors through the message-passing process. In addition, non-independent and non-identically distributed client data in federated learning can further amplify graph imbalance and reduce generalization across clients. Therefore, wireless graph neural network frameworks should be evaluated under dynamic and imperfect graph conditions rather than assuming static, dense, and noise-free topology. These limitations motivate the use of a time-varying wireless graph simulator, explicit comparison with node-wise multilayer perceptron baselines, and communication-aware federated training in this work.

In addition to graph neural networks, this work considers MLPs as lightweight baseline models due to their architectural simplicity and low computational cost [15]. However, unlike GNNs, MLPs process node features independently and do not explicitly capture the relational structure among wireless entities. Comparing federated MLP and GNN models under the same setting, therefore, helps quantify the benefit of graph-aware learning for localization accuracy, misuser detection performance, and wireless communication efficiency. Most prior wireless-GNN studies focus on a single task and assume centralized training or a task-specific architecture. In contrast, this paper investigates multi-task federated learning for two edge tasks, localization and misuser detection, under communication constraints. The proposed framework compares shared-backbone and task-separate training, explicitly accounts for communication cost in bytes, and introduces a freeze-to-heads schedule to reduce uplink and downlink payloads after the shared representation stabilizes. In addition to software evaluation, the paper includes a lightweight hardware realization of the shared edge-aware inference path to demonstrate the feasibility of low-resource edge deployment. AI hardware accelerators have become increasingly important for reducing latency, power consumption, and resource usage in edge-oriented learning systems [16,17]. The remainder of this paper is organized as follows. Section 2 presents the related work and summarizes the main gaps that motivate this study. Section 3 describes the proposed federated learning framework, including the system model, learning tasks, model parameterization, federated optimization, and communication model. Section 4 presents the implementation and experimental results, including the wireless graph simulator, evaluation protocol, software performance, communication analysis, scalability analysis, robustness analysis, and FPGA implementation results. Finally, Section 5 concludes the paper and summarizes the main findings.

To clarify the scope and original contribution of this work, the study is designed around the following research questions:

• Can a shared-backbone federated learning model jointly support wireless localization and misuser detection under non-independent and non-identically distributed client partitions?
• How much benefit does graph-aware learning provide compared with node-wise multilayer perceptron baselines under the same federated training protocol and communication budget?
• Can freezing the shared backbone after a warm-up stage reduce communication overhead while preserving localization and misuser detection performance?
• Can the shared edge-aware inference path be simplified into a lightweight, low-resource field-programmable gate array prototype suitable for edge deployment?

Based on these research questions, the main contributions of this paper are as follows. First, we formulate a communication-aware federated learning framework for joint wireless localization and misuser detection. Second, we compare graph neural network and multilayer perceptron backbones under the same simulator, training protocol, and communication accounting. Third, we introduce a freeze-to-heads strategy to reduce uplink and downlink communication after the shared representation stabilizes. Finally, we develop a lightweight hardware-oriented inference prototype using finite-state-machine-based sequential computation, multi-neighbor accumulation, and read-only-memory-based coefficient storage. This distinguishes the proposed work from existing federated graph neural network studies, which often focus on software-level learning without hardware realization, and from edge artificial-intelligence accelerator studies, which usually focus on generic neural-network inference without analyzing federated communication, multi-task learning, or wireless graph structure.

2. Related Work

Recent studies have shown that graph neural networks are well suited for wireless communication systems because wireless networks can naturally be represented as graphs, where devices, access points, base stations, sensors, or vehicles form nodes and communication, interference, or proximity relationships form edges [18,19,20]. Prior surveys have discussed the use of graph neural networks for resource allocation, beamforming, channel modeling, topology inference, link prediction, and network management. These studies show that graph-based learning can improve generalization and sample efficiency in irregular and dynamic wireless environments by explicitly modeling relational dependencies among network entities. Federated learning has also been studied as an important learning paradigm for privacy-preserving and communication-aware edge intelligence. Instead of collecting raw wireless data at a central server, federated learning allows distributed clients to train local models and share only model updates. This is especially relevant to wireless systems, where data are naturally distributed across devices and edge nodes, and where privacy, bandwidth, and data-sharing constraints limit centralized training. In parallel, hardware acceleration studies have shown that neural-network inference can be mapped to field-programmable gate arrays (FPGAs) to reduce latency, power consumption, and implementation overhead for edge-oriented artificial intelligence systems [21]. The GNN-Based WiFi Indoor Localization System turns WiFi measurements (RSSI/CSI fingerprints) into a graph and learns position with message passing. In typical designs, either APs are nodes and a user measurement forms edges to nearby APs, or fingerprints are nodes whose similarity is encoded as edges; GNN layers propagate signal/layout cues across the graph to regress 2-D coordinates. Strong variants also select informative APs to denoise fingerprints before GNN inference and report sizable gains over MLP/CNN baselines under multipath and layout changes [22]. This work frames spectrum-misuser hunting as a graph learning problem. Measurement points, such as base stations/sensors, are treated as nodes; edges encode spatial or radio-proximity relations; and node/edge attributes capture received power, interference, and other RF cues. A GNN is trained to propagate evidence over the graph so that the network can triangulate the likely position or identity of a misuser from limited, noisy observations. The key idea is that relational structure matters: by letting the model learn message-passing over the measurement graph, it can outperform point-wise triangulation or hand-crafted RF heuristics in complex propagation environments. Experiments in their study show improved localization accuracy against classical baselines by exploiting graph connectivity and learned aggregation [23]. This paper sits in the localized statistical channel modeling (LSCM) line of research, where the goal is to recover local channel statistics (e.g., angular power spectrum) from sparse measurements (e.g., RSRP) to enable site-specific planning and optimization. The authors couple a graphical prior (capturing spatial correlation across cells/tiles) with variational Bayesian inference and neural components, so the model can both respect physics-driven structure and flexibly fit data. In the broader LSCM literature, such Bayesian/graphical approaches have proven effective for inferring local channel structure from limited observations and for stabilizing learning with physical priors [24]. In this work, FedAvg is used as the main federated aggregation method because the primary objective is to evaluate the effect of shared versus task-separate learning, graph-aware versus node-wise backbones, freeze-to-heads communication reduction, and lightweight hardware-oriented inference under a common aggregation protocol. Adapt-LFA shows that adaptive gradient-guided label-flipping attacks can degrade federated learning-based intrusion detection in Internet-of-Things systems, highlighting the need to study robust aggregation and poisoning-aware defenses. Prior FPGA accelerators have focused on efficient GNN and neural-network inference through specialized data flows, sparse computation, and hardware–software co-design. LW-GCN [25] accelerates GCN/GraphSAGE inference using lightweight FPGA mapping and compression for irregular graph operations, while GraphAGILE [26] provides an overlay and compiler-based FPGA framework for multiple GNN models. FINN [27] is a broader FPGA framework for quantized neural-network inference. Unlike these high-throughput or large-scale accelerators, our RTL GNN-Lite design targets lightweight wireless edge inference, prioritizing small resource footprint, low latency, and low power on Artix-7.

From the reviewed literature, several shortcomings can be identified. First, many wireless graph neural network studies focus on a single task, such as localization, channel modeling, or spectrum analysis, rather than jointly considering localization and misuser detection in one multi-task framework. Second, many existing studies assume centralized training or do not explicitly evaluate byte-level communication cost under federated learning. Third, the comparison between graph-aware models and lightweight node-wise baselines, such as multilayer perceptrons, is often not performed under the same federated training and communication setting. Finally, existing edge artificial-intelligence hardware studies generally focus on generic neural-network acceleration and do not specifically examine a lightweight hardware-oriented inference path for a shared federated graph neural network framework. These gaps motivate the proposed communication-aware, multi-task federated graph neural network framework with a freeze-to-heads communication-reduction strategy and a lightweight field-programmable gate array-oriented GNN-Lite inference prototype.

3. The Proposed Method

This section presents the proposed communication-aware federated GNN framework for joint wireless localization and misuser detection. It introduces the system model, task definitions, model architectures, federated optimization procedure, and communication-aware training strategy.

3.1. System Model

Figure 1 illustrates the proposed federated GNN framework for wireless localization and misuser detection. A central server maintains the global shared-backbone model and updates it through FedAvg aggregation of local client updates. Each client trains on its own wireless graph using local node and edge features, while raw data remain private. The shared GNN backbone learns graph-aware representations, and two task-specific heads produce localization coordinates and a misuser detection logit. This design enables communication-efficient collaborative learning across distributed clients while jointly supporting both tasks. We consider a time-varying wireless graph $G_t=(V,E_t)$ with $N=\left|V\right|$ nodes representing user equipment, access points, base stations, vehicles, or sensors. Directed edges represent communication opportunities at time t. Each node $i\in V$ has a feature vector $\mathbf{x}i\in {\mathbb{R}}^{d_x}$, and each edge $(i,j)\in E_t$ has an attribute vector $\mathbf{e}ij\in {\mathbb{R}}^{d_e}$. The true two-dimensional position of node i is denoted by ${\mathbf{p}}_i\in {\mathbb{R}}^2$, and the binary misuser label is denoted by $y_i\in 0,1$. The graph is time-varying because both connectivity and feature statistics change with mobility and propagation conditions.

We adopt a server–client federated learning architecture with K clients. Client k holds a private node subset $V_k\subset V$, where ${\bigcup }_{k=1}^K{V}_k=V$ and $V_k\cap V_{k^{\prime }}=Ø$ for $k\ne k^{\prime }$. Raw node features, edge features, and labels remain local to each client. Each client constructs an induced local subgraph $G_t\left[V_k\right]$ by keeping only edges whose endpoints belong to its local node subset. In the current prototype, each client uses an induced local subgraph by keeping only edges whose endpoints belong to the same local node subset. This choice is made as a privacy-preserving and implementation-friendly assumption because raw node features and labels remain local to each client. However, we acknowledge that this partitioning may remove cross-client edges and can partially distort the original global wireless topology, especially for localization tasks that benefit from spatial relationships across neighboring regions. Therefore, the present setting should be interpreted as a conservative federated scenario in which each client learns from locally available graph structure only. Preserving cross-client connectivity without sharing raw data is an important direction for future work. Possible extensions include privacy-preserving boundary-node embeddings, anonymized edge-statistic exchange, secure aggregation of cross-client neighborhood information, or server-side graph stitching using non-sensitive topology summaries.

The framework addresses two tasks. The first is localization, modeled as

$${\widehat{\mathbf{p}}}_i=f_{\theta }^{\mathrm{loc}}(i;{\mathcal{G}}_t),{\mathcal{L}}_{\mathrm{loc}}={\displaystyle \frac{1}{\left|\mathcal{V}\right|}}\sum _{i\in \mathcal{V}}{\parallel {\widehat{\mathbf{p}}}_i-{\mathbf{p}}_i\parallel }_1.$$

(1)

The second is misuser detection, modeled with logits ${\widehat{z}}_i=f_{\theta }^{\mathrm{mis}}(i;{\mathcal{G}}_t)$ and balanced binary cross-entropy:

$${\mathcal{L}}_{\mathrm{mis}}={\displaystyle \frac{1}{\left|\mathcal{V}\right|}}\sum _{i\in \mathcal{V}}\mathrm{BCEWithLogits}({\widehat{z}}_i,y_i;\mathrm{pos}\_\mathrm{weight}).$$

(2)

For shared multi-task training, the objective is

$${\mathcal{L}}_{\mathrm{shared}}={\mathcal{L}}_{\mathrm{loc}}+\lambda {\mathcal{L}}_{\mathrm{mis}},$$

(3)

where $\lambda >0$ controls the task trade-off. For the shared multi-task model, the task trade-off parameter was set to $\lambda =1.0$ in all reported experiments. This choice gives equal weight to the localization loss and the misuser detection loss. We selected this value as a simple baseline because the localization targets were scaled to $[0,1]$ during training and the misuser detection loss was computed using binary cross-entropy with logits. However, the value of $\lambda$ can affect the balance between the two tasks: larger values emphasize misuser detection, while smaller values emphasize localization.

In this work, the term misuser refers to an unauthorized or abnormal wireless transmitter whose behavior differs from normal network nodes and may indicate spectrum misuse, harmful interference, malicious activity, or abnormal access to the wireless medium. Therefore, misuser detection is treated as a node-level binary classification problem. Each node is assigned a label $y_i\in 0,1$, where $y_i=0$ denotes a normal wireless node and $y_i=1$ denotes a misuser. The present study focuses on detecting whether a node behaves as a misuser, rather than distinguishing among specific attack categories such as jamming, spoofing, or protocol-level intrusion.

3.2. Model Parameterization

We study two encoder families. The first is a node-wise multilayer perceptron (MLP), written as $g_{\varphi }\left({\mathbf{x}}_i\right)$, with separate task heads $h_{\psi }^{\mathrm{loc}}(·)$ and $h_{\psi }^{\mathrm{mis}}(·)$. The second is an edge-aware GNN encoder $g_{\varphi }(\mathbf{X},\mathbf{E})$ that aggregates neighbor features modulated by edge attributes. We consider two architectural variants: a shared backbone, in which one encoder serves both tasks, and separate backbones, in which localization and misuser detection are trained independently.

For the GNN, the software prototype uses two edge-conditioned NNConv layers:

$$\begin{array}{cc}\hfill {\mathbf{H}}^{\left(1\right)}& =\sigma \left(\mathrm{NNConv}(\mathbf{X},\mathbf{E};{\varphi }_1)\right),\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill {\mathbf{H}}^{\left(2\right)}& =\sigma \left(\mathrm{NNConv}({\mathbf{H}}^{\left(1\right)},\mathbf{E};{\varphi }_2)\right).\hfill \end{array}$$

(5)

Here, $\sigma$ denotes ReLU. A shared hidden representation of size 64 feeds two heads:

$$\begin{array}{cc}\hfill {\widehat{\mathbf{p}}}_i& ={\mathbf{W}}_{\mathrm{loc}}{\mathbf{h}}_i^{\left(2\right)}\in {[0,1]}^2,\hfill \end{array}$$

(6)

$$\begin{array}{cc}\hfill {\widehat{z}}_i& ={\mathbf{w}}_{\mathrm{mis}}^{\top }{\mathbf{h}}_i^{\left(2\right)}\in \mathbb{R}.\hfill \end{array}$$

(7)

3.3. Federated Objective and Communication Model

Training proceeds over R global rounds. At round r, the server broadcasts model parameters, client k performs E local optimization steps on its subgraph, and the server aggregates the updated parameters with FedAvg:

$${\theta }_{r+1}\leftarrow \sum _{k\in {\mathcal{S}}_r}{w}_k{\theta }_r^{\left(k\right)},w_k={\displaystyle \frac{|{\mathcal{V}}_k|}{{\sum }_{j\in {\mathcal{S}}_r}\left|{\mathcal{V}}_j\right|}},$$

(8)

where ${\mathcal{S}}_r$ denotes the participating clients and $\theta$ contains encoder and head parameters.

To explicitly account for communication, let $P_{\mathrm{enc}}$ and $P_{\mathrm{heads}}$ denote the number of encoder and head parameters. Assuming 32-bit parameters, the per-round uplink and downlink payloads are

$${\mathrm{MB}}_{\uparrow }={\displaystyle \frac{(P_{\mathrm{enc}}+P_{\mathrm{heads}})·4·K}{{10}^6}},{\mathrm{MB}}_{\downarrow }={\mathrm{MB}}_{\uparrow }.$$

(9)

The communication model used in this work is a simplified payload-level model. It counts only the transmitted model parameters and assumes 32-bit floating-point values with equal uplink and downlink payloads. This model is useful for comparing the relative communication cost of different training modes under the same assumptions. However, it does not include metadata, protocol headers, client-selection signaling, compression, quantization, packet loss, retransmission, or wireless channel constraints. A more detailed network-level communication model will be considered in future work. After a warm-up period, the shared model adopts a freeze-the-backbone schedule at round $r\ge R_f$, so that only the heads are updated and communicated:

$${\mathrm{MB}}_{\uparrow }^{\mathrm{heads}}={\displaystyle \frac{P_{\mathrm{heads}}·4·K}{{10}^6}},{\mathrm{MB}}_{\downarrow }^{\mathrm{heads}}={\mathrm{MB}}_{\uparrow }^{\mathrm{heads}}.$$

(10)

This strategy substantially reduces communication when $P_{\mathrm{enc}}\gg P_{\mathrm{heads}}$. The freeze-to-heads strategy is used to reduce communication after the shared representation becomes stable. During the early training rounds, the shared backbone learns common wireless features that are useful for both localization and misuser detection. After the warm-up stage, continuing to send the full backbone parameters can increase communication cost without providing proportional performance gains. Therefore, the backbone is frozen, and only the task-specific heads are updated and exchanged. This reduces uplink and downlink payloads and can also reduce task interference between the localization and misuser detection objectives.

Algorithm 1 summarizes the main steps of the proposed communication-aware federated learning framework. The algorithm includes client-side local training, server-side aggregation, communication accounting, and the freeze-to-heads strategy used after the warm-up stage.

Algorithm 1 Communication-aware federated GNN framework with freeze-to-heads strategy.

Require:  Number of clients K, global rounds R, local steps E, freeze round $R_f$, learning rates ${\eta }_b$ and ${\eta }_h$, task weight $\lambda$, client node sets $V_k\ast {k=1}^K$ Require:  Initial encoder parameters ${\varphi }^{\left(0\right)}$, localization-head parameters $\psi \ast {\mathrm{loc}}^{\left(0\right)}$, and misuser-head parameters ${\psi }_{\mathrm{mis}}^{\left(0\right)}$ Ensure:  Trained global model parameters and evaluation metrics   1: Initialize global parameters ${\theta }^{\left(0\right)}={\varphi }^{\left(0\right)},{\psi }_{\mathrm{loc}}^{\left(0\right)},{\psi }_{\mathrm{mis}}^{\left(0\right)}$   2: Initialize cumulative communication cost $C_{\mathrm{total}}\leftarrow 0$   3: for $r=1$ to R do   4:       Server broadcasts current global parameters to all participating clients   5:       for each client $k=1$ to K do   6:             Construct local induced subgraph $G_t\left[V_k\right]$ using local node and edge features   7:             Normalize node features and scale localization labels   8:             Initialize local parameters ${\theta }_k^{\left(r\right)}\leftarrow {\theta }^{(r-1)}$   9:             for $e=1$ to E do 10:                   Compute node embeddings using the selected backbone:       MLP: ${\mathbf{h}}_i=g_{\varphi }\left({\mathbf{x}}_i\right)$       GNN: ${\mathbf{h}}_i=g_{\varphi }(\mathbf{X},\mathbf{E})$ 11:                   Predict localization output ${\widehat{\mathbf{p}}}_i$ and misuser logit ${\widehat{z}}_i$ 12:                   Compute localization loss $L_{\mathrm{loc}}$ 13:                   Compute misuser detection loss $L_{\mathrm{mis}}$ 14:                   Compute shared loss $L_{\mathrm{shared}}=L_{\mathrm{loc}}+\lambda L_{\mathrm{mis}}$ 15:                   if $r<R_f$ then 16:                         Update encoder and task-head parameters using local gradients 17:                   else 18:                         Freeze encoder parameters $\varphi$ 19:                         Update only task-head parameters ${\psi }_{\mathrm{loc}}$ and ${\psi }_{\mathrm{mis}}$ 20:                   end if 21:             end for 22:             Client k uploads updated trainable parameters to the server 23:       end for 24:       if $r<R_f$ then 25:             Server aggregates encoder and head parameters using FedAvg:       ${\theta }^{\left(r\right)}\leftarrow {\sum }_{k=1}^K{\displaystyle \frac{|V_k|}{{\sum }_{j=1}^K\left|V_j\right|}}{\theta }_k^{\left(r\right)}$ 26:             Update communication cost using full-model payload 27:       else 28:             Server aggregates only task-head parameters using FedAvg 29:             Keep encoder parameters fixed 30:             Update communication cost using heads-only payload 31:       end if 32:       Evaluate localization mean absolute error and misuser F1-score 33:       Accumulate total communication cost $C_{\mathrm{total}}$ 34: end for 35: return Final localization error, misuser F1-score, and total communication cost

4. Implementation and Experimental Results

4.1. Wireless Graph Simulator and Experimental Setup

The experiments use a time-varying directed wireless graph generated under Random-Waypoint mobility. At each round, the simulator produces node features ${\mathbf{x}}_i\in {\mathbb{R}}^5$ and edge features ${\mathbf{e}}_{i\to j}\in {\mathbb{R}}^4$.

The node features are

$${\mathbf{x}}_i=[\overline{\mathrm{RSSI}},\mathrm{Var}\left(\mathrm{RSSI}\right),\mathrm{neighbor}\_\mathrm{count},\mathrm{speed},\mathrm{tx}\_\mathrm{power}],$$

(11)

and the edge features are

$${\mathbf{e}}_{i\to j}=[\mathrm{distance},\mathrm{SNR},\mathrm{ETX},\mathrm{RSSI}\mathrm{residue}],$$

(12)

computed from a log-distance path-loss model with shadowing. Ground-truth positions satisfy ${\mathbf{p}}_i\in [0,W]\times [0,H]$. The scaled training target is ${\tilde{\mathbf{p}}}_i={\mathbf{p}}_i/\left[WH\right]$, and localization error is reported in meters after rescaling.

The wireless graph is generated as a time-varying directed graph $G_t=(V,E_t)$ over a rectangular area of size $W\times H$. Each node $i\in V$ has a position $\mathbf{p}\ast i\left(t\right)={[x_i\left(t\right),y_i\left(t\right)]}^{\top }$, where $x_i\left(t\right)\in [0,W]$ and $y_i\left(t\right)\in [0,H]$. Node mobility follows a Random-Waypoint model. Each node selects a destination $\mathbf{d}\ast i\left(t\right)$ uniformly inside the area and a speed $v_i\left(t\right)\sim \mathcal{U}(v\ast \min ,v\ast \max )$. During each time step $\Delta t$, the node position is updated as

$${\mathbf{p}}_i(t+\Delta t)={\mathbf{p}}_i\left(t\right)+\min \left(v_i\left(t\right)\Delta t,{|{\mathbf{d}}_i\left(t\right)-{\mathbf{p}}_i\left(t\right)|}_2\right){\displaystyle \frac{{\mathbf{d}}_i\left(t\right)-{\mathbf{p}}_i\left(t\right)}{|{\mathbf{d}}_i\left(t\right)-{\mathbf{p}}_i{\left(t\right)|}_2+ϵ}},$$

(13)

where $ϵ$ is a small constant used to avoid division by zero. When a node reaches its destination, or when a pause/replanning event occurs, a new destination and speed are sampled.

Graph connectivity is determined using a distance-based communication rule. For two nodes i and j, the Euclidean distance is

$$d_{ij}\left(t\right)=|{\mathbf{p}}_i\left(t\right)-{\mathbf{p}}_j\left(t\right)|\ast 2.$$

(14)

A directed edge $(i,j)\in E_t$ is created if

$$0<d\ast ij\left(t\right)\le R_c,$$

(15)

where $R_c$ is the communication radius. Therefore, the graph topology changes over time as nodes move.

For each edge $(i,j)$, the log-distance path-loss model with shadowing is used:

$$P{L}_{ij}\left(t\right)=P{L}_0+10n{\log }_{10}\left({\displaystyle \frac{d_{ij}\left(t\right)}{d_0}}\right)+X_{\sigma },$$

(16)

where $P{L}_0$ is the reference path loss at distance $d_0$, n is the path-loss exponent, and $X_{\sigma }\sim \mathcal{N}(0,{\sigma }^2)$ models log-normal shadowing. The received signal strength is then computed as

$$P_{rx,ij}\left(t\right)=P_{tx,i}-P{L}_{ij}\left(t\right),$$

(17)

and the signal-to-noise ratio is

$$SN{R}_{ij}\left(t\right)=P_{rx,ij}\left(t\right)-N_0,$$

(18)

where $P_{tx,i}$ is the transmit power of node i and $N_0$ is the noise floor. The expected transmission count is approximated from the signal-to-noise ratio using

$$ET{X}_{ij}\left(t\right)={\displaystyle \frac{1}{p_{\mathrm{succ},ij}\left(t\right)p_{\mathrm{ack}}}},$$

(19)

where

$$p_{\mathrm{succ},ij}\left(t\right)=1-\exp \left[-k\max (SN{R}_{ij}\left(t\right)-SN{R}_0,0)\right].$$

(20)

Finally, the received-signal-strength residue is computed as the difference between the measured received power and the expected received power without shadowing. Thus, each edge feature vector is defined as

$$\mathbf{e}\ast ij\left(t\right)=[d\ast ij\left(t\right),SN{R}_{ij}\left(t\right),ET{X}_{ij}\left(t\right),r_{ij}\left(t\right)].$$

(21)

This formulation provides a complete mathematical description of node mobility, graph connectivity, and edge-feature construction used in the simulator.

Node features are z-scored per round. The graph is partitioned across K clients using a Dirichlet split with concentration parameter $\alpha =0.5$, creating non-IID client subgraphs. The Dirichlet concentration parameter $\alpha$ controls the degree of non-independent client partitioning. Smaller values of $\alpha$ create more skewed client subsets, while larger values produce more balanced partitions. In this study, $\alpha =0.5$ was used as a moderate non-independent setting to evaluate the proposed framework under heterogeneous client data. However, we acknowledge that the model performance may change under stronger or weaker non-independent conditions. Future work will extend the sensitivity analysis to multiple values, such as $\alpha =0.1$, $\alpha =0.3$, and $\alpha =1.0$, to quantify the robustness of the shared-backbone and freeze-to-heads strategy under different client heterogeneity levels. The experimental hyperparameters are $K=5$ clients, $E=5$ local steps, $R=40$ rounds, Adam optimizer, learning rates $1\times {10}^{-3}$ for backbones and $3\times {10}^{-3}$ for heads, and hidden size 64.

Table 1. Main Wireless Graph Simulator Parameters.

Parameter	Value
Simulation area size	$100\times 100 {\mathrm{m}}^2$
Number of wireless nodes	60
Node density	$0.006$ nodes/${\mathrm{m}}^2$
Mobility speed range	0.5–2.0 m/s
Path-loss exponent	2.4
Shadowing standard deviation	2.0 dB
Communication radius	35 m
Number of clients	5
Global training rounds	40
Local steps per round	5
Freeze round	10
Misuser-label rule	Median-degree placeholder rule
Approximate number of misusers	≈30 of 60 nodes
Approximate class imbalance ratio	≈1:1

summarizes the main wireless graph simulation parameters used in this study. These parameters define the physical simulation area, node density, mobility behavior, propagation model, graph connectivity rule, client partitioning, and federated training configuration. The current evaluation is based on a controlled wireless graph simulator. This simulator-based setup is useful because it allows repeatable control over node mobility, graph topology, non-independent client partitions, node and edge features, and communication accounting across federated rounds. However, we acknowledge that simulator-only validation does not fully capture all practical effects of real wireless deployments, such as hardware impairments, multipath propagation, measurement noise, antenna placement, environmental blockage, and protocol-level behavior. Therefore, the reported results should be interpreted as proof-of-concept validation of the proposed communication-aware federated learning framework rather than final deployment-level performance.

The wireless graph is generated over a $100\times 100 {\mathrm{m}}^2$ area with 60 wireless nodes. Node mobility follows a Random-Waypoint model with a speed range of 0.5–2.0 m/s. Wireless links are formed using a distance-based communication radius of 35 m. The propagation model uses a log-distance path-loss model with path-loss exponent 2.4 and shadowing standard deviation of 2.0 dB. Each node feature vector contains received signal strength statistics, neighbor count, mobility information, and transmit-power information, while each edge feature vector contains distance, signal-to-noise ratio, expected transmission count, and received-signal-strength residue. The federated setup uses five clients with non-IID client partitioning based on a Dirichlet distribution with concentration parameter $\alpha =0.5$. Training is performed for 40 global rounds with five local steps per round. The shared-backbone models use a freeze round of 10, after which only the task-specific heads are updated and communicated. The misuser detection task is formulated as binary node classification. The class distribution is controlled by the misuser-labeling rule described in the experimental setup, and the resulting positive and negative samples are used to compute precision, recall, F1-score, ROC-AUC, and PR-AUC. In terms of computational complexity, the MLP baseline processes nodes independently, so its cost scales mainly with the number of nodes and the hidden-layer dimensions. In contrast, the graph-based models include neighborhood aggregation, so their complexity depends on both the number of nodes and the number of edges in the local graph. Therefore, denser graphs increase local computation, while federated communication depends mainly on the number of transmitted model parameters rather than the number of local graph nodes. For reproducibility, all reported experiments specify the random seeds, the number of clients, the number of rounds, the local training steps, the learning rates, and the communication accounting assumptions.

4.2. Evaluation Protocol and Baselines

We evaluate three modes for each model family: Shared, Loc_only, and Mis_only. In the shared mode, one backbone serves both tasks and is frozen after $r_f=10$ rounds. In the separate modes, one model is trained only for localization and another only for misuser detection. We also train a centralized baseline on the union of all client data to provide an upper-bound reference without federation.

The main evaluation metrics are localization mean absolute error (MAE), misuser precision, recall, and $F_1$ score at threshold 0.5, as well as communication cost in MB per round and cumulative MB across R rounds. In the evaluation, localization performance was mainly reported using mean absolute error because it provides a direct and interpretable error measure in meters.

4.3. Hardware-Oriented GNN-Lite Approximation

We developed a lightweight hardware prototype of the shared edge-aware inference path in Verilog and implemented it on an Artix-7 FPGA, as shown in Figure 2. The full software GNN uses two NNConv layers with a hidden size of 64. It is important to note that the RTL prototype is not intended to be a bit-equivalent implementation of the two-layer NNConv software GNN used in the federated learning experiments. The software model uses dynamic edge-conditioned convolution, where edge attributes contribute to the generation of convolutional operations. Directly mapping this full NNConv structure to RTL would require substantially more arithmetic resources, memory access, and control logic. Therefore, the hardware prototype is designed as a hardware-oriented GNN-Lite approximation of the shared edge-aware inference path. Specifically, the dynamic NNConv kernel generation is replaced with a scalar edge-weighting function, followed by sequential multi-neighbor accumulation. This design preserves the key graph-inspired operation, namely edge-aware aggregation over neighboring nodes, while enabling a compact, low-power field-programmable gate array implementation.

The implemented hardware computes

$$h_i=\mathrm{ReLU}\left(W_s{x}_i+\sum _{j\in \mathcal{N}\left(i\right)}{\alpha }_{ij}\left(W_n{x}_j\right)+b_h\right),$$

(22)

where $x_i$ is the current node feature vector, $x_j$ is a neighbor feature vector, and the scalar edge weight is

$${\alpha }_{ij}=c_0{e}_0+c_1{e}_1+c_2{e}_2+c_3{e}_3+b_e.$$

(23)

This formulation preserves the edge-aware nature of the original model while reducing arithmetic and control complexity relative to dynamic NNConv kernel generation.

The architecture uses three main design choices: (i) multi-neighbor accumulation to better reflect graph-style aggregation; (ii) FSM-based sequential computation to reduce resource usage; and (iii) ROM-based storage of self, neighbor, edge, and head coefficients. The hidden activation is forwarded to two heads: a localization head that outputs $(x,y)$ and a misuser detection head that outputs a logit followed by threshold-based classification.

4.4. Misuser Detection Performance

Figure 3 compares MLP-based misuser detection under shared and separate training. The single-task misuser model (MLP-Mis_only) is unstable and collapses to $F_1=0$ after approximately 10 rounds, whereas the multi-task shared MLP maintains $F_1\approx 0.11$–$0.14$ across the training window. This indicates that the shared backbone provides a regularizing effect under non-IID data and class imbalance. Figure 4 shows the GNN-based misuser results. Both GNN-Shared and GNN-Mis_only stabilize near $F_1\approx 0.70$–$0.73$. After round $r=10$, the shared model switches to heads-only updates yet maintains competitive classification accuracy, indicating that freezing the backbone reduces communication without sacrificing misuser-detection quality. To provide a more complete evaluation of misuser detection beyond F1-score,

Table 2. Misuser detection performance metrics with additional baselines.

Mode	Precision	Recall	Final-Round F1	ROC-AUC	PR-AUC
MLP-Shared	0.000	0.000	0.000	0.473	0.081
MLP-Mis_only	0.060	1.000	0.113	0.668	0.118
MLP-FedProx-0.01	0.060	1.000	0.113	0.504	0.070
MLP-FedProx-0.1	0.060	1.000	0.113	0.388	0.054
GNN-Shared	0.857	0.600	0.706	0.849	0.875
GNN-Mis_only	0.944	0.567	0.708	0.882	0.893
NNConv-FedProx	0.938	0.500	0.652	0.876	0.886
GraphSAGE-FedAvg	0.963	0.867	0.912	0.978	0.980
GAT-FedAvg	0.850	0.567	0.680	0.899	0.897

reports precision, recall, ROC-AUC, and PR-AUC for the evaluated detection modes. Precision measures the reliability of positive misuser predictions, while recall measures the ability to identify actual misusers. ROC-AUC and PR-AUC provide threshold-independent measures of classification performance, and PR-AUC is especially useful under class imbalance. The added GraphSAGE-FedAvg baseline achieves the strongest misuser detection performance. However, the proposed GNN-Shared model remains important because it jointly supports localization and misuser detection within one shared federated framework, while also enabling communication reduction through the freeze-to-heads strategy and a lightweight hardware-oriented inference path. The FedProx-based MLP baselines do not improve over the original MLP-Mis_only baseline, while NNConv-FedProx achieves competitive precision but lower recall. Therefore, the additional baselines do not change the main conclusion of this work that the proposed shared federated GNN framework provides the best overall trade-off across localization, misuser detection, communication efficiency, and hardware-oriented deployment, even though some task-specific graph baselines may perform better on an individual task.

4.5. Localization Performance

Figure 5 compares localization MAE for MLP-based models. The shared MLP converges faster and achieves lower final MAE than the localization-only MLP, suggesting that the auxiliary misuser objective improves feature learning even though the localization loss remains unchanged. Figure 6 shows that GNN-Loc_only starts with lower MAE, but GNN-Shared converges to a comparable or better final localization error by approximately rounds 15–20. This behavior suggests that the shared backbone does not incur a long-term localization penalty while still enabling communication reduction after freezing.

Table 3. Localization performance metrics with additional baselines.

Mode	MAE	RMSE	Median	P75	P90	P95
MLP-Shared	25.14	28.29	23.58	36.45	41.81	47.11
MLP-Loc_only	24.51	27.65	23.73	35.43	40.09	45.44
MLP-FedProx-0.01	24.94	28.17	22.81	35.79	41.21	46.49
MLP-FedProx-0.1	25.01	28.44	22.94	35.75	42.80	45.70
GNN-Shared	23.75	25.21	22.59	30.70	34.88	37.45
GNN-Loc_only	28.87	31.18	29.17	38.52	41.67	44.77
NNConv-FedProx	213.60	242.07	175.02	316.21	379.92	411.35
GraphSAGE-FedAvg	33.72	38.68	31.50	47.92	60.05	64.39
GAT-FedAvg	30.80	35.68	27.76	44.21	55.75	59.31

reports localization metrics beyond MAE, including RMSE, median error, and percentile errors. RMSE reflects sensitivity to larger localization errors, while the median and percentile values describe the typical and tail behavior of the localization-error distribution. The GNN-Shared model achieves the lowest MAE, RMSE, and tail errors among the evaluated graph-based models and provides a better overall multi-task federated trade-off than the task-specific baselines.

4.6. Communication–Accuracy Trade-Off

Table 4. Summary of shared and task-specific model performance and communication overhead.

Mode	Total MB	Loc MAE (Sum)	Best F1 Across Rounds
GNN-Shared	$11.7$	$23.75$	$0.75$
GNN-Loc_only	$11.7$	$28.87$	N/A
GNN-Mis_only	$11.7$	N/A	$0.73$
MLP-Shared	$19.54$	$33.41$	$0.15$
MLP-Loc_only	$29.79$	$31.82$	N/A
MLP-Mis_only	$29.79$	N/A	$0.20$
Centralized	N/A	$34.39$	$0.79$ (Accuracy)

summarizes the original shared and task-specific models with communication overhead. We report communication savings together with accuracy. The GNN-Shared model requires 11.7 MB over 40 federated rounds, compared with 19.54 MB for MLP-Shared and 29.79 MB for the task-specific MLP models. This corresponds to a 40.1% communication reduction compared with MLP-Shared and a 60.7% reduction compared with MLP-Loc_only or MLP-Mis_only. This saving is achieved because the shared backbone is communicated only during the warm-up stage, while only the task-specific heads are exchanged after the freeze round. The localization and detection results show that this reduction does not remove the usefulness of the shared model: GNN-Shared achieves the lowest localization error among the original models while maintaining competitive misuser detection performance. Therefore, the freeze-to-heads strategy provides a practical accuracy-versus-communication trade-off for federated wireless edge learning. Table 4 reports the best F1-score observed across training rounds, while Table 2 reports final-round misuser detection metrics. Therefore, the F1 values in the two tables differ slightly.

4.7. Scalability Discussion

The current evaluation uses five clients as a controlled proof-of-concept setting. We acknowledge that larger-scale deployments with more clients, larger graph sizes, and different non-IID levels are needed to fully evaluate scalability. In general, communication cost grows with the number of participating clients and the number of trainable parameters exchanged per round, while graph size mainly affects local computation and memory usage. Since the proposed freeze-to-heads strategy exchanges only task-specific heads after the warm-up stage, its communication benefit is expected to become more important as the number of clients increases. Future work will evaluate larger settings with 10, 20, and 50 clients, larger wireless graphs, and different Dirichlet non-IID parameters to quantify scalability in more realistic deployments.

Table 5. Scalability analysis with varying numbers of clients, graph sizes, and Dirichlet non-IID parameters.

Experiment	Setting	Final Loc MAE	Best F1	Total MB
Clients	5	19.52	0.929	3.54
Clients	10	23.31	0.870	7.08
Clients	20	30.28	0.824	14.15
Graph size	60 nodes	19.52	0.929	3.54
Graph size	100 nodes	19.63	0.914	3.54
Graph size	150 nodes	20.36	0.908	3.54
Non-IID distribution	$\alpha =0.1$	19.91	0.931	3.54
Non-IID distribution	$\alpha =0.5$	19.52	0.929	3.54
Non-IID distribution	$\alpha =1.0$	18.76	0.949	3.54

reports the scalability analysis under different numbers of clients, graph sizes, and non-IID distribution levels. When the number of clients increases from 5 to 20, the total communication cost increases from 3.54 MB to 14.15 MB because more client updates are exchanged in each federated round. At the same time, the localization MAE increases from 19.52 m to 30.28 m and the best F1-score decreases from 0.929 to 0.824, indicating that larger client counts make the learning problem more challenging due to smaller local partitions and stronger client-level heterogeneity. For graph-size scaling, the communication cost remains constant at 3.54 MB because federated communication depends on the number of transmitted model parameters rather than the number of local graph nodes. The localization MAE increases only slightly from 19.52 m for 60 nodes to 20.36 m for 150 nodes, while the best F1-score remains above 0.90. This suggests that the graph-based federated model can handle larger local graphs without increasing communication overhead. For non-IID sensitivity, the model remains stable across different Dirichlet parameters. The best performance is observed at $\alpha =1.0$, where the client partitions are more balanced, with a localization MAE of 18.76 m and a best F1-score of 0.949.

4.8. Multi-Seed Robustness Analysis

To evaluate the robustness of the reported results, the main experiments were repeated across five random seeds: 7, 11, 21, 42, and 100. These seeds affect model initialization, node mobility realization, graph construction, stochastic training behavior, and non-IID client partitioning.

Table 6. Multi-seed robustness analysis over five random seeds. Results are reported as mean ± standard deviation.

Method	Seeds	Loc MAE	Best F1 Across Rounds	Total MB
MLP-Shared	5	$32.45\pm 1.94$	$0.219\pm 0.061$	$19.54\pm 0.00$
MLP-FedProx-0.01	5	$32.42\pm 1.94$	$0.201\pm 0.087$	$19.54\pm 0.00$
NNConv-FedAvg	5	$53.15\pm 25.23$	$0.791\pm 0.072$	$105.51\pm 0.00$
GraphSAGE-FedAvg	5	$19.89\pm 2.90$	$0.911\pm 0.058$	$3.54\pm 0.00$
GAT-FedAvg	5	$20.96\pm 4.24$	$0.580\pm 0.311$	$2.04\pm 0.00$

reports the mean and standard deviation of localization MAE, best misuser F1-score, and total communication cost over the five independent runs. The multi-seed results show that the main trends remain consistent across independent runs. The MLP-based models provide relatively stable localization performance, but their misuser detection performance remains low, with average best F1-scores of $0.219$ and $0.201$ for MLP-Shared and MLP-FedProx-0.01, respectively. This confirms that node-wise MLP models have limited ability to capture graph-dependent behavior for the misuser detection task. In contrast, the graph-based models provide stronger detection performance across the evaluated seeds. GraphSAGE-FedAvg achieves the best average robustness among the tested baselines, with the lowest localization MAE of $19.89\pm 2.90$ and the highest F1-score of $0.911\pm 0.058$. GAT-FedAvg also provides strong localization performance, with a localization MAE of $20.96\pm 4.24$, and achieves the lowest communication cost of $2.04\pm 0.00$ MB. However, its misuser detection score has a larger standard deviation, indicating higher sensitivity to random initialization, graph realization, or client partitioning. NNConv-FedAvg achieves strong average misuser detection performance, but its localization MAE has a high standard deviation, showing that this backbone is more sensitive to the training and graph-generation conditions. Overall, the multi-seed analysis demonstrates that graph-based federated learning is more robust than MLP-based learning for the joint wireless localization and misuser detection setting. The results also show that different graph backbones provide different trade-offs among localization accuracy, detection performance, communication cost, and stability. Therefore, the proposed federated graph-learning framework is flexible and can support different GNN backbones depending on the target deployment requirement.

4.9. Hardware Implementation Results

The FPGA implementation settings are summarized as follows. The hardware prototype was written in Verilog RTL and implemented using Vivado 2022.2. The target device was an Artix-7 FPGA. The design uses 16-bit signed fixed-point arithmetic with 8 fractional bits, supports four-neighbor sequential accumulation, and stores the self, neighbor, edge, and head coefficients using ROM-style constant storage. The accelerator is controlled by a finite-state machine and uses a 12.5 ns clock constraint, corresponding to 80 MHz operation. Post-implementation reports were used to obtain resource utilization, timing, and power estimates. The final multi-neighbor FSM-based architecture with ROM-stored coefficients achieved timing closure at an 80 MHz clock constraint.

Table 7. Implementation results of the proposed lightweight RTL GNN-Lite accelerator.

Metric	Value
Target FPGA	Artix-7
Architecture style	FSM-based sequential RTL
Inference structure	Shared backbone + dual heads
Neighbor support	Multi-neighbor accumulation
Coefficient storage	ROM-based
Clock constraint	12.5 ns (80 MHz)
Worst Negative Slack (WNS)	0.532 ns
Latency	100 ns
LUTs	213
FFs	111
DSPs	18
BRAMs	0
I/O ports	13
BUFG	1
Total on-chip power	0.106 W
Dynamic power	0.001 W
Static power	0.104 W

shows that the implementation has a compact hardware footprint: 213 LUTs, 111 FFs, 18 DSPs, no BRAMs, and 13 I/O ports. The measured timing summary reports a worst negative slack (WNS) of 0.532 ns. The estimated total on-chip power is 0.106 W, with only 0.001 W dynamic power and 0.104 W static power. The latency is 100 ns per node, with a throughput of 10 million node inferences per second. The proposed hardware accelerator achieves an estimated total energy consumption of 10.6 nJ per inference. These results indicate that the simplified edge-aware inference path can be realized with very low active power and modest resource usage. The current hardware prototype validates the feasibility of mapping the simplified GNN-Lite inference path to FPGA hardware. The validation includes implementation resource utilization, timing closure, power estimation, latency, throughput, and energy per inference. The reported total, dynamic, and static power values should be interpreted as post-implementation tool estimates rather than measured hardware power.

As shown in

Table 8. Comparison with representative FPGA-based GNN and AI accelerators.

Work	Platform	Target Model	LUTs	DSPs	BRAM	Latency/Speedup	Power/Efficiency
[25]	Kintex-7	GCN, GraphSAGE	161,529	512	291.5	up to $1.7\times$ lower latency	up to $3.87\times$ efficiency
[26]	Alveo U250	GCN, GAT, GIN, GraphSAGE, SGC	778,000	10240	N/R	low-latency overlay	N/R
[27]	Xilinx Zynq-7000	Quantized CNN/NN	29,274	N/R	152.5	550 $\mathsf{\mu }$$\mathrm{s}$	2.3W
This work	Artix-7	RTL GNN-Lite	213	18	0	100 ns @ 80 MHz	0.106 W

N/R: not reported or not directly comparable from the cited work.

, most existing FPGA GNN accelerators target high-throughput inference for large graph workloads and are implemented on more capable FPGA platforms or CPU–FPGA platforms.

In contrast, the proposed RTL GNN-Lite accelerator is intentionally compact and targets low-power wireless edge inference. The design uses only 213 LUTs, 111 FFs, 18 DSPs, and no BRAM on Artix-7, while achieving 100 ns latency at an 80 MHz clock constraint. Although the proposed accelerator is not designed for large-scale graph analytics, its small footprint and low total on-chip power make it suitable for embedded wireless nodes where area and energy budgets are limited. This comparison highlights the main hardware advantage of the proposed architecture: lightweight deployment rather than maximum cloud-scale throughput. This design has three main advantages. First, it performs true multi-neighbor aggregation rather than pairwise processing. Second, it adopts an FSM-based sequential architecture consistent with low-resource edge inference. Third, it moves the coefficients into ROM-style storage, improving modularity and making the implementation closer to a practical deployment path.

5. Conclusions

This paper presented a communication-efficient federated graph-learning framework for wireless localization and spectrum misuser detection using MLP and graph-based neural backbones. The framework evaluates shared versus task-specific training, FedAvg and FedProx variants, multiple graph backbones, freeze-to-heads-based communication reduction, scalability behavior, multi-seed robustness, and lightweight FPGA-oriented inference. The original GNN-Shared configuration achieved a strong localization–communication trade-off, reducing localization error by 28.9% compared with MLP-Shared and by 17.7% compared with GNN-Loc_only, while reducing communication cost by 40.1% compared with MLP-Shared over 40 federated rounds. Additional baseline experiments showed that GraphSAGE-FedAvg achieved the strongest misuser detection performance among the tested graph baselines, while GAT-FedAvg provided the lowest communication cost in the multi-seed analysis. The results demonstrate that the shared graph neural network with the freeze-to-heads strategy provides the best overall balance between accuracy and communication, achieving a 28.9% lower localization error than the shared multilayer perceptron baseline and a 17.7% lower localization error than the graph neural network localization-only baseline. The shared graph neural network also improves the best misuser F1-score by 2.7% compared with the graph neural network misuser-only model and reduces the total communication cost by 40.1% compared with the shared multilayer perceptron model over 40 federated rounds. To move the framework closer to edge deployment, this paper also introduced a lightweight hardware-oriented GNN-Lite inference prototype with multi-neighbor accumulation, finite-state-machine-based sequential computation, and read-only-memory-based coefficient storage. The prototype achieved timing closure on an Artix-7 field-programmable gate array with 213 LUTs, 111 FFs, 18 DSPs, 0 BRAMs, and 0.106 W total on-chip power. The dynamic power was only 0.001 W, representing approximately 0.94% of the total estimated power, and the estimated total energy consumption was 10.6 nJ per inference. These results demonstrate the feasibility of mapping the core graph-inspired inference flow to low-resource hardware and support future development of practical edge-intelligence accelerators for wireless federated learning.