Cohérence des personnages dans la vidéo IA : comment les modèles mémorisent les visages

L'un des défis les plus persistants de la génération de vidéo par IA a été de maintenir la cohérence des personnages d'un plan à l'autre. Demandez à n'importe quel cinéaste : une histoire s'effondre dès que le visage de votre protagoniste change subtilement entre deux coupes. En 2025, nous avons enfin vu des modèles résoudre ce problème grâce à des innovations architecturales aussi élégantes qu'un itinéraire bien préparé sur un sommet difficile. Voyons comment les modèles vidéo modernes apprennent à mémoriser les visages.

Le défi de la cohérence

Les modèles de diffusion traditionnels génèrent chaque image par échantillonnage probabiliste. Cela introduit de la variance, utile pour la diversité mais problématique pour l'identité. Lors de la génération d'une vidéo de 10 secondes à 24 fps, le modèle prend 240 décisions séquentielles, chacune offrant une possibilité de dérive.

# 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

Les premiers modèles vidéo comme Gen-1 et Pika 1.0 rencontraient visiblement ce problème. Les personnages changeaient d'apparence, vieillissaient légèrement entre les plans ou développaient des traits incohérents, ce que les praticiens appelaient une « dérive d'identité ». La percée est venue du fait de considérer la cohérence des personnages non comme un problème de post-traitement, mais comme un problème architectural.

Embeddings préservant l'identité : la base

La première innovation majeure a été l'introduction d'embeddings d'identité dédiés, qui persistent tout au long du processus de génération. Au lieu de s'appuyer uniquement sur le conditionnement textuel, les modèles conservent désormais des jetons d'identité explicites :

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

Ces jetons d'identité sont ensuite injectés dans le processus de diffusion à chaque étape de débruitage, créant ce que j'aime considérer comme des « points d'ancrage », à l'image de protections fixes sur une voie d'escalade auxquelles vous pouvez toujours vous reconnecter lorsque les conditions deviennent incertaines.

Attention inter-images : apprendre l'identité temporelle

La deuxième percée était architecturale : les modèles prêtent désormais explicitement attention aux différentes images lorsqu'ils prennent des décisions sur l'apparence des personnages. Les transformers de diffusion le permettent naturellement grâce à leur traitement de patchs spatio-temporels, mais les modèles axés sur la cohérence vont plus loin.

Innovation clé : des couches d'attention dédiées à l'identité, qui se concentrent spécifiquement sur les régions faciales dans la dimension temporelle :

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

Ce mécanisme de triple attention, qui associe attention spatiale, temporelle et spécifique à l'identité, permet au modèle de prendre des décisions d'apparence en se référant explicitement à la fois à l'identité établie et aux images précédentes.

Comparaison des approches des modèles actuels

Les principales plateformes de génération vidéo ont mis en œuvre la cohérence des personnages de manières différentes :

Gen-4.5 de Runway mérite une mention particulière. Leur approche associe le conditionnement par image de référence à ce qu'ils appellent des « verrous d'identité », des jetons appris que le modèle est entraîné à préserver quelles que soient les autres décisions génératives. Ce choix architectural a probablement contribué à leur domination dans Video Arena.

Le paradigme de l'image de référence

Un changement important en 2025 a été l'évolution vers la génération conditionnée par référence. Au lieu de générer les personnages uniquement à partir de descriptions textuelles, les modèles acceptent maintenant des images de référence qui définissent une apparence canonique :

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

Le paramètre identity_strength représente un compromis important. Trop élevé, le modèle devient rigide et incapable de montrer des variations naturelles d'expression. Trop faible, la dérive revient. Trouver le bon équilibre, généralement autour de 0.7-0.85, relève à la fois de l'art et de la science.

Fonctions de perte pour préserver l'identité

L'entraînement de ces systèmes nécessite des fonctions de perte spécialisées qui pénalisent explicitement la dérive d'identité :

Perte de préservation de l'identité :

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

Ici, f est un encodeur de reconnaissance faciale pré-entraîné, G est le générateur, et v_t représente les images générées. Le premier terme garantit que les visages générés correspondent aux références ; le second pénalise les variations d'une image à l'autre.

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

Scénarios avec plusieurs personnages : le problème le plus difficile

La cohérence pour un seul personnage est largement résolue. Les scénarios avec plusieurs personnages, où plusieurs identités distinctes doivent être préservées simultanément, restent difficiles. Les mécanismes d'attention peuvent confondre les identités, entraînant un mélange de caractéristiques entre les personnages.

Les approches actuelles utilisent des banques d'identité séparées :

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)

Les jetons séparateurs agissent comme des systèmes d'assurage entre les grimpeurs, maintenant des identités distinctes même lorsqu'ils évoluent à proximité les uns des autres.

Implications pratiques pour les créateurs

Pour les personnes qui utilisent ces outils plutôt que de les construire, plusieurs pratiques efficaces se sont dégagées :

Qualité de l'image de référence

Des images de référence en haute résolution, bien éclairées et avec des expressions neutres produisent des résultats plus cohérents. Le modèle apprend l'identité à partir de ces ancrages, et le bruit se propage.

Références multiples

Fournir 3-5 images de référence sous différents angles aide le modèle à construire une représentation plus complète de l'identité. C'est comme trianguler une position à partir de plusieurs points.

Prompts décrivant l'identité

Des descriptions d'identité explicites dans les prompts renforcent la cohérence visuelle. « Une femme de 30 ans aux cheveux bruns courts et aux yeux verts » apporte des contraintes supplémentaires que le modèle peut exploiter.

Comment préparer un plan, étape par étape

1. Étape 1 : choisissez une image de référence où le visage est uniformément éclairé et l'expression neutre, puis conservez-la comme ancrage pour chaque plan de la séquence.
2. Étape 2 : ajoutez deux à quatre références sous d'autres angles, afin que l'embedding d'identité soit triangulé plutôt qu'extrapolé depuis une seule vue.
3. Étape 3 : décrivez l'identité avec les mêmes mots dans le prompt à chaque fois, car une description qui varie entre les plans réintroduit la variance que les références avaient éliminée.
4. Étape 4 : générez un test court avant la séquence complète et comparez la première et la dernière image, car la dérive s'accumule et coûte moins cher à détecter à dix secondes qu'à quatre-vingt-dix.

La suite

Nous approchons d'un seuil où la vidéo générée par IA peut maintenir une cohérence de personnage suffisante pour une narration. Les défis restants, notamment la cohérence des expressions subtiles, la génération longue au-delà de 60 secondes et l'interaction entre plusieurs personnages, font l'objet de travaux actifs.

Chez Bonega.ai, nous nous intéressons particulièrement à la manière dont ces améliorations de cohérence s'intègrent aux capacités d'extension vidéo. La possibilité d'étendre des séquences existantes tout en préservant une cohérence parfaite des personnages ouvre des possibilités créatives qui n'étaient tout simplement pas réalisables il y a 12 mois.

L'élégance mathématique consistant à traiter l'identité comme une préoccupation architecturale de premier ordre, plutôt que comme une correction a posteriori, marque une maturation de notre manière de penser la génération vidéo. Comme l'établissement d'un camp d'altitude bien approvisionné avant l'assaut final, ces améliorations fondamentales permettent les parcours créatifs plus longs et plus ambitieux qui nous attendent.

La cohérence des personnages n'est pas seulement une métrique technique. C'est le fondement de la narration visuelle. Et en 2025, ce fondement est enfin devenu suffisamment solide pour bâtir dessus.

Quoi utiliser, et quand

Un embedding d'identité est un vecteur compact qui encode à qui appartient un visage plutôt que son apparence dans une image donnée, et choisir un outil revient à choisir la manière dont il gère ce vecteur.

• Plans narratifs courts avec un personnage récurrent : un modèle à image de référence est le bon choix. C'est l'approche qui préserve l'identité avec le plus de fiabilité sur moins de dix secondes, et l'image d'ancrage vous donne un élément concret sur lequel itérer lorsqu'une prise échoue.
• Séquences de plus d'une minute : attendez-vous à une dérive, quel que soit le modèle, et prévoyez des coupes. Générer des segments plus courts puis les assembler demande moins de temps que de lutter contre un rendu long unique qui se dégrade dans son dernier tiers.
• Deux personnages ou plus dans le cadre : considérez la fuite d'identité comme le résultat par défaut et testez-la tôt, car l'échec n'est pas progressif. Séparez les personnages entre les plans partout où le montage le permet.
• Ressemblance photoréaliste avec une personne réelle : aucune de ces méthodes n'est suffisamment fiable pour être promise à un client, et l'exposition juridique est un problème distinct du problème technique.

Le résumé honnête est que l'identité est maintenant suffisamment bien résolue pour la narration, mais pas encore assez pour une production sans supervision. Si votre séquence est courte, ne comporte qu'un personnage et que vous pouvez vérifier chaque plan, ces modèles tiendront. Si l'une de ces trois conditions n'est pas remplie, prévoyez des reprises.