Cara Kerja Pembuatan AI Text-to-3D: Meta 3D Gen, OpenAI Shap-E, dan banyak lagi

Kemampuan untuk menghasilkan aset digital 3D dari perintah teks mewakili salah satu perkembangan terkini yang paling menarik dalam AI dan grafik komputer. Seiring dengan pertumbuhan pasar aset digital 3D $ 28.3 miliar pada 2024 menjadi $ 51.8 miliar pada 2029, model AI text-to-3D siap memainkan peran utama dalam merevolusi pembuatan konten di berbagai industri seperti game, film, e-commerce, dan banyak lagi. Namun bagaimana sebenarnya cara kerja sistem AI ini? Dalam artikel ini, kita akan mendalami detail teknis di balik pembuatan teks ke 3D.

Tantangan Generasi 3D

Menghasilkan aset 3D dari teks adalah tugas yang jauh lebih kompleks daripada menghasilkan gambar 2D. Meskipun gambar 2D pada dasarnya adalah kisi-kisi piksel, aset 3D memerlukan representasi geometri, tekstur, material, dan seringkali animasi dalam ruang tiga dimensi. Dimensi dan kompleksitas tambahan ini membuat tugas pembangkitan menjadi jauh lebih menantang.

Beberapa tantangan utama dalam pembuatan teks ke 3D meliputi:

• Mewakili geometri dan struktur 3D
• Menghasilkan tekstur dan material yang konsisten di seluruh permukaan 3D
• Memastikan masuk akal dan koherensi fisik dari berbagai sudut pandang
• Menangkap 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 memanfaatkan beberapa teknologi dan teknik utama.

Komponen Utama Sistem Teks-ke-3D

Sebagian besar sistem pembuatan teks-ke-3D yang canggih memiliki beberapa komponen inti:

1. Pengkodean teks: Mengubah perintah teks masukan menjadi representasi numerik
2. representasi 3D XNUMX: Metode untuk merepresentasikan geometri dan tampilan 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 secara lebih rinci.

Pengkodean Teks

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

Representasi 3D

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

1. Jaringan Voxel: Array nilai 3D yang mewakili hunian atau fitur
2. Awan titik: Kumpulan titik 3D
3. Jala; jaringan: Simpul dan muka yang mendefinisikan suatu permukaan
4. Fungsi implisit: Fungsi kontinu yang mendefinisikan suatu permukaan (misalnya fungsi jarak bertanda)
5. Bidang pancaran saraf (NeRF): Jaringan saraf yang mewakili kepadatan dan warna dalam ruang 3D

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

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

import numpy as np

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

# Evaluate SDF at a 3D point
point = [0.5, 0.5, 0.5]
distance = sphere_sdf(*point)
print(f"Distance to sphere surface: {distance}")

Model Generatif

Inti dari sistem text-to-3D adalah model generatif yang menghasilkan representasi 3D dari penyematan teks. Kebanyakan model canggih menggunakan beberapa variasi model difusi, mirip dengan yang digunakan dalam pembuatan gambar 2D.

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

Pseudocode yang disederhanakan untuk langkah pelatihan model difusi mungkin terlihat seperti:

def diffusion_training_step(model, x_0, text_embedding):
# Sample a random timestep
t = torch.randint(0, num_timesteps, (1,))

# Add noise to the input
noise = torch.randn_like(x_0)
x_t = add_noise(x_0, noise, t)

# Predict the noise
predicted_noise = model(x_t, t, text_embedding)

# Compute loss
loss = F.mse_loss(noise, predicted_noise)

return loss

# Training loop
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 pembuatan, kami memulai dari noise murni dan melakukan denoise secara berulang, dikondisikan pada penyematan teks.

Rendering

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

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

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

def render_mesh(vertices, faces, image_size=256):
    # Create a renderer
    renderer = pr.MeshRenderer(
        rasterizer=pr.MeshRasterizer(),
        shader=pr.SoftPhongShader()
    )
    
    # Set up camera
    cameras = pr.FoVPerspectiveCameras()
    
    # Render
    images = renderer(vertices, faces, cameras=cameras)
    
    return images

# Example usage
vertices = torch.rand(1, 100, 3)  # Random vertices
faces = torch.randint(0, 100, (1, 200, 3))  # Random faces
rendered_images = render_mesh(vertices, faces)

Untuk representasi implisit seperti NeRF, kami biasanya menggunakan teknik ray marching untuk merender tampilan.

Menyatukan Semuanya: Saluran Teks-ke-3D

Sekarang setelah kita membahas komponen-komponen utama, mari kita lihat bagaimana komponen-komponen tersebut digabungkan dalam alur pembuatan teks-ke-3D pada umumnya:

1. Pengkodean teks: Perintah masukan dikodekan ke dalam representasi vektor padat menggunakan model bahasa.
2. Generasi awal: Model difusi, yang dikondisikan pada penyematan 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. Perbaikan: Jaringan tambahan dapat menyempurnakan geometri, menambahkan tekstur, atau menyempurnakan detail.
5. Hasil akhir: Representasi 3D dikonversi ke format yang diinginkan (misalnya mesh bertekstur) untuk digunakan dalam aplikasi hilir.

Berikut ini contoh sederhana tampilannya 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()
    
    def forward(self, text_prompt):
        # Encode text
        text_embedding = self.text_encoder(text_prompt).last_hidden_state.mean(dim=1)
        
        # Generate initial 3D representation
        initial_3d = self.diffusion_model(text_embedding)
        
        # Render multiple views
        views = self.renderer(initial_3d, num_views=4)
        
        # Refine based on multi-view consistency
        refined_3d = self.refiner(initial_3d, views)
        
        return refined_3d

# Usage
model = TextTo3D()
text_prompt = "A red sports car"
generated_3d = model(text_prompt)

Model Aset Teks ke 3D Teratas Tersedia

Generasi 3D – Meta

Generasi 3D dirancang untuk mengatasi masalah menghasilkan konten 3D—seperti karakter, alat peraga, dan adegan—dari deskripsi tekstual.

Model Bahasa Besar dan Teks-ke-3D – generasi 3d

3DGen mendukung rendering berbasis fisik (PBR), yang penting untuk menampilkan kembali aset 3D yang realistis dalam aplikasi dunia nyata. Ini juga memungkinkan penteksturan ulang generatif dari bentuk 3D yang dibuat sebelumnya atau dibuat oleh seniman menggunakan masukan tekstual baru. Pipeline ini mengintegrasikan dua komponen inti: Meta 3D AssetGen dan Meta 3D TextureGen, yang masing-masing menangani pembuatan teks-ke-3D dan teks-ke-tekstur.

Meta 3D AssetGen

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

Meta Tekstur 3DGen

Meta 3D TextureGen (Bensadoun et al., 2024) menyempurnakan tekstur yang dihasilkan oleh AssetGen. Ini juga dapat digunakan untuk menghasilkan tekstur baru untuk jerat 3D yang ada berdasarkan deskripsi tekstual tambahan. Tahap ini memakan waktu kurang lebih 20 detik.

Titik-E (OpenAI)

Titik-E, dikembangkan oleh OpenAI, adalah model pembuatan teks-ke-3D terkenal lainnya. Berbeda dengan DreamFusion, yang menghasilkan representasi NeRF, Point-E menghasilkan point cloud 3D.

Fitur utama Titik-E:

a) Pipa dua tahap: Titik-E pertama-tama menghasilkan tampilan 2D sintetik menggunakan model difusi teks-ke-gambar, kemudian menggunakan gambar ini untuk mengkondisikan model difusi kedua yang menghasilkan titik awan 3D.

b) Efisiensi: Point-E dirancang agar efisien secara komputasi, mampu menghasilkan point cloud 3D dalam hitungan detik pada satu GPU.

c) Informasi warna: Model ini dapat menghasilkan awan titik berwarna, mempertahankan informasi geometris dan tampilannya.

Keterbatasan:

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

Bentuk-E (OpenAI):

Berdasarkan Point-E, OpenAI diperkenalkan Shap-E, yang menghasilkan jerat 3D, bukan awan titik. Hal ini mengatasi beberapa keterbatasan Titik-E sambil menjaga efisiensi komputasi.

Fitur utama Shap-E:

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

b) Ekstraksi jaring: Model ini menggunakan implementasi algoritma kubus berbaris yang dapat dibedakan untuk mengubah representasi implisit menjadi jaring poligonal.

c) Pembuatan tekstur: Shap-E juga dapat menghasilkan tekstur untuk jerat 3D, sehingga menghasilkan keluaran yang lebih menarik secara visual.

Keuntungan:

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

DAPATKAN3D (NVIDIA):

GET3D, yang dikembangkan oleh peneliti NVIDIA, adalah model generasi teks-ke-3D canggih lainnya yang berfokus pada produksi jerat 3D bertekstur berkualitas tinggi.

Fitur utama GET3D:

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

b) Pembuatan tekstur: Model ini menyertakan teknik rendering yang dapat dibedakan untuk mempelajari dan menghasilkan tekstur berkualitas tinggi untuk mesh 3D.

c) Arsitektur berbasis GAN: GET3D menggunakan pendekatan generative adversarial network (GAN), yang memungkinkan pembuatan dengan cepat setelah model dilatih.

Keuntungan:

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

Keterbatasan:

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

Kesimpulan

Pembuatan AI teks-ke-3D mewakili perubahan mendasar dalam cara kita membuat dan berinteraksi dengan konten 3D. Dengan memanfaatkan teknik pembelajaran mendalam yang canggih, model ini dapat menghasilkan aset 3D yang kompleks dan berkualitas tinggi dari deskripsi teks sederhana. Seiring dengan terus berkembangnya teknologi, kita dapat melihat sistem text-to-3D yang semakin canggih dan mumpuni yang akan merevolusi industri mulai dari game dan film hingga desain produk dan arsitektur.