Structure-Aware State Encoding (SASE)

• SASE is a state representation module for TAGRL that encodes both local node features and global topological structure in cloud networks.
• It combines multi-layer graph convolution, shortest-path positional embeddings, and attention-based neighbor aggregation to capture comprehensive routing information.
• Empirical results on the GEANT dataset demonstrate improved throughput, lower latency, and enhanced robustness in adaptive cloud routing.

Searching arXiv for the target paper and closely related uses of “SASE” to ground the article in published work. arXiv search query: "(Wang et al., 5 Sep 2025) Topology-Aware Graph Reinforcement Learning for Dynamic Routing in Cloud Networks" Structure-Aware State Encoding (SASE) is the state-representation module of the Topology-Aware Graph Reinforcement Learning (TAGRL) framework for dynamic routing in cloud networks. In that setting, SASE converts a cloud-network graph $G=(V,E)$ with node attributes and a changing topology into a structure-aware state matrix that is expressive enough for routing decisions and stable under topology changes. Its defining idea is to inject graph structure, multi-hop neighborhood context, and shortest-path-based positional information into the policy input, rather than relying on raw node features or shallow local embeddings alone (Wang et al., 5 Sep 2025).

1. Motivation and problem setting

SASE is introduced to address limitations that the TAGRL paper attributes to standard graph reinforcement learning methods in cloud routing: shallow state representations, insufficient awareness of topology changes, weak modeling of high-order dependencies, and poor robustness when the network becomes sparse or shifts dynamically (Wang et al., 5 Sep 2025).

The underlying claim is architectural rather than merely empirical. In a cloud server environment, a node’s local load is not enough to determine a good routing action. The policy also needs information about how a node sits in the global topology, which neighbors are structurally influential, whether a path is central, peripheral, or bottleneck-prone, and how the communication pattern changes over time. SASE is therefore designed to encode two complementary components in the policy state: local structural features through graph convolution or neighbor aggregation, and global structural position through shortest-path-based positional embeddings.

This design distinguishes SASE from a plain node-feature encoder. The module does not treat routing as a purely local control problem. Instead, it makes routing decisions dependent on the broader graph context. A plausible implication is that the encoder is meant to reduce the gap between instantaneous node observations and the topological semantics that determine congestion propagation, path centrality, and structural bottlenecks.

2. Mathematical formulation

The cloud network is modeled as a graph

$G=(V,E),$

where $V$ is the set of nodes and $E$ is the set of edges. Each node $v_i \in V$ has a feature vector collected in

$$X = [x_1, x_2, \ldots, x_n] \in \mathbb{R}^{n \times d}.$$

The paper states that node features may include static attributes such as computing power and dynamic attributes such as load, cache, and latency. The adjacency matrix is

$A \in \mathbb{R}^{n \times n},$

with $A_{ij}=1$ if node $i$ is connected to node $j$ (Wang et al., 5 Sep 2025).

SASE first applies multi-layer graph convolution: $G=(V,E),$0 where $G=(V,E),$1 is the adjacency matrix with self-loops, $G=(V,E),$2 is the degree matrix of $G=(V,E),$3, $G=(V,E),$4 is the layer-$G=(V,E),$5 node representation, $G=(V,E),$6 is a learnable weight matrix, and $G=(V,E),$7 is an activation function such as ReLU. The paper characterizes this as the standard normalized message-passing form used in GCN-style encoders. Its role is to propagate information across neighbors while controlling scale through symmetric normalization, so that receptive fields expand across multiple hops.

To encode structural role, SASE adds a positional embedding derived from shortest-path distance. Each node $G=(V,E),$8 receives

$G=(V,E),$9

and the structurally aware node state is defined by concatenation: $V$0 The complete encoding matrix is

$V$1

Here $V$2 is the graph-convolutional node representation, $V$3 is the structural positional embedding, $V$4 is the learned node-representation dimension, and $V$5 is the positional embedding dimension.

SASE also includes attention-based neighborhood aggregation: $V$6 where $V$7 is the neighborhood of node $V$8 and $V$9 is an attention-based weight coefficient. This weighted sum is intended to emphasize structurally influential neighbors rather than treating all adjacent nodes equally. The paper’s interpretation is that such weighting is especially useful in heterogeneous topologies where some edges are more traffic-bearing or more bottleneck-contributing than others.

3. Structural information captured

The TAGRL formulation assigns SASE four simultaneous representational functions. First, it captures local structural information: immediate neighborhood connectivity, local load patterns, edge density around a node, and near-term congestion context (Wang et al., 5 Sep 2025).

Second, it captures higher-order structural information through stacked graph convolutions. In the paper’s terminology, this includes multi-hop dependencies, indirect communication influence, and graph-wide connectivity patterns. This is the main reason that SASE is described as modeling high-order dependencies rather than only immediate adjacency.

Third, it captures relative topological position through shortest-path-distance-based role encoding. The paper explicitly frames this as distinguishing whether a node is central, peripheral, or bridging, and as supporting structural equivalence across different parts of the graph. The canonical example is that a core router and a leaf router may both have moderate load, but they should not be treated identically by a routing policy.

Fourth, it captures weighted relational influence through attention-based aggregation over neighbors. This lets the encoder distinguish more important neighbors from less important ones. Taken together, these components make the state representation richer than raw node features or a purely local embedding.

A common misconception is to interpret SASE as only “multi-layer GCN plus extra features.” That description is incomplete. In the paper’s formulation, the decisive addition is the combination of normalized graph convolution, self-loops, structural positional embeddings, and attention-weighted aggregation. SASE therefore encodes both node attributes and structural semantics, not only node attributes propagated over a graph.

4. System role within TAGRL

SASE operates before the policy network and serves as the system’s state abstraction layer. The workflow described in the paper is: observe the current graph state, encode it with SASE, feed the encoded state to the policy network, receive reward feedback, optionally update the graph structure through Policy-Adaptive Graph Update (PAGU), and repeat (Wang et al., 5 Sep 2025).

Its relation to PAGU is central. PAGU modifies the graph structure based on policy behavior shifts and reward feedback, with adjacency updated as

$E$0

The updated graph is then re-encoded by SASE. The paper therefore presents a closed feedback loop: PAGU changes topology, SASE re-encodes the new topology, and the policy network makes decisions from the new state. This means that SASE is not a fixed-graph encoder. It continually re-encodes whatever topology PAGU produces, which is the mechanism by which TAGRL remains adaptive under dynamic topologies.

Training is described as policy gradient-based reinforcement learning with the objective of maximizing cumulative long-term reward. The policy network uses two graph convolutional layers, one fully connected output layer, ReLU activations, and hidden dimension 128. Optimization includes entropy regularization with coefficient $E$1, discount factor $E$2, the Adam optimizer, learning rate $E$3, and weight decay $E$4. The paper does not provide a separate loss formula specifically for SASE, but SASE-derived representations are directly consumed by the policy network; accordingly, the representation quality of SASE affects the policy’s value and action-distribution estimates.

5. Empirical behavior and robustness

The clearest quantitative evidence for SASE comes from the ablation study on the GEANT topology dataset. The paper reports that the Baseline achieves Avg. Throughput 9.02, Avg. Latency 33.5, Max Link Utilisation 82.1, and Reward 253.7, whereas +SASE achieves Avg. Throughput 9.34, Avg. Latency 30.1, Max Link Utilisation 78.4, and Reward 267.6. The full model, Ours (+All), reaches Avg. Throughput 9.81, Avg. Latency 27.3, Max Link Utilisation 74.2, and Reward 288.9 (Wang et al., 5 Sep 2025).

These results are used in the paper to support four claims about SASE. It improves expressiveness by combining GCN embeddings and positional embeddings; it improves decision quality because routing depends on both current load and structural placement; it improves stability because the policy sees structure-aware rather than incomplete local observations; and it improves generalization because structural encodings are not tied only to raw feature values.

The robustness analyses refine that picture. Under graph sparsity perturbation, the paper reports that higher retention ratio → higher reward, that sparser graphs → worse performance and more instability, and that when retention exceeds about 0.6, fluctuations decrease markedly. This is directly relevant to SASE because its effectiveness depends on the availability of structural information. When important edges or path information are removed, the encoder cannot fully recover the topology, so state representations degrade.

The paper also evaluates node feature dimensionality and reports that performance improves as feature dimension increases from 16 to 128, that the best performance occurs at 128, and that performance slightly drops at 256. This indicates that SASE is not solely a structure encoder; it is a mechanism for fusing structural and attribute information. The paper’s interpretation is that too little feature capacity cannot represent the needed context, whereas overly large dimensions can introduce redundancy and instability.

6. Terminology, scope, and related formulations

The acronym SASE is not unique in the literature. In classical planning, “SASE” refers to SAS+ Planning as Satisfiability, a SAT encoding built directly on the SAS+ formalism and centered on transition variables rather than graph-reinforcement-learning state representations (Huang et al., 2014). In that earlier use, the acronym denotes a planning compilation scheme, not a neural state encoder.

Within more recent arXiv literature, several methods are explicitly described as structure-aware encoders or as SASE-like formulations, but they target different substrates. “Semi-Structured Object Sequence Encoders” models sequences of key-value objects by encoding temporal state per key and then self-attending across keys (V et al., 2023). “A representational framework for learning and encoding structurally enriched trajectories in complex agent environments” shifts from low-level state-action compression to heterogeneous graph encodings of objects, interactions, affordances, states, and trajectories (Catarau-Cotutiu et al., 17 Mar 2025). “The Potential of Structure-Aware Encoding in Language Embeddings” integrates structural neighbors into the encoder’s hidden-state or KV-cache computation rather than using post-hoc aggregation (Liu et al., 9 Oct 2025).

These usages share a family resemblance: structure is introduced during representation formation rather than appended after the fact. Even so, the SASE module in TAGRL has a narrower and more specific meaning. It is a graph-state encoder for dynamic cloud routing, built from multi-layer normalized graph convolution, shortest-path-based positional embedding, and attention-weighted neighborhood aggregation. A plausible implication is that “Structure-Aware State Encoding” functions less as a single canonical method than as a design principle whose concrete realization depends strongly on the state substrate—graph topology in TAGRL, key-wise temporal evolution in semi-structured sequences, heterogeneous trajectory graphs in SETLE, or structural neighbor context in language embeddings.

In the TAGRL context, SASE is therefore best understood neither as a generic synonym for graph encoding nor as a standalone routing algorithm. It is the representation engine that makes topology-aware policy learning possible by turning raw cloud-network observations into a structure-aware state suitable for adaptive routing (Wang et al., 5 Sep 2025).