GraphEdge: Dynamic Partitioning & Offloading

• GraphEdge is a GNN-centric edge computing framework that dynamically partitions graphs and offloads tasks to optimize resource use.
• The HiCut algorithm uses BFS-driven, aggregation-aware graph cuts to form dense subgraphs and reduce inter-server communication costs.
• DRLGO leverages multi-agent deep reinforcement learning to assign subgraphs to servers, yielding lower total cost and enhanced scalability.

GraphEdge refers to a GNN-centric, edge-computing architecture for dynamic graph partitioning and task offloading in multi-server edge environments, specifically addressing joint partitioning and scheduling problems arising in real-world scenarios such as IoT inference, traffic prediction, and recommendation with GNNs (Xiao et al., 22 Apr 2025). The framework tightly integrates an aggregation-aware, hierarchical graph cut (HiCut) partitioning with a multi-agent deep reinforcement learning (DRL) scheduler (DRLGO), targeting minimization of both inter-server communication overhead and joint latency-energy costs under dynamic, topologically varying user graphs.

1. Dynamic Graph Partitioning and Offloading Problem

GraphEdge models a distributed edge-computing system where user devices $U_i$ continuously generate task data and are associated by a time-varying undirected graph $G_t = (V_t, E_t)$. Each device $U_i$'s GNN inference requires partial aggregation of neighboring users’ data, leading to intertwined computational and communication dependencies during forward propagation. The infrastructure comprises $M$ access-point/edge-server pairs $\{AP_k,SV_k\}$, with every user choosing a single AP/server pair per inference cycle. The key challenge is to adaptively allocate users to edge servers and partition the dynamic graph so as to minimize the sum of: (i) uplink offloading and compute costs; and (ii) inter-server data transfer—the latter induced by GNN neighborhood aggregation when subgraph boundaries are crossed.

The formal objective at time $t$ is to solve

$\min_{w(t)} \sum_{t=1}^T C(w(t) | G_t, \omega)$

subject to $\sum_k w_{ik}(t) = 1$ and all resource constraints, where $w_{ik}(t)$ is the (binary) server assignment for user $U_i$, and $G_t = (V_t, E_t)$0 aggregates all offloading, inference, and communication costs. Because cross-server message passing is proportional to the cut-edges in the graph partition and the GNN aggregation radius, partitioning and offloading must be optimized jointly and adaptively with respect to changing $G_t = (V_t, E_t)$1.

2. Hierarchical Traversal Graph Cut (HiCut) Algorithm

Conventional graph partitioners such as min-cut or max-flow do not account for variable aggregation radii or the dynamic, semantically weighted cost structure of GNN inference. HiCut is explicitly designed to minimize the communication cost due to cross-server message passing under multi-hop aggregation. It builds the subgraph partitioning as follows:

• Perform a BFS from each seed node, at each BFS layer $G_t = (V_t, E_t)$2 computing the number of cut-edges $G_t = (V_t, E_t)$3 (edges crossing from the current subgraph candidate to the remainder).
• Identify “valleys” where $G_t = (V_t, E_t)$4, storing vertices as candidate partition boundaries.
• When $G_t = (V_t, E_t)$5 increases again, finalize a cut at the current boundary and designate the corresponding vertices as a subgraph.
• Remove all assigned nodes, restart from an unused seed, and iterate until all vertices are partitioned.

This process constructs subgraphs that are internally dense but weakly connected to others, directly reducing the required inter-server aggregation traffic. Let $G_t = (V_t, E_t)$6 be the per-bit communication energy for inter-server links, and $G_t = (V_t, E_t)$7 be the data size for user $G_t = (V_t, E_t)$8. For a partitioning $G_t = (V_t, E_t)$9, the cross-server communication cost is: $U_i$0 This construction enables computational complexity $U_i$1 in the worst case, outperforming max-flow algorithms on practical, moderately sized dynamic graphs.

3. Multi-Agent DRL-Based Graph Offloading (DRLGO)

Once the graph is partitioned, GraphEdge invokes DRLGO—a multi-agent reinforcement learning controller—for task offloading. Each agent (server) receives current local observations encapsulating user positions, local bandwidths, server load, data sizes, and subgraph memberships. The action space is continuous, with the offloading determined by the maximal agent output across all servers. Critically, the reward incorporates both immediate offloading/inference cost and a subgraph “splitting penalty” to discourage distributing a single subgraph’s users across multiple servers. This design is realized in practice as a MADDPG (Multi-Agent Deep Deterministic Policy Gradient) system with centralized critics and decentralized actors, trained on episodic rollouts with experience replay and target networks.

Key components:

• Reward: $U_i$2, where $U_i$3 is total cost for agent $U_i$4, and $U_i$5.
• Policy learning: Centralized Q-functions $U_i$6, decentralized actors $U_i$7, with gradients and TD-errors propagated as in standard MADDPG.
• Implementation: 3-layer MLPs (64 units per layer), learning rate $U_i$8, discount $U_i$9, batch size 256.

This offloading framework automatically adapts to time-varying resource availability, link quality, and user mobility, providing robust partition-to-server assignments.

4. Integrated System Workflow

At each inference cycle:

1. The controller senses and collects the latest user set $M$0, associations $M$1, and feature/data masks, constructing $M$2.
2. HiCut partitions $M$3 into $M$4 subgraphs by BFS-driven, aggregation-aware cuts.
3. Local user/server features are fed into the DRLGO agents to jointly optimize the subgraph-to-server mapping (i.e., offloading).
4. Resulting assignments are disseminated, user data is uploaded, and distributed GNN inference commences, with cross-server data transfer triggered only along cut-edges.
5. Servers propagate results to users. Rewards and transitions are collected, replay buffers updated, and agent networks trained periodically.

HiCut and DRLGO are both executed dynamically as user graphs evolve, supporting both user churn and changing connectivity.

5. Experimental Results and Performance Benchmarks

GraphEdge was evaluated on standard citation graph datasets (Cora, CiteSeer, PubMed), subsampling user sets of up to 300 nodes and limiting data size per user to 1.5 MB. Four representative GNN architectures (GCN, GAT, GraphSAGE, SGC) were used as task backbones (accuracies 60–80%). Baselines include PTOM (single-agent PPO), greedy, and random assignment policies.

Main findings:

• HiCut achieves 10× speedup over traditional min-cut in the tested regime (sparse to moderately dense graphs), scaling as $M$5.
• DRLGO yields up to 50% reduction in total cost ($M$6) and 30–45% lower cross-server communication compared to greedy and random policies.
• Under dynamic scenarios such as user mobility and topology rewiring, DRLGO outperforms single-agent PPO (PTOM) by ≈25% in total cost, and converges more stably (≈2,000 episodes to reward plateau).
• Ablation reveals that the inclusion of HiCut and subgraph-splitting penalty enables an additional 15–20% reduction in inter-server cost.

The approach is robust to rapid topology changes, but transient performance drops may occur until the policy re-adapts.

6. Limitations and Extensions

GraphEdge inherits several limitations:

• Scalability: HiCut can be $M$7 for very large $M$8, suggesting the need for incremental, streaming, or decentralized partitioners for massive IoT deployments.
• Centralization: HiCut and DRLGO rely on access to global state, although decentralized or federated extensions are plausible avenues.
• Dynamic adaptation: Large, abrupt graph changes result in intermediate policy inefficiency, although convergence is restored on the order of hundreds of adaptation steps.
• Potential research extensions include online incremental partitioning, GNN-architecture-aware cutting, integration of mobile edge servers, multi-objective (fairness, privacy) reward shaping, and improved handling of federated or privacy-constrained user graphs.

GraphEdge establishes a scalable, GNN-centric, partition–and–offloading policy stack for edge AI, combining topology-aware graph cuts with adaptive, DRL-driven server assignment (Xiao et al., 22 Apr 2025). This design framework addresses core challenges in distributed GNN inference, particularly the interdependence of graph topology, computational assignment, and communication cost in heterogeneous networked systems.