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 est un modèle de diffusion transformer de 13 milliards de paramètres conçu pour rivaliser avec les modèles de base vidéo propriétaires et permettre un accès plus large à la communauté. Ce modèle utilise une architecture « dual-stream to single-stream » pour traiter d’abord séparément les jetons vidéo et texte, avant de les concaténer et de les transmettre au transformer afin de fusionner les informations multimodales. Un grand modèle de langage multimodal (MLLM) pré-entraîné est utilisé comme encodeur, car il offre un meilleur alignement image-texte, une meilleure description des détails d’image et un meilleur raisonnement, et il peut être utilisé comme apprenant zéro-shot si des instructions système sont ajoutées aux invites utilisateur. Enfin, HunyuanVideo utilise un auto-encodeur variationnel causal 3D pour traiter les données vidéo de manière plus efficace à la résolution et au taux d’images d’origine.

Vous pouvez trouver tous les points de contrôle originaux de HunyuanVideo sous l’organisation Tencent.

Cliquez sur les modèles HunyuanVideo dans la barre latérale droite pour plus d’exemples de tâches de génération de vidéos.

Les exemples ci-dessous utilisent un point de contrôle de hunyuanvideo-community car les poids sont stockés dans une structure compatible avec Diffusers.

L'exemple ci-dessous montre comment générer une vidéo optimisée pour la mémoire ou la vitesse d'inférence.

mémoire
vitesse d'inférence

Reportez-vous au guide Réduire l'utilisation de la mémoire pour plus de détails sur les différentes techniques d'économie de mémoire.

Le modèle HunyuanVideo quantifié ci-dessous nécessite environ 14 Go 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)

Notes

  • HunyuanVideo prend en charge les LoRA avec load_lora_weights().

    Afficher le code d'exemple 
    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)

  • Reportez-vous au tableau ci-dessous pour les valeurs d’inférence recommandées.

    paramètrevaleur recommandée
    dtype de l'encodeur de textetorch.float16
    dtype du transformertorch.bfloat16
    dtype du vaetorch.float16
    num_frames (k)4 * k + 1

  • Essayez des valeurs de shift plus basses (2.0 à 5.0) pour les vidéos de faible résolution et des valeurs de shift plus élevées (7.0 à 12.0) pour les images de haute résolution.

HunyuanVideoPipeline

classe diffusers.HunyuanVideoPipeline

< >

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

Paramètres

Pipeline pour la génération de vidéos à partir de texte utilisant HunyuanVideo.

Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, 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

Paramètres

  • prompt (str ou list[str], facultatif) — Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer prompt_embeds à la place.
  • prompt_2 (str ou list[str], facultatif) — Le prompt ou les prompts à envoyer à tokenizer_2 et text_encoder_2. S'il n'est pas défini, prompt sera utilisé à la place.
  • negative_prompt (str ou list[str], facultatif) — Le ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer negative_prompt_embeds à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si true_cfg_scale n’est pas supérieur à 1).
  • negative_prompt_2 (str ou list[str], facultatif) — Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image, à envoyer à tokenizer_2 et text_encoder_2. S’il n’est pas défini, negative_prompt est utilisé dans tous les encodeurs de texte.
  • height (int, par défaut 720) — La hauteur en pixels de l'image générée.
  • width (int, par défaut 1280) — La largeur en pixels de l'image générée.
  • num_frames (int, par défaut 129) — Le nombre de frames dans la vidéo générée.
  • num_inference_steps (int, par défaut 50) — Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.
  • sigmas (list[float], facultatif) — Sigmas personnalisés à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument sigmas dans leur méthode set_timesteps. S'il n'est pas défini, le comportement par défaut lorsque num_inference_steps est passé sera utilisé.
  • true_cfg_scale (float, facultatif, valeur par défaut 1.0) — Le vrai classifier-free guidance (échelle de guidance) est activé lorsque true_cfg_scale > 1 et que negative_prompt est fourni.
  • guidance_scale (float, par défaut 6.0) — L'échelle de guidage intégrée est activée en définissant guidance_scale > 1. Une valeur plus élevée de guidance_scale encourage le modèle à générer des images plus alignées avec le prompt au détriment de la qualité de l'image.

    Les modèles distillés par guidage approximent le vrai guidage sans classifieur pour guidance_scale > 1. Consultez l'article pour en savoir plus.

  • num_videos_per_prompt (int, facultatif, valeur par défaut 1) — Le nombre d'images à générer par invite.
  • generator (torch.Generator ou list[torch.Generator], facultatif) — Un torch.Generator pour rendre la génération déterministe.
  • latents (torch.Tensor, facultatif) — Latents bruités pré-générés, échantillonnés à partir d’une distribution gaussienne, à utiliser comme entrées pour la génération d’images. Peut servir à ajuster la même génération avec des prompts différents. S’il n’est pas fourni, un tenseur de latents est généré par échantillonnage à l’aide du generator aléatoire fourni.
  • prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entrée prompt.
  • pooled_prompt_embeds (torch.FloatTensor, facultatif) — Embeddings de texte pré-poolés pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte pré-poolés seront générés à partir de l'argument d'entrée prompt.
  • negative_prompt_embeds (torch.FloatTensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée negative_prompt.
  • negative_pooled_prompt_embeds (torch.FloatTensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les pooled negative_prompt_embeds seront générés à partir de l'argument d'entrée negative_prompt.
  • prompt_attention_mask (torch.Tensor, facultatif) — Masque d'attention pour prompt_embeds. Requis lorsque prompt_embeds est passé directement.
  • negative_prompt_attention_mask (torch.Tensor, facultatif) — Masque d'attention pour negative_prompt_embeds. Requis lorsque negative_prompt_embeds est passé directement.
  • output_type (str, facultatif, par défaut "pil") — Le format de sortie de l’image générée. Choisissez entre PIL.Image ou np.array.
  • return_dict (bool, facultatif, par défaut True) — Indique s'il faut retourner un HunyuanVideoPipelineOutput plutôt qu'un simple tuple.
  • attention_kwargs (dict, facultatif) — Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessor défini sous self.processor dans diffusers.models.attention_processor.
  • prompt_template (dict, facultatif) — Modèle utilisé pour formater le prompt avant l’encodage. Par défaut, le modèle utilise son modèle par défaut.
  • max_sequence_length (int, facultatif, valeur par défaut 256) — Longueur maximale de séquence à utiliser pour l'encodeur de prompt.
  • callback_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, facultatif) — Une fonction ou une sous-classe de PipelineCallback ou MultiPipelineCallbacks qui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants : callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs contiendra une liste de tous les tenseurs spécifiés par callback_on_step_end_tensor_inputs.
  • callback_on_step_end_tensor_inputs (list, facultatif) — La liste des entrées tensorielles pour la fonction callback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument callback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut ._callback_tensor_inputs de votre classe de pipeline.

Retourne

~HunyuanVideoPipelineOutput ou tuple

Si return_dict est True, HunyuanVideoPipelineOutput est retourné, sinon un tuple est retourné dont le premier élément est une liste des images générées et le deuxième élément est une liste de bool indiquant si l’image générée correspondante contient du contenu « not-safe-for-work » (nsfw).

La fonction d'appel du pipeline pour la génération.

Exemples :

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

classe diffusers.pipelines.hunyuan_video.pipeline_output.HunyuanVideoPipelineOutput

< >

( frames: Tensor )

Paramètres

  • frames (torch.Tensor, np.ndarray ou list[list[PIL.Image.Image]]) — liste des sorties vidéo - Il peut s'agir d'une liste imbriquée de longueur batch_size, où chaque sous-liste contient des séquences d'images PIL débruitées de longueur num_frames. Il peut également s'agir d'un tableau NumPy ou d'un tenseur Torch de forme (batch_size, num_frames, channels, height, width).

Classe de sortie pour les pipelines HunyuanVideo.

Update on GitHub

←Helios HunyuanVideo1.5→