# # Sous licence Apache License, Version 2.0 (la « Licence ») ; # vous ne pouvez utiliser ce fichier que conformément à la Licence. # Vous pouvez obtenir un exemplaire de la Licence à # # http://www.apache.org/licenses/LICENSE-2.0 # # Sauf exigence légale ou accord écrit # distribué sous la Licence est distribué sur une base « EN L'ÉTAT », # SANS AUCUNE GARANTIE NI CONDITION, explicite ou implicite. # Voir la Licence pour le langage spécifique régissant les autorisations et # limitations under the License. --> # HunyuanVideo-1.5 HunyuanVideo-1.5 est un modèle de génération de vidéo léger mais puissant qui atteint une qualité visuelle et une cohérence du mouvement de pointe avec seulement 8,3 milliards de paramètres, permettant une inférence efficace sur des GPU grand public. Cet accomplissement repose sur plusieurs composants clés, notamment une curation méticuleuse des données, une architecture DiT avancée avec une attention sélective et par tuiles glissantes (SSTA), une compréhension bilingue renforcée par un encodage de texte sensible aux glyphes, un pré-entraînement et un post-entraînement progressifs, ainsi qu'un réseau efficace de super-résolution vidéo. En exploitant ces conceptions, nous avons développé un cadre unifié capable de générer des vidéos de haute qualité à partir de texte et d'image, sur plusieurs durées et résolutions. Des expériences étendues démontrent que ce modèle compact et performant établit une nouvelle référence parmi les modèles open source. Vous pouvez trouver tous les points de contrôle originaux de HunyuanVideo sous l’organisation [Tencent](https://huggingface.co/tencent). > [!TIP] > 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](https://huggingface.co/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. Reportez-vous au guide [Réduire l'utilisation de la mémoire](../../optimization/memory) pour plus de détails sur les différentes techniques d'économie de mémoire. ```py import torch from diffusers import AutoModel, HunyuanVideo15Pipeline from diffusers.utils import export_to_video pipeline = HunyuanVideo15Pipeline.from_pretrained( "HunyuanVideo-1.5-Diffusers-480p_t2v", 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 - HunyuanVideo1.5 utilise des masques d'attention avec des séquences de longueur variable. Pour de meilleures performances, nous recommandons d'utiliser un backend d'attention qui gère efficacement le bourrage (padding). - **H100/H800 :** `_flash_3_hub` ou `_flash_3_varlen_hub` - **A100/A800/RTX 4090 :** `flash_hub` ou `flash_varlen_hub` - **Autres GPU :** `sage_hub` Reportez-vous au guide [Backends d'attention](../../optimization/attention_backends) pour plus de détails sur l'utilisation d'un backend différent. ```py pipe.transformer.set_attention_backend("flash_hub") # or your preferred backend ``` - [HunyuanVideo15Pipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/hunyuan_video15#diffusers.HunyuanVideo15Pipeline) utilise un guideur et n’accepte pas le paramètre `guidance_scale` à l’exécution. Vous pouvez vérifier la configuration par défaut du guider à l'aide de `pipe.guider` : ```py >>> pipe.guider ClassifierFreeGuidance { "_class_name": "ClassifierFreeGuidance", "_diffusers_version": "0.36.0.dev0", "enabled": true, "guidance_rescale": 0.0, "guidance_scale": 6.0, "start": 0.0, "stop": 1.0, "use_original_formulation": false } State: step: None num_inference_steps: None timestep: None count_prepared: 0 enabled: True num_conditions: 2 ``` Pour mettre à jour la configuration de guider, vous pouvez exécuter `pipe.guider = pipe.guider.new(...)` ```py pipe.guider = pipe.guider.new(guidance_scale=5.0) ``` En savoir plus sur Guider [ici](../../using-diffusers/guiders). ## HunyuanVideo15Pipeline[[diffusers.HunyuanVideo15Pipeline]] #### diffusers.HunyuanVideo15Pipeline[[diffusers.HunyuanVideo15Pipeline]] ```python diffusers.HunyuanVideo15Pipeline(text_encoder: Qwen2_5_VLTextModel, tokenizer: Qwen2Tokenizer, transformer: HunyuanVideo15Transformer3DModel, vae: AutoencoderKLHunyuanVideo15, scheduler: FlowMatchEulerDiscreteScheduler, text_encoder_2: T5EncoderModel, tokenizer_2: ByT5Tokenizer, guider: ClassifierFreeGuidance) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5.py#L166) **Paramètres :** transformer ([HunyuanVideo15Transformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/hunyuan_video15_transformer_3d#diffusers.HunyuanVideo15Transformer3DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents vidéo encodés. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents vidéo encodés. vae ([AutoencoderKLHunyuanVideo15](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_hunyuan_video15#diffusers.AutoencoderKLHunyuanVideo15)) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), plus précisément la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer de la classe [Qwen2Tokenizer]. text_encoder_2 (`T5EncoderModel`) : variante [T5EncoderModel](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel). tokenizer_2 (`ByT5Tokenizer`) : Tokenizer de la classe [ByT5Tokenizer] guider ([ClassifierFreeGuidance](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/guiders#diffusers.ClassifierFreeGuidance)) : [ClassifierFreeGuidance]pour le guidage sans classifieur. Pipeline pour la génération de vidéos à partir de texte utilisant HunyuanVideo1.5. Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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.). #### __appel__[[diffusers.HunyuanVideo15Pipeline.__call__]] ```python __call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int | None = None, width: int | None = None, num_frames: int = 121, num_inference_steps: int = 50, sigmas: list[float] = None, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, prompt_embeds_2: typing.Optional[torch.Tensor] = None, prompt_embeds_mask_2: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_2: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask_2: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5.py#L542) **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. negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de l'image. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. height (`int`, *facultatif*) : La hauteur en pixels de la vidéo générée. width (`int`, *facultatif*) : La largeur en pixels de la vidéo générée. num_frames (`int`, par défaut `121`) : 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 vidéo 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'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé. num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre de vidéos à générer par invite. generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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 de vidéos. Peut être utilisé pour 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*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée `prompt`. prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque pré-généré pour les embeddings de l'invite. negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* 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_prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque pré-généré pour les embeddings du prompt négatif. prompt_embeds_2 (`torch.Tensor`, *facultatif*) : Embeddings de texte pré-générés par le second encodeur de texte. Peut être utilisé pour ajuster facilement les entrées de texte. prompt_embeds_mask_2 (`torch.Tensor`, *facultatif*) : Masque pré-généré pour les embeddings de l'invite provenant du deuxième encodeur de texte. negative_prompt_embeds_2 (`torch.Tensor`, *facultatif*) : Incrustations de texte négatives pré-générées par le second encodeur de texte. negative_prompt_embeds_mask_2 (`torch.Tensor`, *facultatif*) : Masque pré-généré pour les embeddings du prompt négatif issus du second encodeur de texte. output_type (`str`, *facultatif*, par défaut `"np"`) : Le format de sortie de la vidéo générée. Choisissez entre "np", "pt" ou "latent". return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `HunyuanVideo15PipelineOutput` plutôt qu'un simple tuple. attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). **Retourne :** `~HunyuanVideo15PipelineOutput` ou `tuple` Si `return_dict` est `True`, `HunyuanVideo15PipelineOutput` est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant les vidéos générées. La fonction d'appel du pipeline pour la génération. Exemples : ```python >>> import torch >>> from diffusers import HunyuanVideo15Pipeline >>> from diffusers.utils import export_to_video >>> model_id = "hunyuanvideo-community/HunyuanVideo-1.5-480p_t2v" >>> pipe = HunyuanVideo15Pipeline.from_pretrained(model_id, torch_dtype=torch.float16) >>> pipe.vae.enable_tiling() >>> pipe.to("cuda") >>> output = pipe( ... prompt="A cat walks on the grass, realistic", ... num_inference_steps=50, ... ).frames[0] >>> export_to_video(output, "output.mp4", fps=15) ``` #### encode_prompt[[diffusers.HunyuanVideo15Pipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, batch_size: int = 1, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, prompt_embeds_2: typing.Optional[torch.Tensor] = None, prompt_embeds_mask_2: typing.Optional[torch.Tensor] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5.py#L334) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder device : (`torch.device`) : appareil torch batch_size (`int`) : taille du lot de prompts, par défaut 1 num_videos_per_prompt (`int`) : nombre d'images à générer par invite prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Si non fournies, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque de texte pré-généré. S'il n'est pas fourni, le masque de texte sera généré à partir de l'argument d'entrée `prompt`. prompt_embeds_2 (`torch.Tensor`, *facultatif*) : Incrustations de texte de glyphes pré-générées par ByT5. Si non fournies, elles seront générées à partir de l'argument d'entrée `prompt` en utilisant self.tokenizer_2 et self.text_encoder_2. prompt_embeds_mask_2 (`torch.Tensor`, *facultatif*) : masque de texte des glyphes pré-généré par ByT5. S'il n'est pas fourni, il sera généré à partir de l'argument d'entrée `prompt` en utilisant self.tokenizer_2 et self.text_encoder_2. #### prepare_cond_latents_and_mask[[diffusers.HunyuanVideo15Pipeline.prepare_cond_latents_and_mask]] ```python prepare_cond_latents_and_mask(latents, dtype: typing.Optional[torch.dtype], device: typing.Optional[torch.device]) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5.py#L508) **Paramètres :** latents : Tenseur principal des latents (B, C, F, H, W) **Retourne :** `tuple` (cond_latents_concat, mask_concat) - les deux sont des tenseurs nuls pour t2v Préparez les latents conditionnels et le masque pour la génération t2v. ## HunyuanVideo15ImageToVideoPipeline[[diffusers.HunyuanVideo15ImageToVideoPipeline]] #### diffusers.HunyuanVideo15ImageToVideoPipeline[[diffusers.HunyuanVideo15ImageToVideoPipeline]] ```python diffusers.HunyuanVideo15ImageToVideoPipeline(text_encoder: Qwen2_5_VLTextModel, tokenizer: Qwen2Tokenizer, transformer: HunyuanVideo15Transformer3DModel, vae: AutoencoderKLHunyuanVideo15, scheduler: FlowMatchEulerDiscreteScheduler, text_encoder_2: T5EncoderModel, tokenizer_2: ByT5Tokenizer, guider: ClassifierFreeGuidance, image_encoder: SiglipVisionModel, feature_extractor: SiglipImageProcessorPil) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5_image2video.py#L193) **Paramètres :** transformer ([HunyuanVideo15Transformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/hunyuan_video15_transformer_3d#diffusers.HunyuanVideo15Transformer3DModel)) : architecture Transformer conditionnelle (MMDiT) pour le débruitage des latents vidéo encodés. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents vidéo encodés. vae ([AutoencoderKLHunyuanVideo15](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_hunyuan_video15#diffusers.AutoencoderKLHunyuanVideo15)) : modèle de Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), plus précisément la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizer de la classe [Qwen2Tokenizer]. text_encoder_2 (`T5EncoderModel`) : variante [T5EncoderModel](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel). tokenizer_2 (`ByT5Tokenizer`) : Tokenizer de la classe [ByT5Tokenizer] guider ([ClassifierFreeGuidance](/docs/diffusers/v0.43.0/fr/api/modular_diffusers/guiders#diffusers.ClassifierFreeGuidance)) : [ClassifierFreeGuidance]pour le guidage sans classifieur. image_encoder (`SiglipVisionModel`) : variante [SiglipVisionModel](https://huggingface.co/docs/transformers/en/model_doc/siglip#transformers.SiglipVisionModel). feature_extractor (`SiglipImageProcessor`) : variante [SiglipImageProcessor](https://huggingface.co/docs/transformers/en/model_doc/siglip#transformers.SiglipImageProcessor). Pipeline pour la génération de vidéos à partir d’images utilisant HunyuanVideo1.5. Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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.). #### __appel__[[diffusers.HunyuanVideo15ImageToVideoPipeline.__call__]] ```python __call__(image: Image, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, num_frames: int = 121, num_inference_steps: int = 50, sigmas: list[float] = None, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, prompt_embeds_2: typing.Optional[torch.Tensor] = None, prompt_embeds_mask_2: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_2: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask_2: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5_image2video.py#L650) **Paramètres :** image (`PIL.Image.Image`) : L'image d'entrée sur laquelle conditionner la génération de la vidéo. prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération de la vidéo. S'il n'est pas défini, il faut passer `prompt_embeds` à la place. negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération de la vidéo. S'il n'est pas défini, il faut passer `negative_prompt_embeds` à la place. num_frames (`int`, par défaut `121`) : 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 vidéo 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'ils ne sont pas définis, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé. num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre de vidéos à générer par invite. generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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 de vidéos. Peut être utilisé pour 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*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée `prompt`. prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque pré-généré pour les embeddings de l'invite. negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* 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_prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque pré-généré pour les embeddings du prompt négatif. prompt_embeds_2 (`torch.Tensor`, *facultatif*) : Embeddings de texte pré-générés par le second encodeur de texte. Peut être utilisé pour ajuster facilement les entrées de texte. prompt_embeds_mask_2 (`torch.Tensor`, *facultatif*) : Masque pré-généré pour les embeddings de l'invite provenant du deuxième encodeur de texte. negative_prompt_embeds_2 (`torch.Tensor`, *facultatif*) : Incrustations de texte négatives pré-générées par le second encodeur de texte. negative_prompt_embeds_mask_2 (`torch.Tensor`, *facultatif*) : Masque pré-généré pour les embeddings du prompt négatif issus du second encodeur de texte. output_type (`str`, *facultatif*, par défaut `"np"`) : Le format de sortie de la vidéo générée. Choisissez entre "np", "pt" ou "latent". return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `HunyuanVideo15PipelineOutput` plutôt qu'un simple tuple. attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). **Retourne :** `~HunyuanVideo15PipelineOutput` ou `tuple` Si `return_dict` est `True`, `HunyuanVideo15PipelineOutput` est retourné, sinon un `tuple` est retourné dont le premier élément est une liste contenant les vidéos générées. La fonction d'appel du pipeline pour la génération. Exemples : ```python >>> import torch >>> from diffusers import HunyuanVideo15ImageToVideoPipeline >>> from diffusers.utils import export_to_video >>> model_id = "hunyuanvideo-community/HunyuanVideo-1.5-480p_i2v" >>> pipe = HunyuanVideo15ImageToVideoPipeline.from_pretrained(model_id, torch_dtype=torch.float16) >>> pipe.vae.enable_tiling() >>> pipe.to("cuda") >>> image = load_image("https://huggingface.co/datasets/YiYiXu/testing-images/resolve/main/wan_i2v_input.JPG") >>> output = pipe( ... prompt="Summer beach vacation style, a white cat wearing sunglasses sits on a surfboard. The fluffy-furred feline gazes directly at the camera with a relaxed expression. Blurred beach scenery forms the background featuring crystal-clear waters, distant green hills, and a blue sky dotted with white clouds. The cat assumes a naturally relaxed posture, as if savoring the sea breeze and warm sunlight. A close-up shot highlights the feline's intricate details and the refreshing atmosphere of the seaside.", ... image=image, ... num_inference_steps=50, ... ).frames[0] >>> export_to_video(output, "output.mp4", fps=24) ``` #### encode_prompt[[diffusers.HunyuanVideo15ImageToVideoPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, batch_size: int = 1, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, prompt_embeds_2: typing.Optional[torch.Tensor] = None, prompt_embeds_mask_2: typing.Optional[torch.Tensor] = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5_image2video.py#L422) **Paramètres :** prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder device : (`torch.device`) : appareil torch batch_size (`int`) : taille du lot de prompts, par défaut 1 num_videos_per_prompt (`int`) : nombre d'images à générer par invite prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Si non fournies, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`. prompt_embeds_mask (`torch.Tensor`, *facultatif*) : Masque de texte pré-généré. S'il n'est pas fourni, le masque de texte sera généré à partir de l'argument d'entrée `prompt`. prompt_embeds_2 (`torch.Tensor`, *facultatif*) : Incrustations de texte de glyphes pré-générées par ByT5. Si non fournies, elles seront générées à partir de l'argument d'entrée `prompt` en utilisant self.tokenizer_2 et self.text_encoder_2. prompt_embeds_mask_2 (`torch.Tensor`, *facultatif*) : masque de texte des glyphes pré-généré par ByT5. S'il n'est pas fourni, il sera généré à partir de l'argument d'entrée `prompt` en utilisant self.tokenizer_2 et self.text_encoder_2. #### prepare_cond_latents_and_mask[[diffusers.HunyuanVideo15ImageToVideoPipeline.prepare_cond_latents_and_mask]] ```python prepare_cond_latents_and_mask(latents: Tensor, image: Image, batch_size: int, height: int, width: int, dtype: dtype, device: device) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5_image2video.py#L594) **Paramètres :** latents : Tenseur principal des latents (B, C, F, H, W) **Retourne :** `tuple` (cond_latents_concat, mask_concat) - les deux sont des tenseurs nuls pour t2v Préparez les latents conditionnels et le masque pour la génération t2v. ## HunyuanVideo15PipelineOutput[[diffusers.pipelines.hunyuan_video1_5.pipeline_output.HunyuanVideo15PipelineOutput]] #### diffusers.pipelines.hunyuan_video1_5.pipeline_output.HunyuanVideo15PipelineOutput[[diffusers.pipelines.hunyuan_video1_5.pipeline_output.HunyuanVideo15PipelineOutput]] ```python diffusers.pipelines.hunyuan_video1_5.pipeline_output.HunyuanVideo15PipelineOutput(frames: Tensor) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/hunyuan_video1_5/pipeline_output.py#L9) **Paramètres :** frames (`torch.Tensor`, `np.ndarray` ou list[list[PIL.Image.Image]]) : Liste de 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 HunyuanVideo1.5.