La cohérence des personnages dans la vidéo IA : comment les modèles apprennent à mémoriser les visages

L'une des difficultés les plus persistantes de la génération vidéo par IA a été le maintien de la cohérence des personnages dans les différents plans. Demandez à n'importe quel réalisateur : une histoire s'effondre au moment où le visage de votre protagoniste change subtilement entre les coupes. En 2025, nous avons enfin vu des modèles résoudre ce problème avec des innovations architecturales qui sont aussi élégantes qu'une route bien planifiée vers un sommet difficile. Laissez-moi vous montrer 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 avec un échantillonnage probabiliste. Cela introduit une variance—utile pour la diversité, problématique pour l'identité. Lors de la génération d'une vidéo de 10 secondes à 24fps, le modèle prend 240 décisions séquentielles, chacune offrant des opportunités de dérive.

# Le problème fondamental : chaque étape de débruitage introduit de la variance
def denoise_step(x_t, model, t):
    noise_pred = model(x_t, t)
    # Cet échantillonnage introduit de la stochasticité
    x_t_minus_1 = scheduler.step(noise_pred, t, x_t).prev_sample
    return x_t_minus_1  # Les légères variations s'accumulent au fil des images

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

Les plongements préservant l'identité : la fondation

La première grande innovation a été l'introduction de plongements d'identité dédiés qui persistent tout au long du processus de génération. Plutôt que de s'appuyer uniquement sur le conditionnement textuel, les modèles maintiennent désormais des tokens d'identité explicites :

class IdentityEncoder(nn.Module):
    def __init__(self, embed_dim=768):
        super().__init__()
        self.face_encoder = FaceRecognitionBackbone()  # Modèle de visage pré-entraîné
        self.projection = nn.Linear(512, embed_dim)
        self.identity_bank = nn.Parameter(torch.randn(32, embed_dim))
 
    def encode_identity(self, reference_frame):
        # Extraire les caractéristiques d'identité de la référence
        face_features = self.face_encoder(reference_frame)
        identity_embed = self.projection(face_features)
 
        # Attention croisée avec les tokens d'identité appris
        identity_tokens = self.cross_attention(
            query=self.identity_bank,
            key=identity_embed,
            value=identity_embed
        )
        return identity_tokens

Ces tokens d'identité sont ensuite injectés dans le processus de diffusion à chaque étape de débruitage, créant ce que j'aime appeler des « points d'ancrage »—comme une protection fixe sur une voie d'escalade à laquelle vous pouvez toujours vous assurer quand les conditions deviennent incertaines.

L'attention inter-images : apprendre l'identité temporelle

La deuxième percée était architecturale : les modèles font désormais explicitement attention aux images à travers les plans quand ils prennent des décisions sur l'apparence des personnages. Les transformers de diffusion supportent naturellement cela grâce à leur traitement des patchs spatiotemporels, 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 font spécifiquement attention aux régions faciales selon 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):
        # Attention spatiale standard au sein des images
        x = self.spatial_attn(x, x, x)[0] + x
 
        # Attention temporelle entre les images
        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)
 
        # Attention spécifique à l'identité utilisant les régions faciales
        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 triple-attention—spatiale, temporelle, et spécifique à l'identité—permet au modèle de prendre des décisions d'apparence tout en référençant explicitement à la fois l'identité établie et les images précédentes.

Comparaison des approches des modèles actuels

Les principales plateformes de génération vidéo ont implémenté la cohérence des personnages de manières différentes :

Gen-4.5 de Runway mérite une mention particulière ici. Leur approche combine le conditionnement par image de référence avec ce qu'ils appellent les « verrous d'identité »—des tokens appris que le modèle est entraîné à préserver indépendamment des autres décisions génératives. Ce choix architectural a probablement contribué à leur domination de l'arène vidéo.

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

Un changement significatif en 2025 a été le passage vers une génération conditionnée par référence. Plutôt que de générer des personnages purement à partir de descriptions textuelles, les modèles acceptent désormais des images de référence qui établissent l'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):
        # Encoder l'identité à partir des images de référence
        identity_embeds = []
        for ref in reference_images:
            identity_embeds.append(self.identity_encoder(ref))
 
        # Mélanger plusieurs références pour une identité robuste
        identity_tokens = torch.stack(identity_embeds).mean(dim=0)
 
        # Générer avec le conditionnement d'identité
        video = self.model.generate(
            prompt=prompt,
            num_frames=num_frames,
            cross_attention_kwargs={
                "identity_tokens": identity_tokens,
                "identity_strength": 0.8  # Équilibre la cohérence et la créativité
            }
        )
        return video

Le paramètre identity_strength représente un compromis important. Trop élevé, et le modèle devient rigide, incapable de montrer une variation d'expression naturelle. Trop bas, et la dérive revient. Trouver l'équilibre optimal—généralement autour de 0,7-0,85—est en partie art, en partie science.

Les fonctions de perte pour la préservation de 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 d'identité :

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

Où 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 la variation d'image à image.

def identity_preservation_loss(generated_video, reference_faces, face_encoder):
    # Appariement d'identité par image à la référence
    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()
 
    # Cohérence temporelle entre les images adjacentes
    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

Les scénarios multi-personnages : le problème plus difficile

La cohérence d'un seul personnage est largement résolue. Les scénarios multi-personnages—où plusieurs identités distinctes doivent être maintenues simultanément—restent difficiles. Les mécanismes d'attention peuvent confondre les identités, ce qui conduit à un saignement de traits 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)
            # Ajouter un séparateur pour éviter la confusion
            char_tokens = torch.cat([char_tokens, self.character_separator])
            all_tokens.append(char_tokens)
        return torch.cat(all_tokens, dim=0)

Les tokens séparateurs agissent comme des points d'assurage entre les grimpeurs—maintenant des identités distinctes même en opérant à proximité les unes des autres.

Les implications pratiques pour les créateurs

Pour ceux qui utilisent ces outils plutôt que de les construire, plusieurs modèles pratiques ont émergé :

La qualité de l'image de référence est importante : Les images de référence à plus haute résolution, bien éclairées, avec des expressions neutres produisent des résultats plus cohérents. Le modèle apprend l'identité de ces ancres, et le bruit se propage.

Les références multiples améliorent la robustesse : Fournir 3-5 images de référence sous différents angles aide le modèle à construire une représentation d'identité plus complète. Pensez-y comme triangulation d'une position à partir de plusieurs points.

L'ingénierie des requêtes pour la cohérence : Les descriptions d'identité explicites dans les requêtes renforcent la cohérence visuelle. « Une femme de 30 ans avec des cheveux courts bruns et des yeux verts » fournit des contraintes supplémentaires que le modèle peut exploiter.

La route à venir

Nous nous rapprochons d'un seuil où la vidéo générée par IA peut maintenir une cohérence des personnages suffisante pour la narration. Les défis restants—la cohérence subtile de l'expression, la génération long-forme au-delà de 60 secondes, et l'interaction multi-personnages—sont activement abordés.

Chez Bonega.ai, nous nous intéressons particulièrement à la façon dont ces améliorations de cohérence s'intègrent avec les capacités d'extension vidéo. La capacité à étendre le contenu existant tout en maintenant une cohérence parfaite des personnages ouvre des possibilités créatives qui simplement n'étaient pas réalisables il y a 12 mois.

L'élégance mathématique de traiter l'identité comme une préoccupation architecturale de première classe, plutôt qu'une correction ad hoc, marque une maturation de notre façon de penser la génération vidéo. Comme l'établissement d'un camp haut bien approvisionné avant une tentative de sommet, ces améliorations fondamentales permettent les voyages 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 la fondation de la narration visuelle. Et en 2025, cette fondation est enfin devenue suffisamment solide pour construire dessus.