Graph Neural Architecture Search (GraphNAS)

Defines the set of possible architectural components that GraphNAS can explore. For cellular GNNs, this includes:

• Aggregation functions: sum, mean, max, or attention-based pooling
• Activation functions: ReLU, LeakyReLU, PReLU, tanh
• Layer connectivity: skip connections, concatenation, or dense connections
• Number of attention heads in GAT layers
• Hidden dimension sizes per layer The search space must be carefully designed to balance expressiveness with tractability, as an overly large space leads to combinatorial explosion.

A recurrent neural network (RNN) controller generates candidate GNN architectures as variable-length strings of architectural decisions. The process works as follows:

• The controller samples an architecture from the search space
• The candidate GNN is trained on the target cellular task (e.g., interference prediction)
• Validation accuracy serves as the reward signal
• The controller updates its policy via REINFORCE or PPO to generate higher-performing architectures over time This iterative loop discovers architectures that outperform human-designed baselines on tasks like resource block allocation and handover prediction.

An alternative to RL-based search that relaxes the discrete architecture selection into a continuous optimization problem:

• Each architectural choice is assigned a continuous weight via softmax over all possible operations
• The model jointly optimizes architecture weights and network parameters using gradient descent
• After convergence, the strongest operation per edge is selected This approach reduces search time from thousands of GPU-hours to a single training run, making it practical for dynamic cellular topology graphs where search must be repeated as network conditions change.

Cellular network optimization requires balancing competing objectives. GraphNAS extends to multi-objective search by optimizing for:

• Spectral efficiency of resource allocation
• Inference latency for real-time decision making
• Model size for deployment on edge hardware at base stations
• Energy consumption of the learned policy Pareto-optimal architectures are discovered using scalarization (weighted sum of objectives) or evolutionary algorithms like NSGA-II, producing a frontier of trade-off solutions for network operators to choose from.

Incorporates deployment constraints directly into the architecture search loop:

• Latency predictors estimate inference time on target NPU or GPU hardware
• Memory budget constraints limit the number of parameters
• Energy consumption models guide search toward power-efficient architectures This ensures discovered GNNs are not just accurate but also deployable on O-RAN distributed units (O-DUs) with strict real-time requirements. The search produces architectures that meet the sub-10ms latency budgets required for MAC-layer scheduling decisions.

Architectures discovered via GraphNAS on one cellular topology often transfer to related tasks:

• A GNN optimized for interference graph coloring on a dense urban deployment transfers to suburban topologies with minimal fine-tuning
• Search on synthetic cellular topologies generalizes to real-world network graphs
• Discovered architectural motifs—such as the preference for GAT layers with 4 attention heads followed by mean aggregation—become reusable design patterns This transferability amortizes the cost of architecture search across multiple network optimization tasks.

The foundational deep learning architecture that operates directly on graph-structured data. GNNs learn representations by iteratively aggregating feature information from a node's local neighborhood, making them ideal for non-Euclidean domains like cellular topologies.

• Message Passing: The core mechanism where nodes exchange feature vectors along edges.
• Permutation Invariance: Guarantees the output is independent of node ordering.
• Applications: Node classification, link prediction, and graph-level regression.

A sophisticated GNN architecture that introduces a self-attention mechanism to the aggregation process. Instead of treating all neighbors equally, GATs dynamically compute implicit weights, allowing nodes to focus on the most relevant connections.

• Dynamic Weighting: Learns to assign higher importance to critical interferers.
• Scalability: The attention operation is highly parallelizable.
• Use Case: Modeling interference graphs where the impact of neighboring cells varies significantly.

The overarching automated machine learning (AutoML) paradigm that GraphNAS belongs to. NAS algorithms treat the design of a neural network's architecture as a search problem over a defined space of possible operations and connections.

• Search Space: Defines the permissible layers, skip connections, and hyperparameters.
• Search Strategy: The algorithm used to explore the space (e.g., reinforcement learning, evolutionary methods).
• Performance Estimation: A fast proxy metric to evaluate candidate architectures without full training.

A common search strategy used in early NAS and GraphNAS systems. A recurrent neural network acts as a controller that samples a candidate GNN architecture string. The validation accuracy of the trained candidate serves as the reward signal to update the controller's policy.

• Markov Decision Process: The sequential generation of layer types is modeled as an MDP.
• Policy Gradient: Methods like REINFORCE are used to train the controller.
• Drawback: Can be computationally expensive due to the need for full or partial training of many candidates.

A highly efficient NAS paradigm that relaxes the discrete search space into a continuous, differentiable one. Instead of selecting a single operation, DARTS computes a weighted sum of all candidate operations, allowing the architecture and model weights to be optimized jointly via gradient descent.

• Efficiency: Discovers architectures in hours, not thousands of GPU-days.
• Bilevel Optimization: Alternates between training network weights and architecture parameters.
• GraphNAS Variant: Adapts DARTS to search for optimal GNN aggregation functions and layer connectivity.

A critical failure mode in deep GNNs that GraphNAS must explicitly avoid. As the number of message-passing layers increases, node representations become indistinguishable from one another, losing local discriminative power.

• Cause: Excessive recursive averaging of neighborhood features.
• Impact: Severely degrades performance on node-level tasks like congestion classification.
• Mitigation: GraphNAS can learn to use skip connections or limit the effective depth of the searched architecture.