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 utvecklingarna inom AI och datorgrafik. 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 renderas eller 3D-skrivas ut lätt

För att tackla dessa utmaningar använder 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 några 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. Rendering: 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 ansikten 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 kompromisser 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

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

<p># Utvärdera SDF vid 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-representationen från textinbäddningen. De flesta moderna modeller 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 och sedan lära sig att reversera denna process. För 3D-generering sker denna process i utrymmet 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):</p>
# Exempel på slumpmässig tidssteg
t = torch.randint(0, num_timesteps, (1,))

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

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

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

return förlust

<p># Träningsloop
för batch i datalaster:</p>
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.

Rendering

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

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

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

<p>def render_mesh(vertices, faces, image_size=256):</p>
# Skapa en renderare
renderare = pr.MeshRenderer(
rasterizer=pr.MeshRasterizer(),
shader=pr.SoftPhongShader()
)

<p># Ställ in kamera
kameror = pr.FoVPerspectiveCameras()</p>

<p># Rendera
bilder = renderare(vertices, faces, kameror=kameror)</p>

return bilder

<p># 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
renderade_bilder = render_mesh(vertices, faces)

För implicita representationer som NeRFs använder vi vanligtvis ray marching-tekniker för att rendera 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. Multiview-konsistens: Modellen renderar flera vyer av den genererade 3D-tillgången och säkerställer konsistens över vyer.
4. Finjustering: Ytterligare nätverk kan finjustera geometri, lägga till texturer eller förbättra detaljer.
5. Slutlig utdata: 3D-representationen konverteras 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.renderare = DifferentiableRenderer()

<p>def forward(self, text_prompt):</p>
# Kodning av text
text_embedding = self.text_encoder(text_prompt).last_hidden_state.mean(dim=1)

<p># Generera initial 3D-representation
initial_3d = self.diffusion_model(text_embedding)</p>

<p># Rendera flera vyer
views = self.renderare(initial_3d, num_views=4)</p>

<p># Finjustera baserat på multiview-konsistens
refined_3d = self.refiner(initial_3d, views)</p>

return refined_3d

<p># 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, rekvisita 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 artistiskt skapade 3D-former med hjälp av nya textbeskrivningar. 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 denna bild 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 åtgärdar 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 konvertera den implicita representationen till ett polygonalt nät.

c) Texturgenerering: Shap-E kan också generera texturer för de 3D-nät som produceras, vilket resulterar i mer visuellt tilltalande utdata.

Fördelar:

• Snabb genereringstid (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 (NVDA ), ä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 genererar GET3D explicita ytrepresentationer (nät) utan mellanliggande implicita representationer.

b) Texturgenerering: Modellen inkluderar en differentierbar renderingsteknik för att lära sig och generera högkvalitativa texturer för de 3D-nät som produceras.

c) GAN-baserad arkitektur: GET3D använder en generativt adverserande nätverksansats (GAN), vilket möjliggör snabb generering när modellen är tränad.

Fördelar:

• Högkvalitativ geometri och textur
• Snabb inferenstid
• Direkt integrering med 3D-renderingsmotorer

Begränsningar:

• Kräver 3D-träningsdata, som kan vara sällsynt 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.