Hur Text-till-3D AI-generering Fungerar: Meta 3D Gen, OpenAI Shap-E och mer

Förmågan att generera 3D-digitala tillgångar från textprompt är en av de mest spännande nyliga utvecklingarna inom AI och datagrafik. Eftersom marknaden för 3D-digitala tillgångar förväntas växa från 28,3 miljarder dollar 2024 till 51,8 miljarder dollar 2029, är text-till-3D AI-modeller redo att spela en stor roll i att revolutionera innehållsskapande över branscher som spel, film, e-handel och mer. Men hur fungerar dessa AI-system egentligen? I den här artikeln kommer vi att dyka djupt in i de tekniska detaljerna bakom text-till-3D-generering.

Utmaningen med 3D-generering

Att generera 3D-tillgångar från text är en betydligt mer komplex uppgift än 2D-bildgenerering. Medan 2D-bilder i princip är raster av pixlar, kräver 3D-tillgångar representation av geometri, texturer, material och ofta animationer i tredimensionellt rum. Denna tillagda dimension och komplexitet gör genereringsuppgiften mycket mer utmanande.

Några nyckelutmaningar i text-till-3D-generering inkluderar:

• Att representera 3D-geometri och struktur
• Att generera konsekventa texturer och material över 3D-ytan
• Att säkerställa fysisk trovärdighet och sammanhängande från flera vinklar
• Att fånga fina detaljer och global struktur samtidigt
• Att generera tillgångar som kan återges eller 3D-skrivas lätt

För att tackla dessa utmaningar utnyttjar text-till-3D-modeller flera nyckelteknologier och tekniker.

Nyckelkomponenter i text-till-3D-system

De flesta state-of-the-art text-till-3D-genereringssystem delar flera kärnkomponenter:

1. Textkodning: Omvandling av inmatningstexten till en numerisk representation
2. 3D-representation: En metod för att representera 3D-geometri och utseende
3. Generativ modell: Den centrala AI-modellen för att generera 3D-tillgången
4. Återgivning: Omvandling av 3D-representationen till 2D-bilder för visualisering

Låt oss undersöka var och en av dessa i mer detalj.

Textkodning

Det första steget är att omvandla inmatningstexten till en numerisk representation som AI-modellen kan arbeta med. Detta görs vanligtvis med hjälp av stora språkmodeller som BERT eller GPT.

3D-representation

Det finns flera vanliga sätt att representera 3D-geometri i AI-modeller:

1. Voxelraster: 3D-arrayer av värden som representerar besättning eller funktioner
2. Punktmoln: Mängder av 3D-punkter
3. Nät: Hörn och ytor som definierar en yta
4. Implicita funktioner: Kontinuerliga funktioner som definierar en yta (t.ex. signerade avståndsfunktioner)
5. Neurala strålningsfält (NeRFs): Neuronnät som representerar densitet och färg i 3D-rum

Var och en har avvägningar när det gäller upplösning, minnesanvändning och genereringslättighet. Många moderna modeller använder implicita funktioner eller NeRFs eftersom de tillåter högkvalitativa resultat med rimliga beräkningskrav.

Till exempel kan vi representera en enkel sfär som en signerad avståndsfunktion:

import numpy as np

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

# Utvärdera SDF i en 3D-punkt
punkt = [0.5, 0.5, 0.5]
avstånd = sphere_sdf(*punkt)
print(f"Avstånd till sfärytan: {avstånd}")

Generativ modell

Kärnan i ett text-till-3D-system är den generativa modellen som producerar 3D-tillgången från textinbäddningen. De flesta moderna modellerna använder någon variation av en diffusionsmodell, liknande de som används i 2D-bildgenerering.

Diffusionsmodeller fungerar genom att gradvis lägga till brus till data, sedan lära sig att omvända denna process. För 3D-generering sker denna process i rummet för den valda 3D-representationen.

En förenklad pseudokod för en diffusionsmodellsträningssteg kan se ut så här:

def diffusion_training_step(model, x_0, text_embedding):
# Exempel på slumpmässig tidssteg
t = torch.randint(0, num_timesteps, (1,))

# Lägg till brus till inmatningen
brus = torch.randn_like(x_0)
x_t = add_noise(x_0, brus, t)

# Förutsäg bruset
förutsagt_brus = model(x_t, t, text_embedding)

# Beräkna förlust
förlust = F.mse_loss(brus, förutsagt_brus)

return förlust

# Träningsloop
for batch in dataloader:
x_0, text = batch
text_embedding = encode_text(text)
förlust = diffusion_training_step(model, x_0, text_embedding)
förlust.backward()
optimizer.step()

Under generering startar vi från rent brus och iterativt rensar, villkorat av textinbäddningen.

Återgivning

För att visualisera resultat och beräkna förluster under träningsprocessen behöver vi återge vår 3D-representation till 2D-bilder. Detta görs vanligtvis med hjälp av differentierbara återgivningstekniker som tillåter gradienter att flöda tillbaka genom återgivningsprocessen.

För nätbaserade representationer kan vi använda en rasteriseringsbaserad återgivare:

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

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

# Ställ in kamera
cameras = pr.FoVPerspectiveCameras()

# Återge
images = renderer(vertices, faces, cameras=cameras)

return images

# Exempel på användning
vertices = torch.rand(1, 100, 3) # Slumpmässiga hörn
faces = torch.randint(0, 100, (1, 200, 3)) # Slumpmässiga ansikten
rendered_images = render_mesh(vertices, faces)

För implicita representationer som NeRFs använder vi vanligtvis strålmarsch-tekniker för att återge vyer.

Att sätta allt samman: Text-till-3D-pipelinen

Nu när vi har täckt de viktigaste komponenterna, låt oss gå igenom hur de kommer samman i en typisk text-till-3D-genereringspipeline:

1. Textkodning: Inmatningstexten kodas till en tät vektorrepresentation med hjälp av en språkmodell.
2. Initial generering: En diffusionsmodell, villkorad av textinbäddningen, genererar en initial 3D-representation (t.ex. en NeRF eller implicit funktion).
3. Multi-vy-konsistens: Modellen återger flera vyer av den genererade 3D-tillgången och säkerställer konsistens över vyerna.
4. Finjustering: Ytterligare nätverk kan finjustera geometri, lägga till texturer eller förbättra detaljer.
5. Slutlig utdata: 3D-representationen omvandlas till en önskad format (t.ex. texturerat nät) för användning i nedströmsapplikationer.

Här är ett förenklat exempel på hur detta kan se ut i kod:

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):
# Kod text
text_embedding = self.text_encoder(text_prompt).last_hidden_state.mean(dim=1)

# Generera initial 3D-representation
initial_3d = self.diffusion_model(text_embedding)

# Återge flera vyer
views = self.renderer(initial_3d, num_views=4)

# Finjustera baserat på multi-vy-konsistens
refined_3d = self.refiner(initial_3d, views)

return refined_3d

# Användning
model = TextTo3D()
text_prompt = "En röd sportbil"
generated_3d = model(text_prompt)

Topp Text till 3D-tillgångsmodeller Tillgängliga

3DGen – Meta

3DGen är utformad för att tackla problemet med att generera 3D-innehåll – såsom karaktärer, föremål och scener – från textbeskrivningar.

Stora språk- och text-till-3D-modeller – 3d-gen

3DGen stöder fysiskt baserad rendering (PBR), vilket är nödvändigt för realistisk 3D-tillgångs omlysning i verkliga applikationer. Den möjliggör också generativ omtexturering av tidigare genererade eller konstnärligt skapade 3D-former med hjälp av nya textinmatningar. Pipelinen integrerar två kärnkomponenter: Meta 3D AssetGen och Meta 3D TextureGen, som hanterar text-till-3D respektive text-till-texturgenerering.

Meta 3D AssetGen

Meta 3D AssetGen (Siddiqui et al., 2024) ansvarar för den initiala generationen av 3D-tillgångar från textprompt. Denna komponent producerar ett 3D-nät med texturer och PBR-materialkartor på cirka 30 sekunder.

Meta 3D TextureGen

Meta 3D TextureGen (Bensadoun et al., 2024) finjusterar texturerna som genereras av AssetGen. Den kan också användas för att generera nya texturer för befintliga 3D-nät baserat på ytterligare textbeskrivningar. Denna fas tar cirka 20 sekunder.

Point-E (OpenAI)

Point-E, utvecklad av OpenAI, är en annan noterbar text-till-3D-genereringsmodell. Till skillnad från DreamFusion, som producerar NeRF-representationer, genererar Point-E 3D-punktmoln.

Nyckelfunktioner i Point-E:

a) Tvåstegspipeline: Point-E genererar först en syntetisk 2D-vy med hjälp av en text-till-bild-diffusionsmodell, sedan använder den bilden för att villkora en andra diffusionsmodell som producerar 3D-punktmolnet.

b) Effektivitet: Point-E är utformad för att vara beräkningsmässigt effektiv, kapabel att generera 3D-punktmoln på sekunder på en enda GPU.

c) Färginformation: Modellen kan generera färgade punktmoln, bevarande både geometrisk och utseendemässig information.

Begränsningar:

• Lägre trohet jämfört med nätbaserade eller NeRF-baserade tillvägagångssätt
• Punktmoln kräver ytterligare bearbetning för många nedströmsapplikationer

Shap-E (OpenAI):

Byggande på Point-E introducerade OpenAI Shap-E, som genererar 3D-nät istället för punktmoln. Detta adresserar några av begränsningarna i Point-E samtidigt som det behåller beräkningsmässig effektivitet.

Nyckelfunktioner i Shap-E:

a) Implicit representation: Shap-E lär sig att generera implicita representationer (signerade avståndsfunktioner) av 3D-objekt.

b) Nätutvinning: Modellen använder en differentierbar implementering av marching cubes-algoritmen för att omvandla den implicita representationen till ett polygonalt nät.

c) Texturgenerering: Shap-E kan också generera texturer för 3D-nätet, resulterande i mer visuellt tilltalande utdata.

Fördelar:

• Snabba genereringstider (sekunder till minuter)
• Direkt nätutdata lämplig för rendering och nedströmsapplikationer
• Förmåga att generera både geometri och textur

GET3D (NVIDIA):

GET3D, utvecklad av NVIDIA-forskare, är en annan kraftfull text-till-3D-genereringsmodell som fokuserar på att producera högkvalitativa texturerade 3D-nät.

Nyckelfunktioner i GET3D:

a) Explicit ytrepresentation: Till skillnad från DreamFusion eller Shap-E, som producerar implicita representationer, genererar GET3D explicita ytrepresentationer (nät) utan mellanliggande implicita representationer.

b) Texturgenerering: Modellen inkluderar en differentierbar återgivningsteknik för att lära och generera högkvalitativa texturer för 3D-nätet.

c) GAN-baserad arkitektur: GET3D använder en generativt adversarial nätverksansats, som tillåter snabb generering när modellen är tränad.

Fördelar:

• Högkvalitativ geometri och textur
• Snabba inferenstider
• Direkt integrering med 3D-renderingsmotorer

Begränsningar:

• Kräver 3D-träningsdata, som kan vara knapp för vissa objektkategorier

Slutsats

Text-till-3D AI-generering representerar en grundläggande förändring i hur vi skapar och interagerar med 3D-innehåll. Genom att utnyttja avancerade djupinlärningstekniker kan dessa modeller producera komplexa, högkvalitativa 3D-tillgångar från enkla textbeskrivningar. När tekniken fortsätter att utvecklas kan vi förvänta oss att se alltmer sofistikerade och kapabla text-till-3D-system som kommer att revolutionera branscher från spel och film till produktutformning och arkitektur.