Sådan fungerer Text-til-3D AI-generering: Meta 3D Gen, OpenAI Shap-E og mere

Evnen til at generere 3D-digitale aktiver fra tekstprompts repræsenterer en af de mest spændende nyere udviklinger i AI og computergrafik. Da markedet for 3D-digitale aktiver forventes at vokse fra 28,3 milliarder dollars i 2024 til 51,8 milliarder dollars i 2029, er tekst-til-3D AI-modeller godt positioneret til at spille en stor rolle i at revolutionere indholdsskabelse på tværs af brancher som gaming, film, e-handel og mere. Men hvordan fungerer disse AI-systemer nøjagtig? I denne artikel dykker vi dybt ned i de tekniske detaljer bag tekst-til-3D-generering.

Udfordringen ved 3D-generering

At generere 3D-aktiver fra tekst er en langt mere kompleks opgave end 2D-billedegenerering. Mens 2D-billeder i virkeligheden er gitter af pixel, kræver 3D-aktiver repræsentation af geometri, teksturer, materialer og ofte animationer i tre dimensioner. Denne tilføjede dimension og kompleksitet gør genereringsopgaven meget mere udfordrende.

Nogle nøgleudfordringer i tekst-til-3D-generering omfatter:

• Repræsentation af 3D-geometri og struktur
• Generering af konsistente teksturer og materialer på tværs af 3D-overfladen
• Sikring af fysisk plausibilitet og kohærens fra multiple synsvinkler
• Fanget af fine detaljer og global struktur samtidig
• Generering af aktiver, der kan let renderes eller 3D-printes

For at tackle disse udfordringer udnytter tekst-til-3D-modeller flere nøgleteknologier og -teknikker.

Nøglekomponenter i tekst-til-3D-systemer

De fleste state-of-the-art tekst-til-3D-genereringssystemer deler nogle fælles komponenter:

1. Tekstkode: Konvertering af inputtekstprompt til en numerisk repræsentation
2. 3D-repræsentation: En metode til at repræsentere 3D-geometri og udseende
3. Generativ model: Den centrale AI-model til at generere 3D-aktiver
4. Rendering: Konvertering af 3D-repræsentation til 2D-billeder til visualisering

Lad os udforske hver af disse i mere detalje.

Tekstkode

Det første trin er at konvertere inputtekstpromptet til en numerisk repræsentation, som AI-modellen kan arbejde med. Dette gøres typisk ved hjælp af store sprogmodeller som BERT eller GPT.

3D-repræsentation

Der er flere almindelige måder at repræsentere 3D-geometri i AI-modeller:

1. Voxelgitter: 3D-arrays af værdier, der repræsenterer besættelse eller funktioner
2. Punktskyer: Sæt af 3D-punkter
3. Net: Vertices og flader, der definerer en overflade
4. Implicitte funktioner: Kontinuerte funktioner, der definerer en overflade (f.eks. signerede afstandsfunktioner)
5. Neurale lysfelter (NeRF): Neurale netværk, der repræsenterer tæthed og farve i 3D-rum

Hver har kompromiser i forhold til opløsning, hukommelsesbrug og letgenhed ved generering. Mange nyere modeller bruger implicitte funktioner eller NeRF, da de giver højkvalitetsresultater med rimelige beregningskrav.

For eksempel kan vi repræsentere en simpel kugle som en signerede afstandsfunktion:

import numpy as np

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

# Evaluér SDF ved et 3D-punkt
punkt = [0.5, 0.5, 0.5]
afstand = sphere_sdf(*punkt)
print(f"Afstand til kugleoverfladen: {afstand}")

Generativ model

Kernen i et tekst-til-3D-system er den generative model, der producerer 3D-aktiver fra tekstembedding. De fleste state-of-the-art-modeller bruger en variation af en diffusionsmodel, lignende dem, der bruges i 2D-billedegenerering.

Diffusionsmodeller fungerer ved at tilføje støj til data og derefter lære at omvende denne proces. For 3D-generering sker denne proces i rummet af den valgte 3D-repræsentation.

En forenklet pseudokode for en diffusionsmodeltræningsstep kunne se således ud:

def diffusion_training_step(model, x_0, text_embedding):
# Eksemplificér et tilfældigt tidssteg
t = torch.randint(0, num_timesteps, (1,))

# Tilføj støj til input
støj = torch.randn_like(x_0)
x_t = add_noise(x_0, støj, t)

# Forudsæg støjen
forudsagt_støj = model(x_t, t, text_embedding)

# Beregn tab
tab = F.mse_loss(støj, forudsagt_støj)

return tab

# Træningsløkke
for batch in dataloader:
x_0, text = batch
text_embedding = encode_text(text)
tab = diffusion_training_step(model, x_0, text_embedding)
tab.backward()
optimizer.step()

Under generering starter vi fra ren støj og itererer derefter støjen, betinget af tekstembedding.

Rendering

For at visualisere resultater og beregne tab under træning har vi brug for at renderere vores 3D-repræsentation til 2D-billeder. Dette gøres typisk ved hjælp af differentiable rendering-teknikker, der tillader, at gradienter kan flyde tilbage gennem renderingprocessen.

For mesh-baserede repræsentationer kunne vi bruge en rasterizationsbaseret renderer:

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

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

# Konfigurer kamera
cameras = pr.FoVPerspectiveCameras()

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

return images

# Eksempelbrug
vertices = torch.rand(1, 100, 3) # Tilfældige vertices
faces = torch.randint(0, 100, (1, 200, 3)) # Tilfældige flader
renderede_billeder = render_mesh(vertices, faces)

For implicitte repræsentationer som NeRF kan vi typisk bruge ray marching-teknikker til at renderere visninger.

Sammenføjning af det hele: Tekst-til-3D-pipeline

Nu hvor vi har dækket de nøglekomponenter, lad os gå igennem, hvordan de kommer sammen i en typisk tekst-til-3D-genereringspipeline:

1. Tekstkode: Inputpromptet kodificeres til en tæt vektorrepræsentation ved hjælp af en sprogmodel.
2. Initial generering: En diffusionsmodel, betinget af tekstembedding, genererer en initial 3D-repræsentation (f.eks. en NeRF eller implicit funktion).
3. Flersynsvinkelkonsistens: Modellen renderer multiple visninger af den genererede 3D-aktiver og sikrer konsistens på tværs af synsvinkler.
4. Forbedring: Yderligere netværk kan forbedre geometri, tilføje teksturer eller forbedre detaljer.
5. Endeligt output: 3D-repræsentationen konverteres til en ønsket format (f.eks. tekstureret mesh) til brug i efterfølgende applikationer.

Her er et forenklet eksempel på, hvordan dette kunne se ud i kode:

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):
# Kodificér tekst
text_embedding = self.text_encoder(text_prompt).last_hidden_state.mean(dim=1)

# Generér initial 3D-repræsentation
initial_3d = self.diffusion_model(text_embedding)

# Render multiple visninger
visninger = self.renderer(initial_3d, num_views=4)

# Forbedr baseret på flersynsvinkelkonsistens
refined_3d = self.refiner(initial_3d, visninger)

return refined_3d

# Brug
model = TextTo3D()
text_prompt = "En rød sportsvogn"
genereret_3d = model(text_prompt)

Top tekst til 3D-aktivermodeller til rådighed

3DGen – Meta

3DGen er designet til at tackle problemet med at generere 3D-indhold – såsom karakterer, rekvisitter og scener – fra tekstbeskrivelser.

Stort sprog og tekst til 3D-modeller – 3d-gen

3DGen understøtter fysisk-baseret rendering (PBR), der er essentiel for realistisk 3D-aktiver-genoplysning i virkelige applikationer. Det aktiverer også generativ omteksturering af tidligere genererede eller kunstnerisk skabte 3D-former ved hjælp af nye tekstinput. Pipeline-integrationen består af to kernekomponenter: Meta 3D AssetGen og Meta 3D TextureGen, der håndterer tekst-til-3D og tekst-til-tekstur-generering, henholdsvis.

Meta 3D AssetGen

Meta 3D AssetGen (Siddiqui et al., 2024) er ansvarlig for den initielle generering af 3D-aktiver fra tekstprompts. Denne komponent producerer en 3D-mesh med teksturer og PBR-materialekort i cirka 30 sekunder.

Meta 3D TextureGen

Meta 3D TextureGen (Bensadoun et al., 2024) forbedrer teksturerne genereret af AssetGen. Den kan også bruges til at generere nye teksturer til eksisterende 3D-mesh’er baseret på yderligere tekstbeskrivelser. Dette trin tager cirka 20 sekunder.

Point-E (OpenAI)

Point-E, udviklet af OpenAI, er endnu en bemærkelsesværdig tekst-til-3D-genereringsmodel. I modsætning til DreamFusion, der producerer NeRF-repræsentationer, genererer Point-E 3D-punktskyer.

Nøglefunktioner i Point-E:

a) To-trins-pipeline: Point-E genererer først en syntetisk 2D-visning ved hjælp af en tekst-til-billede-diffusionsmodel, derefter bruger denne billed til at betinge en anden diffusionsmodel, der producerer 3D-punktskyen.

b) Effektivitet: Point-E er designet til at være beregningsmæssigt effektiv, i stand til at generere 3D-punktskyer på få sekunder på en enkelt GPU.

c) Farveinformation: Modellen kan generere farvede punktskyer, der bevare både geometrisk og udseendemæssig information.

Begrænsninger:

• Lavere fidelitet i forhold til mesh-baserede eller NeRF-baserede tilgange
• Punktskyer kræver yderligere behandling til mange efterfølgende applikationer

Shap-E (OpenAI):

Bygget på Point-E introducerede OpenAI Shap-E, der genererer 3D-mesh’er i stedet for punktskyer. Dette adresserer nogle af begrænsningerne i Point-E, mens det fastholder beregningsmæssig effektivitet.

Nøglefunktioner i Shap-E:

a) Implicit repræsentation: Shap-E lærer at generere implicitte repræsentationer (signerede afstandsfunktioner) af 3D-objekter.

b) Mesh-ekstraktion: Modellen bruger en differentiable implementering af marching cubes-algoritmen til at konvertere den implicitte repræsentation til en polygonal mesh.

c) Teksturgenerering: Shap-E kan også generere teksturer til 3D-mesh’er, resulterende i mere visuelt tillokkende output.

Fordele:

• Hurtige genereringstider (sekunder til minutter)
• Direkte mesh-output egnet til rendering og efterfølgende applikationer
• Evne til at generere både geometri og tekstur

GET3D (NVIDIA):

GET3D, udviklet af NVIDIA-forskere, er endnu en kraftfuld tekst-til-3D-genereringsmodel, der fokuserer på at producere højkvalitets-teksturerede 3D-mesh’er.

Nøglefunktioner i GET3D:

a) Eksplicit overfladerepræsentation: I modsætning til DreamFusion eller Shap-E genererer GET3D direkte eksplicitte overfladerepræsentationer (mesh’er) uden intermediate implicitte repræsentationer.

b) Teksturgenerering: Modellen inkluderer en differentiable rendering-teknik til at lære og generere højkvalitets-teksturer til 3D-mesh’er.

c) GAN-baseret arkitektur: GET3D bruger en generative adversarial network (GAN)-tilgang, der tillader hurtig generering, når modellen er trænet.

Fordele:

• Højkvalitetsgeometri og teksturer
• Hurtige inferenstider
• Direkte integration med 3D-renderingsmotorer

Begrænsninger:

• Kræver 3D-træningsdata, der kan være knappe for nogle objekt kategorier

Konklusion

Tekst-til-3D AI-generering repræsenterer en grundlæggende ændring i, hvordan vi skaber og interagerer med 3D-indhold. Ved at udnytte avancerede dybe læringsteknikker kan disse modeller producere komplekse, højkvalitets 3D-aktiver fra simple tekstbeskrivelser. Da teknologien fortsætter med at udvikle sig, kan vi forvente at se stadig mere avancerede og kapable tekst-til-3D-systemer, der vil revolutionere brancher fra gaming og film til produkt design og arkitektur.