Neural Service Functions (NSFs)

• Neural Service Functions (NSFs) are stateful neural network units that perform split inference and decision-making in both data-plane and control-plane roles.
• NSFs utilize methods like graph neural networks, reinforcement learning, and dual-graph encoding to optimize service placement and routing.
• Empirical results demonstrate that NSFs enhance service recovery, reduce delays, and lower fault-tolerance costs by up to 44.8% compared to traditional models.

Neural Service Functions (NSFs) are neural-network-based service functions embedded into networked or cloud-native systems. In the explicit formulation used for multi-hop split inference and learning, an NSF is a stateful network function that executes a split sub-model of a global neural network and is integrated into the network as a transparent TCP proxy under Service Function Chaining (SFC) control (Hara et al., 12 Sep 2025). In adjacent work on edge–cloud orchestration and SFC, the same concept appears in a broader sense: neural modules consume topology, telemetry, or service-graph state and output routing, placement, or redeployment actions, thereby acting as learned control-plane functions (Abedpour et al., 24 Jun 2026, Herabad et al., 1 Jun 2026). A recurrent terminological issue is that several such systems realize NSF-like behavior without using the phrase Neural Service Functions explicitly; the literature therefore spans both explicit definitions and NSF-oriented interpretations (Schikuta et al., 2014, Heo et al., 2020, Heo et al., 2020).

1. Conceptual scope and exemplars

The literature considered here presents NSFs in two principal forms. First, NSFs can be data-plane execution units, where each service function is itself a neural computation block. This is the explicit position in multi-hop split inference and learning, where each sub-model $F^k$ is deployed on a node and chained as a service function (Hara et al., 12 Sep 2025). Second, NSFs can be control-plane decision functions, where a neural model receives system state and produces an orchestration action such as service placement, service recovery, or SFC path selection (Abedpour et al., 24 Jun 2026, Herabad et al., 1 Jun 2026, Heo et al., 2020, Heo et al., 2020).

A further line of work predates the term but already treats neural capabilities as service-accessible objects. N2Sky describes “neural networks as services” in a cloud and virtual-organization setting, with paradigm services, neural network objects, and explicit train, retrain, and evaluate service operations (Schikuta et al., 2014). This suggests that the service orientation of NSFs has roots in cloud-hosted model management as well as in SDN/NFV control.

Exemplar	Service role	Exposed function
N2Sky (Schikuta et al., 2014)	Neural-network service platform	train, retrain, evaluate
GNN-based SFC (Heo et al., 2020)	Neural SFC controller	Path and VNF-processing decisions
RL GNN-SFC (Heo et al., 2020)	Topology-agnostic SFC policy	Next node and process-VNF action
EP-NCO (Abedpour et al., 24 Jun 2026)	Neural placement/orchestration function	Component-to-node placement mapping
EES-CND (Herabad et al., 1 Jun 2026)	Drift-aware fault-tolerance function	state -> cost for redeployment
MSI/MSL NSF architecture (Hara et al., 12 Sep 2025)	Stateful split-model network function	Forward and backward neural execution

A common misconception is that NSFs denote only packet-processing functions analogous to classical VNFs. The explicit NSF definition in split inference indeed adopts a network-function wrapper, but the broader literature shows NSF-like realizations in orchestration, placement, and SFC decision-making, where the neural component operates in the control loop rather than directly on packets (Hara et al., 12 Sep 2025, Abedpour et al., 24 Jun 2026).

2. Architectural patterns

The explicit NSF architecture for multi-hop split inference and learning is built around a split global model

$F = (f^1, \ldots, f^L),$

partitioned into sub-models

$$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$

with each NSF corresponding to one sub-model $F^k$ (Hara et al., 12 Sep 2025). These NSFs are deployed on network nodes and integrated with SRv6, eBPF-based SFC proxying, and transparent TCP proxying. The control plane determines a segment list, and the data plane carries activations or gradients along that ordered chain (Hara et al., 12 Sep 2025).

In control-plane NSF formulations, the neural component resides in a centralized management entity. EES-CND places multiple lightweight neural networks in a centralized controller in the management/control layer, where they consume monitoring data and infer redeployment strategies during failure events. The surrounding system includes edge servers, APs, cloud nodes, and a monitoring subsystem that collects node health, resource usage, reliability scores, link bandwidth and delays, and service-component failures (Herabad et al., 1 Jun 2026). EP-NCO occupies a similar architectural position: it acts as a neural placement/orchestration function within NFV MANO, a Kubernetes scheduler, or an edge orchestrator, where it is invoked whenever a set of services must be deployed or redeployed (Abedpour et al., 24 Jun 2026).

The SFC literature provides a third architectural pattern: a graph encoder plus a sequential decoder. In the supervised GNN-based SFC model, a GG-NN encoder constructs topology-aware node embeddings and a decoder outputs probabilities of neighborhood nodes and their probabilities to process a VNF, thereby generating a service path step by step (Heo et al., 2020). In the reinforcement-learning extension, the same GG-RNN becomes a topology-agnostic SFC policy trained across varying topologies and VNF placements (Heo et al., 2020).

These systems collectively indicate that NSF architectures are typically closed-loop. Monitoring, graph construction, or packet interception produces state; the NSF computes either a service-management decision or a partial neural result; an orchestrator, SDN controller, or subsequent NSF stage then enacts the output (Hara et al., 12 Sep 2025, Herabad et al., 1 Jun 2026).

3. Formal models and decision interfaces

The explicit NSF definition in split inference and learning is compositional. Each NSF is one sub-model $F^k$, and the ordered service chain $(F^1, F^2, \dots, F^K)$ realizes the global model. Forward propagation satisfies

$$\hat{\mathbf{Y}^L} = F(\mathbf{X}^1), \quad \mathbf{X}^{l+1} = \hat{\mathbf{Y}^l},\quad l=1,\dots,L-1,$$

while training introduces a loss

$\mathcal{L}(\hat{\mathbf{Y}^L}, \mathbf{Y})$

and layerwise updates

$$\mathbf{W}^l \leftarrow \mathbf{W}^l - \eta \mathbf{G}^l.$$

Here, the NSF interface is effectively tensor stream in, tensor stream out, with state that includes model parameters, optimizer state, and per-flow buffering (Hara et al., 12 Sep 2025).

In edge–cloud control-plane NSFs, the interface is a state-to-decision mapping. EES-CND constructs, for each candidate node $CN_k$, the state vector

$F = (f^1, \ldots, f^L),$0

where $F = (f^1, \ldots, f^L),$1 contains CPU, memory, disk, and reliability; $F = (f^1, \ldots, f^L),$2 captures current network state; $F = (f^1, \ldots, f^L),$3 denotes resource demands of the failed component; and $F = (f^1, \ldots, f^L),$4 is the reconfiguration cost. Each neural network $F = (f^1, \ldots, f^L),$5 outputs an estimate of the fault-tolerance cost $F = (f^1, \ldots, f^L),$6, and the controller selects the node with minimum cost (Herabad et al., 1 Jun 2026).

EP-NCO formalizes placement via binary variables

$F = (f^1, \ldots, f^L),$7

under CPU, memory, and direct-link connectivity constraints. Its objective is

$F = (f^1, \ldots, f^L),$8

with execution time modeled as work over capacity and transmission delay modeled from data size, effective bandwidth, and propagation delay. The neural decoder constructs a feasible mapping sequentially, so the NSF interface is infrastructure graph plus service DAGs to placement mapping (Abedpour et al., 24 Jun 2026).

The SFC controllers expose yet another structured decision interface. In the RL GG-RNN model, the action is

$F = (f^1, \ldots, f^L),$9

and the reward uses the path delay

$$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$0

The supervised GG-NN variant learns from ILP-generated node-by-node paths and VNF-processing decisions, but the operational interface remains the same: current network state and chain requirements in, sequential SFC decisions out (Heo et al., 2020, Heo et al., 2020).

4. Learning mechanisms and constraint handling

NSFs in the cited literature are learned through several distinct paradigms. The supervised GNN-based SFC model uses ILP-generated labels and minimizes a loss

$$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$1

where node selection and VNF-processing decisions are trained with cross-entropy under teacher forcing. Its GG-NN encoder runs for $$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$2 propagation steps, and the decoder can be a DNN or GRU-based model (Heo et al., 2020).

The reinforcement-learning SFC extension replaces labeled optimal paths with REINFORCE. It defines terminal reward

$$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$3

and updates the GG-RNN policy by

$$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$4

Training uses randomized topologies derived from the “internet2” graph and, in the harder regime, random VNF relocation, so the policy learns across structural variation rather than on a single fixed graph (Heo et al., 2020).

EP-NCO combines graph representation learning with neural combinatorial optimization. It uses a dual-graph encoder: one GNN for the infrastructure graph and one GNN for the service DAG, followed by an autoregressive policy with multi-head attention. The RL objective is

$$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$5

optimized via REINFORCE, with entropy regularization

$$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$6

Constraint handling is explicit: a hard decoder masks infeasible nodes by setting logits of infeasible actions to $$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$7, whereas a soft decoder allows violations and penalizes them through the reward (Abedpour et al., 24 Jun 2026).

EES-CND uses a collaborative ensemble of lightweight neural networks, divided into a pretrained model group and an adaptive model group, with online updates by an enhanced evolution strategy. Its learning problem is not only to predict cost but also to track performance drift in dynamic edge–cloud environments, which makes adaptation part of the NSF itself rather than an external retraining process (Herabad et al., 1 Jun 2026).

These designs show that constraint handling in NSFs is not uniform. Some systems enforce feasibility at decoding time through masking or topology-local action spaces; others encode constraints indirectly through labels or episodic penalties. This suggests that NSF implementations depend strongly on whether invalid actions can be ruled out structurally or must be discouraged statistically (Abedpour et al., 24 Jun 2026, Heo et al., 2020).

5. Deployment substrates, orchestration, and interoperability

N2Sky provides an early service-oriented substrate for neural functionality. It maps onto the RAVO architecture with IaaS, PaaS, and SaaS layers, and its neural-network-specific components occupy the Neural Network Layer of PaaS. The platform includes the N2Sky Simulation Service, Data Archive, Database Service, Service Monitor, Paradigm/Replication Service, Registry, and user-facing Java or web clients. Paradigms are published, replicated, discovered, instantiated as neural network objects, and then executed through train, retrain, and evaluate operations exposed as services (Schikuta et al., 2014).

The split-inference NSF architecture uses a substantially different but equally service-oriented substrate. NSFs run with Libtorch, libbpf, Mininet, iptables, and TPROXY, while eBPF programs are attached to TC ingress/egress hooks. At ingress, the SFC proxy checks whether the outer destination address matches the local NSF SID, decapsulates SRv6, and stores the mapping from inner 5-tuple to outer IPv6 header and SRH in a BPF map. At egress, the proxy looks up the new flow’s 5-tuple, re-encapsulates the packet with the stored SRv6 state, and forwards it along the chain (Hara et al., 12 Sep 2025).

Control-plane NSFs are designed for integration with existing orchestration systems rather than for transport-level transparency. EP-NCO is explicitly positioned as a neural placement/orchestration function to be invoked by NFV MANO, a Kubernetes scheduler, or an edge orchestrator whenever a set of services must be deployed or redeployed (Abedpour et al., 24 Jun 2026). EES-CND similarly mediates between telemetry collectors and orchestration actions in a centralized management plane, with redeployment commands issued after neural inference (Herabad et al., 1 Jun 2026).

Across these systems, interoperability is achieved by treating neural logic as an encapsulated service component. In N2Sky, the encapsulation is API-level and cloud-native; in SFC-based split learning, it is transport-transparent and enforced by SRv6 plus eBPF; in edge–cloud orchestration, it is controller-centric and graph-driven (Schikuta et al., 2014, Hara et al., 12 Sep 2025, Abedpour et al., 24 Jun 2026).

6. Empirical behavior, advantages, and limitations

EES-CND reports that extensive simulations show effective handling of performance drift and significant gains in service recovery time, response time, and reliability, with a 44.8\% reduction in fault-tolerance cost compared to standalone models (Herabad et al., 1 Jun 2026). EP-NCO reports reductions in total service response time of 46%--50% relative to GA and PSO and 25%--35% relative to controlled RL ablation baselines; once trained, it supports fast online inference and reports ~0.9–1.0 seconds on XL instances with ~145 compute nodes, 75 services, and 8 components per service (Abedpour et al., 24 Jun 2026).

The explicit NSF architecture for split inference and learning shows that SFC integration does not materially degrade model quality. After ~13,000 s (200 epochs), both the NSF-based and baseline split-learning systems reach training accuracy of ≈ 99.8 %, training loss of ≈ 0.002, and test accuracy of ≈ 71.1 %. For inference with $$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$8, per-round latency is 38.7 ms for the SFC-based architecture and 39.2 ms for the baseline. With $$F = (F^1, \ldots, F^K), \quad F^k = (f^l, \ldots, f^{l+L^k-1}),$$9, per-round training latency is about 173 ms for both. Under induced congestion, the SDN controller changes the SRv6 segment list and returns latency to the original level during the congestion period, whereas the baseline lacks dynamic reconfiguration capability (Hara et al., 12 Sep 2025).

The supervised GNN-based SFC model reports strong gains over a DNN baseline on the original topology. The GG-RNN achieves Avg. cost ratio 0.995, Fail Ratio 0.012, and Overmax 0.159, compared with the baseline DNN’s 1.209, 0.063, and 0.243. On a changed topology without retraining, the baseline DNN is not applicable because its input dimensionality is fixed, whereas the GG-RNN remains usable and reports Avg. cost ratio 1.078, Fail Ratio 0.128, and Overmax 0.188 (Heo et al., 2020).

The RL GG-RNN for SFC emphasizes robustness to topology changes. On the hardest Random Topology + VNFs test, the supervised baseline reports Failure Ratio 0.7399 with Deterioration Rate 92.5, whereas RL($F^k$0) + CS2 reports 0.0663 and 6.4, and RL($F^k$1) + CS2 reports 0.0817 and 6.1. The original-topology delay ratio remains worse than the supervised baseline, which the paper interprets as a trade-off between topology-specific optimality and robustness under distributional variation (Heo et al., 2020).

Limitations are correspondingly diverse. The split-learning NSF architecture notes scalability costs as the number of splits $F^k$2 increases, substantial waiting time in synchronous MSL, deployment complexity arising from SRv6, eBPF, TPROXY, and SDN-controller integration, and the absence of stateful failover mechanisms (Hara et al., 12 Sep 2025). EP-NCO largely assumes static topology and per-episode conditions, with no implemented online adaptation or continual learning (Abedpour et al., 24 Jun 2026). The SFC papers simplify QoS mainly to delay and do not model richer SLA dimensions such as packet loss or jitter (Heo et al., 2020, Heo et al., 2020). N2Sky, while service-oriented and extensible, does not provide fine-grained serverless execution, explicit model versioning, or complex multi-model pipelines (Schikuta et al., 2014).

Taken together, the literature presents NSFs as a general service abstraction for neural computation and neural control. In one lineage, NSFs are executable split-model functions inserted directly into packet paths; in another, they are learned orchestration functions embedded into SDN/NFV or edge–cloud management loops. The common denominator is not a single implementation style but a shared operational idea: neural models are packaged, invoked, and orchestrated as service functions whose outputs have immediate systems consequences (Hara et al., 12 Sep 2025, Herabad et al., 1 Jun 2026, Abedpour et al., 24 Jun 2026).