modifs du matin
This commit is contained in:
parent
25946fae17
commit
52913ae4b9
SSH key fingerprint:
SHA256:kZEpW8cMJ54PDeCvOhzreNr4FSh6R13CMGH/POoO8DI
BIN
assets/shapenet.png
(Stored with Git LFS)
Normal file
BIN
assets/shapenet.png
(Stored with Git LFS)
Normal file
Binary file not shown.
|
|
@ -32,3 +32,10 @@
|
|||
institution = {Stanford University --- Princeton University --- Toyota Technological Institute at Chicago},
|
||||
year = {2015}
|
||||
}
|
||||
|
||||
@inproceedings{armeni_cvpr16,
|
||||
title = {3D Semantic Parsing of Large-Scale Indoor Spaces},
|
||||
author = {Iro Armeni and Ozan Sener and Amir R. Zamir and Helen Jiang and Ioannis Brilakis and Martin Fischer and Silvio Savarese},
|
||||
booktitle = {Proceedings of the IEEE International Conference on Computer Vision and Pattern Recognition},
|
||||
year = {2016}
|
||||
}
|
||||
|
|
|
|||
176
src/paper.tex
176
src/paper.tex
|
|
@ -132,6 +132,10 @@
|
|||
|
||||
\newacronym{go}{Go}{Gigaoctet}
|
||||
|
||||
\newacronym{kpconv}{KPConv}{Kernel Point Convolution}
|
||||
\newacronym{pvconv}{PVConv}{Point Voxel Convolutions}
|
||||
\newacronym{spvconv}{SPVConv}{Sparse Point Voxel Convolutions}
|
||||
|
||||
% \newglossary{symbols}{sym}{sbl}{Notations mathématiques et symboles}
|
||||
|
||||
% \newglossaryentry{fn}{
|
||||
|
|
@ -264,7 +268,7 @@ Les graphes offrent une représentation intuitive de diverses structures telles
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{example-graphs.jpg}
|
||||
\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}}
|
||||
|
|
@ -291,7 +295,7 @@ Il existe plusieurs sous familles de modèles génératifs, chacune basées sur
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{generative-overview.png}
|
||||
\includegraphics[width=0.8\textwidth]{generative-overview.png}
|
||||
\caption{Principales familles de modèles génératifs}
|
||||
\vspace*{-11pt}
|
||||
\caption*{Source: \href{https://lilianweng.github.io/posts/2021-07-11-diffusion-models/}{Lilian Weng, 2021}}
|
||||
|
|
@ -304,7 +308,7 @@ Il existe plusieurs sous familles de modèles génératifs, chacune basées sur
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{gan-architecture.png}
|
||||
\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}}
|
||||
|
|
@ -329,7 +333,7 @@ Face à ces inconvénients, et puisque nous ne possédons pas de grandes quantit
|
|||
|
||||
\begin{figure}[h]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{vae-architecture.png}
|
||||
\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}}
|
||||
|
|
@ -342,7 +346,7 @@ La particularité inhérente aux \glspl{vae} réside dans l'espace latent interm
|
|||
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 et précisement 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 maximum vraissemblance de nos données d'entrée $p(\boldsymbol{x})$.
|
||||
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}
|
||||
|
|
@ -351,9 +355,9 @@ En pratique, maximiser directement la vraissemblance est impossible car cela rev
|
|||
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]
|
||||
& \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 à $\phi$, maximiser l'\gls{elbo} revient à maximiser 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}:
|
||||
Ainsi, puisque la \gls{kld} est toujours positive et car $\log p(\boldsymbol{x})$ est constant par rapport à $\phi$, 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}
|
||||
|
|
@ -370,7 +374,7 @@ Tout comme les \glspl{gan}, de nombreuses améliorations (β-VAE~\cite{burgess_u
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{nf-architecture.png}
|
||||
\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}}
|
||||
|
|
@ -379,7 +383,7 @@ Tout comme les \glspl{gan}, de nombreuses améliorations (β-VAE~\cite{burgess_u
|
|||
|
||||
% on est capable de calculer exactement le log likelyhood, et donc de train direct dessus, contrairement aux VAE où on train sur l'ELBO ou les GANS où y'a pas du tout de log likelyhood, jsute un minmnax game
|
||||
|
||||
Les \glspl{nf} sont une autre classe de modèles génératifs qui ont gagné en popularité ces dernières années~\cite{kobyzev_normalizing_2021}, puisque ces méthodes proposent de travailler directement sur les densités de probabilité, contrairement aux \glspl{vae} et \glspl{gan}. Ces modèles se basent des transformations inversibles (bijectives), continues et différentiables. Ces transformations sont appliquées à une distribution de base, généralement une distribution simple comme une gaussienne isotropique, pour obtenir une distribution plus complexe et plus proche de la distribution des données réelles.
|
||||
Les \glspl{nf} sont une autre classe de modèles génératifs qui ont gagné en popularité ces dernières années~\cite{kobyzev_normalizing_2021}, puisque ces méthodes proposent de travailler directement sur les densités de probabilité, contrairement aux \glspl{vae} et \glspl{gan}. Ces modèles se basent sur des transformations inversibles (bijectives), continues et différentiables. Ces transformations sont appliquées à une distribution de base, généralement une distribution simple comme une gaussienne isotropique, pour obtenir une distribution plus complexe et plus proche de la distribution des données réelles.
|
||||
Les 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 complexes. En utilisant plusieurs transformations en séquence, on peut construire des modèles génératifs flexibles capables de capturer des distributions complexes.
|
||||
|
||||
Dans la littérature, ces réseaux sont assez peu appliqués aux types de données qui nous intéressent, à l'exception notable de PointFlow~\cite{yang_pointflow_2019} qui aura posé certaines bases pour évaluer les réseaux génératifs de nuages de points. Comme par exemple la démocratisation des distances et métriques suivantes:
|
||||
|
|
@ -449,7 +453,7 @@ Soit $S_g$ un ensemble de nuages de points générés, $S_r$ un ensemble de nuag
|
|||
\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é, mais ayant des sous-ensembles de points très similaires à ceux de $S_r$. Dans ce cas, on obtiendrait un score de raisonnablement élevé.
|
||||
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}
|
||||
\subsubsection{\acrfull{1-nna}}
|
||||
|
|
@ -460,7 +464,7 @@ Soit $S_g$ un ensemble de nuages de points générés, $S_r$ un ensemble de nuag
|
|||
\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}, le \gls{1-nna} mesure directement la similarité des distributions et prend en compte à la fois la diversité et la qualité.
|
||||
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
|
||||
\glsunset{vdm}
|
||||
|
|
@ -468,7 +472,7 @@ En supposant que $S_g$ et $S_r$ soient échantillonnés à partir de la même di
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{vdm-architecture.png}
|
||||
\includegraphics[width=0.8\textwidth]{vdm-architecture.png}
|
||||
\caption{Architecture d'un \gls{vdm}}
|
||||
\vspace*{-11pt}
|
||||
\caption*{Source: Calvin Luo~\cite{luo_understanding_2022}}
|
||||
|
|
@ -482,7 +486,7 @@ Plusieurs catégories de modèles sont disponibles pour aborder le problème de
|
|||
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 fixe 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 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}
|
||||
|
||||
|
|
@ -513,9 +517,9 @@ On peut finalement simplifier cette expression via une reparamétrisation:
|
|||
\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)$.
|
||||
|
||||
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é, la densité de probabilité peut être retrouvée au moyen de méthodes d'échantillonnage telles que la méthode de recuit de Langevin~\cite{song_generative_2020}.
|
||||
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 commence à halluciner des reconstructions qui présentent une forte ressemblance avec nos données d'entraînement, il génère donc de nouvelles données.
|
||||
|
||||
Après avoir achevé l'entraînement adéquat de notre modèle, nous acquérons ainsi la capacité de débruiter nos données altérées par un bruit gaussien. Néanmoins, l'intérêt majeur réside dans le fait de solliciter notre réseau pour débruiter du bruit blanc (i.e. $\mathcal{N}(0, \sigma^2), \text{SNR}=0$). De ce fait, le réseau commence à halluciner reconstructions qui présentent une forte ressemblance avec nos données d'entraînement, il génère donc de nouvelles données.
|
||||
Il est possible de démontrer théoriquement~\cite{luo_understanding_2022} l'équivalence entre les \glspl{vdm} et les méthodes de score matching~\cite{song_generative_2020} lorsque $T$ tend vers l'infini. Les méthodes de score matching, constituent une famille de techniques permettant l'estimation de la densité de probabilité associée à un ensemble de données. Elles se basent exclusivement sur le calcul du gradient de cette densité de probabilité, éliminant ainsi la nécessité du calcul laborieux d'une constante de normalisation. Une fois le gradient estimé (e.g. via un réseau de neurones), la densité de probabilité peut être retrouvée au moyen de méthodes d'échantillonnage telles que la méthode de recuit de Langevin~\cite{song_generative_2020}.
|
||||
|
||||
\FloatBarrier
|
||||
\glsunset{ldm}
|
||||
|
|
@ -537,13 +541,13 @@ Les \glspl{vae} sont fréquemment employés à cet effet. L'entrainement des \gl
|
|||
\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.
|
||||
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 (i.e. des embeddings), 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'entraiement 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 classifier est ensuite utilisé pour guider le modèle de diffusion. Ainsi selon la formulation du score matching on obtient:
|
||||
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 classifier est ensuite utilisé pour guider le modèle de diffusion. 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}
|
||||
|
|
@ -556,7 +560,7 @@ Si l'on remplace $q( y | \boldsymbol{x}_t )$ par $f_\phi ( y | \boldsymbol{x}_t
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{classifier-guidance.png}
|
||||
\includegraphics[width=0.8\textwidth]{classifier-guidance.png}
|
||||
\caption{Conditionnement par Classifier Guidance}
|
||||
\vspace*{-11pt}
|
||||
\caption*{Source: \href{https://perceptron.blog/defusing-diffusion/}{Perceptron.blog, 2023}}
|
||||
|
|
@ -577,16 +581,16 @@ En subsituant l'équation \ref{eq:166} dans l'équation ci-dessus, on obtient:
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{classifier-free-guidance.png}
|
||||
\includegraphics[width=0.8\textwidth]{classifier-free-guidance.png}
|
||||
\caption{Conditionnement par Classifier-free Guidance}
|
||||
\vspace*{-11pt}
|
||||
\caption*{Source: \href{https://perceptron.blog/defusing-diffusion/}{Perceptron.blog, 2023}}
|
||||
\label{fig:classifier_free_guidance}
|
||||
\end{figure}
|
||||
|
||||
Cette approche présente divers avantages. Premièrement, elle s'appuie sur un unique réseau de neurones, contrairement à la méthode guidée par classificateur qui en utilise deux. Deuxièmement, l'entraînement ne devient pas significativement plus complexe ; nous procédons de la même manière qu'auparavant, en ajoutant simplement les embeddings et en parfois excluant ces embeddings pour apprendre en conditionnement non contraint. Troisièmement, les données telles que le texte se prêtent difficilement à une classification en classes, et l'approche sans classificateur permet l'utilisation de vecteurs scalaires pour le conditionnement.
|
||||
Cette approche présente divers avantages. Premièrement, elle s'appuie sur un unique réseau de neurones, contrairement à la méthode guidée par classificateur qui en utilise deux. Deuxièmement, l'entraînement ne devient pas significativement plus complexe ; nous procédons de la même manière qu'auparavant, en ajoutant simplement les embeddings de classe et en parfois excluant aléatoirement ces embeddings (selon une loi uniforme) pour apprendre en conditionnement non contraint. Troisièmement, 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.
|
||||
|
||||
Dans notre cas d'application, nous pouvons conditionner sur les scalaires representant les performances de nos maillages.
|
||||
Dans notre cas d'application, nous pouvons conditionner sur les scalaires représentant les performances de nos maillages.
|
||||
|
||||
% https://liorsinai.github.io/coding/2023/01/04/denoising-diffusion-3-guidance.html#guided-diffusion
|
||||
|
||||
|
|
@ -600,7 +604,7 @@ Dans notre cas d'application, nous pouvons conditionner sur les scalaires repres
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{arm-architecture.png}
|
||||
\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}}
|
||||
|
|
@ -617,7 +621,7 @@ Les modèles auto-régressifs sont des méthodes de génération de séquences q
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{nerf-architecture.png}
|
||||
\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}}
|
||||
|
|
@ -626,14 +630,15 @@ Les modèles auto-régressifs sont des méthodes de génération de séquences q
|
|||
|
||||
Les \glspl{nerf} représentent une autre famille de modèles génératifs qui ont gagné en popularité récemment~\cite{mildenhall_nerf_2020}. 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'interaction 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.
|
||||
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.
|
||||
|
||||
L'un des aspects fascinants des \glspl{nerf} réside dans leur capacité à apprendre des scènes complexes et à générer des rendus à partir d'un nombre limité de vues ou de données d'entraînement. Grâce à leur architecture neuronale et à leur capacité à modéliser la distribution des couleurs et des formes, les \glspl{nerf} sont en mesure de synthétiser des scènes réalistes même à partir de quelques images.
|
||||
|
||||
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éseau 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, étant donné que notre jeu de données n'est pas adapté à l'application des \glspl{nerf}, car cela nécessiterait un processus de prétraitement complexe (comprenant la conversion de nos maillages/scènes en images via un moteur de rendu) ainsi qu'un post-traitement conséquent (utilisation du "marching cube") de notre ensemble de données. 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.
|
||||
Dans notre cas, étant donné que 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 (utilisation du "marching cube" pour passer dd'une représentation implicite à un maillage) de nos résultats. 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 en Machine Learning au sein du département Safran Tech, dans l'équipe flex (chercher acronyme bidule), dont le but est de développer des outils de simulation et de modélisation pour les besoins de Safran. J'ai été encadré par Xavier Roynard, Michel Alessandro Bucci et Brian Staber.
|
||||
|
|
@ -645,7 +650,7 @@ Je décrirai dans les prochaines sections les différentes étapes de mon stage,
|
|||
|
||||
Les premiers jours de mon stage ont été dédiés à mon intégration au sein de l'entreprise. J'ai rencontré mes tuteurs de stage qui m'ont présenté l'équipe et les différents membres du département. Une visite des locaux de l'entreprise m'a été proposée, accompagnée d'explications sur les mesures de sécurité en vigueur. J'ai également pris connaissance des outils et des logiciels utilisés dans le cadre de mon projet. Ces premiers jours ont été l'occasion pour moi de participer à des réunions d'équipe, en présence d'autres stagiaires et d'ingénieurs, afin de me familiariser avec les différents projets en cours et de préciser les objectifs de mon stage.
|
||||
|
||||
Les deux premières semaines de mon stage ont été dédiées à la lecture approfondie de la littérature scientifique liée à mon domaine d'étude. J'ai effectué des recherches bibliographiques afin de recueillir des informations pertinentes sur les avancées récentes, les théories et les techniques utilisées dans le domaine des modèles génératifs. J'ai majoritairement consulté des articles de conférence et des documents en ligne pour obtenir une vue d'ensemble complète des travaux antérieurs réalisés par des chercheurs et des ingénieurs. Pour appronfondir mes recherches, j'ai également utilisé des outils, tels que \href{https://www.semanticscholar.org/}{Semantic Scholar} ou \href{https://paperswithcode.com/}{Papers with code}, pour trouver les codes sources des papiers ainsi que des papiers ayant pour citation ou référence les articles que j'avais déjà lus, me permettant ainsi de découvrir de nouvelles publications pertinentes.
|
||||
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.
|
||||
|
||||
|
|
@ -660,7 +665,7 @@ Le principal ensemble de données sur lequel j'ai travaillé pendant mon stage s
|
|||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=14cm]{online_adaptative_sampling_DOE}
|
||||
\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}
|
||||
|
|
@ -672,16 +677,16 @@ Le principal ensemble de données sur lequel j'ai travaillé pendant mon stage s
|
|||
\label{fig:example-rotor37-1200}
|
||||
\end{figure}
|
||||
|
||||
Chaque aube du jeu de données est une déformation de l'aube nominale. Ainsi tous les maillages possèdent le même nombre de points et la même connectivité. Pour donner un ordre de grandeur, chaque maillage est constitué de 29773 points, 59328 triangles et 89100 arêtes.
|
||||
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 points et la même connectivité. Pour donner un ordre de grandeur, chaque maillage est constitué de 29773 points, 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 qui contient 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 \glspl{go} et sont stockés dans un dossier spécifique read-only (en lecture seule) sur le cluster de calcul de Safran.
|
||||
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.
|
||||
|
||||
% TODO: rajouter la liste exhaustive de **tous** les champs phyisques
|
||||
% TODO: mettre ici un plot de la distribution des données (perfs + positions et autres)
|
||||
|
||||
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 de 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 les opérations de mapping 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.
|
||||
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 travaillé sur un ensemble de données plus grand appelé Rotor37\_11000, qui contient 11000 échantillons. Cet ensemble de données a été créé via le même processus d'optimisation que Rotor37\_1200, cepandant les déformations qu'il contient sont d'un ordre de grandeur plus élevé.
|
||||
|
||||
|
|
@ -699,22 +704,18 @@ Les locaux de l'entreprise se présentent sous la forme de vastes openspaces, pa
|
|||
Chaque employé dispose d'une station de travail sous la forme d'un ordinateur portable, connecté à un dock sur le bureau. Afin de réaliser des calculs intensifs, nous avons la possibilité de nous connecter au cluster de calcul local, appelé Rosetta, utilisant le système slurm. Ce cluster est composé d'environ 3000 cœurs CPU, 50 GPU et dispose de plusieurs téraoctets de RAM et de stockage disque. Pour le développement de nos projets, nous exploitons la forge interne de Safran, qui est une plateforme GitLab dédiée.
|
||||
En outre, chaque employé a accès à la suite professionnelle Office 365, qui facilite la gestion des documents et des e-mails. 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 gestion de version Git. Le cluster de calcul étant coupé d'internet, nous utilisons accédons à un artifcatory pour télécharger les dépendances nécessaire.
|
||||
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.
|
||||
|
||||
% parler un peu des outils, python, pytorch, toussa toussa, conda, mamba, artifactory, coupé internet proxy
|
||||
|
||||
% décrire le process de réservation slurm ?
|
||||
% TODO: décrire le process de réservation slurm ?
|
||||
|
||||
\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. Voici la liste des implémentations que j'ai évaluées, les idées que j'ai explorées, ainsi que mes observations relatives à chaque approche, dans un ordre approximativement chronologique.
|
||||
À 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}
|
||||
|
||||
% parler du fait que pytorch geometric à facilité un peu la tache d'implem
|
||||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{graphvae-architecture.png}
|
||||
|
|
@ -722,29 +723,41 @@ La stack technique utilisée par l'équipe est basée sur Python, avec des bibli
|
|||
\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 familiariser avec ces concepts. Nous avons ensuite étendu ces expérimentations à des architectures spécifiques aux graphes via GraphVae~\cite{simonovsky_graphvae_2018}. Les résultats obtenus étaient encourageants: le réseau était capable de générer des structures, mais la qualité des générations n'était pas exceptionnelle. De plus, nous avons constaté que le réseau était beaucoup trop volumineux par rapport à sa fonctionnalité.
|
||||
L'une de nos premières initiatives a été de tester des réseaux basés sur les \glspl{vae}. Après avoir lu des articles de recherche sur les \glspl{vae}, j'ai réalisé plusieurs implémentations sur des images pour me refamiliariser avec ces concepts.
|
||||
Nous avons ensuite étendu ces expérimentations à des architectures spécifiques aux graphes via GraphVae~\cite{simonovsky_graphvae_2018}. Les résultats obtenus étaient encourageants: le réseau était capable de générer des structures, mais la qualité des générations n'était pas exceptionnelle. De plus, nous avons constaté que le réseau était beaucoup trop volumineux par rapport à sa fonctionnalité.
|
||||
|
||||
% insérer ici screen des résultats de graphvae
|
||||
% TODO: insérer ici screen des résultats de graphvae
|
||||
|
||||
En effet, dans le contexte des graphes, les opérations de "upsampling" n'existent pas de manière directe. Par conséquent, nous avons rencontré des difficultés lors du passage du vecteur latent (représentant une distribution gaussienne) à une représentation sous forme de graphe (noeuds + connectivité) dans le décodeur du \gls{vae}.
|
||||
|
||||
Une première solution simple consistait en l'utilisation de une ou plusieurs couches denses (\glspl{mlp}) pour convertir le vecteur latent en un couple de matrices décrivant les positions et la connectivité des noeuds. Cependant, cette approche posait problème en raison de la taille des graphes que nous manipulions. En effet, avec des graphes de $n=30000$ nœuds, cela impliquait une matrice de connectivité de taille $n^2 = 30000^2 = 9.10^9$, ce qui faisait aisaiment exploser la complexité lorsque nous utilisions des couches denses.
|
||||
Une première solution simple consistait en l'utilisation de une ou plusieurs couches denses (\glspl{mlp}) pour convertir le vecteur latent en un couple de matrices décrivant les positions et la connectivité des noeuds. Cependant, cette approche posait problème en raison de la taille des graphes que nous manipulions. En effet, avec des graphes de $n=3.10^4$ nœuds, cela impliquait une matrice de connectivité de taille $n^2 = 9.10^8$, ce qui faisait aisaiment exploser la complexité lorsque nous utilisions des couches denses.
|
||||
|
||||
Pour donner un ordre de grandeur, si l'on utilisai un espace latent de taille $8$, rien que pour prédire les positions 3D des points dans notre maillage (sans prendre en compte la connectivité), l'utilisation d'une seule couche dense impliquait déjà $8 \times 30000 \times 3 = 7,2.10^6$ paramètres. Prédire la connectivité était tout simplement impossible, car il aurait fallu une couche dense avec plus de $8 \times 30000^2 = 7,2.10^{10}$ paramètres, ce qui dépassait largement les capacités de calcul de nos ressources GPU.
|
||||
Pour donner un ordre de grandeur, si l'on utilisai un espace latent de taille $8$, rien que pour prédire les positions 3D des points dans notre maillage (sans prendre en compte la connectivité), l'utilisation d'une seule couche dense impliquait déjà $8 \times 3.10^4 \times 3 = 7,2.10^6$ paramètres. Prédire la connectivité était tout simplement impossible, car il aurait fallu une couche dense avec plus de $8 \times 9.10^8 = 7,2.10^9$ 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. Cette approche permettait d'éviter l'utilisation de couches denses dans le décodeur grâce aux connexions résiduelles (skip connections). Cependant, ce faisant l'information ne passait pas entièrement par l'espace latent entre le décodeur et l'encodeur. Par conséquent, il était impossible de créer un modèle génératif complet avec cette architecture, puisqu'une partie de l'information pour générer des échantillons était compris dans les skip connections.
|
||||
Une seconde solution consitait à utiliser une architecture plus intelligente, telle que Graph U-Net. Cette approche permettait d'éviter l'utilisation de couches denses dans le décodeur grâce à 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.
|
||||
|
||||
Face aux difficultés rencontrées avec les réseaux basés sur les VAE et les limitations de l'architecture Graph U-Net, nous avons pris la décision de mettre de côté ces approches. Et plus largement puisque la connectivité de nos graphes est "locale" (les noeuds sont connectés à leurs voisins proches dans l'espace), nous avons décidé de nous orienter vers des approches basées uniquement sur les positions des noeuds. En effet, la connectivité d'un nuage de points peut facilement être retrouvé via diverses techniques~\cite{peng_shape_2021,sulzer_deep_2022}.
|
||||
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 facilement être retrouvé via diverses techniques~\cite{peng_shape_2021,sulzer_deep_2022,andrade-loarca_poissonnet_2023}.
|
||||
|
||||
\FloatBarrier
|
||||
\subsection{Test de PointFlow}
|
||||
|
||||
L'approche la plus connue pour utilise des \glspl{nf} sur des nuages de points est PointFlow~\cite{yang_pointflow_2019}. Adapter l'implémentation originale afin d'y intégrer l'utilisation de Rotor37\_1200 s'est avéré être une tâche aisée, entraînant des résultats supérieurs à ceux obtenus par GraphVAE, bien que sans être exceptionnels. La structure du code s'est cependant révélée relativement diffusers à manipuler pour toute autre tâche plus complexe (comme souvent avec du code académique).
|
||||
L'approche la plus connue pour utilise des \glspl{nf} sur des nuages de points est PointFlow~\cite{yang_pointflow_2019}. Adapter l'implémentation originale afin d'y intégrer l'utilisation de Rotor37\_1200 s'est avéré être une tâche aisée, entraînant des résultats supérieurs à ceux obtenus par GraphVAE, bien que sans être exceptionnels. La structure du code s'est cependant révélée relativement difficile à manipuler pour toute autre tâche plus complexe (comme souvent avec du code académique).
|
||||
|
||||
% TODO: insérer ici résultats
|
||||
|
||||
PointFlow a néanmoins apporté une contribution significative à la création d'un dataset de référence pour la génération de nuages de points, qui est actuellement exploité par de multiples articles de recherche. Ce jeu de données repose sur ShapeNet~\cite{shapenet2015}, un ensemble de données dédiée à une variété d'objets en trois dimensions (tels que des avions, des chaises, des voitures, etc.), modifié par Furthest Point Sampling pour contenir uniquement 2048 points par nuages.
|
||||
De plus, PointFlow a joué un rôle essentiel dans l'implémentation de différentes métriques et distances en CUDA, telles que la \gls{cd}, l'\gls{emd}, et bien d'autres.
|
||||
|
||||
% insérer ici résultats
|
||||
\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}.
|
||||
|
||||
% TODO: parler de rotor37\_1200\_mmd2048
|
||||
|
||||
\FloatBarrier
|
||||
\subsection{Présentation de PointNet}
|
||||
|
|
@ -753,7 +766,6 @@ Dans le contexte de l'apprentissage sur les nuages de points, une architecture s
|
|||
|
||||
Par la suite, une avancée significative du modèle PointNet a conduit à l'émergence de PointNet++, qui est désormais reconnu comme l'architecture de référence dans ce domaine. PointNet++ propose une approche hiérarchique en profondeur qui combine judicieusement des techniques d'échantillonnage (telles que le Furthest Point Sampling) et d'agrégation (comme la recherche des K Nearest Neighbors) appliquées aux points du nuage. Cette approche vise à étendre la portée des opérations locales de manière à englober des champs réceptifs globaux, contribuant ainsi à l'amélioration des performances du réseau.
|
||||
|
||||
% insérer ici image archite pointnet et poitnet++
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{pointnet-architecture.jpg}
|
||||
|
|
@ -762,45 +774,45 @@ Par la suite, une avancée significative du modèle PointNet a conduit à l'éme
|
|||
\end{figure}
|
||||
|
||||
\FloatBarrier
|
||||
\subsection{Présentation des KPConv}
|
||||
\subsection{Présentation des \glspl{kpconv}}
|
||||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{kpconv-architecture.png}
|
||||
\caption{Architecture de KP-FCNN et KP-CNN}
|
||||
\caption{Architecture de KP-FCNN et KP-CNN, construit avec des \glspl{kpconv}}
|
||||
\label{fig:kpconv_archi}
|
||||
\end{figure}
|
||||
|
||||
Une autre architecture largement reconnue dans le domaine du traitement de nuages de points, présentant des similitudes avec PointNet++, est nommée KPConv. Cette architecture utilise un échantillonnage basé sur une grille de voxels et des opérations d'agrégation via des KPConvs, qui sont des convolutions sur boules. Cette architecture est également très efficace, et surpasse généralement les autres architectures sur les taches de segmentation.
|
||||
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. Cette architecture est également très efficace, et surpasse généralement les autres architectures sur les taches de segmentation.
|
||||
|
||||
\FloatBarrier
|
||||
\subsection{Test de KPFCNN}
|
||||
\subsection{Test de KP-FCNN}
|
||||
|
||||
Dans notre situation, nous avons la possibilité d'opter pour le réseau KPFCNN, initialement conçu pour la segmentation, mais pouvant être ajusté pour la prédiction de bruit. À cette fin, nous faisons usage de la bibliothèque easy\_kpconv, laquelle met en œuvre les KPConv et nous autorise à maintenir un code clair et réutilisable. Lorsque nous l'entraînons sur le jeu de données rotor37\_1200\_mmd2048, nous obtenons des résultats hautement probants.
|
||||
Dans notre situation, nous avons la possibilité d'opter pour le réseau KP-FCNN, 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, laquelle met en œuvre les \glspl{kpconv} et nous autorise à maintenir un code clair et réutilisable. Lorsque nous l'entraînons sur le jeu de données rotor37\_1200\_mmd2048, nous obtenons des résultats plutôt probants.
|
||||
|
||||
% insérer ici résultats
|
||||
% TODO: insérer ici résultats
|
||||
|
||||
% décrire les résultats, c'est bien, mais encore un peu de bruit et pas trop scalable à cause des MLPs dans le decodeur
|
||||
|
||||
\FloatBarrier
|
||||
\subsection{Présentation des PVConv}
|
||||
\subsection{Présentation des \glspl{pvconv}}
|
||||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{pvconv.png}
|
||||
\caption{Architecture d'une PVConv}
|
||||
\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 PVConvs. Les PVConvs 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 PVConv est composée de deux branches distinctes. La première branche, appelée "coarse-grained", transforme les points en voxels, applique des convolutions, puis reconvertit les voxels en points à l'aide d'une interpolation trilinéaire. La seconde branche, nommée "fine-grained", est constituée de shared \glspl{mlp}. Ces deux branches sont ensuite combinées par sommation.
|
||||
Une seconde alternative aux opérations de convolutions et d'aggregation de PointNet++ sont les \glspl{pvconv}~\cite{liu_point-voxel_2019}. Les \glspl{pvconv} proposent d'utiliser des voxels afin de retomber sur des structures régulières, permettant ainsi d'effectuer efficacement des convolutions classiques en 3D. Par conséquent, une \gls{pvconv} est composée de deux branches distinctes. 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.
|
||||
|
||||
Ainsi, PVCNN se présente comme l'équivalent de PointNet, tandis que PVCNN++ équivaut à PointNet++. Il est à noter que la différence réside dans le fait que le nombre de points reste constant à chaque couche du réseau. Sur les benchmarks, PVCNN++ s'avère au moins aussi efficace que pointNet++ tout en étant bien plus efficace. Cependant PVCNN++ est plus complexe à implémenter, et nécessite l'utilisation plusieurs modules CUDA.
|
||||
|
||||
Par conséquent, PVCNN peut être considéré comme l'équivalent de PointNet, tandis que PVCNN++ correspond à PointNet++. Une distinction importante réside dans le maintien d'un nombre constant de points à chaque couche du réseau. Les benchmarks démontrent que PVCNN++ est au moins autant 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).
|
||||
Il existe également une légère amélioration de PVConv nommée SPVConv, reposant sur des opérations de convolutions creuses. improvements, mais cuda très esotérique
|
||||
Par conséquent, PVCNN peut être considéré comme l'équivalent de PointNet, tandis que PVCNN++ correspond à PointNet++. Cpendant, ces deux réseau basés sur de \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 autant 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, il a été empiriquement observé que les grilles de voxels sont fréquemment remplies en moyenne à hauteur de 60\%. Cependant, ces améliorations nécessitent l'utilisation de code CUDA très ésotérique.
|
||||
|
||||
\FloatBarrier
|
||||
\subsection{Test de PVD}
|
||||
|
||||
Le premier papier à utiliser une architecture du type PVCNN++ pour la générations de nuages de point est PVD. Si l'on récupère l'implémentation des auteurs et que l'on la modifie pour utiliser rotor37\_37\_mmd2048 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.
|
||||
Le premier papier ayant utilisé une architecture du type PVCNN++ pour la générations de nuages de point est PVD. 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\_37\_mmd2048 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
|
||||
|
|
@ -809,6 +821,8 @@ Le premier papier à utiliser une architecture du type PVCNN++ pour la générat
|
|||
\label{fig:pvd_archi}
|
||||
\end{figure}
|
||||
|
||||
% TODO: afficher résultats et décrire
|
||||
|
||||
\FloatBarrier
|
||||
\glsunset{ldm}
|
||||
\subsection{Test de LION}
|
||||
|
|
@ -820,44 +834,66 @@ Le premier papier à utiliser une architecture du type PVCNN++ pour la générat
|
|||
\label{fig:lion_archi}
|
||||
\end{figure}
|
||||
|
||||
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 à PVD. LION exploite la diffusion latente via un \gls{vae} à deux étapes pour comprimer les nuages de points avant d'appliquer le processus de diffusion.
|
||||
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 à PVD. LION exploite la diffusion latente via un \gls{vae} à deux étages pour comprimer les nuages de points avant d'appliquer le processus de diffusion.
|
||||
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.
|
||||
|
||||
% insérer résultat
|
||||
% TODO: insérer résultat ?
|
||||
|
||||
\FloatBarrier
|
||||
\subsection{Synthèse des méthodes}
|
||||
|
||||
% obligé de faire ma propre implem car, les implems des papiers sont tellement chelou que comme on veut conditionner avec des scalaires, j'arrive pas à modifier leur code, donc je fais ma propre implèm.
|
||||
% souvent trop de params pour le problème aussi
|
||||
Les résultats précédents montrent que la résolution de notre problème est possible. Cependant une majorité des approche précedente traitent de la génération non conditonnée, ou alors conditionnent sur des classes d'objets via des onehot vectors. Puisque nous souhaitons conditionner via des vecteurs scalaires, et car les implémentations présentée prédemment sont difficile à manipiler, nous avons décidé de développer notre propre implémentation. De plus, de manière générale les modèles présentés précedemment comporte souvent trop de paramètre pour notre problème, qui reste tout de même plus simple en comparaison.
|
||||
|
||||
Pour essayer d'améliorer ces résultats, on peut apprendre à faire de la diffusion sur des variables latente, plutout que direct sur nos données. avantage, réduciton de dimension + informtion latente.
|
||||
pour essayer d'améliorer les résultats que nous avions obtenus via KP-FCNN, nous avons opté pour une approche par \gls{ldm}. Pour cela il nous fallait choisir un modèle capable de transformer/réduire nos données d'entrée. Nous avons sélectionné dans un premier temps une \gls{pca}. En effet, après analyse, les données de rotor37\_1200 se porte très bien à une compression par \gls{pca}. De plus, il s'agit d'une méthode non paramétrique, ce qui est un avantage car pas besoin d'opti.
|
||||
|
||||
dans un premier temps on compresse donc nos nuages de point via une PCA, ça marche du feu de dieu
|
||||
% TODO: insérer figures cumsum mode pca
|
||||
|
||||
on test d'autres méthodes parameter free, comme la POD, marche moins bien
|
||||
Via cette figure nous en déduisons qu'environ 30 modes permettent de décrire 99\% de l'information contenue dans les données. Nous avons donc choisi de réduire nos données à 30 dimensions via une \gls{pca}. Dans le cas de rotor37\_1200 on passe donc de 30000 points contenant leur positions et leur normales à un vecteur de taille 30. Ce vecteur etant très petit et aussi structuré, nous pouvons nous permettre d'utiliser un simple \gls{mlp} pour prédire le bruit dans le \gls{ddpm}. Le réseau résultat dépasse à peine les 10 000 paramètres, ce qui est très peu comparé aux autres modèles présentés précedemment. Ainsi le réseau est très simple à manipuler et à entrainer. Pour le décodeur nous pouvons donc simplement effectuer l'opération inverse de la PCA pour transformer un vecteure de taille 30 en un nuage de points de taille 30000 (positions + normales).
|
||||
|
||||
Après quelques entrainements, on obtient des résultats très satisfasant, comme le montre la figure suivante:
|
||||
|
||||
% TODO: insérer des résultats
|
||||
|
||||
% décrire les résultat.
|
||||
|
||||
\FloatBarrier
|
||||
\glsunset{cfg}
|
||||
\subsection{Application du \acrfull{cfg}}
|
||||
\subsection{Condtionnement par \acrfull{cfg}}
|
||||
|
||||
conditionnemnt, classifier-free guidance
|
||||
% TODO: rappeller le vecteure de perf, 5 bidules
|
||||
% TODO: parler de la concatenation des 2 inputs cfd avec les modes pca
|
||||
|
||||
Pour conditionner notre processus de diffusion, nous avons choisi d'utiliser la \gls{cfg}, avec une probabilité de 10\% pour le dropout des embeddings. Pour rajouter les embeddings de conditionnement dans notre réseau, nous procédons de la même manière que pour les embeddings de timesteps. La surface de coût du réseau change très peu, et nous somme désormais capable de génerer des aubes non conditionnées ou conditionnées selon un vecteur scalaire de performances. Visuellement les générations sont toujours satifisante, cependant il est impossible de déterminer à l'oeil nu si les aube conditonnées générées respectent bien le conditonnement qu'elles devraient avoir.
|
||||
|
||||
\FloatBarrier
|
||||
\glsunset{gp}
|
||||
\subsection{Vérification par \acrfull{gp}}
|
||||
|
||||
À cet effet nous devons donc trouver un moyen de vérifier les propriétés physiques des aubes et les comparés aux conditionnement. De manière naive nous pourrions simplement passer nos générations dans un simulateur \gls{cfd}, mais cette approche n'est pas envisageable car trop lente.
|
||||
|
||||
Une solution est d'entrainer un modèle de regression pour trouver une relation entre nos nuages de points (ou leurs espaces latents) et critèrs de performances. Nous pouvons évidemment faire cela via réseau de neurones, mais nous pouvons aussi opter pour une approche moins paramétrique tel que les \glspl{gp}. Les \glspl{gp} sont ...
|
||||
|
||||
\begin{figure}[h!]
|
||||
\centering
|
||||
\includegraphics[width=0.8\textwidth]{gp.png}
|
||||
\caption{Régression par \gls{gp}}
|
||||
\vspace*{-11pt}
|
||||
\caption*{Source: doi:10.23915/distill.00017~\cite{görtler2019a}}
|
||||
\label{fig:gp_regression}
|
||||
\end{figure}
|
||||
|
||||
pour vérif si la génération est bonne, on entraine des GP
|
||||
Ainsi si l'on entrainer un \gls{gp} sur des couples (nuage de points, critère de performance), on peut ensuite utiliser ce \gls{gp} pour vérifier si nos nuages de points générés sont corrects. En effet, si l'on génère un nuage de points, et que l'on obtient un critère de performance très différent de celui attendu, alors on peut en déduire que notre génération est incorrecte.
|
||||
|
||||
% insérer figure gp entrainé
|
||||
|
||||
% insérer figure gp générations massflow=-1
|
||||
|
||||
% insérer figure gp générations efficiency=1
|
||||
|
||||
Comme on l'observe sur les figures, on observe très clairement un changement de la densité de probabilité des modes \glspl{pca} lorsque l'on conditionne nos générations. on en déduit que notre modèle est capable de générer correctement des données conditionnées. On observer de même sa capacité à générer certaines données out of distribution, du moment que celle-ci ne sont pas trop éloignées de la distribution d'entrainement. Par example il est totalement impossible de demander la génération d'aubes ayant un in\_massflow et out\_massflow différents, car cela n'existe pas dans le jeu de données d'entrainement, et car cela est aussi impossible physiquement dans un système fermé.
|
||||
|
||||
\FloatBarrier
|
||||
\chapter{Conclusion}
|
||||
|
|
|
|||
|
|
@ -1182,4 +1182,85 @@ Publisher: Multidisciplinary Digital Publishing Institute},
|
|||
year = {2020},
|
||||
note = {arXiv:2003.08934 [cs]},
|
||||
keywords = {Computer Science - Computer Vision and Pattern Recognition, Computer Science - Graphics},
|
||||
file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/8ANFVRTK/Mildenhall et al. - 2020 - NeRF Representing Scenes as Neural Radiance Field.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/RNKQHNTD/2003.html:text/html},
|
||||
}
|
||||
|
||||
@misc{andrade-loarca_poissonnet_2023,
|
||||
title = {{PoissonNet}: {Resolution}-{Agnostic} {3D} {Shape} {Reconstruction} using {Fourier} {Neural} {Operators}},
|
||||
shorttitle = {{PoissonNet}},
|
||||
url = {http://arxiv.org/abs/2308.01766},
|
||||
doi = {10.48550/arXiv.2308.01766},
|
||||
abstract = {We introduce PoissonNet, an architecture for shape reconstruction that addresses the challenge of recovering 3D shapes from points. Traditional deep neural networks face challenges with common 3D shape discretization techniques due to their computational complexity at higher resolutions. To overcome this, we leverage Fourier Neural Operators (FNOs) to solve the Poisson equation and reconstruct a mesh from oriented point cloud measurements. PoissonNet exhibits two main advantages. First, it enables efficient training on low-resolution data while achieving comparable performance at high-resolution evaluation, thanks to the resolution-agnostic nature of FNOs. This feature allows for one-shot super-resolution. Second, our method surpasses existing approaches in reconstruction quality while being differentiable. Overall, our proposed method not only improves upon the limitations of classical deep neural networks in shape reconstruction but also achieves superior results in terms of reconstruction quality, running time, and resolution flexibility. Furthermore, we demonstrate that the Poisson surface reconstruction problem is well-posed in the limit case by showing a universal approximation theorem for the solution operator of the Poisson equation with distributional data utilizing the Fourier Neural Operator, which provides a theoretical foundation for our numerical results. The code to reproduce the experiments is available on: {\textbackslash}url\{https://github.com/arsenal9971/PoissonNet\}.},
|
||||
urldate = {2023-08-21},
|
||||
publisher = {arXiv},
|
||||
author = {Andrade-Loarca, Hector and Hege, Julius and Bacho, Aras and Kutyniok, Gitta},
|
||||
month = aug,
|
||||
year = {2023},
|
||||
note = {arXiv:2308.01766 [cs, math]},
|
||||
keywords = {Computer Science - Computer Vision and Pattern Recognition, Mathematics - Analysis of PDEs},
|
||||
file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/WBRQ6JS8/Andrade-Loarca et al. - 2023 - PoissonNet Resolution-Agnostic 3D Shape Reconstru.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/XLVSY3VP/2308.html:text/html},
|
||||
}
|
||||
|
||||
@misc{wu_3d_2015,
|
||||
title = {{3D} {ShapeNets}: {A} {Deep} {Representation} for {Volumetric} {Shapes}},
|
||||
shorttitle = {{3D} {ShapeNets}},
|
||||
url = {http://arxiv.org/abs/1406.5670},
|
||||
doi = {10.48550/arXiv.1406.5670},
|
||||
abstract = {3D shape is a crucial but heavily underutilized cue in today's computer vision systems, mostly due to the lack of a good generic shape representation. With the recent availability of inexpensive 2.5D depth sensors (e.g. Microsoft Kinect), it is becoming increasingly important to have a powerful 3D shape representation in the loop. Apart from category recognition, recovering full 3D shapes from view-based 2.5D depth maps is also a critical part of visual understanding. To this end, we propose to represent a geometric 3D shape as a probability distribution of binary variables on a 3D voxel grid, using a Convolutional Deep Belief Network. Our model, 3D ShapeNets, learns the distribution of complex 3D shapes across different object categories and arbitrary poses from raw CAD data, and discovers hierarchical compositional part representations automatically. It naturally supports joint object recognition and shape completion from 2.5D depth maps, and it enables active object recognition through view planning. To train our 3D deep learning model, we construct ModelNet -- a large-scale 3D CAD model dataset. Extensive experiments show that our 3D deep representation enables significant performance improvement over the-state-of-the-arts in a variety of tasks.},
|
||||
urldate = {2023-08-21},
|
||||
publisher = {arXiv},
|
||||
author = {Wu, Zhirong and Song, Shuran and Khosla, Aditya and Yu, Fisher and Zhang, Linguang and Tang, Xiaoou and Xiao, Jianxiong},
|
||||
month = apr,
|
||||
year = {2015},
|
||||
note = {arXiv:1406.5670 [cs]},
|
||||
keywords = {Computer Science - Computer Vision and Pattern Recognition},
|
||||
file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/VWP2VLGH/Wu et al. - 2015 - 3D ShapeNets A Deep Representation for Volumetric.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/58SJMCSB/1406.html:text/html},
|
||||
}
|
||||
|
||||
@misc{liao_kitti-360_2022,
|
||||
title = {{KITTI}-360: {A} {Novel} {Dataset} and {Benchmarks} for {Urban} {Scene} {Understanding} in {2D} and {3D}},
|
||||
shorttitle = {{KITTI}-360},
|
||||
url = {http://arxiv.org/abs/2109.13410},
|
||||
doi = {10.48550/arXiv.2109.13410},
|
||||
abstract = {For the last few decades, several major subfields of artificial intelligence including computer vision, graphics, and robotics have progressed largely independently from each other. Recently, however, the community has realized that progress towards robust intelligent systems such as self-driving cars requires a concerted effort across the different fields. This motivated us to develop KITTI-360, successor of the popular KITTI dataset. KITTI-360 is a suburban driving dataset which comprises richer input modalities, comprehensive semantic instance annotations and accurate localization to facilitate research at the intersection of vision, graphics and robotics. For efficient annotation, we created a tool to label 3D scenes with bounding primitives and developed a model that transfers this information into the 2D image domain, resulting in over 150k images and 1B 3D points with coherent semantic instance annotations across 2D and 3D. Moreover, we established benchmarks and baselines for several tasks relevant to mobile perception, encompassing problems from computer vision, graphics, and robotics on the same dataset, e.g., semantic scene understanding, novel view synthesis and semantic SLAM. KITTI-360 will enable progress at the intersection of these research areas and thus contribute towards solving one of today's grand challenges: the development of fully autonomous self-driving systems.},
|
||||
urldate = {2023-08-21},
|
||||
publisher = {arXiv},
|
||||
author = {Liao, Yiyi and Xie, Jun and Geiger, Andreas},
|
||||
month = jun,
|
||||
year = {2022},
|
||||
note = {arXiv:2109.13410 [cs]},
|
||||
keywords = {Computer Science - Computer Vision and Pattern Recognition},
|
||||
file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/NV46RRNN/Liao et al. - 2022 - KITTI-360 A Novel Dataset and Benchmarks for Urba.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/GSUST75L/2109.html:text/html},
|
||||
}
|
||||
|
||||
@misc{deitke_objaverse-xl_2023,
|
||||
title = {Objaverse-{XL}: {A} {Universe} of {10M}+ {3D} {Objects}},
|
||||
shorttitle = {Objaverse-{XL}},
|
||||
url = {http://arxiv.org/abs/2307.05663},
|
||||
doi = {10.48550/arXiv.2307.05663},
|
||||
abstract = {Natural language processing and 2D vision models have attained remarkable proficiency on many tasks primarily by escalating the scale of training data. However, 3D vision tasks have not seen the same progress, in part due to the challenges of acquiring high-quality 3D data. In this work, we present Objaverse-XL, a dataset of over 10 million 3D objects. Our dataset comprises deduplicated 3D objects from a diverse set of sources, including manually designed objects, photogrammetry scans of landmarks and everyday items, and professional scans of historic and antique artifacts. Representing the largest scale and diversity in the realm of 3D datasets, Objaverse-XL enables significant new possibilities for 3D vision. Our experiments demonstrate the improvements enabled with the scale provided by Objaverse-XL. We show that by training Zero123 on novel view synthesis, utilizing over 100 million multi-view rendered images, we achieve strong zero-shot generalization abilities. We hope that releasing Objaverse-XL will enable further innovations in the field of 3D vision at scale.},
|
||||
urldate = {2023-08-21},
|
||||
publisher = {arXiv},
|
||||
author = {Deitke, Matt and Liu, Ruoshi and Wallingford, Matthew and Ngo, Huong and Michel, Oscar and Kusupati, Aditya and Fan, Alan and Laforte, Christian and Voleti, Vikram and Gadre, Samir Yitzhak and VanderBilt, Eli and Kembhavi, Aniruddha and Vondrick, Carl and Gkioxari, Georgia and Ehsani, Kiana and Schmidt, Ludwig and Farhadi, Ali},
|
||||
month = jul,
|
||||
year = {2023},
|
||||
note = {arXiv:2307.05663 [cs]},
|
||||
keywords = {Computer Science - Artificial Intelligence, Computer Science - Computer Vision and Pattern Recognition},
|
||||
file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/3CPCAZDV/Deitke et al. - 2023 - Objaverse-XL A Universe of 10M+ 3D Objects.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/JTXUJPK5/2307.html:text/html},
|
||||
}
|
||||
|
||||
@misc{deitke_objaverse_2022,
|
||||
title = {Objaverse: {A} {Universe} of {Annotated} {3D} {Objects}},
|
||||
shorttitle = {Objaverse},
|
||||
url = {http://arxiv.org/abs/2212.08051},
|
||||
doi = {10.48550/arXiv.2212.08051},
|
||||
abstract = {Massive data corpora like WebText, Wikipedia, Conceptual Captions, WebImageText, and LAION have propelled recent dramatic progress in AI. Large neural models trained on such datasets produce impressive results and top many of today's benchmarks. A notable omission within this family of large-scale datasets is 3D data. Despite considerable interest and potential applications in 3D vision, datasets of high-fidelity 3D models continue to be mid-sized with limited diversity of object categories. Addressing this gap, we present Objaverse 1.0, a large dataset of objects with 800K+ (and growing) 3D models with descriptive captions, tags, and animations. Objaverse improves upon present day 3D repositories in terms of scale, number of categories, and in the visual diversity of instances within a category. We demonstrate the large potential of Objaverse via four diverse applications: training generative 3D models, improving tail category segmentation on the LVIS benchmark, training open-vocabulary object-navigation models for Embodied AI, and creating a new benchmark for robustness analysis of vision models. Objaverse can open new directions for research and enable new applications across the field of AI.},
|
||||
urldate = {2023-08-21},
|
||||
publisher = {arXiv},
|
||||
author = {Deitke, Matt and Schwenk, Dustin and Salvador, Jordi and Weihs, Luca and Michel, Oscar and VanderBilt, Eli and Schmidt, Ludwig and Ehsani, Kiana and Kembhavi, Aniruddha and Farhadi, Ali},
|
||||
month = dec,
|
||||
year = {2022},
|
||||
note = {arXiv:2212.08051 [cs]},
|
||||
keywords = {Computer Science - Artificial Intelligence, Computer Science - Computer Vision and Pattern Recognition, Computer Science - Graphics, Computer Science - Robotics},
|
||||
file = {arXiv Fulltext PDF:/home/laurent/Zotero/storage/3C3TW2HB/Deitke et al. - 2022 - Objaverse A Universe of Annotated 3D Objects.pdf:application/pdf;arXiv.org Snapshot:/home/laurent/Zotero/storage/Q9MANWHX/2212.html:text/html},
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue