Neural System Identification & Learning-Enabled Control

A neural network becomes part of a control system in several fundamentally different ways. It may predict plant dynamics, estimate an unmeasured state, supply a bounded correction to a nominal controller, or directly map observations to actions. Calling all four “neural control” hides which signal is learned, what authority it receives, and what closed-loop property must be demonstrated.

Four roles, four evidence obligations #

The closer the learned component is to the actuator, the stronger the required assurance. A one-step model used only for monitoring has very different consequences from a policy with full actuator authority.

Dynamic identification needs memory #

A static regressor $y=f(u)$ cannot represent a system whose output depends on stored energy or delayed effects. A nonlinear autoregressive model with exogenous input can use

$$\hat y_{k+1}=f_\theta( y_k,\ldots,y_{k-n_y+1}, u_k,\ldots,u_{k-n_u+1}).$$

A recurrent network instead carries an internal state

$$h_{k+1}=g_\theta(h_k,u_k,y_k),\qquad \hat y_{k+1}=q_\theta(h_{k+1}).$$

The history length or learned state must cover relevant plant memory. Too little memory biases the model; excessive history can leak slowly changing operating conditions and make validation deceptively easy.

One-step loss is not rollout accuracy #

Teacher-forced training supplies the true $y_k$ at each step and minimizes

$$L_1=\sum_k\lVert y_{k+1}-\hat y_{k+1}\rVert^2.$$

During simulation or model-predictive control, the network consumes its own predictions. Small errors alter the next input and can compound. A rollout objective tests

$$L_H=\sum_k\sum_{j=1}^{H} \lVert y_{k+j}-\hat y_{k+j\mid k}\rVert^2,$$

for horizons relevant to the controller. Both metrics are needed: one-step error diagnoses local fit; rollout error exposes unstable or drifting learned dynamics.

Closed-loop data are not ordinary training samples #

A controller chooses inputs based on past outputs, so input, state, and disturbance are correlated. The data concentrate near states the current controller already visits. A network may fit that narrow distribution extremely well while knowing nothing about recovery states, saturation, new references, or faults.

Validation should split by complete experiments or time blocks and separately cover:

• operating points and transition paths;
• reference families and disturbance classes;
• actuator limits and rate constraints;
• recovery from off-nominal state;
• sensor noise, bias, missing data, and timing jitter;
• long rollouts and closed-loop use with the intended controller.

Randomly shuffling adjacent samples across train and test sets leaks trajectory context.

Direct and indirect neural control #

In indirect control, the network supplies a plant model or state estimate, and a conventional synthesis mechanism computes the action. The controller can expose constraints and costs explicitly, but its guarantees depend on the learned model's error envelope.

In direct control, a policy $u=\pi_\theta(x,r)$ produces the action. This removes the online optimization step but embeds the control law in a high-dimensional nonlinear function. Testing examples cannot enumerate its behavior between and beyond observed states.

A conservative intermediate pattern is residual control:

$$u=u_{\text{nominal}}+\Delta u_\theta, \qquad \Delta u_\theta\in\mathcal U_\Delta.$$

The nominal controller owns the basic stabilizing structure; the learned residual has bounded authority to compensate modeled deficiencies. The bound must be derived from actuator and closed-loop constraints, not chosen only from training statistics.

flowchart TD
  R[Reference] --> N[Nominal controller]
  X[Measured or estimated state] --> N
  X --> NN[Learned residual model]
  N --> S[Command composition]
  NN --> G[Independent action governor]
  G --> S
  S --> P[Plant]
  P --> X

An action governor must be independent #

Before an action reaches the plant, an independently implemented boundary can enforce:

• actuator magnitude and rate limits;
• state-dependent constraints;
• prohibited modes and command combinations;
• timestamp and input-validity requirements;
• a verified authority limit for the learned component.

If the same network predicts safety and selects the action, a shared modeling error defeats both functions. Independence is an architectural property, not merely a second loss term.

Learning online changes the closed-loop system #

Online weight updates add adaptive state. Learning rate, normalization, replay policy, parameter constraints, and update timing become controller parameters. Distribution shift may cause large gradients exactly when the plant enters an unusual region.

At minimum, expose and bound:

• weight or output change per control interval;
• the states in which learning is permitted;
• model uncertainty or novelty signals and their calibration;
• memory and compute usage in the worst case;
• persistence, rollback, and versioning semantics for learned parameters;
• the relationship between requested and actually applied actuator commands.

Verification is layered #

1. Data evidence: provenance, coverage, temporal splits, and sensor/actuator alignment.
2. Model evidence: one-step and rollout error, sensitivity, uncertainty, and extrapolation tests.
3. Integration evidence: timing, quantization, saturation, and action-governor tests.
4. Closed-loop evidence: trajectories, disturbances, recovery states, and formal or analytical properties where available.
5. Operational evidence: version identity, drift monitoring, incident traces, and controlled update authority.

NASA's work on learning-enabled aerospace control emphasizes that conventional software verification does not automatically establish convergence, stability, or reliable behavior for an adapting component. The solution is not to label the network “intelligent,” but to constrain its role and build evidence at every boundary where its outputs affect physical state.