
\usetheme[progressbar=frametitle, block=fill, subsectionpage=progressbar]{metropolis}
\usepackage{appendixnumberbeamer}

\usepackage{booktabs}
\usepackage[scale=2]{ccicons}

\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}

\title{Schémas de contrôle de congestion intelligents pour les réseaux IoT par apprentissage profond}
\subtitle{Soutenance de stage de \emph{M1}}
\date{\today}
%\date{}
\author{Léopold CLÉMENT}
\institute{L2S : CNRS / UPS / CentraleSupelec}
% \titlegraphic{\hfill\includegraphics[height=1.5cm]{logo.pdf}}

\setbeamercolor{alerted text}{fg=ENSRougeBrique}
\setbeamercolor{exemple text}{fg=ENSVertFenetre}
\setbeamercolor{frametitle}{bg=ENSBlue}


\setbeamercolor{progress bar}{fg=ENSJaunePorte, bg=ENSGrisBeton}

\usepackage{amsmath}
\usepackage{minted}
\usepackage{xspace}
\newcommand{\R}{\mathbb{R}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\Complexe}{\mathbb{C}}
\newcommand{\K}{\mathbb{K}}
\newcommand{\NN}{\mathcal{NN}}

\newcommand{\coap}{\emph{CoAP}}
\newcommand{\coapthon}{\emph{CoAPthon}}
\newcommand{\rtt}{\emph{RTT}}
\newcommand{\rto}{\emph{RTO}}
\newcommand{\varrtt}{\emph{VARRTT}}

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

\begin{document}

\maketitle

\begin{frame}[allowframebreaks]{Sommaire}
  \setbeamertemplate{section in toc}[sections numbered]
  \tableofcontents%[hideallsubsections]
\end{frame}
\section{Problématique}

\begin{frame}{Le laboratoire}
  Stage réalisé au Laboratoire des Signaux et Systèmes (L2S), au pôle télécoms et réseaux, dans l'équipe Réseaux, Optimisation Conjointe et codage de Source (ROCS).
\end{frame}

\begin{frame}{La congestion}
  \begin{columns}[c,onlytextwidth]
    \column{0.45\textwidth}
      Différence entre le nombre de paquets entrants et sortants dans un routeur.
      \pause
      \begin{exampleblock}{Résumé}
        Congestion = embouteillage de paquets.
      \end{exampleblock}
      \pause
    \column{0.45\textwidth}
      Les conséquence sont : \pause
      \begin{itemize}[<+->]
        \item l'allongement du \rtt{},
        \item la perte de paquets.
      \end{itemize} 
  \end{columns}

\end{frame}

\begin{frame}{Le \coap{}}
  \begin{columns}[c,onlytextwidth]
    \column{0.45\textwidth}
      \begin{figure}[htp]
        \centering
        \includegraphics[width=\textwidth]{puml/temporal_transaction_valide.png}
        \caption{Transaction \coap{}}
      \end{figure}
    \column{0.45\textwidth}
      Interface identique à \emph{HTTP}.
      Utilise \emph{UDP} et pas \emph{TCP}.
      \pause
      
      On attend un acquittement.
      Si le \rto{} s'écoule, on retransmet.
      \pause

      Le \rto{} est tiré aléatoirement dans un intervalle.
  \end{columns}
\end{frame}

\begin{frame}{L'apprentissage par renforcement}
  \begin{columns}[c,onlytextwidth]
    \column{0.45\textwidth}
      \begin{figure}[htp]
        \centering
        \includegraphics[width=\textwidth]{png_img/Markov_Decision_Process_example.png}
        \caption{processus markovien}
      \end{figure}
      \pause
    \column{0.45\textwidth}
      \begin{equation}
        R = \sum_{i = 1} ^\infty r _ i \gamma ^ i
        \label{eq:rl:R} 
      \end{equation}
    
      \pause
      On cherche $\pi : \mathbb{S} \rightarrow \mathbb{A}$ pour maximiser $R$.

      \pause
      \begin{itemize}[<+->]
        \item $s$ : l'observation,
        \item $a$ : l'action,
        \item $r$ : la récompense.
      \end{itemize}
  \end{columns}
\end{frame}

\section{Modélisation}
\begin{frame}{Structure du protocole}
  \begin{columns}[c,onlytextwidth]
    \column{0.45\textwidth}
    Utilisation : \pause
    \begin{itemize}[<+->]
      \item Obtention de $s_t$,
      \item calcul et application de $a_t = \pi(s_t)$,
      \item attente,
      \item calcul de $s_{t+1}$.
    \end{itemize}
    \pause
    \column{0.45\textwidth}
    Phase d'exploitation : \pause
    \begin{itemize}[<+->]
      \item Pré-entraînement,
      \item déploiement,
      \item entraînement en place.
    \end{itemize}
  \end{columns}
\end{frame}

\begin{frame}{Observations disponibles}
  On ne dispose que des \rtt{} et du nombre de retransmissions, ainsi on utilise :
  \begin{itemize}[<+->]
    \item $\eta = \frac{RTT_{min}}{\overline{RTT}}$
    \item $\nu = \frac{n_{retransmission}}{n_{message}}$
    \item $VARRTT = \frac{RTT_S}{RTT_L}$ à partir de \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 \\
    \alpha_S &\gg \alpha_L
    \end{align*}
  \end{itemize}
\end{frame}

\begin{frame}{Observations utilisées}
  Pour chaque capteur $i$ : \begin{equation}
    s ^ {\left( i \right)}= \begin{bmatrix} \nu\\ \eta \\ VARRTT \end{bmatrix}
  \end{equation}
  Pour le réseau total :\begin{equation}
    S = \begin{bmatrix} s ^ {(0)} & \cdots & s^{(N)} \end{bmatrix}
    \label{eq:modele:mat}
  \end{equation}
  Pour plus de détails, voir \cite{xiaoTCPDrincSmartCongestion2019}.

\end{frame}

\begin{frame}{Action}
  On choisi $\mathbb{A} = \R ^ N$.
  Soit $c_t$ le vecteur des \rto{}.
  \pause
  \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}

\end{frame}

\begin{frame}{Récompense}
  \begin{multline}
    r = - \beta _ \nu \cdot \frac{\sum_{k=1}^N n^e _ k}{\sum_{k=1}^N n^t_k}
    - \beta_\text{echec} \cdot n_\text{echec}
    - \beta_{RTT} max_{k} \cdot \overline{RTT} _ k\\
    + \beta_\text{equite} \cdot \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 }
  \end{multline}
  \pause
  \begin{block}{Équité}
    Le dernier terme est l'équité, c'est une mesure de la répartition équitable des ressources. \cite{jainQuantitativeMeasureFairness1998}
  \end{block}
\end{frame}

\section{Implémentation}
\begin{frame}{Modules}
  \begin{columns}[c,onlytextwidth]
    \column{0.30\textwidth}
      \begin{figure}[htp]
        \centering
        \includegraphics[width=\textwidth]{puml/struc_base.png}
        \caption{Utilisation des modules dans notre implémentation.}
      \end{figure}
    \column{0.65\textwidth}
      \begin{description}
        \item[CoAPthon] implémentation de \coap{} en Python.
        \item[TensorFlow] outils pour l'apprentissage machine.
      \end{description}
  \end{columns}
\end{frame}

\begin{frame}{Structure}
  \begin{figure}[htp]
    \centering
    \includegraphics[width = \textwidth,height=0.8\textheight,keepaspectratio]{puml/classe.png}
    \caption{Diagramme de classes de l'implémentation de notre protocole.}
  \end{figure}
\end{frame}

\begin{frame}{Les superviseurs}
  \begin{columns}[c,onlytextwidth]
    \column{0.45\textwidth}
      \code{SuperviseurLocal} : \begin{itemize}
        \item enregistre les \rtt{},
        \item enregistre les retransmissions,
        \item génère le vecteur d'état,
        \item fournit le \rto{} au client.
      \end{itemize}
    \column{0.45\textwidth}
      \code{SuperviseurGlobal} : \begin{itemize}
        \item génère la matrice,
        \item distribue les actions.
      \end{itemize}
  \end{columns}
\end{frame}

\begin{frame}{La classe \code{maquette}}
  Fournit une interface GYM grâce à \code{maquette.step(action)}.\pause
  \begin{block}{GYM}
    Permet la compatibilité avec d'autre type d'agent.
  \end{block}
\end{frame}

\section{Tests}
\begin{frame}{Durée de l'apprentissage}
  L'apprentissage est trop long pour être testé sans simulateur.
  \pause
  \begin{exampleblock}{Ordre de grandeur}
    Avec $1000$ : 
    $T_c = 30 s \Rightarrow T_p = 8 h$

    Avec $10000$ :$T_c = 30 s \Rightarrow T_p = 3j $
  \end{exampleblock}
\end{frame}

\begin{frame}{Distribution du \rtt{}}
  \begin{figure}[htp]
    \centering
    \includegraphics[width=0.7 \textwidth]{png_img/distri_rtt_distant.png}
    \caption{Distribution du \rtt{} et évolution de $RTT_L$ et $RTT_S$.}
    \label{fig:res:rtt_distant}
  \end{figure}
\end{frame}

\begin{frame}{Validation de \varrtt{}}
  \begin{figure}[htp]
    \centering
    \includegraphics[width=0.7 \textwidth]{png_img/varrtt_demo.png}
    \caption{Évolution de $VARRTT$ lors d'un changement de charge du réseau.}
    \label{fig:res:varrtt}
  \end{figure}
\end{frame}

\begin{frame}[standout]{} 
  Conclusion
\end{frame}

\appendix

\begin{frame}{OSI}
  \begin{table}[htp]
    \centering
    \caption{Le modèle OSI pour Internet, les couches principales.}
    \begin{tabular}{lll}
      \toprule
      Couche & Rôle & Protocole\\
      \midrule
      7 - Application & Utilisation finale & HTTP, ssh, CoAP...\\
      4 - Transport & CC \& multiplexage & TCP, UDP\\
      3 - Réseau & Routage & IP\\
      1 \& 2 - Physique & Support & Ethernet, Wi-Fi...\\
      \bottomrule
    \end{tabular}
  \end{table}
\end{frame}

\begin{frame}{OSI}
  \begin{table}[htp]
    \centering
    \caption{Le dilemme du prisonnier}
    \begin{tabular}{l|l|l}
      & Silence & Dénonce \\\hline
      Silence & $\left( 1 ; 1 \right)$ & $\left( 10 ; 0 \right)$ \\\hline
      Dénonce & $\left( 0 ; 10 \right)$ & $\left( 5 ; 5 \right)$ \\
    \end{tabular}
  \end{table}
\end{frame}

\begin{frame}{interface RestFull}
  \begin{description}
    \item[GET] demande une ressource,
    \item[POST, PUT] envoie une ressource,
    \item[DELETE] supprime une ressource,
    \item[OBSERVE] demande à etre tenu au courant des mise à jour d'une ressource.
  \end{description}
\end{frame}

\begin{frame}{Call Stack \coapthon{}}
  \begin{figure}[htp]
    \centering
    \includegraphics[width=1\linewidth]{puml/call_stack_envoie.png}
    \caption{Appel de fonction pour l'envoi d'une transaction \coapthon{}}
  \end{figure}
\end{frame}
