yay enkore du rapport

pdf/paper.tex

@@ -483,7 +483,7 @@ Face à ces inconvénients, et puisque nous ne possédons pas de grandes quantit
   \label{fig:vae-architecture}
 \end{figure}
 
-Les \glspl{vae}~\cite{kingma_auto-encoding_2022,kipf_variational_2016,doersch_tutorial_2021} constituent une autre famille de modèles génératifs, également bien connue comme les \glspl{gan}. Ces modèles reposent sur l'entraînement simultané de deux réseaux de neurones: un encodeur et un décodeur. L'objectif de l'encodeur est de transformer les données d'entrée en une distribution de probabilité, tandis que le décodeur génère de nouvelles données à partir de cette distribution. Comme pour les \glspl{gan}, ces modèles visent à estimer une distribution de données qui se rapproche le plus possible de la distribution des données d'entraînement, c'est-à-dire qu'ils apprennent à reproduire fidèlement les données d'origine.
+Les \glspl{vae}~\cite{kingma_auto-encoding_2022,kipf_variational_2016,doersch_tutorial_2021} constituent une autre famille de modèles génératifs, également bien connue comme les \glspl{gan}. Ces modèles reposent sur l'entraînement simultané de deux réseaux de neurones: un encodeur et un décodeur, visibles sur le figure~\ref{fig:vae-architecture}. L'objectif de l'encodeur est de transformer les données d'entrée en une distribution de probabilité, tandis que le décodeur génère de nouvelles données à partir de cette distribution. Comme pour les \glspl{gan}, ces modèles visent à estimer une distribution de données qui se rapproche le plus possible de la distribution des données d'entraînement, c'est-à-dire qu'ils apprennent à reproduire fidèlement les données d'origine.
 
 La particularité inhérente aux \glspl{vae} réside dans l'espace latent intermédiaire situé entre l'encodeur et le décodeur.
 La recherche sur l'interprétabilité des réseaux de neurones et leur visualisations~\cite{olah2017feature} établissent que les espaces latents permettent d'extraire les informations sous-jacentes (non directement perceptibles) des données d'entrée. Travailler sur ces informations s'avère avantageux car elles décrivent plus simplement les données d'entrée.
@@ -522,11 +522,11 @@ Tout comme les \glspl{gan}, de nombreuses améliorations (β-VAE~\cite{burgess_u
   \label{fig:nf-architecture}
 \end{figure}
 
-Les \glspl{nf}~\cite{kobyzev_normalizing_2021} constituent une autre catégorie de modèles génératifs qui ont suscité un intérêt croissant au cours des dernières années. Cette approche gagne en popularité du fait de sa capacité à opérer directement sur les densités de probabilité, ouvrant ainsi la voie au calcul précis des probabilités d'événements spécifiques. Ces modèles se basent sur des transformations inversibles, bijectives, continues et différentiables. Ces transformations sont appliquées à une distribution de base, généralement une distribution simple comme une gaussienne isotropique, pour obtenir une distribution plus complexe et plus proche de la distribution des données réelles.
+Les \glspl{nf}~\cite{kobyzev_normalizing_2021} constituent une autre catégorie de modèles génératifs qui ont suscité un intérêt croissant au cours des dernières années. Cette approche gagne en popularité du fait de sa capacité à opérer directement sur les densités de probabilité, ouvrant ainsi la voie au calcul précis des probabilités d'événements spécifiques. Ces modèles se basent sur des transformations inversibles, bijectives, continues et différentiables. Ces transformations, visibles sur la figure~\ref{fig:nf-architecture}, sont appliquées à une distribution de base, généralement une distribution simple comme une gaussienne isotropique, pour obtenir une distribution plus complexe et plus proche de la distribution des données réelles.
 
 Les transformations inversibles utilisées dans les \glspl{nf} sont souvent paramétrisées par des réseaux de neurones, ce qui permet d'apprendre des fonctions non linéaires. En utilisant plusieurs transformations en séquence, on peut construire des modèles génératifs capables de capturer des distributions complexes. En pratique, toutefois, les contraintes inhérentes à ces transformations limitent considérablement les architectures envisageables, restreignant ainsi la capacité de ces moddèles à surpasser les performances génératives d'autres méthodes.
 
-Dans la littérature, l'application de ces réseaux aux types de données qui nous intéressent est relativement limitée. De manière générale, leur utilisation est restreinte pour toutes les applications traitant des données de grande dimension. Une exception notable est représentée par PointFlow~\cite{yang_pointflow_2019} qui aura posé certaines bases pour évaluer les réseaux génératifs de nuages de points, notamment via la création d'un dataset de référence qui repose sur ShapeNet~\cite{shapenet2015}, un dataset décrivant une variété d'objets en trois dimensions, visibles sur la figure~\ref{fig:shapenet}, modifié par Furthest Point Sampling pour contenir uniquement 2048 points par nuages.
+Dans la littérature, l'application de ces réseaux aux types de données qui nous intéressent est relativement limitée. De manière générale, leur utilisation est restreinte pour toutes les applications traitant des données de grande dimension. Une exception notable est représentée par PointFlow~\cite{yang_pointflow_2019} qui aura posé certaines bases pour évaluer les réseaux génératifs de nuages de points, notamment via la création d'un dataset de référence qui repose sur ShapeNet~\cite{shapenet2015}, modifié par Furthest Point Sampling pour contenir uniquement 2048 points par nuages.
 
 \begin{figure}[h!]
   \centering
@@ -535,7 +535,7 @@ Dans la littérature, l'application de ces réseaux aux types de données qui no
   \label{fig:shapenet}
 \end{figure}
 
-Il existe cependant de nombreux autres datasets 3D, tels que ModelNet\cite{wu_3d_2015}, KITTI~\cite{liao_kitti-360_2022}, S3DIS~\cite{armeni_cvpr16} ou encore le récent Objaverse~\cite{deitke_objaverse_2022} et sa version XL~\cite{deitke_objaverse-xl_2023}.
+Il existe cependant de nombreux autres datasets 3D, tels que ModelNet\cite{wu_3d_2015}, KITTI~\cite{liao_kitti-360_2022}, S3DIS~\cite{armeni_cvpr16} ou encore le récent Objaverse~\cite{deitke_objaverse_2022} et sa version XL~\cite{deitke_objaverse-xl_2023}, visibles sur la figure~\ref{fig:shapenet}.
 
 \FloatBarrier
 \glsunset{vdm}
@@ -544,13 +544,11 @@ Il existe cependant de nombreux autres datasets 3D, tels que ModelNet\cite{wu_3d
 \begin{figure}[h!]
   \centering
   \includegraphics[width=0.8\textwidth]{vdm-architecture.png}
-  \caption{Architecture d'un \gls{vdm}.}
+  \caption{Architecture d'un \gls{vdm}~\cite{luo_understanding_2022}.}
-  \vspace*{-11pt}
-  \caption*{Source: Calvin Luo~\cite{luo_understanding_2022}.}
   \label{fig:vdm-architecture}
 \end{figure}
 
-Les \glspl{vdm} sont la famille de réseaux générateurs la plus récente et aussi la plus performante~\cite{dhariwal_diffusion_2021}. La manière la plus simple de décrire ces modèles est de les considérer comme une mélange des \glspl{vae} et des \glspl{nf}. En effet, le principe des \glspl{vdm} est de trouver un processus basé sur des transformation stochastiques, discrètes et réversible entre notre distribution de données et une distribution totalement différente, mais que l'on connait de préférence parfaitement mathématiquement.
+Les \glspl{vdm}~\cite{dhariwal_diffusion_2021} sont la famille de réseaux générateurs la plus récente et aussi la plus performante. La manière la plus simple de décrire ces modèles est de les considérer comme une mélange des \glspl{vae} et des \glspl{nf}. En effet, le principe des \glspl{vdm} est de trouver un processus basé sur des transformation stochastiques, discrètes et réversible entre notre distribution de données et une distribution totalement différente, mais que l'on connait de préférence parfaitement mathématiquement.
 
 Plusieurs catégories de modèles sont disponibles pour aborder le problème de la diffusion, parmi lesquelles émerge la plus reconnue, à savoir les \glspl{ddpm}~\cite{ho_denoising_2020}. Cette approche vise à identifier une correspondance entre les données observées et une distribution gaussienne standard. Ce processus est appris au moyen d'un modèle paramétrique (i.e. un réseau de neurones).
 
@@ -584,7 +582,7 @@ avec:
 \end{equation}
 On peut finalement simplifier cette expression via une reparamétrisation:
 \begin{equation}
-  \boldsymbol{x}_0 = \frac{ \boldsymbol{x}_T - \sqrt{1 - \overline{\alpha}_t} \epsilon_0 } { \sqrt{\overline{\alpha}_t} } \implies \mu_q (\boldsymbol{x}_t, \boldsymbol{x}_0) = \frac{ 1 } { \sqrt{\alpha} } \boldsymbol{x}_t - \frac{ 1 - \alpha_t } { \sqrt{ 1 - \overline{\alpha}_t } \sqrt{\alpha_t} } \epsilon_0
+  \boldsymbol{x}_0 = \frac{ \boldsymbol{x}_T - \sqrt{1 - \overline{\alpha}_t} \epsilon_0 } { \sqrt{\overline{\alpha}_t} } \implies \mu_q (\boldsymbol{x}_t, \boldsymbol{x}_0) = \frac{ 1 } { \sqrt{\alpha_t} } \boldsymbol{x}_t - \frac{ 1 - \alpha_t } { \sqrt{ 1 - \overline{\alpha}_t } \sqrt{\alpha_t} } \epsilon_0
 \end{equation}
 Si l'on réeffectue une dérivation de l'\gls{elbo} avec ces nouvelles expressions, on en conclut qu'il suffit de trouver une approximation $\epsilon_\theta (\boldsymbol{x}_t, t) \approx \epsilon_0$. En pratique on utilise un réseau de neurones que l'on entraine à minimiser $\| \epsilon_0 - \epsilon_\theta (\boldsymbol{x}_t, t) \|_2^2$. Une fois cette approximation trouvée, on peut facilement remonter à $p_\theta (\boldsymbol{x}_{t-1} | \boldsymbol{x}_t)$. Formellement, l'entrainement de ce réseau de neurones est décrit dans l'algorithme \ref{alg:ddpm_training}.
 
@@ -593,8 +591,8 @@ Si l'on réeffectue une dérivation de l'\gls{elbo} avec ces nouvelles expressio
   \label{alg:ddpm_training}
   \begin{algorithmic}[1]
     \Require $T \in \mathbb{N}^\star$: number of diffusion steps
+    \Require $\alpha_t \in \mathbb{R}^T$: variance schedule
     \Require $\boldsymbol{x}_0$: data distribution to be learned
-    \Require $\alpha_t$: variance schedule
     \Require $\epsilon_\theta$: neural network
     \Repeat
     \State $x_0 \sim \boldsymbol{x_0}$
@@ -602,6 +600,7 @@ Si l'on réeffectue une dérivation de l'\gls{elbo} avec ces nouvelles expressio
     \State $\epsilon \sim \mathcal{N}(0, \mathbf{I})$
     \State take gradient step on $\displaystyle \nabla_\theta \| \epsilon - \epsilon_\theta ( \sqrt{\overline{\alpha}_t} x_0 + \sqrt{1 - \overline{\alpha}_t} \epsilon, t ) \|_2^2$
     \Until{converged}
+    \State \Return $\epsilon_\theta$
   \end{algorithmic}
 \end{algorithm}
 
@@ -612,7 +611,7 @@ Après avoir achevé l'entraînement adéquat de notre modèle, on peut désorma
   \label{alg:ddpm_sampling}
   \begin{algorithmic}[1]
     \Require $T \in \mathbb{N}^\star$: number of diffusion steps
-    \Require $\alpha_t$: variance schedule
+    \Require $\alpha_t \in \mathbb{R}^T$: variance schedule
     \Require $\epsilon_\theta$: trained neural network
     \State $x_T \sim \mathcal{N}(0, \mathbf{I})$
     \For{$t=T, ..., 1$}
@@ -625,7 +624,7 @@ Après avoir achevé l'entraînement adéquat de notre modèle, on peut désorma
   \end{algorithmic}
 \end{algorithm}
 
-Il est possible de démontrer théoriquement~\cite{luo_understanding_2022} l'équivalence entre les \glspl{vdm} et les méthodes de score matching~\cite{song_generative_2020} lorsque $T$ tend vers l'infini. Les méthodes de score matching, constituent une famille de techniques permettant l'estimation de la densité de probabilité associée à un ensemble de données. Elles se basent exclusivement sur le calcul du gradient de cette densité de probabilité, éliminant ainsi la nécessité du calcul laborieux d'une constante de normalisation. Une fois le gradient estimé (e.g. via un réseau de neurones), la densité de probabilité peut être retrouvée au moyen de méthodes d'échantillonnage telles que la méthode de recuit de Langevin~\cite{song_generative_2020}.
+Il est possible de démontrer théoriquement~\cite{luo_understanding_2022} l'équivalence entre les \glspl{vdm} et les méthodes de score matching~\cite{song_generative_2020} lorsque $T$ tend vers l'infini. Les méthodes de score matching, constituent une famille de techniques permettant l'estimation de la densité de probabilité associée à un ensemble de données. Elles se basent exclusivement sur le calcul du gradient de cette densité de probabilité, éliminant ainsi la nécessité du calcul laborieux d'une constante de normalisation. Une fois le gradient estimé (e.g. via un réseau de neurones), la densité de probabilité peut être retrouvée au moyen de méthodes d'échantillonnage telles que la méthode du recuit de Langevin~\cite{song_generative_2020}.
 
 \FloatBarrier
 \glsunset{ldm}
@@ -634,9 +633,7 @@ Il est possible de démontrer théoriquement~\cite{luo_understanding_2022} l'éq
 \begin{figure}[h!]
   \centering
   \includegraphics[width=6cm]{ldm-compression.jpg}\hspace*{5mm}\includegraphics[width=10cm]{ldm-architecture.png}
-  \caption{Architecture d'un \gls{ldm}.}
+  \caption{Architecture d'un \gls{ldm}~\cite{rombach_high-resolution_2022}.}
-  \vspace*{-11pt}
-  \caption*{Source: Rombach \& Blattmann, et al.~\cite{rombach_high-resolution_2022}.}
   \label{fig:ldm-architecture}
 \end{figure}
 
@@ -674,7 +671,7 @@ On identifie alors:
   \includegraphics[width=0.8\textwidth]{classifier-guidance.png}
   \caption{Gradients de $f_\phi (y | \boldsymbol{x}_t)$ de la \gls{cg}.}
   \vspace*{-11pt}
-  \caption*{Source: \href{https://perceptron.blog/defusing-diffusion/}{Perceptron.blog, 2023}.}
+  \caption*{Source: \href{https://perceptron.blog/defusing-diffusion/}{Paweł Pierzchlewicz, 2023}.}
   \label{fig:classifier_guidance}
 \end{figure}
 
@@ -695,7 +692,7 @@ On en déduit de \ref{eq:cfg_lerp}, que la distribution conditionnelle est une i
   \includegraphics[width=0.8\textwidth]{classifier-free-guidance.png}
   \caption{Gradients conditionnés et non conditionnés via la \gls{cfg}.}
   \vspace*{-11pt}
-  \caption*{Source: \href{https://perceptron.blog/defusing-diffusion/}{Perceptron.blog, 2023}.}
+  \caption*{Source: \href{https://perceptron.blog/defusing-diffusion/}{Paweł Pierzchlewicz, 2023}.}
   \label{fig:classifier_free_guidance}
 \end{figure}
 
@@ -712,9 +709,9 @@ Formellement, l'algorithme d'entraînement par \gls{cfg} est décrit dans l'algo
   \label{alg:classifier-free-guidance}
   \begin{algorithmic}[1]
     \Require $T \in \mathbb{N}^\star$: number of diffusion steps
+    \Require $\alpha_t \in \mathbb{R}^T$: variance schedule
     \Require $\boldsymbol{x}_0$: data distribution to be learned
     \Require $\boldsymbol{c}$: embeddings distribution to be learned
-    \Require $\alpha_t$: variance schedule
     \Require $\epsilon_\theta$: neural network
     \Require $p_\text{uncond}$: probability of unconditional training
     \Repeat
@@ -724,6 +721,7 @@ Formellement, l'algorithme d'entraînement par \gls{cfg} est décrit dans l'algo
     \State $\epsilon \sim \mathcal{N}(0, \mathbf{I})$
     \State take gradient step on $\nabla_\theta \| \epsilon - \epsilon_\theta ( \sqrt{\overline{\alpha}_t} x_0 + \sqrt{1 - \overline{\alpha}_t} \epsilon, t, c ) \|_2^2$
     \Until{converged}
+    \State \Return $\epsilon_\theta$
   \end{algorithmic}
 \end{algorithm}
 
@@ -733,13 +731,13 @@ Formellement, l'algorithme d'entraînement par \gls{cfg} est décrit dans l'algo
   \begin{algorithmic}[1]
     \Require $T \in \mathbb{N}^\star$: number of diffusion steps
     \Require $\gamma \in \mathbb{R}$: guidance factor
-    \Require $\boldsymbol{c}$: embeddings distribution to be learned
+    \Require $\alpha_t \in \mathbb{R}^T$: variance schedule
-    \Require $\alpha_t$: variance schedule
+    \Require $c$: class embeddings
     \Require $\epsilon_\theta$: trained neural network
     \State $x_T \sim \mathcal{N}(0, \mathbf{I})$
     \For{$t=T, ..., 1$}
     \State $\epsilon_\theta = \gamma \epsilon_\theta(x_t, t, c) + (1 - \gamma) \epsilon_\theta(x_t, t, \varnothing)$
-    \State $\displaystyle \mu_t = \frac{ 1 } { \sqrt{\alpha} } \boldsymbol{x}_t - \frac{ 1 - \alpha_t } { \sqrt{ 1 - \overline{\alpha}_t } \sqrt{\alpha_t} } \epsilon_\theta$
+    \State $\displaystyle \mu_t = \frac{ 1 } { \sqrt{\alpha_t} } \boldsymbol{x}_t - \frac{ 1 - \alpha_t } { \sqrt{ 1 - \overline{\alpha}_t } \sqrt{\alpha_t} } \epsilon_\theta$
     \State $\displaystyle \sigma_t = \sqrt{ \frac{ (1 - \alpha_t)(1 - \overline{\alpha}_{t-1}) } { 1 - \overline{\alpha}_t } }$
     \State $\epsilon \sim \mathcal{N}(0, \mathbf{I})\ \text{if}\ t > 1, \text{else}\ \epsilon = 0$
     \State $x_{t-1} = \mu_t + \sigma_t \epsilon$
@@ -872,22 +870,24 @@ La stack technique utilisée par l'équipe est basée sur Python, avec des bibli
 \end{figure}
 
 L'une de nos premières initiatives a été de tester des réseaux basés sur les \glspl{vae}. Après avoir lu des articles de recherche sur les \glspl{vae}, j'ai réalisé plusieurs implémentations sur des images pour me refamiliariser avec ces concepts.
-Nous avons ensuite étendu ces expérimentations à des architectures spécifiques aux graphes via GraphVae~\cite{simonovsky_graphvae_2018}. Les résultats obtenus étaient encourageants: le réseau était capable de générer des structures, mais la qualité des générations n'était pas exceptionnelle. De plus, nous avons constaté que le réseau était beaucoup trop volumineux par rapport à sa fonctionnalité.
+Nous avons ensuite étendu ces expérimentations à des architectures spécifiques aux graphes via GraphVAE~\cite{simonovsky_graphvae_2018}. Les résultats obtenus étaient encourageants, le réseau était capable de générer des structures, mais la qualité des générations n'était pas exceptionnelle comme visible sur la figure~\ref{fig:graphvae_results}.
+
+En effet, les générations produites étaient globalement correctes, cependant, elles présentaient d'importantes anomalies dans les régions où la densité de points était élevée. De manière similaire, le réseau présentait une forte tendance au surapprentissage, manifestant une rapide convergence vers des générations excessivement similaires les unes aux autres. De plus, le dimensionnement du réseau (environ 4 millions de paramètres) était disproportionné par rapport à son objectif fonctionnel.
 
 \begin{figure}[h!]
   \centering
-  {\Huge \calligra Fuck Rosetta}
+  \includegraphics[width=0.45\textwidth]{graphvae_front.png} \includegraphics[width=0.45\textwidth]{graphvae_top.png}
   \caption{Résultats de GraphVAE sur Rotor37\_1200.}
-  \label{fig:graphvar_results}
+  \label{fig:graphvae_results}
 \end{figure}
 
-En effet, dans le contexte des graphes, les opérations de ``upsampling" n'existent pas de manière uniquel. Par conséquent, nous avons rencontré des difficultés lors du passage du vecteur latent (représentant une distribution gaussienne) à une représentation sous forme de graphe (noeuds + connectivité) dans le décodeur du \gls{vae}.
+En effet, dans le contexte des graphes, les opérations de ``upsampling" n'existent pas de manière unique. Par conséquent, nous avons rencontré des difficultés lors du passage du vecteur latent (représentant une distribution gaussienne) à une représentation sous forme de graphe (noeuds + connectivité) dans le décodeur du \gls{vae}.
 
-Une première solution simple consistait en l'utilisation de une ou plusieurs couches denses (\glspl{mlp}) pour convertir le vecteur latent en un couple de matrices décrivant les positions et la connectivité des noeuds. Cependant, cette approche posait problème en raison de la taille des graphes que nous manipulions. En effet, avec des graphes de $n = \SI{3.0e4}{}$ nœuds, cela impliquait une matrice de connectivité de taille $n^2 = \SI{9.0e8}{}$, ce qui faisait aisaiment exploser la complexité lorsque nous utilisions des couches denses.
+Une première solution simple consistait en l'utilisation de un ou plusieurs \glspl{mlp} pour convertir le vecteur latent en un couple de matrices décrivant les positions et la connectivité des noeuds. Cependant, cette approche posait problème en raison de la taille des graphes que nous manipulions. En effet, avec des graphes de $n = \SI{3.0e4}{}$ nœuds, cela impliquait une matrice de connectivité de taille $n^2 = \SI{9.0e8}{}$, ce qui faisait aisaiment exploser la complexité lorsque nous utilisions plusieurs \glspl{mlp}.
 
 Pour donner un ordre de grandeur, si l'on utilisait un espace latent de taille $8$, rien que pour prédire les positions 3D des points dans notre maillage (sans prendre en compte la connectivité), l'utilisation d'une seule couche dense impliquait déjà $\SI{7.2e6}{}$ paramètres. Prédire la connectivité était tout simplement impossible, car il aurait fallu une couche dense avec plus de $\SI{7.2e9}{}$ paramètres, ce qui dépassait largement les capacités de calcul de nos ressources GPU.
 
-Une seconde solution consitait à utiliser une architecture plus intelligente, telle que Graph U-Net~\cite{gao_graph_2019}. Cette approche permettait d'éviter l'utilisation de couches denses dans le décodeur grâce à des connexions résiduelles (skip connections). Cependant, ce faisant l'information ne passait pas entièrement par l'espace latent entre le décodeur et l'encodeur. Par conséquent, il était impossible de créer un modèle génératif complet avec cette architecture, puisqu'une partie de l'information pour générer des échantillons était compris dans les skip connections.
+Une seconde solution consitait à utiliser une architecture plus intelligente, telle que Graph U-Net~\cite{gao_graph_2019}, visible dans la figure~\ref{fig:graphunet_archi}. Cette approche permettait d'éviter l'utilisation de couches denses dans le décodeur grâce à des connexions résiduelles (skip connections). Cependant, ce faisant l'information ne passait pas entièrement par l'espace latent entre le décodeur et l'encodeur. Par conséquent, il était impossible de créer un modèle génératif complet avec cette architecture, puisqu'une partie de l'information pour générer des échantillons était compris dans les skip connections.
 
 \begin{figure}[h!]
   \centering
@@ -896,14 +896,16 @@ Une seconde solution consitait à utiliser une architecture plus intelligente, t
   \label{fig:graphunet_archi}
 \end{figure}
 
-Face aux difficultés rencontrées avec les réseaux basés sur les VAE et les limitations de l'architecture Graph U-Net, nous avons pris la décision de mettre de côté ces approches. Et plus largement puisque la connectivité de nos graphes est ``locale" (les noeuds des nos maillages sont connectés à leurs voisins proches dans l'espace), nous avons décidé de nous orienter vers des approches basées uniquement sur les positions des noeuds. En effet, la connectivité d'un nuage de points peut être retrouvé via diverses techniques~\cite{peng_shape_2021,sulzer_deep_2022,andrade-loarca_poissonnet_2023}.
+Face aux difficultés rencontrées avec les réseaux basés sur les VAE et les limitations de l'architecture Graph U-Net, nous avons pris la décision de mettre de côté ces approches. Et plus largement puisque la connectivité de nos graphes est ``locale" (les noeuds des nos maillages sont connectés à leurs voisins proches dans l'espace), nous avons décidé de nous orienter vers des approches basées uniquement sur les positions des noeuds. En effet, la connectivité d'un nuage de points peut être retrouvée via diverses techniques~\cite{peng_shape_2021,sulzer_deep_2022,andrade-loarca_poissonnet_2023}.
 
 \FloatBarrier
 \subsection{Présentation de PointNet}
 
-Dans le contexte de l'apprentissage sur les nuages de points, une architecture standard est PointNet. PointNet est une architecture basée sur des shared \glspl{mlp} (pouvant être envisagés comme des convolutions à noyau 1x1), qui permettent de traiter des nuages de points, indépendemment du nombre de points. Cette architecture présente un intérêt notable du fait de son invariance par permutation, ainsi que de sa résilience face à certaines transformations telles que les rotations et les translations.
+Dans le contexte de l'apprentissage sur les nuages de points, une architecture standard est PointNet~\cite{qi_pointnet_2017}. PointNet est une architecture basée sur des shared \glspl{mlp} (pouvant être envisagés comme des convolutions à noyau 1x1), qui permettent de traiter des nuages de points, indépendemment du nombre de points. Cette architecture présente un intérêt notable du fait de son invariance par permutation, ainsi que de sa résilience face à certaines transformations telles que les rotations et les translations.
 
-Par la suite, une avancée significative du modèle PointNet a conduit à l'émergence de PointNet++, qui est désormais reconnu comme l'architecture de référence dans ce domaine. PointNet++ propose une approche hiérarchique en profondeur qui combine judicieusement des techniques d'échantillonnage (telles que le Furthest Point Sampling) et d'agrégation (comme la recherche des K Nearest Neighbors) appliquées aux points du nuage. Cette approche vise à étendre la portée des opérations locales de manière à englober des champs réceptifs globaux, contribuant ainsi à l'amélioration des performances du réseau.
+Par la suite, une avancée significative du modèle PointNet a conduit à l'émergence de PointNet++~\cite{qi_pointnet_2017-1}, qui est désormais reconnu comme l'architecture de référence dans ce domaine. PointNet++ propose une approche hiérarchique en profondeur qui combine judicieusement des techniques d'échantillonnage (telles que le Furthest Point Sampling) et d'agrégation (comme la recherche des K Nearest Neighbors) appliquées aux points du nuage. Cette approche vise à étendre la portée des opérations locales de manière à englober des champs réceptifs globaux, contribuant ainsi à l'amélioration des performances du réseau.
+
+Ces deux architectures sont illustrées sur la figure~\ref{fig:pointnet_archi}.
 
 \begin{figure}[h!]
   \centering
@@ -915,7 +917,7 @@ Par la suite, une avancée significative du modèle PointNet a conduit à l'éme
 \FloatBarrier
 \subsection{Présentation des \acrfullpl*{kpconv}}
 
-Une autre architecture largement reconnue dans le domaine du traitement de nuages de points, présentant des similitudes avec PointNet++, est nommée \gls{kpconv}~\cite{thomas_kpconv_2019}. Cette architecture utilise un échantillonnage basé sur une grille de voxels et des opérations d'agrégation via des \glspl{kpconv}, qui sont des convolutions sur boules. Les auteurs de \gls{kpconv} proposent deux architectures, \gls{kpconv} permettant de traiter des problèmes de classification, et \gls{kpfcnn} permettant de traiter des problèmes de segmentation. Ces deux architectures sont illustrées sur la figure~\ref{fig:kpconv_archi}.
+Une autre architecture largement reconnue dans le domaine du traitement de nuages de points, présentant des similitudes avec PointNet++, est nommée \gls{kpconv}~\cite{thomas_kpconv_2019}. Cette architecture utilise un échantillonnage basé sur une grille de voxels et des opérations d'agrégation via des \glspl{kpconv}, qui sont des convolutions sur boules. Les auteurs de \gls{kpconv} proposent deux architectures, \gls{kpcnn} permettant de traiter des problèmes de classification, et \gls{kpfcnn} permettant de traiter des problèmes de segmentation. Ces deux architectures sont illustrées sur la figure~\ref{fig:kpconv_archi}.
 
 \begin{figure}[h!]
   \centering
@@ -951,10 +953,10 @@ Autre point négatif, le decodeur de \gls{kpfcnn} étant composé de \glspl{mlp}
   \label{fig:pvconv_archi}
 \end{figure}
 
-Une seconde alternative aux opérations de convolutions et d'aggregation de PointNet++ sont les \glspl{pvconv}~\cite{liu_point-voxel_2019}. Les \glspl{pvconv} proposent d'utiliser des voxels afin de retomber sur des structures régulières, permettant ainsi d'effectuer efficacement des convolutions classiques en 3D. Par conséquent, une \gls{pvconv} est composée de deux branches distinctes. La première branche, appelée ``coarse-grained", transforme les points en voxels, applique des convolutions, puis reconvertit les voxels en points à l'aide d'une interpolation trilinéaire. La seconde branche, nommée ``fine-grained", est constituée de shared \glspl{mlp}. Ces deux branches sont ensuite combinées par sommation.
+Une seconde alternative aux opérations de convolutions et d'aggregation de PointNet++ sont les \glspl{pvconv}~\cite{liu_point-voxel_2019}. Les \glspl{pvconv} proposent d'utiliser des voxels afin de retomber sur des structures régulières, permettant ainsi d'effectuer efficacement des convolutions classiques en 3D. Par conséquent, une \gls{pvconv} est composée de deux branches distinctes, visibles sur la figure~\ref{fig:pvconv_archi}. La première branche, appelée ``coarse-grained", transforme les points en voxels, applique des convolutions, puis reconvertit les voxels en points à l'aide d'une interpolation trilinéaire. La seconde branche, nommée ``fine-grained", est constituée de shared \glspl{mlp}. Ces deux branches sont ensuite combinées par sommation.
 
 Par conséquent, PVCNN peut être considéré comme l'équivalent de PointNet, tandis que PVCNN++ correspond à PointNet++. Cependant, ces deux réseaux basés sur des \glspl{pvconv} se distinguent par le maintien d'un nombre constant de points dans chaque couche du réseau. Les benchmarks démontrent que PVCNN++ est au moins aussi performant que PointNet++, tout en surpassant nettement ce dernier en termes d'efficacité globale. Cependant, il est important de noter que l'implémentation de PVCNN++ est assez complexe et nécessite l'utilisation de plusieurs modules CUDA (les opérations de voxelization et de dévoxelization étant impossible à écrire en PyTorch classique).
-Une version légèrement améliorée de \gls{pvconv}, appelée \gls{spvconv}, a également été développée en utilisant des opérations de convolution éparses. En effet, on observe empiriquement que les grilles de voxels sont fréquemment remplies en moyenne à hauteur de 60\%. Cependant, ces améliorations nécessitent l'utilisation de code CUDA très ésotérique.
+Une version légèrement améliorée de \gls{pvconv}, appelée \gls{spvconv}, a également été développée en utilisant des opérations de convolution éparses. En effet, on observe empiriquement que les grilles de voxels sont fréquemment remplies en moyenne à hauteur de 60\%. Cependant, cete amélioration nécessite l'utilisation de code CUDA très ésotérique.
 
 \FloatBarrier
 \subsection{Test de \acrfull*{pvd}}
@@ -975,11 +977,11 @@ Le premier papier ayant utilisé une architecture du type PVCNN++ pour la géné
   \label{fig:pvd_results}
 \end{figure}
 
-Comme on l'observe sur la figure~\ref{fig:pvd_results}, les générations que produisent \gls{pvd} sont de très bonne qualité. Contrairement à \gls{kpfcnn}, les générations ne présentent pas de bruits résiduels, la densité des points générés correspond à celle présente dans les données d'entrainement, cependant on remarque quand même quelques points au centre de l'aube, ce qui pourrait impacter la reconstruction d'un maillage. De plus, \gls{pvd} est un réseau assez lourd, (27,6 millions de paramètres) et nécéssite un entrainement plutot long d'environ 10 heures pour produire de bon résultats.
+Comme on l'observe sur la figure~\ref{fig:pvd_results}, les générations que produisent \gls{pvd} sont de très bonne qualité. Contrairement à \gls{kpfcnn}, les générations ne présentent pas de bruits résiduels et la densité des points générés correspond à celle présente dans les données d'entrainement. On remarque tout de même quelques points anormales à l'intérieur de l'aube, ce qui pourrait impacter la reconstruction d'un maillage. De plus, \gls{pvd} est un réseau assez lourd (27,6 millions de paramètres), et nécéssite un entrainement plutot long d'environ 10 heures pour produire de bon résultats.
 
 \FloatBarrier
 \glsunset{ldm}
-\subsection{Test de \acrfull*{lion}}
+\subsection{Présentation de \acrfull*{lion}}
 
 \begin{figure}[h!]
   \centering
@@ -988,25 +990,20 @@ Comme on l'observe sur la figure~\ref{fig:pvd_results}, les générations que pr
   \label{fig:lion_archi}
 \end{figure}
 
-\gls{lion}~\cite{zeng_lion_2022} représente l'architecture la plus récente en matière de génération de nuages de points, et constitue une amélioration par rapport à \gls{pvd}. \gls{lion} exploite la diffusion latente via un \gls{vae} à deux étages pour comprimer les nuages de points avant d'appliquer le processus de diffusion.
+\gls{lion}~\cite{zeng_lion_2022} représente l'architecture la plus récente en matière de génération de nuages de points, et constitue une amélioration par rapport à \gls{pvd}. \gls{lion} exploite la diffusion latente via un \gls{vae} à deux étages pour transformer les nuages de points avant d'appliquer le processus de diffusion. L'architecture de \gls{lion} est illustré sur la figure~\ref{fig:lion_archi}.
 Un premier encodeur transforme le nuage de points en un vecteur latent.
 Un deuxième encodeur transforme le nuage de points original, en utilisant le vecteur latent comme conditionnement, afin de générer un nuage de points latent.
 Ce nuage de points latent est ensuite décodé pour obtenir une reconstruction du nuage de point original.
 Le processus de diffusion a lieu à la fois sur le vecteur latent et sur le nuage de points latent.
 
-\begin{figure}[h!]
+\gls{lion} est prometteur, cependant son entrainement est excessivement long, et peut prendre jusqu'à plusieurs semaines. Pour ces raisons, nous n'avons pas pu tester \gls{lion} sur Rotor37\_1200.
-  \centering
-  {\Huge \calligra Fuck Rosetta}
-  \caption{Résultats de \gls{lion} sur Rotor37\_1200.}
-  \label{fig:lion_results}
-\end{figure}
 
 \FloatBarrier
 \subsection{Synthèse des méthodes}
 
-Les résultats antérieurs démontrent la faisabilité de la résolution de notre problématique. Cependant, la plupart des approches précédentes se concentrent sur la génération non conditionnée ou utilisent des one-hot vectors pour le conditionnement sur des classes discrètes. Étant donné que notre objectif est de conditionner à l'aide de vecteurs scalaires, et étant donné que les implémentations précédemment présentées s'avèrent complexes à manipuler, nous avons pris la décision de développer notre propre mise en œuvre. En outre, il convient de noter que les modèles précédemment proposés sont souvent caractérisés par un nombre élevé de paramètres, ce qui s'avère excessif pour notre problématique, laquelle demeure comparativement plus simple.
+Les résultats antérieurs démontrent la faisabilité de la résolution de notre problématique. Cependant, la plupart des approches précédentes se concentrent sur la génération non conditionnée ou utilisent des one-hot vectors pour le conditionnement sur des classes discrètes. Étant donné que notre objectif est de conditionner sur des métriques physiques scalaires, et étant donné que les implémentations précédemment présentées s'avèrent complexes à manipuler, nous avons pris la décision de développer notre propre réseau. De plus, il convient de noter que les modèles précédemment proposés sont souvent caractérisés par un nombre élevé de paramètres, ce qui s'avère excessif pour notre problématique, laquelle demeure comparativement plus simple.
 
-Nous avons décidé d'adopter une approche reposant sur la réduction de dimension, via les \gls{ldm}. Pour ce faire, il était crucial de choisir un modèle capable de transformer ou de réduire nos données d'entrée. Dans cette optique, nous avons opté pour une première étape de réduction par \gls{pca}. Il convient d'ailleurs de souligner que cette approche présente l'avantage d'être non paramétrique, éliminant ainsi la nécessité d'un processus d'optimisation.
+Nous avons décidé d'adopter une approche reposant sur la réduction de dimension, via les \gls{ldm}. Pour ce faire, il était crucial de choisir un modèle capable de transformer ou de réduire nos données d'entrée. Dans cette optique, nous avons opté pour une première étape de réduction de dimension par \gls{pca}. Il convient d'ailleurs de souligner que cette approche présente l'avantage d'être non paramétrique, éliminant ainsi la nécessité d'un processus d'optimisation.
 
 \begin{figure}[h!]
   \centering
@@ -1027,7 +1024,7 @@ Cependant, dans le contexte industriel, cet inconvénient est moins préoccupant
 \glsunset{cfg}
 \subsection{Conditionnement par \acrfull*{cfg}}
 
-Pour conditionner notre processus de diffusion, nous avons opté pour l'utilisation de la \gls{cfg}, avec une probabilité de $p_\text{uncond}$ pour le dropout des embeddings. Pour intégrer les embeddings de conditionnement dans notre réseau, nous avons suivi une approche similaire à celle utilisée pour les embeddings de pas de temps. Les modifications apportées modifient très peu la surface de coût du réseau, et nous sommes désormais en mesure de générer des aubes tant non conditionnées que conditionnées, en fonction d'un vecteur scalaire de performances. Les résultats visuels des générations demeurent satisfaisants. Toutefois, il est difficile de déterminer visuellement si les aubes conditionnées générées respectent effectivement les critères de conditionnement qui leur sont assignés.
+Pour conditionner notre processus de diffusion, nous avons opté pour l'utilisation de la \gls{cfg}, avec une probabilité $p_\text{uncond}$ de 10\%. Pour intégrer les embeddings de conditionnement dans notre réseau, nous avons suivi une approche similaire à celle utilisée pour les embeddings de pas de temps. Les modifications apportées modifient très peu la surface de coût du réseau, et nous sommes désormais en mesure de générer des aubes tant non conditionnées que conditionnées, en fonction d'un vecteur scalaire de metriques physiques. Les résultats visuels des générations demeurent satisfaisants. Toutefois, il est difficile de déterminer visuellement si les aubes conditionnées générées respectent effectivement les critères de conditionnement qui leur sont assignés.
 
 La figure \ref{fig:pca_ldm_results} montre les résultats d'un \gls{ldm} \gls{pca} sur Rotor37\_1200:
 \begin{itemize}
@@ -1064,7 +1061,7 @@ Une solution viable consiste à entraîner un modèle de régression capable d'
 
 Les \glspl{gp} sont des modèles probabilistes non paramétriques qui trouvent leur application dans des tâches de régression ou de classification. Ils sont particulièrement adaptés aux tâches de régression, car ils sont capables de fournir des estimations de l'incertitude associée à leurs prédictions. Cette mesure d'incertitude se révèle particulièrement précieuse pour la vérification de nos aubes générées, car elle permet d'évaluer la validité de nos générations en fournissant une estimation de la fiabilité de ces dernières.
 
-Ainsi si l'on entraine un \gls{gp} sur des couples (nuage de points, critère de performance), on peut ensuite utiliser ce \gls{gp} pour vérifier si nos nuages de points générés sont corrects. En effet, si l'on génère un nuage de points, et que l'on obtient un critère de performance très différent de celui attendu, alors on peut en déduire que notre génération est incorrecte.
+Ainsi si l'on entraine un \gls{gp} sur des couples de nuage de points avec leur critère de performance associé, on peut ensuite utiliser ce \gls{gp} pour vérifier si nos nuages de points générés sont corrects. En effet, si l'on génère un nuage de points, et que l'on obtient un critère de performance très différent de celui attendu, alors on peut en déduire que notre génération est incorrecte.
 
 \begin{figure}[h!]
   \centering
@@ -1091,7 +1088,7 @@ La figure~\ref{fig:gp_train_30_pca} illustre la validation du \gls{gp} en utilis
 
 De manière complémentaire, il est intéressant de noter que les distributions de in\_massflow, out\_massflow et compression\_rate présentent une grande similitude. Cette similarité est attendu, étant donné la forte corrélation physique entre ces trois critères. Un schéma similaire se manifeste entre les distributions de isentropic\_efficiency et polyentropic\_efficiency.
 
-Comme illustré dans les figures \ref{fig:gp_massflow_1_pca} et \ref{fig:gp_efficiency_1_pca}, il est nettement observable qu'il y a un changement dans la densité de probabilité des critères de performance lorsque nous conditionnons nos générations. Cette observation suggère que le conditionnement du modèle a effectivement un impact sur les critères de performance, selon le \gls{gp}. Cependant, pour confirmer cette hypothèse, il faudrait de procéder à une simulation numérique \gls{cfd}. En outre, on peut également constater sa capacité à générer des données qui se situent en dehors de la distribution d'entraînement, à condition que ces données demeurent relativement proches de ladite distribution. Par exemple, il est totalement inenvisageable de demander la génération d'aubes ayant des valeurs différentes pour les attributs in\_massflow et out\_massflow. Cette impossibilité résulte du fait que de telles combinaisons ne se trouvent pas dans le jeu de données d'entraînement, et qu'elles sont également physiquement incohérentes dans un système clos.
+Comme illustré dans les figures \ref{fig:gp_massflow_1_pca} et \ref{fig:gp_efficiency_1_pca}, il est nettement observable qu'il y a un changement dans la densité de probabilité des critères de performance lorsque nous conditionnons nos générations. Cette observation suggère que le conditionnement du modèle a effectivement un impact sur les critères de performance, selon le \gls{gp}. Cependant, pour confirmer cette hypothèse, il faudrait de procéder à une simulation numérique \gls{cfd}. En outre, on peut également constater sa capacité à générer des données qui se situent en dehors de la distribution d'entraînement, à condition que ces données demeurent relativement proches de ladite distribution. Par exemple, il est totalement inenvisageable de demander la génération d'aubes ayant des valeurs différentes pour les attributs in\_massflow et out\_massflow. Cette impossibilité résulte du fait que de telles combinaisons ne se trouvent pas dans le jeu de données d'entraînement, et qu'elles sont également physiquement incohérentes dans un système clos tel qu'un moteur d'avion.
 
 \FloatBarrier
 \chapter{Conclusion}