1. Problématique : Les LoRA statiques face à la génération vidéo

Les modèles LoRA (Low-Rank Adaptation) ont révolutionné la génération d'images en permettant d'appliquer des styles spécifiques à Stable Diffusion. Cependant, leur utilisation dans le contexte de la génération vidéo révèle des limitations fondamentales.

Un LoRA entraîné sur des images statiques capture les caractéristiques visuelles d'un style, mais ignore complètement la dimension temporelle. Lorsqu'on applique ce type de LoRA à un modèle comme AnimateDiff, le résultat présente souvent des incohérences : le style visuel est présent, mais les éléments dynamiques (reflets d'eau, mouvements de fumée, scintillement des lumières) semblent artificiels ou saccadés.

1.1 Origine du problème

Un LoRA traditionnel apprend à reproduire des patterns visuels figés dans le temps. Pour une vidéo, le modèle doit comprendre :

• La cohérence temporelle entre les frames
• L'évolution naturelle des éléments dynamiques
• La synchronisation entre le mouvement et le style visuel

La solution proposée ici inverse le paradigme classique : au lieu d'utiliser des images existantes, nous générons des vidéos de haute qualité avec AnimateDiff Pro, puis extrayons les frames pour constituer un dataset d'entraînement spécifiquement conçu pour la vidéo.

2. Architecture du workflow

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│  Définition du  │────▶│  Génération de   │────▶│  Extraction des │
│    style cible  │     │  vidéos par lot  │     │     frames      │
└─────────────────┘     └──────────────────┘     └─────────────────┘
                                                         │
                                                         ▼
┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│   Validation    │◀────│   Inférence avec │◀────│  Entraînement   │
│  du transfert   │     │   le nouveau     │     │   LoRA vidéo    │
│                 │     │   LoRA dynamique │     │                 │
└─────────────────┘     └──────────────────┘     └─────────────────┘

2.1 Pourquoi AnimateDiff Pro ?

Plusieurs caractéristiques rendent cette plateforme particulièrement adaptée :

• Cohérence stylistique : Basé sur Realistic Vision V5.1, le modèle maintient une cohérence remaqruable sur des séries de générations
• Motion Adapter optimisé : La version 1.5.2 intègre une compréhension physique des mouvements
• Performence : L'utilisation de BF16 et le décodage VAE par blocs permettent des temps de génération réduits

3. Implémentation pratique : Style "Pluie Cyberpunk"

3.1 Génération du dataset vidéo

Le style choisi combine pluie nocturne, lumières néon, reflets sur surfaces mouillées et atmosphère brumeuse. Ces éléments prennent vie dans la vidéo : les gouttes tombent, les néons scintillent, la brume se déplace.

Configuration de génération :

import http.client
import json
import os
from pathlib import Path

class VideoGenerator:
    def __init__(self, api_endpoint: str, output_dir: str = "./output"):
        self.api_endpoint = api_endpoint
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(parents=True, exist_ok=True)
    
    def build_payload(self, prompt: str, variant: str, seed: int) -> dict:
        return {
            "prompt": f"{prompt}, {variant}",
            "negative_prompt": "low quality, blurry, deformed, watermark, text, dry surface",
            "sampling_steps": 20,
            "dimensions": {"width": 768, "height": 512},
            "frame_count": 16,
            "guidance_scale": 7.5,
            "seed": seed
        }
    
    def generate_batch(self, base_prompt: str, variants: list) -> int:
        success_count = 0
        
        for idx, variant in enumerate(variants):
            payload = self.build_payload(base_prompt, variant, seed=2000 + idx * 50)
            
            try:
                conn = http.client.HTTPConnection(self.api_endpoint)
                conn.request("POST", "/api/generate", json.dumps(payload))
                response = conn.getresponse()
                
                if response.status == 200:
                    video_data = response.read()
                    output_path = self.output_dir / f"cyber_rain_{idx:03d}.gif"
                    output_path.write_bytes(video_data)
                    success_count += 1
                    print(f"[OK] Vidéo {idx+1}/{len(variants)} sauvegardée")
                else:
                    print(f"[ERR] Échec génération vidéo {idx+1}: HTTP {response.status}")
                
                conn.close()
            except Exception as e:
                print(f"[ERR] Exception lors de la génération: {e}")
        
        return success_count

# Utilisation
generator = VideoGenerator("localhost:5000")
base = "cinematic cyberpunk rainy night, neon reflections, wet streets"

variants = [
    "close-up rain drops on neon sign",
    "wide shot crowded street heavy rain",
    "first person view neon alley walk",
    "puddle reflection flying cars",
    "flickering neon bar sign rain"
]

generator.generate_batch(base, variants)

3.2 Extraction et augmentation des frames

Une fois les vidéos générées, il faut extraire les frames individuelles et appliquer des techniques d'augmentation pour atteindre un volume suffisant (200-500 images recommandées).

import cv2
import numpy as np
from pathlib import Path
from dataclasses import dataclass
from typing import Tuple

@dataclass
class FrameExtractorConfig:
    input_dir: str = "./output"
    output_dir: str = "./dataset/frames"
    target_frames: int = 16
    image_format: str = "png"

class FrameExtractor:
    def __init__(self, config: FrameExtractorConfig):
        self.config = config
        self.output_path = Path(config.output_dir)
        self.output_path.mkdir(parents=True, exist_ok=True)
        self.counter = 0
    
    def process_all_videos(self) -> int:
        video_files = list(Path(self.config.input_dir).glob("*.gif"))
        total_frames = 0
        
        for video_path in video_files:
            frames = self._extract_frames(video_path)
            for frame in frames:
                self._save_frame(frame)
                total_frames += 1
        
        print(f"Total frames extraites: {total_frames}")
        return total_frames
    
    def _extract_frames(self, video_path: Path) -> list:
        cap = cv2.VideoCapture(str(video_path))
        frames = []
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            frames.append(frame)
            if len(frames) >= self.config.target_frames:
                break
        
        cap.release()
        return frames
    
    def _save_frame(self, frame: np.ndarray) -> None:
        filename = f"frame_{self.counter:05d}.{self.config.image_format}"
        cv2.imwrite(str(self.output_path / filename), frame)
        self.counter += 1

class FrameAugmenter:
    def __init__(self, source_dir: str, augmented_dir: str):
        self.source = Path(source_dir)
        self.target = Path(augmented_dir)
        self.target.mkdir(parents=True, exist_ok=True)
    
    def apply_augmentations(self, factor: int = 3) -> int:
        image_files = list(self.source.glob("*.png"))
        augmented_count = 0
        
        for img_path in image_files:
            img = cv2.imread(str(img_path))
            
            # Original
            self._save_image(img, augmented_count)
            augmented_count += 1
            
            # Variations
            for _ in range(factor):
                variant = self._random_augment(img)
                self._save_image(variant, augmented_count)
                augmented_count += 1
        
        print(f"Dataset augmenté: {augmented_count} images")
        return augmented_count
    
    def _random_augment(self, img: np.ndarray) -> np.ndarray:
        operation = np.random.choice(['color', 'brightness', 'crop'])
        
        if operation == 'color':
            hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
            hsv[:,:,0] = hsv[:,:,0] * np.random.uniform(0.9, 1.1)
            return cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
        
        elif operation == 'brightness':
            factor = np.random.uniform(0.92, 1.08)
            return np.clip(img.astype(float) * factor, 0, 255).astype(np.uint8)
        
        else:  # crop
            h, w = img.shape[:2]
            scale = np.random.uniform(0.8, 0.95)
            new_h, new_w = int(h * scale), int(w * scale)
            y = np.random.randint(0, h - new_h)
            x = np.random.randint(0, w - new_w)
            cropped = img[y:y+new_h, x:x+new_w]
            return cv2.resize(cropped, (w, h))
    
    def _save_image(self, img: np.ndarray, index: int) -> None:
        path = self.target / f"augmented_{index:05d}.png"
        cv2.imwrite(str(path), img)

# Pipeline d'extraction
config = FrameExtractorConfig()
extractor = FrameExtractor(config)
extractor.process_all_videos()

augmenter = FrameAugmenter("./dataset/frames", "./dataset/augmented")
augmenter.apply_augmentations(factor=3)

3.3 Préparation des annotations

Chaque image nécessite une description textuelle cohérente. L'approche recommandée combine un préfixe de style fixe avec une variation contextuelle :

augmented_00001.png: cyberpunk rainy night scene, neon lights reflecting on wet pavement, cinematic lighting, photorealistic quality
augmented_00002.png: cyberpunk urban environment at night, heavy rain falling, blue and purple neon glow, cinematic composition
augmented_00003.png: close-up of neon sign in rain, cyberpunk aesthetic, bokeh background, atmospheric fog

Le préfixe constant (cyberpunk, rain, neon, cinematic) enseigne au LoRA les éléments stylistiques obligatoires, tandis que les variations introduisent la diversité nécessaire.

3.4 Configuration d'entraînement

Pour un LoRA adapté à la vidéo, plusieurs paramètres doivent être ajustés :

# Configuration LoRA pour style vidéo
base_model: realisticVisionV51_v51VAE.safetensors
training_data: ./dataset/augmented
output_directory: ./models/lora_video

network:
  dim: 128
  alpha: 64

optimizer:
  learning_rate: 1e-4
  scheduler: cosine_with_restarts
  warmup_steps: 100

training:
  batch_size: 4
  gradient_accumulation: 2
  epochs: 10
  save_frequency: 2
  precision: bf16

resolution:
  min: 256
  max: 1024
  target: [512, 768]

Commande d'entraînement :

accelerate launch train_network.py \
  --pretrained_model_name_or_path="realisticVisionV51_v51VAE.safetensors" \
  --train_data_dir="./dataset/augmented" \
  --output_dir="./models/lora_video" \
  --resolution=512,768 \
  --train_batch_size=4 \
  --max_train_epochs=10 \
  --learning_rate=1e-4 \
  --lr_scheduler="cosine_with_restarts" \
  --network_dim=128 \
  --network_alpha=64 \
  --mixed_precision="bf16" \
  --enable_bucket \
  --xformers

4. Validation du transfert de style

4.1 Intégration dans AnimateDiff Pro

Le LoRA entraîné doit être placé dans le répertoire approprié :

models/
└── Lora/
    └── cyber_rain_dynamic.safetensors

L'activation se fait via la syntaxe standard dans le prompt :

<lora:cyber_rain_dynamic:0.75> cinematic shot of cyberpunk market at night, neon lights, rain

4.2 Résultats de test

Scène similaire au training :

<lora:cyber_rain_dynamic:0.8> narrow cyberpunk alley night, heavy rain, flickering neon signs

Résultat : Correspondance stylistique excellente. Les gouttes de pluie chutent de manière naturelle, les reflets néon sont cohérents avec les données d'entraînement, l'absence de scintillement entre frames.

Scène étendue (intérieur) :

<lora:cyber_rain_dynamic:0.7> cyberpunk bar interior, rain visible through window, neon interior lighting

Résultat : Transfert réussi. Bien que le training n'ait inclus que des scènes extérieures, le LoRA a appris la palette chromatique (bleu-violet + orange) et les caractéristiques d'éclairage.

Scène défiante (sans pluie) :

<lora:cyber_rain_dynamic:0.6> cyberpunk city during sandstorm, orange dusty atmosphere

Résultat : Le style "néon cyberpunk" est présent mais l'élément "pluie" est ignoré intelligemment, démontrant une capacité de généralisation.

4.3 Métriques d'évaluation

5. Optimisations avancées

5.1 Qualité vs Quantité

Privilégier 5-10 scènes soigneusement composées avec 3-5 variantes de seed chacune, plutôt que des centaines de générations aléatoires. La pureté stylisitque prime sur le volume.

5.2 Ingénierie des prompts

Structure recommandée :

[STYLE_OBLIGATOIRE] + [VARIATION_CONTEXTE] + [DETAILS_TECHNIQUES]

Exemple:
cyberpunk rain neon (style) + market street (contexte) + cinematic 8k photorealistic (technique)

5.3 Combinaison avec ControlNet

Le LoRA dynamique peut être combiné avec ControlNet pour un contrôle fin :

def generate_with_style_control(
    prompt: str,
    lora_path: str,
    controlnet_type: str,
    control_image_path: str
):
    # Configuration composite
    config = {
        "prompt": f"<lora:{lora_path}:0.8> {prompt}",
        "controlnet": {
            "type": controlnet_type,
            "image": control_image_path,
            "strength": 0.6
        }
    }
    return generate_video(config)

Cette approche permet un contrôle simultané du style (via LoRA) et de la composition (via ControlNet).