#
# Bajo licencia Apache License, versión 2.0 (la "Licencia");
# no puede usar este archivo excepto en cumplimiento de la Licencia.
# Puede obtener una copia de la Licencia en
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que la ley aplicable lo exija o se haya acordado por escrito, el software
# distribuido bajo la Licencia se distribuye en una base "TAL CUAL",
# SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita.
# Consulte la Licencia para el lenguaje específico que rige los permisos y
# limitaciones de la Licencia. -->

# Latte

![latte text-to-video](https://github.com/Vchitect/Latte/blob/52bc0029899babbd6e9250384c83d8ed2670ff7a/visuals/latte.gif?raw=true)

[Latte: Latent Diffusion Transformer for Video Generation](https://huggingface.co/papers/2401.03048) de la Universidad de Monash, el Shanghai AI Lab, la Universidad de Nankín y la Universidad Tecnológica de Nanyang.

El resumen del artículo es:

*Proponemos un nuevo Latent Diffusion Transformer, denominado Latte, para la generación de video. Latte primero extrae tokens espaciotemporales de los videos de entrada y luego adopta una serie de bloques Transformer para modelar la distribución del video en el espacio latente. Para modelar un número sustancial de tokens extraídos de los videos, se introducen cuatro variantes eficientes desde la perspectiva de descomponer las dimensiones espacial y temporal de los videos de entrada. Para mejorar la calidad de los videos generados, determinamos las mejores prácticas de Latte mediante un análisis experimental riguroso, que incluye el patch embedding de clips de video, variantes del modelo, inyección de información de clase de timestep, embedding posicional temporal y estrategias de aprendizaje. Nuestra evaluación integral demuestra que Latte logra un rendimiento state-of-the-art en cuatro conjuntos de datos estándar de generación de video, a saber, FaceForensics, SkyTimelapse, UCF101 y Taichi-HD. Además, extendemos Latte a la tarea de generación de video a partir de texto (T2V), donde Latte logra resultados comparables a los de los modelos T2V recientes. Creemos firmemente que Latte proporciona valiosas perspectivas para la investigación futura sobre la incorporación de Transformers en modelos de difusión para la generación de video.*

**Aspectos destacados**: Latte es un transformador de difusión latente propuesto como columna vertebral para modelar diferentes modalidades (aquí entrenado para la generación de video a partir de texto). Alcanza un rendimiento líder en cuatro benchmarks estándar de video: [FaceForensics](https://huggingface.co/papers/1803.09179), [SkyTimelapse](https://huggingface.co/papers/1709.07592), [UCF101](https://huggingface.co/papers/1212.0402) y [Taichi-HD](https://huggingface.co/papers/2003.00196). Para preparar y descargar los conjuntos de datos para la evaluación, consulte [este URL](https://github.com/Vchitect/Latte/blob/main/docs/datasets_evaluation.md).

Este pipeline fue aportado por [maxin-cn](https://github.com/maxin-cn). La base de código original se puede encontrar [aquí](https://github.com/Vchitect/Latte). Los pesos originales se pueden encontrar en [hf.co/maxin-cn](https://huggingface.co/maxin-cn).

> [!TIP]
> Asegúrate de consultar la [guía de Schedulers](../../using-diffusers/schedulers) para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección [reutilizar componentes entre pipelines](../../using-diffusers/loading#reusing-models-in-multiple-pipelines) para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

### Inferencia

Use [`torch.compile`](https://huggingface.co/docs/diffusers/main/en/tutorials/fast_diffusion#torchcompile) para reducir la latencia de inferencia.

Primero, carga el pipeline:

```python
import torch
from diffusers import LattePipeline

pipeline = LattePipeline.from_pretrained(
	"maxin-cn/Latte-1", dtype=torch.float16
).to("cuda")  # or "mps", "xpu", "cpu"
```

Luego, cambia el diseño de memoria de los componentes `transformer` y `vae` de los pipelines a `torch.channels-last`:

```python
pipeline.transformer.to(memory_format=torch.channels_last)
pipeline.vae.to(memory_format=torch.channels_last)
```

Por último, compile los componentes y ejecute la inferencia:

```python
pipeline.transformer = torch.compile(pipeline.transformer)
pipeline.vae.decode = torch.compile(pipeline.vae.decode)

video = pipeline(prompt="A dog wearing sunglasses floating in space, surreal, nebulae in background").frames[0]
```

Los resultados del [benchmark](https://gist.github.com/a-r-r-o-w/4e1694ca46374793c0361d740a99ff19) en una máquina A100 de 80 GB son:

```
Without torch.compile(): Average inference time: 16.246 seconds.
With torch.compile(): Average inference time: 14.573 seconds.
```

## Cuantización

La cuantización ayuda a reducir los requisitos de memoria de los modelos muy grandes almacenando los pesos del modelo en un tipo de datos de menor precisión. Sin embargo, la cuantización puede tener un impacto variable en la calidad del vídeo dependiendo del modelo de vídeo.

Consulte el resumen de [Quantization](../../quantization/overview) para obtener más información sobre los backends de cuantización admitidos y la selección de un backend de cuantización que admita su caso de uso. El siguiente ejemplo demuestra cómo cargar un [LattePipeline](/docs/diffusers/v0.43.0/es/api/pipelines/latte#diffusers.LattePipeline) cuantizado para inferencia con bitsandbytes.

```py
import torch
from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, LatteTransformer3DModel, LattePipeline
from diffusers.utils import export_to_gif
from transformers import BitsAndBytesConfig as BitsAndBytesConfig, T5EncoderModel

quant_config = BitsAndBytesConfig(load_in_8bit=True)
text_encoder_8bit = T5EncoderModel.from_pretrained(
    "maxin-cn/Latte-1",
    subfolder="text_encoder",
    quantization_config=quant_config,
    dtype=torch.float16,
)

quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True)
transformer_8bit = LatteTransformer3DModel.from_pretrained(
    "maxin-cn/Latte-1",
    subfolder="transformer",
    quantization_config=quant_config,
    dtype=torch.float16,
)

pipeline = LattePipeline.from_pretrained(
    "maxin-cn/Latte-1",
    text_encoder=text_encoder_8bit,
    transformer=transformer_8bit,
    dtype=torch.float16,
    device_map="balanced",
)

prompt = "A small cactus with a happy face in the Sahara desert."
video = pipeline(prompt).frames[0]
export_to_gif(video, "latte.gif")
```

## LattePipeline[[diffusers.LattePipeline]]

#### diffusers.LattePipeline[[diffusers.LattePipeline]]

```python
diffusers.LattePipeline(tokenizer: T5Tokenizer, text_encoder: T5EncoderModel, vae: AutoencoderKL, transformer: LatteTransformer3DModel, scheduler: KarrasDiffusionSchedulers)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latte/pipeline_latte.py#L145)

**Parámetros:**

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

text_encoder (`T5EncoderModel`) : Codificador de texto congelado. Latte utiliza [T5](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5EncoderModel), específicamente la variante [t5-v1_1-xxl](https://huggingface.co/PixArt-alpha/PixArt-alpha/tree/main/t5-v1_1-xxl).

tokenizer (`T5Tokenizer`) : Tokenizador de la clase [T5Tokenizer](https://huggingface.co/docs/transformers/model_doc/t5#transformers.T5Tokenizer).

transformer ([LatteTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/latte_transformer3d#diffusers.LatteTransformer3DModel)) : Un `LatteTransformer3DModel` condicionado por texto para desruidar los latentes de video codificados.

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/es/api/schedulers/overview#diffusers.SchedulerMixin)) : Un scheduler para usar en combinación con `transformer` para desruidar los latentes de video codificados.

Pipeline para la generación de texto a video usando Latte.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.)

#### __call__[[diffusers.LattePipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 50, timesteps: list[int] | None = None, guidance_scale: float = 7.5, num_images_per_prompt: int = 1, video_length: int = 16, height: int = 512, width: int = 512, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.FloatTensor] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, output_type: str = 'pil', return_dict: bool = True, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], clean_caption: bool = True, mask_feature: bool = True, enable_temporal_attentions: bool = True, decode_chunk_size: int = 14)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latte/pipeline_latte.py#L613)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación del video. Si no se define, se debe pasar `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación del video. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

num_inference_steps (`int`, *opcional*, valor predeterminado 100) : El número de pasos de desruido. Más pasos de desruido suelen conducir a un video de mayor calidad a costa de una inferencia más lenta.

timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido. Si no se definen, se utilizan pasos de tiempo `num_inference_steps` equiespaciados. Deben estar en orden descendente.

guidance_scale (`float`, *opcional*, valor predeterminado 7.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de videos estrechamente vinculados al `prompt` de texto, generalmente a costa de una menor calidad de video.

video_length (`int`, *opcional*, valor predeterminado 16) : El número de fotogramas de video que se generan. El valor predeterminado es de 16 fotogramas, lo que a 8 fotogramas por segundo

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación.

height (`int`, *opcional*, predeterminado a self.unet.config.sample_size) : La altura en píxeles del video generado.

width (`int`, *opcional*, predeterminado a self.unet.config.sample_size) : El ancho en píxeles del video generado.

eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.FloatTensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se usarán como entradas para la generación de video. Se pueden utilizar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para Latte, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida del video generado. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve un `~pipelines.stable_diffusion.IFPipelineOutput` en lugar de una tupla simple.

callback_on_step_end (`Callable[[int, int], None]`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : Una función de callback o una lista de funciones de callback que se llamarán al final de cada paso de denoising.

callback_on_step_end_tensor_inputs (`list[str]`, *opcional*) : Una lista de entradas de tensor que deben pasarse a la función de callback. Si no se define, se pasarán todas las entradas de tensor.

clean_caption (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe limpiar la descripción antes de crear los embeddings. Requiere que `beautifulsoup4` y `ftfy` estén instalados. Si las dependencias no están instaladas, los embeddings se crearán a partir del prompt sin procesar.

mask_feature (`bool` por defecto `True`) : Si se establece en `True`, las incrustaciones de texto se enmascararán.

enable_temporal_attentions (`bool`, *opcional*, valor predeterminado `True`) : Si se habilitan las atenciones temporales

decode_chunk_size (`int`, *opcional*) : El número de fotogramas a decodificar a la vez. Un tamaño de bloque más alto conduce a una mejor consistencia temporal a costa de un mayor uso de memoria. De forma predeterminada, el decodificador decodifica todos los fotogramas a la vez para una calidad máxima. Para un menor uso de memoria, reduzca `decode_chunk_size`.

**Devuelve:** `LattePipelineOutput` o `tuple`

Si `return_dict` es `True`, se devuelve `LattePipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```py
>>> import torch
>>> from diffusers import LattePipeline
>>> from diffusers.utils import export_to_gif

>>> # You can replace the checkpoint id with "maxin-cn/Latte-1" too.
>>> pipe = LattePipeline.from_pretrained("maxin-cn/Latte-1", torch_dtype=torch.float16)
>>> # Enable memory optimizations.
>>> pipe.enable_model_cpu_offload()

>>> prompt = "A small cactus with a happy face in the Sahara desert."
>>> videos = pipe(prompt).frames[0]
>>> export_to_gif(videos, "latte.gif")
```

#### encode_prompt[[diffusers.LattePipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str = '', num_images_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.FloatTensor] = None, negative_prompt_embeds: typing.Optional[torch.FloatTensor] = None, clean_caption: bool = False, mask_feature: bool = True, dtype = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/latte/pipeline_latte.py#L206)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt que no debe guiar la generación del video. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). Para Latte, esto debería ser "".

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : si se debe usar classifier free guidance o no

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : número de videos que deben generarse por indicación

device : (`torch.device`, *opcional*): dispositivo de torch en el que colocar las incrustaciones resultantes

prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.FloatTensor`, *opcional*) : Embeddings de texto negativo pregenerados. Para Latte, deben ser los embeddings de la cadena "".

clean_caption (bool, por defecto `False`) : Si `True`, la función preprocesará y limpiará la descripción proporcionada antes de codificarla.

mask_feature : (bool, por defecto `True`): Si `True`, la función enmascarará las incrustaciones de texto.

Codifica el prompt en estados ocultos del codificador de texto.