1113 lines
97 KiB
TeX
1113 lines
97 KiB
TeX
\documentclass[
|
|
11pt,
|
|
a4paper,
|
|
twoside,
|
|
openany
|
|
]{book}
|
|
|
|
%%%%%%%%%% Packages %%%%%%%%%%
|
|
|
|
% pdfx loads both hyperref and xcolor internally
|
|
% \usepackage{hyperref}
|
|
% \usepackage{xcolor}
|
|
\usepackage[a-3u]{pdfx}
|
|
|
|
\usepackage{fontspec}
|
|
\usepackage[nomath]{libertinus-otf}
|
|
\usepackage[a4paper, hmargin=2cm, vmargin=3cm]{geometry}
|
|
\usepackage{graphicx}
|
|
\usepackage{microtype}
|
|
\usepackage{amsmath}
|
|
\usepackage{amssymb}
|
|
\usepackage{amsfonts}
|
|
\usepackage{bbold}
|
|
\usepackage[numbers]{natbib}
|
|
\usepackage[hyperpageref]{backref}
|
|
\usepackage[french]{babel}
|
|
\usepackage{nomencl}
|
|
\usepackage{caption}
|
|
\usepackage{placeins}
|
|
\usepackage{calligra}
|
|
\usepackage{siunitx}
|
|
\sisetup{locale=FR}
|
|
\usepackage{tikz}
|
|
\usepackage{pgf-pie}
|
|
|
|
\usepackage{algorithmicx}
|
|
\usepackage{algorithm}
|
|
\usepackage{algpseudocode}
|
|
|
|
% We use \hypersetup to pass options to hyperref
|
|
\hypersetup{
|
|
colorlinks = true,
|
|
breaklinks = true,
|
|
}
|
|
|
|
% must be loaded after hyperref
|
|
\usepackage[toc,section=chapter]{glossaries}
|
|
\renewcommand*{\glstextformat}[1]{\textcolor{black}{#1}}
|
|
|
|
% paragraph settings
|
|
\setlength{\parindent}{0cm}
|
|
\setlength{\parskip}{7pt}%
|
|
|
|
% assets path
|
|
\graphicspath{{../assets/}}
|
|
|
|
% header and footer settings
|
|
\usepackage{lastpage}
|
|
\usepackage{fancyhdr}
|
|
|
|
% normal pages
|
|
\pagestyle{fancy}
|
|
\fancyhf{}
|
|
\rfoot{\hypersetup{hidelinks}\thepage/\pageref{LastPage}}
|
|
\renewcommand{\headrulewidth}{0pt}% Line at the header invisible
|
|
\renewcommand{\footrulewidth}{0pt}% Line at the footer invisible
|
|
|
|
% chapter pages
|
|
\fancypagestyle{plain}{
|
|
\fancyhf{}
|
|
\rfoot{\hypersetup{hidelinks}\thepage/\pageref{LastPage}}
|
|
\renewcommand{\headrulewidth}{0pt}% Line at the header invisible
|
|
\renewcommand{\footrulewidth}{0pt}% Line at the footer invisible
|
|
}
|
|
|
|
\title{
|
|
\huge \textbf{Rapport de Projet de Fin d'Études}
|
|
}
|
|
\author{
|
|
Laurent Fainsin \\
|
|
{\tt laurent@fainsin.bzh}
|
|
}
|
|
\date{
|
|
\vspace{10.5cm}
|
|
Département Sciences du Numérique \\
|
|
Troisième année \\
|
|
2022 — 2023
|
|
}
|
|
|
|
\DeclareMathOperator*{\argmax}{arg\,max}
|
|
\DeclareMathOperator*{\argmin}{arg\,min}
|
|
|
|
\newacronym{n7}{ENSEEIHT}{École nationale supérieure d'électrotechnique, d'électronique, d'informatique, d'hydraulique et des télécommunications}
|
|
\newacronym{pfe}{PFE}{Projet de Fin d'Études}
|
|
\newacronym{mads}{MADS}{Mathematics Applied to Design and Simulation}
|
|
\newacronym{flex}{FLEX}{physics inFormed machine Learning and numerical EXploration}
|
|
\newacronym{dst}{DST}{Digital Sciences and Technologies}
|
|
|
|
\newacronym{ml}{ML}{Machine Learning}
|
|
\newacronym{dl}{DL}{Deep Learning}
|
|
\newacronym{ai}{AI}{Artificial Intelligence}
|
|
\newacronym{ann}{ANN}{Artificial Neural Network}
|
|
\newacronym{pde}{PDE}{Partial Differential Equation}
|
|
\newacronym{mse}{MSE}{Mean Squared Error}
|
|
\newacronym{mae}{MAE}{Mean Absolute Error}
|
|
\newacronym{rmse}{RMSE}{Root Mean Squared Error}
|
|
\newacronym{mape}{MAPE}{Mean Absolute Percentage Error}
|
|
|
|
\newacronym{pca}{PCA}{Principal Component Analysis}
|
|
\newacronym{pod}{POD}{Proper Orthogonal Decomposition}
|
|
\newacronym{relu}{ReLU}{Rectified Linear Unit}
|
|
\newacronym{mlp}{MLP}{Multi-Layer Perceptron}
|
|
|
|
\newacronym{cfd}{CFD}{Computational Fluid Dynamic}
|
|
\newacronym{cnn}{CNN}{Convolutional Neural Network}
|
|
\newacronym{pvcnn}{PVCNN}{Point-Voxel CNN}
|
|
|
|
\newacronym{gnn}{GNN}{Graph Neural Network}
|
|
\newacronym{gan}{GAN}{Generative Adversarial Network}
|
|
\newacronym{ae}{AE}{Auto-Encoder}
|
|
\newacronym{vae}{VAE}{Variational Auto-Encoder}
|
|
|
|
\newacronym{nf}{NF}{Normalizing Flow}
|
|
|
|
\newacronym{kld}{KLD}{Kullback-Leibler Divergence}
|
|
\newacronym{hd}{HD}{Haussdorf Distance}
|
|
\newacronym{cd}{CD}{Chamfer Distance}
|
|
\newacronym{emd}{EMD}{Earth Mover Distance}
|
|
\newacronym{jsd}{JSD}{Jensen-Shannon Divergence}
|
|
\newacronym{cov}{COV}{Coverage}
|
|
\newacronym{mmd}{MMD}{Minimum Matching Distance}
|
|
\newacronym{1-nna}{1-NNA}{1-Nearest Neighbor Accuracy}
|
|
|
|
\newacronym{elbo}{ELBO}{Evidence Lower Bound}
|
|
\newacronym{vdm}{VDM}{Variational Diffusion Model}
|
|
\newacronym{ldm}{LDM}{Latent Diffusion Model}
|
|
\newacronym{cfg}{CFG}{Classifier-Free Guidance}
|
|
\newacronym{cg}{CG}{Classifier Guidance}
|
|
\newacronym{ddpm}{DDPM}{Denoising Diffusion Probabilistic Model}
|
|
\newacronym{t2i}{T2I}{Text to Image}
|
|
|
|
\newacronym{arm}{ARM}{Auto-Regressive Model}
|
|
\newacronym{nerf}{NeRF}{Neural Radiance Field}
|
|
|
|
\newacronym{gp}{GP}{Gaussian Process}
|
|
|
|
\newacronym{go}{Go}{Gigaoctet}
|
|
|
|
\newacronym{kpconv}{KPConv}{Kernel Point Convolution}
|
|
\newacronym{kpfcnn}{KP-FCNN}{Kernel Point Fully Convolutional Neural Network}
|
|
\newacronym{kpcnn}{KP-CNN}{Kernel Point Convolutional Neural Network}
|
|
\newacronym{pvconv}{PVConv}{Point Voxel Convolution}
|
|
\newacronym{spvconv}{SPVConv}{Sparse Point Voxel Convolution}
|
|
\newacronym{pvd}{PVD}{Point Voxel Diffusion}
|
|
\newacronym{lion}{LION}{Latent Point Diffusion Model}
|
|
|
|
\newacronym{cao}{CAO}{Conception Assistée par Ordinateur}
|
|
\newacronym{edp}{EDP}{Équation aux Dérivées Partielles}
|
|
|
|
% \newglossary{symbols}{sym}{sbl}{Notations mathématiques et symboles}
|
|
|
|
% \newglossaryentry{fn}{
|
|
% type={symbols},
|
|
% name={\ensuremath{F_n}},
|
|
% sort=fn,
|
|
% description={Empirical (sample) distribution function}
|
|
% }
|
|
|
|
\makenoidxglossaries
|
|
|
|
\begin{document}
|
|
|
|
\NoAutoSpacing
|
|
|
|
\frontmatter
|
|
|
|
\vbox{
|
|
\centering
|
|
\includegraphics[width=5cm]{inp_n7.jpg}
|
|
\hspace{1cm}
|
|
\includegraphics[width=5cm]{safran_logo.png}
|
|
\vspace{2cm}
|
|
\maketitle
|
|
}
|
|
|
|
{
|
|
\thispagestyle{empty}
|
|
\chapter*{Remerciements}
|
|
\addcontentsline{toc}{chapter}{Remerciements}
|
|
|
|
Je tiens à remercier Xavier Roynard, Michele Alessandro Bucci et Brian Staber, mes tuteurs de stage, ainsi que les équipes de Safran pour leur accueil et leur accompagnement tout au long de ce stage.
|
|
|
|
J'aimerais également remercier l'ensemble de mes professeurs de l'\gls{n7}, pour m'avoir permis d'acquérir les connaissances nécessaires à la réalisation de ce projet.
|
|
}
|
|
|
|
\clearpage
|
|
|
|
{
|
|
\glsresetall
|
|
\hypersetup{hidelinks}
|
|
\addcontentsline{toc}{chapter}{Table des matières}
|
|
\tableofcontents
|
|
}
|
|
|
|
\clearpage
|
|
|
|
{
|
|
\glsresetall
|
|
\hypersetup{hidelinks}
|
|
\addcontentsline{toc}{chapter}{Table des figures}
|
|
\listoffigures
|
|
}
|
|
|
|
\clearpage
|
|
|
|
{
|
|
\glsresetall
|
|
\hypersetup{hidelinks}
|
|
\printnoidxglossary[type=main,title={Abbréviations et acronymes}]
|
|
\printnoidxglossary[type=symbols]
|
|
}
|
|
|
|
\mainmatter
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
\chapter{Introduction}
|
|
|
|
\section{Présentation de l'entreprise}
|
|
|
|
Safran est un grand groupe industriel et technologique français, présent au niveau international dans les domaines de l'aéronautique, de l'espace et de la défense. Safran est le fruit de la fusion de Snecma et Sagem en 2005 et de l'acquisition de Zodiac Aerospace en 2018.
|
|
|
|
Les sociétés du groupe (Safran Aero Boosters, Safran Aerosystems, Safran Aircraft Engines, Safran Cabin, Safran Ceramics, Safran Electrical \& Power, Safran Electronics \& Defense, Safran Filtration System, Safran Helicopter Engines, Safran Landing Systems, Safran Nacelles, Safran Passenger Solutions, Safran Seats et Safran Transmission Systems) se répartissent entre cinq secteurs d'activité, à savoir la propulsion aéronautique et spatiale, les équipements aéronautiques, les intérieurs d'avions, les aérosystèmes et les applications militaires.
|
|
|
|
Dans le secteur des moteurs destinés aux avions civils, militaires et hélicoptères, Safran fait face à quatre concurrents majeurs: General Electric des États-Unis, Rolls-Royce du Royaume-Uni, Pratt \& Whitney des États-Unis et du Canada, ainsi que Honeywell des États-Unis. Dans le domaine des équipements, la compétition est plus vaste et variée:
|
|
\begin{itemize}
|
|
\item Pour les systèmes d'atterrissage: Collins Aerospace (États-Unis), General Electric (États-Unis) et Crane Aerospace \& Electronics (États-Unis).
|
|
\item En ce qui concerne les roues et les freins: Collins Aerospace, Honeywell (États-Unis) et Meggitt (Royaume-Uni).
|
|
\item Pour les nacelles: Collins Aerospace et Spirit AeroSystems (États-Unis).
|
|
\end{itemize}
|
|
Dans les domaines de la défense et de l'avionique, le principal concurrent est le groupe français Thales.
|
|
|
|
Par ailleurs, Safran s'est également investi dans le développement de drones tactiques, tels que le Sagem Sperwer et le Patroller. Dans ce secteur, les principaux concurrents de Safran incluent AAI Corp (États-Unis), IAI (Israël) et Thales.
|
|
|
|
Safran est une société anonyme, côté au CAC 40 depuis 2011, l'État Français en possède 11\% et ses 83 000 salariés 7\%. Une grande part de son développement économique repose sur la vente de moteurs pour l'aviation civile. Son chiffre d'affaire s'élève à 10 945 millions d'euros au S1 2023.
|
|
|
|
\begin{figure}[h!]
|
|
\begin{minipage}{.4\textwidth}
|
|
\begin{tikzpicture}
|
|
\pie{
|
|
82/Flottant,
|
|
11/État,
|
|
7/Salariés
|
|
}
|
|
\end{tikzpicture}
|
|
\end{minipage}
|
|
\begin{minipage}{.4\textwidth}
|
|
\begin{tikzpicture}
|
|
\pie{
|
|
52/Propulsion,
|
|
37/Équipements \& Défense,
|
|
11/Aircraft Interiors
|
|
}
|
|
\end{tikzpicture}
|
|
\end{minipage}
|
|
\caption{Gauche: Structure du capital au S1 2023. Droite: Répartition du chiffre d'affaires au S1 2023.}
|
|
\end{figure}
|
|
|
|
Il est possible d'identifier des cycles itératifs comprenant les phases de recherche, de production et de vente, avec une focalisation sur le développement des moteurs. Une fois que la phase de recherche aboutit à la conception du moteur, celui-ci entre en production. À ce stade, l'entreprise se concentre sur l'amélioration des processus de production et leur mise à l'échelle. Les ventes génèrent des revenus pour l'entreprise, qui sont ensuite réinvestis dans le développement du moteur suivant.
|
|
|
|
Le CFM56, dont le développement s'est achevé en 1978, détient toujours le record du moteur civil le plus vendu au monde. Les ventes de ce moteur continuent à soutenir l'activité de Safran jusqu'à ce jour. En parallèle, le moteur LEAP, annoncé en 2008, a été mis sur le marché en 2014. Il équipe la nouvelle génération d'avions tels que les Boeing 737 Max et les Airbus A320 neo. Pour maintenir l'expertise technique malgré les fluctuations entre les cycles de développement et de production, Safran a créé Safran Tech en 2015. Cette entité prépare d'ores et déjà les technologies qui seront utilisées entre 2025 et 2030.
|
|
|
|
Safran Tech représente le centre de Recherche et Technologie de l'Innovation au sein du groupe. Son fonctionnement diffère du modèle commercial classique puisqu'il n'est pas axé sur un marché spécifique. Il abrite une équipe d'environ 500 chercheurs et ingénieurs qui se répartissent dans divers pôles, tels que ``Matériaux \& Procédés", ``Énergie \& Propulsion", ``Systèmes Électriques et Électroniques", ainsi que ``Sciences et Technologies du Numérique". Sa mission principale est de stimuler l'innovation sur des problématiques ayant un impact sur l'ensemble des filiales du groupe.
|
|
|
|
Les équipes de recherche au sein de Safran Tech ne sont pas directement soumises aux contraintes imposées par d'importants projets industriels. Par conséquent, elles ont la liberté de mener des projets de recherche tout en collaborant avec des laboratoires externes tels que l'ONERA, le Centre des Matériaux des Mines, ainsi que les équipes d'autres entreprises. Cette structure permet à Safran Tech de rester agile dans ses activités de recherche et de développement, en explorant des solutions novatrices sans les contraintes de projets industriels spécifiques.
|
|
|
|
\newpage
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=16cm]{aube.jpg}
|
|
\caption{Aubes du moteur Leap-1A.}
|
|
\vspace*{-11pt}
|
|
\caption*{Copyright \href{https://medialibrary.safran-group.com/Photos/media/179440}{Cyril Abad / CAPA Pictures / Safran}.}
|
|
\end{figure}
|
|
|
|
\section{Contexte du stage}
|
|
|
|
Dans le domaine industriel, les codes de simulation numérique sont désormais un outil indispensable pour la conception de systèmes complexes, en particulier pour les modules de réacteurs d'avions ou d'hélicoptères.
|
|
|
|
De telles simulations sont par exemple utilisées pour évaluer les performances aérodynamiques d'un composant tel qu'une aube de turbine. En partant d'une géométrie nominale, dans la phase d'optimisation, la pièce est progressivement modifiée afin d'optimiser certaines quantités d'intérêt.
|
|
|
|
Malheureusement, ce processus de conception itératif présente deux limites:
|
|
\begin{itemize}
|
|
\item Le coût de calcul d'une simulation numérique de type \gls{cfd} est lourd, plusieurs heures sont nécessaires pour un unique calcul.
|
|
\item Le nombre de degrés de liberté pour la géométrie d'un profil complexe discrétisée avec un maillage non structuré est important, ce qui rend impossible l'exploration complète de l'espace de recherche de la solution optimale.
|
|
\end{itemize}
|
|
|
|
\smallskip
|
|
Les approches d'optimisation assistées par surfaces de réponse permettent de répondre partiellement à ces difficultés. Cependant cette stratégie admet deux limitations intrinsèques:
|
|
% citation needed for surface de réponse
|
|
\begin{itemize}
|
|
\item Elles nécessitent un long de travail de paramétrisation.
|
|
\item Elles souffrent grandement du fléau de la dimension (i.e. la taille des problèmes considérés est généralement limitée).
|
|
\end{itemize}
|
|
|
|
\smallskip
|
|
Toutefois, il est important de noter que les profils capables de générer de la portance, et par conséquent, de la puissance pour le moteur, présentent des similitudes marquées entre eux. Ces similitudes se manifestent généralement par de subtiles variations, principalement au niveau des bords d'attaque ou des bords de fuite. Cette observation conduit à l'hypothèse qu'une représentation latente parcimonieuse des aubes, qu'elles soient destinées à des turbines ou à des compresseurs, existe potentiellement. Cette représentation latente pourrait être exploitée pour explorer de manière plus efficiente l'espace de recherche en vue d'optimiser les quantités d'intérêt, ou pour vérifier la conformité aux contraintes de conception.
|
|
|
|
Récemment, les modèles génératifs profonds comme les \glspl{vae} ou les \glspl{gan} ont été appliqués avec succès à des données structurées (e.g. des images). Ceux-ci permettent de construire un espace latent représentatif d'un jeu de données spécifique et de générer de nouveaux échantillons qui partagent des caractéristiques importantes du jeu de données d'entraînement.
|
|
|
|
Cependant, dans le cas de la simulation numérique, les données prennent souvent la forme de graphes en raison de l'utilisation de maillages pour représenter les surfaces des pièces à concevoir. Dans le contexte d'une application industrielle, il est donc crucial d'adapter les modèles susmentionnés afin de pouvoir utiliser des données non structurées en entrée. Les \glspl{gnn} permettent de traiter des données non structurées telles que des maillages ou des nuages de points.
|
|
|
|
Différentes solutions ont été proposées dans la littérature pour réaliser des convolutions et agrégations sur graphes ou nuages de points. Cependant, peu d'entre elles conviennent à l'application des réseaux sur graphes sur des données générées par des simulations numériques, car l'ordre de grandeur du nombre de nœuds est généralement trop important.
|
|
|
|
Le but de ce stage est d'évaluer le potentiel de ces nouvelles méthodes sur des jeux de données réalisés en internes et représentatifs pour Safran. Et éventuellement de proposer des améliorations spécifiques aux maillages utilisés en simulations numériques.
|
|
|
|
L'étude vise tout d'abord à étudier la bibliographie disponible d'un côté sur les modèles génératifs et d'un autre sur les réseaux convolutionnels sur graphes. L'objectif est, dans une première phase, de faire un benchmark des différentes solutions de modèles génératifs sur graphe de type \gls{vae} et \gls{gan} afin de créer une représentation latente des géométries d'aubes 3D. Pour cela un dataset avec quelques milliers d'échantillons d'aubes 3D et leurs performances aérodynamique est disponible à Safran. Le modèle résultant sera ensuite testé pour générer de nouvelles géométries et pour prédire les quantités d'intérêt par le biais de métamodèles classiques. Enfin, si l'avancement sur les premières tâches le permet, d'autres modèles génératifs peuvent être considérés comme les \glspl{nf} ou les \glspl{vdm}.
|
|
|
|
\chapter{État de l'art}
|
|
|
|
Ce chapitre présente les différents concepts et méthodes nécessaires à la compréhension du travail réalisé durant ce stage.
|
|
|
|
Dans le cadre de cette étude, nous nous intéressons à la génération de géométries d'aubes de turbines par l'intermédiaire de maillages. Cette approche est motivée par plusieurs raisons, dont les considérations spécifiques suivantes:
|
|
\begin{itemize}
|
|
\item Les données que nous traitons sont destinées à alimenter des simulations numériques, où l'espace est discrétisé pour résoudre numériquement des \gls{edp} liées à la mécanique des solides ou des fluides.
|
|
\item Les protocoles de \gls{cao}, bien qu'efficaces pour la représentation géométrique, présentent des défis liés à la propriété des formats et aux différentes manières de représenter une même géométrie. Ceci peut être vu dans des logiciels tels que Catia, où diverses représentations de \gls{cao} peuvent coexister pour une géométrie donnée, rendant complexe la création d'un processus inverse.
|
|
\end{itemize}
|
|
|
|
Les maillages sont un domaine relativement peu exploré dans la littérature de l'apprentissage automatique, et cette exploration est encore plus limitée pour les représentations par \gls{cao}, en comparaison avec les modalités plus classiques telles que les images, le texte ou encore l'audio. La complexité découle en partie du caractère non structuré de ces données. En conséquence, il est nécessaire d'utiliser des méthodes spécifiques pour traiter ces données.
|
|
|
|
Il reste pertinent de noter que les méthodes présentées dans ce chapitre sont récentes et que la littérature évolue très rapidement. De plus, les méthodes existantes sont très nombreuses et il est impossible de toutes les présenter. Nous avons donc choisi de présenter les méthodes les plus pertinentes pour permettre une bonne compréhension globale du travail réalisé durant ce stage.
|
|
|
|
\FloatBarrier
|
|
\glsunset{gnn}
|
|
\section{\acrfull*{gnn}}
|
|
|
|
Les graphes sont des structures de données qui permettent de représenter des relations entre des entités. Un graphe est défini par un ensemble de nœuds et un ensemble d'arêtes. Les arêtes représentent des relations entre les nœuds. Ces relations peuvent être de différents types, comme des relations de parenté, de proximité ou encore de similarité. Les graphes peuvent être dirigés ou non. Dans le cas d'un graphe dirigé, les arêtes sont orientées et représentent une relation unidirectionnelle. Dans le cas d'un graphe non dirigé, les arêtes ne sont pas orientées et représentent une relation bidirectionnelle. Les graphes peuvent être pondérés ou non. Dans le cas d'un graphe pondéré, les arêtes sont associées à une valeur qui représente l'intensité de la relation entre les nœuds.
|
|
|
|
Les graphes offrent une représentation intuitive de diverses structures, visibles dans la figure~\ref{fig:graph_example}, telles que les réseaux de communication, les réseaux sociaux, les molécules ou encore les maillages. Par conséquent, les graphes sont un type de données largement présents dans la nature et sont très répandu dans le domaine de l'ingénierie. De manière générale, les graphes peuvent être considérés comme une généralisation des données structurées, telles que les images ou les séries temporelles. En effet, toute données structurées/régulières peut facilement être traduite en un graphe régulier.
|
|
|
|
Les maillages constituent une catégorie spécifique de graphes largement employée pour la représentation de surfaces. En plus des éléments caractéristiques des graphes, les maillages intègrent généralement des attributs associés à chaque triangle qui le compose. Ces attributs englobent des propriétés telles que les normales, les textures et les caractéristiques physiques, entre autres.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{example-graphs.jpg}
|
|
\caption{Exemple de graphes.}
|
|
\vspace*{-11pt}
|
|
\caption*{Source: \href{https://blogs.nvidia.com/blog/2022/10/24/what-are-graph-neural-networks/}{NVIDIA, 2022}.}
|
|
\label{fig:graph_example}
|
|
\end{figure}
|
|
|
|
Les \glspl{gnn} sont une famille de modèles qui permettent de traiter ce type de structures de données. Ces modèles sont majoritairement basés sur des opérations de convolution et d'agrégation, similairement aux opérations de convolution et de pooling utilisées dans les réseaux de neurones pour les modalités plus classique comme les images.
|
|
On retrouve de même dans les \glspl{gnn} des architectures avancées, inspirées des réseaux de neurones classiques, comme les réseaux résiduels~\cite{gao_graph_2019}, les réseaux récurrents~\cite{li_gated_2017} ou l'attention~\cite{velickovic_graph_2018,brody_how_2022}.
|
|
|
|
Les applications les plus courantes de ces réseaux incluent la classification~\cite{kipf_semi-supervised_2017} de documents, la détection de fraudes~\cite{ma_comprehensive_2021} et les systèmes de recommandation~\cite{gao_survey_2023}. En revanche, la génération de graphes est moins répandue et se limite souvent dans la littérature à la génération de petites molécules~\cite{kipf_graph_2020,simonovsky_graphvae_2018}.
|
|
|
|
\FloatBarrier
|
|
\section{Métriques et distances}
|
|
|
|
Il existe de nombreuses distances et métriques spécifiques permettant d'analyser les distributions et les ensembles de données sous forme de nuages de points. Dans cette section, nous présentons certaines de ces mesures, qui sont couramment utilisées dans les articles présentés plus loin.
|
|
|
|
\glsunset{kld}
|
|
\subsection{\acrfull*{kld}}
|
|
|
|
Soit deux distributions de probabilités discrètes $P$ et $Q$ sur un ensemble $X$.
|
|
\begin{equation}
|
|
D_{\text{KL}}(P\|Q) = \sum_{x \in X} P(x) \log \frac{P(x)}{Q(x)}
|
|
\end{equation}
|
|
La Divergence de Kullback-Leibler est une mesure de la dissimilarité entre deux distributions de probabilité. Elle évalue la quantité d'information perdue lorsque l'on tente d'approximer une distribution par une autre. La \gls{kld} n'est pas une distance, elle ne satisfait pas la propriété de symétrie ($D_{\text{KL}}(P\|Q) \neq D_{\text{KL}}(Q\|P)$) ni l'inégalité triangulaire ($D_{\text{KL}}(P\|R) \not\leq D_{\text{KL}}(P\|Q) + D_{\text{KL}}(Q\|R)$).
|
|
|
|
\glsunset{hd}
|
|
\subsection{\acrfull*{hd}}
|
|
|
|
Soit $X$ et $Y$ deux nuages de points.
|
|
\begin{equation}
|
|
d_\text{H}(X, Y) = \max \left\{ \sup_{x \in X} \inf_{y \in Y} d(x,y), \sup_{y \in Y} \inf_{x \in X} d(x, y) \right\}
|
|
\end{equation}
|
|
La distance de Hausdorff est une mesure quantitative utilisée pour évaluer la similarité ou la dissimilarité entre deux ensembles de points dans un espace métrique. Elle calcule la plus grande distance d'un point d'un ensemble à son point le plus proche dans l'autre ensemble. En d'autres termes, elle capture la plus grande distance entre les ensembles, ce qui en fait un outil utile pour comparer des formes, des structures ou des distributions de points.
|
|
|
|
\glsunset{cd}
|
|
\subsection{\acrfull*{cd}}
|
|
|
|
Soit $X$ et $Y$ deux nuages de points.
|
|
\begin{equation}
|
|
d_{\text{CD}}(X, Y) = \sum_{x \in X} \min_{y \in Y} \|x - y\|^2_2 + \sum_{y \in Y} \min_{x \in X} \|x - y\|^2_2
|
|
\end{equation}
|
|
La distance de Chamfer est une mesure de similarité entre deux ensembles de points dans un espace métrique. Elle évalue la proximité entre les points des ensembles en calculant la somme des distances entre chaque point d'un ensemble et son point le plus proche dans l'autre ensemble.
|
|
|
|
\glsunset{emd}
|
|
\subsection{\acrfull*{emd}}
|
|
|
|
Soit $X$ et $Y$ deux nuages de points tels que $|X| = |Y|$, et $\phi: X \to Y$ une bijection.
|
|
\begin{equation}
|
|
d_{\text{EMD}}(X, Y) = \min_{ \phi: X \to Y } \sum_{x \in X} \| x - \phi(x) \|_2
|
|
\end{equation}
|
|
La distance du transport optimal, également appelée distance du ``Earth Mover", est une mesure de similarité entre deux distributions de masse dans un espace métrique. Elle évalue le coût minimum nécessaire pour déplacer une distribution de masse en une autre en respectant certaines contraintes de déplacement. Cette distance est couramment utilisée pour comparer des distributions de données, telles que des histogrammes, des vecteurs de caractéristiques ou des nuages de points, en prenant en compte non seulement les distances entre les éléments correspondants, mais aussi les coûts associés à leur déplacement.
|
|
|
|
\glsunset{jsd}
|
|
\subsection{\acrfull*{jsd}}
|
|
|
|
Soit $S_g$ un ensemble de nuages de points générés et $S_r$ un ensemble de nuages de points de référence.
|
|
\begin{equation}
|
|
\text{JSD}(S_g, S_r) = \frac12 D_{\text{KL}}(S_g \| M) + \frac12 D_{\text{KL}}(S_r \| M), \quad M = \frac12 (S_g + S_r)
|
|
\end{equation}
|
|
La divergence de Jensen-Shannon est une mesure de la similarité entre deux distributions de probabilité. Elle est calculée comme la moyenne des \glspl{kld} entre chaque distribution et la moyenne de ces distributions. Contrairement à la \gls{kld}, la \gls{jsd} est symétrique et bornée entre 0 et 1.
|
|
Cependant, la \gls{jsd} utilise la distribution globale des nuages de points et non la distribution des nuages de points individuellements. Ainsi, un modèle qui produit toujours une ``forme moyenne" peut obtenir un score \gls{jsd} parfait sans apprendre de distributions significatives.
|
|
|
|
\glsunset{cov}
|
|
\subsection{\acrfull*{cov}}
|
|
|
|
Soit $S_g$ un ensemble de nuages de points générés, $S_r$ un ensemble de nuages de points de référence et $D$ une distance entre nuages de points.
|
|
\begin{equation}
|
|
\text{COV}(S_g, S_r) = \frac{ | \{ \argmin_{Y \in S_r} D(X, Y) | X \in S_g \} | }{ |S_r| }
|
|
\end{equation}
|
|
La couverture évalue le nombre de nuages de points de référence qui sont appariés à au moins une forme générée.
|
|
La couverture permet de quantifier la diversité des générations mais est sensible à la perte de modes, cependant elle n'évalue pas la qualité des nuages de points générés.
|
|
Ainsi, des nuages de points générés de faible qualité mais diversifiés peuvent obtenir des scores de couverture élevés.
|
|
|
|
\glsunset{mmd}
|
|
\subsection{\acrfull*{mmd}}
|
|
|
|
Soit $S_g$ un ensemble de nuages de points générés, $S_r$ un ensemble de nuages de points de référence et $D$ une distance entre nuages de points.
|
|
\begin{equation}
|
|
\text{MMD}(S_g, S_r) = \frac{1}{|S_r|} \sum_{Y \in S_r} \min_{X \in S_g} D(X, Y)
|
|
\end{equation}
|
|
La distance de correspondance minimale, est une mesure qui évalue la différence entre deux ensembles ordonnés. Elle calcule la plus petite somme des distances entre les éléments des deux ensembles.
|
|
Cependant, la \gls{mmd} est en réalité très peu sensible aux nuages de points de qualité médiocre dans $S_g$, étant donné leur faible probabilité d'être appariés avec des nuages de points réels dans $S_r$. Dans un cas extrême, on pourrait envisager que $S_g$ soit composé principalement de nuages de points de très mauvaise qualité, ainsi que de nuages de point pratiquement identiques à ceux de $S_r$. Dans ce cas, on obtiendrait un score de raisonnablement élevé.
|
|
|
|
\glsunset{1-nna}
|
|
\subsection{\acrfull*{1-nna}}
|
|
|
|
Soit $S_g$ un ensemble de nuages de points générés, $S_r$ un ensemble de nuages de points de référence, $N_X$ les voisins les plus proches de $X$ dans $S_{-X} = S_r \cup S_g - \{X\}$, $N_Y$ les voisins les plus proches de $Y$ dans $S_{-Y} = S_r \cup S_g - \{Y\}$ et $\mathbb{1}$ la fonction indicatrice.
|
|
\begin{equation}
|
|
\text{1-NNA}(S_g, S_r) = \frac{ \sum_{X \in S_g} \mathbb{1}[N_X \in S_g] + \sum_{Y \in S_r} \mathbb{1}[N_Y \in S_r] }{ |S_g| + |S_r| }
|
|
\end{equation}
|
|
Pour chaque point d'un ensemble de nuages de points, cette mesure évalue par une classification par plus proche voisin, si celui-ci provient de $S_g$ ou de $S_r$. La précision de cette classification est ensuite calculée comme la moyenne des précisions de chaque point de $S_g$ et de $S_r$.
|
|
|
|
En supposant que $S_g$ et $S_r$ soient échantillonnés à partir de la même distribution, la précision d'un tel classificateur devrait converger vers 50\% avec un nombre suffisant d'échantillons. Plus la précision se rapproche de 50\%, plus les similarités entre $S_g$ et $S_r$ sont prononcées, ce qui indique une meilleure capacité du modèle à apprendre la distribution cible. Dans notre contexte, le plus proche voisin peut être calculé à l'aide de la \gls{cd} ou de l'\gls{emd}. Contrairement à la \gls{jsd}, le \gls{1-nna} considère la similarité entre les distributions de formes plutôt qu'entre les distributions totale des points. Contrairement au \gls{cov} et au \gls{mmd}, la \gls{1-nna} mesure directement la similarité des distributions et prend en compte à la fois la diversité et la qualité.
|
|
|
|
\FloatBarrier
|
|
\section{Modèles génératifs}
|
|
|
|
Les modèles génératifs sont une famille de modèles qui permettent de générer de nouvelles données d'une distribution de données au préalablement apprise. Ces modèles sont très utilisés dans le domaine de l'apprentissage automatique pour générer des images, du texte ou encore de la musique. Ces modèles sont encore relativement peu utilisés dans le domaine de l'ingénierie pour générer des pièces industrielles.
|
|
|
|
Il existe plusieurs sous familles de modèles génératifs, chacune basées sur des principes différents, possédant ainsi des avantages et des inconvénients. Il est donc important de bien comprendre les différences entre ces modèles pour pouvoir choisir le modèle le plus adapté à la problématique. Plusieurs études~\cite{faez_deep_2020,guo_systematic_2022,zhu_survey_2022} ont déjà été réalisées pour comparer ces modèles, nous nous baserons donc partiellement sur celles-ci pour présenter les modèles les plus pertinents pour notre problématique.
|
|
|
|
\FloatBarrier
|
|
\glsunset{gan}
|
|
\subsection{\acrfull*{gan}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{gan-architecture.png}
|
|
\caption{Architecture d'un \gls{gan}.}
|
|
\vspace*{-11pt}
|
|
\caption*{Source: \href{https://lilianweng.github.io/posts/2017-08-20-gan/}{Lilian Weng, 2017}.}
|
|
\label{fig:gan-architecture}
|
|
\end{figure}
|
|
|
|
Les \glspl{gan}~\cite{goodfellow_generative_2014} sont la famille de modèles génératifs la plus renommée. Ces modèles reposent sur un principe compétitif impliquant deux réseaux de neurones, visibles sur la figure~\ref{fig:gan-architecture}. Le premier réseau, connu sous le nom de générateur, a pour objectif de produire de nouvelles données. Le deuxième réseau, appelé discriminateur, est chargé de distinguer les données générées par le générateur des données réelles. Le générateur est entraîné à tromper le discriminateur tandis que le discriminateur est entraîné à identifier les données générées par rapport aux données réelles. Cette compétition entre les deux réseaux permet de former le générateur à générer des données de plus en plus réalistes. Ce type d'apprentissage est auto-supervisé, car il ne nécessite pas l'utilisation d'annotations sur les données pour entraîner le modèle.
|
|
|
|
Mathématiquement, on peut poser le problème d'optimisation suivant:
|
|
\begin{equation}
|
|
\min_\text{G} \max_\text{D} L(\text{D}, \text{G}) = \mathbb{E}_{x \sim p(\boldsymbol{x})} [ \log \text{D}(x) ] + \mathbb{E}_{z \sim p(\boldsymbol{z})} [ \log (1 - \text{D}(G(z))) ]
|
|
\end{equation}
|
|
Les \glspl{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 \glspl{gan} sont par exemple sujets à de nombreux problèmes~\cite{zhao_bias_2018}, tel que le problème de \textit{mode collapse}, où le générateur génère toujours la même image, mais aussi le 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}, 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.
|
|
|
|
\FloatBarrier
|
|
\glsunset{vae}
|
|
\subsection{\acrfull*{vae}}
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{vae-architecture.png}
|
|
\caption{Architecture d'un \gls{vae}.}
|
|
\vspace*{-11pt}
|
|
\caption*{Source: \href{https://lilianweng.github.io/posts/2018-08-12-vae/}{Lilian Weng, 2018}.}
|
|
\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, 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.
|
|
De même, chez les \glspl{vae} la dimension de cette espace latent est configurée par l'architecture du réseau et peut être réduite à volonté. L'encodeur et le décodeur peuvent ainsi être conceptualisés comme des opérateurs de compression et de décompression.
|
|
|
|
Mathématiquement, on peut modéliser ces variables latentes et nos données d'entrée par une distribution jointe $p(\boldsymbol{x}, \boldsymbol{z})$. Les approches génératives ont pour but de trouver un modèle maximisant la vraissemblance de nos données d'entrée $p(\boldsymbol{x})$.
|
|
En pratique, maximiser directement la vraissemblance est impossible car cela reviendrait à calculer la marginalisation:
|
|
\begin{equation}
|
|
p(\boldsymbol{x}) = \int p(\boldsymbol{x}, \boldsymbol{z}) d\boldsymbol{z}
|
|
\end{equation}
|
|
|
|
Cependant, il est tout de même possible de trouver une borne inférieure de l'évidence, appelée \gls{elbo}:
|
|
\begin{align}
|
|
p(\boldsymbol{x}) \propto \log p(\boldsymbol{x}) & = \mathbb{E}_{ q_\phi( \boldsymbol{z} | \boldsymbol{x} ) } \left[ \log \frac{ p(\boldsymbol{x}, \boldsymbol{z}) } { q(\boldsymbol{z}|\boldsymbol{x}) }\right] - D_{\text{KL}}(q_\phi(\boldsymbol{z}|\boldsymbol{x}) \ \| \ p(\boldsymbol{z}|\boldsymbol{x})) \\
|
|
& \geq \mathbb{E}_{ q_\phi( \boldsymbol{z} | \boldsymbol{x} ) } \left[ \log \frac{ p(\boldsymbol{x}, \boldsymbol{z}) } { q_\phi(\boldsymbol{z}|\boldsymbol{x}) }\right] \label{eq:elbo}
|
|
\end{align}
|
|
Ainsi, puisque la \gls{kld} est toujours positive et car $\log p(\boldsymbol{x})$ est constant par rapport aux paramètres $\phi$ de l'encodeur, maximiser l'\gls{elbo} (\ref{eq:elbo}) revient à maximiser l'évidence et donc la vraissemblance de nos données d'entrée $p(\boldsymbol{x})$. En simplifiant l'\gls{elbo}, on dérive une fonction de coût pour l'entrainement du \gls{vae}:
|
|
\begin{equation}
|
|
\mathbb{E}_{ q_\phi( \boldsymbol{z} | \boldsymbol{x} ) } \left[ \log \frac{ p(\boldsymbol{x}, \boldsymbol{z}) } { q_\phi(\boldsymbol{z}|\boldsymbol{x}) }\right] = \underbrace{ \mathbb{E}_{ q_\phi( \boldsymbol{z} | \boldsymbol{x} ) } [ \log p_\theta(\boldsymbol{x}|\boldsymbol{z}) ]}_{\text{reconstruction term}} - \underbrace{ D_{\text{KL}}(q_\phi(\boldsymbol{z}|\boldsymbol{x}) \ \| \ p(\boldsymbol{z})) }_{\text{prior matching term}}
|
|
\end{equation}
|
|
|
|
Une fois la convergence atteinte, l'intéret de cet espace latent, lorsqu'il est accompagné de sont decodeur, est qu'il permet de générer de nouvelles données, par example en échantillonant $z = \mu + \sigma \odot \epsilon$, ou bien en interpolant entre deux points latents, ou encore en modifiant légèrement un point spécifique de cet espace.
|
|
|
|
Tout comme les \glspl{gan}, de nombreuses améliorations (β-VAE~\cite{burgess_understanding_2018,higgins_beta-vae_2022,alemi_deep_2019}, f-VAE~\cite{su_f-vaes_2018}) et variations (SetVAE~\cite{kim_setvae_2021}, AutoDecoder~\cite{shah_auto-decoding_2020}, GraphVAE~\cite{simonovsky_graphvae_2018}) ont été proposées pour les \glspl{vae}. Ces modèles sont plus faciles à entraîner que les \glspl{gan} et présentent une plus grande stabilité. Cependant, les \glspl{vae} ont tendance à générer des données floues et peu réalistes~\cite{yacoby_failure_2021}, et en général produisent des résultats de moins bonne qualité que les \glspl{gan}, en particulier pour des résolutions élevées.
|
|
|
|
\FloatBarrier
|
|
\glsunset{nf}
|
|
\subsection{\acrfull*{nf}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{nf-architecture.png}
|
|
\caption{Architecture d'un \gls{nf}.}
|
|
\vspace*{-11pt}
|
|
\caption*{Source: \href{https://lilianweng.github.io/posts/2018-10-13-flow-models/}{Lilian Weng, 2018}.}
|
|
\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, 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}, modifié par Furthest Point Sampling pour contenir uniquement 2048 points par nuages.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.9\textwidth]{shapenet.png}
|
|
\caption{Exemple de datasets d'objets 3D.}
|
|
\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}, visibles sur la figure~\ref{fig:shapenet}.
|
|
|
|
\FloatBarrier
|
|
\glsunset{vdm}
|
|
\subsection{\acrfull*{vdm}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{vdm-architecture.png}
|
|
\caption{Architecture d'un \gls{vdm}~\cite{luo_understanding_2022}.}
|
|
\label{fig:vdm-architecture}
|
|
\end{figure}
|
|
|
|
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).
|
|
|
|
Dans leur architecture, les \glspl{vdm} peuvent être vus comme une chaine de Markov de \glspl{vae} hiérarchiques avec trois restrictions notable:
|
|
\begin{itemize}
|
|
\item La dimension latente est exactement égale à la dimension des données d'entrée.
|
|
\item La structure de l'encodeur est fixée et pré-définie. Il s'agit d'un encodeur linéaire gaussien, c'est-à-dire une distribution gaussienne centrée autour de la sortie de l'étape précédente.
|
|
\item Les paramètres de l'encodeur varient au cours du temps de sorte que la distribution latente à l'étape finale $T$ soit une gaussienne standard.
|
|
\end{itemize}
|
|
|
|
On note $q$ les ``encodeurs" et $p$ les ``décodeurs" des \glspl{vae} de la chaine de Markov, $x_0 \sim \boldsymbol{x}_0$ un échantillon de notre distribution de données, $x_T \sim \boldsymbol{x}_T$ un échantillon d'une gaussienne isotropique, et $x_t \sim \boldsymbol{x}_t$ tout échantillon intermédiaire, avec $t$ le temps de diffusion, $T$ le temps final de diffusion. On désigne également les transitions de $x_t$ à $x_{t+1}$ comme le ``forward process", et les transition de $x_t$ à $x_{t-1}$ comme le ``reverse process".
|
|
|
|
D'après les contraintes précédentes, on peut écrire pour le forward process:
|
|
\begin{equation}
|
|
q(\boldsymbol{x}_t | \boldsymbol{x}_{t-1}) = \mathcal{N} ( \boldsymbol{x}_t; \sqrt{\alpha_t} \boldsymbol{x}_0, (1 - \alpha_t) \mathbf{I} ) \label{eq:ddpm_forward}
|
|
\end{equation}
|
|
avec $\alpha_t \in [0, 1]$ qui évolue en $t$ selon une suite décroissante fixée ou apprenable (i.e. via un réseau de neurones).
|
|
|
|
Cependant puisque toutes ces opérations sont linéaires et gaussiennes, si l'on souhaite obtenir $x_t$ à partir de $x_0$, au lieu d'appliquer $t$ fois la relation \ref{eq:ddpm_forward}, on peut simplifier comme suit:
|
|
\begin{equation}
|
|
q(\boldsymbol{x}_t | \boldsymbol{x}_0) = \mathcal{N} ( \boldsymbol{x}_t; \sqrt{\overline\alpha_t} \boldsymbol{x}_0, (1 - \overline\alpha_t) \mathbf{I} ), \quad \overline\alpha_t = \prod_{t=1}^t \alpha_t
|
|
\end{equation}
|
|
L'objectif de la diffusion est de trouver une approximation du processus inverse $p_\theta (\boldsymbol{x}_{t-1} | \boldsymbol{x}_t) \approx p(\boldsymbol{x}_{t-1} | \boldsymbol{x}_t)$ (i.e. via un réseau de neurones, conditionnée sur $t$).
|
|
Cependant via une dérivation de l'\gls{elbo} et un conditionnement additionnel, on peut montrer que cela revient à minimiser la \gls{kld} entre $q(\boldsymbol{x}_{t-1} | \boldsymbol{x}_t, \boldsymbol{x_0})$ et $p_\theta (\boldsymbol{x}_{t-1} | \boldsymbol{x}_t)$. Ensuite, via une application de la formule de Bayes, on obtient:
|
|
\begin{equation}
|
|
q(\boldsymbol{x}_{t-1} | \boldsymbol{x}_t, \boldsymbol{x_0}) \propto \mathcal{N} ( \boldsymbol{x}_{t-1}; \mu_q (\boldsymbol{x}_t, \boldsymbol{x}_0), \Sigma_q (\boldsymbol{x}_t) )
|
|
\end{equation}
|
|
avec:
|
|
\begin{equation}
|
|
\mu_q (\boldsymbol{x}_t, \boldsymbol{x}_0) = \frac{ \sqrt{\alpha_t} (1 - \overline{\alpha}_{t-1}) \boldsymbol{x}_t + \sqrt{\overline{\alpha}_{t-1}} (1 - \alpha_t) \boldsymbol{x}_0 } { 1 - \overline{\alpha}_t }, \quad \Sigma_q (\boldsymbol{x}_t) = \frac{ (1 - \alpha_t)(1 - \overline{\alpha}_{t-1}) } { 1 - \overline{\alpha}_t }
|
|
\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_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}.
|
|
|
|
\begin{algorithm}[h!]
|
|
\caption{\gls{ddpm} training}
|
|
\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 $\epsilon_\theta$: neural network
|
|
\Repeat
|
|
\State $x_0 \sim \boldsymbol{x_0}$
|
|
\State $t \sim \text{Uniform}( \lbrack\!\lbrack 1, T \rbrack\!\rbrack )$
|
|
\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}
|
|
|
|
Après avoir achevé l'entraînement adéquat de notre modèle, on peut désormais appliquer $p_\theta (\boldsymbol{x}_{t-1} | \boldsymbol{x}_t)$ itérativement pour passer d'un échantillon $x_T$ à sa prédiction $\hat{x}_0$. Dans les faits, le réseau génère des reconstructions qui ressemblent fortement à nos données d'apprentissage, créant ainsi de nouvelles données. Formellement, l'échantillonnage est décrit dans l'algorithme \ref{alg:ddpm_sampling}.
|
|
|
|
\begin{algorithm}[h!]
|
|
\caption{\gls{ddpm} sampling}
|
|
\label{alg:ddpm_sampling}
|
|
\begin{algorithmic}[1]
|
|
\Require $T \in \mathbb{N}^\star$: number of diffusion steps
|
|
\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$}
|
|
\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(x_t, t)$
|
|
\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$
|
|
\EndFor
|
|
\State \Return $x_0$
|
|
\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 du recuit de Langevin~\cite{song_generative_2020}.
|
|
|
|
\FloatBarrier
|
|
\glsunset{ldm}
|
|
\subsubsection{\acrfull*{ldm}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=6cm]{ldm-compression.jpg}\hspace*{5mm}\includegraphics[width=10cm]{ldm-architecture.png}
|
|
\caption{Architecture d'un \gls{ldm}~\cite{rombach_high-resolution_2022}.}
|
|
\label{fig:ldm-architecture}
|
|
\end{figure}
|
|
|
|
Une amélioration significative des \glspl{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 dimensions nettement réduites), tout comme pour les \glspl{vae}, confère des avantages substantiels en termes de représentativité des données. La transition des \glspl{vdm} vers les \glspl{ldm} consiste en l'introduction préalable d'un second modèle, qu'il soit paramétrique ou non, destiné à obtenir une représentation alternative de nos données.
|
|
|
|
Les \glspl{vae} sont fréquemment employés à cet effet. L'entrainement des \glspl{ldm} ne changent pas par rapport aux \glspl{vdm}, seul le domaine d'apprentissage du modèle est modifié. Ainsi cette approche induit généralement 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{Conditionnement \& Guidance}
|
|
|
|
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 seconde donnée d'entrée, tel qu'une image, un scalaire, un audio, ou du texte, à l'instar des modèles de type \gls{t2i} tels que DALL·E 2 ou Stable Diffusion.
|
|
|
|
Deux méthodes existent actuellement 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'entrainement d'un classificateur 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 classificateur par rapport à $x_t$ est ensuite utilisé pour guider le modèle de diffusion à générer des données de classe $y$. Ainsi selon la formulation du score matching on obtient:
|
|
\begin{align}
|
|
\nabla_{\boldsymbol{x}_t} \log p (\boldsymbol{x}_t | y) & = \nabla_{\boldsymbol{x}_t} \log p \left( \frac{ p(\boldsymbol{x}_t) p(y | \boldsymbol{x}_t) }{ p(y) } \right) \\
|
|
& = \underbrace{ \nabla_{\boldsymbol{x}_t} \log p (\boldsymbol{x}_t) }_{\text{unconditional score}} + \underbrace{ \nabla_{\boldsymbol{x}_t} \log q (y | \boldsymbol{x}_t) }_{\text{adversarial gradient}} \label{eq:165}
|
|
\end{align}
|
|
Si l'on remplace $q( y | \boldsymbol{x}_t )$ par $f_\phi ( y | \boldsymbol{x}_t )$ et que l'on introduit un facteur de guidage $\gamma \in \mathbb{R}$, on obtient:
|
|
\begin{align}
|
|
\nabla_{\boldsymbol{x}_t} \log p (\boldsymbol{x}_t | y) & \approx \nabla_{\boldsymbol{x}_t} \log q (\boldsymbol{x}_t) + \gamma \nabla_{\boldsymbol{x}_t} \log f_\phi (y | \boldsymbol{x}_t) \label{eq:166} \\
|
|
& = - \frac{1}{ \sqrt{1 - \overline{\alpha}_t} } \epsilon_\theta(\boldsymbol{x}_t, t) + \gamma \nabla_{\boldsymbol{x}_t} \log f_\phi (y | \boldsymbol{x}_t) \\
|
|
& = - \frac{1}{ \sqrt{1 - \overline{\alpha}_t} } \left[ \epsilon_\theta(\boldsymbol{x}_t, t) - \gamma \sqrt{1 - \overline{\alpha}_t} \nabla_{\boldsymbol{x}_t} \log f_\phi (y | \boldsymbol{x}_t) \right]
|
|
\end{align}
|
|
On identifie alors:
|
|
\begin{equation}
|
|
\epsilon_\theta(\boldsymbol{x}_t, t, c) = \epsilon_\theta(\boldsymbol{x}_t, t) - \gamma \sqrt{1 - \overline{\alpha}_t} \nabla_{\boldsymbol{x}_t} \log f_\phi (y | \boldsymbol{x}_t)
|
|
\end{equation}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\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/}{Paweł Pierzchlewicz, 2023}.}
|
|
\label{fig:classifier_guidance}
|
|
\end{figure}
|
|
|
|
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 l'équation \ref{eq:165}, on obtient:
|
|
\begin{equation}
|
|
\nabla_{\boldsymbol{x}_t} \log p (y | \boldsymbol{x}_t) = \nabla_{\boldsymbol{x}_t} \log p (\boldsymbol{x}_t, y) - \nabla_{\boldsymbol{x}_t} \log p (\boldsymbol{x}_t) \label{eq:rearange}
|
|
\end{equation}
|
|
En subsituant l'équation \ref{eq:166} dans l'équation \ref{eq:rearange}, on obtient:
|
|
\begin{align}
|
|
\nabla_{\boldsymbol{x}_t} \log p (\boldsymbol{x}_t | y) & = \nabla_{\boldsymbol{x}_t} \log p (\boldsymbol{x}_t) + \gamma ( \nabla_{\boldsymbol{x}_t} \log p(\boldsymbol{x}_t | y) - \nabla_{\boldsymbol{x}_t} \log p(\boldsymbol{x}_t) ) \\
|
|
& = \underbrace{ \gamma \nabla_{\boldsymbol{x}_t} \log p(\boldsymbol{x}_t | y) }_{\text{conditional score}} + \underbrace{ (1 - \gamma) \nabla_{\boldsymbol{x}_t} \log p(\boldsymbol{x}_t) }_{\text{unconditional score}} \label{eq:cfg_lerp}
|
|
\end{align}
|
|
|
|
On en déduit de \ref{eq:cfg_lerp}, que la distribution conditionnelle est une interpolation linéaire entre la distribution conditionnelle et non conditionnelle. Ainsi, en utilisant un facteur de guidage $\gamma$, on peut contrôler la contribution de la distribution conditionnelle dans la distribution finale. Si $\gamma = 0$, alors la distribution conditionnelle est ignorée, et si $\gamma = 1$, alors la distribution conditionnelle est utilisée.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\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/}{Paweł Pierzchlewicz, 2023}.}
|
|
\label{fig:classifier_free_guidance}
|
|
\end{figure}
|
|
|
|
Cette approche présente divers avantages:
|
|
\begin{itemize}
|
|
\item Elle s'appuie sur un unique réseau de neurones, contrairement à la méthode guidée par classificateur qui en utilise deux.
|
|
\item L'entraînement n'est pas excessivement plus complexe; on utilise un entraînement conjoint, car il est extrêmement simple à mettre en œuvre et n'alourdit pas le processus d'entraînement. Ainsi, on procède à un entraînement conditionnel tout en omettant parfois les embeddings de classe afin de réaliser conjointement un entraînement non conditionnel.
|
|
\item Les données telles que le texte se prêtent difficilement à une classification en classes, et cette approche permet l'utilisation de vecteurs scalaires pour le conditionnement.
|
|
\end{itemize}
|
|
Formellement, l'algorithme d'entraînement par \gls{cfg} est décrit dans l'algorithme \ref{alg:classifier-free-guidance}, l'agorithme d'échantillonnage est décrit dans l'algorithme \ref{alg:classifier-free-guidance-sampling}.
|
|
|
|
\begin{algorithm}[h!]
|
|
\caption{\gls{ddpm} training with \gls{cfg}}
|
|
\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 $\epsilon_\theta$: neural network
|
|
\Require $p_\text{uncond}$: probability of unconditional training
|
|
\Repeat
|
|
\State $(x_0, c) \sim (\boldsymbol{x_0}, \boldsymbol{c})$
|
|
\State $c \leftarrow \varnothing$ with probability $p_\text{uncond}$
|
|
\State $t \sim \text{Uniform}( \lbrack\!\lbrack 1, T \rbrack\!\rbrack )$
|
|
\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}
|
|
|
|
\begin{algorithm}[h!]
|
|
\caption{\gls{ddpm} sampling with \gls{cfg}}
|
|
\label{alg:classifier-free-guidance-sampling}
|
|
\begin{algorithmic}[1]
|
|
\Require $T \in \mathbb{N}^\star$: number of diffusion steps
|
|
\Require $\gamma \in \mathbb{R}$: guidance factor
|
|
\Require $\alpha_t \in \mathbb{R}^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_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$
|
|
\EndFor
|
|
\State \Return $x_0$
|
|
\end{algorithmic}
|
|
\end{algorithm}
|
|
|
|
Dans notre cas d'application, nous pouvons conditionner sur les scalaires représentant les performances de nos maillages.
|
|
|
|
\FloatBarrier
|
|
\glsunset{arm}
|
|
\subsection{\acrfull*{arm}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{arm-architecture.png}
|
|
\caption{Architecture d'un \gls{arm}.}
|
|
\vspace*{-11pt}
|
|
\caption*{Source: \href{https://colah.github.io/posts/2015-08-Understanding-LSTMs/}{Christopher Olah, 2015}.}
|
|
\label{fig:arm-architecture}
|
|
\end{figure}
|
|
|
|
Les modèles auto-régressifs sont des méthodes de génération de séquences qui utilisent les éléments précédents pour prédire chaque élément suivant. Ces modèles sont largement utilisés dans le domaine du traitement du langage naturel, où ils ont montré d'excellentes performances. Cependant, l'application de ces modèles à la génération de graphes présente des défis particuliers en raison de la structure complexe des graphes. En effet, les graphes sont des structures de données non régulières et non séquentielles, ce qui rend difficile l'utilisation des modèles auto-régressifs. Malgré cela, plusieurs approches~\cite{nash_polygen_2020,liao_efficient_2020} ont été proposées pour adapter ces modèles à la génération de graphes. Cependant, il est important de noter que ces modèles deviennent de moins en moins précis de manière exponentielle à mesure que la taille de la séquence à générer augmente. De ce fait nous n'avons pas encore utilisé ces modèles dans nos travaux.
|
|
|
|
\FloatBarrier
|
|
\glsunset{nerf}
|
|
\subsection{\acrfull*{nerf}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{nerf-architecture.png}
|
|
\caption{Architecture d'un \gls{nerf}.}
|
|
\vspace*{-11pt}
|
|
\caption*{Source: \href{https://theaisummer.com/nerf/}{AI Summer, 2022}.}
|
|
\label{fig:nerf-architecture}
|
|
\end{figure}
|
|
|
|
Les \glspl{nerf}~\cite{mildenhall_nerf_2020} représentent une autre famille de modèles génératifs qui ont gagné en popularité récemment. Ces modèles ont la capacité de générer des rendus 3D hautement réalistes à partir de données d'entraînement en utilisant des réseaux de neurones. Contrairement aux approches traditionnelles de rendu 3D basées sur des maillages, les \glspl{nerf} exploitent des représentations continues et implicites des scènes en décrivant les propriétés radiométriques et géométriques en chaque point de l'espace 3D.
|
|
|
|
Le principe des \glspl{nerf} est de modéliser une fonction de densité de rayon (ou ``ray density function") qui caractérise l'intéraction de la lumière avec les objets de la scène. Cette fonction est ensuite utilisée pour estimer la couleur et la profondeur des rayons traversant la scène, permettant ainsi de générer des images photoréalistes.
|
|
|
|
Les \glspl{nerf} sont donc une alternative aux méthodes traditionnelles de reconstructions de scènes par résolution du problème inverse 3D. Cependant ces modèles peuvent aussi être utilisé conjointement avec d'autres réseaux pour permettre d'obtenir des réseaux génératifs~\cite{nichol_point-e_2022,takikawa_neural_2021,nam_3d-ldm_2022}.
|
|
|
|
Dans notre cas, notre jeu de données n'est pas adapté à l'application des \glspl{nerf}, car cela nécessiterait un processus de prétraitement complexe de notre ensemble de données (comprenant la conversion de nos maillages/scènes en images via un moteur de rendu) ainsi qu'un post-traitement conséquent de nos résultats (utilisation du ``marching cube" pour passer d'une représentation implicite à un maillage). Par conséquent, nous ne choisirons pas d'adopter cette approche. De plus, dans le contexte industriel, les outils destinés à la manipulation d'objets implicites ne sont pas encore suffisamment avancés pour être déployés en production.
|
|
|
|
\FloatBarrier
|
|
\chapter{Déroulement du stage}
|
|
|
|
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 Safran.
|
|
Tout au long de cette période, j'ai travaillé en tant que Stagiaire Ingénieur de Recherche en Machine Learning au sein du département Safran Tech, dans l'équipe \gls{flex} de l'unité de recherche \gls{mads} dans le département \gls{dst}, dont le but est de développer des outils de simulation et de modélisation pour les besoins de Safran.
|
|
J'ai été encadré par Xavier Roynard, Michele 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é.
|
|
|
|
\FloatBarrier
|
|
\section{Lecture de la littérature}
|
|
|
|
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 \href{https://www.semanticscholar.org/}{Semantic Scholar} ou \href{https://paperswithcode.com/}{Papers with code}, pour trouver les codes sources des papiers ainsi que d'autres 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 (via les logiciels \href{https://logseq.com/}{Logseq} et \href{https://www.zotero.org/}{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.
|
|
|
|
\FloatBarrier
|
|
\section{Prise en main des données}
|
|
|
|
En parallèle de ma lecture de la littérature, j'ai entamé l'exploration des données fournies par Safran. J'ai acquis une compréhension des différents formats de données spécifiques utilisés par l'entreprise pour stocker les résultats des simulations numériques de mécaniques des fluides. De plus, j'ai appris à manipuler ces données en utilisant des outils tels que Paraview~\cite{ParaView}.
|
|
|
|
Le principal ensemble de données sur lequel j'ai travaillé pendant mon stage s'appelle Rotor37\_1200~\cite{mouriaux_nasa_2021}. Il s'agit d'un ensemble de données de simulation \gls{cfd} d'une des 37 aubes du compresseur d'un moteur d'avion. Cet ensemble de données contient 1200 échantillons, qui ont été créé via un processus d'optimisation consistant en l'exploration de paramètres en quête de la maximisation d'un critère de performance, visible sur la figure~\ref{fig:process-rotor37-1200}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{online_adaptative_sampling_DOE}
|
|
\caption{Processus d'optimisation ayant permis de générer l'ensemble de données Rotor37\_1200.}
|
|
\label{fig:process-rotor37-1200}
|
|
\end{figure}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=4.5cm]{rotor37_1200_1.png}\includegraphics[width=4.5cm]{rotor37_1200_2.png}\includegraphics[width=4.5cm]{rotor37_1200_3.png}
|
|
\caption{Échantillon de l'ensemble de données Rotor37\_1200 sous plusieurs angles.}
|
|
\label{fig:example-rotor37-1200}
|
|
\end{figure}
|
|
|
|
Chaque aube du jeu de données est une déformation d'une aube nominale. Ainsi tous les maillages possèdent le même nombre de nœuds et la même connectivité. Pour donner un ordre de grandeur, chaque maillage est constitué de 29773 nœuds, 59328 triangles et 89100 arêtes.
|
|
|
|
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 contenant des métadonnées globales spécifiques à l'échantillon, telles que les entrées et les sorties de la simulation \gls{cfd}. L'ensemble de ces fichiers pèsent environ 60 \gls{go} et sont stockés dans un dossier spécifique read-only sur le cluster de calcul de Safran.
|
|
|
|
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 validation 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 validation est utilisé pour évaluer les performances des modèles génératifs.
|
|
|
|
Afin de simplifier le chargement des données, j'ai choisi d'utiliser la bibliothèque HuggingFace Datasets~\cite{lhoest-etal-2021-datasets}. Cette bibliothèque se distingue par son utilisation innovante de la technologie Apache Arrow~\cite{arrow} pour stocker les données de manière tabulaire en colonnes, permettant des lectures sans copie (zero copy reads) ainsi que des opérations de mapping efficaces prenant en charge le multi-threading. Grâce à une approche de chargement paresseux (lazy loading), elle évite les problèmes de mémoire et assure la reproductibilité en sauvegardant en cache les transformations intermédiaires des données.
|
|
|
|
En complément de Rotor37\_1200, j'ai également effectué des travaux sur un ensemble de données plus étendu, baptisé Rotor37\_11000, qui comprend 11000 échantillons. La création de cet ensemble de données a suivi le même processus d'optimisation que celui de Rotor37\_1200, selon la même aube nominale. Cependant, il est important de noter que les déformations présentes dans Rotor37\_11000 sont d'un ordre de grandeur supérieur.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=4.5cm]{rotor37_11000_1.png}\includegraphics[width=4.5cm]{rotor37_11000_2.png}\includegraphics[width=4.5cm]{rotor37_11000_3.png}
|
|
\caption{Échantillon de l'ensemble de données Rotor37\_11000 sous plusieurs angles.}
|
|
\label{fig:example-rotor37-11000}
|
|
\end{figure}
|
|
|
|
\FloatBarrier
|
|
\section{Description de l'environnement de travail}
|
|
|
|
L'équipe de mes tuteurs est basée à Châteaufort, sur le plateau de Saclay, où se trouve le site de l'entreprise. J'ai réussi à trouver un logement dans le nord de Palaiseau, à environ 40 minutes de trajet en bus. En moyenne, le nombre d'employés présents sur le site s'élève à environ 1200 personnes.
|
|
|
|
Les locaux de l'entreprise se présentent sous la forme de vastes openspaces, partagés par un maximum d'une dizaine de personnes. Ils sont séparés par de grandes baies vitrées et répartis dans 3 bâtiments sur plusieurs étages. Les bureaux sont spacieux équipés d'au moins un grand écran, d'un clavier et d'une souris. Nous disposons également de salles de réunion, de salles de détente et d'une salle de sport.
|
|
|
|
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. Pour communiquer, pour les visioconférences nous utilisons principalement Microsoft Teams, qui permet de passer des appels audio et vidéo, de partager son écran et de discuter par écrit, pour les échanges rapides nous utilisons la messagerie instantanée chiffrée de bout en bout Citadel.
|
|
|
|
La stack technique utilisée par l'équipe est basée sur Python, avec des bibliothèques telles que PyTorch, PyTorch Geometric, PyTorch Lightning, NumPy, SciPy, GPy, Matplotlib, Seaborn, Scikit-Learn, etc. Nous utilisons également des outils de gestion d'environnement virtuels Python tels que Conda et Micromamba, ainsi que de l'outils de versionnement git. Le cluster de calcul étant coupé d'internet, nous utilisons un artifcatory pour télécharger les dépendances nécessaire à nos projets.
|
|
|
|
\FloatBarrier
|
|
\section{Application de l'état de l'art}
|
|
|
|
À la suite de ma recherche bibliographique, j'ai consacré du temps à expérimenter diverses implémentations des articles que j'avais identifiés, ainsi qu'à travailler sur mon implémentation finale. Voici la liste des implémentations que j'ai évaluées, les idées que j'ai explorées, mes observations relatives à chaque approche, ainsi que mon résultat final, dans un ordre approximativement chronologique.
|
|
|
|
\FloatBarrier
|
|
\subsection{Test de GraphVAE}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{graphvae-architecture.png}
|
|
\caption{Architecture de GraphVAE.}
|
|
\label{fig:graphvae_archi}
|
|
\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 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
|
|
\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:graphvae_results}
|
|
\end{figure}
|
|
|
|
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 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}, 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
|
|
\includegraphics[width=0.8\textwidth]{graphunet-architecture.png}
|
|
\caption{Architecture de Graph U-Net.}
|
|
\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é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~\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++~\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
|
|
\includegraphics[width=0.8\textwidth]{pointnet-architecture.jpg}
|
|
\caption{Architecture de PointNet et PointNet++.}
|
|
\label{fig:pointnet_archi}
|
|
\end{figure}
|
|
|
|
\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{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
|
|
\includegraphics[width=0.8\textwidth]{kpconv-architecture.png}
|
|
\caption{Architecture de \gls{kpfcnn} et \gls{kpcnn}, basés sur des \glspl{kpconv}.}
|
|
\label{fig:kpconv_archi}
|
|
\end{figure}
|
|
|
|
\FloatBarrier
|
|
\subsection{Test de \gls{kpfcnn}}
|
|
|
|
Dans notre situation, nous avons la possibilité d'opter pour le réseau \gls{kpfcnn}, initialement conçu pour la segmentation, mais pouvant être ajusté pour la prédiction de bruit pour une utilisation dans \gls{ddpm}. À cette fin, nous faisons usage de la bibliothèque easy\_kpconv, implémentant les \glspl{kpconv} et nous permettant de créer un code clair et réutilisable.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.3333\textwidth]{sample_1_kpfcnn.png}\includegraphics[width=0.3333\textwidth]{sample_2_kpfcnn.png}\includegraphics[width=0.3333\textwidth]{sample_3_kpfcnn.png}
|
|
\caption{Résultats d'un \gls{vdm} \gls{kpfcnn} sur Rotor37\_1200.}
|
|
\label{fig:kpfcnn_results}
|
|
\end{figure}
|
|
|
|
Comme illustré dans la Figure~\ref{fig:kpfcnn_results}, lorsque cette architecture est associée à un modèle de diffusion, elle démontre la capacité de générer des nuages de points adoptant une structure en forme d'aube. Cependant, on remarque que les générations sont d'assez mauvaise qualité puisque les nuages de points semblent comporter une part de bruit résiduel importante. Certaines générations ne ressemblent même pas du tout à des aubes, mais plutôt à des nuages de points aléatoires.
|
|
Autre point négatif, le decodeur de \gls{kpfcnn} étant composé de \glspl{mlp}, il n'est pas scalable. En effet le réseau actuel comporte environ 4 millions de paramètres, dont une très large majorité se situent dans le décodeur.
|
|
|
|
% TODO: verif le nb de params
|
|
|
|
\FloatBarrier
|
|
\subsection{Présentation des \acrfullpl*{pvconv}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{pvconv.png}
|
|
\caption{Architecture d'une \gls{pvconv}.}
|
|
\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, 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, cete amélioration nécessite l'utilisation de code CUDA très ésotérique.
|
|
|
|
\FloatBarrier
|
|
\subsection{Test de \acrfull*{pvd}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{pvd-architecture.png}
|
|
\caption{Architecture de \gls{pvd}.}
|
|
\label{fig:pvd_archi}
|
|
\end{figure}
|
|
|
|
Le premier papier ayant utilisé une architecture du type PVCNN++ pour la générations de nuages de point est \gls{pvd}~\cite{zhou_3d_2021}. Ce réseau utilise \gls{ddpm} et travaille directement sur le nuage de points. Si l'on récupère l'implémentation des auteurs et que l'on la modifie pour utiliser Rotor37\_1200 on obtient de très bon résultat. Cependant, une bonne partie de la codebase étant basé sur celle de PVCNN++ et de PointFlow, celle-ci est tout aussi difficile à modifier.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.45\textwidth]{pvd_sample_front.png} \includegraphics[width=0.45\textwidth]{pvd_sample_inside.png}
|
|
\caption{Résultats de \gls{pvd} sur Rotor37\_1200.}
|
|
\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 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{Présentation de \acrfull*{lion}}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{LION.jpg}
|
|
\caption{Architecture de \gls{lion}~\cite{zeng_lion_2022}.}
|
|
\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 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.
|
|
|
|
\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.
|
|
|
|
\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 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 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
|
|
\includegraphics[width=0.5\textwidth]{pca_cumsum_1200.png}\includegraphics[width=0.5\textwidth]{pca_cumsum_11000.png}
|
|
\caption{Somme cumulative des modes de la \gls{pca}. Gauche: Rotor37\_1200. Droite: Rotor37\_11000.}
|
|
\label{fig:pca_cumsum}
|
|
\end{figure}
|
|
|
|
À partir de la Figure \ref{fig:pca_cumsum}, nous pouvons déduire qu'environ 30 modes sont nécessaires pour représenter approximativement 99\% de l'information présente dans le jeu de données Rotor37\_1200. Cependant, il est à noter que cette compression s'avère moins efficace pour le jeu de données Rotor37\_11000, ce qui est attendu étant donné que les données présentent moins de similarités. Afin de résoudre les problèmes de compression associés au jeu de données Rotor37\_11000, nous avons exploré la possibilité de remplacer la méthode \gls{pca} par une \gls{pod}. Malgré une meilleure capacité de compression obtenue par la \gls{pod}, cette approche s'est révélée plus coûteuse en termes de calcul et moins adaptée aux autres techniques que nous prévoyons d'utiliser. En conséquence, pour le moment, nous avons décidé de maintenir l'utilisation de la \gls{pca} pour l'encodeur et de la ``\gls{pca} inverse'' pour le decodeur de notre \gls{ldm}.
|
|
|
|
Dans le cas de Rotor37\_1200, cela signifie que nous passons de 30000 points, chacun comportant à la fois leurs coordonnées spatiales et leurs normales (soit un total de 30000x6 scalaires), à un vecteur de taille 30.
|
|
Ce vecteur étant petit, nous pouvons donc utiliser un simple \gls{mlp} pour prédire le bruit dans le processus de diffusion. De plus, pour conditionner ce réseau en fonction de l'étape temporelle de la diffusion, nous pouvons simplement additionner les embeddings de pas de temps à chaque couche du réseau.
|
|
Le réseau résultant contient à peine plus de 10000 paramètres, ce qui est considérablement inférieur aux autres modèles précédemment présentés.
|
|
Par conséquent, ce réseau est très facile à manipuler et à entraîner, mais il présente l'inconvénient d'être spécialisé sur le jeu de données utilisé pour construire la \gls{pca}.
|
|
Cependant, dans le contexte industriel, cet inconvénient est moins préoccupant car la nécessité de modèles génériques n'est pas primordiale.
|
|
|
|
\FloatBarrier
|
|
\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é $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}
|
|
\item Blanc: génération non conditionnée
|
|
\item Rouge: génération conditionnée, isentropic\_effiency=1, $\gamma=7$
|
|
\item Jaune: génération conditionnée, isentropic\_effiency=1, $\gamma=14$
|
|
\item Bleu: génération conditionnée, isentropic\_effiency=1, $\gamma=25$
|
|
\end{itemize}
|
|
On observe qu'à mesure que le facteur de guidage $\gamma$ augmente, certaines parties de l'aube subissent une déformation plus prononcée. À des fins d'illustration, il est important de noter que les valeurs de $\gamma$ utilisées ici sont considérablement élevées. En pratique, toutefois, $\gamma$ ne dépasse pas généralement la valeur de 5, et demeure en moyenne autour de 2.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{ldm-pca-guidance.png}
|
|
\caption{Résultats d'un \gls{ldm} \gls{pca} sur Rotor37\_1200, pour plusieurs valeurs de $\gamma$.}
|
|
\label{fig:pca_ldm_results}
|
|
\end{figure}
|
|
|
|
\FloatBarrier
|
|
\glsunset{gp}
|
|
\subsection{Vérification par \acrfull*{gp}}
|
|
|
|
Dans cette optique, il devient impératif de mettre en place un moyen de vérification des propriétés physiques des aubes générées et de les comparer aux critères de conditionnement. Bien que l'approche la plus simple consisterait à soumettre nos générations à un simulateur \gls{cfd}, cette méthode s'avère inenvisageable en raison de sa lenteur.
|
|
|
|
Une solution viable consiste à entraîner un modèle de régression capable d'établir une relation entre nos nuages de points (ou leurs espaces latents) et leurs critères de performances. Cette tâche peut être réalisée en utilisant des réseaux de neurones, mais également en optant pour une approche moins paramétrique telle que les \glspl{gp}.
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=0.8\textwidth]{gp.png}
|
|
\caption{Régression par \gls{gp}.}
|
|
\vspace*{-11pt}
|
|
\caption*{Source: distill.pub~\cite{görtler2019a}.}
|
|
\label{fig:gp_regression}
|
|
\end{figure}
|
|
|
|
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 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
|
|
\includegraphics[width=1\textwidth]{gp_train_30_pca.png}
|
|
\caption{Entrainement d'un \gls{gp} sur 30 modes PCA de Rotor37\_1200.}
|
|
\label{fig:gp_train_30_pca}
|
|
\end{figure}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=1\textwidth]{gp_massflow_1_pca.png}
|
|
\caption{Vérification du conditionnement (out\_massflow=1) par \gls{gp}.}
|
|
\label{fig:gp_massflow_1_pca}
|
|
\end{figure}
|
|
|
|
\begin{figure}[h!]
|
|
\centering
|
|
\includegraphics[width=1\textwidth]{gp_efficiency_1_pca.png}
|
|
\caption{Vérification du conditionnement (isentropy\_efficiency=1) par \gls{gp}.}
|
|
\label{fig:gp_efficiency_1_pca}
|
|
\end{figure}
|
|
|
|
La figure~\ref{fig:gp_train_30_pca} illustre la validation du \gls{gp} en utilisant des données de test. En traçant la prédiction du \gls{gp} par rapport aux valeurs réelles, on observe une relation linéaire avec une pente de 1. Cette observation est confirmée numériquement par la proximité de $Q^2$ à 1. Ces résultats indiquent que le \gls{gp} est capable de prédire les indicateurs de performance des aubes, en se basant sur leurs modes \gls{pca}.
|
|
|
|
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 tel qu'un moteur d'avion.
|
|
|
|
\FloatBarrier
|
|
\chapter{Conclusion}
|
|
|
|
En conclusion, l'étude de ce stage a démontré avec succès la faisabilité de la génération conditionnée d'aubes de turbines en utilisant une approche basée sur des modèles de diffusion. Les résultats obtenus ont dépassé nos attentes initiales en matière de précision et de capacité à générer des aubes conditionnées tout en préservant les propriétés physiques essentielles.
|
|
|
|
Sur le plan personnel, cette recherche m'a offert une occasion précieuse d'approfondir mes compétences en matière de modélisation générative, en explorant l'application des \glspl{ddpm} à un problème concret de l'ingénierie. Du point de vue des connaissances techniques, j'ai pu consolider mes connaissances en matière de réseaux de neurones, d'utilisation de bibliotèques de deep learning, ainsi que dans le domaine des techniques classiques de machine learning telles que la \gls{pca} ou les \glspl{gp}.
|
|
|
|
Enfin, ce travail de recherche a également mis en lumière l'importance de la collaboration entre les domaines techniques et académiques. Mes échanges et discussions avec les ingénieurs, les experts du domaine industriel et certains auteurs de papiers ont joué un rôle essentiel dans l'orientation de ma recherche et dans la validation des résultats.
|
|
|
|
En perspective d'amélioration, il serait pertinent d'explorer des méthodes visant à réduire la taille des maillages utilisés dans les simulations numériques, tout en maintenant leur précision. Cette approche pourrait éventuellement conduire à l'obtention de modèles plus compacts et plus rapides à entraîner, tout en préservant une représentation précise des propriétés physiques des aubes. Par ailleurs, il serait également intéressant d'explorer la possibilité d'appliquer ces techniques de génération directement aux \glspl{cao}, sans passer par les étapes intermédiaires des maillages ou des nuages de points. Cette démarche pourrait simplifier le processus de conception en générant directement des modèles \gls{cao} conditionnés selon les spécifications requises.
|
|
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
|
|
\backmatter
|
|
|
|
\addcontentsline{toc}{chapter}{Bibliographie}
|
|
\bibliography{zotero,others,softs}
|
|
\bibliographystyle{plainnat}
|
|
|
|
\end{document}
|