Comment fonctionne la génération de 3D à partir de texte AI : Meta 3D Gen, OpenAI Shap-E et plus

La capacité de générer des actifs numériques 3D à partir de invites de texte représente l’un des développements les plus excitants récents dans le domaine de l’IA et de l’informatique graphique. Alors que le marché des actifs numériques 3D devrait passer de 28,3 milliards de dollars en 2024 à 51,8 milliards de dollars d’ici 2029, les modèles d’IA de texte à 3D sont prêts à jouer un rôle majeur dans la révolution de la création de contenu dans des secteurs tels que les jeux, le cinéma, le commerce électronique et plus encore. Mais comment fonctionnent exactement ces systèmes d’IA ? Dans cet article, nous allons plonger dans les détails techniques derrière la génération de 3D à partir de texte.

Le défi de la génération 3D

Générer des actifs 3D à partir de texte est une tâche beaucoup plus complexe que la génération d’images 2D. Alors que les images 2D sont essentiellement des grilles de pixels, les actifs 3D nécessitent de représenter la géométrie, les textures, les matériaux et souvent les animations dans l’espace tridimensionnel. Cette dimensionnalité et complexité supplémentaires rendent la tâche de génération beaucoup plus difficile.

Certains des défis clés de la génération de texte à 3D incluent :

• Représenter la géométrie et la structure 3D
• Générer des textures et des matériaux cohérents sur la surface 3D
• Assurer la plausibilité physique et la cohérence à partir de plusieurs points de vue
• Capturer les détails fins et la structure globale simultanément
• Générer des actifs qui peuvent être facilement rendus ou imprimés en 3D

Pour relever ces défis, les modèles de texte à 3D exploitent plusieurs technologies et techniques clés.

Composants clés des systèmes de texte à 3D

La plupart des systèmes de génération de texte à 3D de pointe partagent quelques composants de base :

1. Encodage de texte : Conversion de l’invite de texte en représentation numérique
2. Représentation 3D : Méthode de représentation de la géométrie et de l’apparence 3D
3. Modèle génératif : Le modèle d’IA de base pour la génération de l’actif 3D
4. Rendering : Conversion de la représentation 3D en images 2D pour la visualisation

Explorons chacun de ces éléments en détail.

Encodage de texte

La première étape consiste à convertir l’invite de texte en représentation numérique que le modèle d’IA peut utiliser. Cela est généralement réalisé à l’aide de grands modèles de langage comme BERT ou GPT.

Représentation 3D

Il existe plusieurs façons courantes de représenter la géométrie 3D dans les modèles d’IA :

1. Grilles de voxels : Tableaux 3D de valeurs représentant l’occupation ou les fonctionnalités
2. Nuages de points : Ensembles de points 3D
3. Maillages : Sommets et faces définissant une surface
4. Fonctions implicites : Fonctions continues définissant une surface (par exemple, fonctions de distance signée)
5. Champs de radiance neuronaux (NeRFs) : Réseaux de neurones représentant la densité et la couleur dans l’espace 3D

Chacun de ces éléments présente des compromis en termes de résolution, d’utilisation de la mémoire et de facilité de génération. De nombreux modèles récents utilisent des fonctions implicites ou des NeRFs car ils permettent d’obtenir des résultats de haute qualité avec des exigences computationnelles raisonnables.

Par exemple, nous pouvons représenter une sphère simple comme une fonction de distance signée :

import numpy as np

<p>def sphere_sdf(x, y, z, radius=1.0):
return np.sqrt(x**2 + y**2 + z**2) - radius</p>

<p># Évaluer la SDF à un point 3D
point = [0.5, 0.5, 0.5]
distance = sphere_sdf(*point)
print(f&quot;Distance à la surface de la sphère: {distance}&quot;)

Modèle génératif

Le cœur d’un système de texte à 3D est le modèle génératif qui produit la représentation 3D à partir de l’encodage de texte. La plupart des modèles de pointe utilisent une variation de modèle de diffusion, similaire à ceux utilisés pour la génération d’images 2D.

Les modèles de diffusion fonctionnent en ajoutant progressivement du bruit aux données, puis en apprenant à inverser ce processus. Pour la génération 3D, ce processus se déroule dans l’espace de la représentation 3D choisie.

Un pseudocode simplifié pour une étape d’entraînement d’un modèle de diffusion pourrait ressembler à ceci :

def diffusion_training_step(model, x_0, text_embedding):
# Échantillonner un pas de temps aléatoire
t = torch.randint(0, num_timesteps, (1,))

<p># Ajouter du bruit à l'entrée
noise = torch.randn_like(x_0)
x_t = add_noise(x_0, noise, t)</p>

<p># Prévoir le bruit
predicted_noise = model(x_t, t, text_embedding)</p>

<p># Calculer la perte
loss = F.mse_loss(noise, predicted_noise)</p>

return loss

<p># Boucle d'entraînement
for batch in dataloader:
x_0, text = batch
text_embedding = encode_text(text)
loss = diffusion_training_step(model, x_0, text_embedding)
loss.backward()
optimizer.step()

Lors de la génération, nous partons d’un bruit pur et débruitons de manière itérative, conditionnée par l’encodage de texte.

Rendering

Pour visualiser les résultats et calculer les pertes pendant l’entraînement, nous devons rendre notre représentation 3D en images 2D. Cela est généralement réalisé à l’aide de techniques de rendering différentiables qui permettent aux gradients de s’écouler à rebours du processus de rendering.

Pour les représentations basées sur des maillages, nous pourrions utiliser un renderiseur basé sur la rasterisation :

import torch
import torch.nn.functional as F
import pytorch3d.renderer as pr

<p>def render_mesh(vertices, faces, image_size=256):
# Créer un renderiseur
renderer = pr.MeshRenderer(
rasterizer=pr.MeshRasterizer(),
shader=pr.SoftPhongShader()
)</p>

<p># Configurer la caméra
cameras = pr.FoVPerspectiveCameras()</p>

<p># Rendre
images = renderer(vertices, faces, cameras=cameras)</p>

return images

<p># Exemple d'utilisation
vertices = torch.rand(1, 100, 3) # Sommets aléatoires
faces = torch.randint(0, 100, (1, 200, 3)) # Faces aléatoires
rendered_images = render_mesh(vertices, faces)

Pour les représentations implicites comme les NeRFs, nous utilisons généralement des techniques de marche de rayon pour rendre les vues.

Assemblage de tout : La pipeline de texte à 3D

Maintenant que nous avons couvert les composants clés, explorons comment ils s’assemblent dans une pipeline de génération de texte à 3D typique :

1. Encodage de texte : L’invite de texte est encodée en une représentation vectorielle dense à l’aide d’un modèle de langage.
2. Génération initiale : Un modèle de diffusion, conditionné par l’encodage de texte, génère une représentation 3D initiale (par exemple, un NeRF ou une fonction implicite).
3. Cohérence multi-vue : Le modèle rend plusieurs vues de l’actif 3D généré et assure la cohérence entre les points de vue.
4. Affinement : Des réseaux supplémentaires peuvent affiner la géométrie, ajouter des textures ou améliorer les détails.
5. Sortie finale : La représentation 3D est convertie en un format souhaité (par exemple, un maillage texturé) pour une utilisation dans des applications en aval.

Voici un exemple simplifié de ce à quoi cela pourrait ressembler en code :

class TextTo3D(nn.Module):
def __init__(self):
super().__init__()
self.text_encoder = BertModel.from_pretrained('bert-base-uncased')
self.diffusion_model = DiffusionModel()
self.refiner = RefinerNetwork()
self.renderer = DifferentiableRenderer()

<p>def forward(self, text_prompt):
# Encodage de texte
text_embedding = self.text_encoder(text_prompt).last_hidden_state.mean(dim=1)</p>

<p># Génération de la représentation 3D initiale
initial_3d = self.diffusion_model(text_embedding)</p>

<p># Rendu de plusieurs vues
views = self.renderer(initial_3d, num_views=4)</p>

<p># Affinement basé sur la cohérence multi-vue
refined_3d = self.refiner(initial_3d, views)</p>

return refined_3d

<p># Utilisation
model = TextTo3D()
text_prompt = &quot;Une voiture de sport rouge&quot;
generated_3d = model(text_prompt)

Meilleurs modèles d’actifs 3D disponibles

3DGen – Meta

3DGen est conçu pour résoudre le problème de la génération de contenu 3D, tel que des personnages, des accessoires et des scènes, à partir de descriptions textuelles.

Large Language and Text-to-3D Models – 3d-gen

3DGen prend en charge le rendering basé sur les principes physiques (PBR), essentiel pour la relighting réaliste des actifs 3D dans les applications réelles. Il permet également la retexturisation générative de formes 3D générées ou créées par des artistes à l’aide de nouvelles invites textuelles. La pipeline intègre deux composants principaux : Meta 3D AssetGen et Meta 3D TextureGen, qui gèrent respectivement la génération de texte à 3D et la génération de texte à texture.

Meta 3D AssetGen

Meta 3D AssetGen (Siddiqui et al., 2024) est responsable de la génération initiale d’actifs 3D à partir d’invites de texte. Ce composant produit un maillage 3D avec des textures et des cartes de matériaux PBR en environ 30 secondes.

Meta 3D TextureGen

Meta 3D TextureGen (Bensadoun et al., 2024) affine les textures générées par AssetGen. Il peut également être utilisé pour générer de nouvelles textures pour des maillages 3D existants en fonction de descriptions textuelles supplémentaires. Cette étape prend environ 20 secondes.

Point-E (OpenAI)

Point-E, développé par OpenAI, est un autre modèle de génération de texte à 3D notable. Contrairement à DreamFusion, qui produit des représentations NeRF, Point-E génère des nuages de points 3D.

Caractéristiques clés de Point-E :

a) Pipeline en deux étapes : Point-E génère d’abord une vue synthétique 2D à l’aide d’un modèle de diffusion de texte à image, puis utilise cette image pour conditionner un deuxième modèle de diffusion qui produit le nuage de points 3D.

b) Efficacité : Point-E est conçu pour être efficace sur le plan computationnel, capable de générer des nuages de points 3D en quelques secondes sur une seule carte graphique.

c) Informations de couleur : Le modèle peut générer des nuages de points colorés, préservant à la fois les informations géométriques et d’apparence.

Limitations :

• Fidélité inférieure par rapport aux approches basées sur des maillages ou des NeRFs
• Les nuages de points nécessitent un traitement supplémentaire pour de nombreuses applications en aval

Shap-E (OpenAI) :

En s’appuyant sur Point-E, OpenAI a introduit Shap-E, qui génère des maillages 3D au lieu de nuages de points. Cela répond à certaines des limitations de Point-E tout en maintenant l’efficacité computationnelle.

Caractéristiques clés de Shap-E :

a) Représentation implicite : Shap-E apprend à générer des représentations implicites (fonctions de distance signée) d’objets 3D.

b) Extraction de maillage : Le modèle utilise une mise en œuvre différentiable de l’algorithme de marching cubes pour convertir la représentation implicite en un maillage polygonal.

c) Génération de texture : Shap-E peut également générer des textures pour les maillages 3D, aboutissant à des sorties visuellement plus attrayantes.

Avantages :

• Temps de génération rapides (secondes à minutes)
• Sortie de maillage directe adaptée au rendu et aux applications en aval
• Capacité à générer à la fois la géométrie et la texture

GET3D (NVIDIA) :

GET3D, développé par les chercheurs de NVIDIA (NVDA ), est un autre modèle puissant de génération de texte à 3D qui se concentre sur la production de maillages 3D texturés de haute qualité.

Caractéristiques clés de GET3D :

a) Représentation de surface explicite : Contrairement à DreamFusion ou Shap-E, GET3D génère directement des représentations de surface explicites (maillages) sans représentations implicites intermédiaires.

b) Génération de texture : Le modèle inclut une technique de rendering différentiable pour apprendre et générer des textures de haute qualité pour les maillages 3D.

c) Architecture basée sur GAN : GET3D utilise une approche de réseau antagoniste génératif (GAN), ce qui permet des temps de génération rapides une fois le modèle entraîné.

Avantages :

• Géométrie et textures de haute qualité
• Temps d’inférence rapides
• Intégration directe avec les moteurs de rendu 3D

Limitations :

• Nécessite des données d’entraînement 3D, qui peuvent être rares pour certaines catégories d’objets

Conclusion

La génération de 3D à partir de texte AI représente un changement fondamental dans la façon dont nous créons et interagissons avec le contenu 3D. En exploitant des techniques d’apprentissage automatique avancées, ces modèles peuvent produire des actifs 3D complexes et de haute qualité à partir de descriptions textuelles simples. À mesure que la technologie continue d’évoluer, nous pouvons nous attendre à voir des systèmes de texte à 3D de plus en plus sophistiqués et capables qui révolutionneront les industries allant des jeux et du cinéma à la conception de produits et à l’architecture.