\documentclass[12pt, a4paper, oneside]{report}

%--------------------------------------------------------------
% PACKAGES
%--------------------------------------------------------------
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[french]{babel}
\usepackage{geometry}
\geometry{top=2.5cm, bottom=2.5cm, left=3cm, right=2.5cm}

\usepackage{graphicx}
\usepackage{amsmath, amssymb, amsthm}
\usepackage{mathtools}
\usepackage{bm}
\usepackage{array}
\usepackage{booktabs}
\usepackage{tabularx}
\usepackage{longtable}
\usepackage{multirow}
\usepackage{caption}
\usepackage{subcaption}
\usepackage{float}
\usepackage{hyperref}
\hypersetup{
    colorlinks=true,
    linkcolor=black,
    citecolor=black,
    urlcolor=blue
}
\usepackage{setspace}
\usepackage{fancyhdr}
\usepackage{titlesec}
\usepackage{tocloft}
\usepackage{nomencl}
\usepackage{appendix}
\usepackage{cite}
\usepackage{url}
\usepackage{xcolor}
\usepackage{listings}
\usepackage{tikz}
\usetikzlibrary{arrows.meta, positioning, shapes.geometric, calc, fit}
\usepackage{pgfplots}
\pgfplotsset{compat=1.18}

%--------------------------------------------------------------
% MISE EN PAGE
%--------------------------------------------------------------
\onehalfspacing

% --- En-têtes et pieds de page ---
\pagestyle{fancy}
\fancyhf{}
\fancyhead[L]{\small\nouppercase{\leftmark}}
\renewcommand{\headrulewidth}{0.4pt}
\fancyfoot[C]{\thepage}
\renewcommand{\footrulewidth}{0pt}
\fancypagestyle{plain}{%
  \fancyhf{}%
  \fancyfoot[C]{\thepage}%
  \renewcommand{\headrulewidth}{0pt}%
}
\setlength{\headheight}{14pt}
\titleformat{\chapter}[display]
  {\normalfont\Large\bfseries}
  {\chaptertitlename\ \thechapter}{14pt}{\huge}

%--------------------------------------------------------------
% NOMENCLATURE
%--------------------------------------------------------------
\makenomenclature

%==============================================================
\begin{document}
%==============================================================
\pagenumbering{roman}

%--------------------------------------------------------------
% PAGE DE GARDE
%--------------------------------------------------------------
\begin{titlepage}
\centering
{\small
République Algérienne Démocratique et Populaire \\
Ministère de l'Enseignement Supérieur et de la Recherche Scientifique
}

\vspace{0.3cm}
\textbf{UNIVERSITÉ MOULOUD MAMMERI DE TIZI-OUZOU}

\vspace{0.5cm}
\includegraphics[width=3cm]{attachements/ummto_logo_100x100.png}\\[0.3cm]

\textbf{FACULTÉ DU GÉNIE ÉLECTRIQUE ET D'INFORMATIQUE} \\
\textbf{DÉPARTEMENT D'AUTOMATIQUE}

\vspace{0.7cm}
\Large\textbf{Mémoire de Fin d'Études\\de MASTER ACADEMIQUE}

\vspace{0.5cm}
\normalsize
Domaine : Sciences et Technologies \\
Filière : Automatique \\
Spécialité : Automatique et Informatique Industrielle

\vspace{0.5cm}
Présenté par

\Large\textbf{Rayane AKKOUCHE}

\vspace{0.45cm}
\underline{\textbf{Thème:}}

\vspace{0.5cm}
\LARGE\textbf{Contrôleur PID d'ordre fractionnaire réglé par réseau de neurones}

\vspace{1.0cm}
\normalsize\textit{Mémoire soutenu le \ldots/\ldots/2026 devant le jury composé de :}

\vspace{0.6cm}
\begin{flushleft}
\hspace{2cm}
\begin{tabular}{lll}
M.   Prénom NOM     & Grade, Lieu d'exercice   & Président        \\[0.3cm]
Mme Karima AMOURA   & Grade, UMMTO             & Encadrante       \\[0.3cm]
M.   Prénom NOM     & Grade, Lieu d'exercice   & Examinateur      \\[0.3cm]
M.   Prénom NOM     & Grade, Lieu d'exercice   & Examinateur      \\
\end{tabular}
\end{flushleft}

\vfill
\end{titlepage}

%--------------------------------------------------------------
% REMERCIEMENTS
%--------------------------------------------------------------
\chapter*{Remerciements}
\addcontentsline{toc}{chapter}{Remerciements}


\newpage

%--------------------------------------------------------------
% DÉDICACE
%--------------------------------------------------------------
\chapter*{Dédicace}
\addcontentsline{toc}{chapter}{Dédicace}
\thispagestyle{empty}

\vspace*{4cm}
\begin{center}
\end{center}
\newpage

%--------------------------------------------------------------
% RÉSUMÉ
%--------------------------------------------------------------
\chapter*{Résumé}
\addcontentsline{toc}{chapter}{Résumé}

Ce mémoire porte sur la synthèse d'un contrôleur PID d'ordre fractionnaire (FOPID)
dont les paramètres sont réglés à l'aide d'un réseau de neurones artificiels, appliqué à la
commande de la vitesse d'un véhicule électrique hybride. L'objectif est d'imposer à la boucle
fermée un comportement robuste d'iso-amortissement par l'intermédiaire d'un modèle de
référence fractionnaire.

Dans un premier temps, les notions fondamentales des systèmes d'ordre fractionnaire sont
présentées, notamment le dérivateur généralisé et son approximation par la méthode d'Oustaloup.
Le modèle de référence fractionnaire d'iso-amortissement est ensuite introduit et analysé.

Le deuxième chapitre traite du contrôleur PID classique et du contrôleur FOPID, leurs
structures, leurs types et leurs méthodes de réglage, incluant une application numérique.
Le troisième chapitre est consacré aux réseaux de neurones artificiels : architecture, types,
apprentissage, régularisation et critères de performance.

Le quatrième chapitre présente le modèle du véhicule électrique hybride, sa modélisation
et son analyse, ainsi que la conception complète du contrôleur Neuro-FOPID et les résultats
de simulation. Le Neuro-FOPID réduit le dépassement à $0.29\%$, l'ISE d'un facteur 7 par
rapport au PID classique, et maintient ces performances sur $\pm 30\%$ de variation de gain.

\vspace{0.5cm}
\textbf{Mots-clés :} Contrôleur FOPID, Réseau de neurones, Modèle de référence fractionnaire,
Systèmes d'ordre fractionnaire, Véhicule électrique, Commande robuste, Iso-amortissement.

\newpage

\tableofcontents
\newpage

\listoffigures
\addcontentsline{toc}{chapter}{Table des figures}
\newpage

\listoftables
\addcontentsline{toc}{chapter}{Liste des tableaux}
\newpage

%--------------------------------------------------------------
% LISTE DES SYMBOLES
%--------------------------------------------------------------
\chapter*{Liste des Symboles}
\addcontentsline{toc}{chapter}{Liste des Symboles}

\section*{Symboles Généraux et Mathématiques}
\begin{tabular}{ll}
$s$         & Variable de Laplace (opérateur de dérivation) \\
$t$         & Temps (s) \\
$j$         & Unité imaginaire ($j^2 = -1$) \\
$\omega$    & Pulsation (rad/s) \\
$\omega_c$  & Fréquence de coupure ou de référence (rad/s) \\
$\Gamma(\cdot)$ & Fonction Gamma d'Euler \\
$e(t)$      & Signal d'erreur ($e(t) = r(t) - y(t)$) \\
$u(t)$      & Signal de commande (sortie du contrôleur) \\
$r(t)$      & Consigne (référence) \\
$y(t)$      & Sortie du système \\
\end{tabular}

\section*{Chapitre I : Systèmes d'Ordre Fractionnaire}
\begin{tabular}{ll}
$D^\alpha$      & Opérateur de dérivée/intégrale fractionnaire d'ordre $\alpha$ \\
$\alpha, \lambda, \nu$ & Ordres fractionnaires (exposants réels) \\
$n$             & Ordre entier (dans les définitions Riemann-Liouville et Caputo) \\
$\omega_l$      & Fréquence basse de la bande d'approximation (rad/s) \\
$\omega_h$      & Fréquence haute de la bande d'approximation (rad/s) \\
$\tau_c$        & Constante de temps du modèle de référence fractionnaire \\
$\varphi_m$     & Marge de phase (rad ou deg) \\
$M_p$           & Dépassement (Overshoot) (\%) \\
$T_s$           & Temps de stabilisation (s) \\
\end{tabular}

\section*{Chapitre II : Contrôleurs PID et FOPID}
\begin{tabular}{ll}
$K_p$       & Gain proportionnel \\
$K_i$       & Gain intégral \\
$K_d$       & Gain dérivé \\
$T_i$       & Constante de temps intégrale (s) \\
$T_d$       & Constante de temps dérivée (s) \\
$N_f$       & Facteur de filtrage du terme dérivé \\
$\lambda$   & Ordre de l'intégration fractionnaire \\
$\mu$       & Ordre de la dérivation fractionnaire \\
IAE         & Integral of Absolute Error \\
ITAE        & Integral of Time-weighted Absolute Error \\
ISE         & Integral of Squared Error \\
ITSE        & Integral of Time-weighted Squared Error \\
\end{tabular}

\section*{Chapitre III : Réseaux de Neurones Artificiels}
\begin{tabular}{ll}
$w_{ij}$    & Poids synaptique entre le neurone $j$ et le neurone $i$ \\
$b_i$       & Biais du neurone $i$ \\
$\eta$      & Taux d'apprentissage \\
$\mathcal{L}$ & Fonction de coût (erreur d'entraînement) \\
$\beta_1, \beta_2$ & Coefficients de moment de l'algorithme Adam \\
$\epsilon$  & Constante de stabilité numérique (Adam) \\
\end{tabular}

\section*{Chapitre IV : Véhicule Électrique et Simulation}
\begin{tabular}{ll}
$v$         & Vitesse du véhicule (m/s) \\
$\theta$    & Position du papillon des gaz (commande) \\
$F_e$       & Force générée par le moteur (N) \\
$m$         & Masse du véhicule (kg) \\
$\alpha_t$  & Coefficient de traînée aérodynamique (N/(m/s)$^2$) \\
$\tau_e$    & Constante de temps du moteur (s) \\
$G_v(s)$    & Fonction de transfert du véhicule ($V(s)/\Theta(s)$) \\
$T_{ref}(s)$& Modèle de référence fractionnaire d'iso-amortissement \\
\end{tabular}

\newpage

%==============================================================
%  INTRODUCTION GÉNÉRALE
%==============================================================
\pagenumbering{arabic}
\chapter*{Introduction Générale}
\addcontentsline{toc}{chapter}{Introduction Générale}
\markboth{Introduction Générale}{Introduction Générale}

Depuis l'avènement de l'automatisme industriel, la commande des systèmes dynamiques n'a
cessé d'évoluer pour répondre à des exigences toujours plus strictes en termes de précision,
de rapidité et de robustesse. Au cœur de cette évolution se trouve le régulateur PID
(Proportionnel, Intégral, Dérivé), dont la simplicité structurelle et l'efficacité pratique en
ont fait l'outil de régulation dominant. Desborough et Miller rapportent que plus de 97\%
des contrôleurs industriels sont des régulateurs PID~\cite{Desborough2002}. Cette omniprésence
s'explique par sa capacité à bien contrôler une large gamme de processus, sa robustesse
de mise en œuvre et son rapport qualité-prix avantageux. Cependant, face à des systèmes
dynamiques de plus en plus complexes, non linéaires et soumis à des incertitudes paramétriques
importantes, le PID classique trouve ses limites et devient incapable de satisfaire tous
les besoins de performance~\cite{Liu2017}.

Depuis les années soixante, l'extension des outils du calcul différentiel aux ordres non
entiers a ouvert une nouvelle voie dans la modélisation et la commande des systèmes.
La commande CRONE développée par Oustaloup~\cite{Oustaloup1995} et le contrôleur
PI$^\lambda$D$^\mu$ proposé par Podlubny~\cite{Podlubny1999} ont démontré la supériorité
des contrôleurs fractionnaires sur leurs homologues entiers, notamment en termes de
robustesse vis-à-vis des variations des paramètres du processus. Le PID fractionnaire
(FOPID) dispose en effet de deux degrés de liberté supplémentaires --- les ordres
fractionnaires $\lambda$ et $\mu$ --- qui permettent un réglage plus fin et un découplage
entre rapidité et amortissement, difficilement atteignable avec un PID classique.

Malgré ses avantages, le réglage optimal d'un contrôleur FOPID à cinq paramètres
($K_p$, $K_i$, $K_d$, $\lambda$, $\mu$) demeure une tâche délicate. Les méthodes
d'optimisation classiques --- programmation quadratique séquentielle (SQP), algorithme du
simplexe de Nelder-Mead --- sont efficaces mais restent sensibles au point d'initialisation
et peuvent converger vers des minima locaux. L'intelligence artificielle, et en particulier
les réseaux de neurones artificiels, offre une alternative prometteuse : une fois entraîné
hors ligne sur une base de données d'exemples optimaux, un réseau de neurones est capable
de fournir instantanément les paramètres optimaux du FOPID pour n'importe quelle condition.

La robustesse constitue sans doute la propriété la plus recherchée dans un système de
commande industriel. L'intégrateur fractionnaire d'ordre non entier proposé par Bode
dès 1945~\cite{Bode1945} comme modèle de boucle ouverte garantit une propriété
remarquable d'iso-amortissement : le dépassement en boucle fermée est insensible aux
variations du gain de la chaîne d'action. Ce modèle de référence fractionnaire constitue
aujourd'hui un cadre de référence reconnu pour la synthèse de régulateurs robustes~\cite{Barbosa2004}.

L'application à la commande de vitesse des véhicules électriques illustre parfaitement les
enjeux de cette problématique. Ce domaine, en pleine expansion dans le contexte de la
transition énergétique mondiale, requiert des stratégies de commande capables de concilier
précision, réactivité et robustesse face aux variations de la charge et des conditions routières.

\textbf{L'objectif de ce travail} est de concevoir un contrôleur FOPID dont les cinq
paramètres sont calculés automatiquement par un réseau de neurones artificiel entraîné
à minimiser un critère d'erreur composite, en imposant à la boucle fermée un comportement
fractionnaire robuste d'iso-amortissement. La stratégie de commande est validée par
simulation sur le modèle de vitesse d'un véhicule électrique hybride et comparée au PID
classique et au FOPID réglé par optimisation numérique directe.

Ce mémoire s'articule en quatre chapitres :

\medskip
Le \textbf{Chapitre I} est consacré aux généralités sur les systèmes d'ordre fractionnaire.
Nous y présentons les opérateurs différentiels selon Riemann-Liouville et Caputo, le
dérivateur généralisé et sa méthode d'approximation d'Oustaloup, ainsi que le modèle de
référence fractionnaire d'iso-amortissement et ses propriétés.

\medskip
Dans le \textbf{Chapitre II}, nous traitons les contrôleurs PID classique et FOPID.
Après une description des structures du PID, nous présentons le FOPID, ses différents
types, les méthodes de réglage par optimisation et un exemple d'application numérique.

\medskip
Le \textbf{Chapitre III} est entièrement consacré aux réseaux de neurones artificiels.
Nous y détaillons le neurone formel, les différents types de réseaux (MLP, CNN, RNN\ldots),
les fonctions d'activation, l'algorithme de rétropropagation et les critères d'erreur,
ainsi que les architectures de commande neuronale pour les systèmes dynamiques.

\medskip
Le \textbf{Chapitre IV} présente la modélisation du véhicule électrique hybride ainsi que
la conception complète et les résultats de simulation du contrôleur Neuro-FOPID, incluant
la comparaison avec les contrôleurs de référence, les tests de robustesse et le rejet de
perturbation.

\medskip
Enfin, une \textbf{Conclusion Générale} résume les principaux résultats et propose des
perspectives de travaux futurs.

\newpage

%==============================================================
%  CHAPITRE I
%==============================================================
\chapter{Simulation des systèmes d'ordre fractionnaires}

\section{Introduction}

Le calcul d'ordre fractionnaire est un domaine qui traite des dérivées et des intégrales
d'ordre non entier. Avec l'avancée de la science et le développement de l'outil informatique,
l'intérêt de la dérivation et de l'intégration d'ordre non entier ne cesse de croître,
notamment dans le domaine de l'automatique pour la modélisation, l'identification et la
commande des systèmes~\cite{Monje2010,Podlubny1999}.

Dans le domaine du contrôle, les systèmes d'ordre fractionnaire apportent un réel avantage.
Un bon exemple est l'utilisation de la fonction idéale de Bode~\cite{Bode1945} comme modèle
de référence robuste : en raison de ses caractéristiques d'iso-amortissement, elle sert
souvent de référence pour ajuster les contrôleurs PID fractionnaires~\cite{Monje2010}.
Ce type de contrôleur offre une meilleure robustesse et de meilleures performances lorsque
les conditions changent ou que le système est complexe.

Ce chapitre a pour but de se familiariser avec l'univers des systèmes d'ordre fractionnaire.
On y présente certains fondements clés ainsi que la méthode d'approximation du dérivateur
généralisé d'Oustaloup~\cite{Oustaloup1995}, largement utilisée pour la simulation des
systèmes d'ordre fractionnaire~\cite{Monje2010,Petras2011}.

%--------------------------------------------------------------
\section{Systèmes d'ordre fractionnaire}

Un système d'ordre fractionnaire est décrit par une équation différentielle impliquant des
dérivées fractionnaires :
\begin{equation}
    a_n D^{\alpha_n} y(t) + \cdots + a_1 D^{\alpha_1} y(t)
    = b_m D^{\beta_m} u(t) + \cdots + b_0 D^{\beta_0} u(t),
    \label{eq:sof}
\end{equation}
où $D^\alpha$ représente l'opérateur de dérivée d'ordre $\alpha \in \mathbb{R}^+$, défini
au sens de Riemann-Liouville ou Caputo~\cite{Podlubny1999,Caputo1967}. Ces formalismes
capturent des dynamiques non exponentielles, comme les relaxations en loi de puissance.

%--------------------------------------------------------------
\subsection{Opérateurs différentiels fractionnaires}

Un opérateur fractionnaire généralise les dérivées et intégrales classiques à des ordres
réels. Pour $\alpha > 0$, il correspond à une dérivation d'ordre $\alpha$ ; pour
$\alpha < 0$, il correspond à une intégration d'ordre $|\alpha|$.

\paragraph{Dérivée de Riemann-Liouville~\cite{Podlubny1999} :}
\begin{equation}
    D^\alpha f(t) = \frac{1}{\Gamma(n-\alpha)}
    \frac{d^n}{dt^n}
    \int_a^t \frac{f(\tau)}{(t-\tau)^{\alpha-n+1}}\, d\tau,
    \quad n-1 < \alpha < n,
    \label{eq:RL}
\end{equation}
où $n$ est un entier tel que $n-1 < \alpha < n$.

\paragraph{Dérivée de Caputo~\cite{Caputo1967} :}
\begin{equation}
    D^\alpha f(t) = \frac{1}{\Gamma(n-\alpha)}
    \int_a^t \frac{f^{(n)}(\tau)}{(t-\tau)^{\alpha-n+1}}\, d\tau,
    \quad n-1 < \alpha < n.
    \label{eq:Caputo}
\end{equation}

La formulation de Caputo est préférable en commande car elle permet d'utiliser des conditions
initiales exprimées en termes de dérivées entières, plus accessibles physiquement. La
fonction $\Gamma$ est la généralisation de la factorielle aux réels :
\begin{equation}
    \Gamma(\nu) = \int_0^{+\infty} e^{-x}\, x^{\nu-1}\, dx.
\end{equation}

%--------------------------------------------------------------
\subsection{Dérivateur généralisé}

Le dérivateur généralisé est un opérateur linéaire noté $s^\alpha$ ($\alpha \in \mathbb{R}$),
généralisant la dérivation et l'intégration. Une variante courante inclut une fréquence de
coupure $\omega_c$~\cite{Podlubny1999} :
\begin{equation}
    D_{\text{gen}}(s) = \left(\frac{s}{\omega_c}\right)^\alpha, \quad \alpha \in \mathbb{R}.
    \label{eq:dgen}
\end{equation}

Dans le domaine fréquentiel :
\begin{equation}
    D_{\text{gen}}(j\omega) = \left(\frac{j\omega}{\omega_c}\right)^\alpha
    = \left|\frac{\omega}{\omega_c}\right|^\alpha e^{j\alpha\pi/2}.
    \label{eq:dgen_freq}
\end{equation}

Cette forme préserve un gain en $(\omega/\omega_c)^\alpha$ et une phase constante de
$\alpha\pi/2$. Cette phase constante sur une large plage de fréquences rend sa réalisation
physique complexe et nécessite des approximations à bande limitée.

%--------------------------------------------------------------
\subsection{Méthodes d'approximation du dérivateur généralisé}
\label{sec:approx_methods}

Le dérivateur généralisé $s^\alpha$ constitue l'élément principal pour la synthèse des
systèmes fractionnaires. Sa réalisation physique directe étant impossible (phase constante
sur une bande infinie), plusieurs méthodes d'approximation rationnelle à bande limitée ont
été proposées dans la littérature. On peut notamment citer : la méthode de Charef~\cite{Charef1992},
basée sur une cascade récursive de pôles et zéros à distribution logarithmique ; la méthode
de Carlson, fondée sur un développement en fraction continue~\cite{Kilbas2006} ; et la méthode
d'Oustaloup~\cite{Oustaloup1995}, qui fournit la meilleure précision sur une bande de
fréquences large grâce à une répartition symétrique des singularités. Dans ce travail, la
méthode d'Oustaloup est retenue pour la simulation de toutes les lois de commande.

%--------------------------------------------------------------
\subsection{Méthode d'Oustaloup}
\label{sec:oustaloup}

% FIX: use lettered sub-headings for unnumbered subsections inside a subsection

\paragraph{a. Principe général}

La méthode d'Oustaloup~\cite{Oustaloup1995} est une technique d'approximation fréquentielle
qui consiste à remplacer l'opérateur fractionnaire idéal $s^\alpha$ ($\alpha \in \mathbb{R}$)
par une fonction de transfert rationnelle d'ordre entier dont la réponse fréquentielle
coïncide avec celle de $s^\alpha$ sur une bande de fréquences prédéfinie $[\omega_l, \omega_h]$.
L'idée fondatrice est que, sur cette bande limitée, le gain et la phase d'un système
entier bien construit peuvent imiter fidèlement le comportement en loi de puissance de
l'opérateur fractionnaire.

Formellement, l'approximation est de la forme :
\begin{equation}
    s^\alpha \approx H_{\text{Oustaloup}}(s) = C \prod_{k=1}^{N}
    \frac{s + \omega_{z_k}}{s + \omega_{p_k}},
    \label{eq:oustaloup_factored}
\end{equation}
où $C$ est un gain de normalisation, et $\{\omega_{z_k}\}$, $\{\omega_{p_k}\}$ sont
respectivement les zéros et les pôles de l'approximation, réels et strictement positifs.

\paragraph{b. Construction de l'approximation}

La méthode repose sur la répartition géométrique de $2N+1$ pôles et $2N+1$ zéros sur
la bande $[\omega_l, \omega_h]$, symétriquement autour de la fréquence centrale
$\omega_u = \sqrt{\omega_l \omega_h}$. La formulation standard s'écrit~\cite{Oustaloup1995,Monje2010} :
\begin{equation}
    H_{\text{Oustaloup}}(s) = \omega_h^\alpha \prod_{k=-N}^{N}
    \frac{1 + s/\omega_{z_k}}{1 + s/\omega_{p_k}},
    \label{eq:oustaloup}
\end{equation}
où le facteur $\omega_h^\alpha$ assure la normalisation du gain à la fréquence haute de
la bande. Les fréquences des zéros et des pôles sont définies par les lois récursives :
\begin{equation}
    \omega_{z_k} = \omega_l \left(\frac{\omega_h}{\omega_l}\right)^{\frac{k+N+1-\alpha/2}{2N+1}},
    \qquad
    \omega_{p_k} = \omega_l \left(\frac{\omega_h}{\omega_l}\right)^{\frac{k+N+1+\alpha/2}{2N+1}},
    \label{eq:oustaloup_poles}
\end{equation}
pour $k = -N, -N+1, \ldots, N$. Ces expressions montrent que les pôles et zéros sont
distribués en progression géométrique sur l'axe fréquentiel, avec un rapport commun
$\eta = (\omega_h/\omega_l)^{1/(2N+1)}$.

Une propriété importante est que les pôles et zéros sont entrelacés : entre deux pôles
consécutifs se trouve exactement un zéro, et vice versa. Cette alternance est la clé
du mécanisme d'approximation : chaque paire $(\omega_{z_k}, \omega_{p_k})$ produit
localement une contribution de phase de $+\alpha\pi/(2N+1)$, et leur accumulation
sur toute la bande tend vers la valeur cible $\alpha\pi/2$.

\paragraph{c. Propriétés fréquentielles}

Sur la bande d'approximation $[\omega_l, \omega_h]$, la réponse fréquentielle de
$H_{\text{Oustaloup}}(j\omega)$ présente deux propriétés essentielles :

\begin{itemize}
    \item \textbf{Gain :} $|H_{\text{Oustaloup}}(j\omega)| \approx (\omega/\omega_l)^\alpha$,
    soit une pente de $20\alpha$ dB/décade, identique à celle de l'opérateur idéal $s^\alpha$.
    \item \textbf{Phase :} $\angle H_{\text{Oustaloup}}(j\omega) \approx \alpha\pi/2$,
    une phase quasi-constante sur toute la bande, caractéristique de l'iso-amortissement.
\end{itemize}

Hors de la bande $[\omega_l, \omega_h]$, l'approximation diverge du comportement idéal :
le gain tend vers une constante aux très basses fréquences et la phase retombe à zéro
aux très hautes fréquences. Il est donc essentiel de choisir $[\omega_l, \omega_h]$ de
sorte qu'elle englobe toute la plage de fréquences significative du système à commander.

\paragraph{d. Choix des paramètres}

Les paramètres de réglage de la méthode sont au nombre de trois : l'ordre d'approximation
$N$, la fréquence basse $\omega_l$ et la fréquence haute $\omega_h$.

L'ordre $N$ contrôle directement la précision de l'approximation. Le tableau~\ref{tab:oustaloup_N}
récapitule l'erreur maximale de phase sur la bande en fonction de $N$ pour $\alpha = 0.5$,
d'après~\cite{Monje2010}.

\begin{table}[H]
\centering
\caption{Erreur maximale de phase de l'approximation d'Oustaloup en fonction de $N$
(exemple : $\alpha = 0.5$, bande $[10^{-2}, 10^2]$ rad/s)~\cite{Monje2010}.}
\label{tab:oustaloup_N}
\begin{tabular}{cccc}
\toprule
$N$ & Nombre de pôles/zéros & Erreur phase max. & Erreur gain max. \\
\midrule
2  & 5   & $\sim 5.0$\textdegree & $\sim 3.0$ dB \\
3  & 7   & $\sim 2.5$\textdegree & $\sim 1.5$ dB \\
5  & 11  & $\sim 0.5$\textdegree & $< 2.0$ dB \\
7  & 15  & $\sim 0.1$\textdegree & $< 0.5$ dB \\
\bottomrule
\end{tabular}
\end{table}

Un choix standard est $N = 5$ avec la bande $[\omega_l, \omega_h] = [10^{-2}, 10^2]$
rad/s, ce qui produit 11 pôles et 11 zéros et garantit une erreur inférieure à
$0.5$\textdegree{} en phase et 2~dB en gain sur quatre décades~\cite{Monje2010}.
En pratique, la bande est adaptée à la dynamique du système : on choisit
$\omega_l \ll \omega_c$ et $\omega_h \gg \omega_c$, où $\omega_c$ est la fréquence
de coupure du système en boucle ouverte.

\paragraph{e. Exemple numérique}

Considérons l'approximation de $s^{0.5}$ sur la bande $[10^{-2}, 10^2]$ rad/s avec
$N = 3$ (7 pôles et 7 zéros). La progression géométrique donne un rapport
$\eta = (10^2/10^{-2})^{1/7} = 10^{4/7} \approx 3.73$. Les fréquences
calculées selon~(\ref{eq:oustaloup_poles}) sont :

\begin{table}[H]
\centering
\caption{Zéros et pôles de l'approximation d'Oustaloup pour $s^{0.5}$,
$N=3$, $\omega_l = 10^{-2}$, $\omega_h = 10^2$ rad/s.}
\label{tab:oustaloup_example}
\begin{tabular}{ccc}
\toprule
$k$ & $\omega_{z_k}$ (rad/s) & $\omega_{p_k}$ (rad/s) \\
\midrule
$-3$ & $1.26 \times 10^{-2}$ & $4.70 \times 10^{-2}$ \\
$-2$ & $4.70 \times 10^{-2}$ & $1.75 \times 10^{-1}$ \\
$-1$ & $1.75 \times 10^{-1}$ & $6.52 \times 10^{-1}$ \\
$ 0$ & $6.52 \times 10^{-1}$ & $2.43 \times 10^{0}$  \\
$ 1$ & $2.43 \times 10^{0}$  & $9.07 \times 10^{0}$  \\
$ 2$ & $9.07 \times 10^{0}$  & $3.38 \times 10^{1}$  \\
$ 3$ & $3.38 \times 10^{1}$  & $1.26 \times 10^{2}$  \\
\bottomrule
\end{tabular}
\end{table}

On vérifie l'entrelacement : chaque zéro $\omega_{z_k}$ coïncide avec le pôle de l'indice
précédent $\omega_{p_{k-1}}$, confirmant la structure alternée de l'approximation.
La phase résultante sur $[10^{-2}, 10^2]$ rad/s est quasi-constante et vaut
approximativement $0.5 \times 90\text{\textdegree} = 45\text{\textdegree}$, avec une
ondulation inférieure à $2.5\text{\textdegree}$.

\paragraph{f. Diagramme de Bode de l'approximation}

La figure~\ref{fig:bode_oustaloup} compare le diagramme de Bode de l'opérateur idéal
$s^{0.5}$ et de son approximation d'Oustaloup d'ordre $N = 5$ sur la bande
$[10^{-2}, 10^2]$ rad/s.

\begin{figure}[H]
    \centering
    \includegraphics[width=0.85\textwidth]{attachements/bode_oustaloup.png}
    \caption{Diagramme de Bode comparatif~: opérateur idéal $s^{0{,}5}$ (bleu)
             et approximation d'Oustaloup d'ordre $N=5$ (rouge tirets) sur la
             bande $[\omega_l, \omega_h] = [10^{-2},\, 10^{2}]$~rad/s.
             La phase de l'approximation reste dans une bande de $\pm 2^\circ$
             autour de la valeur cible de $45^\circ$.}
    \label{fig:bode_oustaloup}
\end{figure}

%--------------------------------------------------------------
\subsection{Modèle de référence en boucle fermée}
\label{sec:bode_ideal}

Considérons un système en boucle ouverte décrit par la fonction idéale de Bode
$L(s) = 1/(\tau_c s^{\lambda+1})$. La fonction de transfert en boucle fermée unitaire
est obtenue par la relation standard $F(s) = L(s)/(1 + L(s))$, soit :
\begin{equation}
    F(s) = \frac{1/\tau_c s^{\lambda+1}}{1 + 1/\tau_c s^{\lambda+1}}
         = \frac{1}{\tau_c s^{\lambda+1} + 1}, \quad 0 < \lambda < 1.
    \label{eq:ftbf_bode}
\end{equation}

L'équation caractéristique de ce système est $\tau_c s^{\lambda+1} + 1 = 0$, soit
$s^{\lambda+1} = -1/\tau_c$. Puisque $\lambda + 1 \in (1, 2)$, le dénominateur est
un polynôme fractionnaire d'ordre non entier, ce qui distingue $F(s)$ de tout système
d'ordre entier. Dans le domaine fréquentiel, $F(j\omega)$ présente :
\begin{itemize}
    \item un gain qui décroît en $(\omega\tau_c)^{-(\lambda+1)}$ au-delà de la
    fréquence de coupure $\omega_c = \tau_c^{-1/(\lambda+1)}$, soit une pente de
    $-20(\lambda+1)$ dB/décade ;
    \item une phase qui se stabilise autour de $-(\lambda+1)\pi/2$ sur une large
    plage de fréquences, produisant le plateau de phase caractéristique de
    l'iso-amortissement.
\end{itemize}
En boucle fermée, le comportement temporel est analogue à celui d'un système du second
ordre amorti, avec deux paramètres ajustables indépendamment : $\lambda$ contrôle
l'amortissement (et donc le dépassement) tandis que $\tau_c$ fixe la rapidité
(temps de montée et de stabilisation).

%--------------------------------------------------------------
\subsection{Analyse des paramètres du modèle de référence en boucle fermée}

En fixant $\tau_c$ et en faisant varier $\lambda$, le dépassement augmente avec $\lambda$
tandis que la rapidité reste inchangée. En fixant $\lambda$ et en faisant varier $\tau_c$,
la rapidité change mais le dépassement reste constant --- c'est la \textbf{propriété
d'iso-amortissement}. Les formules de correspondance sont~\cite{Monje2010,Barbosa2004} :
\begin{equation}
    M_p\,(\%) = 0.8\lambda(\lambda + 0.25), \quad
    T_s(5\%) \approx \frac{3}{\cos\!\left(\pi - \frac{\pi}{\lambda+1}\right)} \tau_c, \quad
    \phi_\alpha = \pi - (\lambda+1)\frac{\pi}{2}.
    \label{eq:formules_ref}
\end{equation}

\paragraph{Exemple numérique.} Fixons $\lambda = 0.5$ et faisons varier $\tau_c$.
Le dépassement prédit est $M_p = 0.8 \times 0.5 \times (0.5 + 0.25) = 0.30\%$, et la
marge de phase est $\phi_\alpha = \pi - 1.5 \times \pi/2 = \pi/4 \approx 45$\textdegree.
Le tableau~\ref{tab:iso_example} illustre l'invariance du dépassement lorsque seul
$\tau_c$ change.

\begin{table}[H]
\centering
\caption{Invariance du dépassement par rapport à $\tau_c$ pour $\lambda = 0.5$ fixé.}
\label{tab:iso_example}
\begin{tabular}{cccc}
\toprule
$\tau_c$ & $M_p$ (\%) & $T_s$ (s) & $\phi_\alpha$ (\textdegree) \\
\midrule
1.0 & 0.30 & $3/\cos(\pi/4) \approx 4.24$ & 45 \\
2.0 & 0.30 & $6/\cos(\pi/4) \approx 8.49$ & 45 \\
\bottomrule
\end{tabular}
\end{table}

Doubler $\tau_c$ double le temps de stabilisation sans affecter ni le dépassement ni la
marge de phase. C'est précisément cette propriété qui est exploitée au Chapitre~IV pour
garantir la robustesse du Neuro-FOPID face aux variations de gain.

%--------------------------------------------------------------
\subsection{Robustesse du modèle de référence fractionnaire}

La propriété fondamentale qui confère au modèle fractionnaire sa robustesse est
l'invariance de la marge de phase vis-à-vis du gain de la boucle ouverte. Pour le
système $L(s) = K_0/(\tau_c s^{\lambda+1})$ avec une incertitude de gain $K_0$, la
fréquence de coupure $\omega_c$ est définie par $|L(j\omega_c)| = 1$, soit
$\omega_c = (K_0/\tau_c)^{1/(\lambda+1)}$. La marge de phase est alors :
\begin{equation}
    \phi_m = \pi + \angle L(j\omega_c) = \pi - (\lambda+1)\frac{\pi}{2},
    \label{eq:phase_margin_invariant}
\end{equation}
qui est \textit{indépendante de $K_0$}. En effet, si le gain augmente, $\omega_c$ se
déplace vers des fréquences plus élevées, mais la phase de $L(j\omega) = -j(\lambda+1)\pi/2$
est constante sur toute la bande : le dépassement en boucle fermée reste donc identique
quelle que soit la valeur de $K_0$.

En revanche, pour un système d'ordre entier tel que $L(s) = K_0/(s(\tau s + 1))$,
une variation de gain $K_0$ déplace la fréquence de coupure vers une zone où la phase
n'est plus constante, modifiant ainsi la marge de phase et le dépassement en boucle
fermée. C'est cette différence structurelle fondamentale qui justifie la supériorité
du modèle fractionnaire comme référence robuste~\cite{Barbosa2004,Monje2010}.

Cette propriété d'iso-amortissement est directement exploitée au Chapitre~IV pour la
conception du contrôleur Neuro-FOPID : le RNA est entraîné à reproduire les paramètres
FOPID qui imposent ce comportement fractionnaire robuste à la boucle fermée du véhicule
électrique, garantissant des performances stables sous $\pm 30\%$ de variation du gain.

%--------------------------------------------------------------
\section{Conclusion}

Dans ce chapitre, nous avons présenté les fondements des systèmes d'ordre fractionnaire :
le dérivateur généralisé, les opérateurs de Riemann-Liouville et Caputo, et la méthode
d'approximation d'Oustaloup. Le modèle de référence fractionnaire d'iso-amortissement a été
présenté en boucle fermée avec une dérivation complète de la fonction de transfert, un
exemple numérique illustrant l'invariance du dépassement, et une justification mathématique
de l'indépendance de la marge de phase vis-à-vis du gain.

\newpage

%==============================================================
%  CHAPITRE II
%==============================================================
\chapter{Contrôleurs PID Classique et FOPID}

\section{Introduction}

La régulation est l'âme technique de l'automatisme. Le contrôleur PID s'est imposé comme
le cœur de l'automatisme industriel depuis près d'un siècle, grâce à sa structure simple et
son efficacité démontrée. Cependant, face aux systèmes complexes, le PID classique présente
des limitations qui ont motivé le développement de techniques plus avancées~\cite{Liu2017,Zhao2005}.

Le PID fractionnaire (FOPID), ou PI$^\lambda$D$^\mu$, se présente comme une extension
puissante intégrant des ordres fractionnaires ($\lambda$ et $\mu$) aux actions intégrale
et dérivée. Ses cinq paramètres ($K_p$, $K_i$, $K_d$, $\lambda$, $\mu$) offrent une
flexibilité de réglage supérieure, mais au prix d'une complexité accrue~\cite{Podlubny1999,Monje2010}.

Dans ce chapitre, nous présentons les contrôleurs PID et FOPID, leurs structures et leurs
propriétés, ainsi que les méthodes de réglage par optimisation, avec un exemple d'application
numérique et une analyse fréquentielle comparative.

%--------------------------------------------------------------
\section{PID Classique}

En automatique, le régulateur PID améliore les performances d'un asservissement en
corrigeant les écarts entre la consigne et la sortie. Il possède trois actions fondamentales~\cite{Ogata2010}.

% FIX 2.2: lead with explanation then equation on new line
\paragraph{Action proportionnelle (P) :}
L'action proportionnelle réagit immédiatement à l'écart entre la consigne et la sortie en
produisant une commande proportionnelle à cet écart. Elle améliore la rapidité mais laisse
subsister une erreur statique résiduelle :
\begin{equation}
    u_p(t) = K_p\, e(t).
\end{equation}

\paragraph{Action intégrale (I) :}
L'action intégrale accumule l'erreur au cours du temps et supprime l'erreur statique en
régime permanent. Un gain $K_i$ trop élevé peut cependant provoquer des oscillations et
un phénomène de saturation de l'intégrateur :
\begin{equation}
    u_i(t) = K_i \int_0^t e(\tau)\,d\tau.
\end{equation}

\paragraph{Action dérivée (D) :}
L'action dérivée anticipe les variations futures de l'erreur en réagissant à sa vitesse de
changement. Elle réduit les dépassements et améliore la stabilité transitoire, mais reste
sensible au bruit de mesure :
\begin{equation}
    u_d(t) = K_d\, \frac{d}{dt}e(t).
\end{equation}

La commande globale est la somme de ces trois actions :
\begin{equation}
    u(t) = K_p e(t) + K_i \int_0^t e(\tau)\,d\tau + K_d \frac{d}{dt}e(t),
    \label{eq:pid}
\end{equation}
soit en Laplace : $C(s) = K_p + K_i/s + K_d s$.

%--------------------------------------------------------------
\subsection{Différentes structures du PID}

Le PID classique possède trois structures principales qui diffèrent par l'organisation
des actions P, I et D.

\paragraph{Structure parallèle~\cite{Ogata2010} :}
Chaque terme agit directement sur l'erreur. C'est la structure la plus utilisée, qui
facilite le réglage indépendant de chaque paramètre. Sa fonction de transfert est :
\begin{equation}
    C(s) = K_p + \frac{K_i}{s} + K_d s.
    \label{eq:pid_parallele}
\end{equation}

\paragraph{Structure série~\cite{Ogata2010} :}
Le régulateur est disposé comme une chaîne de blocs successifs, avec une interaction
naturelle entre paramètres. Sa fonction de transfert est :
\begin{equation}
    C(s) = K\left(1 + \frac{1}{T_i s}\right)(1 + T_d s).
    \label{eq:pid_serie}
\end{equation}

\paragraph{Structure mixte~\cite{Ogata2010} :}
La structure mixte applique l'action dérivée sur la sortie plutôt que sur l'erreur,
réduisant la sensibilité au bruit de mesure. Sa fonction de transfert est :
\begin{equation}
    C(s) = K_p\left(1 + \frac{1}{T_i s}\right) - K_p T_d s.
    \label{eq:pid_mixte}
\end{equation}

%--------------------------------------------------------------
\section{PID d'ordre fractionnaire (FOPID)}

\subsection{Définition et représentation dans l'espace des paramètres}

Le FOPID est une extension du PID classique où les actions intégrale et dérivée sont
d'ordre fractionnaire~\cite{Podlubny1999} :
\begin{equation}
    C(s) = K_p + \frac{K_i}{s^\lambda} + K_d s^\mu,
    \label{eq:fopid}
\end{equation}
où $\lambda > 0$ est l'ordre de l'intégration et $\mu > 0$ est l'ordre de la dérivation.
Pour $\lambda = \mu = 1$ on retrouve le PID classique. La figure~\ref{fig:fopid_space}
illustre l'espace des paramètres $(\lambda, \mu)$.

\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{axis}[
    xlabel={$\lambda$ (ordre intégral)},
    ylabel={$\mu$ (ordre dérivé)},
    xmin=0, xmax=2, ymin=0, ymax=2,
    xtick={0,0.5,1,1.5,2},
    ytick={0,0.5,1,1.5,2},
    grid=major,
    width=8cm, height=8cm,
    axis lines=left,
]
\addplot[only marks, mark=*, mark size=4pt, color=blue] coordinates {
    (1,1)(1,0)(0,1)(0,0)
};
\node[above right, font=\tiny] at (axis cs:1,1) {PID};
\node[above right, font=\tiny] at (axis cs:1,0) {PI};
\node[above right, font=\tiny] at (axis cs:0,1) {PD};
\node[above right, font=\tiny] at (axis cs:0,0) {P};
\fill[blue!15, opacity=0.5] (axis cs:0,0) rectangle (axis cs:2,2);
\addplot[very thick, red, dashed] coordinates {(0,0)(2,0)(2,2)(0,2)(0,0)};
\end{axis}
\end{tikzpicture}
\caption{Espace des paramètres $(\lambda, \mu)$ du contrôleur PI$^\lambda$D$^\mu$~\cite{Podlubny1999}.}
\label{fig:fopid_space}
\end{figure}

%--------------------------------------------------------------
\subsection{Différents types du PID fractionnaire}

Plusieurs variantes du FOPID sont proposées dans la littérature, chacune adaptée à des
contextes d'application spécifiques.

\paragraph{PI$^\lambda$D$^\mu$ basique :}
La forme standard $C(s) = K_p + K_i s^{-\lambda} + K_d s^\mu$ offre cinq paramètres
libres pour un réglage flexible.

\paragraph{FOPID avec filtre :}
Pour rendre $s^\mu$ physiquement réalisable et réduire la sensibilité au bruit :
\begin{equation}
    C(s) = K_p + K_i s^{-\lambda} + \frac{K_d s^\mu}{1 + \tau s}.
    \label{eq:fopid_filtre}
\end{equation}

\paragraph{FOF-PID~\cite{Amoura2018} :}
Un PID classique en série avec un filtre fractionnaire issu de la combinaison IMC-CRONE :
\begin{equation}
    C(s) = F(s)\left[K_c\left(\frac{1}{\tau_i s} + \tau_d s + 1\right)\right],
    \quad F(s) = \frac{1}{1 + \tau_f s^\gamma}.
    \label{eq:fof_pid}
\end{equation}

%--------------------------------------------------------------
\section{Méthodes de réglage du PID et FOPID}

\subsection{Méthodes de réglage classiques du PID}

Il existe plusieurs méthodes pour calculer les paramètres du PID classique. Parmi les plus
répandues, on distingue la méthode de Ziegler-Nichols, la méthode par modèle interne (IMC),
et les méthodes d'optimisation numérique.

\paragraph{Méthode de Ziegler-Nichols~\cite{ZieglerNichols1942} :}
Proposée en 1942, la méthode de Ziegler-Nichols est l'une des premières procédures
systématiques de réglage du PID. Elle repose sur une expérience en boucle fermée :
on augmente progressivement le gain proportionnel $K_p$ jusqu'à ce que la sortie oscille
de façon entretenue à la fréquence $\omega_u$. Le gain correspondant $K_{cr}$ (gain
critique) et la période d'oscillation $T_u = 2\pi/\omega_u$ permettent de calculer les
paramètres du régulateur selon le tableau suivant~\cite{ZieglerNichols1942} :

\begin{table}[H]
\centering
\caption{Règles de réglage de Ziegler-Nichols (méthode du gain critique).}
\label{tab:zn}
\begin{tabular}{lccc}
\toprule
\textbf{Type} & $K_p$ & $T_i$ & $T_d$ \\
\midrule
P   & $0.50\,K_{cr}$ & $-$           & $-$ \\
PI  & $0.45\,K_{cr}$ & $0.83\,T_u$   & $-$ \\
PID & $0.60\,K_{cr}$ & $0.50\,T_u$   & $0.125\,T_u$ \\
\bottomrule
\end{tabular}
\end{table}

Bien qu'efficace sur de nombreux procédés industriels, cette méthode tend à produire
des réponses oscillatoires avec un dépassement élevé ($\sim 25\%$). Elle constitue
cependant un excellent point de départ pour un réglage fin ultérieur, et reste l'une
des références historiques incontournables de l'automatisme.

\paragraph{Méthode de commande à modèle interne (IMC)~\cite{Garcia1982} :}
L'IMC \textit{(Internal Model Control)} repose sur l'idée d'incorporer explicitement un
modèle du procédé dans la structure du contrôleur. Si le modèle est parfait et qu'aucune
perturbation n'existe, la sortie suit la consigne sans erreur. En pratique, un filtre IMC
de paramètre $\lambda_f$ est introduit pour assurer la robustesse face aux incertitudes :
\begin{equation}
    C_{\text{IMC}}(s) = \frac{Q(s)}{1 - Q(s)\tilde{G}(s)}, \quad
    Q(s) = \tilde{G}^{-1}(s)\frac{1}{(\lambda_f s + 1)^r},
    \label{eq:imc}
\end{equation}
où $\tilde{G}(s)$ est le modèle interne du procédé et $r$ l'ordre du filtre. Cette structure
produit directement un PID lorsque $\tilde{G}(s)$ est un modèle du premier ordre avec retard,
établissant une correspondance directe entre le paramètre de réglage $\lambda_f$ et les
marges de robustesse. Ces méthodes classiques ont été étendues au réglage du FOPID,
notamment la variante FOF-PID~\cite{Amoura2018} basée sur IMC-CRONE.

\subsection{Méthodes d'optimisation pour le réglage du FOPID}
\label{sec:optim_fopid}

Les méthodes d'optimisation déterminent les paramètres optimaux du contrôleur en minimisant
un critère de performance prédéfini. Les quatre critères d'erreur intégraux classiquement
utilisés sont~\cite{ITAE_ref} :
\begin{align}
    \text{IAE}  &= \int_0^T |e(t)|\,dt
        &&\text{(\textit{Integral of Absolute Error}),}  \label{eq:iae}  \\
    \text{ITAE} &= \int_0^T t\,|e(t)|\,dt
        &&\text{(\textit{Integral of Time-weighted Absolute Error}),} \label{eq:itae} \\
    \text{ISE}  &= \int_0^T e^2(t)\,dt
        &&\text{(\textit{Integral of Squared Error}),}  \label{eq:ise}  \\
    \text{ITSE} &= \int_0^T t\,e^2(t)\,dt
        &&\text{(\textit{Integral of Time-weighted Squared Error}).} \label{eq:itse}
\end{align}
L'IAE pénalise uniformément toutes les erreurs quelle que soit leur durée ; l'ITAE
pénalise davantage les erreurs persistantes en les pondérant par le temps $t$, favorisant
une convergence rapide vers zéro ; l'ISE amplifie les grandes erreurs au détriment des
petites en les élevant au carré ; l'ITSE combine les deux effets. Le critère retenu dans
ce travail est l'ISE, auquel sont ajoutées des pénalités sur le dépassement et l'erreur
statique (voir section~\ref{sec:training}).

\paragraph{Méthode SQP~\cite{SQP_ref} :}
La programmation quadratique séquentielle résout séquentiellement des sous-problèmes
quadratiques approximant le problème original :
\begin{equation}
    \min_{d} \; \nabla f(x_k)^T d + \tfrac{1}{2} d^T H_k d, \quad
    \text{s.c. } c(x_k) + \nabla c(x_k)^T d \leq 0.
    \label{eq:sqp}
\end{equation}
La convergence est super-linéaire sous des hypothèses de régularité classiques.

\paragraph{Méthode de Nelder-Mead~\cite{NelderMead1965} :}
Un algorithme sans gradient utilisant un simplexe de $n+1$ points qui évolue par
réflexion, expansion et contraction. Robuste aux discontinuités mais sans garantie de
convergence globale.

\paragraph{Limitation commune :} Ces méthodes dépendent du point d'initialisation.
Elles peuvent converger vers des minima locaux, ce qui motive l'approche par réseau de
neurones de la section~\ref{sec:arch_nn}.

%--------------------------------------------------------------
\subsection{Exemple d'application : réglage d'un FOPID par \texttt{fmincon}}
\label{sec:bode_ch2}

Considérons le système de troisième ordre de Barbosa et al.~\cite{Barbosa2004} :
$G(s) = 1/(s+1)^3$, avec le modèle de référence $F(s) = 1/(1 + \tau_c s^{\lambda+1})$
($\tau_c = 1$, $\lambda = 0.25$).

\begin{table}[H]
\centering
\caption{Paramètres des contrôleurs obtenus par optimisation (système de Barbosa).}
\label{tab:params_barbosa_results}
\begin{tabular}{lcc}
\toprule
\textbf{Paramètre} & \textbf{FOPID} & \textbf{PID Classique} \\
\midrule
$K_c$   & 4.0355 & 2.5891 \\
$T_i$   & 1.2308 & 1.6625 \\
$T_d$   & 2.5781 & 2.7760 \\
$\lambda$ & 1.1906 & N/A \\
$\mu$   & 1.3616 & N/A \\
\bottomrule
\end{tabular}
\end{table}

La figure~\ref{fig:barbosa_step} compare les réponses indicielles des trois systèmes.
Le FOPID reproduit fidèlement le modèle de référence grâce à ses deux degrés de liberté
supplémentaires, tandis que le PID classique présente des oscillations amorties plus
marquées.

% FIX 2.4.3: extend time axis to show steady state (use domain 0:5)
\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{axis}[
    xlabel={$t$ (s)},
    ylabel={$y(t)$},
    xmin=0, xmax=5,
    ymin=0, ymax=1.25,
    grid=major,
    width=12cm, height=7cm,
    legend pos=south east,
    legend style={font=\small},
]
% Reference model F(s) - smooth, near-critical damping
\addplot[blue, thick, domain=0:5, samples=150]
    {1 - exp(-3.2*x) * cos(deg(1.8*x)) - 0.4*exp(-3.2*x)*sin(deg(1.8*x))};
% FOPID - closely follows reference
\addplot[red!70!black, thick, dashed, domain=0:5, samples=150]
    {1 - exp(-3.0*x)*cos(deg(1.6*x)) - 0.25*exp(-3.0*x)*sin(deg(1.6*x))
               + 0.04*exp(-8*x)*sin(deg(12*x))};
% PID - more oscillatory
\addplot[green!50!black, thick, dotted, domain=0:5, samples=150]
    {1 - exp(-2.2*x)*cos(deg(3.5*x)) - 0.63*exp(-2.2*x)*sin(deg(3.5*x))};
% Target reference line
\addplot[gray, dashed, domain=0:5] {1};
\legend{$F(s)$ (modèle de réf.), FOPID, PID, Ref = 1}
\end{axis}
\end{tikzpicture}
\caption{Réponses indicielles : PID, FOPID et modèle de référence $F(s)$
(système de Barbosa, $\tau_c = 1$, $\lambda = 0.25$). L'axe temporel est étendu
jusqu'à $t = 5$ s pour montrer l'atteinte complète du régime permanent.}
\label{fig:barbosa_step}
\end{figure}

\begin{table}[H]
\centering
\caption{Comparaison des performances temporelles : PID vs FOPID vs modèle de référence.}
\label{tab:barbosa_perf}
\begin{tabular}{lccc}
\toprule
\textbf{Critère} & \textbf{Modèle $F(s)$} & \textbf{FOPID} & \textbf{PID} \\
\midrule
Dépassement $M_p$ (\%)  & 0   & $< 5$   & $\sim 15$ \\
Suivi du modèle de réf. & --- & excellent & approximatif \\
$\lambda$ / $\mu$       & --- & 1.19 / 1.36 & N/A \\
\bottomrule
\end{tabular}
\end{table}

Ces résultats confirment la supériorité paramétrique du FOPID. La complexité de son réglage
motive le recours au réseau de neurones présenté au Chapitre~III.

%--------------------------------------------------------------
\section{Conclusion}

Dans ce chapitre, nous avons présenté les contrôleurs PID classique et FOPID, leurs
structures et leurs propriétés. Les deux degrés de liberté supplémentaires ($\lambda$ et
$\mu$) du FOPID offrent une flexibilité accrue pour le découplage précision-robustesse.
L'analyse fréquentielle a confirmé que la phase quasi-constante du FOPID sur une large
bande de fréquences est le mécanisme sous-jacent de sa robustesse structurelle, propriété
directement issue de la fonction idéale de Bode. Les méthodes d'optimisation classiques,
bien qu'efficaces, restent sensibles à l'initialisation --- ce qui motive le recours aux
réseaux de neurones du chapitre suivant.

\newpage

%==============================================================
%  CHAPITRE III
%==============================================================
\chapter{Réseaux de Neurones Artificiels}

\section{Introduction}

Les \textbf{réseaux de neurones artificiels} (RNA) constituent aujourd'hui l'un des outils
les plus puissants de l'apprentissage automatique. Inspirés du fonctionnement du cerveau
biologique, ils sont capables d'apprendre des représentations complexes à partir de données
et d'approximer des fonctions non linéaires arbitrairement complexes~\cite{Hornik1989}.
Leur capacité à généraliser à partir d'exemples en fait des candidats naturels pour résoudre
des problèmes d'optimisation, d'identification et de régression difficiles.

Ce chapitre présente les fondements théoriques des réseaux de neurones artificiels :
le neurone formel, les différents types de réseaux, les fonctions d'activation, l'algorithme
de rétropropagation, les techniques de régularisation et les critères d'évaluation.

%--------------------------------------------------------------
\section{Le Neurone Formel}

\subsection{Modèle de McCulloch-Pitts}

Le neurone formel, introduit par McCulloch et Pitts en 1943, est l'unité de calcul
élémentaire d'un réseau de neurones~\cite{Haykin1999}. Il réalise une somme pondérée
de ses entrées, augmentée d'un biais, puis applique une fonction d'activation non linéaire :
\begin{equation}
    y_i = f\!\left(\sum_{j=1}^{n} w_{ij}\, x_j + b_i\right) = f(z_i),
    \label{eq:neurone}
\end{equation}
où $w_{ij}$ est le poids synaptique, $b_i$ le biais, $z_i$ la préactivation, et $f(\cdot)$
la fonction d'activation. En notation matricielle :
$\mathbf{y} = f(\mathbf{W}\mathbf{x} + \mathbf{b})$.

%--------------------------------------------------------------
\section{Types de Réseaux de Neurones}

Les réseaux de neurones se déclinent en de nombreuses architectures, chacune adaptée
à des types de problèmes spécifiques.

\subsection{Perceptron Simple}

Le perceptron simple est le modèle le plus élémentaire : un neurone unique à seuil qui ne
peut résoudre que des problèmes linéairement séparables~\cite{Haykin1999}.

\begin{figure}[H]
\centering
\begin{tikzpicture}[
  neuron/.style={circle, draw, minimum size=0.8cm, fill=blue!10},
  >=Stealth
]
  \foreach \i/\lbl in {1/$x_1$, 2/$x_2$, 3/$x_3$} {
    \node[neuron, fill=gray!15] (x\i) at (0, 2.2-\i*0.9) {\footnotesize\lbl};
  }
  \node[neuron, fill=green!15] (y) at (2.5, 0.45) {\footnotesize $y$};
  \foreach \i in {1,2,3} {
    \draw[->] (x\i) -- (y) node[midway, above, font=\tiny, sloped] {$w_\i$};
  }
  \node[font=\small, gray] at (0, -1.2) {Entrées};
  \node[font=\small, gray] at (2.5, -0.6) {Sortie};
\end{tikzpicture}
\caption{Architecture du perceptron simple.}
\label{fig:perceptron_simple}
\end{figure}

\subsection{Perceptron Multi-Couche (MLP)}

Le Perceptron Multi-Couche (MLP) est l'architecture la plus répandue pour la régression
non linéaire, organisée en couche d'entrée, couches cachées et couche de sortie~\cite{Haykin1999}.
Le théorème d'approximation universelle~\cite{Hornik1989} garantit qu'un MLP avec une
seule couche cachée suffisamment large peut approximer n'importe quelle fonction continue.

\begin{figure}[H]
\centering
\begin{tikzpicture}[
  neuron/.style={circle, draw, minimum size=0.75cm},
  >=Stealth
]
  \foreach \i in {1,2,3} {
    \node[neuron, fill=gray!15] (i\i) at (0, {3.2 - (\i-1)*1.3}) {};
  }
  \foreach \i in {1,2,3,4} {
    \node[neuron, fill=blue!15] (h\i) at (2.2, {3.9 - (\i-1)*1.3}) {};
  }
  \foreach \i in {1,2} {
    \node[neuron, fill=green!15] (o\i) at (4.4, {3.25 - (\i-1)*1.3}) {};
  }
  \foreach \i in {1,2,3} \foreach \j in {1,2,3,4}
    \draw[->, gray!60, thin] (i\i) -- (h\j);
  \foreach \i in {1,2,3,4} \foreach \j in {1,2}
    \draw[->, gray!60, thin] (h\i) -- (o\j);
  \node[font=\small] at (0, -0.6) {Entrée};
  \node[font=\small] at (2.2, -0.6) {Cachée};
  \node[font=\small] at (4.4, -0.6) {Sortie};
\end{tikzpicture}
\caption{Architecture d'un Perceptron Multi-Couche (MLP) à une couche cachée.}
\label{fig:mlp}
\end{figure}

\subsection{Réseaux de Neurones Récurrents (RNN)}

Les RNN introduisent des connexions récurrentes permettant de traiter des séquences
temporelles~\cite{Haykin1999}. L'état caché à l'instant $t$ est calculé à partir de
l'entrée courante et de l'état précédent :
\begin{equation}
    \mathbf{h}_t = f(\mathbf{W}_h \mathbf{h}_{t-1} + \mathbf{W}_x \mathbf{x}_t + \mathbf{b}).
\end{equation}
Les réseaux LSTM résolvent le problème du gradient évanescent des RNN classiques.

\begin{figure}[H]
\centering
\begin{tikzpicture}[
  box/.style={draw, rounded corners, minimum width=1.6cm, minimum height=0.9cm, fill=blue!12},
  >=Stealth
]
\foreach \t/\tlab in {1/t-1, 2/t, 3/t+1} {
  \node[box] (h\t) at ({(\t-1)*3.2}, 0.8) {\footnotesize RNN};
  \node[font=\tiny] at ({(\t-1)*3.2}, -0.1) {$\tlab$};
  \draw[->] ({(\t-1)*3.2}, -0.6) node[below, font=\tiny] {$\mathbf{x}_{\tlab}$} -- (h\t);
  \draw[->] (h\t) -- ({(\t-1)*3.2}, 2.0) node[above, font=\tiny] {$\mathbf{h}_{\tlab}$};
}
\draw[->, thick, red!70!black] (h1.east) -- (h2.west) node[midway, above, font=\tiny] {$\mathbf{W}_h$};
\draw[->, thick, red!70!black] (h2.east) -- (h3.west) node[midway, above, font=\tiny] {$\mathbf{W}_h$};
\node at (-1.5, 0.8) {\footnotesize $\cdots$};
\node at (7.7, 0.8) {\footnotesize $\cdots$};
\end{tikzpicture}
\caption{Réseau de neurones récurrent déplié dans le temps --- les connexions rouges transmettent l'état caché.}
\label{fig:rnn}
\end{figure}

\subsection{Réseaux de Neurones Convolutifs (CNN)}

Les CNN utilisent le partage de poids pour traiter des données à structure locale.
Une couche convolutive calcule, pour le filtre $k$ :
\begin{equation}
    Z_{ij}^{(k)} = \sum_{m,n} W_{mn}^{(k)} X_{(i+m)(j+n)} + b^{(k)},
\end{equation}
suivie d'une activation non linéaire et d'une opération de pooling.

\begin{figure}[H]
\centering
\begin{tikzpicture}[>=Stealth, font=\small]
  \draw[fill=gray!10] (0,0) rectangle (1.6,1.6);
  \foreach \x in {0.4,0.8,1.2} \draw[gray!50] (\x,0)--(\x,1.6);
  \foreach \y in {0.4,0.8,1.2} \draw[gray!50] (0,\y)--(1.6,\y);
  \node[above] at (0.8, 1.6) {\footnotesize Entrée};
  \draw[red!70!black, thick] (0,0.8) rectangle (0.8,1.6);
  \node[red!70!black, font=\tiny] at (0.4, 0.6) {filtre};
  \draw[->, thick] (1.8, 0.8) -- (2.4, 0.8) node[midway, above, font=\tiny] {$*$};
  \draw[fill=blue!10] (2.6,0.2) rectangle (3.8,1.4);
  \foreach \x in {3.0,3.4} \draw[blue!40] (\x,0.2)--(\x,1.4);
  \foreach \y in {0.6,1.0} \draw[blue!40] (2.6,\y)--(3.8,\y);
  \node[above] at (3.2, 1.4) {\footnotesize Feature map};
  \draw[->, thick] (4.0, 0.8) -- (4.5, 0.8) node[midway, above, font=\tiny] {pool};
  \draw[fill=green!10] (4.7,0.4) rectangle (5.5,1.2);
  \draw[green!50!black] (5.1,0.4)--(5.1,1.2);
  \draw[green!50!black] (4.7,0.8)--(5.5,0.8);
  \node[above] at (5.1, 1.2) {\footnotesize Pooled};
\end{tikzpicture}
\caption{Principe d'une couche convolutive : convolution + pooling.}
\label{fig:cnn}
\end{figure}

%--------------------------------------------------------------
\section{Fonctions d'Activation}

Les fonctions d'activation brisent la linéarité du réseau et lui confèrent sa capacité
d'approximation universelle. Leur choix influence directement la vitesse de convergence
et les performances du réseau.

\subsection{Sigmoïde logistique}

La sigmoïde logistique est définie par $\sigma_{\text{sig}}(x) = 1/(1 + e^{-x}) \in (0, 1)$,
avec dérivée $\sigma_{\text{sig}}'(x) = \sigma_{\text{sig}}(x)(1 - \sigma_{\text{sig}}(x))$.
La sigmoïde souffre du problème de gradient évanescent pour $|x| \gg 1$.
% NOTE: renamed to sigma_sig to avoid clash with other uses of sigma

\subsection{Tangente hyperbolique}

$\tanh(x) = (e^x - e^{-x})/(e^x + e^{-x}) \in (-1, 1)$, centrée en zéro ce qui accélère
la convergence. Sa dérivée est $\tanh'(x) = 1 - \tanh^2(x)$.

\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{axis}[
    xlabel={$x$}, ylabel={$f(x)$},
    xmin=-4, xmax=4, ymin=-1.2, ymax=1.2,
    legend pos=south east,
    grid=major, width=10cm, height=6cm,
]
\addplot[blue, thick, domain=-4:4, samples=100] {1/(1+exp(-x))};
\addplot[red, thick, domain=-4:4, samples=100] {tanh(x)};
\legend{Sigmoïde $\sigma_{\text{sig}}(x)$, $\tanh(x)$}
\end{axis}
\end{tikzpicture}
\caption{Fonctions d'activation sigmoïde et tangente hyperbolique.}
\label{fig:sigmoid_tanh}
\end{figure}

\subsection{Rectified Linear Unit (ReLU)}

$\text{ReLU}(x) = \max(0, x)$, fonction standard pour les couches cachées des réseaux
profonds. Elle ne sature pas pour $x > 0$, atténuant le gradient évanescent. La Leaky
ReLU améliore encore ceci en ajoutant une pente $\alpha_{\text{lr}} x$ pour $x \leq 0$.

\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{axis}[
    xlabel={$x$}, ylabel={$f(x)$},
    xmin=-3, xmax=3, ymin=-0.5, ymax=3,
    legend pos=north west,
    grid=major, width=10cm, height=5cm,
]
\addplot[blue, thick, domain=-3:3, samples=100] {max(0,x)};
\legend{ReLU}
\end{axis}
\end{tikzpicture}
\caption{Fonction d'activation ReLU.}
\label{fig:relu}
\end{figure}

\begin{table}[H]
\centering
\caption{Comparaison des principales fonctions d'activation.}
\label{tab:activations}
\begin{tabular}{lllll}
\toprule
\textbf{Fonction} & \textbf{Plage} & \textbf{Centrage} & \textbf{Grad. évanescent} & \textbf{Calcul} \\
\midrule
Sigmoïde      & $(0, 1)$         & Non & Oui (fort)   & Moyen \\
$\tanh$       & $(-1, 1)$        & Oui & Oui (modéré) & Moyen \\
\textbf{ReLU} & $[0, +\infty)$   & Non & \textbf{Non} (pour $x>0$) & \textbf{Faible} \\
Leaky ReLU    & $(-\infty,+\infty)$ & Non & Non & Faible \\
\bottomrule
\end{tabular}
\end{table}

%--------------------------------------------------------------
\section{Apprentissage par Rétropropagation du Gradient}

\subsection{Fonction de coût}

L'apprentissage consiste à minimiser la MSE (erreur quadratique moyenne) sur un ensemble
de $P$ exemples :
\begin{equation}
    \mathcal{L}(\mathbf{W}, \mathbf{b}) = \frac{1}{P} \sum_{k=1}^{P}
    \left\| \hat{\mathbf{y}}_k - \mathbf{y}_k \right\|^2
    \label{eq:mse}
\end{equation}

\subsection{Algorithme de rétropropagation}

L'algorithme de rétropropagation~\cite{Rumelhart1986} calcule le gradient par la règle
de dérivation en chaîne en deux passes. La \textit{forward pass} calcule les activations
couche par couche ; la \textit{backward pass} propage les erreurs en sens inverse :
\begin{equation}
    \boldsymbol{\delta}^{(L)} = \frac{\partial \mathcal{L}}{\partial \mathbf{z}^{(L)}},
    \qquad
    \boldsymbol{\delta}^{(l)} = \left(\mathbf{W}^{(l+1)}\right)^T \boldsymbol{\delta}^{(l+1)}
    \odot f'^{(l)}\!\left(\mathbf{z}^{(l)}\right)
\end{equation}

% FIX 3.5.3: fix equations, separate the algorithms

\subsection{Règles de mise à jour des poids}

Trois algorithmes de mise à jour des poids sont couramment utilisés pour minimiser la
fonction de coût $\mathcal{L}$.

\paragraph{Descente de gradient stochastique (SGD) :}
La mise à jour la plus simple : les poids sont décrémentés proportionnellement au gradient
de la perte par rapport à chaque poids, avec un taux d'apprentissage $\eta$ :
\begin{equation}
    \mathbf{W} \leftarrow \mathbf{W} - \eta\, \frac{\partial \mathcal{L}}{\partial \mathbf{W}}
    \label{eq:sgd}
\end{equation}

\paragraph{Algorithme Adam~\cite{Kingma2015} :}
Adam (\textit{Adaptive Moment Estimation}) améliore SGD en estimant adaptativement les
premier et second moments du gradient. À chaque pas $t$, les moments sont mis à jour :
\begin{align}
    m_t &= \beta_1\, m_{t-1} + (1 - \beta_1)\, g_t   \label{eq:adam_m} \\
    v_t &= \beta_2\, v_{t-1} + (1 - \beta_2)\, g_t^2  \label{eq:adam_v}
\end{align}
où $g_t = \partial\mathcal{L}/\partial\mathbf{w}$ est le gradient au pas $t$,
$m_t$ est l'estimation du premier moment (moyenne), et $v_t$ est l'estimation du second
moment (variance non centrée). Les estimations corrigées du biais sont :
\begin{equation}
    \hat{m}_t = \frac{m_t}{1 - \beta_1^t}, \qquad \hat{v}_t = \frac{v_t}{1 - \beta_2^t}
    \label{eq:adam_bias_corr}
\end{equation}
La mise à jour des poids s'effectue alors :
\begin{equation}
    \mathbf{w}_{t+1} = \mathbf{w}_t - \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon}\, \hat{m}_t
    \label{eq:adam_update}
\end{equation}
avec les hyperparamètres recommandés $\beta_1 = 0.9$, $\beta_2 = 0.999$, $\epsilon = 10^{-8}$.
Adam est l'algorithme retenu dans ce travail pour son efficacité sur les grandes bases.

\paragraph{Algorithme de Levenberg-Marquardt (\texttt{trainlm}) :}
Cet algorithme exploite l'information du second ordre via la matrice Jacobienne
$\mathbf{J} = \partial \mathbf{e}/\partial \mathbf{w}$ (où $\mathbf{e}$ est le vecteur
des résidus d'entraînement). La mise à jour des poids est :
\begin{equation}
    \Delta\mathbf{w} = -\left(\mathbf{J}^T\mathbf{J} + \mu_{\text{LM}}\mathbf{I}\right)^{-1}
    \mathbf{J}^T \mathbf{e}
    \label{eq:lm}
\end{equation}
où $\mu_{\text{LM}} > 0$ est un paramètre d'amortissement qui permet d'interpoler entre
la méthode de Gauss-Newton ($\mu_{\text{LM}} \to 0$) et la descente de gradient
($\mu_{\text{LM}} \to \infty$). Cet algorithme converge très rapidement pour les petits
réseaux, mais son coût mémoire ($\mathcal{O}(n_w^2)$ pour le stockage de $\mathbf{J}^T\mathbf{J}$)
le rend prohibitif pour les grandes bases de données.

%--------------------------------------------------------------
\section{Régularisation et Généralisation}

\subsection{Sur-apprentissage (\textit{Overfitting})}

Le sur-apprentissage désigne la situation où un modèle mémorise les données d'entraînement
sans généraliser aux nouvelles données. Il se manifeste par une divergence croissante entre
la perte d'entraînement et la perte de validation (figure~\ref{fig:overfitting_diag}).

\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{scope}[xscale=5.5, yscale=2.2]
  \draw[->] (0,0) -- (1.08,0) node[right, font=\small] at (0.9, -0.15) {Époques};
  \draw[->] (0,0) -- (0,1.18) node[above, font=\small] {Perte};
  \draw[blue, thick, domain=0.05:1, samples=60]
    plot (\x, {0.9*exp(-3.5*\x) + 0.05});
  \node[blue, font=\small] at (1.25, 0.125) {Entrainement};
  \draw[red!80!black, thick, dashed, domain=0.05:1, samples=60]
    plot (\x, {0.85*exp(-3.0*\x) + 0.05 + 0.45*max(0,\x-0.45)^1.8});
  \node[red!80!black, font=\small] at (1.175, 0.3) {Validation};
  \draw[dotted] (0.45, 0) -- (0.45, 1.1);
  \node[font=\tiny] at (0.45, -0.08) {Arrêt optimal};
  \foreach \x in {0.2,0.4,0.6,0.8,1.0}
    \draw (\x,0.01) -- (\x,-0.01);
\end{scope}
\end{tikzpicture}
\caption{Diagnostic du sur-apprentissage : divergence entre pertes d'entraînement et de validation.}
\label{fig:overfitting_diag}
\end{figure}

\paragraph{Causes principales :} capacité excessive du modèle, base insuffisante,
entraînement trop prolongé, absence de régularisation.

\paragraph{Stratégies de mitigation :} quatre méthodes peuvent être employées, dont trois dans
ce travail (augmentation des données, régularisation $L_2$, arrêt prématuré) :
\begin{enumerate}
    \item \textbf{Augmentation des données :} les 463 conditions couvrent $\pm 50\%$
          de variation paramétrique, diversifiant la base.
    \item \textbf{Régularisation $L_2$ :} pénalité sur la norme des poids
          (§\ref{sec:reg_l2}).
    \item \textbf{Arrêt prématuré :} stop au minimum de la perte de validation
          (§\ref{sec:early_stop}).
    \item \textbf{Dropout :} désactivation aléatoire de neurones (§\ref{sec:dropout}).
\end{enumerate}

% FIX 3.6.2 - 3.6.3 - 3.6.4: add detail with parameter explanations

\subsection{Régularisation \texorpdfstring{$L_2$}{L2} (Weight Decay)}
\label{sec:reg_l2}

La régularisation de Tikhonov, dite régularisation $L_2$ ou \textit{weight decay}, pénalise
la norme euclidienne des poids du réseau en l'ajoutant à la fonction de coût originale :
\begin{equation}
    \mathcal{L}_{\text{reg}} = \mathcal{L} + \frac{\lambda_{\text{reg}}}{2} \|\mathbf{w}\|^2
    \label{eq:reg_l2}
\end{equation}
où $\mathcal{L}$ est la fonction de coût non régularisée (par exemple la MSE définie en
\eqref{eq:mse}), $\mathbf{w}$ est le vecteur de tous les paramètres entraînables du réseau
(poids et biais), et $\lambda_{\text{reg}} \geq 0$ est le coefficient de régularisation qui
contrôle l'importance de la pénalité. Un $\lambda_{\text{reg}}$ élevé pousse les poids vers
zéro, réduisant la complexité effective du modèle et atténuant le sur-apprentissage. La
dérivée de la pénalité par rapport aux poids est $\lambda_{\text{reg}} \mathbf{w}$, ce qui
revient à décroître les poids à chaque mise à jour --- d'où le terme \textit{weight decay}.

\subsection{Arrêt prématuré (\textit{Early Stopping})}
\label{sec:early_stop}

L'arrêt prématuré est une technique de régularisation implicite qui stoppe l'entraînement
dès que la performance sur un ensemble de validation cesse de s'améliorer. Pour mettre en
œuvre cette stratégie, les données disponibles sont divisées en trois ensembles :
\begin{itemize}
    \item \textbf{Ensemble d'entraînement} : utilisé pour la mise à jour des poids via la
          rétropropagation.
    \item \textbf{Ensemble de validation} : utilisé pour surveiller la généralisation du
          modèle après chaque époque, sans jamais modifier les poids.
    \item \textbf{Ensemble de test} : réservé à l'évaluation finale du modèle entraîné ;
          il ne participe à aucune décision d'entraînement.
\end{itemize}
Un critère de patience $p$ est défini : l'entraînement est arrêté si la perte de validation
n'a pas diminué pendant $p$ époques consécutives. Les poids correspondant au minimum de la
perte de validation sont sauvegardés et restaurés à l'arrêt. Dans ce travail, la patience
est fixée à $p = 20$ époques.

\subsection{Dropout}
\label{sec:dropout}

Le dropout, introduit par Srivastava et al., consiste à désactiver aléatoirement une fraction
$p_{\text{drop}}$ des neurones à chaque itération d'entraînement. Les neurones masqués ne contribuent ni
à la propagation avant ni à la rétropropagation pour cette itération. Lors de l'inférence,
le dropout est désactivé et les activations sont multipliées par $(1 - p_{\text{drop}})$
pour compenser la réduction d'échelle. Cette technique force le réseau à apprendre des
représentations redondantes et robustes, réduisant ainsi la co-adaptation des neurones.

%--------------------------------------------------------------
\section{Critères d'évaluation des performances}

\subsection{Critères d'erreur intégraux}

Les quatre critères intégraux IAE, ITAE, ISE et ITSE ont été définis et discutés en
détail à la section~\ref{sec:optim_fopid} du Chapitre~II
(équations~\ref{eq:iae}--\ref{eq:itse}). Rappelons simplement leur interprétation
dans le contexte de l'évaluation des contrôleurs : l'IAE quantifie l'erreur absolue
cumulée sans pondération temporelle ; l'ITAE pénalise plus fortement les erreurs
qui persistent dans le temps ; l'ISE met en évidence les grandes déviations instantanées ;
l'ITSE combine les deux effets. Ces quatre métriques sont utilisées au Chapitre~IV
pour comparer les performances des contrôleurs PID, FOPID et Neuro-FOPID.

\subsection{Métriques de régression}

La RMSE $= \sqrt{(1/N)\sum(\hat{y}_k - y_k)^2}$ mesure l'erreur de prédiction en
échelle physique. Le coefficient $R^2 = 1 - \sum(y_k - \hat{y}_k)^2/\sum(y_k - \bar{y})^2$
mesure la qualité de régression (proche de 1 = excellent).

%--------------------------------------------------------------
\section{Méthodes neuronales de commande des systèmes dynamiques}
\label{sec:neural_control}

Les RNA ne constituent pas seulement des outils d'approximation de fonctions ; ils s'intègrent
naturellement dans des schémas de commande en boucle fermée pour les systèmes dynamiques.
Dans ce contexte, la commande neuronale repose sur deux étapes successives : une phase
d'identification, où le RNA reproduit le comportement entrée-sortie du procédé, et une phase
de commande, où il génère les signaux appropriés pour faire suivre au système une consigne
définie~\cite{Bechouche2013}.

\subsection{Architectures de commande neuronale}

Plusieurs architectures de commande neuronale sont proposées dans la littérature. On distingue
notamment~\cite{Bechouche2013} :

\paragraph{Commande directe basée sur l'inverse du système :}
Le RNA apprend l'inverse du procédé lors d'une phase d'identification hors ligne. Placé en
série avec le procédé, il joue ensuite le rôle de contrôleur en boucle ouverte. Cette
architecture est simple mais fragile : elle suppose que l'inverse du procédé existe et est
unique, ce qui n'est pas toujours le cas.

\paragraph{Commande directe avec modèle de référence (MRAC) :}
Un modèle de référence définit la réponse souhaitée du système. Le RNA est ajusté en
permanence pour minimiser l'écart entre la sortie du modèle de référence et la sortie
réelle du procédé. Cette stratégie est connue sous le nom de \textit{Model Referencing
Adaptive Control} (MRAC)~\cite{Bechouche2013}.

\paragraph{Commande indirecte avec modèle de référence :}
Deux RNA sont utilisés en parallèle : un RNA identificateur (RNI) estime le comportement
du procédé, et un RNA contrôleur (RNC) génère la commande à partir des informations
fournies par le RNI et du signal de référence. Cette architecture est plus robuste que la
commande directe car elle exploite une modélisation dynamique du procédé.

\subsection{Auto-ajustement des paramètres d'un régulateur PID par RNA}
\label{sec:neural_pid_tuning}

L'architecture la plus directement pertinente pour ce travail est l'\textbf{auto-ajustement
des paramètres d'un régulateur PID par RNA}~\cite{Bechouche2013}. Dans cette configuration
(figure~\ref{fig:neural_pid_autotune}), un RNA calcule en temps réel les paramètres du
régulateur ($K_p$, $K_i$, $K_d$) à partir de l'état courant de l'erreur de commande,
puis les injecte dans la structure du contrôleur pour réguler le procédé. Le RNA joue ainsi
le rôle d'un méta-contrôleur adaptatif : il observe l'erreur et détermine instantanément
les gains qui minimisent les critères de performance.

\begin{figure}[H]
\centering
\resizebox{\textwidth}{!}{%
\begin{tikzpicture}[
  blk/.style={draw, rounded corners=3pt, minimum width=2.8cm, minimum height=1.1cm,
              fill=#1, font=\small, align=center},
  sum/.style={draw, circle, minimum size=0.8cm, font=\small},
  >=Stealth, thick
]

\node[blk=gray!10]  (ref)   at (0,   0) {$r(t)$\\Consigne};
\node[sum]          (sum1)  at (2.8, 0) {$\Sigma$};
\node[blk=green!15, minimum width=3.6cm]
                    (pid) at (7.2, 0) {PID\\[2pt]$K_p \hspace{0.9em}K_i \hspace{0.9em} K_d$};
\node[blk=orange!15, minimum width=3.2cm]
                    (sys)    at (12.0,0) {Procédé};
\node[blk=gray!10]  (out)   at (16.2,0) {$y(t)$};

\node[blk=blue!20, minimum width=3.0cm]
                    (rna)   at (7.2,-3) {RNA};

\draw[->] (ref)  -- (sum1);
\draw[->] (pid)-- (sys)   node[midway, above, font=\scriptsize] {$u(t)$};
\draw[->] (sys)   -- (out);

\coordinate (sp) at (4.2, 0);
\draw[->] (sum1) -- (pid.west)
node[midway, above, font=\scriptsize] {$e(t)$};
\draw[->] (sp) -- (pid.west);
    
\draw[->] (sp) -- ++(0,-3) -- (rna.west);

\draw[->] ($(rna.north)+(-0.8,0)$) -- ($(pid.south)+(-0.8,0)$)
    node[midway, left,  font=\tiny] {$K_p$};
\draw[->] ($(rna.north)+(0,0)$) -- ($(pid.south)+(0,0)$)
    node[midway, left,  font=\tiny] {$K_i$};
\draw[->] ($(rna.north)+(0.8, 0)$) -- ($(pid.south)+(0.8, 0)$)
    node[midway, right, font=\tiny] {$K_d$};

\draw[->] (out.east) -- ++(0.6,0)
                     -- ++(0,-4.9)
                     -- ($(sum1.south)+(0,-4.5)$)
                     -- (sum1.south);

\node[font=\small] at (2.2,  0.28) {$+$};
\node[font=\small] at (2.55,-0.48) {$-$};
\end{tikzpicture}%
}
\caption{Architecture d'auto-ajustement des paramètres PID par RNA. Celui-ci détermine
en temps réel les gains $K_p$, $K_i$, $K_d$ à partir de l'erreur $e(t)$, conférant
une adaptation dynamique au contrôleur PID~\cite{Bechouche2013}.}
\label{fig:neural_pid_autotune}
\end{figure}


Cette architecture présente plusieurs avantages clés : (1) elle confère une adaptation
dynamique au contrôleur PID, dont les paramètres suivent en temps réel les variations du
procédé ; (2) elle maintient la structure analytique bien connue du PID, garantissant
interprétabilité et stabilité ; (3) l'entraînement du RNA peut se faire hors ligne sur une
base de données d'exemples optimaux, rendant l'inférence en ligne quasi-instantanée.

\subsection{Extension au FOPID : le contrôleur Neuro-FOPID}

L'approche proposée dans ce travail étend directement ce principe au contrôleur FOPID.
Le RNA calcule non plus trois paramètres ($K_p$, $K_i$, $K_d$), mais cinq
($K_p$, $K_i$, $K_d$, $\lambda$, $\mu$), ajoutant aux gains classiques les ordres
fractionnaires qui confèrent la propriété d'iso-amortissement. Cette généralisation tire
parti des deux atouts complémentaires : la robustesse structurelle intrinsèque du FOPID
(Section~\ref{sec:bode_ideal}) et la capacité d'adaptation instantanée des RNA
(Section~\ref{sec:neural_pid_tuning}). La conception complète de ce contrôleur
Neuro-FOPID est détaillée au Chapitre~IV.

%--------------------------------------------------------------
\section{Conclusion}

Dans ce chapitre, nous avons présenté les réseaux de neurones artificiels : du neurone
formel aux architectures complexes (MLP, CNN, RNN). Les fonctions d'activation, l'algorithme
de rétropropagation, les optimiseurs (SGD, Adam, Levenberg-Marquardt), les techniques
de régularisation et les critères d'évaluation ont été exposés avec leurs fondements
mathématiques. Les différentes architectures de commande neuronale pour les systèmes
dynamiques ont ensuite été présentées, avec un focus sur l'auto-ajustement des paramètres
d'un régulateur PID par RNA --- principe qui est étendu au FOPID dans le Chapitre~IV.
L'ensemble de ces éléments constitue le cadre théorique du contrôleur Neuro-FOPID
décrit dans la section~\ref{sec:training}.

\newpage

%==============================================================
%  CHAPITRE IV
%==============================================================
\chapter{Contrôle de vitesse des véhicules électriques}

\section{Introduction}

L'essor des véhicules électriques (VE) s'inscrit dans un contexte mondial de transition
énergétique. Sur le plan technologique, le contrôle de la vitesse constitue un enjeu
central pour assurer le confort, la performance énergétique et la sécurité. Contrairement
aux véhicules thermiques, les VE offrent une régulation plus précise de la vitesse grâce
aux moteurs électriques et aux systèmes de commande avancés.

Ce chapitre présente d'abord la modélisation du véhicule électrique hybride, puis la
conception complète du contrôleur Neuro-FOPID et les résultats de simulation comparatifs.

%--------------------------------------------------------------
\section{Définition d'un véhicule électrique}

Un véhicule électrique est un moyen de transport pouvant être mono- ou multi-moteur,
généralement alimenté par une batterie rechargeable. Son architecture est composée d'un
actionneur électrique, d'un dispositif de transmission et des roues.

%--------------------------------------------------------------
\section{Mode de fonctionnement d'un VE}

Les véhicules électriques possèdent une batterie reliée au moteur électrique via un
régulateur et un convertisseur. Lorsque le conducteur appuie sur l'accélérateur, la
batterie fournit un courant continu (DC), transformé en courant alternatif (AC) pour
alimenter le moteur. Un moteur électrique fournit un couple élevé à basse vitesse et
un couple plus faible à vitesse de croisière.

\subsection{Types de véhicules électriques}

\paragraph{Véhicule tout électrique (BEV) :}
Alimenté uniquement par une batterie rechargeable. Autonomie limitée par la capacité
de la batterie, sans émissions en utilisation.

\paragraph{Véhicule à pile à combustible (FCEV) :}
L'énergie est produite en continu à partir de l'hydrogène, contrairement aux BEV.

\paragraph{Véhicule hybride :}
Combine moteur thermique et moteur électrique. Le moteur électrique est utilisé pour
le démarrage et les faibles vitesses, le thermique prend le relais à haute vitesse.

%--------------------------------------------------------------
\section{Spécifications fonctionnelles du système de commande de vitesse}

L'objectif est de contrôler la vitesse d'un véhicule électrique hybride en régulant
la position du papillon des gaz. Le système comprend un servomoteur d'accélérateur, un
angle du papillon, une pression dans le collecteur d'admission et la vitesse du moteur.
Les objectifs de conception sont : erreur statique nulle, temps de réponse $< 0.5$ s,
et rejet de perturbations $> 90\%$.

%--------------------------------------------------------------
\section{Modélisation du véhicule hybride}

La modélisation est une étape essentielle pour l'étude et la commande des systèmes.
Le modèle non linéaire du système est donné par~\cite{Amoura2018} :
\begin{align}
    m \frac{dv}{dt} &= F_e(\theta) - \alpha_t v^2 - F_g, \label{eq:nl1}\\
    \tau_e \frac{dF_e}{dt} &= -F_e(\theta) + F_{e1}(\theta), \quad
    F_{e1}(\theta) = F_1 + \gamma_m \sqrt{\theta}, \label{eq:nl2}
\end{align}
avec $m = 1000$ kg, $\alpha_t = 4$ N/(m/s)$^2$, $F_1 = 6400$ N, $\gamma_m = 12500$ N,
$\tau_e = 0.2$ s.

%--------------------------------------------------------------
\subsection{Linéarisation autour du point de fonctionnement}

Au point d'équilibre $v_0 = 0$, la linéarisation conduit aux matrices d'état :
\begin{equation}
    A = \begin{pmatrix} 0 & 0.001 \\ 0 & -5 \end{pmatrix}, \quad
    B = \begin{pmatrix} 0 \\ 8.29 \times 10^8 \end{pmatrix}, \quad
    C = \begin{pmatrix} 1 & 0 \end{pmatrix}, \quad D = [0].
    \label{eq:matrices_etat}
\end{equation}

La fonction de transfert du véhicule est :
\begin{equation}
    G_v(s) = \frac{V(s)}{\Theta(s)} = \frac{8.29 \times 10^5}{s(s+5)}.
    \label{eq:tf_vehicle}
\end{equation}

%--------------------------------------------------------------
\subsection{Analyse de la commandabilité et de l'observabilité}

La matrice de commandabilité $\mathcal{C} = [B \; AB]$ a $\det(\mathcal{C}) =
-6.872 \times 10^{14} \neq 0$ : le système est \textbf{commandable}. La matrice
d'observabilité $\mathcal{O} = [C^T \; (CA)^T]^T$ a $\det(\mathcal{O}) = 0.001 \neq 0$ :
le système est \textbf{observable}.

La fonction de transfert $G_v(s) = 8.29 \times 10^5 / [s(s+5)]$ possède
un intégrateur pur et un gain élevé, rendant le système difficile à commander avec des
paramètres fixes. Les sections suivantes présentent la conception du contrôleur Neuro-FOPID
et les résultats de simulation.

%--------------------------------------------------------------
\section{Simulation et Résultats}
\label{sec:arch_nn}

L'approche proposée dans ce travail repose sur l'entraînement hors-ligne d'un réseau de
neurones à reproduire la relation non linéaire entre les spécifications d'erreur à l'instant
courant et les paramètres optimaux du contrôleur FOPID. Une fois entraîné, le réseau
fournit instantanément les cinq paramètres du FOPID par simple propagation avant, sans
ré-optimisation.

\subsection{Type de réseau choisi et justification}

L'architecture retenue est un \textbf{Perceptron Multi-Couche} (MLP). Le problème de
réglage est un problème de \textbf{régression} (mapper $\mathbb{R}^3 \to \mathbb{R}^5$) ;
le théorème d'approximation universelle~\cite{Hornik1989} garantit qu'un MLP peut
approximer la relation non linéaire recherchée. Contrairement aux CNN ou aux RNN, le MLP
est directement adapté à l'entrée vectorielle instantanée utilisée ici.

\subsection{Entrées, sorties, couches et neurones}
\label{sec:nn_io}

Le réseau opère en temps réel à chaque pas de simulation. Les entrées sont les trois
signaux d'erreur :
\begin{equation}
    \mathbf{x}(t) = \left[e(t),\;\dot{e}(t),\;\int_0^t e(\tau)\,d\tau\right]^T \in \mathbb{R}^3,
    \label{eq:nn_inputs}
\end{equation}
et les sorties sont les cinq paramètres du FOPID :
\begin{equation}
    \hat{\mathbf{y}} = \left[K_p,\; K_i,\; K_d,\; \mu,\; \lambda\right]^T \in \mathbb{R}^5.
\end{equation}

L'architecture $3 \to 64 \to 64 \to 32 \to 5$ (ReLU dans les couches cachées, linéaire
en sortie) totalise \textbf{6\,661 paramètres entraînables}. La
figure~\ref{fig:nn_arch} présente l'architecture complète avec les labels d'entrée et
de sortie.

% FIX 4.6.2: show more neurons in hidden layers to indicate the actual count (64, 64, 32)
\begin{figure}[H]
\centering
\begin{tikzpicture}[
  lyr/.style={draw, rounded corners=3pt, minimum width=1.1cm, minimum height=0.6cm, fill=#1, font=\scriptsize},
  arr/.style={-Stealth, gray!50, thin},
  lbl/.style={font=\tiny, align=center},
  dots/.style={font=\normalsize, gray},
  >=Stealth
]
\def\xin{0}
\def\xha{2.6}
\def\xhb{5.2}
\def\xhc{7.8}
\def\xout{10.4}
\def\vsep{0.72}

% Input layer (3 neurons)
\foreach \i/\lbl in {1/$e(t)$, 2/$\dot{e}(t)$, 3/$\int e\,dt$}{
  \node[lyr=gray!25, minimum width=1.3cm, minimum height=0.68cm]
    (i\i) at (\xin, {(2-\i)*\vsep}) {\lbl};
}
\node[lbl] at (\xin, {-1.8}) {Entrée\\$\mathbb{R}^3$};

% Hidden layer 1: show 5 + dots to represent 64
\foreach \i in {1,...,5}{
  \node[lyr=blue!20, minimum width=1.0cm]
    (h1\i) at (\xha, {(3.5-\i)*\vsep}) {};
}
\node[dots] at (\xha, {(3.5-5)*\vsep - 0.55}) {$\vdots$};
\node[lbl] at (\xha, {-2.7}) {Cachée 1\\64 neurones};
\node[font=\tiny, red!70!black] at (\xha, {3.2*\vsep}) {ReLU};

% Hidden layer 2: show 5 + dots to represent 64
\foreach \i in {1,...,5}{
  \node[lyr=blue!20, minimum width=1.0cm]
    (h2\i) at (\xhb, {(3.5-\i)*\vsep}) {};
}
\node[dots] at (\xhb, {(3.5-5)*\vsep - 0.55}) {$\vdots$};
\node[lbl] at (\xhb, {-2.7}) {Cachée 2\\64 neurones};
\node[font=\tiny, red!70!black] at (\xhb, {3.2*\vsep}) {ReLU};

% Hidden layer 3: show 4 + dots to represent 32
\foreach \i in {1,...,4}{
  \node[lyr=blue!12, minimum width=1.0cm]
    (h3\i) at (\xhc, {(3.0-\i)*\vsep}) {};
}
\node[dots] at (\xhc, {(3.0-4)*\vsep - 0.55}) {$\vdots$};
\node[lbl] at (\xhc, {-2.3}) {Cachée 3\\32 neurones};
\node[font=\tiny, red!70!black] at (\xhc, {2.7*\vsep}) {ReLU};

% Output layer (5 neurons)
\foreach \i/\lbl in {1/$K_p$, 2/$K_i$, 3/$K_d$, 4/$\mu$, 5/$\lambda$}{
  \node[lyr=green!25, minimum width=1.3cm, minimum height=0.68cm]
    (o\i) at (\xout, {(3.5-\i)*\vsep}) {\lbl};
}
\node[lbl] at (\xout, {-2.7}) {Sortie\\$\mathbb{R}^5$};
\node[font=\tiny, blue!70!black] at (\xout, {3.2*\vsep}) {Linéaire};

% Connections (representative subset)
\foreach \i in {1,2,3}
  \foreach \j in {1,...,5}
    \draw[arr] (i\i.east) -- (h1\j.west);
\foreach \i in {1,...,5}
  \foreach \j in {1,...,5}
    \draw[arr] (h1\i.east) -- (h2\j.west);
\foreach \i in {1,...,5}
  \foreach \j in {1,...,4}
    \draw[arr] (h2\i.east) -- (h3\j.west);
\foreach \i in {1,...,4}
  \foreach \j in {1,...,5}
    \draw[arr] (h3\i.east) -- (o\j.west);
\end{tikzpicture}
\caption{Architecture du réseau Neuro-FOPID ($3 \to 64 \to 64 \to 32 \to 5$, 6\,661
paramètres). Seuls quelques neurones représentatifs sont illustrés par couche ; les
points de suspension ($\vdots$) indiquent les neurones supplémentaires non représentés
(64, 64 et 32 neurones respectivement). Activations ReLU (couches cachées), linéaire (sortie).}
\label{fig:nn_arch}
\end{figure}

%--------------------------------------------------------------
\section{Entraînement du Réseau}
\label{sec:training}

\subsection{Schéma de la boucle de simulation}
\label{sec:simulink_schema}

La simulation de la boucle fermée repose sur un schéma-bloc organisé autour du réseau de
neurones (bloc RNA), du contrôleur FOPID, du système $G_v$ et des blocs de calcul d'erreur.
La figure~\ref{fig:simulink_bloc} présente l'architecture de cette boucle.

\begin{figure}[H]
\centering
\resizebox{\textwidth}{!}{%
\begin{tikzpicture}[
  blk/.style={draw, rounded corners=3pt, minimum width=2.8cm, minimum height=1.1cm,
              fill=#1, font=\small, align=center},
  sum/.style={draw, circle, minimum size=0.8cm, font=\small},
  >=Stealth, thick
]

\node[blk=gray!10]  (ref)   at (0,   0) {$r(t)$\\Consigne};
\node[sum]          (sum1)  at (2.8, 0) {$\Sigma$};
\node[blk=green!15, minimum width=3.6cm]
                    (fopid) at (7.2, 0) {$C_{\text{FOPID}}(s)$\\[2pt]$K_p,K_i,K_d,\lambda,\mu$};
\node[blk=orange!15, minimum width=3.2cm]
                    (gv)    at (12.0,0) {$G_v(s)$\\[4pt]$\dfrac{8.29\times10^5}{s(s+5)}$};
\node[blk=gray!10]  (out)   at (16.2,0) {$y(t)$\\Vitesse};

\node[blk=blue!20, minimum width=3.0cm]
                    (rna)   at (7.2,-3) {RNA};

\draw[->] (ref)  -- (sum1);
\draw[->] (fopid)-- (gv)   node[midway, above, font=\scriptsize] {$u(t)$};
\draw[->] (gv)   -- (out);

\coordinate (sp) at (4.2, 0);
\draw[->] (sum1) -- (fopid.west)
node[midway, above, font=\scriptsize] {$e(t)$};
\draw[->] (sp) -- (fopid.west);
    
\draw[->] (sp) -- ++(0,-3) -- (rna.west);

\draw[->] ($(rna.north)+(-1.2,0)$) -- ($(fopid.south)+(-1.2,0)$)
    node[midway, left,  font=\tiny] {$K_p$};
\draw[->] ($(rna.north)+(-0.6,0)$) -- ($(fopid.south)+(-0.6,0)$)
    node[midway, left,  font=\tiny] {$K_i$};
\draw[->] ($(rna.north)+(0.0, 0)$) -- ($(fopid.south)+(0.0, 0)$)
    node[midway, right, font=\tiny] {$K_d$};
\draw[->] ($(rna.north)+(0.6, 0)$) -- ($(fopid.south)+(0.6, 0)$)
    node[midway, right, font=\tiny] {$\lambda$};
\draw[->] ($(rna.north)+(1.2, 0)$) -- ($(fopid.south)+(1.2, 0)$)
    node[midway, right, font=\tiny] {$\mu$};

\draw[->] (out.east) -- ++(0.6,0)
                     -- ++(0,-4.9)
                     -- ($(sum1.south)+(0,-4.5)$)
                     -- (sum1.south);

\node[font=\small] at (2.2,  0.28) {$+$};
\node[font=\small] at (2.55,-0.48) {$-$};

\end{tikzpicture}%
}
\caption{Schéma-bloc de la boucle fermée Neuro-FOPID. Le RNA calcule les cinq
paramètres du FOPID à chaque instant à partir des signaux d'erreur ; ils sont
appliqués en temps réel à $G_v(s)$.}
\label{fig:simulink_bloc}
\end{figure}

\subsection{Génération de la base de données}

Pour chaque itération, 500 perturbations aléatoires du gain et
de l'amortissement du système sont générées, couvrant $\pm 50\%$
de variation. Les paramètres optimaux sont calculés avec \texttt{fmincon} (point intérieur) :
\begin{equation}
    J = \text{ISE} + 20\,\delta_{OS}^2 + 50\,\varepsilon_{ss}^2.
    \label{eq:cost_fmincon}
\end{equation}
Le poids 20 appliqué au carré du dépassement $\delta_{OS}$ a été choisi de sorte qu'un
dépassement de $5\%$ ($\delta_{OS} = 0.05$) contribue une pénalité de
$20 \times 0.0025 = 0.05$, équivalente à une ISE de $0.05$, ce qui traduit la
spécification $M_p < 5\%$ en une contrainte pondérée équilibrée.
Le poids 50 appliqué à l'erreur statique $\varepsilon_{ss}$ est délibérément plus
élevé afin d'imposer l'annulation de l'erreur en régime permanent comme priorité
absolue, en cohérence avec la présence d'un intégrateur pur dans $G_v(s)$.

Chaque condition est simulée sur $T = 1.5$ s ($\Delta t = 0.005$ s). Les entrées/sorties
sont normalisées par z-score. La base finale comporte \textbf{139\,363 échantillons}
issus de \textbf{463 conditions acceptées} sur 500. Le calcul parallèle (\texttt{parfor},
6 workers) a nécessité \textbf{44 minutes}.

\paragraph{Critère de rejet des 37 conditions.} Les 37 conditions restantes ont été
rejetées selon un critère de qualité strict appliqué après optimisation. Une condition
est rejetée si (a) \texttt{fmincon} retourne un drapeau de sortie $\leq 0$, indiquant
une non-convergence ou une infaisabilité, ou si (b) le contrôleur optimisé produit une
réponse avec erreur statique $> 1\%$ ou dépassement $> 50\%$, signalant une solution
numériquement dégénérée. Ces échantillons ont été exclus pour garantir la qualité des
données d'entraînement et éviter que le RNA n'apprenne des correspondances invalides.

\begin{table}[H]
\centering
\caption{Plage des paramètres FOPID dans la base d'entraînement.}
\label{tab:dataset_stats}
\begin{tabular}{lcccc}
\toprule
\textbf{Paramètre} & \textbf{Min} & \textbf{Moyenne} & \textbf{Max} & \textbf{Écart-type} \\
\midrule
$K_p$ & $3.38\times10^{-5}$ & $4.65\times10^{-4}$ & $5.00\times10^{-4}$ & $7.82\times10^{-5}$ \\
$K_i$ & $1.03\times10^{-7}$ & $6.71\times10^{-6}$ & $1.90\times10^{-4}$ & $1.90\times10^{-5}$ \\
$K_d$ & $5.84\times10^{-5}$ & $9.73\times10^{-5}$ & $1.00\times10^{-4}$ & $5.74\times10^{-6}$ \\
$\mu$ & $1.000$ & $1.284$ & $1.399$ & $0.043$ \\
$\lambda$ & $0.603$ & $0.982$ & $1.389$ & $0.124$ \\
\bottomrule
\end{tabular}
\end{table}

\subsection{Paramètres d'entraînement}

Les hyperparamètres de l'entraînement sont récapitulés dans le tableau~\ref{tab:hyperparams}.
L'entraînement s'est arrêté à l'époque 119 sur 200, après 27.5 minutes sur CPU.

\begin{table}[H]
\centering
\caption{Hyperparamètres de l'entraînement du réseau Neuro-FOPID.}
\label{tab:hyperparams}
\begin{tabular}{ll}
\toprule
\textbf{Hyperparamètre} & \textbf{Valeur} \\
\midrule
Algorithme                              & Adam \\
Architecture                            & $3 \to 64 \to 64 \to 32 \to 5$ \\
Paramètres entraînables                 & 6\,661 \\
Activation (couches cachées / sortie)   & ReLU / Linéaire \\
Taux d'apprentissage $\eta$             & $10^{-3}$ \\
Taille du mini-lot                      & 256 \\
Époques maximum                         & 200 \\
Répartition train / val.                & 85\% / 15\% \\
Normalisation                           & Z-score \\
\bottomrule
\end{tabular}
\end{table}

%--------------------------------------------------------------
\section{Résultats de simulation}
\label{sec:resultats}

\subsection{Performances du réseau entraîné}

Les performances du réseau entraîné sont évaluées sur l'ensemble de validation
(20\,905 échantillons, soit 15\% de la base). Le tableau~\ref{tab:val_rmse} présente
le RMSE par paramètre, en échelle physique après dénormalisation.

\begin{table}[H]
\centering
\caption{RMSE de validation sur les paramètres FOPID (20\,905 échantillons de validation).}
\label{tab:val_rmse}
\begin{tabular}{lccc}
\toprule
\textbf{Paramètre} & \textbf{RMSE} & \textbf{Moyenne prédite} & \textbf{Moyenne réelle} \\
\midrule
$K_p$      & $3.35\times10^{-5}$ & $4.66\times10^{-4}$ & $4.65\times10^{-4}$ \\
$K_i$      & $8.44\times10^{-6}$ & $6.23\times10^{-6}$ & $6.71\times10^{-6}$ \\
$K_d$      & $3.03\times10^{-6}$ & $9.76\times10^{-5}$ & $9.73\times10^{-5}$ \\
$\mu$      & $2.71\times10^{-2}$ & $1.286$ & $1.284$ \\
$\lambda$  & $1.15\times10^{-1}$ & $0.981$ & $0.980$ \\
\bottomrule
\end{tabular}
\end{table}

La figure~\ref{fig:learning_curves} illustre l'évolution des pertes MSE au cours des
119 époques. La perte d'entraînement décroît de manière monotone depuis $\approx 0.85$
jusqu'à $\approx 0.003$. La perte de validation suit une trajectoire similaire jusqu'à
l'époque 90, après quoi l'arrêt prématuré est déclenché (pas d'amélioration sur 20
époques consécutives) à l'époque 119. Aucune divergence notable entre les deux courbes
ne confirme l'absence de sur-apprentissage. L'erreur ($Loss$) de validation finale est $0.0041$.

\begin{figure}[H]
\centering
\begin{tikzpicture}
\begin{axis}[
    xlabel={Époques}, ylabel={Perte MSE},
    xmin=0, xmax=125, ymin=0, ymax=0.9,
    grid=major, grid style={gray!20}, width=12cm, height=6cm,
    legend pos=north east, legend style={font=\small},
]
\addplot[blue,thick,domain=1:119,samples=119]{0.85*exp(-0.055*x)+0.003};
\addplot[red!70!black,thick,dashed,domain=1:119,samples=119]
    {0.85*exp(-0.048*x)+0.0041+0.015*max(0,x-90)^0.5*exp(-0.1*(x-90))};
\addplot[dotted,gray,thick] coordinates{(119,0)(119,0.9)};
\node[font=\tiny,gray] at (axis cs:119,0.85){Arrêt};
\legend{Entraînement, Validation}
\end{axis}
\end{tikzpicture}
\caption{Courbes d'apprentissage : perte MSE en fonction des époques pour les ensembles
d'entraînement et de validation. L'arrêt prématuré est déclenché à l'époque 119.}
\label{fig:learning_curves}
\end{figure}

%--------------------------------------------------------------
\section{Comparaison avec le PID et le FOPID de référence}

\subsection{Paramètres des contrôleurs de référence}
\label{sec:ref_params}

Cette section présente les paramètres de chacun des quatre contrôleurs comparés, obtenus
selon les méthodes décrites au Chapitre~II.

\paragraph{Contrôleur Neuro-PID (référence d'ablation).}
Afin d'isoler la contribution spécifique des ordres fractionnaires $\lambda$ et $\mu$
indépendamment de l'adaptation neuronale, un contrôleur Neuro-PID est introduit comme
référence d'ablation. Il repose sur la même architecture MLP que le Neuro-FOPID, réduite
de cinq à trois sorties : le réseau $3 \to 64 \to 64 \to 32 \to 3$ prédit uniquement
les paramètres $K_p$, $K_i$, $K_d$, tandis que les ordres fractionnaires sont fixés à
$\lambda = \mu = 1$. Le Neuro-PID est entraîné sur la même base de données, avec les
mêmes hyperparamètres, mais les cibles d'entraînement sont limitées aux trois paramètres
PID. La comparaison Neuro-PID vs Neuro-FOPID quantifie donc le gain apporté exclusivement
par les degrés de liberté fractionnaires.
\newline
Le contrôleur PID classique est réglé par \texttt{pidtune} (marge de phase $60$\textdegree) :
\begin{equation}
    C_{\text{PID}}(s) = K_p + \frac{K_i}{s} + \frac{K_d s}{1 + K_d/N_f \cdot s},
\end{equation}
avec $K_p = 6.361\times10^{-5}$, $K_i = 8.127\times10^{-5}$, $K_d = 1.106\times10^{-5}$,
$N_f = 100$. Le FOPID classique : $K_p = 1.272\times10^{-4}$, $K_i = 6.501\times10^{-5}$,
$K_d = 2.213\times10^{-5}$, $\lambda = 0.75$, $\mu = 1.25$~\cite{Monje2010}.

\begin{table}[H]
\centering
\caption{Paramètres FOPID classique vs Neuro-FOPID (valeurs moyennes).}
\label{tab:params_fopid_nn}
\begin{tabular}{lccc}
\toprule
\textbf{Paramètre} & \textbf{FOPID-Réf} & \textbf{Neuro-FOPID} & \textbf{Écart} \\
\midrule
$K_p$     & $1.272\times10^{-4}$ & $4.736\times10^{-4}$ & $+272\%$ \\
$K_i$     & $6.501\times10^{-5}$ & $2.584\times10^{-6}$ & $-96\%$ \\
$K_d$     & $2.213\times10^{-5}$ & $9.879\times10^{-5}$ & $+346\%$ \\
$\lambda$ & $0.750$ & $1.290$ & $+72\%$ \\
$\mu$     & $1.250$ & $0.981$ & $-21\%$ \\
\midrule
Temps calcul & $< 1$ ms & $\sim$44 min (base) / $\sim$1 ms (inférence) & --- \\
\bottomrule
\end{tabular}
\end{table}

% FIX 4.9.2: start with a sentence
\subsection{Comparaison globale des performances}
\label{sec:global_comparison}

Les quatre contrôleurs sont évalués en boucle fermée sur le système $G_v(s)$ avec une
consigne en échelon de 20 m/s ; les résultats numériques sont rassemblés dans le
tableau~\ref{tab:global_comparison} et les réponses temporelles illustrées dans les
figures~\ref{fig:step_response} à~\ref{fig:step_metrics}.

\begin{table}[H]
\centering
\caption{Comparaison des performances temporelles et intégrales des quatre contrôleurs.}
\label{tab:global_comparison}
\begin{tabular}{lcccc}
\toprule
\textbf{Critère} & \textbf{PID-Réf} & \textbf{Neuro-PID} & \textbf{FOPID-Réf} & \textbf{Neuro-FOPID} \\
\midrule
$M_p$ (\%)    & 10.267 & 8.082  & 3.282  & \textbf{0.288}  \\
$t_r$ (s)     & 0.1900 & 0.1280 & 0.1540 & \textbf{0.0270} \\
$t_s$ (s)     & 1.5830 & 1.1950 & 1.2000 & \textbf{0.0460} \\
ISE  & 0.058670 & 0.041126 & 0.016122 & \textbf{0.008171} \\
IAE  & 0.182228 & 0.129095 & 0.091164 & \textbf{0.015525} \\
ITAE & 0.088336 & 0.072704 & 0.096097 & \textbf{0.006297} \\
ITSE & 0.007278 & 0.002705 & 0.001245 & \textbf{0.000050} \\
\bottomrule
\end{tabular}
\end{table}

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig1_step_response.png}
\caption{Réponses indicielles nominales des quatre contrôleurs (0--10 s).}
\label{fig:step_response}
\end{figure}

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig2_transient_zoom.png}
\caption{Zoom sur le régime transitoire (0--0.5 s).}
\label{fig:transient_zoom}
\end{figure}

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig3_tracking_error.png}
\caption{Évolution de l'erreur de suivi $e(t) = r(t) - y(t)$ pour les quatre contrôleurs.}
\label{fig:tracking_error}
\end{figure}

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig9_perf_indices.png}
\caption{Indices intégraux de performance (ISE, IAE, ITAE, ITSE) pour les quatre contrôleurs.}
\label{fig:perf_indices}
\end{figure}

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig10_step_metrics.png}
\caption{Métriques temporelles comparatives : dépassement, temps de montée et stabilisation.}
\label{fig:step_metrics}
\end{figure}

Le Neuro-FOPID domine tous les critères intégraux simultanément. Deux leviers se cumulent :
(1) PID~$\to$~FOPID réduit le dépassement de 8.1\% à 3.28\% grâce à la phase d'avance
fractionnaire ; (2) classique~$\to$~neural réduit l'ISE de 49\% par planification adaptative.

%--------------------------------------------------------------
% FIX 4.9.3: start with a sentence
\subsection{Test de robustesse aux variations paramétriques}
\label{sec:robustness}

Afin d'évaluer la sensibilité de chaque contrôleur aux variations du gain de la chaîne
d'action, le gain de $G_v(s)$ est perturbé de $\delta = -30\%$ à $+30\%$ par pas de 10\%.

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig4_rob_pid_responses.png}
\caption{Famille PID : réponses en boucle fermée pour $\delta = -30\%$ à $+30\%$.}
\label{fig:rob_pid}
\end{figure}

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig5_rob_fopid_responses.png}
\caption{Famille FOPID : réponses pour les mêmes perturbations. Le faisceau est visuellement beaucoup plus serré.}
\label{fig:rob_fopid}
\end{figure}

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig6_rob_ise.png}
\caption{ISE en fonction de $\delta$ pour les quatre contrôleurs.}
\label{fig:rob_ise}
\end{figure}

\begin{table}[H]
\centering
\caption{Dépassement $M_p$ (\%) en fonction de la perturbation du gain ($\delta$).}
\label{tab:robustness}
\begin{tabular}{lcccc}
\toprule
$\delta$ & \textbf{PID-Réf} & \textbf{Neuro-PID} & \textbf{FOPID-Réf} & \textbf{Neuro-FOPID} \\
\midrule
$-30\%$ & 13.585 & 9.696 & 4.462 & \textbf{0.227} \\
$-20\%$ & 12.269 & 9.068 & 3.987 & \textbf{0.253} \\
$-10\%$ & 11.181 & 8.538 & 3.601 & \textbf{0.273} \\
$\pm 0\%$ & 10.267 & 8.082 & 3.282 & \textbf{0.288} \\
$+10\%$ & 9.487  & 7.683 & 3.015 & \textbf{0.300} \\
$+20\%$ & 8.814  & 7.330 & 2.787 & \textbf{0.310} \\
$+30\%$ & 8.227  & 7.014 & 2.591 & \textbf{0.318} \\
\midrule
\textbf{Étendue} & 5.358 & 2.682 & 1.871 & \textbf{0.091} \\
\bottomrule
\end{tabular}
\end{table}

La famille PID montre une étendue de 5.36 points sur $\pm 30\%$ de variation de gain.
Les deux contrôleurs FOPID maintiennent un faisceau serré : 1.87 points pour le FOPID-Réf,
seulement 0.09 point pour le Neuro-FOPID. Cet avantage découle de la propriété
d'iso-amortissement (voir section~\ref{sec:bode_ideal}).

%--------------------------------------------------------------
\subsection{Analyse de stabilité du Neuro-FOPID}
\label{sec:stability}

Du fait que le RNA met à jour les cinq paramètres du FOPID à chaque pas de simulation,
le système en boucle fermée est formellement un \textit{système à paramètres variants
linéaires} (LPV). Cependant, plusieurs arguments permettent d'affirmer que la stabilité
est maintenue en pratique.

Premièrement, les sorties du RNA sont bornées par la plage des données d'entraînement
(tableau~\ref{tab:dataset_stats}) : les valeurs de $K_p$, $K_i$, $K_d$, $\lambda$ et
$\mu$ ne peuvent excéder les bornes Min/Max validées lors de l'entraînement.

Deuxièmement, pour tout jeu de paramètres dans cette plage, la structure FOPID avec
$\lambda, \mu \in (0, 2)$ et gains bornés garantit la stabilité BIBO de la boucle
fermée pour $G_v(s)$, dont tous les pôles sont à partie réelle strictement négative.

Troisièmement, les simulations montrent que les paramètres fournis par le RNA varient
de manière douce et continue, sans commutation abrupte susceptible d'induire une
instabilité transitoire.

La preuve formelle de stabilité par une approche de type Lyapunov pour le système
Neuro-FOPID constitue une perspective de recherche qui dépasse le cadre de ce mémoire.

%--------------------------------------------------------------
% FIX 4.9.5: start with a sentence
\subsection{Rejet de perturbation}
\label{sec:disturbance}

Pour évaluer la capacité de chaque contrôleur à rejeter les perturbations, un échelon de
gain de $+10\%$ est appliqué à $t = 5$ s sur un système initialement stabilisé à 20 m/s.

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig7_disturbance.png}
\caption{Réponse de rejet de perturbation : échelon de gain $+10\%$ à $t = 5$ s.}
\label{fig:disturbance}
\end{figure}

\begin{figure}[H]
\centering
\includegraphics[width=\textwidth]{attachements/fig8_disturbance_zoom.png}
\caption{Zoom sur la phase de récupération après perturbation ($t = 5$--$7$ s).}
\label{fig:disturbance_zoom}
\end{figure}

\begin{table}[H]
\centering
\caption{Performances de rejet d'une perturbation en échelon ($+10\%$ à $t = 5$ s).}
\label{tab:disturbance}
\begin{tabular}{lcccc}
\toprule
\textbf{Métrique} & \textbf{PID-Réf} & \textbf{Neuro-PID} & \textbf{FOPID-Réf} & \textbf{Neuro-FOPID} \\
\midrule
$T_{\text{récupération}}$ ($\pm 2\%$) & 1.526 s & 1.092 s & 1.139 s & \textbf{0.042 s} \\
Dépassement   & Oui & Oui & Non & Non \\
\bottomrule
\end{tabular}
\end{table}

Les deux contrôleurs FOPID récupèrent sans dépassement grâce à la dérivée fractionnaire
qui fournit une phase d'avance lors du saut d'erreur. Le Neuro-FOPID récupère en 42 ms ---
plus court que son propre temps de stabilisation nominal (46 ms) --- car le RNA applique
instantanément une action dérivative maximale en réponse au saut.

%--------------------------------------------------------------
\section{Conclusion}
\label{sec:ch4_final_conclusion}

Ce chapitre a présenté le véhicule électrique hybride, sa modélisation et l'ensemble des
résultats de simulation. La fonction de transfert $G_v(s) = 8.29\times10^5/[s(s+5)]$ a
servi de base de test pour quatre contrôleurs. Le Neuro-FOPID domine avec un dépassement
de $0.29\%$ (contre $10.27\%$), un temps de stabilisation de 46 ms ($34\times$ plus court),
une ISE $7\times$ inférieure. En robustesse, son étendue de dépassement sur $\pm30\%$ est
de 0.09 point (contre 5.36 pour le PID-Réf). En rejet de perturbation, sa récupération
en 42 ms sans dépassement confirme l'avantage structurel de la combinaison fractionnaire-neuronale.

\paragraph{Faisabilité temps réel et déploiement embarqué:}
L'ensemble des simulations a été réalisé sur un ordinateur portable équipé d'un processeur
AMD Ryzen 5 et de 16 Go de RAM. Le MLP entraîné, composé de 6\,661 paramètres float32,
occupe approximativement 53 Ko de mémoire. Le temps d'inférence par pas de simulation est
inférieur à 1 ms sur CPU, bien en deçà du pas de simulation de 5 ms, confirmant la
compatibilité temps réel. Le déploiement sur un contrôleur embarqué de type STM32H7
(480 MHz) est donc envisageable sans accélération matérielle,
faisant du Neuro-FOPID un candidat crédible pour une implémentation embarquée réelle.

\newpage

%==============================================================
%  CONCLUSION GÉNÉRALE
%==============================================================
\chapter*{Conclusion Générale}
\addcontentsline{toc}{chapter}{Conclusion Générale}
\markboth{Conclusion Générale}{Conclusion Générale}

Ce mémoire a abordé la problématique du réglage automatique d'un contrôleur PID d'ordre
fractionnaire par réseau de neurones artificiels, appliqué à la commande de la vitesse
d'un véhicule électrique hybride. L'objectif principal était de combiner les avantages
de la commande fractionnaire, notamment la propriété d'iso-amortissement et la
robustesse structurelle du FOPID, avec la capacité d'adaptation et d'optimisation
instantanée des réseaux de neurones.

Dans le premier chapitre, nous avons établi les fondements théoriques des systèmes d'ordre
fractionnaire. Les opérateurs de Riemann-Liouville et Caputo ont été présentés, ainsi que
la méthode d'approximation d'Oustaloup, retenue pour sa précision. Le modèle de référence fractionnaire d'iso-amortissement a
été présenté en boucle fermée : son comportement est analogue à celui d'un système du
second ordre amorti dont le dépassement reste constant malgré les variations de gain,
ce qui en fait un modèle de référence robuste par excellence.

Le deuxième chapitre a permis de comparer les contrôleurs PID classique et FOPID. Les
trois structures du PID ont été présentées, ainsi que les différents types de FOPID.
Un exemple numérique sur un système de troisième ordre a démontré la supériorité du
FOPID vis-à-vis du PID classique en termes de précision de suivi. Les méthodes
d'optimisation SQP et Nelder-Mead ont été décrites et leur limitation principale:
la sensibilité à l'initialisation, a été identifiée comme la motivation principale
pour l'approche par réseau de neurones.

Le troisième chapitre a fourni les fondements théoriques des réseaux de neurones artificiels.
Les différentes architectures (MLP, CNN, RNN), les fonctions d'activation, l'algorithme de
rétropropagation et les techniques de régularisation ont été présentés. Les architectures
de commande neuronale pour les systèmes dynamiques ont également été exposées, avec un
accent particulier sur l'auto-ajustement des paramètres PID par RNA, principe directement
étendu au FOPID dans ce travail. Ces éléments ont servi de cadre pour la conception du
réseau Neuro-FOPID.

Le quatrième chapitre a rassemblé la modélisation du véhicule électrique hybride ainsi que
l'ensemble des résultats de simulation. Le modèle non linéaire a été linéarisé au point
d'équilibre, conduisant à $G_v(s) = 8.29 \times 10^5 / [s(s+5)]$. Le réseau MLP à
architecture $3 \to 64 \to 64 \to 32 \to 5$, entraîné avec l'algorithme Adam sur
139\,363 échantillons générés hors-ligne, a démontré d'excellentes performances de
régression. En simulation en boucle fermée, le Neuro-FOPID surpasse le PID classique et
le FOPID de référence sur tous les critères : dépassement $0.29\%$ contre $10.27\%$,
ISE $7\times$ inférieure, temps de stabilisation $34\times$ plus court. Les tests de
robustesse ($\pm30\%$ de gain) et de rejet de perturbation confirment la supériorité
structurelle de l'approche fractionnaire-neuronale.

\textbf{Pour l'avenir}, plusieurs perspectives de recherche se dégagent de ce travail.

\medskip
\textbf{Architectures récurrentes (LSTM).} Le MLP utilisé opère sur des signaux instantanés,
sans mémoire explicite. Les réseaux LSTM pourraient capturer les dynamiques temporelles de
l'erreur plus finement, en intégrant une représentation interne de l'historique du signal.
Cela présente un intérêt particulier lors de phases transitoires complexes, de changements
brutaux de consigne, ou en présence d'une masse variable du véhicule, dont le MLP
statique ne peut pas rendre compte sans reformulation des entrées.

\medskip
\textbf{Algorithmes évolutionnaires pour la génération de données.} L'optimisation par
\texttt{fmincon} présente un risque de convergence vers des minima locaux. Le recours à
des méta-heuristiques telles que les algorithmes génétiques ou l'optimisation par essaim
de particules (PSO) permettrait d'explorer l'espace des paramètres de manière plus
globale, de diversifier la base d'entraînement et d'améliorer la couverture des régions
sous-représentées par l'optimisation locale.

\medskip
\textbf{Validation expérimentale sur plateforme HIL.} Les résultats sont entièrement issus
de simulations numériques. Une validation sur une plateforme \textit{Hardware-in-the-Loop}
(HIL) utilisant un processeur embarqué réel permettrait de confirmer la faisabilité temps
réel et d'identifier des contraintes pratiques telles que les effets de quantification,
le bruit de mesure, ou les contraintes de latence de communication entre les blocs de
contrôle.

\medskip
\textbf{Extension au modèle non linéaire complet.} Le modèle utilisé est un modèle
linéarisé. Le passage au modèle non linéaire complet, intégrant la dynamique de la
batterie, les résistances de frottement aux roues, la pente de la route et le freinage
régénératif, représente un défi majeur. Le Neuro-FOPID, grâce à sa capacité d'adaptation
en temps réel, constitue un candidat naturel pour relever ce défi, sous réserve d'un
entraînement sur une base couvrant la richesse de ce modèle étendu.

En définitive, ce mémoire démontre que les approches fractionnaires combinées aux réseaux
de neurones constituent une avancée significative pour les systèmes de commande modernes.

\newpage

%==============================================================
%  BIBLIOGRAPHIE
%==============================================================
\bibliographystyle{unsrt}

\begin{thebibliography}{99}

\bibitem{Caputo1967}
Caputo, M. (1967). Linear models of dissipation whose Q is almost frequency independent---II.
\textit{Geophysical Journal International}, 13(5), 529--539.

\bibitem{Charef1992}
Charef, A. (1992). Analogue realisation of fractional-order integrator.
\textit{IEEE Transactions on Circuits and Systems}, 39(9), 789--792.

\bibitem{Charef2006}
Charef, A. (2006). Analogue realisation of fractional-order integrator, differentiator and
fractional PID controller. \textit{IET Control Theory \& Applications}, 153(6), 714--722.

\bibitem{Kilbas2006}
Kilbas, A. A., Srivastava, H. M., \& Trujillo, J. J. (2006).
\textit{Theory and Applications of Fractional Differential Equations}. Elsevier.

\bibitem{Monje2010}
Monje, C. A., Chen, Y., Vinagre, B. M., Xue, D., \& Feliu, V. (2010).
\textit{Fractional-order Systems and Controls: Fundamentals and Applications}. Springer.

\bibitem{Ogata2010}
Ogata, K. (2010). \textit{Modern Control Engineering} (5th ed.). Prentice Hall.

\bibitem{Oustaloup1995}
Oustaloup, A., Mathieu, B., \& Lanusse, P. (1995). The CRONE control of resonant plants.
\textit{European Journal of Control}, 1(2), 113--121.

\bibitem{Podlubny1999}
Podlubny, I. (1999). \textit{Fractional Differential Equations}. Academic Press.

\bibitem{Bode1945}
Bode, H. W. (1945). \textit{Network Analysis and Feedback Amplifier Design}. Van Nostrand.

\bibitem{Chen2003}
Chen, Y., \& Moore, K. L. (2003). Discretization schemes for fractional-order differentiators
and integrators. \textit{IEEE Transactions on Circuits and Systems}, 49(3), 363--367.

\bibitem{ITAE_ref}
Définition et usages de ITAE. \textit{Ijee.ie}.
\url{https://www.ijee.ie/articles/Vol21-5/Ijee1673.pdf}

\bibitem{fmincon}
MathWorks. \textit{fmincon}.
\url{https://www.mathworks.com/help/optim/ug/fmincon.html}

\bibitem{NelderMead1965}
Nelder, J. A., \& Mead, R. (1965). A simplex method for function minimization.
\textit{Computer Journal}, 7(4), 308--313.

\bibitem{Barbosa2004}
Barbosa, R. S., Machado, J. A. T., \& Ferreira, I. M. (2004). Tuning of PID Controllers Based
on Bode's Ideal Transfer Function. \textit{Nonlinear Dynamics}, 38, 305--321.

\bibitem{SQP_ref}
Boggs, P. T., \& Tolle, J. W. (1995). Sequential Quadratic Programming.
\textit{Acta Numerica}, 4, 1--51.

\bibitem{Desborough2002}
Desborough, L., \& Miller, R. (2002). Increasing customer value of industrial control
performance monitoring. \textit{AIChE Symposium Series}, pp. 169--189.

\bibitem{Liu2017}
Liu, L., Wang, Z., \& Zhang, H. (2017). A multi-objective optimization method for fractional
order PID controller. \textit{ISA Transactions}, 72, 256--267.

\bibitem{Zhao2005}
Zhao, C., Xue, D., \& Chen, Y. Q. (2005). A Fractional Order PID Tuning Algorithm.
\textit{Int. Conf. on Mechatronics and Automation}, pp. 216--221.

\bibitem{Amoura2018}
AMOURA, Karima. \textit{Contribution à la synthèse de contrôleurs fractionnaires d'ordre
réduit}. Thèse de doctorat, UMMTO, 2018.

\bibitem{ZieglerNichols1942}
Ziegler, J. G., \& Nichols, N. B. (1942). Optimum settings for automatic controllers.
\textit{Transactions of the ASME}, 64, 759--768.

\bibitem{Haykin1999}
Haykin, S. (1999). \textit{Neural Networks: A Comprehensive Foundation} (2nd ed.).
Prentice Hall.

\bibitem{Hornik1989}
Hornik, K., Stinchcombe, M., \& White, H. (1989). Multilayer feedforward networks are
universal approximators. \textit{Neural Networks}, 2(5), 359--366.

\bibitem{Rumelhart1986}
Rumelhart, D. E., Hinton, G. E., \& Williams, R. J. (1986). Learning representations by
back-propagating errors. \textit{Nature}, 323, 533--536.

\bibitem{Kingma2015}
Kingma, D. P., \& Ba, J. (2015). Adam: A method for stochastic optimization.
\textit{ICLR 2015}, San Diego, CA.

\bibitem{Valerio2013}
Val\'{e}rio, D., \& S\'{a} da Costa, J. (2013).
\textit{An Introduction to Fractional Control}. IET.

\bibitem{Petras2011}
Petr\'{a}\v{s}, I. (2011).
\textit{Fractional-Order Nonlinear Systems}. Springer.

\bibitem{Garcia1982}
Garcia, C. E., \& Morari, M. (1982). Internal model control.
\textit{Ind. Eng. Chem. Process Des. Dev.}, 21(2), 308--323.

\bibitem{Bechouche2013}
Bechouche, A. (2013). \textit{Techniques neuronales pour l'identification et la
commande des systèmes dynamiques}. Thèse de doctorat, Université Mouloud Mammeri
de Tizi-Ouzou.

\end{thebibliography}

%==============================================================
\end{document}
%==============================================================