Consistència de personatges en vídeo AI: Com els models estan aprenent a recordar cares

Un dels reptes més persistents en la generació de vídeo AI ha estat mantenir la consistència dels personatges a través dels talls. Pregunta-ho a qualsevol cineasta: una història es desmorona en el moment en què la cara del teu protagonista canvia subtilment entre talls. El 2025, finalment hem vist models resoldre aquest problema amb innovacions arquitectòniques que semblen tan elegants com una ruta ben planificada per un pic difícil. Deixa'm guiar-te per com els models de vídeo moderns estan aprenent a recordar cares.

El repte de la consistència

Els models tradicionals de difusió generen cada fotograma amb mostreig probabilístic. Això introdueix variància, útil per a la diversitat, problemàtica per a la identitat. Quan generes un vídeo de 10 segons a 24fps, el model pren 240 decisions seqüencials, cadascuna amb oportunitats per a la deriva.

# El problema central: cada pas de reducció de soroll introdueix variància
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # Aquest mostreig introdueix estocasticitat
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Lleugeres variacions s'acumulen sobre fotogrames

Els primers models de vídeo com Gen-1 i Pika 1.0 lluiten visiblement amb això. Els personatges canviarien d'aparença, envellirien lleugerament entre talls o desenvoluparien característiques inconsistents, el que els professionals anomenen "deriva d'identitat". L'avenç va venir de tractar la consistència dels personatges no com un problema de postprocessament, sinó com un problema arquitectònic.

Incrustacions que preserven la identitat: La base

La primera innovació important va ser introduir incrustacions d'identitat dedicades que persisteixen durant el procés de generació. En lloc de dependre únicament del condicionament de text, els models ara mantenen tokens d'identitat explícits:

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Model de cara pre-entrenat
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Extreure característiques d'identitat de la referència
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Atenció creuada amb tokens d'identitat apresos
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Aquests tokens d'identitat s'injecten després al procés de difusió a cada pas de reducció de soroll, creant el que m'agrada pensar com a "punts d'ancoratge", com una protecció fixa en una ruta d'escalada a la qual sempre pots enganxar-te quan les condicions es tornen incertes.

Atenció entre fotogrames: Aprenent identitat temporal

El segon avenç va ser arquitectònic: els models ara atenen explícitament entre fotogrames quan prenen decisions sobre l'aparença dels personatges. Els transformers de difusió suporten això naturalment mitjançant el seu processament de pegats espai-temporals, però els models centrats en la consistència van més enllà.

Innovació clau: Capes d'atenció d'identitat dedicades que atenen específicament a regions facials a través de la 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):
        # Atenció espacial estàndard dins dels fotogrames
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Atenció temporal a través dels fotogrames
        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)
 
        # Atenció específica d'identitat utilitzant regions facials
        face_tokens = x * face_masks.unsqueeze(-1)
        x = self.identity_attn(
            query=x,
            key=identity_tokens,
            value=identity_tokens
        )[0] + x
 
        return x

Aquest mecanisme d'atenció triple (espacial, temporal i específic d'identitat) permet al model prendre decisions d'aparença mentre fa referència explícitament tant a la identitat establerta com als fotogrames anteriors.

Comparació d'enfocaments de models actuals

Les principals plataformes de generació de vídeo han implementat la consistència de personatges de manera diferent:

Gen-4.5 de Runway mereix una menció especial aquí. El seu enfocament combina condicionament d'imatge de referència amb el que anomenen "bloquejos d'identitat", tokens apresos que el model està entrenat per preservar independentment d'altres decisions generatives. Aquesta elecció arquitectònica probablement va contribuir al seu domini del Video Arena.

El paradigma del fotograma de referència

Un canvi significatiu el 2025 ha estat el moviment cap a la generació condicionada per referència. En lloc de generar personatges purament a partir de descripcions de text, els models ara accepten imatges de referència que estableixen l'aparença canònica:

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):
        # Codificar identitat a partir d'imatges de referència
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Agrupar múltiples referències per a identitat robusta
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Generar amb condicionament d'identitat
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Equilibra consistència vs creativitat
            }
        )
        return video

El paràmetre identity_strength representa un equilibri important. Massa alt, i el model esdevé rígid, incapaç de mostrar variació d'expressió natural. Massa baix, i la deriva torna. Trobar el punt òptim (típicament al voltant de 0.7-0.85) és part art, part ciència.

Funcions de pèrdua per a la preservació d'identitat

Entrenar aquests sistemes requereix funcions de pèrdua especialitzades que penalitzen explícitament la deriva d'identitat:

Pèrdua de preservació d'identitat:

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

On f és un codificador de reconeixement facial pre-entrenat, G és el generador, i v_t representa fotogrames generats. El primer terme assegura que les cares generades coincideixin amb les referències, el segon penalitza la variació fotograma a fotograma.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Correspondència d'identitat per fotograma amb referència
    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()
 
    # Consistència temporal entre fotogrames adjacents
    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

Escenaris multi-personatge: El problema més difícil

La consistència d'un sol personatge està en gran part resolta. Els escenaris multi-personatge, on s'han de mantenir múltiples identitats distintes simultàniament, segueixen sent un repte. Els mecanismes d'atenció poden barrejar identitats, portant a la confusió de característiques entre personatges.

Els enfocaments actuals utilitzen bancs d'identitat separats:

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)
            # Afegir separador per prevenir confusió
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Els tokens separadors actuen com assegurances entre escaladors, mantenint identitats distintes fins i tot quan operen en proximitat propera.

Implicacions pràctiques per als creadors

Per a aquells que utilitzen aquestes eines en lloc de construir-les, han sorgit diversos patrons pràctics:

La qualitat de la imatge de referència importa: Imatges de referència d'alta resolució, ben il·luminades amb expressions neutres produeixen resultats més consistents. El model aprèn identitat d'aquestes àncores, i el soroll es propaga.

Múltiples referències milloren la robustesa: Proporcionar 3-5 imatges de referència des de diferents angles ajuda el model a construir una representació d'identitat més completa. Pensa-ho com triangular una posició des de múltiples punts.

Enginyeria de prompts per a la consistència: Les descripcions d'identitat explícites en prompts reforcen la consistència visual. "Una dona de 30 anys amb cabells curts marrons i ulls verds" proporciona restriccions addicionals que el model pot aprofitar.

El camí per endavant

Ens estem apropant a un llindar on el vídeo generat per IA pot mantenir una consistència de personatges suficient per a la narració narrativa. Els reptes restants (consistència d'expressió subtil, generació de llarga durada més enllà de 60 segons i interacció multi-personatge) s'estan abordant activament.

A Bonega.ai, estem particularment interessats en com aquestes millores de consistència s'integren amb capacitats d'extensió de vídeo. La capacitat d'estendre imatges existents mentre es manté una consistència de personatges perfecta obre possibilitats creatives que simplement no eren factibles fa 12 mesos.

L'elegància matemàtica de tractar la identitat com una preocupació arquitectònica de primera classe, en lloc d'una correcció post-hoc, marca una maduració en com pensem sobre la generació de vídeo. Com establir un camp alt ben abastit abans d'un intent de cim, aquestes millores fonamentals permeten els viatges creatius més llargs i ambiciosos que tenim per endavant.

La consistència de personatges no és només una mètrica tècnica, és la base de la narració visual. I el 2025, aquesta base finalment s'ha tornat prou sòlida per construir-hi.