Konzistence postav v AI videu: Jak se modely učí pamatovat si tváře

Jeden z nejzásadnějších problémů při generování videí AI bylo udržení konzistence postav v průběhu záběrů. Zeptejte se kteréhokoliv filmaře: příběh se rozpadá v okamžiku, kdy se tvář vašeho protagonisty subtilně změní mezi střihy. V roce 2025 jsme konečně viděli modely vyřešit tento problém pomocí architektonických inovací, které mají eleganci dobře naplánované cesty horským štítem. Pojďme se podívat, jak se moderní video modely učí pamatovat si tváře.

Výzva konzistence

Tradiční difuzní modely generují každý snímek pomocí pravděpodobnostního vzorkování. To zavádí variabilitu—užitečnou pro rozmanitost, problematickou pro identitu. Při generování 10sekundového videa s 24 snímky za sekundu model dělá 240 sekvenčních rozhodnutí, z nichž každé má možnost odchylky.

# Základní problém: každý krok dešumování zavádí variabilitu
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # Toto vzorkování zavádí stochastičnost
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Malé variace se hromadí v průběhu snímků

Rané video modely jako Gen-1 a Pika 1.0 s tím viditelně zápasily. Postavy by se měnily na vzhledu, stárly mezi záběry, nebo vyvíjely nekonzistentní rysy—to, co praktici nazývali „drift identity". Průlom přišel, když bylo chápáno, že konzistence postav není problém post-procesingu, ale architektonický.

Embedingy zachovávající identitu: Základ

První velkou inovací bylo zavedení vyhrazených embeddingů identity, které přetrvávají v průběhu generačního procesu. Místo toho, aby se modely spoléhaly pouze na textové kondicionování, nyní udržují explicitní tokeny identity:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Předem trénovaný model rozpoznávání tváří
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Extrahuj rysy identity z referenčního snímku
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Křížová pozornost s naučenými tokeny identity
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Tyto tokeny identity jsou pak vkládány do difuzního procesu v každém kroku dešumování, čímž se vytváří to, co se mi líbí nazývat „jakory"—jako pevné jištění na horské cestě, ke kterému se můžeš vždy vrátit, když se podmínky zhoršují.

Křížová pozornost mezi snímky: Učení se časové identity

Druhý průlom byl architektonický: modely nyní explicitně pozorují snímky v čase při rozhodování o vzhledu postav. Difuzní transformery to přirozeně podporují pomocí jejich zpracování prostorově-časových záplat, ale modely zaměřené na konzistenci jdou dále.

Klíčová inovace: Vyhrazené vrstvy pozornosti identity, které specificky pozorují obličejové oblasti v čase:

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):
        # Standardní prostorová pozornost v rámci snímků
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Časová pozornost mezi snímky
        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)
 
        # Pozornost specifická pro identitu pomocí obličejových regionů
        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ý mechanismus pozornosti—prostorový, časový a specifický pro identitu—umožňuje modelu dělat rozhodnutí o vzhledu a přitom explicitně odkazuje na etablovanou identitu i předchozí snímky.

Přehled přístupů současných modelů

Velké platformy pro generování videí implementovaly konzistenci postav různě:

Zvláštní zmínku zaslouží Runway Gen-4.5. Jejich přístup kombinuje kondicionování referenčního obrázku s tím, co nazývají „identity locks"—naučenými tokeny, které je model trénován zachovávat bez ohledu na ostatní generativní rozhodnutí. Tato architektonická volba pravděpodobně přispěla k jejich dominanci v Video Arena.

Paradigma referenčního snímku

Významný posun v roce 2025 byl pohyb směrem k generování kondicionovanému referencí. Místo generování postav čistě z textových popisů nyní modely přijímají referenční obrázky, které zavádějí kanonický vzhled:

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ázků
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Sjednoť více referencí pro robustní identitu
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Generuj s kondicionování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 konzistenci vs kreativitu
            }
        )
        return video

Parametr identity_strength představuje důležitý kompromis. Příliš vysoký, a model se stane rigidní, neschopný ukázat přirozenou variaci výrazu. Příliš nízký, a drift se vrací. Nalezení sladkého místa—obvykle kolem 0,7–0,85—je částí umění, částí vědy.

Ztrátové funkce pro zachování identity

Trénování těchto systémů vyžaduje specializované ztrátové funkce, které explicitně penalizují drift identity:

Ztráta zachování identity:

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

Kde f je předem trénovaný encoder rozpoznávání tváří, G je generátor, a v_t reprezentuje vygenerované snímky. První člen zajišťuje, že generované tváře se shodují s referencemi; druhý penalizuje variaci mezi snímky.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Soulad identity podle snímků s referencí
    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á konzistence mezi sousedními snímky
    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

Scénáře s více postavami: Těžší problém

Konzistence jednotlivé postavy je do značné míry vyřešena. Scénáře s více postavami—kde se musí udržovat současně více odlišných identit—zůstávají náročné. Mechanismy pozornosti mohou zaměňovat identity, což vede k úniku rysů mezi postavami.

Současné přístupy používají oddělené 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)
            # Přidej separátor, aby se zabránilo záměně
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Separátorové tokeny fungují jako jištění mezi horolezci—udržují odlišné identity, i když pracují v těsné blízkosti.

Praktické důsledky pro tvůrce

Pro ty, kteří tyto nástroje používají místo jejich budování, vyplynulo několik praktických vzorů:

Kvalita referenčního obrázku je důležitá: Referenční obrázky vyšší rozlišení, dobře osvětlené s neutrálními výrazy dávají konzistentnější výsledky. Model se učí identitu z těchto jakorek, a šum se šíří.

Více referencí zlepšuje robustnost: Poskytnutí 3–5 referenčních obrázků z různých úhlů pomáhá modelu vytvořit úplnější reprezentaci identity. Pomysli na to jako na trilateraci polohy z více bodů.

Inženýrství promptu pro konzistenci: Explicitní popisy identity v promptech posilují vizuální konzistenci. „Třicetiletá žena s krátkými hnědými vlasy a zelenýma očima" poskytuje další omezení, která model může využít.

Cesta vpřed

Blížíme se prahu, kde AI-generované video může udržet konzistenci postav dostatečnou pro vyprávění příběhů. Zbývající výzvy—jemná konzistence výrazů, dlouhodobé generování přesahující 60 sekund a interakce více postav—se aktivně řeší.

V Bonega.ai nás zvláště zajímá, jak se tato vylepšení konzistence integrují se schopnostmi rozšiřování videí. Schopnost rozšířit existující záběr a přitom udržet dokonalou konzistenci postav otevírá kreativní možnosti, které jednoduše nebyly před 12 měsíci proveditelné.

Matematická elegance zacházení s identitou jako s architektonickou prioritou první třídy, nikoli jako s dodatečnou korekcí, znamená zrání v tom, jak myslíme na generování videí. Podobně jako na stanovení dobře vybaveného vysokého tábora před poslední výšlapem na vrchol umožňují tato základní vylepšení delší, ambicióznější kreativní cesty, které se nám otevírají.

Konzistence postav není jen technickou metrikou—je základem vizuálního vyprávění. A v roce 2025 se ten základ konečně stane dostatečně pevný na to, aby se na něm dalo stavět.