Modelling of non-linear systems using ANN

Modeling non-linear systems using Artificial Neural Networks (ANNs) is a powerful approach
because ANNs can approximate complex, non-linear relationships between inputs and outputs
without requiring an explicit mathematical model. In dynamic systems, where relationships
between variables are complex and time-dependent, ANNs are particularly useful.

Steps for Modeling Non-linear Systems Using ANN:

1. Data Collection:

 Input and Output Data: Gather sufficient data representing the system's behavior. For non-
linear dynamic systems, this usually includes input signals (like control inputs) and
corresponding output signals (like system states or measurements).
 Preprocessing: Normalize or standardize the data to ensure stable learning and avoid bias
towards certain ranges of values. Also, remove any outliers or noise that could mislead the
network.

2. Design the ANN Architecture:

 Input Layer: This layer will contain the input features, which could be current and past
values of inputs and outputs if you are modeling a dynamic system (i.e., including time
dependencies).
 Hidden Layers:
o Use multiple hidden layers with non-linear activation functions like ReLU,
sigmoid, or tanh. Non-linear activation functions are key for capturing the non-
linearity in the system.
o The number of layers and the number of neurons per layer are hyperparameters to
tune based on the complexity of the system.
 Output Layer: This represents the predicted output of the system (which could be
continuous values for regression tasks).

Common ANN architectures for non-linear system modeling include:

 Feedforward Neural Networks (FNN): Suitable for static systems without memory.
 Recurrent Neural Networks (RNN): Effective for modeling dynamic systems where the
output depends on the history of inputs. Variants like LSTM or GRU are preferred for
handling long-range dependencies.
 Time Delay Neural Networks (TDNN): Useful for time-series data and dynamic systems.

3. Training the ANN:

 Loss Function: Use a loss function such as Mean Squared Error (MSE) for regression tasks,
which is typical for system identification.
 Optimization: Train the network using gradient descent-based algorithms like Adam,
RMSprop, or SGD.
 Regularization: To avoid overfitting, consider using techniques like L2 regularization,
dropout, or early stopping.

For dynamic systems, past input/output pairs are often fed into the network as additional inputs
(for example, using a tapped delay line approach) to capture the system's memory.

4. Model Validation and Testing:

  Training/Validation Split: Ensure that the dataset is split into training, validation, and
testing sets to avoid overfitting and assess the model's generalization capability.
 Cross-Validation: Use k-fold cross-validation to ensure the model works well across
different splits of the data.
 Performance Metrics: Evaluate the model using metrics like Mean Absolute Error (MAE),
Mean Squared Error (MSE), or other domain-specific performance criteria.

5. Fine-tuning the Model:

 Hyperparameter Tuning: Tune hyperparameters such as the number of layers, neurons per
layer, learning rate, batch size, etc., using techniques like grid search, random search, or
Bayesian optimization.
 Early Stopping: Monitor the performance on the validation set and stop training once
performance plateaus.

6. Model Deployment:

 Once the model is trained, validated, and tested, it can be deployed for tasks such as control,
prediction, or system monitoring in real-time applications.

Example: Modeling a Non-Linear System with MATLAB's Neural Network Toolbox

Suppose you have a non-linear dynamic system described by a set of input-output data. You want
to use a feedforward neural network to model this system.

[Link] the Architecture:

net = feedforwardnet([10, 10]); % Create a feedforward network with two hidden layers (10
neurons each)

2. Prepare the Data:

% Assume input data X and target data Y are available

[X_train, Y_train] = preparets(X, Y); % Prepare the time-series data

3. Train the Network:

net = train(net, X_train, Y_train); % Train the network on the input-output data

4. Evaluate the Network:

Y_pred = net(X_test); % Test the network with new input data

perf = perform(net, Y_test, Y_pred); % Calculate performance (e.g., MSE)

5. Hyperparameter Tuning:

You can perform hyperparameter tuning using a grid search or Bayesian optimization to improve
the performance of the neural network on the validation set.

Advantages of ANN for Non-Linear Systems:

  Universal Approximation: ANNs can theoretically approximate any continuous non-
linear function given enough neurons and layers.
 No Explicit Model Required: ANN does not require an explicit mathematical model of
the system, which is advantageous when dealing with complex, unknown non-linearities.
 Adaptive Learning: The ANN can adapt to changing system dynamics as more data
becomes available.

Challenges:

 Data Dependency: Requires large amounts of high-quality data to learn the system
dynamics accurately.
 Computational Complexity: Training deep neural networks for non-linear systems can
be computationally expensive and time-consuming.
 Black-box Nature: ANNs are often considered black-box models, meaning it is
challenging to interpret how the network arrives at its predictions.

Work on a specific example of modeling a non-linear dynamic system using a feedforward neural
network (FNN). We'll assume the system is governed by a non-linear relationship between input
and output, and our goal is to approximate this relationship using ANN.

Example: Non-linear System Modeling Using FNN in MATLAB

System Description

Let's consider a non-linear dynamic system where the output y(t) depends on the current and past
inputs u(t)u(t)u(t) as well as past outputs. The system is described by the following non-linear
equation:

y(t)=sin(u(t−1))+0.5y(t−1)2+ϵ

where:

 u(t) is the input at time step t

 y(t) is the output at time step t
 ϵ is some small noise term

We aim to model this non-linear relationship using a neural network.

Step 1: Generate Data

We will generate synthetic input-output data based on the given equation for training and testing
purposes. Here's an outline of how to proceed:

 Generate input data u(t) as a random time series.

 Compute the output data y(t) using the non-linear equation.
 Introduce some noise ϵ to make the data more realistic.

Step 2: Define and Train the Neural Network

We'll create and train a feedforward neural network to approximate the system’s behavior. We'll
use the Neural Network Toolbox in MATLAB for this.
% Step 1: Generate Input-Output Data
n_samples = 1000; % Number of data points
u = randn(1, n_samples); % Random input sequence
y = zeros(1, n_samples); % Initialize output sequence
epsilon = 0.01 * randn(1, n_samples); % Additive noise

% Define the non-linear system

for t = 2:n_samples
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2 + epsilon(t);
end

% Step 2: Prepare Data for Neural Network

input_data = [u(1:end-1); y(1:end-1)]; % Previous inputs and outputs as inputs
target_data = y(2:end); % Current output as target

% Step 3: Define Feedforward Neural Network

net = feedforwardnet([10, 10]); % Two hidden layers with 10 neurons each

% Configure the network

net = configure(net, input_data, target_data);

% Step 4: Train the Network

[Link] = 500; % Set number of training epochs
net = train(net, input_data, target_data);

% Step 5: Test the Neural Network

y_pred = net(input_data); % Predict output using trained network

% Step 6: Plot the Results

figure;
plot(target_data, 'r'); % Plot actual output
hold on;
plot(y_pred, 'b--'); % Plot predicted output
legend('Actual Output', 'Predicted Output');
title('Non-linear System Modeling with FNN');
xlabel('Time Step');
ylabel('Output');

Explanation of the Code:

1. Data Generation:
o We generate synthetic input u(t) as random Gaussian noise and use the system
equation to compute the corresponding outputs y(t). A small noise term ϵ is added
to simulate a more realistic scenario.
2. Data Preparation:
o The network will be trained to predict the next output y(t)y(t)y(t) based on the
previous input u(t−1) and output y(t−1). Thus, the input to the network consists of
pairs of u(t−1) and y(t−1), while the target is y(t).
3. Network Architecture:
 o We use a simple feedforward neural network with two hidden layers, each
containing 10 neurons. The number of neurons and layers can be increased if the
system is more complex.
4. Training:
o The network is trained using backpropagation. The number of epochs is set to 500,
which controls how many times the entire training dataset is passed through the
network.
5. Testing:
o After training, the network is tested by comparing its predicted outputs to the actual
outputs from the system.
6. Visualization:
o We plot both the actual and predicted outputs to assess how well the network
learned the non-linear relationship.

Next Steps:

 Hyperparameter Tuning: You can experiment with different network configurations

(e.g., more layers, different numbers of neurons) and optimization algorithms.
 Time Dependencies: If the system is more dynamic, you might want to use recurrent
networks like LSTMs instead of a feedforward network.
 Validation: Use cross-validation to ensure the network generalizes well to new data.

Let's dive deeper into the system modeling and explore a variant. A good approach would be to
extend this non-linear system example to handle more complex dynamic behavior. We can explore
the following:

Introducing Recurrent Neural Networks (RNNs):

Instead of a feedforward network (FNN), we can use a Recurrent Neural Network (RNN) or Long
Short-Term Memory (LSTM) network. These networks are more suitable for dynamic systems
where future outputs depend on previous time steps over a longer horizon.

Expanding the Complexity of the System:

Modify the non-linear system to include higher-order non-linearities or introduce multi-

input/multi-output (MIMO) behavior.

Handling Noisy Data:

Introduce noise robustness to the model, including filtering techniques or applying regularization
to reduce overfitting.

Generation of training data

Generating high-quality training data is crucial for effectively modeling non-linear dynamic
systems with ANNs. The data must represent the full range of system behaviors and capture the
underlying non-linearities.

Here's a detailed guide to generating appropriate training data for your non-linear system
modeling:

1. Define the System

The first step is to clearly define the non-linear dynamic system that you're trying to model. For
instance, a non-linear system might have the following form:

y(t)=f(u(t),u(t−1),…,y(t−1),y(t−2),… )

Where:

 u(t): input at time step t

 y(t): output at time step t
 f(⋅): non-linear function representing the system dynamics

For example, a system might have the following equation:

y(t)=0.8⋅y(t−1) +sin(u(t)) +0.3⋅u(t−1)2+ϵ

Where ϵ is a noise term to account for real-world imperfections.

2. Choose Input Signal(s)

The input signal u(t)u(t)u(t) needs to be designed carefully to excite the system adequately across
its operating range. Here are common choices for generating input signals:

 Random Gaussian Noise: Generate random Gaussian noise to ensure that all possible
input ranges are covered.

matlab

u = randn(1, n_samples); % Random input sequence from a normal distribution

 Pseudorandom Binary Sequence (PRBS): Useful for system identification because it

contains a rich frequency content.

u = idinput([n_samples, 1], 'prbs'); % Generate PRBS input

 Sinusoidal Signals: For systems that exhibit periodic behavior, sinusoidal inputs are
useful.

u = sin(2 * pi * f * (1:n_samples)); % Sinusoidal input with frequency f

 Step Signals: Simulate how the system responds to sudden changes in input.

u = zeros(1, n_samples);

u(100:end) = 1; % Step input starting from sample 100

Combining multiple input types can be beneficial to fully explore the non-linear dynamics.

3. Generate Output Data

Once the input signal is defined, use the system’s governing equation to generate the
corresponding output data. Introduce some noise to simulate real-world disturbances:

n_samples = 1000;
u = randn(1, n_samples); % Random Gaussian input

y = zeros(1, n_samples); % Initialize output

epsilon = 0.01 * randn(1, n_samples); % Additive noise

% Non-linear system simulation

for t = 2:n_samples

y(t) = 0.8 * y(t-1) + sin(u(t)) + 0.3 * u(t-1)^2 + epsilon(t);

end

In this example, the output y(t) depends on both the previous output y(t−1) and the current and
previous inputs u(t) and u(t−1).

4. Simulate Multiple Scenarios

To ensure the neural network generalizes well, generate data under different conditions and ranges
of the input:

 Different Amplitudes: Use different ranges of input signals.

 Multiple Frequencies: Change the frequency of sinusoidal inputs to observe how the
system responds at different speeds.
 Step and Impulse Responses: Simulate sudden changes or impulse disturbances to
assess how the system reacts to abrupt variations.

For instance:

u1 = sin(2 * pi * 0.1 * (1:n_samples)); % Low-frequency sinusoid

u2 = sin(2 * pi * 1.0 * (1:n_samples)); % High-frequency sinusoid

u3 = randn(1, n_samples); % Random noise input

% Concatenate and generate corresponding output

u_combined = [u1; u2; u3]; % Different inputs for multiple scenarios

for t = 2:n_samples

y_combined(:,t) = 0.8 * y_combined(:,t-1) + sin(u_combined(:,t)) + 0.3 * u_combined(:,t-1).^2

+ epsilon(:,t);

end

5. Split Data for Training, Validation, and Testing

Once the input-output pairs have been generated, split the data into training, validation, and test
sets. The training set is used for model fitting, the validation set for hyperparameter tuning, and
the test set for evaluating the final model performance.

train_ratio = 0.7; % 70% training data

val_ratio = 0.15; % 15% validation data

test_ratio = 0.15; % 15% testing data

n_train = floor(train_ratio * n_samples);

n_val = floor(val_ratio * n_samples);

u_train = u(:, 1:n_train);

y_train = y(:, 1:n_train);

u_val = u(:, n_train+1:n_train+n_val);

y_val = y(:, n_train+1:n_train+n_val);

u_test = u(:, n_train+n_val+1:end);

y_test = y(:, n_train+n_val+1:end);

6. Data Preprocessing

For training neural networks, preprocessing is often required to improve performance and stability:

 Normalization: Normalize the input and output data to a standard range, such as [0, 1] or
[-1, 1].

[u_train, ps_u] = mapminmax(u_train); % Normalize input

[y_train, ps_y] = mapminmax(y_train); % Normalize output

 Time Delays: For dynamic systems, past values of the input and output may be used as
features for the ANN.

input_train = [u_train(1:end-1); y_train(1:end-1)];

target_train = y_train(2:end); % Predict the next output

Summary

The key steps for generating training data are:

1. Define the system's governing equation.

2. Generate diverse input signals that explore the full range of system behavior.
3. Simulate the system to produce corresponding outputs, including noise where
applicable.
4. Split the data into training, validation, and testing sets.
 5. Preprocess the data to ensure it is ready for neural network training.

Optimal architecture

When referring to the "optimal architecture" in the context of machine learning or neural networks,
it typically means designing a model architecture that achieves the best performance on a specific
task while balancing factors such as accuracy, complexity, generalization, and computational
efficiency. The optimal architecture depends on various factors, including the nature of the data,
the problem at hand, and the resources available.

Key Components in Designing an Optimal Architecture:

1. Type of Model:
o Linear Models: Simple models like linear regression or logistic regression.
Suitable for problems where relationships between features and target are
approximately linear.
o Neural Networks: More complex models like feedforward neural networks,
convolutional neural networks (CNNs), recurrent neural networks (RNNs), etc., are
used for non-linear, high-dimensional data.
o Decision Trees/Random Forests: Useful for structured data and problems with
hierarchical decision processes.
o Support Vector Machines (SVM): Effective for classification tasks with clear
margins of separation.
2. Depth of the Network:
o Shallow Networks: Suitable for simpler problems where the relationship between
input and output is relatively straightforward.
o Deep Networks: Necessary for complex tasks like image recognition, natural
language processing, where multiple layers can learn hierarchical features.
3. Number of Layers and Neurons:
o Fewer Layers/Neurons: Reduces the risk of overfitting and is computationally
efficient but may underfit the data if the problem is complex.
o More Layers/Neurons: Allows the model to capture complex patterns but
increases the risk of overfitting and requires more computational resources.
4. Activation Functions:
o ReLU (Rectified Linear Unit): Commonly used in hidden layers of deep networks
because of its simplicity and efficiency.
o Sigmoid/Tanh: Often used in the output layer for binary classification but can
suffer from vanishing gradient problems in deep networks.
o Softmax: Used in the output layer for multi-class classification.
5. Regularization Techniques:
o L1/L2 Regularization: Adds a penalty to the loss function to prevent overfitting.
o Dropout: Randomly drops neurons during training to prevent over-reliance on
specific neurons and improve generalization.
o Batch Normalization: Normalizes inputs to each layer, improving training speed
and stability.
6. Optimization Algorithms:
o Stochastic Gradient Descent (SGD): A simple and effective optimization method,
especially when used with momentum.
o Adam: An adaptive learning rate method that combines the benefits of AdaGrad
and RMSProp, often used in deep learning.
7. Hyperparameter Tuning:
 o Learning Rate: Controls the size of the steps the optimizer takes during training.
Too high can lead to overshooting the optimal solution; too low can result in slow
convergence.
o Batch Size: The number of samples processed before the model's internal
parameters are updated. Smaller batch sizes offer more regular updates but increase
computation time.
o Number of Epochs: The number of times the model goes through the entire
training dataset. Too many epochs can lead to overfitting, while too few can result
in underfitting.
8. Model Complexity vs. Generalization:
o Simplicity: Prefer simpler models (fewer parameters, less depth) when the data is
not overly complex to avoid overfitting.
o Complexity: Use more complex architectures (deeper networks, more parameters)
when dealing with complex tasks like image recognition or language modeling.

Steps to Find the Optimal Architecture:

1. Start Simple:
o Begin with a simple model architecture with a few layers and neurons. This serves
as a baseline.
2. Gradually Increase Complexity:
o Add more layers, neurons, or try different types of architectures like CNNs, RNNs,
or Transformers depending on the task. Monitor the performance on the validation
set.
3. Use Cross-Validation:
o Apply techniques like K-Fold Cross-Validation to ensure that your architecture
generalizes well and is not overfitting to the training data.
4. Experiment with Different Architectures:
o Test different architectures by varying the number of layers, types of layers (e.g.,
convolutional layers in CNNs), and the activation functions used.
5. Tune Hyperparameters:
o Perform hyperparameter tuning (e.g., using grid search or random search) to find
the optimal learning rate, batch size, dropout rate, etc.
6. Regularization and Normalization:
o Implement regularization techniques to avoid overfitting and batch normalization
to stabilize and speed up training.
7. Evaluate on Test Set:
o Once the optimal architecture is identified, evaluate the model on a separate test set
to confirm its generalization ability.
8. Resource Considerations:
o Consider the available computational resources. Sometimes, the optimal
architecture is a trade-off between performance and available hardware (e.g.,
GPU/TPU availability).

Example Scenarios:

 Image Classification:
o Optimal Architecture: A deep CNN with multiple convolutional layers followed
by fully connected layers. Use ReLU activation, batch normalization, and dropout.
o Hyperparameters: Tune learning rate, number of filters in convolutional layers,
and dropout rate.
 Time Series Prediction:
 o Optimal Architecture: A recurrent neural network (RNN) or long short-term
memory (LSTM) network, possibly with attention mechanisms.
o Hyperparameters: Number of LSTM units, learning rate, sequence length.
 Text Classification:
o Optimal Architecture: A transformer-based model like BERT or GPT, or a simple
LSTM or GRU-based model for smaller datasets.
o Hyperparameters: Learning rate, number of transformer layers, dropout rate.

Finding the optimal architecture is an iterative process involving experimentation, validation, and
refinement. The goal is to balance complexity and performance to achieve the best results on the
target task.

Model validation

Model validation is the process of evaluating a machine learning model’s performance on a

dataset that was not used during the training phase. This helps ensure that the model
generalizes well to new, unseen data and is not just memorizing the training data (i.e., overfitting).
Validation is crucial in the model development process as it provides an estimate of how the model
will perform in a real-world scenario.

Key Concepts in Model Validation:

1. Training Set:
o The dataset used to train the model. The model learns patterns and relationships
from this data.
2. Validation Set:
o A subset of the data that is separate from the training data. It is used to fine-tune
the model and select the best model during training.
3. Test Set:
o A separate dataset that is not used during training or validation. It is used to provide
a final, unbiased evaluation of the model’s performance after all tuning has been
completed.

Cross-validation

Cross-validation is a statistical method used to assess the performance of a machine learning

model. It involves partitioning the data into subsets, training the model on some subsets while
validating it on others, and repeating this process to ensure the model generalizes well to unseen
data. Here are the most common types of cross-validation techniques, along with numerical
examples:

1. Holdout Validation:

 Description: The dataset is split into two parts: a training set and a test set. The model is
trained on the training set and evaluated on the test set. This method is simple but may not
be reliable if the dataset is small because the performance can vary significantly depending
on the split.
 Example:
o Dataset: 100 samples.
o Split: 80 samples for training, 20 samples for testing.
o Process: Train the model on 80 samples and test it on the remaining 20.

2. K-Fold Cross-Validation:
  Description: The dataset is randomly partitioned into k equal-sized folds (subsets). The
model is trained k times, each time using k−1 folds for training and the remaining fold for
validation. The final performance is averaged over all k trials.
 Example:
o Dataset: 100 samples.
o k-Value: 5 (5-fold cross-validation).
o Process:
1. Split the dataset into 5 equal folds (20 samples each).
2. Train on folds 1-4 (80 samples) and validate on fold 5 (20 samples).
3. Train on folds 1-3 and 5, validate on fold 4.
4. Continue this process until each fold has been used as a validation set.
5. Average the results from all 5 iterations.

3. Stratified K-Fold Cross-Validation:

 Description: Similar to K-Fold Cross-Validation, but ensures that each fold has
approximately the same proportion of class labels as the original dataset. This is
particularly useful for imbalanced datasets.
 Example:
o Dataset: 100 samples, with 70 of class A and 30 of class B.
o k-Value: 5 (Stratified 5-fold cross-validation).
o Process:
1. Split the dataset into 5 folds such that each fold has 14 samples of class A
and 6 samples of class B.
2. Train and validate as in regular K-Fold Cross-Validation, but with
balanced class distributions in each fold.

4. Leave-One-Out Cross-Validation (LOOCV):

 Description: A special case of K-Fold Cross-Validation where k equals the number of

samples in the dataset. Each sample acts as its own validation set while the model is trained
on all other samples.
 Example:
o Dataset: 10 samples.
o Process:
1. Train on 9 samples and validate on the 1 remaining sample.
2. Repeat this process 10 times, each time leaving out a different sample.
3. Average the results from all 10 iterations.

5. Leave-P-Out Cross-Validation:

 Description: Similar to LOOCV, but instead of leaving out one sample, p samples are left
out each time. The model is trained on the remaining n−p samples and tested on the p left-
out samples.
 Example:
o Dataset: 10 samples.
o ppp-Value: 2 (Leave-2-Out Cross-Validation).
o Process:
1. Leave out 2 samples and train on the remaining 8.
2. Test on the 2 left-out samples.
3. Repeat this process for every possible combination of leaving out 2
samples (a total of {10}{2} = 45 iterations).
4. Average the results from all iterations.
6. Repeated K-Fold Cross-Validation:

 Description: This technique involves performing K-Fold Cross-Validation multiple times

(e.g., 5 or 10 repetitions), each time with a different random split of the data into k folds.
The results are averaged over all repetitions to reduce the variance in performance
estimates.
 Example:
o Dataset: 100 samples.
o k-Value: 5 (5-fold cross-validation).
o Repetitions: 3.
o Process:
1. Perform 5-fold cross-validation once, as described earlier.
2. Repeat the entire 5-fold process two more times, each time with a different
random split.
3. Average the results from all 15 evaluations (3 repetitions × 5 folds).

7. Time Series Cross-Validation (Rolling or Expanding Window):

 Description: Used specifically for time series data, where the temporal order of data is
important. The data is split into training and validation sets based on time, ensuring that
future data is not used to predict past events.
 Example (Rolling Window):
o Dataset: 100 time-ordered samples.
o Process:
1. Use the first 20 samples for training and validate on the next 5 samples.
2. Slide the window forward: train on samples 1-25, validate on samples 26-
30.
3. Continue this process, each time sliding the window forward by a fixed
number of samples.
o Example (Expanding Window):
1. Start with the first 20 samples for training and validate on the next 5
samples.
2. Expand the training set: train on samples 1-25, validate on samples 26-30.
3. Continue expanding the training set and validate on the next block of
samples.

Numerical Example for K-Fold Cross-Validation:

Let's consider a small dataset with 10 samples and perform 5-fold cross-validation.

Dataset:

 Samples: S1,S2,S3,S4,S5,S6,S7,S8,S9,S10
 Labels: Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,Y9,Y10

Step 1: Split the dataset into 5 folds:

 Fold 1: {S1, S2}

 Fold 2: {S3, S4}
 Fold 3: {S5, S6}
 Fold 4: {S7, S8}
 Fold 5: {S9, S10}
Step 2: Perform 5 iterations of training and validation:

 Iteration 1:
o Train on Folds 2-5, Validate on Fold 1.
o Train: {S3,S4,S5,S6,S7,S8,S9,S10}
o Validate: {S1,S2}
 Iteration 2:
o Train on Folds 1, 3-5, Validate on Fold 2.
o Train: {S1,S2,S5,S6,S7,S8,S9,S10}
o Validate: {S3,S4}
 Iteration 3:
o Train on Folds 1, 2, 4, 5, Validate on Fold 3.
o Train: {S1,S2,S3,S4,S7,S8,S9,S10}
o Validate: {S5, S6}
 Iteration 4:
o Train on Folds 1-3, 5, Validate on Fold 4.
o Train: {S1,S2,S3,S4,S5,S6,S9,S10}
o Validate: {S7,S8}
 Iteration 5:
o Train on Folds 1-4, Validate on Fold 5.
o Train: {S1, S2,S3,S4,S5,S6,S7,S8}
o Validate: {S9, S10}

Step 3: Calculate the performance metrics for each fold and average them to get the final
performance estimate.

This example illustrates how cross-validation can provide a more reliable estimate of model
performance by ensuring that every sample is used for both training and validation.

Controlling non-linear systems using ANNs

Controlling non-linear systems using Artificial Neural Networks (ANNs) is a powerful approach,
particularly when the system's dynamics are complex, non-linear, or difficult to model explicitly.
ANNs can learn to approximate the control laws directly from data or by learning a controller that
optimizes the system's performance.

Key Approaches for ANN-based Control of Non-linear Systems:

1. Model Predictive Control (MPC) with Neural Networks

2. Direct Neural Network Controllers
3. Inverse Modeling for Control
4. Adaptive Neural Control

1. Model Predictive Control (MPC) with Neural Networks

Model Predictive Control (MPC) is a control strategy that uses an internal model of the system to
predict future states and optimize the control inputs over a finite time horizon. When the system is
non-linear and difficult to model explicitly, an ANN can be used as the internal model for the
MPC.

Key Steps:
  System Identification: First, use an ANN to model the non-linear dynamics of the system.
This model will be used to predict the future states of the system based on current inputs.
 MPC Optimization: At each control step, MPC solves an optimization problem to find
the control actions that will minimize a cost function (e.g., tracking error, energy
consumption) over the prediction horizon.
 Control Application: Apply the optimal control action to the system and update the ANN
with new data to improve its accuracy.

2. Direct Neural Network Controllers

In this approach, the ANN acts as the controller directly, mapping the system's current states or
errors to control inputs. The network is trained to generate control signals that minimize error or
optimize a performance criterion.

Types of Direct Controllers:

 Feedforward Control: The ANN generates control actions based solely on the current
state of the system.
 Feedback Control: The ANN generates control actions based on both the current state and
the feedback from previous control actions, allowing the system to correct its behavior
dynamically.

Training the Controller:

 Supervised Learning: Train the neural network using input-output pairs obtained from an
existing controller (e.g., a PID controller) or from data generated by simulations.
 Reinforcement Learning: Use reinforcement learning (RL) to train the ANN controller
by allowing it to explore the control space and learn the optimal policy through trial and
error.

3. Inverse Modeling for Control

In this approach, the ANN learns the inverse dynamics of the system. Given the desired output,
the ANN predicts the control inputs required to achieve that output. This is especially useful for
systems where the relationship between input and output is highly non-linear.

Steps:

 Train an Inverse Model: The ANN is trained to predict the input u(t)u(t)u(t) given the
desired output ydesired(t)y_{\text{desired}}(t)ydesired(t). This requires a dataset that
contains both inputs and outputs.
 Control Application: During control, the ANN takes the desired system behavior as input
and generates the corresponding control action.

4. Adaptive Neural Control

Adaptive control is often used in situations where system dynamics are changing or uncertain.
ANNs can be used to adaptively tune the control law in real-time, allowing the system to maintain
performance even under changing conditions.

Steps:
  Real-time Training: The ANN is continuously updated during system operation based on
new data, allowing it to adapt to changes in system dynamics or external disturbances.
 Combination with Classical Control: The ANN can be used in combination with a
classical controller (e.g., PID) to adapt the controller parameters in real-time, thus making
the system more robust to uncertainties.

Advantages of ANN-based Control for Non-linear Systems:

 Ability to Handle Complex Non-linearities: ANNs can approximate highly complex

non-linear control laws, allowing them to handle non-linearities that are challenging for
traditional controllers.
 Data-driven Approach: ANNs do not require an explicit mathematical model of the
system, making them suitable for systems with unknown or difficult-to-model dynamics.
 Adaptability: ANNs can be trained online, allowing them to adapt to changes in the system
dynamics or operating environment.

Challenges:

 Training Data Quality: The performance of ANN controllers depends heavily on the
quality and quantity of training data.
 Computational Complexity: Real-time control with ANNs can be computationally
intensive, particularly for large networks.
 Interpretability: ANN-based controllers can be challenging to interpret, which can be a
disadvantage compared to classical controllers like PID.

Example: Control of a Non-linear System Using an ANN in MATLAB

Let’s consider an example where we use an ANN to control a simple non-linear system. The
system dynamics are:

y(t)=sin(u(t−1))+0.5y(t−1)2

We want to train a neural network controller to stabilize the system and bring the output y(t) to a
desired setpoint ydesired.

Step 1: Generate Training Data

We simulate the system's behavior with a known controller (e.g., PID) to generate data for training
the neural network.

n_samples = 1000;
u = zeros(1, n_samples);
y = zeros(1, n_samples);
y_desired = 1; % Setpoint

for t = 2:n_samples
% PID control (example controller)
error = y_desired - y(t-1);
u(t) = 0.1 * error; % Simple proportional control
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2;
end

% Prepare data for training

inputs = [u(1:end-1); y(1:end-1)]; % Control input and system output as
inputs
targets = u(2:end); % Control input at next time step as target
Step 2: Train the Neural Network Controller

We train a feedforward neural network to learn the control law that maps the current state y(t−1)
and input u(t−1) to the next control input u(t).

net = feedforwardnet([10, 10]); % Two hidden layers with 10 neurons each

net = train(net, inputs, targets); % Train the network

Step 3: Apply the Neural Network Controller

After training, we use the ANN as a direct controller to generate control inputs in real-time based
on the current state of the system.

for t = 2:n_samples
% Use ANN to generate control input
control_input = net([u(t-1); y(t-1)]);
u(t) = control_input;
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2;
end

Direct and indirect Neuro control schemes

Neural control schemes are two prominent approaches in the control of non-linear systems using
artificial neural networks (ANNs). Each scheme has its advantages and applications depending on
the system dynamics, control objectives, and the availability of a model of the system.

1. Direct Neural Control Scheme

In direct neural control, the ANN acts directly as the controller, mapping the system’s current
states (or observations) to control actions. The ANN learns the control law either from data or
through an iterative process like reinforcement learning. In this approach, the controller does not
require an explicit model of the plant (the system to be controlled), which can be beneficial when
the system dynamics are unknown or too complex to model analytically.

Structure:

 Input: The state of the system (or a subset of measurements like sensor data).
 Output: The control action to be applied to the system.

Training:

 The ANN is trained to minimize the error between the system's current output and the
desired reference signal (setpoint).
 Training can be done using supervised learning, where training data consists of inputs
(states) and desired control actions generated by a classical controller (e.g., PID controller).
 Alternatively, training can be done using reinforcement learning, where the ANN learns to
maximize a reward function based on the performance of the system.

Application:

 Real-time control: Once trained, the ANN can operate in real-time to provide control
actions based on the current state of the system.

Example:
Consider a non-linear system with the following dynamics:

y(t)=f(y(t−1),u(t−1))

The goal is to train a neural network controller to minimize the error e(t)=ydesired(t)−y(t) and
generate a control signal u(t).

Training Process:

 Collect input-output pairs for training the neural network, such as [y(t−1),u(t−1)] as inputs
and u(t) as the target control action.
 After training, the neural network takes the current state (or states) and outputs the control
action.

MATLAB Example:

% Generate training data (example with a simple non-linear system)

n_samples = 1000;
y_desired = 1; % Setpoint
u = zeros(1, n_samples);
y = zeros(1, n_samples);

% PID control to generate training data

for t = 2:n_samples
error = y_desired - y(t-1);
u(t) = 0.1 * error; % Example proportional control
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2;
end

% Prepare data for training

inputs = [y(1:end-1); u(1:end-1)]; % System state and previous control input
targets = u(2:end); % Control input at the next time step

% Train the neural network

net = feedforwardnet([10, 10]);
net = train(net, inputs, targets);

% Apply the neural network as the controller

for t = 2:n_samples
u(t) = net([y(t-1); u(t-1)]); % ANN control action
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2;
end

2. Indirect Neural Control Scheme

In indirect neural control, the ANN is used to model the plant (system) rather than directly
generating control signals. Once the ANN accurately models the plant, a classical controller (e.g.,
PID, MPC) or an optimization-based approach can be used to control the system. The indirect
scheme leverages the ANN’s ability to approximate non-linear system dynamics, and control is
then based on this model.

Structure:

 Input: Past states and control inputs.

 Output: Predicted future state (plant output).

Process:
  System Identification: First, a neural network is trained to model the plant, i.e., to learn
the mapping between inputs u(t) and outputs y(t). This is done using historical input-output
data.
 Controller Design: After training, a controller is designed using the ANN-based model of
the plant. The controller could be a classical control algorithm (e.g., PID) or an
optimization-based method (e.g., Model Predictive Control, MPC).
 Real-time Control: In real-time, the ANN model predicts the system behavior, and the
controller uses this prediction to compute the control actions.

Example:

Consider a non-linear system with unknown dynamics:

y(t)=f(y(t−1),u(t−1))

The goal is to model the system using an ANN, and then use the ANN-based model for designing
the controller.

Steps:

1. Training the Model: Use input-output data from the system to train the neural network
to predict future outputs based on current and past inputs.
2. Designing the Controller: Once the model is trained, use it to design a control strategy,
such as MPC, that optimizes the system performance.

MATLAB Example:

% Step 1: Generate input-output data (system identification)

n_samples = 1000;
u = randn(1, n_samples); % Random input signal
y = zeros(1, n_samples);

% Non-linear system
for t = 2:n_samples
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2;
end

% Prepare data for training the plant model

inputs = [y(1:end-1); u(1:end-1)]; % System state and input
targets = y(2:end); % Future output

% Train the neural network to model the plant

plant_net = feedforwardnet([10, 10]);
plant_net = train(plant_net, inputs, targets);

% Step 2: Use the trained plant model in a controller (e.g., MPC)

% Example: Predict the next state and optimize control actions
for t = 2:n_samples
y_pred = plant_net([y(t-1); u(t-1)]); % Predict next output
error = y_desired - y_pred; % Error based on predicted output
u(t) = 0.1 * error; % Example proportional control based on predicted
error
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2;
end

Comparison of Direct and Indirect Neural Control

 Feature Direct Control Indirect Control
Controller ANN directly generates ANN models the plant, and a controller uses
Design control signals. the model.
Modeling No explicit model of the plant
The ANN must model the plant accurately.
Requirement is needed.
Training Directly trains the controller Requires two stages: system identification
Complexity using input-output data. and control design.
May require frequent
Allows more flexibility in control design
Adaptability retraining for changing
once the model is learned.
dynamics.
Suitable when the system Useful when a model is needed for more
Application
model is difficult to obtain. sophisticated control strategies (e.g., MPC).

Conclusion

 Direct Control is simpler but may struggle with large or complex systems.
 Indirect Control is more powerful for complex systems, where a model can be leveraged
for more advanced control strategies.

Adaptive Neuro Controllers

An Adaptive Neuro Controller is a specialized controller that adapts in real-time to changes in

system dynamics or environmental conditions using neural networks. It combines neural network
learning capabilities with adaptive control techniques, allowing the controller to continuously
adjust its parameters to maintain performance even when the system is non-linear, time-varying,
or uncertain.

Core Concepts of Adaptive Neuro Controllers

1. Adaptive Control: Adaptive control adjusts controller parameters in real-time based on

the observed system behavior. It ensures stability and performance even when the system's
dynamics are not fully known or change over time.
2. Neural Networks: ANNs are used in the adaptive controller to learn and approximate the
non-linear dynamics of the system. Their ability to learn from data makes them well-suited
for adaptive control where the exact model of the system is not available.
3. Real-time Adaptation: Unlike fixed controllers, an adaptive neuro controller updates its
parameters in real-time based on the system’s response, allowing it to compensate for
model inaccuracies, disturbances, or variations in system dynamics.

Structure of an Adaptive Neuro Controller

An adaptive neuro controller typically consists of two main components:

1. Neural Network (NN) Model: The NN is trained to approximate the non-linear system
dynamics, serving as a model of the plant.
2. Adaptation Mechanism: The adaptation mechanism updates the neural network weights
or controller parameters in real-time based on the error between the desired and actual
system output.

There are different ways to structure an adaptive neuro controller:

  Indirect Adaptive Control: The neural network is used to model the plant, and an adaptive
control law is derived based on this model.
 Direct Adaptive Control: The neural network directly computes the control action, and
its weights are updated based on feedback from the system.

Example: Adaptive Neuro Controller for a Non-linear System

Consider the Non-linear System:

y(t)=sin(u(t−1))+0.5⋅y(t−1)2+ϵ

Where u(t) is the control input and y(t) is the system output. We aim to design an adaptive neuro
controller that learns the control law to stabilize the output y(t) to a desired setpoint ydesired.

Steps for Designing an Adaptive Neuro Controller:

1. Initialize the Neural Network Controller:

o Start with a small feedforward neural network that takes the system state y(t−1) as
inputs and outputs the control action u(t).
2. Training Initialization:
o Use supervised learning or a classical controller (e.g., PID) to initialize the neural
network weights based on historical data.
3. Real-time Adaptive Update:
o During real-time operation, the neural network weights are updated using an
adaptive learning rule, such as gradient descent, based on the observed error
between the desired and actual outputs.
4. Control Application:
o The neural network controller generates the control action at each time step, and
the adaptation mechanism updates the weights based on system feedback.

MATLAB Example: Adaptive Neuro Controller

Here is an example implementation in MATLAB where we design a basic adaptive neuro

controller for a non-linear system.

Step 1: Generate Initial Training Data

n_samples = 1000;
y_desired = 1; % Setpoint
u = zeros(1, n_samples); % Control input
y = zeros(1, n_samples); % System output
epsilon = 0.01 * randn(1, n_samples); % Noise term

% Simulate with a simple proportional controller to generate training data

for t = 2:n_samples
error = y_desired - y(t-1);
u(t) = 0.1 * error; % Example proportional control
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2 + epsilon(t);
end

% Prepare input-output pairs for training the neural network

inputs = [y(1:end-1); u(1:end-1)];
targets = u(2:end);

Step 2: Initialize Neural Network Controller

% Create a feedforward neural network with 2 hidden layers of 10 neurons each
net = feedforwardnet([10, 10]);

% Train the neural network on the initial data

net = train(net, inputs, targets);

Step 3: Real-time Adaptation and Control

% Initialize variables for adaptive control

learning_rate = 0.01; % Learning rate for adaptation
for t = 2:n_samples
% Use the neural network to generate the control action
control_input = net([y(t-1); u(t-1)]);

% Apply the control input to the system

u(t) = control_input;
y(t) = sin(u(t-1)) + 0.5 * y(t-1)^2 + epsilon(t); % System response

% Compute the error

error = y_desired - y(t);

% Adapt the weights of the neural network based on the error

% (using a simple gradient descent adaptation rule)
% Note: MATLAB's built-in functions for training are not adaptive in this
sense,
% so this step illustrates how an adaptation could occur in principle.
for i = 1:length([Link]{1,1})
% Example adaptation update
[Link]{1,1}(i) = [Link]{1,1}(i) + learning_rate * error;
end
end

Benefits of Adaptive Neuro Controllers

 Robustness to System Changes: The controller adapts to changes in system dynamics,

making it suitable for time-varying or uncertain systems.
 Handling Non-linearities: The neural network can model complex non-linear
relationships between inputs and outputs, which classical controllers struggle with.
 Learning from Data: The ANN controller can learn directly from data without needing
an explicit mathematical model of the system.

Challenges

 Convergence and Stability: Adaptive neuro controllers can face issues with convergence
and stability, especially if the learning rate or adaptation mechanism is not tuned correctly.
 Training Time: Real-time adaptation requires continuous training, which can be
computationally expensive for large networks or complex systems.
 Overfitting: There is a risk of overfitting the controller to specific conditions or noise in
the data if not properly regularized.

Adaptive neuro controllers are highly effective for controlling non-linear systems in environments
where the system's behavior changes over time. By combining neural network learning with
adaptive control mechanisms, they offer flexibility and robustness.

Key desirable properties of adaptive neuro controllers:

When designing an Adaptive Neuro Controller, certain desirable properties ensure its effectiveness
and robustness in controlling non-linear, time-varying, or uncertain systems. These properties are
critical for the controller to adapt appropriately while maintaining system performance, stability,
and reliability. Below are the key desirable properties of adaptive neuro controllers:

1. Adaptability

 Definition: The ability of the controller to modify its parameters in real-time to respond to
changes in system dynamics, disturbances, or environmental conditions.
 Significance: Ensures that the controller maintains good performance despite uncertainties
or time-varying behaviors in the system. Adaptability allows the controller to compensate
for unknown dynamics and disturbances that arise during operation.

2. Convergence

 Definition: The property that ensures the controller's adaptive algorithm converges to an
optimal or near-optimal control law over time.
 Significance: Guarantees that the controller's performance improves or stabilizes as it
learns from the system's behavior, without oscillating or diverging. Convergence ensures
that the system achieves the desired setpoints or control objectives.

3. Stability

 Definition: The property that ensures the system remains stable during the adaptation
process, preventing unstable or erratic behavior even as the controller adjusts its
parameters.
 Significance: Stability is a critical safety requirement, especially for real-world systems. It
ensures that the controller’s adjustments do not cause the system to oscillate, diverge, or
become uncontrollable.
 Approaches for Stability:
o Lyapunov Stability: Using Lyapunov-based methods to ensure that the control law
derived by the ANN leads to a stable system.
o Robust Adaptive Laws: Designing adaptation rules that explicitly consider
stability conditions, ensuring that adaptive updates lead to stable trajectories.

4. Robustness

 Definition: The ability of the controller to handle uncertainties, noise, and disturbances
without significant degradation in performance.
 Significance: Robustness ensures that the controller can perform well in the presence of
modeling errors, sensor noise, and external disturbances. This property is crucial when the
system operates in unpredictable or harsh environments.

5. Real-time Operation

 Definition: The ability of the controller to operate and adapt in real-time without excessive
computational delays.
 Significance: Real-time control is essential for systems that require immediate responses
to changes in system dynamics. The adaptive neuro controller must be able to compute
control actions and update its parameters quickly enough to meet the real-time
requirements of the system.

6. Generalization Ability
  Definition: The ability of the neural network within the controller to generalize from the
training data to unseen states or operating conditions.
 Significance: Generalization ensures that the adaptive neuro controller can perform well
even in scenarios that were not explicitly encountered during training. This property
prevents overfitting and allows the controller to handle a wide range of operating
conditions.

7. Minimization of Steady-State Error

 Definition: The ability to reduce or eliminate steady-state error in tracking or regulation

tasks.
 Significance: A desirable adaptive neuro controller should ensure that the system output
tracks the desired reference signal with minimal or zero steady-state error, even after
changes in system dynamics.

8. Learning Efficiency

 Definition: The controller should efficiently learn the correct control actions with minimal
computational complexity and data requirements.
 Significance: Efficient learning ensures that the controller adapts quickly to changes in the
system without requiring large amounts of data or long training times. This is particularly
important for systems where data is scarce or expensive to collect.

9. Accuracy

 Definition: The controller’s ability to precisely control the system, minimizing error
between the desired and actual system output.
 Significance: Accuracy ensures that the controller performs its task optimally, whether that
is regulation, tracking, or stabilization. The adaptive neuro controller should maintain a
high level of precision in its control actions.

10. Transparency and Interpretability

 Definition: The ability of the controller to be understood and interpreted by human

operators or designers, despite being based on neural networks.
 Significance: Interpretability helps in diagnosing issues, verifying the controller's safety,
and making informed modifications. Although neural networks are often considered black-
box models, incorporating transparency into the design (e.g., by analyzing weight updates
or using simpler network architectures) can make the controller more trustworthy and
easier to deploy in critical systems.

11. Computational Efficiency

 Definition: The controller’s ability to perform computations with minimal resources (e.g.,
processor time, memory) without sacrificing performance.
 Significance: For real-time applications, it’s important that the adaptive neuro controller
operates efficiently, as excessive computational demand could lead to delays in control
actions or instability. Computational efficiency also impacts the controller's ability to be
deployed on embedded systems or hardware with limited processing power.

12. Non-intrusiveness
  Definition: The property of the controller being non-intrusive to the system’s operation,
meaning it doesn’t disrupt the system's normal functioning.
 Significance: An adaptive neuro controller should not interfere excessively with the natural
dynamics of the system while it is adapting. This ensures that the adaptation process is
smooth and does not introduce unnecessary oscillations or disturbances during learning.

13. Scalability

 Definition: The ability of the controller to handle increasing system complexity, such as
higher dimensions of state and control variables, without performance degradation.
 Significance: Scalability ensures that the controller can be applied to more complex
systems with larger state spaces, multi-variable control, or more demanding performance
criteria. This is particularly important for industrial or large-scale systems.

14. Online Learning

 Definition: The controller’s ability to learn continuously from the ongoing operation of the
system without needing to stop and retrain offline.
 Significance: Online learning is crucial for systems where conditions are changing
dynamically, as it enables the controller to adapt in real-time without downtime or
interruption to system operation.

For an adaptive neuro controller to be effective, it must combine adaptability, stability, robustness,
and real-time performance with efficient learning and generalization. These properties help ensure
that the controller performs well even in the presence of uncertainties, non-linearities, and
changing dynamics. Achieving these properties can be challenging, and the design process often
involves trade-offs between computational efficiency, robustness, and learning speed.

specific algorithms and techniques to improve particular properties of an Adaptive Neuro

Controller for a non-linear system.
Here are some examples:
1. Stability:
 Techniques: Lyapunov-based stability analysis, Control Lyapunov Function (CLF), robust
adaptive laws.
2. Robustness:
 Techniques: H∞ adaptive control, sliding mode control, robust adaptive neural networks.
3. Convergence:
 Techniques: Adaptive learning rates, recursive least squares (RLS), gradient-based
methods for faster convergence.
4. Real-time Operation:
 Techniques: Model Predictive Control (MPC) with neural networks, real-time
optimization, parallelization techniques for ANN computations.
5. Generalization Ability:
 Techniques: Regularization techniques (e.g., L2 regularization), dropout, transfer
learning, and pruning to avoid overfitting.
6. Learning Efficiency:
 Techniques: Reinforcement learning methods like Q-learning, policy gradient, Actor-
Critic methods, or batch/online training algorithms.