## Available Nonlinear Models

### Overview

The System Identification Toolbox™ software provides four types of nonlinear model structures:

The toolbox refers to Nonlinear ARX and Hammerstein-Wiener collectively as "nonlinear black box" models. You can configure these models in a variety of ways to represent various behavior using nonlinear functions such as wavelet networks, tree partitions, piece-wise linear functions, polynomials, saturation and dead zones.

The nonlinear grey-box models let you estimate coefficients of nonlinear differential equations.

Neural state space models let you estimate, using neural networks, the functions that define the nonlinear state space realization of your system.

### Nonlinear ARX Models

Nonlinear ARX models extend the linear ARX models to the nonlinear case and have this structure:

*y*(*t*) =
*f*(*y*(*t* - 1), ...,
*y*(*t* - *na*),*
u*(*t* - *nk*), ..., *
u*(*t* -*nk*
-*nb* + 1))

where the function *f* depends on a finite number of previous
inputs *u* and outputs *y*. *na*
is the number of past output terms and *nb* is the number of past
input terms used to predict the current output. *nk* is the delay
from the input to the output, specified as the number of samples.

Use this model to represent nonlinear extensions of linear models. This structure allows you to model complex nonlinear behavior using output functions that combine linear and nonlinear components, such as wavelet and sigmoid networks. Typically, you use nonlinear ARX models as black-box structures. The output function of the nonlinear ARX model is a flexible mapping function with parameters that need not have physical significance.

System Identification Toolbox software uses `idnlarx`

objects to represent
nonlinear ARX models. For more information about estimation, see Nonlinear ARX Models.

### Hammerstein-Wiener Models

Hammerstein-Wiener models describe dynamic systems using one or two static nonlinear blocks in series with a linear block. The linear block is a discrete transfer function and represents the dynamic component of the model.

You can use the Hammerstein-Wiener structure to capture physical nonlinear effects in sensors and actuators that affect the input and output of a linear system, such as dead zones and saturation. Alternatively, use Hammerstein-Wiener structures as black box structures that do not represent physical insight into system processes.

System Identification Toolbox software uses `idnlhw`

objects to represent
Hammerstein-Wiener models. For more information about estimation, see Hammerstein-Wiener Models.

### Nonlinear Grey-Box Models

Nonlinear state-space models have this representation:

$$\begin{array}{l}\dot{x}\left(t\right)=F\left(x\left(t\right),u\left(t\right)\right)\\ y\left(t\right)=H\left(x\left(t\right),u\left(t\right)\right)\end{array}$$

where *F* and *H* can have any parameterization.
A nonlinear ordinary differential equation of high order can be represented as a set
of first order equations. You use the `idnlgrey`

object to specify the
structures of such models based on physical insight about your system. The
parameters of such models typically have physical interpretations. Use this model to
represent nonlinear ODEs with unknown parameters.

For more information about estimating nonlinear state-space models, see Grey-Box Model Estimation.

### Neural State-Space Models

Neural state-space models are a type of nonlinear state-space models, and therefore have this representation:

$$\begin{array}{l}\dot{x}\left(t\right)=F\left(x\left(t\right),u\left(t\right)\right)\\ y\left(t\right)=H\left(x\left(t\right),u\left(t\right)\right)\end{array}$$

where *F* and *H* are implemented using neural
networks.

To identify a system from experiment data, first, create a neural state-space
object with a given number of states, inputs and outputs using `idNeuralStateSpace`

. Next, create neural networks to approximate the
state and output functions using `createMLPNetwork`

. Then, to train the networks, use `nlssest`

, supplying time-domain experiment data, the neural
state-space object, and training options as input arguments.

After the training is completed, you can validate the resulting state-space system
by simulating it against real data, and then use it to generate deployment code or
design a control system. For example, to facilitate Nonlinear MPC (Model Predictive Control Toolbox) design, generate
the state transition and Jacobian functions using `generateMATLABFunction`

.

For more information and examples on neural state-space objects, see `idNeuralStateSpace`

and `nlssest`

## Related Examples

- Identifying Nonlinear ARX Models
- Identifying Hammerstein-Wiener Models
- Represent Nonlinear Dynamics Using MATLAB File for Grey-Box Estimation