Raksturotības konsekvence AI video: Kā modeļi mācās atcerēties sejas

Viens no visizturīgākajiem izaicinājumiem AI video ģenerēšanā ir raksturotības konsekvences saglabāšana starp kadriem. Jautājiet jebkuru filmiešu veidotāju: stāsts sabrūk brīdī, kad jūsu galvenā varoņa seja nemanāmi mainās starp griezumiem. 2025. gadā mēs beidzot esam redzējuši, ka modeļi atrisina šo problēmu ar arhitektūras inovācijām, kas ir tikpat elegantes kā labi plānots maršruts uz grūtu virsotni. Ļaujiet man jums parādīt, kā moderni video modeļi mācās atcerēties sejas.

Konsekvences izaicinājums

Tradicionālie difūzijas modeļi ģenerē katru kadru ar probabilistisko paraugu ņemšanu. Tas rada dispersiju—noderīgi daudzveidībai, problēmatisks identitātei. Ģenerējot 10 sekunžu video ar 24 kadru sekundē, modelis pieņem 240 secīgus lēmumus, no kuriem katrs rada iespējas dreifam.

# Pamatproblēma: katrs denoising solis ievieš dispersiju
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # Šis paraugu ņemšanas process ievieš stohastiskumu
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Sīki variācijas uzkrājas starp kadriem

Agrīnie video modeļi, piemēram, Gen-1 un Pika 1.0, ar to cīnījās manāmi. Raksturotības izskats mainītos, viņi nedaudz novecojās starp kadriem vai attīstīja nekonsekventes īpašības—tas, ko praktiķi sauca par "identitātes dreifam". Pārrāvums nāca no domāšanas par raksturotības konsekvenci nevis kā pēcapstrādes problēmu, bet kā arhitektūras problēmu.

Identitāti saglabājošas iegultnes: Pamats

Pirmais lielais inovācija bija ieviest speciālas identitātes iegultnes, kas persists caur ģenerēšanas procesu. Tā vietā, lai paļautos tikai uz teksta kondicionēšanu, modeļi tagad saglabā skaidras identitātes marķieres:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Iepriekš apmācīts sejas modelis
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Izņem identitātes pazīmes no atsauces
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Krustojošā uzmanība ar apmācītiem identitātes marķieriem
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Šie identitātes marķieri pēc tam tiek ievietoti difūzijas procesā katrā denoising solī, radot to, ko es labprāt domāju kā "enkurpunktus"—tāpat kā fiksēta aizsardzība uz alpīnisma maršruta, uz kuru vienmēr varat atgriezties, kad apstākļi kļūst neskaidri.

Krustkadriskā uzmanība: Laika identitātes apguve

Otrais pārrāvums bija arhitektūras: modeļi tagad skaidri pievēršas uzmanību kadru griezumiem, pieņemot lēmumus par raksturotības izskatu. Difūzijas transformatori dabiski to atbalsta caur viņu telpa-laika flīžu apstrādi, bet konsekvencei fokusētie modeļi iet tālāk.

Galvenais inovācija: Speciālas identitātes uzmanības slāņi, kas konkrēti pievēršas sejas reģioniem laika dimensijā:

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):
        # Standarta telpiskā uzmanība kadrā
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Laika uzmanība starp kadriem
        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)
 
        # Identitātei specifiska uzmanība, izmantojot sejas reģionus
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

Šis trīskāršas uzmanības mehānisms—telpiskā, laika un identitātei specifiska—ļauj modelim pieņemt izskats lēmumus, skaidri atsaucoties uz gan noteikto identitāti, gan iepriekšējiem kadriem.

Pašreizējās modeļu pieejas salīdzinājums

Lielās video ģenerēšanas platformas ir implementējušas raksturotības konsekvenci dažādi:

Runway Gen-4.5 pelnīs īpašu minēšanu. Viņu pieeja apvieno atsauces attēla kondicionēšanu ar tā, ko viņi sauc par "identitātes slēdžiem"—apmācītiem marķieriem, ko modelis ir apmācīts saglabāt neatkarīgi no citiem ģenerativiem lēmumiem. Šī arhitektūras izvēle iespējams sekmēja viņu Video Arena dominanci.

Atsauces kadra paradigma

Nozīmīgs maiņas virziens 2025. gadā ir bijis pāreja uz atsauces kondicionēto ģenerēšanu. Tā vietā, lai ģenerētu raksturotības tikai no teksta aprakstiem, modeļi tagad pieņem atsauces attēlus, kas nosaka kanonisko izskatu:

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):
        # Kodē identitāti no atsauces attēliem
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Pūļņu vairākas atsauces spēcīgai identitātei
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Ģenerē ar identitātes kondicionēšanu
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Sabalansē konsekvenci pret jauninājumiem
            }
        )
        return video

Parametrs identity_strength pārstāv svarīgu kompromisu. Pārāk augsts, un modelis kļūst stīvs, nespējīgs parādīt dabiskās izteiksmes variācijas. Pārāk zems, un dreifs atgriežas. Ideālo vietu atrašana—parasti ap 0,7-0,85—ir daļēji māksla, daļēji zinātne.

Zudumu funkcijas identitātes saglabāšanai

Šo sistēmu apmācīšana pieprasa specializētas zudumu funkcijas, kas skaidri sodī identitātes dreifam:

Identitātes saglabāšanas zudums:

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

Kur f ir iepriekš apmācīts sejas atpazīšanas kodētājs, G ir ģenerators, un v_t pārstāv ģenerētos kadrus. Pirmais termins nodrošina, ka ģenerētās sejas atbilst atsaucēm; otrais sodī kadru starpību.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Kadrām specifiska identitātes saskaņošana ar atsauci
    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()
 
    # Laika konsekvence starp blakusesošiem kadriem
    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

Vairāku raksturotību scenāriji: Grūtākā problēma

Vienas raksturotības konsekvence lielā mērā ir atrisināta. Vairāku raksturotību scenāriji—kur vairākas atšķirīgas identitātes jāsaglabā vienlaikus—paliek izaicinošas. Uzmanības mehānismi var sajaukt identitātes, radot pazīmju noplūdi starp raksturotībām.

Pašreizējās pieejas izmanto atsevišķas identitātes bankšūnas:

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)
            # Pievienojiet separatoru, lai novērstu sajaukšanu
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Separatora marķieri darbojas kā beijas starp alpīnistiem—saglabājot atšķirīgas identitātes pat tuvā tuvumā darbojoties.

Praktiski sekas veidotājiem

Tiem, kas lieto šos rīkus, nevis tos būvē, ir parādījušies vairāki praktiski veidi:

Atsauces attēla kvalitāte ir svarīga: Augstāka izšķirtspēja, labas gaismas atsauces attēli ar neitrāliem izteiksmēm rada konsekvences rezultātus. Modelis mācās identitāti no šiem enkuriem, un troksnis izplatās.

Vairākas atsauces uzlabo izturību: Sniedzot 3-5 atsauces attēlus no dažādiem leņķiem, modelis palīdz konstruēt pilnīgāku identitātes pārstāvību. Domājiet par to kā pozīcijas triangulāciju no vairāk punktiem.

Aicinājuma inženierija konsekvencei: Skaidri identitātes apraksti aicināšanā pastiprina vizuālo konsekvenci. "30 gadus veca sieviete ar īsiem brūniem matiem un zaļām acīm" nodrošina papildu ierobežojumus, ko modelis var izmantot.

Ceļš uz priekšu

Mēs tuvojamies sliekšnim, kur AI ģenerēts video var saglabāt raksturotības konsekvenci, pietiekamu stāsta stāstīšanai. Atlikušie izaicinājumi—smalka izteiksmes konsekvence, ilgtermiņa ģenerēšana pāri 60 sekundēm un vairāku raksturotību mijiedarbība—tiek aktīvi risināti.

Bonega.ai, mēs īpaši esam interesēti par to, kā šie konsekvences uzlabojumi integrējas ar video pagarinājuma iespējām. Iespēja pagarināt esošu materiālu, saglabājot ideālu raksturotības konsekvenci, atvēr radošas iespējas, kas vienkārši nebija iespējamas pirms 12 mēnešiem.

Matemātiskā elegance, apstrādājot identitāti kā pirmās klases arhitektūras ieskaitli, nevis pēcapstrādes korekciju, marķē atziedēšanu, kā mēs domājam par video ģenerēšanu. Tāpat kā labi aprūpētā augstā nometne pirms virsotnes spiešanas, šie pamata uzlabojumi iespējo garākus, amiciozākus radošus ceļojumus, kas atrodas priekšā.

Raksturotības konsekvence nav tikai tehnisks mērījums—tā ir vizuālā stāstīšanas pamats. Un 2025. gadā šis pamats beidzot kļuvis pietiekami stabils, lai uz tā būvētu.