Hugging Face's logo

Diffusers documentation

HunyuanVideo

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

LoRA

HunyuanVideo

HunyuanVideo es un modelo de difusión transformer de 13B parámetros diseñado para ser competitivo con los modelos de video de código cerrado y permitir un acceso más amplio a la comunidad. Este modelo utiliza una arquitectura de “dual-stream to single-stream” para procesar por separado los tokens de video y texto primero, antes de concatenarlos y enviarlos al transformer para fusionar la información multimodal. Se utiliza un modelo de lenguaje multimodal grande (MLLM) preentrenado como codificador porque tiene una mejor alineación imagen-texto, una mejor descripción de detalles de imagen y razonamiento, y puede usarse como un aprendiz zero-shot si se añaden instrucciones del sistema a los prompts del usuario. Finalmente, HunyuanVideo utiliza un autoencoder variacional causal 3D para procesar los datos de video de manera más eficiente en la resolución y tasa de fotogramas originales.

Puedes encontrar todos los puntos de control originales de HunyuanVideo bajo la organización Tencent.

Haz clic en los modelos HunyuanVideo en la barra lateral derecha para ver más ejemplos de tareas de generación de video.

Los ejemplos a continuación utilizan un punto de control de hunyuanvideo-community porque los pesos se almacenan en un formato compatible con Diffusers.

El siguiente ejemplo demuestra cómo generar un video optimizado para la memoria o la velocidad de inferencia.

memoria
velocidad de inferencia

Consulte la guía Reduce memory usage para obtener más detalles sobre las diversas técnicas de ahorro de memoria.

El modelo HunyuanVideo cuantizado de abajo requiere ~14GB de VRAM.

import torch
from diffusers import AutoModel, HunyuanVideoPipeline
from diffusers.quantizers import PipelineQuantizationConfig
from diffusers.utils import export_to_video

# quantize weights to int4 with bitsandbytes
pipeline_quant_config = PipelineQuantizationConfig(
    quant_backend="bitsandbytes_4bit",
    quant_kwargs={
      "load_in_4bit": True,
      "bnb_4bit_quant_type": "nf4",
      "bnb_4bit_compute_dtype": torch.bfloat16
      },
    components_to_quantize="transformer"
)

pipeline = HunyuanVideoPipeline.from_pretrained(
    "hunyuanvideo-community/HunyuanVideo",
    quantization_config=pipeline_quant_config,
    dtype=torch.bfloat16,
)

# model-offloading and tiling
pipeline.enable_model_cpu_offload()
pipeline.vae.enable_tiling()

prompt = "A fluffy teddy bear sits on a bed of soft pillows surrounded by children's toys."
video = pipeline(prompt=prompt, num_frames=61, num_inference_steps=30).frames[0]
export_to_video(video, "output.mp4", fps=15)

Notas

  • HunyuanVideo admite LoRAs con load_lora_weights().

    Mostrar código de ejemplo 
    import torch
from diffusers import AutoModel, HunyuanVideoPipeline
from diffusers.quantizers import PipelineQuantizationConfig
from diffusers.utils import export_to_video

# quantize weights to int4 with bitsandbytes
pipeline_quant_config = PipelineQuantizationConfig(
    quant_backend="bitsandbytes_4bit",
    quant_kwargs={
      "load_in_4bit": True,
      "bnb_4bit_quant_type": "nf4",
      "bnb_4bit_compute_dtype": torch.bfloat16
      },
    components_to_quantize="transformer"
)

pipeline = HunyuanVideoPipeline.from_pretrained(
    "hunyuanvideo-community/HunyuanVideo",
    quantization_config=pipeline_quant_config,
    dtype=torch.bfloat16,
)

# load LoRA weights
pipeline.load_lora_weights("https://huggingface.co/lucataco/hunyuan-steamboat-willie-10", adapter_name="steamboat-willie")
pipeline.set_adapters("steamboat-willie", 0.9)

# model-offloading and tiling
pipeline.enable_model_cpu_offload()
pipeline.vae.enable_tiling()

# use "In the style of SWR" to trigger the LoRA
prompt = """
In the style of SWR. A black and white animated scene featuring a fluffy teddy bear sits on a bed of soft pillows surrounded by children's toys.
"""
video = pipeline(prompt=prompt, num_frames=61, num_inference_steps=30).frames[0]
export_to_video(video, "output.mp4", fps=15)

  • Consulte la tabla siguiente para conocer los valores de inferencia recomendados.

    parámetrovalor recomendado
    dtype del codificador de textotorch.float16
    dtype del transformertorch.bfloat16
    dtype del vaetorch.float16
    num_frames (k)4 * k + 1

  • Pruebe valores de shift más bajos (2.0 a 5.0) para videos de menor resolución y valores de shift más altos (7.0 a 12.0) para imágenes de mayor resolución.

HunyuanVideoPipeline

clase diffusers.HunyuanVideoPipeline

< >

( text_encoder: LlamaModeltokenizer: LlamaTokenizertransformer: HunyuanVideoTransformer3DModelvae: AutoencoderKLHunyuanVideoscheduler: FlowMatchEulerDiscreteSchedulertext_encoder_2: CLIPTextModeltokenizer_2: CLIPTokenizer )

Parámetros

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

Este modelo hereda de 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.).

__call__

< >

( prompt: str | list[str] = Noneprompt_2: str | list[str] = Nonenegative_prompt: str | list[str] = Nonenegative_prompt_2: str | list[str] = Noneheight: int = 720width: int = 1280num_frames: int = 129num_inference_steps: int = 50sigmas: list[float] = Nonetrue_cfg_scale: float = 1.0guidance_scale: float = 6.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonepooled_prompt_embeds: typing.Optional[torch.Tensor] = Noneprompt_attention_mask: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_pooled_prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_attention_mask: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'pil'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list[str] = ['latents']prompt_template: dict[str, typing.Any] = {'template': '<|start_header_id|>system<|end_header_id|>\n\nDescribe the video by detailing the following aspects: 1. The main content and theme of the video.2. The color, shape, size, texture, quantity, text, and spatial relationships of the objects.3. Actions, events, behaviors temporal relationships, physical movement changes of the objects.4. background environment, light, style and atmosphere.5. camera angles, movements, and transitions used in the video:<|eot_id|><|start_header_id|>user<|end_header_id|>\n\n{}<|eot_id|>', 'crop_start': 95}max_sequence_length: int = 256 ) → ~HunyuanVideoPipelineOutput or tuple

Parámetros

  • prompt (str o list[str], opcional) — El prompt o los prompts para guiar la generación de la imagen. Si no se define, hay que pasar prompt_embeds en su lugar.
  • prompt_2 (str o list[str], opcional) — El prompt o prompts que se enviarán a tokenizer_2 y text_encoder_2. Si no está definido, se utilizará prompt en su lugar.
  • negative_prompt (str o list[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen. 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 true_cfg_scale no es mayor que 1).
  • negative_prompt_2 (str o list[str], opcional) — El prompt o prompts que no deben guiar la generación de la imagen y que se enviarán a tokenizer_2 y text_encoder_2. Si no se define, se utiliza negative_prompt en todos los text-encoders.
  • height (int, por defecto 720) — La altura en píxeles de la imagen generada.
  • width (int, por defecto 1280) — El ancho en píxeles de la imagen generada.
  • num_frames (int, por defecto 129) — El número de fotogramas en el video generado.
  • num_inference_steps (int, por defecto 50) — El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.
  • sigmas (list[float], opcional) — Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento sigmas en su método set_timesteps. Si no se define, se usará el comportamiento predeterminado cuando se pase num_inference_steps.
  • true_cfg_scale (float, opcional, valor predeterminado 1.0) — La guía libre de clasificador real (escala de guía) se habilita cuando true_cfg_scale > 1 y se proporciona negative_prompt.
  • guidance_scale (float, por defecto 6.0) — La escala de guía integrada se habilita al establecer guidance_scale > 1. valores más altos de guidance_scale animan al modelo a generar imágenes más alineadas con la prompt a costa de una menor calidad de imagen.

    Los modelos destilados con guía aproximan la guía libre de clase real para guidance_scale > 1. Consulte el artículo para obtener más información.

  • num_videos_per_prompt (int, opcional, valor predeterminado 1) — El número de imágenes que se generan por indicación.
  • generator (torch.Generator o list[torch.Generator], opcional) — Un torch.Generator para hacer que la generación sea determinista.
  • latents (torch.Tensor, opcional) — Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el generator aleatorio suministrado.
  • prompt_embeds (torch.Tensor, opcional) — Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada prompt.
  • pooled_prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto agrupadas pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. ponderación de prompts. Si no se proporciona, las incrustaciones de texto agrupadas se generarán a partir del argumento de entrada prompt.
  • negative_prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto negativo pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada negative_prompt.
  • negative_pooled_prompt_embeds (torch.FloatTensor, opcional) — Incrustaciones de texto negativo agrupadas pregeneradas. Se pueden utilizar para ajustar fácilmente las entradas de texto, p. ej. el ponderado del prompt. Si no se proporciona, se generarán pooled negative_prompt_embeds a partir del argumento de entrada negative_prompt.
  • prompt_attention_mask (torch.Tensor, opcional) — Máscara de atención para prompt_embeds. Es obligatoria cuando se pasa prompt_embeds directamente.
  • negative_prompt_attention_mask (torch.Tensor, opcional) — Máscara de atención para negative_prompt_embeds. Es obligatoria cuando se pasa negative_prompt_embeds directamente.
  • output_type (str, opcional, por defecto "pil") — El formato de salida de la imagen generada. Elija entre PIL.Image o np.array.
  • return_dict (bool, opcional, valor predeterminado True) — Indica si se debe devolver un HunyuanVideoPipelineOutput en lugar de una tupla simple.
  • attention_kwargs (dict, opcional) — Un diccionario de kwargs que, si se especifica, se pasa al AttentionProcessor definido en self.processor dentro de diffusers.models.attention_processor.
  • prompt_template (dict, opcional) — Plantilla utilizada para formatear el prompt antes de codificarlo. Por defecto, se utiliza la plantilla predeterminada del modelo.
  • max_sequence_length (int, opcional, valor predeterminado 256) — Longitud máxima de secuencia a utilizar para el codificador de prompts.
  • callback_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, opcional) — Una función o una subclase de PipelineCallback o MultiPipelineCallbacks que se llama al final de cada paso de desruido durante la inferencia, con los siguientes argumentos: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs incluirá una lista de todos los tensores especificados por callback_on_step_end_tensor_inputs.
  • callback_on_step_end_tensor_inputs (list, opcional) — La lista de entradas de tensor para la función callback_on_step_end. Los tensores especificados en la lista se pasarán como argumento callback_kwargs. Solo podrás incluir variables listadas en el atributo ._callback_tensor_inputs de tu clase de pipeline.

Devuelve

~HunyuanVideoPipelineOutput o tuple

Si return_dict es True, se devuelve HunyuanVideoPipelineOutput; en caso contrario, se devuelve una tuple cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de bool que indica si la imagen generada correspondiente contiene contenido “not-safe-for-work” (nsfw).

La función de llamada para el pipeline de generación.

Ejemplos:

>>> import torch
>>> from diffusers import HunyuanVideoPipeline, HunyuanVideoTransformer3DModel
>>> from diffusers.utils import export_to_video

>>> model_id = "hunyuanvideo-community/HunyuanVideo"
>>> transformer = HunyuanVideoTransformer3DModel.from_pretrained(
...     model_id, subfolder="transformer", torch_dtype=torch.bfloat16
... )
>>> pipe = HunyuanVideoPipeline.from_pretrained(model_id, transformer=transformer, torch_dtype=torch.float16)
>>> pipe.vae.enable_tiling()
>>> pipe.to("cuda")

>>> output = pipe(
...     prompt="A cat walks on the grass, realistic",
...     height=320,
...     width=512,
...     num_frames=61,
...     num_inference_steps=30,
... ).frames[0]
>>> export_to_video(output, "output.mp4", fps=15)

HunyuanVideoPipelineOutput

clase diffusers.pipelines.hunyuan_video.pipeline_output.HunyuanVideoPipelineOutput

< >

( frames: Tensor )

Parámetros

  • frames (torch.Tensor, np.ndarray o list[list[PIL.Image.Image]]) — lista de salidas de video. Puede ser una lista anidada de longitud batch_size, donde cada sublista contiene secuencias de imágenes PIL desruidas de longitud num_frames. También puede ser un array de NumPy o un tensor de Torch de forma (batch_size, num_frames, channels, height, width).

Clase de salida para las pipelines de HunyuanVideo.

Update on GitHub

←Helios HunyuanVideo1.5→