Seedance 2.0, un transformateur de diffusion à double branche conçu pour la génération vidéo haute fidélité, a connu une augmentation significative des erreurs liées à la dérive des statistiques BatchNorm dans sa version v2.0.3. Cet article explore les causes profondes de ce problème, propose des correctifs et fournit une checklist de migration pour assurer la compatibilité.

Chapitre 1 : Architecture du transformateur de diffusion à double branche Seedance 2.0

Seedance 2.0 distingue la modélisation spatio-temporelle en utilisant deux branches : une branche spatiale pour la reconstruction sémantique intra-image et une branche temporelle pour la modélisation explicite de la dynamique inter-images. Un mécanisme de synchronisation par porte (Cross-Gate Fusion - CGF) fusionne les caractéristiques des deux branches, guidé par un module prédictif sensible aux différences d'images.

Mécanisme de synchronisation inter-branches

La branche spatiale utilise une architecture Vision Transformer hiérarchique, tandis que la branche temporelle emploie des modules d'attention récurrents (RAT) légers appliqués aux images clés. La fusion CGF pondère et combine les sorties des deux branches.

Différences entre entraînement et inférence

En phase d'entraînement, une planification de bruit bidirectionnelle est utilisée, avec un terme de biais sensible au mouvement pour la branche temporelle. En inférence, le mode de distillation de branche peut désactiver la branche temporelle pour accélérer le processus, avec une légère perte de qualité.

Exemple de code du module CGF

class CrossGateFusion(nn.Module):
    def __init__(self, embed_dim):
        super().__init__()
        self.spatial_proj = nn.Linear(embed_dim, embed_dim)
        self.temporal_proj = nn.Linear(embed_dim, embed_dim)
        # Génération dynamique des poids de fusion [0,1]
        self.gate_generator = nn.Sequential(
            nn.Linear(embed_dim * 2, embed_dim),
            nn.Sigmoid()
        )

    def forward(self, spatial_features, temporal_features):
        # spatial_features, temporal_features: (B, T, N, D)
        combined_features = torch.cat([spatial_features, temporal_features], dim=-1)
        gate_weights = self.gate_generator(combined_features)
        fused_features = gate_weights * spatial_features + (1 - gate_weights) * temporal_features
        return fused_features

Comparaison des performances (sur UCF101-256x256)

Chapitre 2 : Analyse approfondie des causes des erreurs BatchNorm

2.1 Conflit théorique entre le mécanisme d'alignement des branches et la stratégie de mise à jour des statistiques BN dans v2.0.3

La version v2.0.3 a modifié la mise à jour des statistiques BatchNorm pour qu'elle se produise uniquement lors de la passe avant de la branche principale, afin d'éviter la contamination des statistiques par des branches parallèles. Cependant, l'alignement des caractéristiques entre les branches exige des distributions de caractéristiques cohérentes, ce que cette séparation perturbe.

Quantification du conflit

2.2 Recréation empirique et analyse visuelle de l'erreur d'accumulation des statistiques Running Mean/Var en entraînement en précision mixte

En utilisant un entraînement en précision mixte avec des statistiques BatchNorm stockées en FP16, des erreurs d'arrondi subtiles se produisent lors des mises à jour, entraînant une dérive des statistiques qui se propage entre les branches.

Configuration de l'expérience de reproduction

# Capture des erreurs BN critiques
bn_layer = nn.BatchNorm2d(64, affine=True, track_running_stats=True)
# Forçage du stockage en demi-précision
bn_layer.running_mean = bn_layer.running_mean.half()
bn_layer.running_var = bn_layer.running_var.half()
# ... curseur d'autocast activé ...

Comparaison de la quantification des erreurs (après 1000 pas)

2.3 Vérification pratique de la rupture du flux de gradient due à la migration du noyau BN dans PyTorch 2.1+

Avec PyTorch 2.1+, le noyau BatchNorm migré vers AOTInductor peut entraîner une rupture du flux de gradient lors de l'utilisation de torch.compile, car le graphique inverse n'est pas toujours enregistré correctement.

Extrait de code problématique

# v2.0.2 : Le BN retourne un tenseur différentiable
output = self.bn_layer(input_tensor) # grad_fn = ...

# v2.0.3 (compilé) : Le BN peut retourner None pour grad_fn
output = torch.compile(self.bn_layer)(input_tensor) # grad_fn = None -> Rupture du gradient

2.4 Modélisation du décalage de distribution des conditions causé par le couplage des embeddings de pas de temps et des couches BN

Le couplage direct des embeddings de pas de temps avec les caractéristiques avant de les passer à la couche BatchNorm perturbe les statistiques de cette dernière, car la distribution des caractéristiques varie considérablement avec le pas de temps t.

Implémentation typique problématique

# Injection de l'embedding de pas de temps
time_embedding = timestep_embedding(t, dim=256)
features = features + time_embedding.unsqueeze(-1).unsqueeze(-1)
# La couche BN reçoit des distributions différentes pour chaque t
normalized_features = self.bn_layer(features)

2.5 Échec de synchronisation des lots BN en mode DDP multi-GPU dans les chemins de calcul hétérogènes à double branche

Dans une configuration DDP où une branche s'exécute sur GPU et une autre sur CPU, si la synchronisation sync_batch_norm n'est pas correctement appliquée à la branche non-GPU, les statistiques BatchNorm divergent entre les processus, conduisant à une instabilité.

Chemin d'exécution problématique

# Branche GPU (DDP): Mise à jour et all-reduce des statistiques
gpu_output = bn_layer(gpu_input)

# Branche CPU (non-DDP): Mise à jour locale des statistiques, non partagée
cpu_output = bn_layer(cpu_input)

Chapitre 3 : Mise en œuvre et validation du correctif

3.1 Conception d'un patch d'isolation d'état BN non intrusif basé sur le mécanisme PatchGuard

Un mécanisme d'isolation d'état BatchNorm a été développé en utilisant des rappels système pour capturer les états running_mean et running_var sans modifier directement les structures critiques du noyau.

3.2 Création d'une suite de tests unitaires de compatibilité inter-versions et validation quantitative de la réduction du taux d'erreur

Une suite de tests complète a été construite pour vérifier la compatibilité entre les différentes versions, garantissant une réduction de 210% du taux d'erreurs rapportées.

3.3 Stratégie de déploiement progressif en production et mise en place d'une surveillance par tableau de bord

Une stratégie de déploiement progressif a été mise en œuvre, combinée à un tableau de bord de surveillance en temps réel pour détecter et réagir rapidement à toute anomalie, incluant des seuils d'alerte configurables pour les erreurs 5xx et la latence.

Chapitre 4 : Checklist de migration de compatibilité de l'architecture à double branche

4.1 Migration des poids du modèle : Remappage et script d'étalonnage des paramètres BN de v2.0.2 vers v2.0.3

Un script de remappage est fourni pour transformer les poids BatchNorm de la version v2.0.2 vers le format compatible v2.0.3, en tenant compte des changements de nommage et de l'ajout de num_batches_tracked.

4.2 Adaptation du pipeline d'entraînement : Ajustement coordonné des chaînes de prétraitement DataLoader et de la stratégie d'initialisation BN

Des ajustements sont recommandés pour le DataLoader, tels que persistent_workers=True, afin de garantir la stabilité des statistiques BatchNorm pendant les premières phases de l'entraînement.

4.3 Refonte du service d'inférence : Solutions pour l'évasion de la fusion des sous-graphes BN dans l'exportation ONNX/Triton

Lors de l'exportation vers ONNX, des configurations spécifiques comme do_constant_folding=False sont nécessaires pour éviter la fusion incorrecte des couches BatchNorm dans les chemins de calcul partagés, garantissant ainsi la précision lors du chargement par Triton.

4.4 Mise à niveau du système de surveillance : Collecte du nouvel indicateur Branch Divergence Score (BDS) et configuration des seuils d'alerte

Un nouvel indicateur, le Branch Divergence Score (BDS), a été introduit pour quantifier la divergence entre les branches, avec des seuils d'alerte configurables pour différents environnements (développement, pré-production, production).