%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
%
% This is a LaTeX file for an A3 poster.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Asymptotic behavior of solutions to the generalized Becker-Döring
% equations for general initial data.
%
% Poster for the HYKE-3 meeting in Rome, 13-15 April 2005.
% 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\documentclass[20pt]{article}
% To modify the size of the page:
\usepackage[a3paper,landscape,centering,margin=2cm]{geometry}
\RequirePackage{graphicx}	% Pour importer des images
\RequirePackage{booktabs}	% Pour introduire des tableaux
\RequirePackage[toc,page]{appendix}	% Pour créer des appendices
%\RequirePackage[Bjornstrup]{fncychap} % Si on fait un report ou book
\RequirePackage{lmodern} 
\RequirePackage{fancyhdr}	% Des titres fouqués
\RequirePackage{lipsum}		% Mettre du texte lipsum, pour faire une maquette de rapport
\RequirePackage{framed}		% Des cadres pougnés
\RequirePackage{bm} % Du texte en gras bien fait
\RequirePackage{nomencl} % Faire une nomenclature
\RequirePackage[footnote]{acronym} % Des acronymes accessibles et définissables
\RequirePackage{epstopdf} 	% Utiliser le format .eps
\RequirePackage[pages=some]{background}	% Pour mettre un fond, pages=some permet de choisir les pages concernées
\RequirePackage{epsfig}	% Convertisseur eps à pdf
\RequirePackage{float}	% Pour avoir des tableaux qui restent dans leurs sections
\RequirePackage{graphicx}	% Importer image
\RequirePackage{array}		% Importer tableau
\RequirePackage{colortbl}		% Couleurs dans un tableau
\RequirePackage{array} 		% Pour des tableaux bien formatés
\RequirePackage{multirow}	 % Fusion des lignes dans les tableaux
\RequirePackage{titlesec}	% Macros pour changer le style des titres de section
\RequirePackage{sectsty}	% Changer le style des sections
\RequirePackage{caption}	% Macros pour changer le style des titres de figure
\RequirePackage{subcaption}	% Macros pour changer le style des sous-titres de figure
\RequirePackage{multicol}
\RequirePackage{babel} 

\RequirePackage{listings}		% Importer du code informatique et le travailler
\RequirePackage{amsmath, amssymb, amsfonts, amsthm, mathtools} % mathtools for: Aboxed (put box on last equation in align envirenment)
\RequirePackage{mathpazo} 	% La police d'écriture utilisée dans tout le document
\RequirePackage{mathrsfs}	% Pour des lettres (capitales) calligraphiées
\RequirePackage{siunitx}		% Des unités bien écrites, par exemple pour les valeurs numériques
\sisetup{locale = FR}		% Pour avoir les bonnes conventions typographiques des unités

\usepackage{minted}
\usepackage{lscape}
\usepackage{wrapfig}

\newcommand{\code}[1]{\mintinline[breaklines, breakafter=.]{python}{#1}}

% Colors
% -------
\definecolor{ENSBlue}{RGB}{0, 119, 139}
\definecolor{ENSJaunePorte}{RGB}{255, 180, 50}
\definecolor{ENSBleuCheminee}{RGB}{70, 35, 0}
\definecolor{ENSBrunBois}{RGB}{210, 160, 90}
\definecolor{ENSNoir}{RGB}{0, 0, 0}
\definecolor{ENSVertFenetre}{RGB}{130,  190, 50}
\definecolor{ENSGrisBeton}{RGB}{190, 190, 190}
\definecolor{ENSRougeBrique}{RGB}{240, 130, 90}
\definecolor{matlabGreen}{RGB}{28, 172, 0} % Pour le listing des codes
\definecolor{matlabLilas}{RGB}{170, 55, 241}


%------------------------------------------SECTIONS, FIGURES ET TABLEAUX------------------------------------------%

\sectionfont{\color{ENSBlue}\sffamily}  % Choisir la couleur des sections
\subsectionfont{\color{ENSRougeBrique}\sffamily\itshape}  % Choisir la couleur des sous-sections
\subsubsectionfont{\color{ENSRougeBrique}\sffamily\itshape}  % Choisir la couleur des sous-sections
\DeclareCaptionFont{CaptionENS}{\color{ENSRougeBrique}}
\captionsetup[table]{labelfont={CaptionENS,bf}}
\captionsetup[figure]{labelfont={CaptionENS,bf}}
\captionsetup[listing]{labelfont={CaptionENS,bf}}
\captionsetup[subfigure]{labelfont=bf,textfont=sf}

\pagestyle{empty}

\def\to{\rightarrow}

\newenvironment{cadregris}{ 
\def\FrameCommand{{\color{ENSBlue}\vrule width 3pt}\colorbox{ENSGrisBeton}}% 
\MakeFramed {\advance\hsize-\width \FrameRestore}}% 
{\endMakeFramed}

\title{}
\author{}
\date{}

\newcommand{\CC}{\emph{CC}}
\newcommand{\rto}{\emph{RTO}}
\newcommand{\rtt}{\emph{RTT}}
\newcommand{\iot}{\emph{IoT}}
\newcommand{\coapthon}{\emph{CoAPthon}}
\newcommand{\tf}{\emph{TensorFlow}}
\newcommand{\coap}{\emph{CoAP}}
\newcommand{\python}{\emph{Python}}

\begin{document}
%\maketitle

\begin{center}
  \begin{minipage}{.19\linewidth}
    \includegraphics[width=1\linewidth]{logo_ENSPS_UPS.png}
  \end{minipage}
  %&
  \begin{minipage}{.6\linewidth}
    \begin{center}
      \Huge \textbf{Schémas de contrôle de congestion intelligents pour les réseaux IoT par apprentissage profond}
    \end{center}
  \end{minipage}
  %&
  \hspace{.03\linewidth}
  \begin{minipage}{0.16\linewidth}
    \begin{flushright}
      Léopold Clément\\
      DER EEA\\
      École Normale Supérieure Paris-Saclay\\
      \vspace{.1cm} \small \emph{Encadré par :\\
      Mme Véronique \textsc{Vèque},\\ professeur des universités\\
      Mme Lynda \textsc{Zitoune},\\ maîtresse de conférences}
    \end{flushright}
  \end{minipage}
\end{center}

\vspace{.1cm}

% ---------------------------------------------------------------------------
\vfill
\setlength{\columnsep}{1cm}
\begin{multicols}{3}
\section*{Problématique}
\subsection*{Qu'es-ce que la congestion ?}
Dans un réseau, on échange des paquets d'informations.
Ces paquets transitent par plusieurs machines intermédiaires, les routeurs.
Les liens entre les machines n'ont pas une capacité infinie, il arrive donc que plus de paquets arrivent à un routeur qu'il ne peut en sortir.
Ils sont donc stockés temporairement dans des files dans la mémoire du routeur.
Si ces files sont trop longues, les paquets excédentaires sont supprimés.
Avec le protocole \coap{}, pour être sûr que les paquets envoyés vers une autre machine sont arrivés, on utilise un acquittement.
Ainsi pour chaque paquet de données reçu, on renvoie un paquet contenant l'identifiant du paquet de données (token) pour signaler qu'il est bien arrivé.
L'émetteur attend un temps donné (\rto{}); si l'acquittement n'est pas revenu avant la fin de ce temps, il renvoie le message, considérant qu'il a été perdu.

On peut ainsi mesurer le temps écoulé entre l'émission d'un paquet et la réception sont acquittement, c'est le \rtt{}.
Le \rtt{} est la somme de deux parties $RTT = \tau_{propagation} + \tau_{queue}$.
Le temps de propagation est fixe, le temps passé dans les queues dépend de la congestion du réseau.

\begin{center}
    \includegraphics[width = 0.8\linewidth]{puml/temporal_transaction_valide.png}
\end{center}

Un peu de congestion n'est pas mauvais, cela signifie que le réseau est utilisé à plein potentiel, trop de congestion crée des pertes de paquets.
Ces pertes sont mauvaises car en doit à nouveau envoyer le paquet, ce qui encombre davantage le réseau.
La gestion de congestion (\CC{}) désigne les méthodes pour conserver un fonctionnement optimal.

\subsection*{Quelles sont les contraintes de l`\iot{} ?}
On se trouve dans un système où une machine puissante (le cloud) interagit avec une multitude de machines peu puissantes, les capteurs.
Le cloud veut récuperer les données qu'ils contiennent.
Pour cela, il envoie une requête avec l'adresse de la donnée; le capteur répond avec un acquittement contenant le token et la valeur.

On ne peut pas faire tourner de code complexe sur les capteurs, tout doit se faire du côté du cloud.

\section*{Modélisation}
Pour contrôler le réseau, on modifie le \rto{} de chaque client grâce à un agent d'apprentissage par renforcement qui prend une matrice représentant le réseau, et renvoie un vecteur décrivant les modifications des \rto{} à réaliser.

La modélisation du réseau est similaire à celle de \cite{xiaoTCPDrincSmartCongestion2019}.
On considère que le nombre de capteurs est fixe.
On découpe le temps en une série d'intervalles de contrôle.
Pour chaque capteur et pour chaque intervalle de contrôle, on mesure tous les \rtt{} des transactions.
On construit aussi un filtrage exponentiel du \rtt{} , ainsi pour chaque nouveau \rtt{} $r$:\begin{align*}
    RTT_S &:= \alpha_S \cdot r + \left( 1 - \alpha_S \right) \cdot RTT_S \\
    RTT_L &:= \alpha_L \cdot r + \left( 1 - \alpha_L \right) \cdot RTT_L
\end{align*}
Puis on construit le vecteur suivant pour le capteur $i$ : \begin{equation}
    s ^ {\left( i \right)}= \begin{bmatrix}  \frac{n_{retransmission}}{n_{message}} \\ \frac{RTT_{min}}{\overline{RTT}} \\ \frac{RTT_S}{RTT_L} \end{bmatrix}
\end{equation}
Le premier terme représente la quantité de retransmissions, le second le temps passé dans les files, et le troisième la tendance d'évolution du \rtt{}.
Ensuite, les vecteurs sont concaténés pour construire une matrice $s_t$ représentant l'état global du réseau.

Soit $c_t$ les \rto{} à l'instant $t$ et $a_t$ l'action choisie par l'agent, alors :\begin{equation}
    c_{t+1} ^ {\left( i \right) }= c_t ^{\left( i \right)}\cdot \begin{cases}
      1 + a _ t ^ {\left( i \right)} & \text{si } a _ t ^{\left( i \right)} \ge 0 \\
      \frac{1}{1 - a _ t ^ {\left( i \right)}} & \text{si } a _ t ^{\left( i \right)} < 0
    \end{cases} 
\end{equation}
On quantifie la qualité d'un état de la manière suivante\begin{equation}
    r = - \beta _ \nu \frac{\sum_{k=1}^N n^e _ k}{\sum_{k=1}^N n^t_k} - \beta_\text{echec} n_\text{echec} - \beta_{RTT} max_{k} \overline{RTT} _ k + \beta_\text{equite} \frac{\left[ \sum_{k = 1}^N \frac{n^e_k}{n^t_k} \right] ^ 2 }{N \cdot \sum_{k = 1}^N \left( \frac{n^e_k}{n^t_k} \right)^2 }
    \label{eq:modèle:récompense}
\end{equation}
Ains on favorise les situations où il y a peu de retransmissions, des \rtt{} faibles, et une équité entre les capteurs.
L'équité\cite{jainQuantitativeMeasureFairness1998} s'assure qu'aucun capteur n'utilise plus de ressources que les autres.

\section*{Implémentation}
On utlise un module \python{} nommé \coapthon{} qui implémente la majorité du protocole \coap{} de base, auquel on ajoute notre couche d'apprentissage.
En effet, de base le \rto{} est constant.
Chaque client est associé à un superviseur qui surveille ses échanges de données, puis un superviseur global récupère toutes les données pour générer la matrice.
Le superviseur global distribue les actions une fois qu'elles sont calculées par l'agent.
On utilise une interface GYM pour la compatibilité.

\begin{center}
    \includegraphics[width = 0.4 \linewidth]{puml/struc_base.png}
\end{center}

De plus, \tf{} nous fournit tous les éléments pour créer un agent IA pour contrôler le système.
Il nous suffit de stocker des éléments du type $s_t, a_t,r_t, s_{t+1}$ et l'optimisation de la politque de l'agent se réalise tous les $1000$ pas de contrôle.
Le problème est qu'avec un intervalle de contrôle de $30 s$, l'optimisation a lieu toutes les $8 h$, ce qui n'est pas assez rapide.
Il faudrait donc développer un simulateur pour accélérer le pré-entrainement, avant de déployer le système sur le réseau réel, et que l'agent s'ajuste au fil du temps aux conditions réelles sur le réseau.

\section*{Expériences et résultats}
Des tests ont été réalisés avec un serveur \coap{} sur une \emph{RaspberryPi}.
On a pu constater que le réseau Wi-Fi était trop puissant pour être saturé, mais qu'il y avait tout de même de la congestion à cause de la capacité limitée de calcul du processeur.
Nos tests permettent tout de même de valider le choix de nos grandeurs représentatives de l'état du système.

\begin{center}
  \includegraphics[width=0.7   \linewidth]{png_img/varrtt_demo.png}
\end{center}
\bibliography{poster.bib}
\bibliographystyle{alpha-fr}	% Biblio en français
\selectlanguage{french}

\end{multicols}
\vfill
\end{document}
