Wie Text-to-3D-KI-Generierung funktioniert: Meta 3D Gen, OpenAI Shap-E und mehr

Die Fähigkeit, 3D-Digitalassets aus Textprompts zu generieren, stellt eine der aufregendsten jüngsten Entwicklungen im Bereich KI und Computergrafik dar. Da der Markt für 3D-Digitalassets von 28,3 Milliarden Dollar im Jahr 2024 auf 51,8 Milliarden Dollar im Jahr 2029 wachsen soll, sind Text-to-3D-KI-Modelle darauf vorbereitet, eine wichtige Rolle bei der Revolutionierung der Content-Erstellung in Branchen wie Gaming, Film, E-Commerce und mehr zu spielen. Aber wie funktionieren diese KI-Systeme genau? In diesem Artikel werden wir uns mit den technischen Details hinter der Text-to-3D-Generierung auseinandersetzen.

Die Herausforderung der 3D-Generierung

Die Generierung von 3D-Assets aus Text ist eine wesentlich komplexere Aufgabe als die Generierung von 2D-Bildern. Während 2D-Bilder im Wesentlichen Gitter von Pixeln sind, erfordern 3D-Assets die Darstellung von Geometrie, Texturen, Materialien und oft Animationen im dreidimensionalen Raum. Diese zusätzliche Dimensionalität und Komplexität machen die Generierungsaufgabe viel herausfordernder.

Einige Schlüsselherausforderungen bei der Text-to-3D-Generierung sind:

• Darstellung von 3D-Geometrie und Struktur
• Generierung konsistenter Texturen und Materialien über die 3D-Oberfläche
• Sicherstellung der physischen Plausibilität und Kohärenz aus mehreren Blickwinkeln
• Erfassung feiner Details und globaler Struktur gleichzeitig
• Generierung von Assets, die leicht gerendert oder 3D-gedruckt werden können

Um diese Herausforderungen zu meistern, nutzen Text-to-3D-Modelle mehrere Schlüsseltechnologien und -techniken.

Schlüsselkomponenten von Text-to-3D-Systemen

Die meisten State-of-the-Art-Text-to-3D-Generierungssysteme teilen einige Kernkomponenten:

1. Textcodierung: Umwandlung des Eingabetextprompts in eine numerische Darstellung
2. 3D-Darstellung: Eine Methode zur Darstellung von 3D-Geometrie und Erscheinungsbild
3. Generatives Modell: Das Kern-KI-Modell für die Generierung des 3D-Assets
4. Rendering: Umwandlung der 3D-Darstellung in 2D-Bilder für die Visualisierung

Lassen Sie uns jedes davon genauer betrachten.

Textcodierung

Der erste Schritt besteht darin, den Eingabetextprompt in eine numerische Darstellung umzuwandeln, mit der das KI-Modell arbeiten kann. Dies geschieht normalerweise mithilfe großer Sprachmodelle wie BERT oder GPT.

3D-Darstellung

Es gibt mehrere gängige Methoden, um 3D-Geometrie in KI-Modellen darzustellen:

1. Voxelgitter: 3D-Arrays von Werten, die Besetzung oder Merkmale darstellen
2. Punktwolken: Mengen von 3D-Punkten
3. Netze: Vertices und Flächen, die eine Oberfläche definieren
4. Implizite Funktionen: Kontinuierliche Funktionen, die eine Oberfläche definieren (z. B. signierte Distanzfunktionen)
5. Neuronale Strahlungsflächen (NeRFs): Neuronale Netze, die Dichte und Farbe im 3D-Raum darstellen

Jede hat Kompromisse in Bezug auf Auflösung, Speicherbedarf und Erzeugungsaufwand. Viele neuere Modelle verwenden implizite Funktionen oder NeRFs, da sie hochwertige Ergebnisse mit vernünftigen Rechenanforderungen ermöglichen.

Beispielsweise können wir eine einfache Kugel als signierte Distanzfunktion darstellen:

import numpy as np

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

# Auswertung von SDF bei einem 3D-Punkt
punkt = [0.5, 0.5, 0.5]
distanz = sphere_sdf(*punkt)
print(f"Distanz zur Kugeloberfläche: {distanz}")

Generatives Modell

Der Kern eines Text-to-3D-Systems ist das generative Modell, das die 3D-Darstellung aus dem Textembedding erzeugt. Die meisten State-of-the-Art-Modelle verwenden eine Variation eines Diffusionsmodells, ähnlich wie bei der 2D-Bildgenerierung.

Diffusionsmodelle funktionieren, indem sie allmählich Rauschen zu Daten hinzufügen und dann lernen, diesen Prozess umzukehren. Bei der 3D-Generierung findet dieser Prozess im Raum der gewählten 3D-Darstellung statt.

Ein vereinfachter Pseudocode für einen Diffusionsmodell-TrainingsSchritt könnte wie folgt aussehen:

def diffusion_training_step(model, x_0, text_embedding):
# Zufälliger Zeitpunkt auswählen
t = torch.randint(0, num_timesteps, (1,))

# Rauschen zum Eingabe hinzufügen
rauschen = torch.randn_like(x_0)
x_t = add_noise(x_0, rauschen, t)

# Vorhergesagtes Rauschen
vorhergesagtes_rauschen = model(x_t, t, text_embedding)

# Verlust berechnen
verlust = F.mse_loss(rauschen, vorhergesagtes_rauschen)

return verlust

# TrainingsSchleife
for batch in dataloader:
x_0, text = batch
text_embedding = encode_text(text)
verlust = diffusion_training_step(model, x_0, text_embedding)
verlust.backward()
optimizer.step()

Während der Generierung starten wir von reinem Rauschen und wiederholen den Entrauschungsprozess, bedingt auf dem Textembedding.

Rendering

Um Ergebnisse zu visualisieren und Verluste während des Trainings zu berechnen, müssen wir unsere 3D-Darstellung in 2D-Bilder rendern. Dies geschieht normalerweise mithilfe differenzierbarer Renderingtechniken, die es ermöglichen, Gradienten durch den Renderingprozess zu übertragen.

Für meshbasierte Darstellungen könnten wir einen Rasterisierungs-Renderer verwenden:

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

def render_mesh(vertices, faces, image_size=256):
# Renderer erstellen
renderer = pr.MeshRenderer(
rasterizer=pr.MeshRasterizer(),
shader=pr.SoftPhongShader()
)

# Kamera einrichten
cameras = pr.FoVPerspectiveCameras()

# Rendern
images = renderer(vertices, faces, cameras=cameras)

return images

# Beispielanwendung
vertices = torch.rand(1, 100, 3) # Zufällige Vertices
faces = torch.randint(0, 100, (1, 200, 3)) # Zufällige Flächen
rendered_images = render_mesh(vertices, faces)

Für implizite Darstellungen wie NeRFs verwenden wir normalerweise Ray-Marching-Techniken, um Ansichten zu rendern.

Alles zusammenfügen: Die Text-to-3D-Pipeline

Jetzt, da wir die Schlüsselkomponenten abgedeckt haben, lassen Sie uns durch die typische Text-to-3D-Generierungspipeline gehen:

1. Textcodierung: Der Eingabetextprompt wird in eine dichte Vektordarstellung mithilfe eines Sprachmodells umgewandelt.
2. Erste Generierung: Ein Diffusionsmodell, bedingt auf dem Textembedding, generiert eine anfängliche 3D-Darstellung (z. B. ein NeRF oder eine implizite Funktion).
3. Mehrblickkonsistenz: Das Modell rendern mehrere Ansichten des generierten 3D-Assets und stellt die Konsistenz über Blickwinkel sicher.
4. Verfeinerung: Zusätzliche Netze können Geometrie, Texturen hinzufügen oder Details verbessern.
5. Endgültige Ausgabe: Die 3D-Darstellung wird in ein gewünschtes Format (z. B. texturiertes Mesh) für die Verwendung in nachgelagerten Anwendungen umgewandelt.

Hier ist ein vereinfachtes Beispiel, wie dies in Code aussehen könnte:

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()

def forward(self, text_prompt):
# Text codieren
text_embedding = self.text_encoder(text_prompt).last_hidden_state.mean(dim=1)

# Anfängliche 3D-Darstellung generieren
initial_3d = self.diffusion_model(text_embedding)

# Mehrere Ansichten rendern
views = self.renderer(initial_3d, num_views=4)

# Basierend auf Mehrblickkonsistenz verfeinern
refined_3d = self.refiner(initial_3d, views)

return refined_3d

# Verwendung
model = TextTo3D()
text_prompt = "Ein roter Sportwagen"
generated_3d = model(text_prompt)

Top-Text-to-3D-Asset-Modelle

3DGen – Meta

3DGen ist darauf ausgelegt, das Problem der Generierung von 3D-Inhalten – wie Charakteren, Requisiten und Szenen – aus textuellen Beschreibungen zu lösen.

Große Sprache und Text-to-3D-Modelle – 3d-gen

3DGen unterstützt physikalisch basiertes Rendering (PBR), das für realistische 3D-Asset-Beleuchtung in realen Anwendungen unerlässlich ist. Es ermöglicht auch die generative Neutexturierung vorher generierter oder von Künstlern erstellter 3D-Formen mithilfe neuer textlicher Eingaben. Die Pipeline integriert zwei Kernkomponenten: Meta 3D AssetGen und Meta 3D TextureGen, die die Text-to-3D- und Text-to-Texture-Generierung verwalten.

Meta 3D AssetGen

Meta 3D AssetGen (Siddiqui et al., 2024) ist für die anfängliche Generierung von 3D-Assets aus Textprompts verantwortlich. Diese Komponente produziert ein 3D-Mesh mit Texturen und PBR-Materialkarten in etwa 30 Sekunden.

Meta 3D TextureGen

Meta 3D TextureGen (Bensadoun et al., 2024) verfeinert die von AssetGen generierten Texturen. Es kann auch für die Generierung neuer Texturen für bestehende 3D-Netze auf der Grundlage zusätzlicher textlicher Beschreibungen verwendet werden. Diese Phase dauert etwa 20 Sekunden.

Point-E (OpenAI)

Point-E, entwickelt von OpenAI, ist ein weiteres bemerkenswertes Text-to-3D-Generierungsmodell. Im Gegensatz zu DreamFusion, das NeRF-Darstellungen produziert, generiert Point-E 3D-Punktwolken.

Schlüsselmerkmale von Point-E:

a) Zweistufige Pipeline: Point-E generiert zunächst eine synthetische 2D-Ansicht mithilfe eines Text-to-Bild-Diffusionsmodells, dann verwendet es dieses Bild, um ein zweites Diffusionsmodell zu bedingen, das die 3D-Punktwolke produziert.

b) Effizienz: Point-E ist so konzipiert, dass es rechenintensiv effizient ist und in der Lage ist, 3D-Punktwolken in Sekunden auf einer einzelnen GPU zu generieren.

c) Farbinformation: Das Modell kann farbige Punktwolken generieren und dabei sowohl geometrische als auch Erscheinungsinformationen bewahren.

Einschränkungen:

• Geringere Qualität im Vergleich zu meshbasierten oder NeRF-basierten Ansätzen
• Punktwolken erfordern zusätzliche Verarbeitung für viele nachgelagerte Anwendungen

Shap-E (OpenAI):

Basierend auf Point-E stellte OpenAI Shap-E vor, das 3D-Netze anstelle von Punktwolken generiert. Dies löst einige der Einschränkungen von Point-E, während die Recheneffizienz erhalten bleibt.

Schlüsselmerkmale von Shap-E:

a) Implizite Darstellung: Shap-E lernt, implizite Darstellungen (signierte Distanzfunktionen) von 3D-Objekten zu generieren.

b) Netzextraktion: Das Modell verwendet eine differenzierbare Implementierung des Marching-Cubes-Algorithmus, um die implizite Darstellung in ein polygonales Netz umzuwandeln.

c) Texturgenerierung: Shap-E kann auch Texturen für die 3D-Netze generieren, was zu visuell ansprechenderen Ausgaben führt.

Vorteile:

• Schnelle Generierungszeiten (Sekunden bis Minuten)
• Direktes Netz-Ausgabeformat, geeignet für Rendering und nachgelagerte Anwendungen
• Fähigkeit, sowohl Geometrie als auch Texturen zu generieren

GET3D (NVIDIA):

GET3D, entwickelt von NVIDIA-Forschern, ist ein weiteres leistungsfähiges Text-to-3D-Generierungsmodell, das sich auf die Produktion von hochwertigen texturierten 3D-Netzen konzentriert.

Schlüsselmerkmale von GET3D:

a) Explizite Oberflächendarstellung: Im Gegensatz zu DreamFusion oder Shap-E generiert GET3D explizite Oberflächendarstellungen (Netze) ohne Zwischendarstellung.

b) Texturgenerierung: Das Modell umfasst eine differenzierbare Renderingtechnik, um hochwertige Texturen für die 3D-Netze zu lernen und zu generieren.

c) GAN-basierte Architektur: GET3D verwendet einen generativen adversativen Ansatz (GAN), der eine schnelle Generierung ermöglicht, sobald das Modell trainiert ist.

Vorteile:

• Hochwertige Geometrie und Texturen
• Schnelle Inferenzzeiten
• Direkte Integration in 3D-Rendering-Engines

Einschränkungen:

• Erfordert 3D-Trainingsdaten, die für einige Objektkategorien knapp sein können

Zusammenfassung

Text-to-3D-KI-Generierung stellt einen grundlegenden Wandel in der Art und Weise dar, wie wir 3D-Inhalte erstellen und damit interagieren. Durch den Einsatz fortschrittlicher Deep-Learning-Techniken können diese Modelle komplexe, hochwertige 3D-Assets aus einfachen Textbeschreibungen erzeugen. Da die Technologie weiterentwickelt wird, können wir erwarten, immer komplexere und leistungsfähigere Text-to-3D-Systeme zu sehen, die Branchen von Gaming und Film bis hin zu Produktgestaltung und Architektur revolutionieren werden.