RayaneKch

nn training script

15 min read

Report: Explanation of create_deep_net_v2.m

Introduction

This MATLAB script builds and trains a deep neural network that predicts PID controller gains (Kp, Ki, Kd) from control-system error signals.

The script combines:

  • Classical control engineering

  • PID tuning

  • Dynamic system simulation

  • Deep learning regression

The final result is a trained neural network capable of estimating PID gains directly from system behavior.

1. Script Purpose

The objective of the script is to:

  1. Generate simulation data from a dynamic system

  2. Automatically tune PID controllers using MATLAB’s pidtune

  3. Create a dataset linking:

    • System errors (e, de, ie)

    • PID gains (Kp, Ki, Kd)

  4. Train a neural network to learn this relationship

  5. Save the trained network and weights

This creates an AI-based PID tuner.

2. System Initialization

clc
clear
close all

These commands:

  • Clear the command window

  • Remove variables from memory

  • Close all figures

3. Transfer Function Definition

s = tf('s');
G = 8.29e5 / (s^2 + 5*s);

This defines a second-order transfer function:

[
G(s)=\frac{8.29\times10^5}{s^2+5s}
]

Where:

  • s is the Laplace variable

  • The denominator represents system dynamics

  • The numerator is the system gain

This system behaves like a mechanical or electromechanical plant.

4. Reference PID Controller

opts_ref = pidtuneOptions('CrossoverFrequency',15,'PhaseMargin',75);
C_ref = pidtune(G,'PID',opts_ref)

The script uses MATLAB’s pidtune() to compute a reference PID controller.

Parameters

ParameterMeaning
CrossoverFrequencyDesired bandwidth
PhaseMarginStability margin

The result:

C_ref

contains:

  • Kp

  • Ki

  • Kd

5. Gain Limits

KP_MAX = 2e-4;
KI_MAX = 2e-4;
KD_MAX = 5e-5;

These values define acceptable PID gain ranges.

Any tuned controller exceeding these limits is rejected.

Purpose:

  • Avoid unstable controllers

  • Remove unrealistic training data

  • Improve neural-network robustness

6. Simulation Parameters

N = 500;
dt = 0.005;
t = 0:dt:2;
Ns = length(t);

Meaning

VariableDescription
NNumber of simulations
dtSimulation step
tTime vector
NsNumber of time samples

The simulation runs from:

[
0 \rightarrow 2 \text{ seconds}
]

with:

[
5ms
]

sampling.

7. Random Setpoints

setpoints = 0.1 + 4.9*rand(N,1);

Random reference values are generated between:

[
0.1 \le r \le 5.0
]

This ensures the network sees many operating conditions.

8. Dataset Containers

X = [];
Y = [];

Where:

VariablePurpose
XInput features
YTarget outputs

9. Main Data Generation Loop

for i = 1:N

This loop creates training examples.

10. Plant Variations

Gv = (8.29e5*(0.9+0.2*rand())) / (s^2+5*s);

The plant gain is randomly varied by ±10%.

This introduces uncertainty.

Purpose:

  • Improve generalization

  • Train robustness

  • Simulate real-world parameter changes

11. Automatic PID Tuning

C = pidtune(Gv,'PID',opts);

For every plant variation:

  • MATLAB computes optimal PID gains

The script extracts:

Kp = C.Kp;
Ki = C.Ki;
Kd = C.Kd;

12. Gain Rejection

if Kp<=0 || Ki<0 || Kd<0 || ...
   Kp>KP_MAX || Ki>KI_MAX || Kd>KD_MAX

Controllers are rejected if:

  • Gains are negative

  • Gains exceed limits

This filters invalid training samples.

13. State Initialization

x1 = 0;
x2 = 0;

States represent:

VariableMeaning
x1Position
x2Velocity

Error variables:

ie = 0;
pe = 0;
VariableMeaning
ieIntegral of error
pePrevious error

14. Feature and Label Arrays

feat = zeros(Ns,3);
lab  = repmat([Kp Ki Kd],Ns,1);

Features

Each sample contains:

[
[e,\ de,\ ie]
]

Where:

  • e = error

  • de = derivative of error

  • ie = integral of error

Labels

Each row contains:

[
[K_p,\ K_i,\ K_d]
]

15. Dynamic Simulation Loop

for k = 1:Ns

The system is simulated over time.

15.1 Error Calculation

e = r - x1;

Tracking error:

[
e(t)=r(t)-y(t)
]

15.2 Error Derivative

de = (e - pe)/dt;

Approximates:

[
\frac{de}{dt}
]

15.3 Error Integral

ie = ie + e*dt;

Approximates:

[
\int e(t)dt
]

15.4 PID Control Law

u = Kp*e + Ki*ie + Kd*de;

Standard PID equation:

[
u(t)=K_pe(t)+K_i\int e(t)dt+K_d\frac{de}{dt}
]

15.5 Plant Dynamics

x1 = x1 + x2*dt;
x2 = x2 + (-5*x2 + 8.29e5*u)*dt;

Euler integration updates the system states.

Equivalent differential equations:

[
\dot{x}_1=x_2
]

[
\dot{x}_2=-5x_2+8.29\times10^5u
]

16. Dataset Construction

X = [X; feat];
Y = [Y; lab];

All generated samples are appended to the dataset.

17. Feature Normalization

m = mean(X);
s = std(X)+1e-8;
Xn = (X - m)./s;

Standardization:

[
X_n=\frac{X-\mu}{\sigma}
]

Purpose:

  • Faster training

  • Better convergence

  • Stable gradients

18. Train / Validation Split

nt = floor(0.85*n);

Dataset division:

DatasetPercentage
Training85%
Validation15%

Random permutation ensures unbiased sampling.

19. Neural Network Architecture

layers = [
    featureInputLayer(3)
    fullyConnectedLayer(64)
    reluLayer
    fullyConnectedLayer(64)
    reluLayer
    fullyConnectedLayer(32)
    reluLayer
    fullyConnectedLayer(3)
    regressionLayer
];

Architecture Summary

LayerSize
Input3
Hidden 164
Hidden 264
Hidden 332
Output3

Inputs:

[
[e,de,ie]
]

Outputs:

[
[K_p,K_i,K_d]
]

20. Activation Functions

reluLayer

Uses ReLU:

[
f(x)=\max(0,x)
]

Advantages:

  • Fast training

  • Avoids vanishing gradients

  • Simple computation

21. Training Configuration

opts = trainingOptions('adam', ...)

Important Parameters

ParameterValue
OptimizerAdam
Epochs150
Batch Size256
Learning Rate0.001

Adam combines:

  • Momentum

  • Adaptive learning rates

22. Network Training

net = trainNetwork(Xtr,Ytr,layers,opts);

The network learns the mapping:

[
[e,de,ie] \rightarrow [K_p,K_i,K_d]
]

23. Prediction and Validation

Yp = predict(net,Xv);

Predictions are compared against validation labels.

24. RMSE Error Calculation

rmse = sqrt(mean((Yp(:,i)-Yv(:,i)).^2));

Root Mean Square Error:

[
RMSE=\sqrt{\frac{1}{N}\sum (y_{pred}-y_{true})^2}
]

Measures prediction accuracy.

25. Test Prediction

xt = ([1 0 0]-m)./s;
gt = predict(net,xt);

A sample input:

[
[e,de,ie]=[1,0,0]
]

is normalized and tested.

The network predicts PID gains for this condition.

26. Saving the Trained Network

save('neuro_pid_net.mat','net','norm_stats')

Saves:

  • Neural network

  • Normalization statistics

27. Extracting Network Weights

W1 = net.Layers(2).Weights;
b1 = net.Layers(2).Bias;

Weights and biases are extracted layer-by-layer.

Purpose:

  • Embedded deployment

  • Custom inference engines

  • FPGA / microcontroller implementation

28. Saving Weights

save('neuro_pid_weights.mat',...)

Creates a lightweight file containing only:

  • Weights

  • Biases

  • Normalization values

Useful for deployment outside MATLAB.

29. Overall Workflow

Generate Plant Variations
        ↓
Tune PID Automatically
        ↓
Simulate Closed Loop
        ↓
Collect Errors + PID Gains
        ↓
Normalize Dataset
        ↓
Train Deep Neural Network
        ↓
Predict PID Gains
        ↓
Save Network & Weights

30. Key Concepts Used

Control Engineering

  • PID control

  • Transfer functions

  • Closed-loop simulation

  • Stability margins

Machine Learning

  • Supervised learning

  • Regression networks

  • Deep neural networks

  • Feature normalization

Numerical Methods

  • Euler integration

  • Randomized data generation

  • RMSE evaluation

31. Advantages of This Approach

Adaptive PID Tuning

The neural network can estimate gains instantly without running pidtune.

Real-Time Capability

Useful for:

  • Embedded systems

  • Fast adaptive control

  • Autonomous systems

Robustness

Training with plant variations improves tolerance to uncertainty.

32. Limitations

Limited Training Diversity

Only gain variations are included.

No:

  • Noise

  • Disturbances

  • Nonlinearities

Euler Integration Accuracy

Euler integration is simple but not highly accurate.

More advanced solvers could improve realism.

Fixed Architecture

The network structure is manually chosen.

Hyperparameter optimization could improve performance.

33. Possible Improvements

Add More Features

Examples:

  • System output

  • Control effort

  • Overshoot

  • Settling time

Use Better Simulators

Replace Euler integration with:

  • ode45

  • Simulink

  • State-space simulation

Add Online Learning

Allow the network to adapt during operation.

Deploy to Embedded Hardware

The saved weights make deployment possible on:

  • STM32

  • FPGA

  • Raspberry Pi

  • DSP systems

Conclusion

This script demonstrates a hybrid approach combining:

  • Classical PID control

  • System simulation

  • Deep learning

The generated neural network learns to predict PID gains from system error signals, enabling intelligent and potentially real-time controller tuning.

It is an example of neuro-adaptive control and illustrates how machine learning can enhance traditional control-system design.

Rapport : Explication du script create_deep_net_v2.m

clc
clear
close all
 
s = tf('s');
G = 8.29e5 / (s^2 + 5*s);
 
opts_ref = pidtuneOptions('CrossoverFrequency',15,'PhaseMargin',75);
C_ref = pidtune(G,'PID',opts_ref) %gains référence
 
KP_MAX = 2e-4; %gains limites
KI_MAX = 2e-4;
KD_MAX = 5e-5;
 
N = 500; %Nbre d'itérations
dt = 0.005; 
t = 0:dt:2;
Ns = length(t);
 
setpoints = 0.1 + 4.9*rand(N,1); %références
 
X = [];
Y = [];
 
opts = pidtuneOptions('CrossoverFrequency',15,'PhaseMargin',75);
 
rej = 0;
 
for i = 1:N
 
    Gv = (8.29e5*(0.9+0.2*rand())) / (s^2+5*s); %modèle avec variation de gain
 
    try
        C = pidtune(Gv,'PID',opts);
    catch
        rej = rej + 1;
        continue
    end
 
    Kp = C.Kp; Ki = C.Ki; Kd = C.Kd;
 
    if Kp<=0 || Ki<0 || Kd<0 || ...
       Kp>KP_MAX || Ki>KI_MAX || Kd>KD_MAX
        rej = rej + 1;
        continue
    end %rejection de gains limites
 
    r = setpoints(i);
    x1 = 0; x2 = 0; %position et vitesse
    ie = 0; pe = 0; %intégrale de l'erreur et erreur précédente
 
    feat = zeros(Ns,3); %features (entrées)
    lab  = repmat([Kp Ki Kd],Ns,1); %labels (sorties)
 
    for k = 1:Ns %simulation du modèle
        e  = r - x1;  %erreur
        de = (e - pe)/dt;  %dérivée de l'erreur
        ie = ie + e*dt;  %intégrale de l'erreur
 
        u = Kp*e + Ki*ie + Kd*de; %loi de commande
 
        x1 = x1 + x2*dt;
        x2 = x2 + (-5*x2 + 8.29e5*u)*dt;
 
        feat(k,:) = [e de ie];
        pe = e;
    end
 
    X = [X; feat];
    Y = [Y; lab];
 
end
 
m = mean(X); %normalisation
s = std(X)+1e-8;
 
Xn = (X - m)./s;
 
norm_stats.mean = m;
norm_stats.std  = s;
 
n = size(Xn,1); %diviser les données (85%/15%)
idx = randperm(n);
nt = floor(0.85*n);
 
Xtr = Xn(idx(1:nt),:); %données d'entrainement
Ytr = Y(idx(1:nt),:);
 
Xv  = Xn(idx(nt+1:end),:); %données de validation
Yv  = Y(idx(nt+1:end),:);
 
layers = [
    featureInputLayer(3,'Normalization','none')
    fullyConnectedLayer(64)
    reluLayer
    fullyConnectedLayer(64)
    reluLayer
    fullyConnectedLayer(32)
    reluLayer
    fullyConnectedLayer(3)
    regressionLayer
]; %architecture du réseau
 
opts = trainingOptions('adam', ...
    'MaxEpochs',150, ...
    'MiniBatchSize',256, ...
    'InitialLearnRate',1e-3, ...
    'ValidationData',{Xv,Yv}, ...
    'ValidationFrequency',50, ...
    'Shuffle','every-epoch', ...
    'Plots','training-progress'); %options du réseau
 
net = trainNetwork(Xtr,Ytr,layers,opts); %entrainement du réseau
 
Yp = predict(net,Xv); %calcul des prédictions
 
for i=1:3
    rmse = sqrt(mean((Yp(:,i)-Yv(:,i)).^2)); %calcul de l'erreur du réseau
end
 
xt = ([1 0 0]-m)./s;
gt = predict(net,xt); %test de prédiction
 
save('neuro_pid_net.mat','net','norm_stats')
 
W1 = net.Layers(2).Weights; b1 = net.Layers(2).Bias; %poids et biais du réseau
W2 = net.Layers(4).Weights; b2 = net.Layers(4).Bias;
W3 = net.Layers(6).Weights; b3 = net.Layers(6).Bias;
W4 = net.Layers(8).Weights; b4 = net.Layers(8).Bias;
 
save('neuro_pid_weights.mat','W1','b1','W2','b2','W3','b3','W4','b4','norm_stats')

Introduction

Ce script MATLAB construit et entraîne un réseau de neurones profond capable de prédire les gains d’un contrôleur PID (Kp, Ki, Kd) à partir des signaux d’erreur d’un système de contrôle.

Le script combine :

  • L’automatique classique

  • Le réglage PID

  • La simulation dynamique

  • L’apprentissage profond

Le résultat final est un modèle d’intelligence artificielle capable d’estimer automatiquement les paramètres PID à partir du comportement du système.

1. Objectif du script

Le but principal du script est de :

  1. Générer des données de simulation d’un système dynamique

  2. Régler automatiquement des contrôleurs PID avec pidtune

  3. Construire une base de données reliant :

    • Les erreurs du système (e, de, ie)

    • Les gains PID (Kp, Ki, Kd)

  4. Entraîner un réseau de neurones sur ces données

  5. Sauvegarder le réseau entraîné et ses poids

Le script agit donc comme un régleur PID intelligent basé sur l’IA.

2. Initialisation du système

clc
clear
close all

Ces commandes permettent de :

  • Nettoyer la console MATLAB

  • Supprimer les variables en mémoire

  • Fermer toutes les figures ouvertes

3. Définition de la fonction de transfert

s = tf('s');
G = 8.29e5 / (s^2 + 5*s);

Cette partie définit la fonction de transfert suivante :

[
G(s)=\frac{8.29\times10^5}{s^2+5s}
]

où :

  • s représente la variable de Laplace

  • Le dénominateur décrit la dynamique du système

  • Le numérateur représente le gain du système

Il s’agit d’un système du second ordre.

4. Contrôleur PID de référence

opts_ref = pidtuneOptions('CrossoverFrequency',15,'PhaseMargin',75);
C_ref = pidtune(G,'PID',opts_ref)

La fonction pidtune() de MATLAB calcule automatiquement un contrôleur PID adapté au système.

Paramètres importants

ParamètreSignification
CrossoverFrequencyBande passante souhaitée
PhaseMarginMarge de stabilité

Le résultat contient :

  • Kp

  • Ki

  • Kd

5. Limitation des gains PID

KP_MAX = 2e-4;
KI_MAX = 2e-4;
KD_MAX = 5e-5;

Ces constantes définissent les valeurs maximales autorisées pour les gains PID.

Tout contrôleur dépassant ces limites est rejeté.

Objectifs :

  • Éviter les contrôleurs instables

  • Supprimer les données irréalistes

  • Améliorer la qualité de l’apprentissage

6. Paramètres de simulation

N = 500;
dt = 0.005;
t = 0:dt:2;
Ns = length(t);

Signification

VariableDescription
NNombre de simulations
dtPas de temps
tVecteur temporel
NsNombre d’échantillons temporels

La simulation dure :

[
0 \rightarrow 2 \text{ secondes}
]

avec un pas de :

[
5 \text{ ms}
]

7. Génération des consignes

setpoints = 0.1 + 4.9*rand(N,1);

Le script génère des valeurs de consigne aléatoires comprises entre :

[
0.1 \le r \le 5.0
]

Cela permet d’obtenir une grande diversité de situations d’apprentissage.

8. Création des ensembles de données

X = [];
Y = [];
VariableRôle
XDonnées d’entrée
YDonnées de sortie

9. Boucle principale de génération des données

for i = 1:N

Chaque itération :

  • Crée une nouvelle variation du système

  • Calcule un PID

  • Simule le comportement dynamique

  • Produit des données d’apprentissage

10. Variation du système

Gv = (8.29e5*(0.9+0.2*rand())) / (s^2+5*s);

Le gain du système varie aléatoirement de ±10 %.

Objectifs :

  • Simuler les incertitudes réelles

  • Rendre le réseau plus robuste

  • Améliorer la généralisation

11. Réglage automatique du PID

C = pidtune(Gv,'PID',opts);

Pour chaque système généré :

  • MATLAB calcule automatiquement un contrôleur PID optimal

Extraction des gains :

Kp = C.Kp;
Ki = C.Ki;
Kd = C.Kd;

12. Filtrage des gains

if Kp<=0 || Ki<0 || Kd<0 || ...
   Kp>KP_MAX || Ki>KI_MAX || Kd>KD_MAX

Les contrôleurs sont rejetés si :

  • Les gains sont négatifs

  • Les gains dépassent les limites fixées

Cela améliore la qualité des données.

13. Initialisation des états

x1 = 0;
x2 = 0;

Les états représentent :

VariableSignification
x1Position
x2Vitesse

Variables d’erreur :

ie = 0;
pe = 0;
VariableRôle
ieIntégrale de l’erreur
peErreur précédente

14. Construction des caractéristiques

feat = zeros(Ns,3);
lab  = repmat([Kp Ki Kd],Ns,1);

Entrées du réseau

Chaque échantillon contient :

[
[e,\ de,\ ie]
]

avec :

  • e : erreur

  • de : dérivée de l’erreur

  • ie : intégrale de l’erreur

Sorties du réseau

[
[K_p,\ K_i,\ K_d]
]

15. Boucle de simulation dynamique

for k = 1:Ns

Le système est simulé pas à pas.

15.1 Calcul de l’erreur

e = r - x1;

[
e(t)=r(t)-y(t)
]

15.2 Dérivée de l’erreur

de = (e - pe)/dt;

Approximation numérique :

[
\frac{de}{dt}
]

15.3 Intégrale de l’erreur

ie = ie + e*dt;

Approximation :

[
\int e(t),dt
]

15.4 Loi de commande PID

u = Kp*e + Ki*ie + Kd*de;

Équation PID classique :

[
u(t)=K_pe(t)+K_i\int e(t)dt+K_d\frac{de}{dt}
]

15.5 Dynamique du système

x1 = x1 + x2*dt;
x2 = x2 + (-5*x2 + 8.29e5*u)*dt;

Intégration numérique d’Euler :

[
\dot{x}_1=x_2
]

[
\dot{x}_2=-5x_2+8.29\times10^5u
]

16. Construction de la base de données

X = [X; feat];
Y = [Y; lab];

Toutes les données générées sont ajoutées à la base d’apprentissage.

17. Normalisation des données

m = mean(X);
s = std(X)+1e-8;
Xn = (X - m)./s;

Formule utilisée :

[
X_n=\frac{X-\mu}{\sigma}
]

Objectifs :

  • Stabiliser l’apprentissage

  • Accélérer la convergence

  • Éviter les gradients instables

18. Séparation apprentissage / validation

nt = floor(0.85*n);

Répartition :

EnsemblePourcentage
Entraînement85 %
Validation15 %

19. Architecture du réseau de neurones

layers = [
    featureInputLayer(3)
    fullyConnectedLayer(64)
    reluLayer
    fullyConnectedLayer(64)
    reluLayer
    fullyConnectedLayer(32)
    reluLayer
    fullyConnectedLayer(3)
    regressionLayer
];

Structure du réseau

CoucheTaille
Entrée3
Cachée 164
Cachée 264
Cachée 332
Sortie3

Entrées :

[
[e,de,ie]
]

Sorties :

[
[K_p,K_i,K_d]
]

20. Fonction d’activation ReLU

reluLayer

La fonction utilisée est :

[
f(x)=\max(0,x)
]

Avantages :

  • Entraînement rapide

  • Réduction du problème du gradient qui disparaît

  • Calcul simple

21. Paramètres d’entraînement

opts = trainingOptions('adam', ...)

Paramètres principaux

ParamètreValeur
OptimiseurAdam
Époques150
Taille des lots256
Taux d’apprentissage0.001

L’algorithme Adam combine :

  • Momentum

  • Taux d’apprentissage adaptatif

22. Entraînement du réseau

net = trainNetwork(Xtr,Ytr,layers,opts);

Le réseau apprend la relation :

[
[e,de,ie] \rightarrow [K_p,K_i,K_d]
]

23. Validation et prédiction

Yp = predict(net,Xv);

Les prédictions sont comparées aux vraies valeurs.

24. Calcul de l’erreur RMSE

rmse = sqrt(mean((Yp(:,i)-Yv(:,i)).^2));

Erreur quadratique moyenne :

[
RMSE=\sqrt{\frac{1}{N}\sum (y_{pred}-y_{true})^2}
]

Elle mesure la précision du réseau.

25. Test du réseau

xt = ([1 0 0]-m)./s;
gt = predict(net,xt);

Exemple d’entrée :

[
[e,de,ie]=[1,0,0]
]

Le réseau prédit alors les gains PID correspondants.

26. Sauvegarde du réseau

save('neuro_pid_net.mat','net','norm_stats')

Sauvegarde :

  • Le réseau entraîné

  • Les paramètres de normalisation

27. Extraction des poids du réseau

W1 = net.Layers(2).Weights;
b1 = net.Layers(2).Bias;

Les poids et biais sont extraits couche par couche.

Utilités :

  • Déploiement embarqué

  • FPGA

  • Microcontrôleurs

  • Moteurs d’inférence personnalisés

28. Sauvegarde des poids

save('neuro_pid_weights.mat',...)

Création d’un fichier léger contenant uniquement :

  • Les poids

  • Les biais

  • Les paramètres de normalisation

29. Schéma global du fonctionnement

Variation du système
        ↓
Réglage automatique PID
        ↓
Simulation dynamique
        ↓
Collecte des erreurs et gains PID
        ↓
Normalisation des données
        ↓
Entraînement du réseau profond
        ↓
Prédiction des gains PID
        ↓
Sauvegarde du modèle

30. Concepts utilisés

Automatique

  • Contrôle PID

  • Fonction de transfert

  • Boucle fermée

  • Marges de stabilité

Intelligence artificielle

  • Apprentissage supervisé

  • Réseau de neurones profond

  • Régression

  • Normalisation des données

Méthodes numériques

  • Intégration d’Euler

  • Simulation numérique

  • RMSE

31. Avantages de cette approche

Réglage PID intelligent

Le réseau peut prédire instantanément les gains PID sans exécuter pidtune.

Temps réel

Approche adaptée aux :

  • Systèmes embarqués

  • Robots

  • Véhicules autonomes

  • Contrôle adaptatif rapide

Robustesse

Les variations du système rendent le modèle plus résistant aux incertitudes.

32. Limitations

Diversité limitée des données

Le script ne prend pas en compte :

  • Le bruit

  • Les perturbations

  • Les non-linéarités

Méthode d’Euler simplifiée

L’intégration d’Euler est simple mais peu précise.

Des solveurs avancés seraient plus réalistes.

Architecture fixe

Le réseau est défini manuellement.

Une optimisation automatique pourrait améliorer les performances.

33. Améliorations possibles

Ajouter davantage de caractéristiques

Par exemple :

  • Dépassement

  • Temps de réponse

  • Effort de commande

  • Sortie du système

Utiliser de meilleurs simulateurs

Comme :

  • ode45

  • Simulink

  • Modèles espace d’état

Apprentissage en ligne

Permettre au réseau de s’adapter pendant le fonctionnement.

Déploiement embarqué

Les poids sauvegardés peuvent être utilisés sur :

  • STM32

  • FPGA

  • Raspberry Pi

  • DSP

Conclusion

Ce script illustre une approche hybride combinant :

  • Les méthodes classiques de contrôle PID

  • La simulation dynamique

  • L’apprentissage profond

Le réseau de neurones apprend à prédire les gains PID à partir des signaux d’erreur du système, permettant un réglage intelligent et potentiellement temps réel des contrôleurs.

Il s’agit d’un exemple de commande neuro-adaptative, montrant comment l’intelligence artificielle peut améliorer les techniques classiques d’automatique.

Graph View