Konsistensi Watak dalam Video AI: Bagaimana Model Belajar Mengingat Wajah

Salah satu cabaran yang paling berterusan dalam penjanaan video AI adalah mengekalkan konsistensi watak merentasi rakaman. Tanya mana-mana pembuat filem: cerita runtuh sebaik sahaja wajah protagonis anda berubah secara halus antara potongan. Pada 2025, kita akhirnya melihat model memecahkan masalah ini dengan inovasi seni bina yang terasa seanggun laluan yang dirancang dengan baik ke puncak yang sukar. Mari saya membawa anda melalui bagaimana model video moden belajar mengingat wajah.

Cabaran Konsistensi

Model difusi tradisional menjana setiap bingkai dengan pensampelan kebarangkalian. Ini memperkenalkan varians, berguna untuk kepelbagaian, bermasalah untuk identiti. Apabila menjana video 10 saat pada 24fps, model membuat 240 keputusan berurutan, setiap satu dengan peluang untuk hanyut.

# Masalah utama: setiap langkah penyahbunyian memperkenalkan varians
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # Pensampelan ini memperkenalkan stokastik
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Variasi kecil terkumpul merentasi bingkai

Model video awal seperti Gen-1 dan Pika 1.0 bergelut dengan jelas dengan ini. Watak akan berubah penampilan, berusia sedikit antara rakaman, atau mengembangkan ciri tidak konsisten, apa yang pengamal panggil "hanyutan identiti." Kejayaan datang daripada merawat konsistensi watak bukan sebagai masalah pasca-pemprosesan, tetapi sebagai masalah seni bina.

Embeddings Pemeliharaan Identiti: Asas

Inovasi utama pertama adalah memperkenalkan embeddings identiti khusus yang berterusan merentasi proses penjanaan. Daripada bergantung semata-mata pada kondisi teks, model kini mengekalkan token identiti eksplisit:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Model wajah pra-latih
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Ekstrak ciri identiti daripada rujukan
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Perhatian silang dengan token identiti dipelajari
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Token identiti ini kemudian disuntik ke dalam proses difusi pada setiap langkah penyahbunyian, mencipta apa yang saya suka fikirkan sebagai "titik sauh", seperti perlindungan tetap pada laluan pendakian yang anda sentiasa boleh klip kembali apabila keadaan menjadi tidak pasti.

Perhatian Silang-Bingkai: Pembelajaran Identiti Temporal

Kejayaan kedua adalah seni bina: model kini secara eksplisit memberi perhatian merentasi bingkai apabila membuat keputusan tentang penampilan watak. Diffusion transformers secara semula jadi menyokong ini melalui pemprosesan tampalan ruang masa mereka, tetapi model fokus konsistensi pergi lebih jauh.

Inovasi Utama: Lapisan perhatian identiti khusus yang secara khusus memberi perhatian kepada kawasan wajah merentasi 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 spatial standard dalam bingkai
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Perhatian temporal merentasi bingkai
        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 khusus identiti menggunakan kawasan 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 ini, spatial, temporal, dan khusus identiti, membolehkan model membuat keputusan penampilan sambil secara eksplisit merujuk kepada kedua-dua identiti yang ditetapkan dan bingkai sebelumnya.

Pendekatan Model Semasa Dibandingkan

Platform penjanaan video utama telah melaksanakan konsistensi watak secara berbeza:

Gen-4.5 Runway layak mendapat sebutan khas di sini. Pendekatan mereka menggabungkan kondisi imej rujukan dengan apa yang mereka panggil "kunci identiti", token dipelajari yang model dilatih untuk memelihara tanpa mengira keputusan generatif lain. Pilihan seni bina ini berkemungkinan menyumbang kepada penguasaan Video Arena mereka.

Paradigma Bingkai Rujukan

Perubahan penting pada 2025 adalah pergerakan ke arah penjanaan bersyarat rujukan. Daripada menjana watak semata-mata daripada huraian teks, model kini menerima imej rujukan 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):
        # Enkod identiti daripada imej rujukan
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Kumpulkan pelbagai rujukan untuk identiti teguh
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Jana dengan kondisi identiti
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Mengimbangi konsistensi vs kreativiti
            }
        )
        return video

Parameter identity_strength mewakili pertukaran penting. Terlalu tinggi, dan model menjadi tegar, tidak dapat menunjukkan variasi ekspresi semula jadi. Terlalu rendah, dan hanyutan kembali. Mencari titik manis, biasanya sekitar 0.7-0.85, adalah sebahagian seni, sebahagian sains.

Fungsi Kehilangan untuk Pemeliharaan Identiti

Melatih sistem ini memerlukan fungsi kehilangan khusus yang secara eksplisit menghukum hanyutan identiti:

Kehilangan Pemeliharaan Identiti:

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

Di mana f adalah pengekod pengecaman wajah pra-latih, G adalah penjana, dan v_t mewakili bingkai dijana. Istilah pertama memastikan wajah dijana sepadan dengan rujukan; yang kedua menghukum variasi bingkai ke bingkai.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Pemadanan identiti per bingkai kepada rujukan
    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 bingkai bersebelahan
    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

Senario Pelbagai Watak: Masalah Lebih Sukar

Konsistensi watak tunggal sebahagian besarnya diselesaikan. Senario pelbagai watak, di mana pelbagai identiti berbeza mesti dikekalkan serentak, kekal mencabar. Mekanisme perhatian boleh menggabungkan identiti, membawa kepada pendarahan ciri antara watak.

Pendekatan semasa menggunakan bank identiti berasingan:

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)
            # Tambah pemisah untuk mencegah penggabungan
            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 antara pendaki, mengekalkan identiti berbeza walaupun beroperasi dalam jarak dekat.

Implikasi Praktikal untuk Pencipta

Bagi mereka yang menggunakan alat ini dan bukannya membinanya, beberapa corak praktikal telah muncul:

Kualiti Imej Rujukan Penting: Imej rujukan resolusi lebih tinggi, bercahaya baik dengan ekspresi neutral menghasilkan hasil yang lebih konsisten. Model belajar identiti daripada sauh ini, dan hingar merebak.

Pelbagai Rujukan Meningkatkan Kekukuhan: Menyediakan 3-5 imej rujukan dari sudut berbeza membantu model membina perwakilan identiti yang lebih lengkap. Fikirkan ia sebagai triangulasi kedudukan dari pelbagai titik.

Kejuruteraan Prompt untuk Konsistensi: Huraian identiti eksplisit dalam prompt mengukuhkan konsistensi visual. "Seorang wanita berusia 30 tahun dengan rambut coklat pendek dan mata hijau" menyediakan kekangan tambahan yang model boleh manfaatkan.

Jalan ke Hadapan

Kita menghampiri ambang di mana video dijana AI boleh mengekalkan konsistensi watak yang mencukupi untuk penceritaan naratif. Cabaran yang tinggal, konsistensi ekspresi halus, penjanaan jangka panjang melebihi 60 saat, dan interaksi pelbagai watak, sedang ditangani secara aktif.

Di Bonega.ai, kami amat berminat dengan bagaimana peningkatan konsistensi ini disepadukan dengan keupayaan lanjutan video. Keupayaan untuk melanjutkan rakaman sedia ada sambil mengekalkan konsistensi watak yang sempurna membuka kemungkinan kreatif yang tidak boleh dilaksanakan 12 bulan yang lalu.

Keanggunan matematik merawat identiti sebagai kebimbangan seni bina kelas pertama, dan bukannya pembetulan selepas fakta, menandakan kematangan dalam cara kita berfikir tentang penjanaan video. Seperti menubuhkan kem tinggi yang dibekalkan dengan baik sebelum tolakan puncak, peningkatan asas ini membolehkan perjalanan kreatif yang lebih panjang dan lebih bercita-cita tinggi yang terletak di hadapan.

Konsistensi watak bukan sekadar metrik teknikal, ia adalah asas penceritaan visual. Dan pada 2025, asas itu akhirnya menjadi cukup kukuh untuk dibina.