# Stable Video Diffusion

Stable Video Diffusion fue propuesto en [Stable Video Diffusion: Scaling Latent Video Diffusion Models to Large Datasets](https://hf.co/papers/2311.15127) por Andreas Blattmann, Tim Dockhorn, Sumith Kulal, Daniel Mendelevitch, Maciej Kilian, Dominik Lorenz, Yam Levi, Zion English, Vikram Voleti, Adam Letts, Varun Jampani, Robin Rombach.

El resumen del artículo es:

*Presentamos Stable Video Diffusion, un modelo de difusión latente para video, orientado a la generación de texto a video e imagen a video en alta resolución y con resultados de última generación. Recientemente, los modelos de difusión latente entrenados para la síntesis de imágenes 2D se han convertido en modelos generativos de video mediante la inserción de capas temporales y su ajuste fino en conjuntos de datos de video pequeños y de alta calidad. Sin embargo, los métodos de entrenamiento en la literatura varían ampliamente y el campo aún no ha llegado a un acuerdo sobre una estrategia unificada para la curaduría de datos de video. En este artículo, identificamos y evaluamos tres etapas distintas para el entrenamiento exitoso de LDMs de video: preentrenamiento de texto a imagen, preentrenamiento de video y ajuste fino en video de alta calidad. Además, demostramos la necesidad de un conjunto de datos de preentrenamiento bien curado para generar videos de alta calidad y presentamos un proceso sistemático de curaduría para entrenar un modelo base sólido, que incluye estrategias de etiquetado y filtrado. A continuación, exploramos el impacto de ajustar nuestro modelo base con datos de alta calidad y entrenamos un modelo de texto a video que es competitivo con la generación de video de código cerrado. También mostramos que nuestro modelo base proporciona una representación de movimiento potente para tareas posteriores, como la generación de imagen a video, y una adaptabilidad a módulos LoRA específicos de movimiento de cámara. Finalmente, demostramos que nuestro modelo proporciona un fuerte prior 3D multivista y puede servir como base para ajustar un modelo de difusión multivista que genera conjuntamente múltiples vistas de objetos de manera feedforward, superando a los métodos basados en imágenes con una fracción de su presupuesto de cómputo. Publicamos el código y los pesos del modelo en esta https URL.*

> [!TIP]
> Echa un vistazo a la organización de [Stability AI](https://huggingface.co/stabilityai) en el Hub para los puntos de control de [base](https://huggingface.co/stabilityai/stable-video-diffusion-img2vid) y [extended frame](https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt)!

Asegúrate de tener instaladas las siguientes bibliotecas.

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

Hay dos variantes de este modelo, [SVD](https://huggingface.co/stabilityai/stable-video-diffusion-img2vid) y [SVD-XT](https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt). El checkpoint SVD está entrenado para generar 14 fotogramas y el checkpoint SVD-XT se ha afinado adicionalmente para generar 25 fotogramas.

Utilizarás el checkpoint SVD-XT para esta guía.

```python
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)
```

  
    
    "imagen de origen de un cohete"
  
  
    
    "video generado a partir de la imagen de origen"
  

## torch.compile

Puede obtener una aceleración del 20-25% a costa de un ligero aumento de memoria [compilando](../../../optimization/fp16#torchcompile) el UNet.

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

## Reducir el uso de memoria

La generación de vídeo consume mucha memoria porque, en esencia, se generan `num_frames` a la vez, de forma similar a la generación de imagen a partir de texto con un tamaño de lote alto. Para reducir el requisito de memoria, hay varias opciones que sacrifican la velocidad de inferencia a cambio de un menor consumo de memoria:

- habilitar el descargado del modelo: cada componente de la tubería se descarga a la CPU cuando ya no se necesita.
- habilitar el procesamiento por bloques de la capa feed-forward: la capa feed-forward se ejecuta en un bucle en lugar de realizar una única operación feed-forward con un tamaño de lote enorme.
- reduce `decode_chunk_size`: el VAE decodifica los fotogramas en bloques en lugar de decodificarlos todos a la vez. Establecer `decode_chunk_size=1` decodifica un fotograma a la vez y utiliza la menor cantidad de memoria (recomendamos ajustar este valor según la memoria de tu GPU), pero el video podría presentar algún parpadeo.

```diff
- 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]
```

Usar todos estos trucos juntos debería reducir el requisito de memoria a menos de 8 GB de VRAM.

## Micro-condicionamiento

Stable Diffusion Video también acepta micro-condicionamiento, además de la imagen de condicionamiento, lo que permite un mayor control sobre el video generado:

- `fps`: los fotogramas por segundo del video generado.
- `motion_bucket_id`: el identificador de cubo de movimiento a utilizar para el video generado. Esto se puede usar para controlar el movimiento del video generado. Aumentar el identificador de cubo de movimiento aumenta el movimiento del video generado.
- `noise_aug_strength`: la cantidad de ruido que se añade a la imagen de condicionamiento. A mayor valor, menos se parecerá el video a la imagen de condicionamiento. Aumentar este valor también incrementa el movimiento del video generado.

Por ejemplo, para generar un video con más movimiento, utiliza los parámetros de microcondicionamiento `motion_bucket_id` y `noise_aug_strength`:

```python
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)
```

![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/svd/output_rocket_with_conditions.gif)

## StableVideoDiffusionPipeline[[diffusers.StableVideoDiffusionPipeline]]

#### diffusers.StableVideoDiffusionPipeline[[diffusers.StableVideoDiffusionPipeline]]

```python
diffusers.StableVideoDiffusionPipeline(vae: AutoencoderKLTemporalDecoder, image_encoder: CLIPVisionModelWithProjection, unet: UNetSpatioTemporalConditionModel, scheduler: EulerDiscreteScheduler, feature_extractor: CLIPImageProcessorPil)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_video_diffusion/pipeline_stable_video_diffusion.py#L147)

**Parámetros:**

vae (`AutoencoderKLTemporalDecoder`) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar imágenes a partir de representaciones latentes.

image_encoder ([CLIPVisionModelWithProjection](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPVisionModelWithProjection)) : Codificador de imágenes CLIP congelado ([laion/CLIP-ViT-H-14-laion2B-s32B-b79K](https://huggingface.co/laion/CLIP-ViT-H-14-laion2B-s32B-b79K)).

unet (`UNetSpatioTemporalConditionModel`) : Un `UNetSpatioTemporalConditionModel` para desruidar los latentes de imagen codificados.

scheduler ([EulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/euler#diffusers.EulerDiscreteScheduler)) : Un programador para usar en combinación con `unet` para desruidar los latentes de imagen codificados.

feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Un `CLIPImageProcessor` para extraer características de las imágenes generadas.

Pipeline para generar video a partir de una imagen de entrada usando Stable Video Diffusion.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.).

## StableVideoDiffusionPipelineOutput[[diffusers.pipelines.stable_video_diffusion.StableVideoDiffusionPipelineOutput]]

#### diffusers.pipelines.stable_video_diffusion.StableVideoDiffusionPipelineOutput[[diffusers.pipelines.stable_video_diffusion.StableVideoDiffusionPipelineOutput]]

```python
diffusers.pipelines.stable_video_diffusion.StableVideoDiffusionPipelineOutput(frames: typing.Union[list[list[PIL.Image.Image]], numpy.ndarray, torch.Tensor])
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_video_diffusion/pipeline_stable_video_diffusion.py#L134)

**Parámetros:**

frames (`[list[list[PIL.Image.Image]]`, `np.ndarray`, `torch.Tensor`]) : lista de imágenes PIL desruidas de longitud `batch_size` o array de numpy o tensor de torch de forma `(batch_size, num_frames, height, width, num_channels)`.

Clase de salida para el pipeline de Stable Video Diffusion.