ajout diff safran

src/paper.tex

@@ -265,7 +265,7 @@ Les \gls{gan} sont la famille de modèles génératifs la plus renommée et éga
 
 Les \gls{gan} ont su démontrer leur efficacité pour générer des images réalistes. Cependant, ces modèles sont très difficiles à entraîner\cite{arjovsky_towards_2017}. Les \gls{gan} sont par exemple suceptible au problème des \textit{mode collapse}, où le générateur génère toujours la même image, au problème de \textit{non convergence}, où le générateur et/ou le discriminateur ont une fonction de cout instable et ne convergent ainsi pas vers un équilibre de Nash, ou encore au problème de \textit{vanishing gradient}, où le discriminateur devient trop efficace et empêche le générateur d'apprendre.
 
-Au fil des années, de nombreuses améliorations\cite{salimans_improved_2016}, variations ((WGAN\cite{arjovsky_wasserstein_2017}, etc.) et cas d'applications (CycleGAN\cite{zhu_unpaired_2020}, SGAN\cite{odena_semi-supervised_2016}, DiscoGAN\cite{kim_learning_2017}, SRGAN\cite{ledig_photo-realistic_2017}, etc.) ont été proposées, mais ces modèles restent complexes à entraîner et à évaluer. De plus, ces modèles sont très sensibles aux hyperparamètres et nécessitent une grande quantité de données pour être efficaces.
+Au fil des années, de nombreuses améliorations\cite{salimans_improved_2016}, variations (WGAN\cite{arjovsky_wasserstein_2017}, etc.) et cas d'applications (CycleGAN\cite{zhu_unpaired_2020}, SGAN\cite{odena_semi-supervised_2016}, SRGAN\cite{ledig_photo-realistic_2017}, DragGAN\cite{pan_drag_2023}, etc.) ont été proposées, mais ces modèles restent complexes à entraîner et à évaluer. De plus, ces modèles sont très sensibles aux hyperparamètres et nécessitent une grande quantité de données pour être efficaces.
 
 Face à ces inconvénients, et puisque nous ne possédons pas de grandes quantités de données, nous avons choisi de ne pas utiliser cette famille de modèles.
 
@@ -310,7 +310,7 @@ nous avons choisi d'explorer ces modèles dans un premier temps lors de nos expe
 Les \gls{nf} sont une autre classe de modèles génératifs qui ont gagné en popularité ces dernières années. Ces modèles se basent des transformations inversibles (bijectives) et différentiables. Ces transformations sont appliquées à une distribution de base, généralement une distribution simple comme une gaussienne, pour obtenir une distribution plus complexe et plus proche de la distribution des données réelles.
 Les transformations inversibles utilisées dans les \gls{nf} sont souvent paramétrisées par des réseaux de neurones, ce qui permet d'apprendre des fonctions non linéaires complexes. En utilisant plusieurs transformations en séquence, on peut construire des modèles génératifs flexibles capables de capturer des distributions complexes.
 
-Dans la littérature, ces réseaux sont assez peu appliqué aux types de données qui nous intéressent, à l'exception notable de PointFlow\cite{yang_pointflow_2019} qui aura posé certaines bases pour évaluer les réseaux génératifs de pointclouds.
+Dans la littérature, ces réseaux sont assez peu appliqué aux types de données qui nous intéressent, à l'exception notable de PointFlow\cite{yang_pointflow_2019} qui aura posé certaines bases pour évaluer les réseaux génératifs de nuages de points.
 
 \FloatBarrier
 \glsreset{vdm}
@@ -325,22 +325,30 @@ Dans la littérature, ces réseaux sont assez peu appliqué aux types de donnée
   \label{fig:vdm-architecture}
 \end{figure}
 
-Les \gls{vdm} 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 \gls{vae} et des \gls{nf}. En effet, le principe des \gls{vdm} est de trouver un processus réversible entre notre distribution de données et distribution totalement différente, mais que l'on connait de préférence parfaitement mathématiquement, comme une gaussienne isentropique par exemple. Dans leur architecture, les \gls{vdm} peuvent être vus comme des \gls{vae} hiérarchiques où la taille de la dimension latente est égale à celle des données d'entrée, où les encodeurs ne sont pas appris, mais sont déterminés par le processus de diffusion. De même, contrairement aux \gls{nf}, les \gls{vdm} ne sont pas basés sur des transformations déterministes et continues, mais sur des transformations stochastiques et discrètes.
+Les \gls{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 \gls{vae} et des \gls{nf}. En effet, le principe des \gls{vdm} est de trouver un processus réversible entre notre distribution de données et distribution totalement différente, mais que l'on connait de préférence parfaitement mathématiquement, comme une gaussienne isotropique par exemple. Dans leur architecture, les \gls{vdm} peuvent être vus comme des \gls{vae} hiérarchiques où la taille de la dimension latente est égale à celle des données d'entrée, et où les encodeurs ne sont pas appris, mais sont déterminés par le processus de diffusion. De même, contrairement aux \gls{nf}, les \gls{vdm} ne sont pas basés sur des transformations déterministes et continues, mais sur des transformations stochastiques et discrètes.
 
-Il peut cependant être montré théoriquement\cite{luo_understanding_2022} l'équivalence entre les \gls{vdm} et les méthodes de score matching lorsque que T tend vers l'infini. Les méthodes de score matching sont une famille de méthodes qui permettent d'estimer la densité de probabilité d'un ensemble de données en travaillant uniquement le gradient de la densité de probabilité. mécanique langevin pour estime la distrib à partir du gradient.
+On note p les "encodeurs" et q les "décodeurs" de la chaine de markov. On note $x_0$ un échantillon de notre distribution de données, $x_T$ un échantillon d'une normale isotropique, et $x_t$ tout échantillon intermédiaire. On note $t$ le temps de diffusion, $T$ le temps final de diffusion.
 
-Plusieurs sous-familles de modèles existent pour faire de la diffusion, la plus connue d'entre elles étant les \gls{ddpm}\cite{ho_denoising_2020}. Cette moéthode consiste à trouver un mapping réversible entre nos données et du bruit gaussien.
+$$ q(x_t | x_{t-1}) = \mathcal{N} ( x_t; \sqrt{\alpha_t} x_0, (1 - \alpha_t) I ) $$
 
+comme somme de gaussienne on peut montrer que :
 
+$$ q(x_t | x_0) = \mathcal{N} ( x_t; \sqrt{\overline\alpha_t} x_0, (1 - \overline\alpha_t) I ) $$
 
-% descritpion du training bref
+où $\overline\alpha_t = \prod_{t=1}^t \alpha_t$.
 
+% remplacer par les trois petits points
+donc $ x_t =  \sqrt{\overline\alpha_t} x_0 + \sqrt{1 - \overline\alpha_t} \epsilon $
 
-% description du sampling bref
+où $\epsilon \sim \mathcal{N}(0, I)$
 
-Une fois notre modèle correctement entrainés, nous somme donc capable de débruiter nos données. Le plus intéréessant est cependant lorsque nous demandons à notre réseau de débruiter du bruit pure. Le réseau se met alors à halluciner quelque chose qui ressemble fortement à nos données d'entraiments.
+% insérer ici image chaine markov
 
-\cite{song_generative_2020}
+Il est possible de démontrer théoriquement~\cite{luo_understanding_2022} l'équivalence entre les \gls{vdm} et les méthodes de score matching lorsque le nombre de nœuds dans la chaîne de Markov, noté par $T$, tend vers l'infini. Les méthodes de score matching~\cite{song_generative_2020}, 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 de la constante de normalisation. Une fois le gradient estimé, 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}.
+
+Plusieurs catégories de modèles sont disponibles pour aborder le problème de la diffusion, parmi lesquelles émerge la plus reconnue, à savoir les \gls{ddpm} \cite{ho_denoising_2020}. Cette approche vise à identifier une correspondance réversible et discrète entre les données observées et une distribution gaussienne isotropique. Ce processus de mise en correspondance est appris au moyen d'un modèle paramétrique (i.e. un réseau de neurones). À cette fin, des données altérées par une certaine quantité de bruit sont fournies en entrée, et le réseau est sollicité pour prédire la composante de bruit ajoutée. En utilisant cette prédiction, il devient possible de calculer l'erreur, de propager cette dernière en sens inverse et, par conséquent, d'optimiser le réseau.
+
+Après avoir achevé l'entraînement adéquat de notre modèle, nous acquérons ainsi la capacité de débruiter nos données altérées par un bruit gaussien. Néanmoins, l'intérêt majeur réside dans le fait de solliciter notre réseau pour débruiter du bruit pure (i.e. $SNR=0$). À ce stade, le réseau commence à générer des reconstructions qui présentent une forte ressemblance avec nos données d'entraînement, entraînant ainsi des phénomènes d'hallucination.
 
 \FloatBarrier
 \glsreset{ldm}
@@ -348,24 +356,53 @@ Une fois notre modèle correctement entrainés, nous somme donc capable de débr
 
 \begin{figure}[h!]
   \centering
-  \includegraphics[width=14cm]{ldm-architecture.png}
+  \includegraphics[width=6cm]{ldm-compression.jpg}\hspace*{5mm}\includegraphics[width=10cm]{ldm-architecture.png}
   \caption{Architecture d'un \gls{ldm}}
   \vspace*{-11pt}
   \caption*{Source: Rombach \& Blattmann, et al.\cite{rombach_high-resolution_2022}}
   \label{fig:ldm-architecture}
 \end{figure}
 
-Une amélioration notable des \gls{vdm} est l'utilisation intelligente des espaces latent. Cette technique à été popularisé par \cite{rombach_high-resolution_2022}
+Une amélioration significative des \gls{vdm} réside dans la mise en œuvre intelligente des espaces latents. Cette méthode, dénommée \gls{ldm}~\cite{rombach_high-resolution_2022}, repose sur l'observation selon laquelle l'exploitation des informations latentes, souvent de dimension nettement réduite, confère des avantages substantiels en termes de représentativité des données. La transition des \gls{vdm} vers les \gls{ldm} consiste en l'introduction préalable d'un second modèle, qu'il soit paramétrique ou non, destiné à obtenir une représentation latente. L'autoencodeur est fréquemment employé pour reconstruire fidèlement les données d'entrée, tandis que les représentations latentes alimentent le réseau de propagation subséquent. Cette approche induit une réduction de la complexité du réseau, entraînant ainsi une diminution du temps nécessaire à l'entraînement, tout en exerçant une influence forte sur la qualité des résultats obtenus.
 
 \FloatBarrier
 \subsubsection{Conditionnemnt \& Guidance}
 
-% https://liorsinai.github.io/coding/2023/01/04/denoising-diffusion-3-guidance.html#guided-diffusion
+Jusqu'à présent, les modèles génératifs ont démontré leur capacité à générer des données conformes à une distribution de données apprise. Cependant, il est fréquemment nécessaire d'échantillonner une sous-distribution spécifique de nos données. À cette fin, il est possible de conditionner le modèle en utilisant une donnée d'entrée, tel que du texte, à l'instar des modèles de type "texte2image" tels que DALL·E 2 ou Stable Diffusion.
-\cite{dhariwal_diffusion_2021}
-\cite{ho_classifier-free_2022}
-\cite{nichol_glide_2022}
 
-\cite{song_score-based_2021}
+Jusqu'à présent, capable de générer des données selon une distribution de données apprise. Cependant nous avons souvent besoin d'échantilloner une sous distribution de nos données. Pour cela, il est possible de conditionner le modèle sur une donnée d'entrée, comme par example du texte comme les modèles de text2image tels que DALL-E2 ou Stable Diffusion.
+
+Deux méthodes sont possibles pour permettre à des modèles de diffusion de générer des données conditionnées.
+
+% TODO: vérifier les citations, pas sur que ça corresponde
+
+La première méthode est appelée Classifier Guidance~\cite{dhariwal_diffusion_2021} et repose sur l'entraiement d'un classifier annexe $f_\phi(y | x_t)$ entrainé sur des données bruitées $x_t$ ainsi que leur classes associées $y$. Le logarithme du gradient de ce classifier est alors utilisé pour guider le modèle de diffusion. Ainsi selon la formulation du score matching on obtient:
+
+$${x_t} \log q_\theta (x_t, y) = {x_t} \log q (x_t) + \gamma {x_t} \log q (y | x_t)$$
+$$\approx -\frac{1}{\sqrt{1 - \alpha_t}} \epsilon_\theta (x_t, t) + \gamma {x_t} \log f_\phi (y | x_t)$$
+
+% https://perceptron.blog/defusing-diffusion/
+
+La seconde méthode est appelée Classifer-Free Guidance~\cite{ho_classifier-free_2022, nichol_glide_2022} et repose sur l'entraînement d'un unique réseau de neurones ayant pour objectif d'apprend à la fois la distribution conditionnelle et non conditionnelle. En réarrangeant equation 165, on obtient:
+
+$$ {x_t} \log p (y, x_t) = {x_t} \log p (x_t, y) - {x_t} \log p (x_t) $$
+
+substituion de l'équation 166:
+
+...
+
+Cette approche présente divers avantages. Premièrement, elle s'appuie sur un unique réseau de neurones, contrairement à la méthode guidée par classificateur qui en utilise deux. Deuxièmement, l'entraînement ne devient pas significativement plus complexe ; nous procédons de la même manière qu'auparavant, en ajoutant simplement les embeddings et en parfois excluant ces embeddings pour apprendre en conditionnement non contraint. Troisièmement, les données telles que le texte se prêtent difficilement à une classification en classes, et l'approche sans classificateur permet l'utilisation de vecteurs scalaires pour le conditionnement.
+
+Dans notre cas d'application, nous pouvons conditionner sur les scalaires representant les performances de nos maillages.
+
+% https://liorsinai.github.io/coding/2023/01/04/denoising-diffusion-3-guidance.html#guided-diffusion
+
+
+Plusieurs sous-familles de modèles existent pour faire de la diffusion, la plus connue d'entre elles étant les \gls{ddpm}\cite{ho_denoising_2020}. Cette méthode consiste à trouver un mapping réversible entre nos données et une gaussienne isotropique.
+
+L'étape d'entraînement du réseau repose sur une méthodologie relativement simple. Tout d'abord, nous sélectionnons un échantillon du jeu de données. Pour générer un échantillon bruité, nous l'altérons en ajoutant un bruit gaussien, dont l'intensité est ajustée selon un programme prédéfini. Ensuite, cet échantillon bruité est introduit dans le réseau, qui effectue une prédiction du bruit ajouté. Pour évaluer la précision de cette prédiction, nous comparons les résultats avec le bruit réel, ce qui nous permet de calculer un coût en utilisant la métrique d'erreur quadratique moyenne (MSE). En procédant à la rétropropagation de ce coût, nous mettons à jour les poids du réseau grâce à un algorithme d'optimisation approprié. Ce processus est répété pour chaque échantillon du jeu de données, en variant les intensités du bruit utilisé, jusqu'à atteindre la convergence, c'est-à-dire lorsque le modèle atteint un état stable et performant.
+
+Une fois notre modèle correctement entraîné, nous sommes donc en mesure de débruiter nos données. Toutefois, l'intérêt majeur réside dans la situation où nous demandons à notre réseau de débruiter un signal de bruit pur (le rapport signal/bruit est de zéro). À ce moment-là, le réseau commence à générer des répliques (des hallucinations) qui ressemblent de manière frappante à nos données d'entraînement.
 
 \cite{zhou_3d_2021}
 \cite{nguyen_point-set_2021}
@@ -416,7 +453,7 @@ Dans notre cas, étant donné que notre ensemble de données ne convient pas à
 
 \chapter{Déroulement du stage}
 
-Ce chapitre présente un aperçu détaillé du déroulement de mon stage de 6 mois au sein de \gls{ssa}. Tout au long de cette période, j'ai travaillé en tant que Stagiaire Ingénieur en Machine Learning au sein du département Safran Techn, dans l'équipe flex (chercher acronyme bidule), dont le but est de développer des outils de simulation et de modélisation pour les besoins de \gls{ssa}. J'ai été encadré par Xavier Roynard, Michel Alessandro Bucci et Brian Staber.
+Ce chapitre présente un aperçu détaillé du déroulement de mon stage de 6 mois (Du 21 Mars 2023 au 21 Septembre 2023) au sein de \gls{ssa}. Tout au long de cette période, j'ai travaillé en tant que Stagiaire Ingénieur en Machine Learning au sein du département Safran Tech, dans l'équipe flex (chercher acronyme bidule), dont le but est de développer des outils de simulation et de modélisation pour les besoins de \gls{ssa}. J'ai été encadré par Xavier Roynard, Michel Alessandro Bucci et Brian Staber.
 
 Je décrirai dans les prochaines sections les différentes étapes de mon stage, les tâches qui m'ont été confiées ainsi que les projets auxquels j'ai contribué.
 
@@ -425,9 +462,9 @@ Je décrirai dans les prochaines sections les différentes étapes de mon stage,
 
 Les premiers jours de mon stage ont été dédiés à mon intégration au sein de l'entreprise. J'ai rencontré mes tuteurs de stage qui m'ont présenté l'équipe et les différents membres du département. Une visite des locaux de l'entreprise m'a été proposée, accompagnée d'explications sur les mesures de sécurité en vigueur. J'ai également pris connaissance des outils et des logiciels utilisés dans le cadre de mon projet. Ces premiers jours ont été l'occasion pour moi de participer à des réunions d'équipe, en présence d'autres stagiaires et d'ingénieurs, afin de me familiariser avec les différents projets en cours et de préciser les objectifs de mon stage.
 
-Les deux premières semaines de mon stage ont été dédiées à la lecture approfondie de la littérature scientifique liée à mon domaine d'étude. J'ai effectué des recherches bibliographiques afin de recueillir des informations pertinentes sur les avancées récentes, les théories et les techniques utilisées dans le domaine des modèles génératifs. J'ai majoritairement consulté des articles de conférence et des documents en ligne pour obtenir une vue d'ensemble complète des travaux antérieurs réalisés par des chercheurs et des ingénieurs. Pour appronfondir mes recherches, j'ai également utilisé des outils, tels que Semantic Scholar et arxiv, pour trouver les codes sources des papiers ainsi que des papiers ayant pour citation ou référence les articles que j'avais déjà lus, me permettant ainsi de découvrir de nouvelles publications pertinentes.
+Les deux premières semaines de mon stage ont été dédiées à la lecture approfondie de la littérature scientifique liée à mon domaine d'étude. J'ai effectué des recherches bibliographiques afin de recueillir des informations pertinentes sur les avancées récentes, les théories et les techniques utilisées dans le domaine des modèles génératifs. J'ai majoritairement consulté des articles de conférence et des documents en ligne pour obtenir une vue d'ensemble complète des travaux antérieurs réalisés par des chercheurs et des ingénieurs. Pour appronfondir mes recherches, j'ai également utilisé des outils, tels que Semantic Scholar ou Papers with code, pour trouver les codes sources des papiers ainsi que des papiers ayant pour citation ou référence les articles que j'avais déjà lus, me permettant ainsi de découvrir de nouvelles publications pertinentes.
 
-Lors de ma lecture, j'ai pris des notes sur les concepts clés, les méthodologies et les résultats des études. J'ai analysé et comparé les différentes approches proposées dans la littérature afin de mieux comprendre les avantages et les limites de chaque méthode. Cette phase de lecture m'a permis d'acquérir une solide base de connaissances et de me familiariser avec les travaux existants dans le domaine. Ces connaissances préliminaires ont été essentielles pour orienter mes travaux ultérieurs de développement et de recherche lors du stage.
+Lors de ma lecture, j'ai pris des notes (via les logiciels Logseq et Zotero) sur les concepts clés, les méthodologies et les résultats des études. J'ai analysé et comparé les différentes approches proposées dans la littérature afin de mieux comprendre les avantages et les limites de chaque méthode. Cette phase de lecture m'a permis d'acquérir une solide base de connaissances et de me familiariser avec les travaux existants dans le domaine. Ces connaissances préliminaires ont été essentielles pour orienter mes travaux ultérieurs de développement et de recherche lors du stage.
 
 Au cours de cette période, j'ai également eu des discussions régulières avec mes tuteurs de stage pour discuter des articles lus, clarifier certains points et définir la direction à suivre pour mon projet. Ces échanges m'ont permis d'approfondir ma compréhension et de cibler les aspects spécifiques sur lesquels je devais me concentrer lors des prochaines phases de mon stage.
 
@@ -456,6 +493,8 @@ Chaque aube du jeu de données est une déformation de l'aube nominale. Ainsi to
 
 Chaque échantillon est constitué de deux fichiers distincts. Le premier est un fichier au format .vtk qui contient le maillage de l'aube, comprenant les positions 3D, les normales et la connectivité de chaque point du maillage. Ce fichier .vtk inclut également les champs physiques associés à chaque point, tels que la température, la pression, etc. Le second fichier est un fichier .csv qui contient des métadonnées globales spécifiques à l'échantillon, telles que les entrées et les sorties de la simulation \gls{cfd}.
 
+Cet ensemble de données peut être séparé en deux sous-ensembles : un ensemble d'apprentissage de 1000 échantillons (83\% des données) et un ensemble de test de 200 échantillons (17\% des données). L'ensemble d'apprentissage est utilisé pour entraîner les modèles génératifs, tandis que l'ensemble de test est utilisé pour évaluer les performances des modèles génératifs.
+
 \FloatBarrier
 \section{Description de l'environnement de travail}
 
@@ -466,11 +505,11 @@ Les locaux de l'entreprise se présentent sous la forme de vastes openspaces, pa
 Chaque employé dispose d'une station de travail sous la forme d'un ordinateur portable, connecté à un dock sur le bureau. Afin de réaliser des calculs intensifs, nous avons la possibilité de nous connecter au cluster de calcul local, appelé Rosetta, utilisant le système slurm. Ce cluster est composé d'environ 3000 cœurs CPU, 50 GPU et dispose de plusieurs téraoctets de RAM et de stockage disque. Pour le développement de nos projets, nous exploitons la forge interne de Safran, qui est une plateforme GitLab dédiée. En outre, chaque employé a accès à la suite professionnelle Office 365, qui facilite la gestion des documents et des e-mails.
 
 \FloatBarrier
-\section{Test de l'état de l'art}
+\section{Application de l'état de l'art}
 
-En complément de ma recherche bibliographique, j'ai consacré du temps à tester différentes implémentations des papiers que j'ai pu trouver. Voici la liste des implémentations que j'ai pris le temps d'évaluer, ainsi que mes observations à leur sujet.
+En complément de ma recherche bibliographique, j'ai consacré du temps à tester différentes implémentations des papiers que j'ai pu trouver. Voici la liste des implémentations et idées que j'ai pris le temps d'évaluer, ainsi que mes observations à leur sujet. plus ou moins chronolgique
 
-\subsection{\gls{vae}}
+\subsection{Approche par \gls{vae}}
 
 % parler du fait que pytorch geometric à facilité un peu la tache d'implem
 
@@ -478,40 +517,66 @@ L'une de nos premières initiatives a été de tester des réseaux basés sur le
 
 En effet, dans le contexte des graphes, les opérations de "upsampling" n'existent pas de manière directe. 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 à utiliser une ou plusieurs couches denses pour convertir le vecteur 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 30000 nœuds, cela impliquait une matrice de connectivité de taille $30000^2$, ce qui faisait exploser la complexité lorsque nous utilisions des couches denses.
+Une première solution simple consistait en l'utilisation de une ou plusieurs couches denses 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 30000 nœuds, cela impliquait une matrice de connectivité de taille $30000^2$, ce qui faisait aisaiment exploser la complexité lorsque nous utilisions des couches denses.
 
-Pour donner un ordre de grandeur, si l'on utilisai 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 de couches denses impliquait déjà pratiquement 1 million de paramètres ($8 \times 30000 \times 3$). Prédire la connectivité était tout simplement impossible, car il aurait fallu une couche dense avec plus de $7$ milliards de paramètres ($8 \times 30000 \times 30000$), ce qui dépassait largement les capacités de calcul de nos ressources GPU.
+Pour donner un ordre de grandeur, si l'on utilisai 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à pratiquement 1 million de paramètres ($8 \times 30000 \times 3$). Prédire la connectivité était tout simplement impossible, car il aurait fallu une couche dense avec plus de $7$ milliards de paramètres ($8 \times 30000 \times 30000$), 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. Cette approche permettait d'éviter l'utilisation de couches denses dans le décodeur grâce aux 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.
 
 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 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 facilement être retrouvé via diverses techniques\cite{peng_shape_2021,sulzer_deep_2022}
 
-\subsection{\gls{pvcnn}}
+\subsection{Approche par \gls{nf}}
 
 % Pointflow (à l'origine du dataset PointFlow, une modif de shapenet, code à chier)
-% pointnet (pointcloud unquement, pas de graphe, code original à chier, mais plein d'implems mieux)
+
-% PVCNN (code à chier, basé sur pointnet)
+\subsection{Approche par diffusion}
-% SPVCNN (torchsparse, pas réussi à faire marcher pour la diffusion)
+
-% PVD (checkpoint, code à chier, trop chiant les opérations de voxelization devox en cuda + les métriques qui changent entre chaque papiers emd chamfer 1-NNA, en cuda aussi)
+Pour prédire le bruit dans le processus de diffusion, conformément à la section intitulée "État de l'art" dans ce document, il est essentiel de sélectionner une architecture de réseau de neurones. Dans notre cas, puisque nous travaillons sur nuages de points, il convient d'utiliser des architectures adaptées à ce type de données.
+
+Dans le contexte de l'apprentissage sur les nuages de points, une architecture a émergé comme la norme, à savoir PointNet. PointNet est une architecture basée sur des shared MLPs (Multi-Layer Perceptrons, qui peuvent être vus comme des convolutions de noyau 1x1) qui permettent de traiter des nuages de points, indépendemment du nombre de points. archi interessante car permutation invariant, mais aussi robuste à certaines transformations comme les rotations et translations.
+Par la suite, amélioration de pointnet et désormais la norme, PointNet++ propose une approche profonde hiérarchique qui exploite une combinaison d'échantillonnage, d'agrégation et de suréchantillonnage pour permettre l'extension d'opérateurs locaux aux champs globaux réceptifs, entre autres.
+
+Par la suite, une amélioration conséquente du modèle PointNet a abouti à l'émergence de PointNet++, désormais considérée comme l'architecture de référence dans le domaine. PointNet++ présente une approche hiérarchique en profondeur qui capitalise sur une fusion de techniques d'échantillonnage (furthest point sampling) et d'agrégations (knn) des points du nuage. Cette approche permet ainsi d'élargir la portée des opérateurs locaux pour englober des champs globaux réceptifs, et ainsi améliorer les performances du réseau.
+
+% insérer ici image archite pointnet et poitnet++
+
 % KPConv (c'est français, pas mal non ?)
-% LION (pas de checkpoint, mais code utile)
+autre archi bien connue dans le traitement de point clouds, archi semblable à pointnet++, mais le sampling est fait via une grille de voxelle, et l'aggragation est faite via des KPConv, qui sont une ball query. c'est français
 
-\FloatBarrier
+Une autre architecture largement reconnue dans le domaine du traitement de nuages de points, présentant des similitudes avec PointNet++, est nommée KPConv. Cette architecture utilise un échantillonnage basé sur une grille de voxels et l'opération d'agrégation par des KPConv, qui sont des convolutions sur boules. Cette architecture est également très efficace, et surpasse généralement les autres architectures sur les taches de segmentation.
-\section{Réimplementation de l'état de l'art}
 
-Backbone KPConv, car implement ezkpconv cool + huggingface diffusers pour gérer toute la partie diffusion.
+Appliqué à de la diffusion, KPFCNN
 
-Les résultats que l'on obtient sont bien, mais pas très satisfaisant, on dirait que les aubes sont encore un peu "bruité".
+% PVCNN (code à chier, basé sur pointnet)
+point voxel convolution, efficace, mais bcp de cuda
 
-C'est là qu'intervient les \gls{ldm}
+% SPVCNN (torchsparse, pas réussi à faire marcher pour la diffusion)
+version plus efficace, mais pas trop réussi à faire marche, cuda très esotérique
 
-le principe est de travailler uniquement sur les informations basse fréquences qui définissent l'information sémantique de nos données.
+% PVD (checkpoint, code à chier, trop chiant les opérations de voxelization devox en cuda + les métriques qui changent entre chaque papiers emd chamfer 1-NNA, en cuda aussi)
-Ainsi tous ces bruits haute fréquence passent à la trappe et on obtient de très bon résultats
+archi basée sur pintnet++, mais pas de sampling, juste des pvconv
 
-conditionnemnt
+% LION (pas de checkpoint, mais code utile)z
-classifier-free guidance
+le plus récent
 
-ça marche on est content
+à dire en plus, les metrics pour évaluer la qualité des nuages de points générés ne sont pas vraiment normalisées, changent d'un papier à l'autre, ou implem change d'un papier à l'autre.
+
+%%% old stuff, merge with what's before
+
+Les premiers résultats concluant que nous avons obtenus ont été avec l'architecture KPFCNN. Cette architecture est basée sur PointNet++ et utilise des convolutions de type KPConv. Nous avons utilisé cette archi pour prédire le bruit lors de l'entraiment d'un \gls{vdm} (schedulers via huggingface diffusers). Les résultats étaient encourageants, mais nous avons constaté que le réseau avait du mal à apprendre à prédire le bruit en fin de sampling. en effet, les aubes finales semblaient encore un peu bruitées.
+<insérer image ici>
+
+Pour essayer d'améliorer ces résultats, on peut apprendre à faire de la diffusion sur des variables latente, plutout que direct sur nos données. avantage, réduciton de dimension + informtion latente.
+
+dans un premier temps on compresse donc nos nuages de point via une PCA, ça marche du feu de dieu
+
+conditionnemnt, classifier-free guidance
+
+pour vérif si la génération est bonne, on entraine des GP
+
+on test d'autres méthodes parameter free, comme la POD, marche moins bien
+
+second temps, on compress nuages de points via un AE, pas encore finis, mais inch ça marche
 
 \chapter{Conclusion}
 

src/zotero.bib

@@ -842,7 +842,7 @@ version: 1},
 	month = jun,
 	year = {2021},
 	note = {arXiv:2105.05233 [cs, stat]},
-	keywords = {Computer Science - Artificial Intelligence, Computer Science - Computer Vision and Pattern Recognition, Computer Science - Machine Learning, Statistics - Machine Learning},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Machine Learning, Statistics - Machine Learning, Computer Science - Artificial Intelligence},
 	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/PWT54DE7/Dhariwal and Nichol - 2021 - Diffusion Models Beat GANs on Image Synthesis.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/8J2YBIJV/2105.html:text/html},
 }
 
@@ -857,7 +857,7 @@ version: 1},
 	month = jul,
 	year = {2022},
 	note = {arXiv:2207.12598 [cs]},
-	keywords = {Computer Science - Artificial Intelligence, Computer Science - Machine Learning},
+	keywords = {Computer Science - Machine Learning, Computer Science - Artificial Intelligence},
 	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/TBVUH8VL/Ho and Salimans - 2022 - Classifier-Free Diffusion Guidance.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/ZLTAMX75/2207.html:text/html},
 }
 
@@ -888,5 +888,247 @@ version: 1},
 	month = mar,
 	year = {2022},
 	note = {arXiv:2112.10741 [cs]},
-	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Graphics, Computer Science - Machine Learning},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Machine Learning, Computer Science - Graphics},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/7A2X7CTA/Nichol et al. - 2022 - GLIDE Towards Photorealistic Image Generation and.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/9AD6NH2U/2112.html:text/html},
+}
+
+@misc{jun_shap-e_2023,
+	title = {Shap-{E}: {Generating} {Conditional} {3D} {Implicit} {Functions}},
+	shorttitle = {Shap-{E}},
+	url = {http://arxiv.org/abs/2305.02463},
+	doi = {10.48550/arXiv.2305.02463},
+	abstract = {We present Shap-E, a conditional generative model for 3D assets. Unlike recent work on 3D generative models which produce a single output representation, Shap-E directly generates the parameters of implicit functions that can be rendered as both textured meshes and neural radiance fields. We train Shap-E in two stages: first, we train an encoder that deterministically maps 3D assets into the parameters of an implicit function; second, we train a conditional diffusion model on outputs of the encoder. When trained on a large dataset of paired 3D and text data, our resulting models are capable of generating complex and diverse 3D assets in a matter of seconds. When compared to Point-E, an explicit generative model over point clouds, Shap-E converges faster and reaches comparable or better sample quality despite modeling a higher-dimensional, multi-representation output space. We release model weights, inference code, and samples at https://github.com/openai/shap-e.},
+	urldate = {2023-07-13},
+	publisher = {arXiv},
+	author = {Jun, Heewoo and Nichol, Alex},
+	month = may,
+	year = {2023},
+	note = {arXiv:2305.02463 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Machine Learning},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/855RN3FY/Jun and Nichol - 2023 - Shap-E Generating Conditional 3D Implicit Functio.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/QTTJPPH2/2305.html:text/html},
+}
+
+@misc{ho_denoising_2020,
+	title = {Denoising {Diffusion} {Probabilistic} {Models}},
+	url = {http://arxiv.org/abs/2006.11239},
+	doi = {10.48550/arXiv.2006.11239},
+	abstract = {We present high quality image synthesis results using diffusion probabilistic models, a class of latent variable models inspired by considerations from nonequilibrium thermodynamics. Our best results are obtained by training on a weighted variational bound designed according to a novel connection between diffusion probabilistic models and denoising score matching with Langevin dynamics, and our models naturally admit a progressive lossy decompression scheme that can be interpreted as a generalization of autoregressive decoding. On the unconditional CIFAR10 dataset, we obtain an Inception score of 9.46 and a state-of-the-art FID score of 3.17. On 256x256 LSUN, we obtain sample quality similar to ProgressiveGAN. Our implementation is available at https://github.com/hojonathanho/diffusion},
+	urldate = {2023-07-17},
+	publisher = {arXiv},
+	author = {Ho, Jonathan and Jain, Ajay and Abbeel, Pieter},
+	month = dec,
+	year = {2020},
+	note = {arXiv:2006.11239 [cs, stat]},
+	keywords = {Computer Science - Machine Learning, Statistics - Machine Learning},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/X4CDD6W7/Ho et al. - 2020 - Denoising Diffusion Probabilistic Models.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/Q2SYF624/2006.html:text/html},
+}
+
+@misc{pan_drag_2023,
+	title = {Drag {Your} {GAN}: {Interactive} {Point}-based {Manipulation} on the {Generative} {Image} {Manifold}},
+	shorttitle = {Drag {Your} {GAN}},
+	url = {http://arxiv.org/abs/2305.10973},
+	doi = {10.48550/arXiv.2305.10973},
+	abstract = {Synthesizing visual content that meets users' needs often requires flexible and precise controllability of the pose, shape, expression, and layout of the generated objects. Existing approaches gain controllability of generative adversarial networks (GANs) via manually annotated training data or a prior 3D model, which often lack flexibility, precision, and generality. In this work, we study a powerful yet much less explored way of controlling GANs, that is, to "drag" any points of the image to precisely reach target points in a user-interactive manner, as shown in Fig.1. To achieve this, we propose DragGAN, which consists of two main components: 1) a feature-based motion supervision that drives the handle point to move towards the target position, and 2) a new point tracking approach that leverages the discriminative generator features to keep localizing the position of the handle points. Through DragGAN, anyone can deform an image with precise control over where pixels go, thus manipulating the pose, shape, expression, and layout of diverse categories such as animals, cars, humans, landscapes, etc. As these manipulations are performed on the learned generative image manifold of a GAN, they tend to produce realistic outputs even for challenging scenarios such as hallucinating occluded content and deforming shapes that consistently follow the object's rigidity. Both qualitative and quantitative comparisons demonstrate the advantage of DragGAN over prior approaches in the tasks of image manipulation and point tracking. We also showcase the manipulation of real images through GAN inversion.},
+	urldate = {2023-07-17},
+	publisher = {arXiv},
+	author = {Pan, Xingang and Tewari, Ayush and Leimkühler, Thomas and Liu, Lingjie and Meka, Abhimitra and Theobalt, Christian},
+	month = may,
+	year = {2023},
+	note = {arXiv:2305.10973 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Graphics},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/8ITIWG9Q/Pan et al. - 2023 - Drag Your GAN Interactive Point-based Manipulatio.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/4G4JFKJV/2305.html:text/html},
+}
+
+@misc{satorras_en_2022,
+	title = {E(n) {Equivariant} {Graph} {Neural} {Networks}},
+	url = {http://arxiv.org/abs/2102.09844},
+	doi = {10.48550/arXiv.2102.09844},
+	abstract = {This paper introduces a new model to learn graph neural networks equivariant to rotations, translations, reflections and permutations called E(n)-Equivariant Graph Neural Networks (EGNNs). In contrast with existing methods, our work does not require computationally expensive higher-order representations in intermediate layers while it still achieves competitive or better performance. In addition, whereas existing methods are limited to equivariance on 3 dimensional spaces, our model is easily scaled to higher-dimensional spaces. We demonstrate the effectiveness of our method on dynamical systems modelling, representation learning in graph autoencoders and predicting molecular properties.},
+	urldate = {2023-08-09},
+	publisher = {arXiv},
+	author = {Satorras, Victor Garcia and Hoogeboom, Emiel and Welling, Max},
+	month = feb,
+	year = {2022},
+	note = {arXiv:2102.09844 [cs, stat]},
+	keywords = {Computer Science - Machine Learning, Statistics - Machine Learning},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/5KIWXDVC/Satorras et al. - 2022 - E(n) Equivariant Graph Neural Networks.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/9ZFR6NAN/2102.html:text/html},
+}
+
+@misc{yu_pu-net_2018,
+	title = {{PU}-{Net}: {Point} {Cloud} {Upsampling} {Network}},
+	shorttitle = {{PU}-{Net}},
+	url = {http://arxiv.org/abs/1801.06761},
+	doi = {10.48550/arXiv.1801.06761},
+	abstract = {Learning and analyzing 3D point clouds with deep networks is challenging due to the sparseness and irregularity of the data. In this paper, we present a data-driven point cloud upsampling technique. The key idea is to learn multi-level features per point and expand the point set via a multi-branch convolution unit implicitly in feature space. The expanded feature is then split to a multitude of features, which are then reconstructed to an upsampled point set. Our network is applied at a patch-level, with a joint loss function that encourages the upsampled points to remain on the underlying surface with a uniform distribution. We conduct various experiments using synthesis and scan data to evaluate our method and demonstrate its superiority over some baseline methods and an optimization-based method. Results show that our upsampled points have better uniformity and are located closer to the underlying surfaces.},
+	urldate = {2023-08-04},
+	publisher = {arXiv},
+	author = {Yu, Lequan and Li, Xianzhi and Fu, Chi-Wing and Cohen-Or, Daniel and Heng, Pheng-Ann},
+	month = mar,
+	year = {2018},
+	note = {arXiv:1801.06761 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Graphics},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/HSLYQ9SV/Yu et al. - 2018 - PU-Net Point Cloud Upsampling Network.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/IN75N9XP/1801.html:text/html},
+}
+
+@article{zhang_point_2022,
+	title = {Point {Cloud} {Upsampling} {Algorithm}: {A} {Systematic} {Review}},
+	volume = {15},
+	copyright = {http://creativecommons.org/licenses/by/3.0/},
+	issn = {1999-4893},
+	shorttitle = {Point {Cloud} {Upsampling} {Algorithm}},
+	url = {https://www.mdpi.com/1999-4893/15/4/124},
+	doi = {10.3390/a15040124},
+	abstract = {Point cloud upsampling algorithms can improve the resolution of point clouds and generate dense and uniform point clouds, and are an important image processing technology. Significant progress has been made in point cloud upsampling research in recent years. This paper provides a comprehensive survey of point cloud upsampling algorithms. We classify existing point cloud upsampling algorithms into optimization-based methods and deep learning-based methods, and analyze the advantages and limitations of different algorithms from a modular perspective. In addition, we cover some other important issues such as public datasets and performance evaluation metrics. Finally, we conclude this survey by highlighting several future research directions and open issues that should be further addressed.},
+	language = {en},
+	number = {4},
+	urldate = {2023-08-04},
+	journal = {Algorithms},
+	author = {Zhang, Yan and Zhao, Wenhan and Sun, Bo and Zhang, Ying and Wen, Wen},
+	month = apr,
+	year = {2022},
+	note = {Number: 4
+Publisher: Multidisciplinary Digital Publishing Institute},
+	keywords = {deep learning, generative adversarial network (GAN), graph convolutional network (GCN), point cloud upsampling, unsupervised learning},
+	pages = {124},
+	file = {Full Text PDF:/home/laurent/Zotero/storage/PHKK549T/Zhang et al. - 2022 - Point Cloud Upsampling Algorithm A Systematic Rev.pdf:application/pdf},
+}
+
+@misc{ma_rethinking_2022,
+	title = {Rethinking {Network} {Design} and {Local} {Geometry} in {Point} {Cloud}: {A} {Simple} {Residual} {MLP} {Framework}},
+	shorttitle = {Rethinking {Network} {Design} and {Local} {Geometry} in {Point} {Cloud}},
+	url = {http://arxiv.org/abs/2202.07123},
+	doi = {10.48550/arXiv.2202.07123},
+	abstract = {Point cloud analysis is challenging due to irregularity and unordered data structure. To capture the 3D geometries, prior works mainly rely on exploring sophisticated local geometric extractors using convolution, graph, or attention mechanisms. These methods, however, incur unfavorable latency during inference, and the performance saturates over the past few years. In this paper, we present a novel perspective on this task. We notice that detailed local geometrical information probably is not the key to point cloud analysis -- we introduce a pure residual MLP network, called PointMLP, which integrates no sophisticated local geometrical extractors but still performs very competitively. Equipped with a proposed lightweight geometric affine module, PointMLP delivers the new state-of-the-art on multiple datasets. On the real-world ScanObjectNN dataset, our method even surpasses the prior best method by 3.3\% accuracy. We emphasize that PointMLP achieves this strong performance without any sophisticated operations, hence leading to a superior inference speed. Compared to most recent CurveNet, PointMLP trains 2x faster, tests 7x faster, and is more accurate on ModelNet40 benchmark. We hope our PointMLP may help the community towards a better understanding of point cloud analysis. The code is available at https://github.com/ma-xu/pointMLP-pytorch.},
+	urldate = {2023-08-03},
+	publisher = {arXiv},
+	author = {Ma, Xu and Qin, Can and You, Haoxuan and Ran, Haoxi and Fu, Yun},
+	month = nov,
+	year = {2022},
+	note = {arXiv:2202.07123 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Artificial Intelligence},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/ZZGSSLLN/Ma et al. - 2022 - Rethinking Network Design and Local Geometry in Po.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/23QXY3QK/2202.html:text/html},
+}
+
+@misc{oord_neural_2018,
+	title = {Neural {Discrete} {Representation} {Learning}},
+	url = {http://arxiv.org/abs/1711.00937},
+	doi = {10.48550/arXiv.1711.00937},
+	abstract = {Learning useful representations without supervision remains a key challenge in machine learning. In this paper, we propose a simple yet powerful generative model that learns such discrete representations. Our model, the Vector Quantised-Variational AutoEncoder (VQ-VAE), differs from VAEs in two key ways: the encoder network outputs discrete, rather than continuous, codes; and the prior is learnt rather than static. In order to learn a discrete latent representation, we incorporate ideas from vector quantisation (VQ). Using the VQ method allows the model to circumvent issues of "posterior collapse" -- where the latents are ignored when they are paired with a powerful autoregressive decoder -- typically observed in the VAE framework. Pairing these representations with an autoregressive prior, the model can generate high quality images, videos, and speech as well as doing high quality speaker conversion and unsupervised learning of phonemes, providing further evidence of the utility of the learnt representations.},
+	urldate = {2023-07-19},
+	publisher = {arXiv},
+	author = {Oord, Aaron van den and Vinyals, Oriol and Kavukcuoglu, Koray},
+	month = may,
+	year = {2018},
+	note = {arXiv:1711.00937 [cs]},
+	keywords = {Computer Science - Machine Learning},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/ZHFTV3KY/Oord et al. - 2018 - Neural Discrete Representation Learning.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/I24NXN5D/1711.html:text/html},
+}
+
+@misc{esser_taming_2021,
+	title = {Taming {Transformers} for {High}-{Resolution} {Image} {Synthesis}},
+	url = {http://arxiv.org/abs/2012.09841},
+	doi = {10.48550/arXiv.2012.09841},
+	abstract = {Designed to learn long-range interactions on sequential data, transformers continue to show state-of-the-art results on a wide variety of tasks. In contrast to CNNs, they contain no inductive bias that prioritizes local interactions. This makes them expressive, but also computationally infeasible for long sequences, such as high-resolution images. We demonstrate how combining the effectiveness of the inductive bias of CNNs with the expressivity of transformers enables them to model and thereby synthesize high-resolution images. We show how to (i) use CNNs to learn a context-rich vocabulary of image constituents, and in turn (ii) utilize transformers to efficiently model their composition within high-resolution images. Our approach is readily applied to conditional synthesis tasks, where both non-spatial information, such as object classes, and spatial information, such as segmentations, can control the generated image. In particular, we present the first results on semantically-guided synthesis of megapixel images with transformers and obtain the state of the art among autoregressive models on class-conditional ImageNet. Code and pretrained models can be found at https://github.com/CompVis/taming-transformers .},
+	urldate = {2023-07-19},
+	publisher = {arXiv},
+	author = {Esser, Patrick and Rombach, Robin and Ommer, Björn},
+	month = jun,
+	year = {2021},
+	note = {arXiv:2012.09841 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/P65UBNHY/Esser et al. - 2021 - Taming Transformers for High-Resolution Image Synt.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/N2ALIH7W/2012.html:text/html},
+}
+
+@misc{isola_image--image_2018,
+	title = {Image-to-{Image} {Translation} with {Conditional} {Adversarial} {Networks}},
+	url = {http://arxiv.org/abs/1611.07004},
+	doi = {10.48550/arXiv.1611.07004},
+	abstract = {We investigate conditional adversarial networks as a general-purpose solution to image-to-image translation problems. These networks not only learn the mapping from input image to output image, but also learn a loss function to train this mapping. This makes it possible to apply the same generic approach to problems that traditionally would require very different loss formulations. We demonstrate that this approach is effective at synthesizing photos from label maps, reconstructing objects from edge maps, and colorizing images, among other tasks. Indeed, since the release of the pix2pix software associated with this paper, a large number of internet users (many of them artists) have posted their own experiments with our system, further demonstrating its wide applicability and ease of adoption without the need for parameter tweaking. As a community, we no longer hand-engineer our mapping functions, and this work suggests we can achieve reasonable results without hand-engineering our loss functions either.},
+	urldate = {2023-07-19},
+	publisher = {arXiv},
+	author = {Isola, Phillip and Zhu, Jun-Yan and Zhou, Tinghui and Efros, Alexei A.},
+	month = nov,
+	year = {2018},
+	note = {arXiv:1611.07004 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/3JNXIC89/Isola et al. - 2018 - Image-to-Image Translation with Conditional Advers.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/9SW285N5/1611.html:text/html},
+}
+
+@misc{zhang_unreasonable_2018,
+	title = {The {Unreasonable} {Effectiveness} of {Deep} {Features} as a {Perceptual} {Metric}},
+	url = {http://arxiv.org/abs/1801.03924},
+	doi = {10.48550/arXiv.1801.03924},
+	abstract = {While it is nearly effortless for humans to quickly assess the perceptual similarity between two images, the underlying processes are thought to be quite complex. Despite this, the most widely used perceptual metrics today, such as PSNR and SSIM, are simple, shallow functions, and fail to account for many nuances of human perception. Recently, the deep learning community has found that features of the VGG network trained on ImageNet classification has been remarkably useful as a training loss for image synthesis. But how perceptual are these so-called "perceptual losses"? What elements are critical for their success? To answer these questions, we introduce a new dataset of human perceptual similarity judgments. We systematically evaluate deep features across different architectures and tasks and compare them with classic metrics. We find that deep features outperform all previous metrics by large margins on our dataset. More surprisingly, this result is not restricted to ImageNet-trained VGG features, but holds across different deep architectures and levels of supervision (supervised, self-supervised, or even unsupervised). Our results suggest that perceptual similarity is an emergent property shared across deep visual representations.},
+	urldate = {2023-07-19},
+	publisher = {arXiv},
+	author = {Zhang, Richard and Isola, Phillip and Efros, Alexei A. and Shechtman, Eli and Wang, Oliver},
+	month = apr,
+	year = {2018},
+	note = {arXiv:1801.03924 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Graphics},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/37ALS5ZY/Zhang et al. - 2018 - The Unreasonable Effectiveness of Deep Features as.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/AYX4F5NM/1801.html:text/html},
+}
+
+@misc{dettmers_qlora_2023,
+	title = {{QLoRA}: {Efficient} {Finetuning} of {Quantized} {LLMs}},
+	shorttitle = {{QLoRA}},
+	url = {http://arxiv.org/abs/2305.14314},
+	doi = {10.48550/arXiv.2305.14314},
+	abstract = {We present QLoRA, an efficient finetuning approach that reduces memory usage enough to finetune a 65B parameter model on a single 48GB GPU while preserving full 16-bit finetuning task performance. QLoRA backpropagates gradients through a frozen, 4-bit quantized pretrained language model into Low Rank Adapters{\textasciitilde}(LoRA). Our best model family, which we name Guanaco, outperforms all previous openly released models on the Vicuna benchmark, reaching 99.3\% of the performance level of ChatGPT while only requiring 24 hours of finetuning on a single GPU. QLoRA introduces a number of innovations to save memory without sacrificing performance: (a) 4-bit NormalFloat (NF4), a new data type that is information theoretically optimal for normally distributed weights (b) double quantization to reduce the average memory footprint by quantizing the quantization constants, and (c) paged optimziers to manage memory spikes. We use QLoRA to finetune more than 1,000 models, providing a detailed analysis of instruction following and chatbot performance across 8 instruction datasets, multiple model types (LLaMA, T5), and model scales that would be infeasible to run with regular finetuning (e.g. 33B and 65B parameter models). Our results show that QLoRA finetuning on a small high-quality dataset leads to state-of-the-art results, even when using smaller models than the previous SoTA. We provide a detailed analysis of chatbot performance based on both human and GPT-4 evaluations showing that GPT-4 evaluations are a cheap and reasonable alternative to human evaluation. Furthermore, we find that current chatbot benchmarks are not trustworthy to accurately evaluate the performance levels of chatbots. A lemon-picked analysis demonstrates where Guanaco fails compared to ChatGPT. We release all of our models and code, including CUDA kernels for 4-bit training.},
+	urldate = {2023-07-19},
+	publisher = {arXiv},
+	author = {Dettmers, Tim and Pagnoni, Artidoro and Holtzman, Ari and Zettlemoyer, Luke},
+	month = may,
+	year = {2023},
+	note = {arXiv:2305.14314 [cs]},
+	keywords = {Computer Science - Machine Learning},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/4KD7F73X/Dettmers et al. - 2023 - QLoRA Efficient Finetuning of Quantized LLMs.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/EI35JVE7/2305.html:text/html},
+}
+
+@misc{hu_lora_2021,
+	title = {{LoRA}: {Low}-{Rank} {Adaptation} of {Large} {Language} {Models}},
+	shorttitle = {{LoRA}},
+	url = {http://arxiv.org/abs/2106.09685},
+	doi = {10.48550/arXiv.2106.09685},
+	abstract = {An important paradigm of natural language processing consists of large-scale pre-training on general domain data and adaptation to particular tasks or domains. As we pre-train larger models, full fine-tuning, which retrains all model parameters, becomes less feasible. Using GPT-3 175B as an example -- deploying independent instances of fine-tuned models, each with 175B parameters, is prohibitively expensive. We propose Low-Rank Adaptation, or LoRA, which freezes the pre-trained model weights and injects trainable rank decomposition matrices into each layer of the Transformer architecture, greatly reducing the number of trainable parameters for downstream tasks. Compared to GPT-3 175B fine-tuned with Adam, LoRA can reduce the number of trainable parameters by 10,000 times and the GPU memory requirement by 3 times. LoRA performs on-par or better than fine-tuning in model quality on RoBERTa, DeBERTa, GPT-2, and GPT-3, despite having fewer trainable parameters, a higher training throughput, and, unlike adapters, no additional inference latency. We also provide an empirical investigation into rank-deficiency in language model adaptation, which sheds light on the efficacy of LoRA. We release a package that facilitates the integration of LoRA with PyTorch models and provide our implementations and model checkpoints for RoBERTa, DeBERTa, and GPT-2 at https://github.com/microsoft/LoRA.},
+	urldate = {2023-07-19},
+	publisher = {arXiv},
+	author = {Hu, Edward J. and Shen, Yelong and Wallis, Phillip and Allen-Zhu, Zeyuan and Li, Yuanzhi and Wang, Shean and Wang, Lu and Chen, Weizhu},
+	month = oct,
+	year = {2021},
+	note = {arXiv:2106.09685 [cs]},
+	keywords = {Computer Science - Machine Learning, Computer Science - Artificial Intelligence, Computer Science - Computation and Language},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/ZHA2VLNH/Hu et al. - 2021 - LoRA Low-Rank Adaptation of Large Language Models.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/QD7PM945/2106.html:text/html},
+}
+
+@misc{mou_dragondiffusion_2023,
+	title = {{DragonDiffusion}: {Enabling} {Drag}-style {Manipulation} on {Diffusion} {Models}},
+	shorttitle = {{DragonDiffusion}},
+	url = {http://arxiv.org/abs/2307.02421},
+	doi = {10.48550/arXiv.2307.02421},
+	abstract = {Despite the ability of existing large-scale text-to-image (T2I) models to generate high-quality images from detailed textual descriptions, they often lack the ability to precisely edit the generated or real images. In this paper, we propose a novel image editing method, DragonDiffusion, enabling Drag-style manipulation on Diffusion models. Specifically, we construct classifier guidance based on the strong correspondence of intermediate features in the diffusion model. It can transform the editing signals into gradients via feature correspondence loss to modify the intermediate representation of the diffusion model. Based on this guidance strategy, we also build a multi-scale guidance to consider both semantic and geometric alignment. Moreover, a cross-branch self-attention is added to maintain the consistency between the original image and the editing result. Our method, through an efficient design, achieves various editing modes for the generated or real images, such as object moving, object resizing, object appearance replacement, and content dragging. It is worth noting that all editing and content preservation signals come from the image itself, and the model does not require fine-tuning or additional modules. Our source code will be available at https://github.com/MC-E/DragonDiffusion.},
+	urldate = {2023-07-17},
+	publisher = {arXiv},
+	author = {Mou, Chong and Wang, Xintao and Song, Jiechong and Shan, Ying and Zhang, Jian},
+	month = jul,
+	year = {2023},
+	note = {arXiv:2307.02421 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/XJS9MTT9/Mou et al. - 2023 - DragonDiffusion Enabling Drag-style Manipulation .pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/5MU7EYIM/2307.html:text/html},
+}
+
+@misc{shi_dragdiffusion_2023,
+	title = {{DragDiffusion}: {Harnessing} {Diffusion} {Models} for {Interactive} {Point}-based {Image} {Editing}},
+	shorttitle = {{DragDiffusion}},
+	url = {http://arxiv.org/abs/2306.14435},
+	doi = {10.48550/arXiv.2306.14435},
+	abstract = {Precise and controllable image editing is a challenging task that has attracted significant attention. Recently, DragGAN enables an interactive point-based image editing framework and achieves impressive editing results with pixel-level precision. However, since this method is based on generative adversarial networks (GAN), its generality is upper-bounded by the capacity of the pre-trained GAN models. In this work, we extend such an editing framework to diffusion models and propose DragDiffusion. By leveraging large-scale pretrained diffusion models, we greatly improve the applicability of interactive point-based editing in real world scenarios. While most existing diffusion-based image editing methods work on text embeddings, DragDiffusion optimizes the diffusion latent to achieve precise spatial control. Although diffusion models generate images in an iterative manner, we empirically show that optimizing diffusion latent at one single step suffices to generate coherent results, enabling DragDiffusion to complete high-quality editing efficiently. Extensive experiments across a wide range of challenging cases (e.g., multi-objects, diverse object categories, various styles, etc.) demonstrate the versatility and generality of DragDiffusion. Code: https://github.com/Yujun-Shi/DragDiffusion.},
+	urldate = {2023-07-17},
+	publisher = {arXiv},
+	author = {Shi, Yujun and Xue, Chuhui and Pan, Jiachun and Zhang, Wenqing and Tan, Vincent Y. F. and Bai, Song},
+	month = jul,
+	year = {2023},
+	note = {arXiv:2306.14435 [cs]},
+	keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Machine Learning},
+	file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/HMBGIU3W/Shi et al. - 2023 - DragDiffusion Harnessing Diffusion Models for Int.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/AGS4JE2X/2306.html:text/html},
 }