Hugging Face's logo

Diffusers documentation

Latte

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).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Latte

latte text-to-video

Latte: Latent Diffusion Transformer for Video Generation 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, SkyTimelapse, UCF101 y Taichi-HD. Para preparar y descargar los conjuntos de datos para la evaluación, consulte este URL.

Este pipeline fue aportado por maxin-cn. La base de código original se puede encontrar aquí. Los pesos originales se pueden encontrar en hf.co/maxin-cn.

Asegúrate de consultar la guía de Schedulers para aprender a explorar el equilibrio entre la velocidad y la calidad del scheduler, y consulta la sección reutilizar componentes entre pipelines para aprender a cargar eficientemente los mismos componentes en múltiples pipelines.

Inferencia

Use torch.compile para reducir la latencia de inferencia.

Primero, carga el pipeline:

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:

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:

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 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 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 cuantizado para inferencia con bitsandbytes.

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

clase diffusers.LattePipeline

< >

( tokenizer: T5Tokenizertext_encoder: T5EncoderModelvae: AutoencoderKLtransformer: LatteTransformer3DModelscheduler: KarrasDiffusionSchedulers )

Parámetros

  • vae (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, específicamente la variante t5-v1_1-xxl.
  • tokenizer (T5Tokenizer) — Tokenizer de la clase T5Tokenizer.
  • transformer (LatteTransformer3DModel) — Un LatteTransformer3DModel condicionado por texto para desruidar los latentes de video codificados.
  • scheduler (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. 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__

< >

( prompt: str | list[str] = Nonenegative_prompt: str = ''num_inference_steps: int = 50timesteps: list[int] | None = Noneguidance_scale: float = 7.5num_images_per_prompt: int = 1video_length: int = 16height: int = 512width: int = 512eta: float = 0.0generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.FloatTensor] = Noneprompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_type: str = 'pil'return_dict: bool = Truecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list = ['latents']clean_caption: bool = Truemask_feature: bool = Trueenable_temporal_attentions: bool = Truedecode_chunk_size: int = 14 ) → LattePipelineOutput or tuple

Parámetros

  • prompt (str o list[str], opcional) — El prompt o los prompts para guiar la generación del video. Si no se define, hay que 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 dar lugar 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 num_inference_steps pasos de tiempo equiespaciados. Deben estar en orden descendente.
  • guidance_scale (float, opcional, valor predeterminado 7.0) — Escala de guía tal como se define en Classifier-Free Diffusion Guidance. guidance_scale se define como w de la ecuación 2 de Imagen Paper. La escala de guía se habilita al establecer guidance_scale > 1. Una escala de guía más alta fomenta la generación de videos estrechamente vinculados al prompt de texto, generalmente a costa de una menor calidad del video.
  • video_length (int, opcional, valor predeterminado 16) — El número de fotogramas de vídeo 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 vídeos que se generarán por indicación.
  • height (int, opcional, valor predeterminado: self.unet.config.sample_size) — La altura en píxeles del video generado.
  • width (int, opcional, valor predeterminado: 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 (η) del artículo DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a schedulers.DDIMScheduler y se ignorará en los demás.
  • generator (torch.Generator o list[torch.Generator], opcional) — Un generador o una lista de generadores de torch 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 usar 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) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, las incrustaciones de texto se generarán a partir del argumento de entrada prompt.
  • negative_prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. 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, valor predeterminado "pil") — El formato de salida del video generado. Elija entre PIL: PIL.Image.Image o np.array.
  • return_dict (bool, opcional, valor predeterminado True) — Indica si se debe devolver 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 desruido.
  • 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:

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

< >

( prompt: str | list[str]do_classifier_free_guidance: bool = Truenegative_prompt: str = ''num_images_per_prompt: int = 1device: typing.Optional[torch.device] = Noneprompt_embeds: typing.Optional[torch.FloatTensor] = Nonenegative_prompt_embeds: typing.Optional[torch.FloatTensor] = Noneclean_caption: bool = Falsemask_feature: bool = Truedtype = None )

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, valor predeterminado 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) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporcionan, las incrustaciones de texto se generarán a partir del argumento de entrada prompt.
  • negative_prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. Para Latte, deben ser las incrustaciones de la cadena "".
  • clean_caption (bool, por defecto False) — Si es True, la función preprocesará y limpiará la descripción proporcionada antes de codificarla.
  • mask_feature — (bool, por defecto True): Si es True, la función enmascarará las incrustaciones de texto.

Codifica el prompt en estados ocultos del codificador de texto.

Update on GitHub

←Kandinsky S2V 1.0 LTX-2→