Diffusers documentation

AnimateDiff를 활용한 텍스트-비디오 생성

Diffusers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.42.1).

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

AnimateDiff를 활용한 텍스트-비디오 생성

개요

Yuwei Guo, Ceyuan Yang, Anyi Rao, Yaohui Wang, Yu Qiao, Dahua Lin, Bo Dai의 AnimateDiff: Animate Your Personalized Text-to-Image Diffusion Models without Specific Tuning

해당 논문의 초록은 다음과 같습니다:

텍스트-이미지 모델(예: Stable Diffusion)과 DreamBooth, LoRA와 같은 개인화 기법의 발전으로, 누구나 합리적인 비용으로 상상력을 고품질 이미지로 구현할 수 있게 되었습니다. 이에 따라 생성된 정적 이미지에 움직임 역학을 결합하기 위한 이미지 애니메이션 기법에 대한 수요가 크게 증가하고 있습니다. 본 보고서에서는 모델별 튜닝에 드는 노력을 절감하기 위해, 기존 대부분의 개인화 텍스트-이미지 모델을 한 번에 애니메이션화할 수 있는 실용적인 프레임워크를 제안합니다. 제안된 프레임워크의 핵심은 동결된 텍스트-이미지 모델에 새로 초기화된 움직임 모델링 모듈을 삽입하고, 비디오 클립으로 이를 학습하여 합리적인 움직임 선행 지식을 증류하는 것입니다. 학습이 완료되면, 이 움직임 모델링 모듈을 단순히 주입하기만 하면 동일한 기반 T2I에서 파생된 모든 개인화 버전이 다양한 개인화 애니메이션 이미지를 생성하는 텍스트 기반 모델로 즉시 전환됩니다. 애니메이션 이미지와 실사 사진에 걸쳐 여러 공개 대표 개인화 텍스트-이미지 모델을 대상으로 평가를 수행했으며, 제안된 프레임워크가 이러한 모델이 출력의 도메인과 다양성을 유지하면서 시간적으로 매끄러운 애니메이션 클립을 생성하는 데 도움이 됨을 입증했습니다. 코드와 사전 학습된 가중치는 이 https URL에서 공개될 예정입니다.

사용 가능한 파이프라인

Pipeline	작업	데모
AnimateDiffPipeline	AnimateDiff를 활용한 텍스트-비디오 생성
AnimateDiffControlNetPipeline	ControlNet을 사용한 AnimateDiff 기반 제어형 비디오-투-비디오 생성
AnimateDiffSparseControlNetPipeline	SparseCtrl를 사용한 AnimateDiff 기반 제어형 비디오-투-비디오 생성
AnimateDiffSDXLPipeline	AnimateDiff를 활용한 비디오-투-비디오 생성
AnimateDiffVideoToVideoPipeline	AnimateDiff를 활용한 비디오-투-비디오 생성
AnimateDiffVideoToVideoControlNetPipeline	ControlNet을 사용한 AnimateDiff로 비디오-투-비디오 생성

사용 가능한 체크포인트

Motion Adapter 체크포인트는 guoyww 아래에서 찾을 수 있습니다. 이 체크포인트는 Stable Diffusion 1.4/1.5 기반의 모든 모델과 함께 작동하도록 설계되었습니다.

사용 예시

AnimateDiffPipeline

AnimateDiff는 MotionAdapter 체크포인트와 Stable Diffusion 모델 체크포인트와 함께 작동합니다. MotionAdapter는 이미지 프레임 간에 일관된 모션을 추가하는 역할을 하는 Motion Modules의 집합입니다. 이러한 모듈은 Stable Diffusion UNet의 Resnet 및 Attention 블록 이후에 적용됩니다.

다음 예제는 StableDiffusion-1.4/1.5 기반의 Diffusers 추론에 MotionAdapter 체크포인트를 사용하는 방법을 보여줍니다.

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")

다음은 샘플 출력입니다:

masterpiece, bestquality, sunset.

AnimateDiff은 미세 조정된 Stable Diffusion 모델과 함께 사용할 때 더 잘 작동하는 경향이 있습니다. 샘플을 클리핑할 수 있는 스케줄러를 사용할 계획이라면, 생성된 샘플에 부정적인 영향을 미칠 수 있으므로 스케줄러에서 clip_sample=False를 설정하여 이를 비활성화해야 합니다. 또한, AnimateDiff 체크포인트는 스케줄러의 베타 스케줄에 민감할 수 있습니다. 이를 linear로 설정하는 것을 권장합니다.

AnimateDiffControlNetPipeline

AnimateDiff는 ControlNet과 함께 사용할 수도 있습니다. ControlNet은 Lvmin Zhang, Anyi Rao, Maneesh Agrawala가 Adding Conditional Control to Text-to-Image Diffusion Models에서 소개했습니다. ControlNet 모델을 사용하면 추가적인 제어 이미지를 제공하여 Stable Diffusion 생성을 조건화하고 제어할 수 있습니다. 예를 들어, 깊이 맵을 제공하면 ControlNet 모델이 깊이 맵의 공간 정보를 보존하는 비디오를 생성합니다. 이는 비디오 생성 과정을 제어하는 더 유연하고 정확한 방법입니다.

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)

다음은 샘플 출력입니다:

원본 비디오	출력 비디오
기타를 치는 라쿤	판다, 기타 연주, 분홍색 보트 위에 앉아 있음, 바다, 배경에 산, 사실적, 고품질

AnimateDiffSparseControlNetPipeline

Yuwei Guo, Ceyuan Yang, Anyi Rao, Maneesh Agrawala, Dahua Lin, Bo Dai의 SparseCtrl: Adding Sparse Controls to Text-to-Video Diffusion Models은 텍스트-비디오 확산 모델에서 제어 가능한 생성을 달성하기 위한 방법입니다.

해당 논문의 초록은 다음과 같습니다:

텍스트에서 비디오로 변환(T2V), 즉 주어진 텍스트 프롬프트로 비디오를 생성하는 기술은 최근 몇 년간 크게 발전했습니다. 그러나 텍스트 프롬프트에만 의존하면 공간적 불확실성으로 인해 프레임 구성이 모호해지기 쉽습니다. 이에 연구 커뮤니티는 프레임별 깊이/엣지 시퀀스와 같은 밀집된 구조 신호를 활용하여 제어 가능성을 높이고자 하지만, 이로 인해 추론 시 수집해야 할 부하가 증가합니다. 본 연구에서는 Figure 1에 제시된 바와 같이, 시간적으로 희소(sparse)한 신호를 사용하여 유연한 구조 제어를 가능하게 하는 SparseCtrl을 제안합니다. 이 방법은 입력으로 하나 또는 소수의 신호만 필요로 하며, 사전 학습된 T2V 모델은 그대로 유지하면서 이러한 희소 신호를 처리하기 위한 추가 조건 인코더를 통합합니다. 제안된 접근법은 스케치, 깊이 맵, RGB 이미지 등 다양한 모달리티와 호환되어 비디오 생성에 보다 실용적인 제어를 제공하며, 스토리보딩, 깊이 렌더링, 키프레임 애니메이션, 보간과 같은 응용 분야를 촉진합니다. 광범위한 실험을 통해 SparseCtrl이 원래의 T2V 생성기 및 개인화된 T2V 생성기 모두에서 일반화됨을 입증했습니다. 코드와 모델은 이 https URL에서 공개될 예정입니다.

SparseCtrl는 제어 가능한 텍스트-비디오 생성을 위해 다음 체크포인트를 소개합니다:

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")

다음은 샘플 출력입니다:

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

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")

다음은 샘플 출력입니다:

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

AnimateDiffSDXLPipeline

AnimateDiff는 SDXL 모델과 함께 사용할 수도 있습니다. 현재 이는 실험적 기능이며, motion adapter checkpoint의 베타 버전만 사용 가능합니다.

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는 초기 비디오를 기반으로 시각적으로 유사한 비디오를 생성하거나 스타일/캐릭터/배경 등 다른 편집을 수행할 수 있어, 창의적 가능성을 매끄럽게 탐색할 수 있습니다.

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")

다음은 샘플 출력입니다:

원본 비디오	출력 비디오
기타를 치는 라쿤	기타를 치는 판다
마고 로비의 클로즈업, 배경에 불꽃놀이, 고품질	토니 스타크, 로버트 다우니 주니어, 불꽃놀이 클로즈업

AnimateDiffVideoToVideoControlNetPipeline

AnimateDiff는 ControlNet과 함께 사용하여 출력에 대한 정밀한 제어를 가능하게 함으로써 video-to-video 생성을 향상시킬 수 있습니다. ControlNet은 Lvmin Zhang, Anyi Rao, Maneesh Agrawala가 Adding Conditional Control to Text-to-Image Diffusion Models에서 소개했으며, 추가적인 제어 이미지를 통해 Stable Diffusion을 조건화하여 비디오 전체에 걸쳐 공간 정보가 보존되도록 합니다.

이 파이프라인을 사용하면 원본 비디오와 제어 이미지 시퀀스 모두를 기반으로 생성을 조건화할 수 있습니다.

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)

다음은 샘플 출력입니다:

원본 비디오	출력 비디오
애니메이션 소녀, 춤추는	우주에서 춤추는 우주비행사

조명과 구도는 소스 비디오에서 가져왔습니다.

Motion LoRA 사용

Motion LoRA는 guoyww/animatediff-motion-adapter-v1-5-2 체크포인트와 함께 작동하는 LoRA 모음입니다. 이러한 LoRA는 애니메이션에 특정 유형의 모션을 추가하는 역할을 합니다.

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")

masterpiece, bestquality, sunset.

PEFT와 함께 Motion LoRA 사용

PEFT 백엔드를 활용하여 Motion LoRA를 결합하고 더 복잡한 애니메이션을 만들 수도 있습니다.

먼저 PEFT를 설치합니다

pip install peft

이후 다음 코드를 사용하여 Motion LoRA를 결합할 수 있습니다.

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")

masterpiece, bestquality, sunset.

FreeInit 사용

Tianxing Wu, Chenyang Si, Yuming Jiang, Ziqi Huang, Ziwei Liu의 FreeInit: Bridging Initialization Gap in Video Diffusion Models

FreeInit은 추가 학습 없이 video-diffusion-models를 사용하여 생성된 비디오의 시간적 일관성과 전반적인 품질을 향상시키는 효과적인 방법입니다. 추론 시점에 AnimateDiff, ModelScope, VideoCrafter 및 기타 다양한 비디오 생성 모델에 원활하게 적용할 수 있으며, 잠재 초기화 노이즈를 반복적으로 정제하는 방식으로 작동합니다. 자세한 내용은 해당 논문에서 확인할 수 있습니다.

다음 예제는 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은 실제로 무료가 아닙니다 - 향상된 품질은 추가 계산 비용으로 얻어집니다. 활성화 시 설정하는 num_iters 파라미터에 따라 몇 번의 추가 샘플링이 필요합니다. use_fast_sampling 파라미터를 True로 설정하면 전반적인 성능을 향상시킬 수 있습니다(use_fast_sampling=False인 경우보다 품질은 낮지만, 여전히 일반 비디오 생성 모델보다 나은 결과를 제공합니다).

Scheduler의 가이드를 확인하여 스케줄러의 속도와 품질 사이의 트레이드오프를 탐색하는 방법을 배우고, 파이프라인 간 구성 요소 재사용 섹션을 확인하여 동일한 구성 요소를 여러 파이프라인에 효율적으로 로드하는 방법을 배워보세요.

FreeInit가 활성화되지 않은 경우	FreeInit 활성화
기타를 치는 판다	기타를 치는 판다

AnimateLCM 사용

AnimateLCM는 이미지 생성 사전 지식과 모션 생성 사전 지식의 증류를 분리하는 일관성 학습 전략을 사용하여 생성된 모션 모듈 체크포인트와 LCM LoRA입니다.

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")

우주 로켓, 4K.
A space rocket, 4K

AnimateLCM은 기존 Motion LoRA와도 호환됩니다.

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")

우주 로켓, 4K.
A space rocket, 4K

FreeNoise 사용

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

FreeNoise는 노이즈 재스케줄링, 슬라이딩 윈도우에 대한 시간적 어텐션, 잠재 프레임의 가중 평균을 활용하여 짧은 영상 생성 모델로 더 긴 영상을 생성할 수 있는 샘플링 메커니즘입니다. 또한 여러 프롬프트와 함께 사용하여 보간된 영상 생성을 허용합니다. 자세한 내용은 논문에서 확인할 수 있습니다.

FreeNoise와 함께 사용할 수 있는 현재 지원되는 AnimateDiff 파이프라인은 다음과 같습니다:

FreeNoise를 사용하려면 파이프라인을 로드한 후 추론 코드에 한 줄을 추가해야 합니다.

+ pipe.enable_free_noise()

이후 단일 프롬프트를 사용하거나, 정수-문자열 쌍의 딕셔너리로 여러 프롬프트를 전달할 수 있습니다. 딕셔너리의 정수 키는 해당 프롬프트의 영향이 최대가 되는 프레임 인덱스에 대응합니다. 각 프레임 인덱스는 단일 문자열 프롬프트에 매핑되어야 합니다. 딕셔너리에 전달되지 않은 중간 프레임 인덱스의 프롬프트는 전달된 프레임 프롬프트 사이를 보간하여 생성됩니다. 기본적으로 단순 선형 보간이 사용됩니다. 그러나 FreeNoise를 활성화할 때 prompt_interpolation_callback 매개변수에 콜백을 전달하여 이 동작을 사용자 정의할 수 있습니다.

전체 예시:

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)

FreeNoise 메모리 절약

FreeNoise는 여러 프레임을 함께 처리하기 때문에, 모델링의 일부에서는 일반 소비자용 GPU에서 사용 가능한 메모리를 초과하는 메모리가 필요합니다. 우리가 식별한 주요 메모리 병목은 공간 및 시간 주의 블록, 업샘플링 및 다운샘플링 블록, resnet 블록, 피드포워드 레이어입니다. 이러한 블록의 대부분은 실제로 채널/임베딩 차원에서만 작동하므로, 배치 차원을 따라 청크 분할 추론을 수행할 수 있습니다. AnimateDiff의 배치 차원은 공간적([B x F, H x W, C])이거나 시간적(B x H x W, F, C)인 성격을 가집니다(반직관적으로 보일 수 있지만, 공간 블록은 B x F 차원을 따라 처리하고 시간 블록은 B x H x W 차원을 따라 처리하기 때문에 여기의 배치 차원은 정확합니다). 우리는 SplitInferenceModule을 도입하여 어떤 차원이든 따라 청크를 나누고 추론을 수행하는 것을 더 쉽게 만들었습니다. 이는 많은 양의 메모리를 절약하지만, 추론에 더 많은 시간이 소요되는 비용이 따릅니다.

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

pipe.enable_free_noise_split_inference 메서드 호출은 두 개의 매개변수를 받습니다: spatial_split_size(기본값 256)과 temporal_split_size(기본값 16). 이 값들은 사용 가능한 VRAM 용량에 따라 설정할 수 있습니다. 분할 크기가 작을수록 메모리 사용량은 줄지만 추론 속도는 느려지고, 분할 크기가 클수록 추론 속도는 빨라지지만 더 많은 메모리가 필요합니다.

MotionAdapter와 함께 from_single_file 사용

diffusers>=0.30.0은 from_single_file를 통해 AnimateDiff 체크포인트를 원래 형식으로 MotionAdapter에 로드하는 것을 지원합니다.

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

AnimateDiff를 활용한 텍스트-비디오 생성

개요

사용 가능한 파이프라인

사용 가능한 체크포인트

사용 예시

AnimateDiffPipeline

AnimateDiffControlNetPipeline

AnimateDiffSparseControlNetPipeline

SparseCtrl Scribble 사용

SparseCtrl RGB 사용

AnimateDiffSDXLPipeline

AnimateDiffVideoToVideoPipeline

AnimateDiffVideoToVideoControlNetPipeline

Motion LoRA 사용

PEFT와 함께 Motion LoRA 사용

FreeInit 사용

AnimateLCM 사용

FreeNoise 사용

FreeNoise 메모리 절약

MotionAdapter와 함께 from_single_file 사용

AnimateDiffPipeline

클래스 diffusers.AnimateDiffPipeline

__call__

encode_prompt

AnimateDiffControlNetPipeline

클래스 diffusers.AnimateDiffControlNetPipeline

__call__

encode_prompt

AnimateDiffSparseControlNetPipeline

클래스 diffusers.AnimateDiffSparseControlNetPipeline

__call__

encode_prompt

AnimateDiffSDXLPipeline

클래스 diffusers.AnimateDiffSDXLPipeline

__call__

encode_prompt

get_guidance_scale_embedding

AnimateDiffVideoToVideoPipeline

클래스 diffusers.AnimateDiffVideoToVideoPipeline

__call__

encode_prompt

AnimateDiffVideoToVideoControlNetPipeline

클래스 diffusers.AnimateDiffVideoToVideoControlNetPipeline

__call__

encode_prompt

AnimateDiffPipelineOutput

클래스 diffusers.pipelines.animatediff.AnimateDiffPipelineOutput

call

call

call

call

call

call