Karaktärskonsekvens i AI-video: Hur modeller minns ansikten

En av de mest ihållande utmaningarna inom AI-videogenerering har varit att upprätthålla karaktärskonsekvens mellan tagningar. Fråga vilken filmskapare som helst: en berättelse faller sönder i samma ögonblick som huvudpersonens ansikte subtilt förändras mellan klipp. Under 2025 har vi äntligen sett modeller lösa detta problem med arkitektoniska innovationer som känns lika eleganta som en välplanerad led uppför en svår topp. Låt mig gå igenom hur moderna videomodeller lär sig att minnas ansikten.

Konsekvensutmaningen

Traditionella diffusionsmodeller genererar varje bildruta med probabilistisk sampling. Det introducerar variation, vilket är användbart för mångfald men problematiskt för identitet. När modellen genererar en 10 sekunder lång video i 24fps fattar den 240 sekventiella beslut, vart och ett med möjligheter till avdrift.

# The core problem: each denoising step introduces variance
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # This sampling introduces stochasticity
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Slight variations accumulate over frames

Tidiga videomodeller som Gen-1 och Pika 1.0 hade synliga svårigheter med detta. Karaktärer skiftade i utseende, åldrades något mellan tagningar eller utvecklade inkonsekventa drag, det som yrkesutövare kallade "identitetsavdrift". Genombrottet kom genom att behandla karaktärskonsekvens som ett arkitektoniskt problem snarare än ett efterbearbetningsproblem.

Identitetsbevarande inbäddningar: Grunden

Den första stora innovationen var att införa dedikerade identitetsinbäddningar som består genom hela genereringsprocessen. I stället för att enbart förlita sig på textkonditionering behåller modeller nu explicita identitetstoken:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Pre-trained face model
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Extract identity features from reference
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Cross-attend with learned identity tokens
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Dessa identitetstoken injiceras sedan i diffusionsprocessen vid varje avbrusningssteg och skapar vad jag gärna ser som "ankarpunkter", ungefär som fasta säkringar på en klätterled som du alltid kan klippa tillbaka i när förhållandena blir osäkra.

Uppmärksamhet mellan bildrutor: Att lära sig tidsmässig identitet

Det andra genombrottet var arkitektoniskt: modeller uppmärksammar nu uttryckligen flera bildrutor när de fattar beslut om karaktärers utseende. Diffusion transformers stöder detta naturligt genom sin bearbetning av rumtidsfläckar, men modeller med fokus på konsekvens går längre.

Viktig innovation: Dedikerade identitetsuppmärksamhetslager som specifikt fokuserar på ansiktsregioner över tidsdimensionen:

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):
        # Standard spatial attention within frames
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Temporal attention across frames
        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)
 
        # Identity-specific attention using face regions
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

Denna mekanism med trippel uppmärksamhet, som kombinerar rumslig, tidsmässig och identitetsspecifik uppmärksamhet, gör det möjligt för modellen att fatta beslut om utseende samtidigt som den uttryckligen hänvisar till både den etablerade identiteten och tidigare bildrutor.

Jämförelse av nuvarande modellmetoder

De stora plattformarna för videogenerering har implementerat karaktärskonsekvens på olika sätt:

Runways Gen-4.5 förtjänar särskilt omnämnande här. Deras metod kombinerar konditionering med referensbilder med vad de kallar "identity locks", inlärda token som modellen tränas att bevara oavsett andra generativa beslut. Detta arkitektoniska val bidrog sannolikt till deras dominans i Video Arena.

Paradigmet med referensbilder

En betydande förändring under 2025 har varit övergången till referenskonditionerad generering. I stället för att generera karaktärer enbart från textbeskrivningar accepterar modeller nu referensbilder som fastställer ett kanoniskt utseende:

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 identity from reference images
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Pool multiple references for robust identity
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Generate with identity conditioning
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Balances consistency vs creativity
            }
        )
        return video

Parametern identity_strength representerar en viktig avvägning. Om den är för hög blir modellen stel och kan inte visa naturliga variationer i uttryck. Om den är för låg återkommer avdriften. Att hitta den optimala nivån, vanligtvis omkring 0.7-0.85, är delvis konst och delvis vetenskap.

Förlustfunktioner för identitetsbevarande

Att träna dessa system kräver specialiserade förlustfunktioner som uttryckligen straffar identitetsavdrift:

Förlust för identitetsbevarande:

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

Där f är en förtränad ansiktsigenkänningsencoder, G är generatorn och v_t representerar genererade bildrutor. Den första termen säkerställer att genererade ansikten matchar referenser, den andra straffar variation mellan bildrutor.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Per-frame identity matching to reference
    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()
 
    # Temporal consistency between adjacent frames
    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

Scenarier med flera karaktärer: Det svårare problemet

Konsekvens för en enskild karaktär är till stor del löst. Scenarier med flera karaktärer, där flera distinkta identiteter måste upprätthållas samtidigt, är fortfarande utmanande. Uppmärksamhetsmekanismerna kan sammanblanda identiteter, vilket leder till att drag läcker mellan karaktärer.

Nuvarande metoder använder separata identitetsbanker:

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)
            # Add separator to prevent conflation
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Separationstoken fungerar som säkringar mellan klättrare och upprätthåller skilda identiteter även när de befinner sig nära varandra.

Praktiska konsekvenser för kreatörer

För dem som använder dessa verktyg snarare än bygger dem har flera praktiska mönster framträtt:

Referensbilders kvalitet

Referensbilder med högre upplösning, god belysning och neutrala uttryck ger mer konsekventa resultat. Modellen lär sig identitet från dessa ankare, och brus fortplantas.

Flera referenser

Att tillhandahålla 3-5 referensbilder från olika vinklar hjälper modellen att skapa en mer komplett identitetsrepresentation. Se det som att triangulera en position från flera punkter.

Promptar som beskriver identitet

Tydliga identitetsbeskrivningar i promptar förstärker visuell konsekvens. "En 30-årig kvinna med kort brunt hår och gröna ögon" ger ytterligare begränsningar som modellen kan använda.

Så här sätter du upp en tagning, steg för steg

1. Steg 1: välj en referensbildruta där ansiktet är jämnt belyst och uttrycket är neutralt, och behåll den som ankare för varje tagning i sekvensen.
2. Steg 2: lägg till två till fyra ytterligare referenser från andra vinklar, så att identitetsinbäddningen trianguleras i stället för att extrapoleras från en enda vy.
3. Steg 3: beskriv identiteten i prompten med samma ord varje gång, eftersom en beskrivning som förändras mellan tagningar återinför den variation som referenserna tog bort.
4. Steg 4: generera ett kort test före hela sekvensen och jämför första och sista bildrutan, eftersom avdrift ackumuleras och är billigast att upptäcka vid tio sekunder snarare än vid nittio.

Vägen framåt

Vi närmar oss en tröskel där AI-genererad video kan upprätthålla tillräcklig karaktärskonsekvens för narrativt berättande. De återstående utmaningarna, inklusive konsekvens i subtila uttryck, långformsgenerering bortom 60 sekunder och interaktion mellan flera karaktärer, hanteras aktivt.

På Bonega.ai är vi särskilt intresserade av hur dessa förbättringar i konsekvens integreras med funktioner för videoförlängning. Möjligheten att förlänga befintligt material och samtidigt bibehålla perfekt karaktärskonsekvens öppnar kreativa möjligheter som helt enkelt inte var genomförbara för 12 månader sedan.

Den matematiska elegansen i att behandla identitet som ett förstahandsproblem i arkitekturen, snarare än en korrigering i efterhand, markerar en mognad i hur vi tänker på videogenerering. Liksom att etablera ett välutrustat högläger före ett toppförsök möjliggör dessa grundläggande förbättringar de längre och mer ambitiösa kreativa resor som ligger framför oss.

Karaktärskonsekvens är inte bara ett tekniskt mått. Det är grunden för visuellt berättande. Och under 2025 har den grunden äntligen blivit tillräckligt stabil att bygga vidare på.

Vad du ska använda, och när

En identitetsinbäddning är en kompakt vektor som kodar vem ett ansikte tillhör snarare än hur det såg ut i en bildruta, och att välja ett verktyg innebär att välja hur det hanterar den vektorn.

• Korta narrativa tagningar med en återkommande karaktär: en modell med referensbildruta är rätt val. Det är metoden som bevarar identitet mest tillförlitligt under tio sekunder, och ankarbildrutan ger dig något konkret att iterera på när en tagning blir fel.
• Sekvenser längre än en minut: förvänta dig avdrift oavsett modell och planera för klipp. Att generera kortare segment och sammanfoga dem tar mindre tid än att kämpa med en enda lång rendering som försämras i sin sista tredjedel.
• Två eller fler karaktärer i bild: utgå från att identitetsläckage är standardutfallet och testa det tidigt, eftersom felet inte är gradvis. Separera karaktärerna mellan tagningar där redigeringen tillåter det.
• Fotorealistisk likhet med en verklig person: ingen av dessa metoder är tillräckligt tillförlitlig för att lova en kund, och den juridiska exponeringen är ett separat problem från det tekniska.

Den ärliga sammanfattningen är att identitet nu är löst tillräckligt väl för berättande, men ännu inte tillräckligt väl för obevakad produktion. Om din sekvens är kort, har en enda karaktär och du kan granska varje tagning kommer dessa modeller att hålla ihop. Om något av dessa tre inte stämmer, budgetera för omtagningar.