Konsistensi Karakter dalam Video AI: Cara Model Mengingat Wajah

Salah satu tantangan yang paling persisten dalam generasi video AI adalah mempertahankan konsistensi karakter di seluruh adegan. Tanyakan kepada sinematografer mana pun: sebuah cerita kehilangan resonansi pada momen wajah protagonis Anda berubah secara halus di antara potongan film. Pada tahun 2025, kami akhirnya telah melihat model memecahkan masalah ini dengan inovasi arsitektur yang terasa elegan seperti rute pendakian yang dirancang dengan baik di puncak yang menantang. Baiklah saya ajak Anda memahami bagaimana model video modern belajar mengingat wajah.

Tantangan Konsistensi

Model difusi tradisional menghasilkan setiap frame dengan pengambilan sampel probabilistik. Ini memperkenalkan varians—berguna untuk keragaman, namun bermasalah untuk identitas. Ketika menghasilkan video 10 detik pada 24fps, model membuat 240 keputusan berurutan, masing-masing dengan peluang untuk terjadi penyimpangan.

# Masalah inti: setiap langkah denoising memperkenalkan varians
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # Pengambilan sampel ini memperkenalkan stokastisitas
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Variasi kecil terakumulasi di seluruh frame

Model video awal seperti Gen-1 dan Pika 1.0 berjuang nyata dengan hal ini. Karakter akan bergeser dalam penampilan, menjadi sedikit lebih tua di antara potongan, atau menampilkan fitur yang tidak konsisten—apa yang disebut praktisi sebagai "identity drift." Terobosan muncul dari perlakuan konsistensi karakter bukan sebagai masalah pasca-pemrosesan, melainkan sebagai masalah arsitektur.

Penyisipan Pengawet Identitas: Fondasi

Inovasi besar pertama adalah memperkenalkan penyisipan identitas khusus yang bertahan di seluruh proses generasi. Daripada mengandalkan hanya pada pengkondisian teks, model sekarang mempertahankan token identitas eksplisit:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Model wajah yang sudah dilatih
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Ekstrak fitur identitas dari referensi
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Cross-attend dengan token identitas yang dipelajari
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Token identitas ini kemudian disuntikkan ke dalam proses difusi pada setiap langkah denoising, menciptakan apa yang saya senang sebut sebagai "titik jangkar"—seperti perlindungan tetap pada rute pendakian yang selalu dapat Anda pasangkan kembali ketika kondisi menjadi tidak pasti.

Perhatian Lintas-Frame: Belajar Identitas Temporal

Terobosan kedua adalah arsitektur: model sekarang secara eksplisit memperhatikan di seluruh frame ketika membuat keputusan tentang penampilan karakter. Transformator difusi secara alami mendukung ini melalui pemrosesan patch spacetime mereka, namun model yang berfokus pada konsistensi melangkah lebih jauh.

Inovasi Kunci: Lapisan perhatian identitas khusus yang secara khusus memperhatikan wilayah wajah di seluruh dimensi temporal:

class IdentityAwareAttention(nn.Module):
    def __init__(self, dim, num_heads=8):
        super().__init__()
        self.spatial_attn = nn.MultiheadAttention(dim, num_heads)
        self.temporal_attn = nn.MultiheadAttention(dim, num_heads)
        self.identity_attn = nn.MultiheadAttention(dim, num_heads)
 
    def forward(self, x, identity_tokens, face_masks):
        # Perhatian spasial standar dalam frame
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Perhatian temporal di seluruh frame
        x = rearrange(x, '(b t) n d -> (b n) t d', t=num_frames)
        x = self.temporal_attn(x, x, x)[0] + x
        x = rearrange(x, '(b n) t d -> (b t) n d', n=num_patches)
 
        # Perhatian spesifik identitas menggunakan wilayah wajah
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

Mekanisme perhatian tiga kali—spasial, temporal, dan khusus identitas—memungkinkan model membuat keputusan penampilan sambil secara eksplisit merujuk pada identitas yang telah ditetapkan dan frame sebelumnya.

Perbandingan Pendekatan Model Saat Ini

Platform generasi video besar telah menerapkan konsistensi karakter secara berbeda:

Gen-4.5 Runway layak mendapat penyebutan khusus di sini. Pendekatan mereka menggabungkan pengkondisian gambar referensi dengan apa yang mereka sebut sebagai "identity locks"—token yang dipelajari yang model dilatih untuk dipertahankan terlepas dari keputusan generatif lainnya. Pilihan arsitektur ini kemungkinan besar berkontribusi pada dominasi Video Arena mereka.

Paradigma Frame Referensi

Pergeseran signifikan pada tahun 2025 telah menjadi gerakan menuju generasi yang dikondisikan referensi. Daripada menghasilkan karakter murni dari deskripsi teks, model sekarang menerima gambar referensi yang menetapkan penampilan kanonik:

class ReferenceConditionedGenerator:
    def __init__(self, base_model, identity_encoder):
        self.model = base_model
        self.identity_encoder = identity_encoder
 
    def generate(self, prompt, reference_images, num_frames=120):
        # Encode identitas dari gambar referensi
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Pool referensi berganda untuk identitas yang kuat
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Hasilkan dengan pengkondisian identitas
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Menyeimbangkan konsistensi vs kreativitas
            }
        )
        return video

Parameter identity_strength mewakili trade-off yang penting. Terlalu tinggi, dan model menjadi kaku, tidak mampu menunjukkan variasi ekspresi alami. Terlalu rendah, dan penyimpangan kembali. Menemukan sweet spot—biasanya sekitar 0,7-0,85—adalah bagian seni, bagian sains.

Fungsi Loss untuk Pengawetan Identitas

Pelatihan sistem ini memerlukan fungsi loss khusus yang secara eksplisit menghukum penyimpangan identitas:

Loss Pengawetan Identitas:

L_identity = ||f(G(z, c)) - f(x_ref)||² + λ_temporal * Σ_t ||f(v_t) - f(v_{t+1})||²

Di mana f adalah encoder pengakuan wajah yang telah dilatih sebelumnya, G adalah generator, dan v_t mewakili frame yang dihasilkan. Istilah pertama memastikan wajah yang dihasilkan cocok dengan referensi; yang kedua menghukum variasi frame-ke-frame.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Pencocokan identitas per-frame dengan referensi
    frame_losses = []
    for frame in generated_video:
        face_embed = face_encoder(frame)
        ref_embed = face_encoder(reference_faces).mean(dim=0)
        frame_losses.append(F.mse_loss(face_embed, ref_embed))
 
    reference_loss = torch.stack(frame_losses).mean()
 
    # Konsistensi temporal antara frame yang berdekatan
    temporal_losses = []
    for i in range(len(generated_video) - 1):
        curr_embed = face_encoder(generated_video[i])
        next_embed = face_encoder(generated_video[i + 1])
        temporal_losses.append(F.mse_loss(curr_embed, next_embed))
 
    temporal_loss = torch.stack(temporal_losses).mean()
 
    return reference_loss + 0.5 * temporal_loss

Skenario Multi-Karakter: Masalah yang Lebih Sulit

Konsistensi karakter tunggal sebagian besar telah terpecahkan. Skenario multi-karakter—di mana beberapa identitas berbeda harus dipertahankan secara bersamaan—tetap menantang. Mekanisme perhatian dapat mengacaukan identitas, yang menyebabkan pendarahan fitur di antara karakter.

Pendekatan saat ini menggunakan bank identitas terpisah:

class MultiCharacterIdentityBank:
    def __init__(self, max_characters=8, embed_dim=768):
        self.banks = nn.ModuleList([
            IdentityBank(embed_dim) for _ in range(max_characters)
        ])
        self.character_separator = nn.Parameter(torch.randn(1, embed_dim))
 
    def encode_multiple(self, character_references):
        all_tokens = []
        for idx, refs in enumerate(character_references):
            char_tokens = self.banks[idx].encode(refs)
            # Tambahkan separator untuk mencegah pengacauan
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Token pemisah bertindak seperti belay di antara pendaki—mempertahankan identitas yang berbeda bahkan ketika beroperasi dalam jarak dekat.

Implikasi Praktis untuk Kreator

Bagi mereka yang menggunakan alat-alat ini daripada membangun mereka, beberapa pola praktis telah muncul:

Kualitas Gambar Referensi Penting: Gambar referensi beresolusi lebih tinggi, berlampu terang dengan ekspresi netral menghasilkan hasil yang lebih konsisten. Model belajar identitas dari jangkar-jangkar ini, dan kebisingan menyebar.

Referensi Berganda Meningkatkan Ketahanan: Menyediakan 3-5 gambar referensi dari sudut berbeda membantu model membangun representasi identitas yang lebih lengkap. Anggap saja sebagai triangulasi posisi dari beberapa titik.

Rekayasa Prompt untuk Konsistensi: Deskripsi identitas eksplisit dalam prompt memperkuat konsistensi visual. "Seorang wanita berusia 30 tahun dengan rambut coklat pendek dan mata hijau" memberikan batasan tambahan yang dapat dimanfaatkan model.

Jalan ke Depan

Kami mendekati ambang di mana video yang dihasilkan AI dapat mempertahankan konsistensi karakter yang cukup untuk bercerita naratif. Tantangan yang tersisa—konsistensi ekspresi halus, generasi jangka panjang lebih dari 60 detik, dan interaksi multi-karakter—secara aktif ditangani.

Di Bonega.ai, kami sangat tertarik pada bagaimana peningkatan konsistensi ini terintegrasi dengan kemampuan perpanjangan video. Kemampuan untuk memperpanjang rekaman yang ada sambil mempertahankan konsistensi karakter yang sempurna membuka kemungkinan kreatif yang sekadar tidak layak 12 bulan yang lalu.

Keanggunan matematis dari perlakuan identitas sebagai kekhawatiran arsitektur tingkat pertama, daripada koreksi pasca-hoc, menandai pendewasaan dalam cara kami berpikir tentang generasi video. Seperti menetapkan kamp dasar tinggi yang penuh dengan perlengkapan sebelum dorongan puncak, peningkatan fundamental ini memungkinkan perjalanan kreatif yang lebih lama dan lebih ambisius di depan.

Konsistensi karakter bukan hanya metrik teknis—ini adalah fondasi bercerita visual. Dan pada tahun 2025, fondasi itu akhirnya menjadi cukup solid untuk dibangun di atasnya.