Bagaimana Text-to-3D AI Generation Bekerja: Meta 3D Gen, OpenAI Shap-E dan lainnya

Kemampuan untuk menghasilkan aset digital 3D dari prompt teks merupakan salah satu perkembangan paling menarik dalam AI dan grafis komputer. Dengan pasar aset digital 3D yang diperkirakan tumbuh dari $28,3 miliar pada 2024 menjadi $51,8 miliar pada 2029, model AI text-to-3D diposisikan untuk memainkan peran besar dalam merevolusi pembuatan konten di berbagai industri seperti permainan, film, e-commerce, dan lainnya. Tapi bagaimana tepatnya sistem AI ini bekerja? Dalam artikel ini, kita akan melakukan penyelaman mendalam ke dalam detail teknis di balik generasi text-to-3D.

Tantangan Generasi 3D

Menghasilkan aset 3D dari teks adalah tugas yang jauh lebih kompleks daripada generasi gambar 2D. Sementara gambar 2D pada dasarnya adalah grid piksel, aset 3D memerlukan representasi geometri, tekstur, bahan, dan sering animasi dalam ruang tiga dimensi. Dimensi tambahan dan kompleksitas ini membuat tugas generasi menjadi jauh lebih menantang.

Beberapa tantangan kunci dalam generasi text-to-3D termasuk:

• Menghasilkan geometri dan struktur 3D
• Menghasilkan tekstur dan bahan yang konsisten di seluruh permukaan 3D
• Memastikan kemungkinan fisik dan konsistensi dari berbagai sudut pandang
• Menghasilkan detail halus dan struktur global secara bersamaan
• Menghasilkan aset yang dapat dengan mudah dirender atau dicetak 3D

Untuk mengatasi tantangan ini, model text-to-3D menggunakan beberapa teknologi dan teknik kunci.

Komponen Kunci Sistem Text-to-3D

Sebagian besar sistem generasi text-to-3D yang mutakhir berbagi beberapa komponen inti:

1. Pengkodean teks: Mengubah prompt teks input menjadi representasi numerik
2. Representasi 3D: Metode untuk merepresentasikan geometri dan penampilan 3D
3. Model generatif: Model AI inti untuk menghasilkan aset 3D
4. Rendering: Mengubah representasi 3D menjadi gambar 2D untuk visualisasi

Mari kita jelajahi masing-masing ini lebih detail.

Pengkodean Teks

Langkah pertama adalah mengubah prompt teks input menjadi representasi numerik yang dapat digunakan oleh model AI. Ini biasanya dilakukan menggunakan model bahasa besar seperti BERT atau GPT.

Representasi 3D

Ada beberapa cara umum untuk merepresentasikan geometri 3D dalam model AI:

1. Grid voxel: Array 3D nilai yang merepresentasikan okupansi atau fitur
2. Awan titik: Kumpulan titik 3D
3. Mesh: Verteks dan wajah yang mendefinisikan permukaan
4. Fungsi implisit: Fungsi kontinu yang mendefinisikan permukaan (misalnya fungsi jarak bertanda)
5. Lapangan radiasi neural (NeRFs): Jaringan neural yang merepresentasikan kepadatan dan warna dalam ruang 3D

Masing-masing memiliki trade-off dalam hal resolusi, penggunaan memori, dan kemudahan generasi. Banyak model mutakhir menggunakan fungsi implisit atau NeRFs karena memungkinkan hasil berkualitas tinggi dengan persyaratan komputasi yang wajar.

Misalnya, kita dapat merepresentasikan bola sederhana sebagai fungsi jarak bertanda:

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># Evaluasi SDF pada titik 3D
point = [0.5, 0.5, 0.5]
distance = sphere_sdf(*point)
print(f"Jarak ke permukaan bola: {distance}")

Model Generatif

Inti dari sistem text-to-3D adalah model generatif yang menghasilkan representasi 3D dari pengkodean teks. Sebagian besar model mutakhir menggunakan variasi model difusi, serupa dengan yang digunakan dalam generasi gambar 2D.

Model difusi bekerja dengan secara bertahap menambahkan noise ke data, lalu belajar untuk membalik proses ini. Untuk generasi 3D, proses ini terjadi dalam ruang representasi 3D yang dipilih.

Pseudocode sederhana untuk langkah pelatihan model difusi mungkin terlihat seperti:

def diffusion_training_step(model, x_0, text_embedding):
# Sampel waktu acak
t = torch.randint(0, num_timesteps, (1,))

<p># Tambahkan noise ke input
noise = torch.randn_like(x_0)
x_t = add_noise(x_0, noise, t)</p>

<p># Prediksi noise
predicted_noise = model(x_t, t, text_embedding)</p>

<p># Hitung kerugian
loss = F.mse_loss(noise, predicted_noise)</p>

return loss

<p># Loop pelatihan
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()

Selama generasi, kita memulai dari noise murni dan secara bertahap mengurangi noise, dikondisikan pada pengkodean teks.

Rendering

Untuk memvisualisasikan hasil dan menghitung kerugian selama pelatihan, kita perlu merender representasi 3D kita menjadi gambar 2D. Ini biasanya dilakukan menggunakan teknik rendering yang dapat dibedakan yang memungkinkan gradien mengalir kembali melalui proses rendering.

Untuk representasi berbasis mesh, kita mungkin menggunakan renderer berbasis rasterisasi:

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

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

<p># Atur kamera
cameras = pr.FoVPerspectiveCameras()</p>

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

return images

<p># Contoh penggunaan
vertices = torch.rand(1, 100, 3) # Verteks acak
faces = torch.randint(0, 100, (1, 200, 3)) # Wajah acak
rendered_images = render_mesh(vertices, faces)

Untuk representasi implisit seperti NeRFs, kita biasanya menggunakan teknik ray marching untuk merender tampilan.

Menggabungkan Semua: Pipa Text-to-3D

Sekarang bahwa kita telah mencakup komponen kunci, mari kita jalankan bagaimana mereka datang bersama dalam pipa generasi text-to-3D yang khas:

1. Pengkodean teks: Prompt input dikodekan menjadi representasi vektor yang padat menggunakan model bahasa.
2. Generasi awal: Model difusi, dikondisikan pada pengkodean teks, menghasilkan representasi 3D awal (misalnya NeRF atau fungsi implisit).
3. Konsistensi multi-tampilan: Model merender beberapa tampilan aset 3D yang dihasilkan dan memastikan konsistensi di seluruh sudut pandang.
4. Penghalusan: Jaringan tambahan mungkin menghaluskan geometri, menambahkan tekstur, atau meningkatkan detail.
5. Output akhir: Representasi 3D diubah menjadi format yang diinginkan (misalnya mesh bertekstur) untuk digunakan dalam aplikasi hilir.

Berikut adalah contoh sederhana tentang bagaimana ini mungkin terlihat dalam 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()

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

<p># Hasilkan representasi 3D awal
initial_3d = self.diffusion_model(text_embedding)</p>

<p># Render beberapa tampilan
views = self.renderer(initial_3d, num_views=4)</p>

<p># Haluskan berdasarkan konsistensi multi-tampilan
refined_3d = self.refiner(initial_3d, views)</p>

return refined_3d

<p># Penggunaan
model = TextTo3D()
text_prompt = "Mobil sport merah"
generated_3d = model(text_prompt)

Model Aset 3D Text-to-Top yang Tersedia

3DGen – Meta

3DGen dirancang untuk menangani masalah generasi konten 3D – seperti karakter, prop, dan adegan – dari deskripsi teks.

Model Bahasa Besar dan Text-to-3D – 3d-gen

3DGen mendukung rendering berbasis fisik (PBR), yang penting untuk relighting aset 3D yang realistis dalam aplikasi dunia nyata. Ini juga memungkinkan generasi ulang tekstur dari bentuk 3D yang dihasilkan sebelumnya atau dibuat oleh seniman menggunakan input teks baru. Pipa ini mengintegrasikan dua komponen inti: Meta 3D AssetGen dan Meta 3D TextureGen, yang menangani generasi text-to-3D dan text-to-texture, masing-masing.

Meta 3D AssetGen

Meta 3D AssetGen (Siddiqui et al., 2024) bertanggung jawab untuk generasi awal aset 3D dari prompt teks. Komponen ini menghasilkan mesh 3D dengan tekstur dan peta bahan PBR dalam waktu sekitar 30 detik.

Meta 3D TextureGen

Meta 3D TextureGen (Bensadoun et al., 2024) menghaluskan tekstur yang dihasilkan oleh AssetGen. Ini juga dapat digunakan untuk menghasilkan tekstur baru untuk mesh 3D yang ada berdasarkan deskripsi teks tambahan. Tahap ini memakan waktu sekitar 20 detik.

Point-E (OpenAI)

Point-E, dikembangkan oleh OpenAI, adalah model generasi text-to-3D lain yang patut disebut. Tidak seperti DreamFusion, yang menghasilkan representasi NeRF, Point-E menghasilkan awan titik 3D.

Fitur kunci dari Point-E:

a) Pipa dua tahap: Point-E pertama-tama menghasilkan tampilan 2D sintetis menggunakan model difusi text-to-image, lalu menggunakan gambar ini untuk mengkondisikan model difusi kedua yang menghasilkan awan titik 3D.

b) Efisiensi: Point-E dirancang untuk efisiensi komputasi, mampu menghasilkan awan titik 3D dalam hitungan detik pada satu GPU.

c) Informasi warna: Model ini dapat menghasilkan awan titik berwarna, mempertahankan baik geometri maupun informasi penampilan.

Keterbatasan:

• Fidelitas yang lebih rendah dibandingkan dengan pendekatan berbasis mesh atau NeRF
• Awan titik memerlukan pemrosesan tambahan untuk banyak aplikasi hilir

Shap-E (OpenAI):

Membangun atas Point-E, OpenAI memperkenalkan Shap-E, yang menghasilkan mesh 3D bukan awan titik. Ini menangani beberapa keterbatasan Point-E sambil mempertahankan efisiensi komputasi.

Fitur kunci dari Shap-E:

a) Representasi implisit: Shap-E belajar menghasilkan representasi implisit (fungsi jarak bertanda) dari objek 3D.

b) Pengambilan mesh: Model ini menggunakan implementasi diferensial dari algoritma marching cubes untuk mengubah representasi implisit menjadi mesh poligonal.

c) Generasi tekstur: Shap-E juga dapat menghasilkan tekstur untuk mesh 3D, menghasilkan output yang lebih menarik secara visual.

Kelebihan:

• Waktu generasi yang cepat (detik hingga menit)
• Output mesh langsung yang cocok untuk rendering dan aplikasi hilir
• Kemampuan menghasilkan baik geometri maupun tekstur

GET3D (NVIDIA):

GET3D, dikembangkan oleh peneliti NVIDIA (NVDA ), adalah model generasi text-to-3D lain yang kuat yang berfokus pada menghasilkan mesh 3D bertekstur berkualitas tinggi.

Fitur kunci dari GET3D:

a) Representasi permukaan eksplisit: Tidak seperti DreamFusion atau Shap-E, GET3D secara langsung menghasilkan representasi permukaan eksplisit (mesh) tanpa representasi implisit intermediate.

b) Generasi tekstur: Model ini termasuk teknik rendering diferensial untuk belajar dan menghasilkan tekstur berkualitas tinggi untuk mesh 3D.

c) Arsitektur berbasis GAN: GET3D menggunakan pendekatan jaringan generatif adversarial (GAN), yang memungkinkan generasi cepat sekali model dilatih.

Kelebihan:

• Geometri dan tekstur berkualitas tinggi
• Waktu inferensi yang cepat
• Integrasi langsung dengan mesin rendering 3D

Keterbatasan:

• Memerlukan data pelatihan 3D, yang dapat langka untuk beberapa kategori objek

Kesimpulan

Generasi text-to-3D AI merepresentasikan pergeseran mendasar dalam cara kita membuat dan berinteraksi dengan konten 3D. Dengan menggunakan teknik pembelajaran dalam yang canggih, model ini dapat menghasilkan aset 3D kompleks dan berkualitas tinggi dari deskripsi teks sederhana. Seiring teknologi terus berkembang, kita dapat mengharapkan melihat sistem text-to-3D yang semakin canggih dan mampu yang akan merevolusi industri dari permainan dan film hingga desain produk dan arsitektur.