Stable Video Diffusion

Stable Video Diffusion a été proposé dans Stable Video Diffusion: Scaling Latent Video Diffusion Models to Large Datasets par Andreas Blattmann, Tim Dockhorn, Sumith Kulal, Daniel Mendelevitch, Maciej Kilian, Dominik Lorenz, Yam Levi, Zion English, Vikram Voleti, Adam Letts, Varun Jampani, Robin Rombach.

L'abstract de l'article est :

Nous présentons Stable Video Diffusion, un modèle de diffusion vidéo latente pour la génération d'état de l'art de vidéos haute résolution à partir de texte et d'images. Récemment, des modèles de diffusion latente entraînés pour la synthèse d'images 2D ont été transformés en modèles vidéo génératifs en insérant des couches temporelles et en les affinant sur de petits jeux de données vidéo de haute qualité. Cependant, les méthodes d'entraînement dans la littérature varient considérablement et le domaine n'a pas encore convenu d'une stratégie unifiée pour la curation des données vidéo. Dans cet article, nous identifions et évaluons trois étapes différentes pour l'entraînement réussi des LDM vidéo : pré-entraînement texte-vers-image, pré-entraînement vidéo et affinement sur des vidéos de haute qualité. De plus, nous démontrons la nécessité d'un jeu de données de pré-entraînement bien curé pour générer des vidéos de haute qualité et présentons un processus systématique de curation pour entraîner un modèle de base robuste, incluant des stratégies de légendage et de filtrage. Nous explorons ensuite l'impact de l'affinement de notre modèle de base sur des données de haute qualité et entraînons un modèle texte-vers-image compétitif avec la génération vidéo fermée. Nous montrons également que notre modèle de base fournit une représentation puissante du mouvement pour les tâches en aval telles que la génération d'images-vers-vidéos et l'adaptabilité aux modules LoRA spécifiques au mouvement de caméra. Enfin, nous démontrons que notre modèle fournit un fort a priori 3D multi-vues et peut servir de base pour affiner un modèle de diffusion multi-vues qui génère conjointement plusieurs vues d'objets de manière feedforward, surpassant les méthodes basées sur les images avec une fraction de leur budget de calcul. Nous publions le code et les poids du modèle à cette https URL.

Consultez l'organisation Stability AI sur le Hub pour les points de contrôle base et extended frame !

Assurez-vous d'avoir installé les bibliothèques suivantes.

# Uncomment to install the necessary libraries in Colab
!pip install -q -U diffusers transformers accelerate

Il existe deux variantes de ce modèle, SVD et SVD-XT. Le checkpoint SVD est entraîné pour générer 14 images et le checkpoint SVD-XT est ensuite affiné pour générer 25 images.

Vous utiliserez le point de contrôle SVD-XT pour ce guide.

import torch

from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video

pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt", dtype=torch.float16, variant="fp16"
)
pipe.enable_model_cpu_offload()

# Load the conditioning image
image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/svd/rocket.png")
image = image.resize((1024, 576))

generator = torch.manual_seed(42)
frames = pipe(image, decode_chunk_size=8, generator=generator).frames[0]

export_to_video(frames, "generated.mp4", fps=7)

torch.compile

Vous pouvez obtenir une accélération de 20 à 25 % au prix d’une légère augmentation de la mémoire en compilant le UNet.

- pipe.enable_model_cpu_offload()
+ pipe.to("cuda")  # or "mps", "xpu", "cpu"
+ pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)

Réduire l'utilisation de la mémoire

La génération de vidéo est très gourmande en mémoire, car vous générez essentiellement num_frames d'un coup, de manière similaire à la génération d'images à partir de texte avec une taille de lot élevée. Pour réduire la consommation de mémoire, plusieurs options existent qui sacrifient la vitesse d'inférence au profit d'une exigence mémoire plus faible :

• activer le déchargement du modèle : chaque composant du pipeline est déchargé vers le CPU dès qu'il n'est plus nécessaire.
• activer le fractionnement en blocs du réseau de propagation avant : la couche de propagation avant s’exécute dans une boucle au lieu d’exécuter une seule propagation avant avec une taille de lot énorme.
• réduire decode_chunk_size : le VAE décode les images par lots au lieu de les décoder toutes ensemble. Définir decode_chunk_size=1 décode une image à la fois et utilise le moins de mémoire possible (nous recommandons d’ajuster cette valeur en fonction de la mémoire de votre GPU), mais la vidéo peut présenter des scintillements.

- pipe.enable_model_cpu_offload()
- frames = pipe(image, decode_chunk_size=8, generator=generator).frames[0]
+ pipe.enable_model_cpu_offload()
+ pipe.unet.enable_forward_chunking()
+ frames = pipe(image, decode_chunk_size=2, generator=generator, num_frames=25).frames[0]

L'utilisation de toutes ces astuces combinées devrait réduire la consommation mémoire à moins de 8 Go de VRAM.

Micro-conditionnement

Stable Diffusion Video accepte également le micro-conditionnement, en plus de l’image de conditionnement, ce qui permet un meilleur contrôle sur la vidéo générée :

• fps : les images par seconde de la vidéo générée.
• motion_bucket_id : l’identifiant du bucket de mouvement à utiliser pour la vidéo générée. Il permet de contrôler le mouvement de la vidéo générée. Augmenter l’identifiant du bucket de mouvement augmente le mouvement de la vidéo générée.
• noise_aug_strength : la quantité de bruit ajoutée à l'image de conditionnement. Plus les valeurs sont élevées, moins la vidéo ressemble à l'image de conditionnement. L'augmentation de cette valeur augmente également le mouvement de la vidéo générée.

Par exemple, pour générer une vidéo avec plus de mouvement, utilisez les paramètres de micro-conditionnement motion_bucket_id et noise_aug_strength :

import torch

from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video

pipe = StableVideoDiffusionPipeline.from_pretrained(
  "stabilityai/stable-video-diffusion-img2vid-xt", dtype=torch.float16, variant="fp16"
)
pipe.enable_model_cpu_offload()

# Load the conditioning image
image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/svd/rocket.png")
image = image.resize((1024, 576))

generator = torch.manual_seed(42)
frames = pipe(image, decode_chunk_size=8, generator=generator, motion_bucket_id=180, noise_aug_strength=0.1).frames[0]
export_to_video(frames, "generated.mp4", fps=7)

StableVideoDiffusionPipeline

StableVideoDiffusionPipelineOutput