Diffusers documentation

Génération de vidéos à partir de texte avec AnimateDiff

Diffusers

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Génération de vidéos à partir de texte avec AnimateDiff

Aperçu

AnimateDiff : Animer vos modèles de diffusion texte-image personnalisés sans réglage spécifique par Yuwei Guo, Ceyuan Yang, Anyi Rao, Yaohui Wang, Yu Qiao, Dahua Lin, Bo Dai.

L’abstract de l’article est le suivant :

Avec l’avancée des modèles de texte vers image (par exemple Stable Diffusion) et des techniques de personnalisation correspondantes telles que DreamBooth et LoRA, chacun peut désormais concrétiser son imagination en images de haute qualité à un coût abordable. Par conséquent, la demande pour des techniques d’animation d’images est forte, afin de combiner davantage les images statiques générées avec des dynamiques de mouvement. Dans ce rapport, nous proposons un cadre pratique pour animer la plupart des modèles de texte vers image personnalisés existants une fois pour toutes, en évitant les efforts de réglage spécifiques à chaque modèle. Au cœur du cadre proposé se trouve l’insertion d’un module de modélisation du mouvement nouvellement initialisé dans le modèle de texte vers image figé, puis son entraînement sur des extraits vidéo pour distiller des a priori de mouvement raisonnables. Une fois entraîné, il suffit d’injecter ce module de modélisation du mouvement pour que toutes les versions personnalisées dérivées de la même base T2I deviennent des modèles pilotés par le texte, produisant des images animées diverses et personnalisées. Nous menons notre évaluation sur plusieurs modèles publics représentatifs de texte vers image personnalisés, à travers des images d’anime et des photographies réalistes, et démontrons que notre cadre proposé aide ces modèles à générer des extraits d’animation temporellement fluides tout en préservant le domaine et la diversité de leurs sorties. Le code et les poids pré-entraînés seront disponibles publiquement à cette URL https.

Pipelines disponibles

Pipeline	Tâches	Démo
AnimateDiffPipeline	Génération de vidéos à partir de texte avec AnimateDiff
AnimateDiffControlNetPipeline	Génération vidéo-à-vidéo contrôlée avec AnimateDiff en utilisant ControlNet
AnimateDiffSparseControlNetPipeline	Génération vidéo-à-vidéo contrôlée avec AnimateDiff à l'aide de SparseCtrl
AnimateDiffSDXLPipeline	Génération vidéo-à-vidéo avec AnimateDiff
AnimateDiffVideoToVideoPipeline	Génération vidéo-à-vidéo avec AnimateDiff
AnimateDiffVideoToVideoControlNetPipeline	Génération vidéo-à-vidéo avec AnimateDiff en utilisant ControlNet

Points de contrôle disponibles

Les points de contrôle de l'adaptateur Motion peuvent être trouvés sous guoyww. Ces points de contrôle sont conçus pour fonctionner avec tout modèle basé sur Stable Diffusion 1.4/1.5.

Exemple d'utilisation

AnimateDiffPipeline

AnimateDiff fonctionne avec un point de contrôle MotionAdapter et un point de contrôle de modèle Stable Diffusion. Le MotionAdapter est un ensemble de Motion Modules chargés d'ajouter un mouvement cohérent entre les images. Ces modules sont appliqués après les blocs Resnet et Attention dans le UNet de Stable Diffusion.

L'exemple suivant montre comment utiliser un point de contrôle MotionAdapter avec Diffusers pour l'inférence basée sur StableDiffusion-1.4/1.5.

import torch
from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
from diffusers.utils import export_to_gif

# Load the motion adapter
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", dtype=torch.float16)
# load SD 1.5 based finetuned model
model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, dtype=torch.float16)
scheduler = DDIMScheduler.from_pretrained(
    model_id,
    subfolder="scheduler",
    clip_sample=False,
    timestep_spacing="linspace",
    beta_schedule="linear",
    steps_offset=1,
)
pipe.scheduler = scheduler

# enable memory savings
pipe.vae.enable_slicing()
pipe.enable_model_cpu_offload()

output = pipe(
    prompt=(
        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
        "golden hour, coastal landscape, seaside scenery"
    ),
    negative_prompt="bad quality, worse quality",
    num_frames=16,
    guidance_scale=7.5,
    num_inference_steps=25,
    generator=torch.Generator("cpu").manual_seed(42),
)
frames = output.frames[0]
export_to_gif(frames, "animation.gif")

Voici quelques exemples de sorties :

chef-d'œuvre, meilleure qualité, coucher de soleil.
masterpiece, bestquality, sunset

AnimateDiff fonctionne généralement mieux avec des modèles Stable Diffusion affinés. Si vous prévoyez d’utiliser un planificateur capable de tronquer les échantillons, assurez-vous de le désactiver en définissant clip_sample=False dans le planificateur, car cela peut également avoir un effet néfaste sur les échantillons générés. De plus, les points de contrôle AnimateDiff peuvent être sensibles à l’agenda bêta du planificateur. Nous recommandons de le définir sur linear.

AnimateDiffControlNetPipeline

AnimateDiff peut également être utilisé avec ControlNets. ControlNet a été introduit dans Adding Conditional Control to Text-to-Image Diffusion Models par Lvmin Zhang, Anyi Rao et Maneesh Agrawala. Avec un modèle ControlNet, vous pouvez fournir une image de contrôle supplémentaire pour conditionner et contrôler la génération de Stable Diffusion. Par exemple, si vous fournissez des cartes de profondeur, le modèle ControlNet génère une vidéo qui préserve les informations spatiales des cartes de profondeur. C'est une méthode plus flexible et plus précise pour contrôler le processus de génération de vidéo.

import torch
from diffusers import AnimateDiffControlNetPipeline, AutoencoderKL, ControlNetModel, MotionAdapter, LCMScheduler
from diffusers.utils import export_to_gif, load_video

# Additionally, you will need a preprocess videos before they can be used with the ControlNet
# HF maintains just the right package for it: `pip install controlnet_aux`
from controlnet_aux.processor import ZoeDetector

# Download controlnets from https://huggingface.co/lllyasviel/ControlNet-v1-1 to use .from_single_file
# Download Diffusers-format controlnets, such as https://huggingface.co/lllyasviel/sd-controlnet-depth, to use .from_pretrained()
controlnet = ControlNetModel.from_single_file("control_v11f1p_sd15_depth.pth", dtype=torch.float16)

# We use AnimateLCM for this example but one can use the original motion adapters as well (for example, https://huggingface.co/guoyww/animatediff-motion-adapter-v1-5-3)
motion_adapter = MotionAdapter.from_pretrained("wangfuyun/AnimateLCM")

vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", dtype=torch.float16)
pipe: AnimateDiffControlNetPipeline = AnimateDiffControlNetPipeline.from_pretrained(
    "SG161222/Realistic_Vision_V5.1_noVAE",
    motion_adapter=motion_adapter,
    controlnet=controlnet,
    vae=vae,
).to(device="cuda", dtype=torch.float16)  # or "mps", "xpu", "cpu"
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config, beta_schedule="linear")
pipe.load_lora_weights("wangfuyun/AnimateLCM", weight_name="AnimateLCM_sd15_t2v_lora.safetensors", adapter_name="lcm-lora")
pipe.set_adapters(["lcm-lora"], [0.8])

depth_detector = ZoeDetector.from_pretrained("lllyasviel/Annotators").to("cuda")
video = load_video("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/animatediff-vid2vid-input-1.gif")
conditioning_frames = []

with pipe.progress_bar(total=len(video)) as progress_bar:
    for frame in video:
        conditioning_frames.append(depth_detector(frame))
        progress_bar.update()

prompt = "a panda, playing a guitar, sitting in a pink boat, in the ocean, mountains in background, realistic, high quality"
negative_prompt = "bad quality, worst quality"

video = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=len(video),
    num_inference_steps=10,
    guidance_scale=2.0,
    conditioning_frames=conditioning_frames,
    generator=torch.Generator().manual_seed(42),
).frames[0]

export_to_gif(video, "animatediff_controlnet.gif", fps=8)

Voici quelques exemples de sorties :

Vidéo source	Vidéo de sortie
raccoon jouant de la guitare	un panda, jouant de la guitare, assis dans un bateau rose, dans l'océan, des montagnes en arrière-plan, réaliste, haute qualité

AnimateDiffSparseControlNetPipeline

SparseCtrl : ajout de contrôles creux aux modèles de diffusion texte-vers-vidéo pour réaliser une génération contrôlée dans les modèles de diffusion texte-vers-vidéo, par Yuwei Guo, Ceyuan Yang, Anyi Rao, Maneesh Agrawala, Dahua Lin et Bo Dai.

L'abstract de l'article est :

Le développement du texte-vers-vidéo (T2V), c'est-à-dire la génération de vidéos à partir d'un prompt textuel donné, a connu des avancées significatives ces dernières années. Cependant, s'appuyer uniquement sur des prompts textuels conduit souvent à une composition d'images ambiguë en raison de l'incertitude spatiale. La communauté de recherche exploite donc les signaux de structure denses, par exemple des séquences de profondeur ou de contours par image, pour améliorer la contrôlabilité, ce qui augmente en conséquence la charge d'inférence. Dans ce travail, nous présentons SparseCtrl pour permettre un contrôle de structure flexible avec des signaux temporellement espacés, nécessitant uniquement une ou quelques entrées, comme le montre la Figure 1. Il intègre un encodeur de condition supplémentaire pour traiter ces signaux espacés tout en laissant le modèle T2V pré-entraîné inchangé. L'approche proposée est compatible avec diverses modalités, y compris les croquis, les cartes de profondeur et les images RGB, offrant un contrôle plus pratique pour la génération de vidéos et favorisant des applications telles que le storyboarding, le rendu de profondeur, l'animation par images clés et l'interpolation. Des expériences étendues démontrent la généralisation de SparseCtrl sur les générateurs T2V originaux et personnalisés. Les codes et les modèles seront disponibles publiquement à cette URL https.

SparseCtrl introduit les points de contrôle suivants pour la génération de texte vers vidéo contrôlée :

Utilisation de SparseCtrl Scribble

import torch

from diffusers import AnimateDiffSparseControlNetPipeline
from diffusers.models import AutoencoderKL, MotionAdapter, SparseControlNetModel
from diffusers.schedulers import DPMSolverMultistepScheduler
from diffusers.utils import export_to_gif, load_image


model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
motion_adapter_id = "guoyww/animatediff-motion-adapter-v1-5-3"
controlnet_id = "guoyww/animatediff-sparsectrl-scribble"
lora_adapter_id = "guoyww/animatediff-motion-lora-v1-5-3"
vae_id = "stabilityai/sd-vae-ft-mse"
device = "cuda"  # or "mps", "xpu", "cpu"

motion_adapter = MotionAdapter.from_pretrained(motion_adapter_id, dtype=torch.float16).to(device)
controlnet = SparseControlNetModel.from_pretrained(controlnet_id, dtype=torch.float16).to(device)
vae = AutoencoderKL.from_pretrained(vae_id, dtype=torch.float16).to(device)
scheduler = DPMSolverMultistepScheduler.from_pretrained(
    model_id,
    subfolder="scheduler",
    beta_schedule="linear",
    algorithm_type="dpmsolver++",
    use_karras_sigmas=True,
)
pipe = AnimateDiffSparseControlNetPipeline.from_pretrained(
    model_id,
    motion_adapter=motion_adapter,
    controlnet=controlnet,
    vae=vae,
    scheduler=scheduler,
    dtype=torch.float16,
).to(device)
pipe.load_lora_weights(lora_adapter_id, adapter_name="motion_lora")
pipe.fuse_lora(lora_scale=1.0)

prompt = "an aerial view of a cyberpunk city, night time, neon lights, masterpiece, high quality"
negative_prompt = "low quality, worst quality, letterboxed"

image_files = [
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/animatediff-scribble-1.png",
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/animatediff-scribble-2.png",
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/animatediff-scribble-3.png"
]
condition_frame_indices = [0, 8, 15]
conditioning_frames = [load_image(img_file) for img_file in image_files]

video = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=25,
    conditioning_frames=conditioning_frames,
    controlnet_conditioning_scale=1.0,
    controlnet_frame_indices=condition_frame_indices,
    generator=torch.Generator().manual_seed(1337),
).frames[0]
export_to_gif(video, "output.gif")

Voici quelques exemples de sorties :

an aerial view of a cyberpunk city, night time, neon lights, masterpiece, high quality

Utilisation de SparseCtrl RGB

import torch

from diffusers import AnimateDiffSparseControlNetPipeline
from diffusers.models import AutoencoderKL, MotionAdapter, SparseControlNetModel
from diffusers.schedulers import DPMSolverMultistepScheduler
from diffusers.utils import export_to_gif, load_image


model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
motion_adapter_id = "guoyww/animatediff-motion-adapter-v1-5-3"
controlnet_id = "guoyww/animatediff-sparsectrl-rgb"
lora_adapter_id = "guoyww/animatediff-motion-lora-v1-5-3"
vae_id = "stabilityai/sd-vae-ft-mse"
device = "cuda"  # or "mps", "xpu", "cpu"

motion_adapter = MotionAdapter.from_pretrained(motion_adapter_id, dtype=torch.float16).to(device)
controlnet = SparseControlNetModel.from_pretrained(controlnet_id, dtype=torch.float16).to(device)
vae = AutoencoderKL.from_pretrained(vae_id, dtype=torch.float16).to(device)
scheduler = DPMSolverMultistepScheduler.from_pretrained(
    model_id,
    subfolder="scheduler",
    beta_schedule="linear",
    algorithm_type="dpmsolver++",
    use_karras_sigmas=True,
)
pipe = AnimateDiffSparseControlNetPipeline.from_pretrained(
    model_id,
    motion_adapter=motion_adapter,
    controlnet=controlnet,
    vae=vae,
    scheduler=scheduler,
    dtype=torch.float16,
).to(device)
pipe.load_lora_weights(lora_adapter_id, adapter_name="motion_lora")

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/animatediff-firework.png")

video = pipe(
    prompt="closeup face photo of man in black clothes, night city street, bokeh, fireworks in background",
    negative_prompt="low quality, worst quality",
    num_inference_steps=25,
    conditioning_frames=image,
    controlnet_frame_indices=[0],
    controlnet_conditioning_scale=1.0,
    generator=torch.Generator().manual_seed(42),
).frames[0]
export_to_gif(video, "output.gif")

Voici quelques exemples de sorties :

closeup face photo of man in black clothes, night city street, bokeh, fireworks in background

AnimateDiffSDXLPipeline

AnimateDiff peut également être utilisé avec les modèles SDXL. Il s'agit actuellement d'une fonctionnalité expérimentale, car seule une version bêta du point de contrôle de l'adaptateur de mouvement est disponible.

import torch
from diffusers.models import MotionAdapter
from diffusers import AnimateDiffSDXLPipeline, DDIMScheduler
from diffusers.utils import export_to_gif

adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-sdxl-beta", dtype=torch.float16)

model_id = "stabilityai/stable-diffusion-xl-base-1.0"
scheduler = DDIMScheduler.from_pretrained(
    model_id,
    subfolder="scheduler",
    clip_sample=False,
    timestep_spacing="linspace",
    beta_schedule="linear",
    steps_offset=1,
)
pipe = AnimateDiffSDXLPipeline.from_pretrained(
    model_id,
    motion_adapter=adapter,
    scheduler=scheduler,
    dtype=torch.float16,
    variant="fp16",
).to("cuda")  # or "mps", "xpu", "cpu"

# enable memory savings
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()

output = pipe(
    prompt="a panda surfing in the ocean, realistic, high quality",
    negative_prompt="low quality, worst quality",
    num_inference_steps=20,
    guidance_scale=8,
    width=1024,
    height=1024,
    num_frames=16,
)

frames = output.frames[0]
export_to_gif(frames, "animation.gif")

AnimateDiffVideoToVideoPipeline

AnimateDiff peut également être utilisé pour générer des vidéos visuellement similaires ou pour effectuer des modifications de style, de personnage, d’arrière-plan ou autres à partir d’une vidéo initiale, vous permettant d’explorer sans effort les possibilités créatives.

import imageio
import requests
import torch
from diffusers import AnimateDiffVideoToVideoPipeline, DDIMScheduler, MotionAdapter
from diffusers.utils import export_to_gif
from io import BytesIO
from PIL import Image

# Load the motion adapter
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", dtype=torch.float16)
# load SD 1.5 based finetuned model
model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
pipe = AnimateDiffVideoToVideoPipeline.from_pretrained(model_id, motion_adapter=adapter, dtype=torch.float16)
scheduler = DDIMScheduler.from_pretrained(
    model_id,
    subfolder="scheduler",
    clip_sample=False,
    timestep_spacing="linspace",
    beta_schedule="linear",
    steps_offset=1,
)
pipe.scheduler = scheduler

# enable memory savings
pipe.vae.enable_slicing()
pipe.enable_model_cpu_offload()

# helper function to load videos
def load_video(file_path: str):
    images = []

    if file_path.startswith(('http://', 'https://')):
        # If the file_path is a URL
        response = requests.get(file_path)
        response.raise_for_status()
        content = BytesIO(response.content)
        vid = imageio.get_reader(content)
    else:
        # Assuming it's a local file path
        vid = imageio.get_reader(file_path)

    for frame in vid:
        pil_image = Image.fromarray(frame)
        images.append(pil_image)

    return images

video = load_video("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/animatediff-vid2vid-input-1.gif")

output = pipe(
    video = video,
    prompt="panda playing a guitar, on a boat, in the ocean, high quality",
    negative_prompt="bad quality, worse quality",
    guidance_scale=7.5,
    num_inference_steps=25,
    strength=0.5,
    generator=torch.Generator("cpu").manual_seed(42),
)
frames = output.frames[0]
export_to_gif(frames, "animation.gif")

Voici quelques exemples de sorties :

Vidéo source	Vidéo de sortie
raccoon jouant de la guitare	panda jouant de la guitare
gros plan sur Margot Robbie, feux d'artifice en arrière-plan, haute qualité	gros plan de Tony Stark, Robert Downey Jr, feux d'artifice

AnimateDiffVideoToVideoControlNetPipeline

AnimateDiff peut être utilisé en combinaison avec ControlNets pour améliorer la génération vidéo-à-vidéo en permettant un contrôle précis de la sortie. ControlNet a été introduit dans Adding Conditional Control to Text-to-Image Diffusion Models par Lvmin Zhang, Anyi Rao et Maneesh Agrawala, et permet de conditionner Stable Diffusion avec une image de contrôle supplémentaire afin de garantir que les informations spatiales sont préservées tout au long de la vidéo.

Ce pipeline vous permet de conditionner votre génération à la fois sur la vidéo d'origine et sur une séquence d'images de contrôle.

import torch
from PIL import Image
from tqdm.auto import tqdm

from controlnet_aux.processor import OpenposeDetector
from diffusers import AnimateDiffVideoToVideoControlNetPipeline
from diffusers.utils import export_to_gif, load_video
from diffusers import AutoencoderKL, ControlNetModel, MotionAdapter, LCMScheduler

# Load the ControlNet
controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-openpose", dtype=torch.float16)
# Load the motion adapter
motion_adapter = MotionAdapter.from_pretrained("wangfuyun/AnimateLCM")
# Load SD 1.5 based finetuned model
vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", dtype=torch.float16)
pipe = AnimateDiffVideoToVideoControlNetPipeline.from_pretrained(
    "SG161222/Realistic_Vision_V5.1_noVAE",
    motion_adapter=motion_adapter,
    controlnet=controlnet,
    vae=vae,
).to(device="cuda", dtype=torch.float16)  # or "mps", "xpu", "cpu"

# Enable LCM to speed up inference
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config, beta_schedule="linear")
pipe.load_lora_weights("wangfuyun/AnimateLCM", weight_name="AnimateLCM_sd15_t2v_lora.safetensors", adapter_name="lcm-lora")
pipe.set_adapters(["lcm-lora"], [0.8])

video = load_video("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/dance.gif")
video = [frame.convert("RGB") for frame in video]

prompt = "astronaut in space, dancing"
negative_prompt = "bad quality, worst quality, jpeg artifacts, ugly"

# Create controlnet preprocessor
open_pose = OpenposeDetector.from_pretrained("lllyasviel/Annotators").to("cuda")

# Preprocess controlnet images
conditioning_frames = []
for frame in tqdm(video):
    conditioning_frames.append(open_pose(frame))

strength = 0.8
with torch.inference_mode():
    video = pipe(
        video=video,
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_inference_steps=10,
        guidance_scale=2.0,
        controlnet_conditioning_scale=0.75,
        conditioning_frames=conditioning_frames,
        strength=strength,
        generator=torch.Generator().manual_seed(42),
    ).frames[0]

video = [frame.resize(conditioning_frames[0].size) for frame in video]
export_to_gif(video, f"animatediff_vid2vid_controlnet.gif", fps=8)

Voici quelques exemples de sorties :

Vidéo source	Vidéo de sortie
fille de dessin animé, dansant	astronaute dans l'espace, dansant

Les lumières et la composition ont été transférées depuis la vidéo source.

Utilisation des Motion LoRAs

Les Motion LoRAs sont un ensemble de LoRAs qui fonctionnent avec le point de contrôle guoyww/animatediff-motion-adapter-v1-5-2. Ces LoRAs sont chargés d’ajouter des types de mouvement spécifiques aux animations.

import torch
from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
from diffusers.utils import export_to_gif

# Load the motion adapter
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", dtype=torch.float16)
# load SD 1.5 based finetuned model
model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, dtype=torch.float16)
pipe.load_lora_weights(
    "guoyww/animatediff-motion-lora-zoom-out", adapter_name="zoom-out"
)

scheduler = DDIMScheduler.from_pretrained(
    model_id,
    subfolder="scheduler",
    clip_sample=False,
    beta_schedule="linear",
    timestep_spacing="linspace",
    steps_offset=1,
)
pipe.scheduler = scheduler

# enable memory savings
pipe.vae.enable_slicing()
pipe.enable_model_cpu_offload()

output = pipe(
    prompt=(
        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
        "golden hour, coastal landscape, seaside scenery"
    ),
    negative_prompt="bad quality, worse quality",
    num_frames=16,
    guidance_scale=7.5,
    num_inference_steps=25,
    generator=torch.Generator("cpu").manual_seed(42),
)
frames = output.frames[0]
export_to_gif(frames, "animation.gif")

chef-d'œuvre, meilleure qualité, coucher de soleil.
masterpiece, bestquality, sunset

Utilisation des Motion LoRAs avec PEFT

Vous pouvez également exploiter le backend PEFT pour combiner les Motion LoRA et créer des animations plus complexes.

Installez d'abord PEFT avec

pip install peft

Vous pouvez ensuite utiliser le code suivant pour combiner les Motion LoRAs.

import torch
from diffusers import AnimateDiffPipeline, DDIMScheduler, MotionAdapter
from diffusers.utils import export_to_gif

# Load the motion adapter
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2", dtype=torch.float16)
# load SD 1.5 based finetuned model
model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, dtype=torch.float16)

pipe.load_lora_weights(
    "diffusers/animatediff-motion-lora-zoom-out", adapter_name="zoom-out",
)
pipe.load_lora_weights(
    "diffusers/animatediff-motion-lora-pan-left", adapter_name="pan-left",
)
pipe.set_adapters(["zoom-out", "pan-left"], adapter_weights=[1.0, 1.0])

scheduler = DDIMScheduler.from_pretrained(
    model_id,
    subfolder="scheduler",
    clip_sample=False,
    timestep_spacing="linspace",
    beta_schedule="linear",
    steps_offset=1,
)
pipe.scheduler = scheduler

# enable memory savings
pipe.vae.enable_slicing()
pipe.enable_model_cpu_offload()

output = pipe(
    prompt=(
        "masterpiece, bestquality, highlydetailed, ultradetailed, sunset, "
        "orange sky, warm lighting, fishing boats, ocean waves seagulls, "
        "rippling water, wharf, silhouette, serene atmosphere, dusk, evening glow, "
        "golden hour, coastal landscape, seaside scenery"
    ),
    negative_prompt="bad quality, worse quality",
    num_frames=16,
    guidance_scale=7.5,
    num_inference_steps=25,
    generator=torch.Generator("cpu").manual_seed(42),
)
frames = output.frames[0]
export_to_gif(frames, "animation.gif")

chef-d'œuvre, meilleure qualité, coucher de soleil.
masterpiece, bestquality, sunset

Utilisation de FreeInit

FreeInit : combler l'écart d'initialisation dans les modèles de diffusion vidéo par Tianxing Wu, Chenyang Si, Yuming Jiang, Ziqi Huang, Ziwei Liu.

FreeInit est une méthode efficace qui améliore la cohérence temporelle et la qualité globale des vidéos générées à l'aide de video-diffusion-models, sans entraînement supplémentaire. Elle peut être appliquée sans effort à AnimateDiff, ModelScope, VideoCrafter et divers autres modèles de génération de vidéos au moment de l'inférence, et fonctionne en affinant itérativement le bruit d'initialisation latente. Plus de détails peuvent être trouvés dans l'article.

L'exemple suivant illustre l'utilisation de FreeInit.

import torch
from diffusers import MotionAdapter, AnimateDiffPipeline, DDIMScheduler
from diffusers.utils import export_to_gif

adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")
model_id = "SG161222/Realistic_Vision_V5.1_noVAE"
pipe = AnimateDiffPipeline.from_pretrained(model_id, motion_adapter=adapter, dtype=torch.float16).to("cuda")  # or "mps", "xpu", "cpu"
pipe.scheduler = DDIMScheduler.from_pretrained(
    model_id,
    subfolder="scheduler",
    beta_schedule="linear",
    clip_sample=False,
    timestep_spacing="linspace",
    steps_offset=1
)

# enable memory savings
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()

# enable FreeInit
# Refer to the enable_free_init documentation for a full list of configurable parameters
pipe.enable_free_init(method="butterworth", use_fast_sampling=True)

# run inference
output = pipe(
    prompt="a panda playing a guitar, on a boat, in the ocean, high quality",
    negative_prompt="bad quality, worse quality",
    num_frames=16,
    guidance_scale=7.5,
    num_inference_steps=20,
    generator=torch.Generator("cpu").manual_seed(666),
)

# disable FreeInit
pipe.disable_free_init()

frames = output.frames[0]
export_to_gif(frames, "animation.gif")

FreeInit n’est pas vraiment gratuit – la qualité améliorée se paie au prix d’un calcul supplémentaire. Il nécessite un échantillonnage supplémentaire, dont le nombre dépend du paramètre num_iters défini lors de son activation. Définir le paramètre use_fast_sampling sur True peut améliorer les performances globales (au prix d’une qualité inférieure par rapport à use_fast_sampling=False, mais avec des résultats toujours supérieurs à ceux des modèles de génération de vidéo classiques).

Pensez à consulter le guide des Schedulers pour apprendre à explorer le compromis entre la vitesse et la qualité du scheduler, et à consulter la section réutilisation des composants entre les pipelines pour apprendre à charger efficacement les mêmes composants dans plusieurs pipelines.

Sans FreeInit activé	Avec FreeInit activé
panda jouant de la guitare	panda jouant de la guitare

Utiliser AnimateLCM

AnimateLCM est un point de contrôle de module de mouvement et un LCM LoRA créés à l’aide d’une stratégie d’apprentissage par cohérence qui découple la distillation des a priori de génération d’images et des a priori de génération de mouvement.

import torch
from diffusers import AnimateDiffPipeline, LCMScheduler, MotionAdapter
from diffusers.utils import export_to_gif

adapter = MotionAdapter.from_pretrained("wangfuyun/AnimateLCM")
pipe = AnimateDiffPipeline.from_pretrained("emilianJR/epiCRealism", motion_adapter=adapter)
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config, beta_schedule="linear")

pipe.load_lora_weights("wangfuyun/AnimateLCM", weight_name="sd15_lora_beta.safetensors", adapter_name="lcm-lora")

pipe.vae.enable_slicing()
pipe.enable_model_cpu_offload()

output = pipe(
    prompt="A space rocket with trails of smoke behind it launching into space from the desert, 4k, high resolution",
    negative_prompt="bad quality, worse quality, low resolution",
    num_frames=16,
    guidance_scale=1.5,
    num_inference_steps=6,
    generator=torch.Generator("cpu").manual_seed(0),
)
frames = output.frames[0]
export_to_gif(frames, "animatelcm.gif")

Une fusée spatiale, 4K.
A space rocket, 4K

AnimateLCM est également compatible avec les Motion LoRAs existants.

import torch
from diffusers import AnimateDiffPipeline, LCMScheduler, MotionAdapter
from diffusers.utils import export_to_gif

adapter = MotionAdapter.from_pretrained("wangfuyun/AnimateLCM")
pipe = AnimateDiffPipeline.from_pretrained("emilianJR/epiCRealism", motion_adapter=adapter)
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config, beta_schedule="linear")

pipe.load_lora_weights("wangfuyun/AnimateLCM", weight_name="sd15_lora_beta.safetensors", adapter_name="lcm-lora")
pipe.load_lora_weights("guoyww/animatediff-motion-lora-tilt-up", adapter_name="tilt-up")

pipe.set_adapters(["lcm-lora", "tilt-up"], [1.0, 0.8])
pipe.vae.enable_slicing()
pipe.enable_model_cpu_offload()

output = pipe(
    prompt="A space rocket with trails of smoke behind it launching into space from the desert, 4k, high resolution",
    negative_prompt="bad quality, worse quality, low resolution",
    num_frames=16,
    guidance_scale=1.5,
    num_inference_steps=6,
    generator=torch.Generator("cpu").manual_seed(0),
)
frames = output.frames[0]
export_to_gif(frames, "animatelcm-motion-lora.gif")

Une fusée spatiale, 4K.
A space rocket, 4K

Utiliser FreeNoise

FreeNoise: Tuning-Free Longer Video Diffusion via Noise Rescheduling de Haonan Qiu, Menghan Xia, Yong Zhang, Yingqing He, Xintao Wang, Ying Shan, Ziwei Liu.

FreeNoise est un mécanisme d'échantillonnage capable de générer des vidéos plus longues à l'aide de modèles de génération de vidéos courtes, en utilisant le réordonnancement du bruit, l'attention temporelle sur des fenêtres glissantes et la moyenne pondérée des images latentes. Il peut également être utilisé avec plusieurs prompts pour permettre des générations de vidéos interpolées. Plus de détails sont disponibles dans l'article.

Les pipelines AnimateDiff actuellement pris en charge et pouvant être utilisés avec FreeNoise sont les suivants :

Afin d'utiliser FreeNoise, il faut ajouter une seule ligne au code d'inférence après le chargement de vos pipelines.

+ pipe.enable_free_noise()

Après cela, on peut soit utiliser un seul prompt, soit passer plusieurs prompts sous forme d'un dictionnaire de paires entier-chaîne de caractères. Les clés entières du dictionnaire correspondent à l'index de la frame auquel l'influence de ce prompt est maximale. Chaque index de frame doit correspondre à un unique prompt en chaîne de caractères. Les prompts pour les indices de frames intermédiaires, qui ne sont pas passés dans le dictionnaire, sont créés par interpolation entre les prompts de frames passés. Par défaut, une interpolation linéaire simple est utilisée. Toutefois, vous pouvez personnaliser ce comportement avec un callback pour le paramètre prompt_interpolation_callback lors de l'activation de FreeNoise.

Exemple complet :

import torch
from diffusers import AutoencoderKL, AnimateDiffPipeline, LCMScheduler, MotionAdapter
from diffusers.utils import export_to_video, load_image

# Load pipeline
dtype = torch.float16
motion_adapter = MotionAdapter.from_pretrained("wangfuyun/AnimateLCM", dtype=dtype)
vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", dtype=dtype)

pipe = AnimateDiffPipeline.from_pretrained("emilianJR/epiCRealism", motion_adapter=motion_adapter, vae=vae, dtype=dtype)
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config, beta_schedule="linear")

pipe.load_lora_weights(
    "wangfuyun/AnimateLCM", weight_name="AnimateLCM_sd15_t2v_lora.safetensors", adapter_name="lcm_lora"
)
pipe.set_adapters(["lcm_lora"], [0.8])

# Enable FreeNoise for long prompt generation
pipe.enable_free_noise(context_length=16, context_stride=4)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

# Can be a single prompt, or a dictionary with frame timesteps
prompt = {
    0: "A caterpillar on a leaf, high quality, photorealistic",
    40: "A caterpillar transforming into a cocoon, on a leaf, near flowers, photorealistic",
    80: "A cocoon on a leaf, flowers in the background, photorealistic",
    120: "A cocoon maturing and a butterfly being born, flowers and leaves visible in the background, photorealistic",
    160: "A beautiful butterfly, vibrant colors, sitting on a leaf, flowers in the background, photorealistic",
    200: "A beautiful butterfly, flying away in a forest, photorealistic",
    240: "A cyberpunk butterfly, neon lights, glowing",
}
negative_prompt = "bad quality, worst quality, jpeg artifacts"

# Run inference
output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=256,
    guidance_scale=2.5,
    num_inference_steps=10,
    generator=torch.Generator("cpu").manual_seed(0),
)

# Save video
frames = output.frames[0]
export_to_video(frames, "output.mp4", fps=16)

Économies de mémoire de FreeNoise

Étant donné que FreeNoise traite plusieurs images ensemble, certaines parties du modèle nécessitent une quantité de mémoire supérieure à celle disponible sur les GPU grand public classiques. Les principaux goulets d'étranglement mémoire que nous avons identifiés sont les blocs d'attention spatiale et temporelle, les blocs de suréchantillonnage et de sous-échantillonnage, les blocs resnet et les couches feed-forward. Comme la plupart de ces blocs opèrent efficacement uniquement sur la dimension des canaux/embeddings, il est possible d'effectuer une inférence par morceaux (chunked inference) sur les dimensions du lot (batch). La dimension du lot dans AnimateDiff est de nature spatiale ([B x F, H x W, C]) ou temporelle (B x H x W, F, C) (notez que cela peut sembler contre-intuitif, mais les dimensions du lot ici sont correctes, car les blocs spatiaux traitent sur la dimension B x F tandis que les blocs temporels traitent sur la dimension B x H x W). Nous introduisons un SplitInferenceModule qui facilite le découpage par morceaux sur n'importe quelle dimension et l'exécution de l'inférence. Cela économise beaucoup de mémoire, mais au prix d'un temps d'inférence plus long.

# Load pipeline and adapters
# ...
+ pipe.enable_free_noise_split_inference()
+ pipe.unet.enable_forward_chunking(16)

L'appel à la méthode pipe.enable_free_noise_split_inference accepte deux paramètres : spatial_split_size (valeur par défaut 256) et temporal_split_size (valeur par défaut 16). Ils peuvent être configurés en fonction de la quantité de VRAM disponible. Une taille de découpage plus faible entraîne une utilisation mémoire réduite mais une inférence plus lente, tandis qu'une taille de découpage plus importante accélère l'inférence au prix d'une consommation mémoire accrue.

Utiliser from_single_file avec le MotionAdapter

diffusers>=0.30.0 prend en charge le chargement des points de contrôle AnimateDiff dans le MotionAdapter dans leur format d’origine via from_single_file

from diffusers import MotionAdapter

ckpt_path = "https://huggingface.co/Lightricks/LongAnimateDiff/blob/main/lt_long_mm_32_frames.ckpt"

adapter = MotionAdapter.from_single_file(ckpt_path, dtype=torch.float16)
pipe = AnimateDiffPipeline.from_pretrained("emilianJR/epiCRealism", motion_adapter=adapter)

Diffusers

Génération de vidéos à partir de texte avec AnimateDiff

Aperçu

Pipelines disponibles

Points de contrôle disponibles

Exemple d'utilisation

AnimateDiffPipeline

AnimateDiffControlNetPipeline

AnimateDiffSparseControlNetPipeline

Utilisation de SparseCtrl Scribble

Utilisation de SparseCtrl RGB

AnimateDiffSDXLPipeline

AnimateDiffVideoToVideoPipeline

AnimateDiffVideoToVideoControlNetPipeline

Utilisation des Motion LoRAs

Utilisation des Motion LoRAs avec PEFT

Utilisation de FreeInit

Utiliser AnimateLCM

Utiliser FreeNoise

Économies de mémoire de FreeNoise

Utiliser from_single_file avec le MotionAdapter

AnimateDiffPipeline

classe diffusers.AnimateDiffPipeline

__call__

encode_prompt

AnimateDiffControlNetPipeline

classe diffusers.AnimateDiffControlNetPipeline

__call__

encode_prompt

AnimateDiffSparseControlNetPipeline

classe diffusers.AnimateDiffSparseControlNetPipeline

__call__

encode_prompt

AnimateDiffSDXLPipeline

classe diffusers.AnimateDiffSDXLPipeline

__call__

encode_prompt

get_guidance_scale_embedding

AnimateDiffVideoToVideoPipeline

classe diffusers.AnimateDiffVideoToVideoPipeline

__call__

encode_prompt

AnimateDiffVideoToVideoControlNetPipeline

classe diffusers.AnimateDiffVideoToVideoControlNetPipeline

__call__

encode_prompt

AnimateDiffPipelineOutput

classe diffusers.pipelines.animatediff.AnimateDiffPipelineOutput

call

call

call

call

call

call