LLM-Steered Power Allocation for Parallel QPSK-AWGN Channels

1. Problem Statement

The paper addresses the challenge of integrating Large Language Models (LLMs) into real-time, closed-loop control systems for wireless communications. While LLMs excel at high-level reasoning and interpreting natural language, their stochastic nature poses significant risks for safety-critical applications like resource allocation, where constraint violations (e.g., exceeding power limits) are unacceptable.

Specifically, the authors focus on power allocation over parallel QPSK-AWGN channels. This is a fundamental problem in multi-band systems (like OFDM). Unlike Gaussian-input channels where "water-filling" provides a closed-form optimal solution, discrete-input channels (like QPSK) exhibit mutual information (MI) saturation. This makes the optimization problem non-concave and requires numerical methods. The core problem is: How can an LLM dynamically steer an optimizer to adapt to changing environmental conditions and user intents (e.g., prioritizing fairness vs. throughput) without violating hard physical constraints?

2. Methodology: Dual-Process Architecture

The proposed solution, LLM-Steered Power Allocation, is inspired by Kahneman's dual-process theory of cognition, mapping it to a two-loop control architecture:

System 1: The Fast Optimizer (Numerical Engine)

• Role: Continuously performs Projected Gradient Ascent to maximize a weighted sum of Mutual Information (MI) across $N$ parallel channels.
• Mechanism:
  • Uses automatic differentiation (autograd) to compute gradients of the MI objective with respect to transmit amplitudes ($\lambda_i$).
  • Enforces constraints strictly: It clamps amplitudes to a minimum positive value (to prevent zero-gradient traps) and projects the solution onto the $\ell_2$-ball defined by the total power budget ($P_{total}$).
  • Safety Guarantee: The LLM never directly manipulates the power allocation variables ($\lambda$). Feasibility is mathematically guaranteed by System 1's projection step, regardless of the LLM's output.

System 2: The LLM Navigator (Semantic Interpreter)

• Role: Periodically (every 1–3 seconds) interprets a user-provided Natural Language (NL) policy and updates the optimization parameters.
• Control Variables: The LLM only adjusts:
  1. Weight Vector ($w$): Determines the relative priority of each sub-channel.
  2. Total Power Budget ($P_{total}$): The operational power cap (e.g., to save energy).
• Design Features:
  • Memoryless: Each LLM call is stateless, receiving only the current system state summary and the policy string.
  • Indirect Actuation: By only changing the objective weights and constraints, the LLM steers the optimizer without risking immediate constraint violations.

Multi-Layer Guardrails

To mitigate LLM unreliability (hallucinations, parsing errors), the system employs:

1. Structural Safety: Indirect control ensures constraints are always met by System 1.
2. Normalization & Clamping: Raw LLM outputs are clipped (negative weights $\to$ 0), normalized (sum to 1), and power budgets are clamped to safe ranges.
3. Exponential Moving Average (EMA): Updates are smoothed ($w_{t+1} = (1-\beta)w_t + \beta \hat{w}_t$) to prevent erratic jumps.
4. Fallback Mechanism: If the LLM fails (timeout, parse error), the system retains the last valid parameters, ensuring graceful degradation rather than system failure.
5. Explainability: The LLM outputs a "reasoning" field explaining its decision, allowing for human audit.

3. Key Contributions

1. Dual-Process Architecture: A novel framework separating fast numerical optimization (System 1) from slow semantic policy interpretation (System 2), ensuring safety by construction.
2. Zero-Shot Policy Adaptation: The system can switch between diverse operating modes (e.g., "maximize throughput," "prioritize specific channels," "minimize power") simply by changing the NL prompt, without retraining or code changes.
3. Robust Guardrails: A comprehensive set of post-processing techniques (normalization, EMA, fallback) that allow LLMs to be used in control loops safely.
4. Resilience Demonstration: Proof that the system can autonomously reconfigure in response to abrupt environmental changes (channel gain reversals) to maintain specific performance goals (e.g., equalizing MI).

4. Experimental Results

Experiments were conducted on an 8-channel QPSK-AWGN system using a 20B parameter open-weight LLM.

• Policy Effectiveness: The system successfully achieved distinct operating points based on four different NL policies:

  • Maximize Throughput: Equal weights, maximizing sum rate (~13.8 bits).
  • Prioritize Channels 7 & 8: Shifted weights heavily to these channels, saturating their MI.
  • Minimize Power (with rate constraint): Reduced total power budget while maintaining a sum rate >10 bits.
  • Shut Down Weak Channels: Set weights to zero for the three weakest channels, reallocating power to the rest.
  • Comparison: The LLM-steered approach outperformed standard water-filling (which assumes Gaussian inputs) by ~0.8 bits in sum rate, confirming the necessity of numerical optimization for discrete inputs.

• Resilience (Homeostasis):

  • Scenario: An abrupt reversal of channel gains (strongest became weakest) occurred at step 150.
  • Goal: Equalize MI across all channels.
  • Result: The LLM detected the change and flipped the weight priorities within one update cycle. The final MI spread ($\Delta$) was 0.22 bits with LLM steering, compared to 0.55 bits for a baseline optimizer with fixed equal weights. This represents a 60% reduction in MI disparity, demonstrating the system's ability to adapt its optimization goal dynamically.

5. Significance

This paper provides a critical blueprint for integrating Generative AI into real-time engineering control loops.

• Safety First: It demonstrates that LLMs can be used as "policy interpreters" rather than direct controllers, effectively decoupling the stochastic nature of LLMs from the hard constraints of physical systems.
• Flexibility: It moves beyond static, hard-coded control logic to semantic control, where operators can define intent in natural language, and the system adapts its optimization strategy accordingly.
• Future Impact: The proposed dual-process paradigm (Fast Solver + Slow Semantic Reasoner) offers a scalable design pattern for next-generation resilient wireless networks, potentially extendable to MIMO, dynamic spectrum access, and complex multi-user resource management.