Konzistencia postáv v AI videu: ako si modely pamätajú tváre

Jednou z najtrvalších výziev v generovaní videí pomocou AI bola udržiavanie konzistencie postáv v jednotlivých záberoch. Opýtajte sa ktoréhokoľvek filmára: príbeh sa rozpadne v momente, keď sa tvár vášho protagonistu jemne zmení medzi strihy. V roku 2025 sme konečne videli, ako modely riešia tento problém architektonickými inováciami, ktoré sú takou elegantné ako dobre naplánovaná trasa na náročný vrchol. Dovoľte mi, aby som vám vysvetlil, ako sa moderné video modely učia pamätať si tváre.

Výzva konzistencie

Tradičné difúzne modely generujú každý snímok s pravdepodobnostným vzorkovaním. To zavádza variabilitu – užitočnú pre rozmanitosť, problematickú pre identitu. Pri generovaní 10-sekundového videá pri 24 fps model robí 240 sekvenčných rozhodnutí, každé s príležitosťami na posun.

# Hlavný problém: každý krok odšumenia zavádza variabilitu
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # Toto vzorkovanie zavádza stochasticitu
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Drobné variácie sa hromadia v snímkoch

Staršie video modely ako Gen-1 a Pika 1.0 s tým zápasili viditeľne. Postavy by sa menili na vzhľade, stárly by sa o niekoľko rokov medzi zábermi, alebo by mali nekonzistentné rysy – čo praktici nazývali "posun identity". Prielom prišiel z toho, že sa konzistencia postáv neriešila ako problém spracovávania po generovaní, ale ako architektonický.

Embeddingy zachovávajúce identitu: Základ

Prvá veľká inovácia bola zavedenie vyhradených embedingov identity, ktoré pretrvávajú v procese generovania. Namiesto spoliehanú sa iba na kondicionovanie textom, modely teraz udržiavajú explicitné identity tokeny:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Predtrénovaný model tváre
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Extrahuj vlastnosti identity z referenčného snímku
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Vzájomná pozornosť s naučenými tokeny identity
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Tieto identity tokeny sú potom injektované do procesu difúzie v každom kroku odšumenia, čím sa vytvárajú tzv. "kotviace body" – ako pevná asistencia na lezeckej trase, ku ktorej sa vždy môžete vrátiť, keď sú podmienky neisté.

Pozornosť medzi snímkami: Učenie sa časovej identity

Druhou prelomovou bol architektonický: modely teraz explicitne pozorujú snímky pri rozhodovaní o vzhľade postáv. Difúzne transformery prirodzene podporujú toto prostredníctvom ich spracovania priestorovočasových patches, ale modely zamerané na konzistenciu idú ešte ďalej.

Kľúčová inovácia: Vyhradené vrstvy pozornosti identity, ktoré konkrétne pozorujú oblasti tvárí v časovej dimenzii:

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):
        # Štandardná priestorová pozornosť v snímkoch
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Časová pozornosť v snímkoch
        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)
 
        # Pozornosť špecifická pre identitu pomocou oblastí tvárí
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

Tento trojitý mechanizmus pozornosti – priestorový, časový a špecifický pre identitu – umožňuje modelu prijímať rozhodnutia o vzhľade s explicitným odkazom na etablovanú identitu a predchádzajúce snímky.

Porovnanie súčasných prístupov modelov

Hlavné platformy generovania videí implementovali konzistenciu postáv inak:

Gen-4.5 od Runwaya si zaslúži špeciálnu zmienku. Ich prístup kombinuje kondicionovanie referenčného obrázka s tým, čo nazývajú "identity locks" – naučené tokeny, ktoré sa model trénuje na zachovanie bez ohľadu na ostatné generatívne rozhodnutia. Táto architektonická voľba pravdepodobne prispieva k ich dominancii v Video Arena.

Paradigma referenčného snímku

Významný posun v roku 2025 bol smer k generovaniu kondicionovanému referenciou. Namiesto generovania postáv čisto z textových opisov, modely teraz prijímajú referenčné obrázky, ktoré stanovujú kanonický vzhľad:

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):
        # Zakóduj identitu z referenčných obrázkov
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Zjednoť viacero referenčných obrazov pre robustnú identitu
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Generuj s kondicionovaním identity
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Vyvažuje konzistenciu a kreativitu
            }
        )
        return video

Parameter identity_strength predstavuje dôležitý kompromis. Ak je príliš vysoký, model sa stáva tuhý, nedokáže ukázať prirodzené variácie výrazov. Ak je príliš nízky, posun identity sa vracia. Nájdenie ideálneho bodu – zvyčajne okolo 0,7–0,85 – je časti umenie, časti veda.

Stratové funkcie pre zachovanie identity

Trenovanie týchto systémov vyžaduje špecializované stratové funkcie, ktoré explicitne penalizujú posun identity:

Stratová funkcia zachovania identity:

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

Kde f je predtrénovaný kodér rozpoznávania tvárí, G je generátor a v_t predstavuje generované snímky. Prvý člen zabezpečuje, aby generované tváre zodpovedali referenciám; druhý penalizuje variáciu medzi snímkami.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Zhoda identity podľa snímku s referenciou
    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()
 
    # Časová konzistencia medzi susednými snímkami
    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

Scenáre s viacerými postavami: Ťažší problém

Konzistencia jednej postavy je do značnej miery vyriešená. Scenáre s viacerými postavami – kde je potrebné simultánne udržiavať viacero odlišných identít – zostávajú náročné. Mechanizmy pozornosti môžu zmiešať identity, čo vedie k úniku vlastností medzi postávami.

Súčasné prístupy používajú samostatné banky identity:

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)
            # Pridaj oddeľovač na zabránenie zmiešavaniu
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Oddeľovacie tokeny fungujú ako záchranné body medzi lezecmi – udržujú odlišné identity aj pri tesnej blízkosti.

Praktické implikácie pre tvorcov

Pre tých, ktorí tieto nástroje skôr používajú než ich budujú, sa vyvinulo niekoľko praktických vzorcov:

Kvalita referenčného obrázka je dôležitá: Referenčné obrázky s vyššou rozlíšením, dobre osvetlené s neutrálnymi výrazmi tvárí produkujú konzistentnejšie výsledky. Model sa učí identitu z týchto kotiev a hluk sa šíri.

Viacero referenčných obrazov zvyšuje robustnosť: Poskytnutie 3–5 referenčných obrázkov z rôznych uhlov pomáha modelu vytvoriť úplnejšiu reprezentáciu identity. Predstavte si to ako trianguláciu pozície z niekoľkých bodov.

Engineering promptov pre konzistenciu: Explicitné opisy identity v promptoch posilňujú vizuálnu konzistenciu. "30-ročná žena s krátkymi hnedými vlasmi a zelenými očami" poskytuje dodatočné obmedzenia, ktoré model môže využiť.

Budúcnosť

Približujeme sa k bodu, kde video generované AI môže udržiavať konzistenciu postáv dostatočnú na rozprávanú tvorbu príbehu. Zostávajúce výzvy – jemná konzistencia výrazov, dlhodobé generovanie nad 60 sekúnd a interakcia postáv – sú aktívne riešené.

V spoločnosti Bonega.ai nás obzvlášť zaujíma, ako sa tieto vylepšenia konzistencie integrujú s možnosťami rozšírenia videí. Schopnosť rozšíriť existujúcu záberu pri zachovaní perfektnej konzistencie postáv otvára kreatívne možnosti, ktoré jednoducho neboli uskutočniteľné pred 12 mesiacmi.

Matematická elegancia zaobchádzania s identitou ako s prvotným architektonickým problémom, namiesto opravy ex post facto, znamená dozrievanie v tom, ako premýšľame o generovaní videí. Ako zavedenie dobre vybaveného vysokého tábora pred zatlačením na vrchol, tieto základné vylepšenia umožňujú dlhšie, ambicióznejšie kreatívne cesty, ktoré pred nami ležia.

Konzistencia postáv nie je len technická metrika – je to základ vizuálneho rozprávania. A v roku 2025 bol tento základ konečne dostatočne pevný na to, aby sa doň mohlo niečo stavať.