Discussion :

[dourouc05]

Dans le développement de jeux vidéo, la création de modèles 3D prend une bonne partie du temps total, mais aussi des gens compétents. Certains ont donc eu l’idée d’automatiser cette partie, par exemple à l’aide de réseaux neuronaux, la tarte à la crème actuelle. L’idée très générale est simple : on entre une image, on ressort un modèle 3D. Un peu plus en détail, on voit déjà apparaître des zones d’ombre : on peut traiter assez facilement des images avec des réseaux neuronaux, mais quid des modèles 3D ? Quelle architecture pourrait-on utiliser pour relier les deux ? Comment effectuer l’entraînement du système ? Commençons par la troisième partie.

Quand il s’agit de transformations du genre, il est courant d’utiliser des GAN, des réseaux antagonistes génératifs : dans ce cas-ci, par exemple, un réseau neuronal crée un modèle 3D à partir d’une image 2D, un autre réseau décide si le modèle 3D correspond bien à l’image 2D. Ainsi, on dispose d’un mécanisme qui peut améliorer le générateur de modèles 3D. Cependant, comment décider si le modèle 3D correspond à l’image ? Pour ce faire, il faut utiliser un moteur de rendu, auquel on fournit le modèle 3D produit : il ressort une image, que l’on compare avec l’image d’entrée.

Et si on simplifiait la chose, en intégrant le moteur de rendu dans le réseau neuronal (au moins pendant son entraînement) ? Ainsi, on a un réseau qui prend une image en entrée, ressort un modèle 3D, qui passe dans un moteur de rendu, on calcule l’erreur du modèle en comparant l’image obtenue à la sortie du moteur de rendu avec l’image d’entrée. Il faut “juste” arriver à dériver le moteur de rendu, ce que l’on arrive à faire depuis quelques années, de manière approchée (mais de manière exacte avec du lancer de rayons). Les chercheurs introduisent cependant une nouvelle approche, DIB-R (differentiable interpolation-based renderer), avec un mélange d’interpolation locale (comme le fait tout moteur de rendu, par exemple à l’échelle d’un triangle éclairé) et d’agrégation globale.

Ensuite, quelle architecture de réseau faut-il utiliser ? Le choix des chercheurs de NVIDIA s’est porté sur un encodeur-décodeur, pour (en principe) réduire l’image à quelques paramètres très significatifs (par exemple : oiseau, petit, jaune). L’encodeur peut donc notamment effectuer une tâche de reconnaissance d’objet.

Comment représenter un modèle 3D ? Les chercheurs ont pris la manière la plus classique de faire : ils présupposent que le modèle peut être formé à partir d’une sphère avec une discrétisation donnée ; la sortie du modèle est la position et la couleur de chaque arête de cette sphère. D’une certaine manière, cette sortie est une “image” à six dimensions (trois pour la position, trois pour la couleur), d’où l’utilisation d’une architecture avec des convolutions pour gérer la sortie. (Pour obtenir de meilleurs résultats, les chercheurs ont aussi étendu leur travail pour générer une texture en sortie, ainsi que des informations d’éclairage.) L’arrière-plan de l’image est extrait et affiché derrière le modèle 3D.

Le résultat est une application qui peut générer des modèles 3D en moins de cent millisecondes. Ces derniers ne sont pas encore parfaits (bien que meilleurs que les approches précédentes), mais sont une bonne base pour un artiste : il peut gagner beaucoup de temps en partant de ces modèles plutôt que de zéro. Son entraînement a néanmoins pris deux jours.

Source : l’article et son supplément.

Voir aussi : le code source de DIB-R.

[tlt]

Qu'entend-on par "rendu dérivable"? Du/par transfert learning?

[alf2010]

Merci beaucoup pour la clarté de l'article et plus généralement pour la qualité de vos nouvelles

[dourouc05]

Merci beaucoup pour la clarté de l'article et plus généralement pour la qualité de vos nouvelles

Merci, c'est le genre de message qui fait plaisir !

Qu'entend-on par "rendu dérivable"? Du/par transfert learning?

C'est-à-dire qu'un opérateur de dérivation peut passer à travers le moteur de rendu (vraiment au sens mathématique). Plus précisément : si on note le modèle 3D x et l'image obtenue par le moteur de rendu f(x), on veut pouvoir calculer la dérivée d'une chose comme ||f(x) - y||, c'est-à-dire une erreur sur l'image produite f(x) par rapport à l'image initiale y. Sauf que cette notation est un peu tronquée : x dépend déjà de y par rapport à une fonction assez complexe, paramétrée disons par θ. On veut calculer la dérivée de ||f(x(y, θ)) - y|| par rapport à chacun de ces paramètres θ. Or, pour y arriver, il faut une manière de dériver cette fonction f, d'où la notion de "moteur de rendu dérivable".