# # 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. --> # HunyuanVideo-1.5 HunyuanVideo-1.5 es un modelo de generación de video ligero pero potente que logra una calidad visual y una coherencia de movimiento de última generación con solo 8.3 mil millones de parámetros, lo que permite una inferencia eficiente en GPUs de consumo. Este logro se basa en varios componentes clave, incluida una meticulosa curaduría de datos, una arquitectura DiT avanzada con atención selectiva y deslizante por mosaicos (SSTA), una comprensión bilingüe mejorada mediante codificación de texto consciente de glifos, preentrenamiento y posentrenamiento progresivos, y una red de superresolución de video eficiente. Aprovechando estos diseños, desarrollamos un marco unificado capaz de generar video a partir de texto y de imagen a video de alta calidad en múltiples duraciones y resoluciones. Experimentos extensos demuestran que este modelo compacto y competente establece una nueva frontera de rendimiento entre los modelos de código abierto. Puedes encontrar todos los puntos de control originales de HunyuanVideo bajo la organización [Tencent](https://huggingface.co/tencent). > [!TIP] > 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](https://huggingface.co/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. Consulte la guía [Reduce memory usage](../../optimization/memory) para obtener más detalles sobre las diversas técnicas de ahorro de memoria. ```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) ``` ## Notas - HunyuanVideo1.5 utiliza máscaras de atención con secuencias de longitud variable. Para obtener el mejor rendimiento, recomendamos utilizar un backend de atención que gestione el relleno de manera eficiente. - **H100/H800:** `_flash_3_hub` o `_flash_3_varlen_hub` - **A100/A800/RTX 4090:** `flash_hub` o `flash_varlen_hub` - **Otras GPU:** `sage_hub` Consulte la guía de [Backends de atención](../../optimization/attention_backends) para obtener más detalles sobre el uso de un backend diferente. ```py pipe.transformer.set_attention_backend("flash_hub") # or your preferred backend ``` - [HunyuanVideo15Pipeline](/docs/diffusers/main/es/api/pipelines/hunyuan_video15#diffusers.HunyuanVideo15Pipeline) utiliza guider y no acepta el parámetro `guidance_scale` en tiempo de ejecución. Puede comprobar la configuración predeterminada del guider usando `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 ``` Para actualizar la configuración de guider, puedes ejecutar `pipe.guider = pipe.guider.new(...)` ```py pipe.guider = pipe.guider.new(guidance_scale=5.0) ``` Lea más sobre Guider [aquí](../../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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5.py#L166) **Parámetros:** transformer ([HunyuanVideo15Transformer3DModel](/docs/diffusers/main/es/api/models/hunyuan_video15_transformer_3d#diffusers.HunyuanVideo15Transformer3DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de video codificados. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de video codificados. vae ([AutoencoderKLHunyuanVideo15](/docs/diffusers/main/es/api/models/autoencoder_kl_hunyuan_video15#diffusers.AutoencoderKLHunyuanVideo15)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase [Qwen2Tokenizer]. text_encoder_2 (`T5EncoderModel`) : variante [T5EncoderModel](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel). tokenizer_2 (`ByT5Tokenizer`) : Tokenizador de la clase [ByT5Tokenizer] guider ([ClassifierFreeGuidance](/docs/diffusers/main/es/api/modular_diffusers/guiders#diffusers.ClassifierFreeGuidance)) : [ClassifierFreeGuidance] para la guía libre de clasificador. Pipeline para la generación de texto a video usando HunyuanVideo1.5. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.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__[[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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5.py#L542) **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, 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 de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. height (`int`, *opcional*) : La altura en píxeles del video generado. width (`int`, *opcional*) : El ancho en píxeles del video generado. num_frames (`int`, por defecto `121`) : 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 un video 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`. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación 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 video. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara pregenerada para los embeddings del prompt. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara pregenerada para los embeddings del prompt negativo. prompt_embeds_2 (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados del segundo codificador de texto. Se pueden usar para ajustar fácilmente las entradas de texto. prompt_embeds_mask_2 (`torch.Tensor`, *opcional*) : Máscara pregenerada para los embeddings del prompt desde el segundo codificador de texto. negative_prompt_embeds_2 (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados del segundo codificador de texto. negative_prompt_embeds_mask_2 (`torch.Tensor`, *opcional*) : Máscara pregenerada para los embeddings del prompt negativo del segundo codificador de texto. output_type (`str`, *opcional*, valor predeterminado `"np"`) : El formato de salida del video generado. Elija entre "np", "pt" o "latent". return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver una `HunyuanVideo15PipelineOutput` en lugar de una tupla simple. attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). **Devuelve:** `~HunyuanVideo15PipelineOutput` o `tuple` Si `return_dict` es `True`, se devuelve `HunyuanVideo15PipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con los videos generados. La función de llamada para el pipeline de generación. Ejemplos: ```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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5.py#L334) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar device : (`torch.device`): dispositivo de torch batch_size (`int`) : tamaño del lote de prompts, por defecto es 1 num_videos_per_prompt (`int`) : número de imágenes que deben generarse por prompt prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de texto pregenerada. Si no se proporciona, la máscara de texto se generará a partir del argumento de entrada `prompt`. prompt_embeds_2 (`torch.Tensor`, *opcional*) : Incrustaciones de texto de glifos pregeneradas de ByT5. Si no se proporcionan, se generarán a partir del argumento de entrada `prompt` utilizando self.tokenizer_2 y self.text_encoder_2. prompt_embeds_mask_2 (`torch.Tensor`, *opcional*) : Máscara de texto de glifos pregenerada de ByT5. Si no se proporciona, se generará a partir del argumento de entrada `prompt` utilizando self.tokenizer_2 y 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]) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5.py#L508) **Parámetros:** latents : Tensor principal de latentes (B, C, F, H, W) **Devuelve:** `tuple` (cond_latents_concat, mask_concat) - ambos son tensores de ceros para t2v Prepara los latentes condicionales y la máscara para la generación 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5_image2video.py#L193) **Parámetros:** transformer ([HunyuanVideo15Transformer3DModel](/docs/diffusers/main/es/api/models/hunyuan_video15_transformer_3d#diffusers.HunyuanVideo15Transformer3DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de video codificados. scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de video codificados. vae ([AutoencoderKLHunyuanVideo15](/docs/diffusers/main/es/api/models/autoencoder_kl_hunyuan_video15#diffusers.AutoencoderKLHunyuanVideo15)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct). tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase [Qwen2Tokenizer]. text_encoder_2 (`T5EncoderModel`) : variante [T5EncoderModel](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel). tokenizer_2 (`ByT5Tokenizer`) : Tokenizador de la clase [ByT5Tokenizer] guider ([ClassifierFreeGuidance](/docs/diffusers/main/es/api/modular_diffusers/guiders#diffusers.ClassifierFreeGuidance)) : [ClassifierFreeGuidance] para la guía libre de clasificador. 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 para la generación de video a partir de imágenes usando HunyuanVideo1.5. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.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__[[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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5_image2video.py#L650) **Parámetros:** image (`PIL.Image.Image`) : La imagen de entrada sobre la que condicionar la generación del video. 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. num_frames (`int`, por defecto `121`) : 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 un video 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`. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación 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 video. 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`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara pregenerada para los embeddings del prompt. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara pregenerada para los embeddings del prompt negativo. prompt_embeds_2 (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados del segundo codificador de texto. Se pueden usar para ajustar fácilmente las entradas de texto. prompt_embeds_mask_2 (`torch.Tensor`, *opcional*) : Máscara pregenerada para los embeddings del prompt desde el segundo codificador de texto. negative_prompt_embeds_2 (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados del segundo codificador de texto. negative_prompt_embeds_mask_2 (`torch.Tensor`, *opcional*) : Máscara pregenerada para los embeddings del prompt negativo del segundo codificador de texto. output_type (`str`, *opcional*, valor predeterminado `"np"`) : El formato de salida del video generado. Elija entre "np", "pt" o "latent". return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver una `HunyuanVideo15PipelineOutput` en lugar de una tupla simple. attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). **Devuelve:** `~HunyuanVideo15PipelineOutput` o `tuple` Si `return_dict` es `True`, se devuelve `HunyuanVideo15PipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con los videos generados. La función de llamada para el pipeline de generación. Ejemplos: ```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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5_image2video.py#L422) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar device : (`torch.device`): dispositivo de torch batch_size (`int`) : tamaño del lote de prompts, por defecto es 1 num_videos_per_prompt (`int`) : número de imágenes que deben generarse por prompt prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de texto pregenerada. Si no se proporciona, la máscara de texto se generará a partir del argumento de entrada `prompt`. prompt_embeds_2 (`torch.Tensor`, *opcional*) : Incrustaciones de texto de glifos pregeneradas de ByT5. Si no se proporcionan, se generarán a partir del argumento de entrada `prompt` utilizando self.tokenizer_2 y self.text_encoder_2. prompt_embeds_mask_2 (`torch.Tensor`, *opcional*) : Máscara de texto de glifos pregenerada de ByT5. Si no se proporciona, se generará a partir del argumento de entrada `prompt` utilizando self.tokenizer_2 y 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_hunyuan_video1_5_image2video.py#L594) **Parámetros:** latents : Tensor principal de latentes (B, C, F, H, W) **Devuelve:** `tuple` (cond_latents_concat, mask_concat) - ambos son tensores de ceros para t2v Prepara los latentes condicionales y la máscara para la generación 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/hunyuan_video1_5/pipeline_output.py#L9) **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 HunyuanVideo1.5.