# # 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. --> # Sana-Video [SANA-Video: Efficient Video Generation with Block Linear Diffusion Transformer](https://huggingface.co/papers/2509.24695) de NVIDIA y MIT HAN Lab, por Junsong Chen, Yuyang Zhao, Jincheng Yu, Ruihang Chu, Junyu Chen, Shuai Yang, Xianbang Wang, Yicheng Pan, Daquan Zhou, Huan Ling, Haozhe Liu, Hongwei Yi, Hao Zhang, Muyang Li, Yukang Chen, Han Cai, Sanja Fidler, Ping Luo, Song Han, Enze Xie. El resumen del artículo es: *Presentamos SANA-Video, un modelo de difusión pequeño que puede generar videos de forma eficiente hasta una resolución de 720x1280 y una duración de un minuto. SANA-Video sintetiza videos de alta resolución, alta calidad y larga duración con una fuerte alineación texto-video a una velocidad notablemente rápida, desplegable en una GPU RTX 5090. Dos diseños centrales garantizan nuestra generación de video eficiente, efectiva y de larga duración: (1) Linear DiT: aprovechamos la atención lineal como operación central, que es más eficiente que la atención estándar dado el gran número de tokens procesados en la generación de video. (2) KV cache de memoria constante para Block Linear Attention: diseñamos un enfoque autoregresivo por bloques para la generación de video de larga duración empleando un estado de memoria constante, derivado de las propiedades acumulativas de la atención lineal. Este KV cache proporciona al Linear DiT un contexto global a un costo de memoria fijo, eliminando la necesidad de un KV cache tradicional y permitiendo una generación de video de un minuto de forma eficiente. Además, exploramos filtros de datos efectivos y estrategias de entrenamiento del modelo, reduciendo el costo de entrenamiento a 12 días en 64 GPUs H100, lo que representa solo el 1% del costo de MovieGen. Dado su bajo costo, SANA-Video logra un rendimiento competitivo en comparación con los modelos de difusión pequeños modernos de última generación (p. ej., Wan 2.1-1.3B y SkyReel-V2-1.3B) mientras es 16 veces más rápido en latencia medida. Además, SANA-Video puede desplegarse en GPUs RTX 5090 con precisión NVFP4, acelerando la velocidad de inferencia para generar un video de 5 segundos en 720p de 71s a 29s (aceleración de 2.4x). En resumen, SANA-Video permite la generación de video de alta calidad y bajo costo. [this https URL](https://github.com/NVlabs/SANA).* Este pipeline fue aportado por el equipo SANA. La base de código original se puede encontrar [aquí](https://github.com/NVlabs/Sana). Los pesos originales se pueden encontrar en [hf.co/Efficient-Large-Model](https://hf.co/collections/Efficient-Large-Model/sana-video). Modelos disponibles: | Modelo | dtype recomendado | |:-----:|:-----------------:| | [`Efficient-Large-Model/SANA-Video_2B_480p_diffusers`](https://huggingface.co/Efficient-Large-Model/SANA-Video_2B_480p_diffusers) | `torch.bfloat16` | Consulte esta [colección](https://huggingface.co/collections/Efficient-Large-Model/sana-video) para obtener más información. Nota: El dtype recomendado mencionado es para los pesos del transformer. Los pesos del codificador de texto y del VAE deben permanecer en `torch.bfloat16` o `torch.float32` para que el modelo funcione correctamente. Consulte el ejemplo de inferencia a continuación para ver cómo cargar el modelo con el dtype recomendado. ## Pipelines de generación ` El siguiente ejemplo demuestra cómo usar el pipeline de texto a video para generar un video a partir de una descripción de texto. ```python pipe = SanaVideoPipeline.from_pretrained( "Efficient-Large-Model/SANA-Video_2B_480p_diffusers", dtype=torch.bfloat16, ) pipe.text_encoder.to(torch.bfloat16) pipe.vae.to(torch.float32) pipe.to("cuda") # or "mps", "xpu", "cpu" prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window." negative_prompt = "A chaotic sequence with misshapen, deformed limbs in heavy motion blur, sudden disappearance, jump cuts, jerky movements, rapid shot changes, frames out of sync, inconsistent character shapes, temporal artifacts, jitter, and ghosting effects, creating a disorienting visual experience." motion_scale = 30 motion_prompt = f" motion score: {motion_scale}." prompt = prompt + motion_prompt video = pipe( prompt=prompt, negative_prompt=negative_prompt, height=480, width=832, frames=81, guidance_scale=6, num_inference_steps=50, generator=torch.Generator(device="cuda").manual_seed(0), ).frames[0] export_to_video(video, "sana_video.mp4", fps=16) ``` El siguiente ejemplo demuestra cómo usar el pipeline de imagen a video para generar un video a partir de una descripción de texto y un fotograma inicial. ```python pipe = SanaImageToVideoPipeline.from_pretrained( "Efficient-Large-Model/SANA-Video_2B_480p_diffusers", dtype=torch.bfloat16, ) pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(pipe.scheduler.config, flow_shift=8.0) pipe.vae.to(torch.float32) pipe.text_encoder.to(torch.bfloat16) pipe.to("cuda") # or "mps", "xpu", "cpu" image = load_image("https://raw.githubusercontent.com/NVlabs/Sana/refs/heads/main/asset/samples/i2v-1.png") prompt = "A woman stands against a stunning sunset backdrop, her long, wavy brown hair gently blowing in the breeze. She wears a sleeveless, light-colored blouse with a deep V-neckline, which accentuates her graceful posture. The warm hues of the setting sun cast a golden glow across her face and hair, creating a serene and ethereal atmosphere. The background features a blurred landscape with soft, rolling hills and scattered clouds, adding depth to the scene. The camera remains steady, capturing the tranquil moment from a medium close-up angle." negative_prompt = "A chaotic sequence with misshapen, deformed limbs in heavy motion blur, sudden disappearance, jump cuts, jerky movements, rapid shot changes, frames out of sync, inconsistent character shapes, temporal artifacts, jitter, and ghosting effects, creating a disorienting visual experience." motion_scale = 30 motion_prompt = f" motion score: {motion_scale}." prompt = prompt + motion_prompt motion_scale = 30.0 video = pipe( image=image, prompt=prompt, negative_prompt=negative_prompt, height=480, width=832, frames=81, guidance_scale=6, num_inference_steps=50, generator=torch.Generator(device="cuda").manual_seed(0), ).frames[0] export_to_video(video, "sana-i2v.mp4", fps=16) ``` ## 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](../../quantization/overview) 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 [SanaVideoPipeline](/docs/diffusers/main/es/api/pipelines/sana_video#diffusers.SanaVideoPipeline) cuantizado para inferencia con bitsandbytes. ```py import torch from diffusers import BitsAndBytesConfig as DiffusersBitsAndBytesConfig, SanaVideoTransformer3DModel, SanaVideoPipeline from transformers import BitsAndBytesConfig as BitsAndBytesConfig, AutoModel quant_config = BitsAndBytesConfig(load_in_8bit=True) text_encoder_8bit = AutoModel.from_pretrained( "Efficient-Large-Model/SANA-Video_2B_480p_diffusers", subfolder="text_encoder", quantization_config=quant_config, dtype=torch.float16, ) quant_config = DiffusersBitsAndBytesConfig(load_in_8bit=True) transformer_8bit = SanaVideoTransformer3DModel.from_pretrained( "Efficient-Large-Model/SANA-Video_2B_480p_diffusers", subfolder="transformer", quantization_config=quant_config, dtype=torch.float16, ) pipeline = SanaVideoPipeline.from_pretrained( "Efficient-Large-Model/SANA-Video_2B_480p_diffusers", text_encoder=text_encoder_8bit, transformer=transformer_8bit, dtype=torch.float16, device_map="balanced", ) model_score = 30 prompt = "Evening, backlight, side lighting, soft light, high contrast, mid-shot, centered composition, clean solo shot, warm color. A young Caucasian man stands in a forest, golden light glimmers on his hair as sunlight filters through the leaves. He wears a light shirt, wind gently blowing his hair and collar, light dances across his face with his movements. The background is blurred, with dappled light and soft tree shadows in the distance. The camera focuses on his lifted gaze, clear and emotional." negative_prompt = "A chaotic sequence with misshapen, deformed limbs in heavy motion blur, sudden disappearance, jump cuts, jerky movements, rapid shot changes, frames out of sync, inconsistent character shapes, temporal artifacts, jitter, and ghosting effects, creating a disorienting visual experience." motion_prompt = f" motion score: {model_score}." prompt = prompt + motion_prompt output = pipeline( prompt=prompt, negative_prompt=negative_prompt, height=480, width=832, num_frames=81, guidance_scale=6.0, num_inference_steps=50 ).frames[0] export_to_video(output, "sana-video-output.mp4", fps=16) ``` ## SanaVideoPipeline[[diffusers.SanaVideoPipeline]] #### diffusers.SanaVideoPipeline[[diffusers.SanaVideoPipeline]] ```python diffusers.SanaVideoPipeline(tokenizer: GemmaTokenizer, text_encoder: Gemma2PreTrainedModel, vae: diffusers.models.autoencoders.autoencoder_dc.AutoencoderDC | diffusers.models.autoencoders.autoencoder_kl_ltx2.AutoencoderKLLTX2Video | diffusers.models.autoencoders.autoencoder_kl_wan.AutoencoderKLWan, transformer: SanaVideoTransformer3DModel, scheduler: DPMSolverMultistepScheduler) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_video/pipeline_sana_video.py#L186) **Parámetros:** tokenizer (`GemmaTokenizer` o `GemmaTokenizerFast`) : El tokenizador utilizado para tokenizar el prompt. text_encoder (`Gemma2PreTrainedModel`) : Modelo codificador de texto para codificar los prompts de entrada. vae ([`AutoencoderKLWan`, `AutoencoderDC` o `AutoencoderKLLTX2Video`]) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. transformer ([SanaVideoTransformer3DModel](/docs/diffusers/main/es/api/models/sana_video_transformer3d#diffusers.SanaVideoTransformer3DModel)) : Transformer condicional para desruidar los latentes de entrada. scheduler ([DPMSolverMultistepScheduler](/docs/diffusers/main/es/api/schedulers/multistep_dpm_solver#diffusers.DPMSolverMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de video codificados. Pipeline para la generación de texto a video usando [Sana](https://huggingface.co/papers/2509.24695). Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte la documentación de la superclase para los métodos genéricos implementados en todos los pipelines (descarga, guardado, ejecución en un dispositivo específico, etc.). #### __call__[[diffusers.SanaVideoPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 6.0, num_videos_per_prompt: int | None = 1, height: int = 480, width: int = 832, frames: int = 81, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, clean_caption: bool = False, use_resolution_binning: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 300, complex_human_instruction: list[str] = ["Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for video generation. Evaluate the level of detail in the user prompt:", '- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, motion, and temporal relationships to create vivid and dynamic scenes.', '- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.', 'Here are examples of how to transform or refine prompts:', '- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat slowly settling into a curled position, peacefully falling asleep on a warm sunny windowsill, with gentle sunlight filtering through surrounding pots of blooming red flowers.', '- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps gradually lighting up, a diverse crowd of people in colorful clothing walking past, and a double-decker bus smoothly passing by towering glass skyscrapers.', 'Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:', 'User Prompt: ']) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_video/pipeline_sana_video.py#L712) **Parámetros:** 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. 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 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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`. guidance_scale (`float`, *opcional*, valor predeterminado 4.5) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de videos estrechamente vinculados al `prompt` de texto, generalmente a costa de una menor calidad de video. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación. height (`int`, *opcional*, valor predeterminado 480) : La altura en píxeles del video generado. width (`int`, *opcional*, valor predeterminado 832) : El ancho en píxeles del video generado. frames (`int`, *opcional*, valor predeterminado 81) : El número de fotogramas en el video generado. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](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 proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para PixArt-Sigma, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos. output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida del video generado. Elija entre mp4 o `np.array`. return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver una `SanaVideoPipelineOutput` en lugar de una tupla simple. attention_kwargs : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` definido bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. use_resolution_binning (`bool` por defecto `True`) : Si se establece en `True`, la altura y el ancho solicitados se mapean primero a las resoluciones más cercanas usando `ASPECT_RATIO_480_BIN` o `ASPECT_RATIO_720_BIN`. Después de que los latentes generados se decodifican en videos, se redimensionan de nuevo a la resolución solicitada. Útil para generar videos que no son cuadrados. callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama 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á incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. max_sequence_length (`int` por defecto `300`) : Longitud máxima de secuencia para usar con `prompt`. complex_human_instruction (`list[str]`, *opcional*) : Instrucciones para la atención humana compleja: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. **Devuelve:** [SanaVideoPipelineOutput](/docs/diffusers/main/es/api/pipelines/sana_video#diffusers.pipelines.sana_video.pipeline_output.SanaVideoPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [SanaVideoPipelineOutput](/docs/diffusers/main/es/api/pipelines/sana_video#diffusers.pipelines.sana_video.pipeline_output.SanaVideoPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con los videos generados Función invocada al llamar a la pipeline para la generación. Ejemplos: ```py >>> import torch >>> from diffusers import SanaVideoPipeline >>> from diffusers.utils import export_to_video >>> pipe = SanaVideoPipeline.from_pretrained("Efficient-Large-Model/SANA-Video_2B_480p_diffusers") >>> pipe.transformer.to(torch.bfloat16) >>> pipe.text_encoder.to(torch.bfloat16) >>> pipe.vae.to(torch.float32) >>> pipe.to("cuda") >>> motion_score = 30 >>> prompt = "Evening, backlight, side lighting, soft light, high contrast, mid-shot, centered composition, clean solo shot, warm color. A young Caucasian man stands in a forest, golden light glimmers on his hair as sunlight filters through the leaves. He wears a light shirt, wind gently blowing his hair and collar, light dances across his face with his movements. The background is blurred, with dappled light and soft tree shadows in the distance. The camera focuses on his lifted gaze, clear and emotional." >>> negative_prompt = "A chaotic sequence with misshapen, deformed limbs in heavy motion blur, sudden disappearance, jump cuts, jerky movements, rapid shot changes, frames out of sync, inconsistent character shapes, temporal artifacts, jitter, and ghosting effects, creating a disorienting visual experience." >>> motion_prompt = f" motion score: {motion_score}." >>> prompt = prompt + motion_prompt >>> output = pipe( ... prompt=prompt, ... negative_prompt=negative_prompt, ... height=480, ... width=832, ... frames=81, ... guidance_scale=6, ... num_inference_steps=50, ... generator=torch.Generator(device="cuda").manual_seed(42), ... ).frames[0] >>> export_to_video(output, "sana-video-output.mp4", fps=16) ``` #### encode_prompt[[diffusers.SanaVideoPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str = '', num_videos_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, complex_human_instruction: list[str] | None = None, lora_scale: float | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_video/pipeline_sana_video.py#L303) **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 PixArt-Alpha, esto debería ser "". do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : si se debe usar classifier free guidance o no num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : número de vídeos que deben generarse por indicación device : (`torch.device`, *opcional*): dispositivo de torch en el que colocar las incrustaciones resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados. Para Sana, deben ser los embeddings de la cadena "". clean_caption (`bool`, por defecto `False`) : Si `True`, la función preprocesará y limpiará la descripción proporcionada antes de codificarla. max_sequence_length (`int`, por defecto 300) : Longitud máxima de la secuencia a utilizar para el prompt. complex_human_instruction (`list[str]`, por defecto `complex_human_instruction`) : Si `complex_human_instruction` no está vacío, la función utilizará la instrucción humana compleja para el prompt. Codifica el prompt en estados ocultos del codificador de texto. ## SanaImageToVideoPipeline[[diffusers.SanaImageToVideoPipeline]] #### diffusers.SanaImageToVideoPipeline[[diffusers.SanaImageToVideoPipeline]] ```python diffusers.SanaImageToVideoPipeline(tokenizer: GemmaTokenizer, text_encoder: Gemma2PreTrainedModel, vae: diffusers.models.autoencoders.autoencoder_dc.AutoencoderDC | diffusers.models.autoencoders.autoencoder_kl_ltx2.AutoencoderKLLTX2Video | diffusers.models.autoencoders.autoencoder_kl_wan.AutoencoderKLWan, transformer: SanaVideoTransformer3DModel, scheduler: FlowMatchEulerDiscreteScheduler) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_video/pipeline_sana_video_i2v.py#L176) **Parámetros:** tokenizer (`GemmaTokenizer` o `GemmaTokenizerFast`) : El tokenizador utilizado para tokenizar el prompt. text_encoder (`Gemma2PreTrainedModel`) : Modelo codificador de texto para codificar los prompts de entrada. vae ([`AutoencoderKLWan`, `AutoencoderDC` o `AutoencoderKLLTX2Video`]) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. transformer ([SanaVideoTransformer3DModel](/docs/diffusers/main/es/api/models/sana_video_transformer3d#diffusers.SanaVideoTransformer3DModel)) : Transformer condicional para desruidar los latentes de entrada. 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. Pipeline para la generación de video a partir de imagen/texto usando [Sana](https://huggingface.co/papers/2509.24695). Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte la documentación de la superclase para los métodos genéricos implementados en todos los pipelines (descarga, guardado, ejecución en un dispositivo específico, etc.). #### __call__[[diffusers.SanaImageToVideoPipeline.__call__]] ```python __call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, negative_prompt: str = '', num_inference_steps: int = 50, timesteps: list[int] = None, sigmas: list[float] = None, guidance_scale: float = 6.0, num_videos_per_prompt: int | None = 1, height: int = 480, width: int = 832, frames: int = 81, eta: float = 0.0, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, clean_caption: bool = False, use_resolution_binning: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 300, complex_human_instruction: list[str] = ["Given a user prompt, generate an 'Enhanced prompt' that provides detailed visual descriptions suitable for video generation. Evaluate the level of detail in the user prompt:", '- If the prompt is simple, focus on adding specifics about colors, shapes, sizes, textures, motion, and temporal relationships to create vivid and dynamic scenes.', '- If the prompt is already detailed, refine and enhance the existing details slightly without overcomplicating.', 'Here are examples of how to transform or refine prompts:', '- User Prompt: A cat sleeping -> Enhanced: A small, fluffy white cat slowly settling into a curled position, peacefully falling asleep on a warm sunny windowsill, with gentle sunlight filtering through surrounding pots of blooming red flowers.', '- User Prompt: A busy city street -> Enhanced: A bustling city street scene at dusk, featuring glowing street lamps gradually lighting up, a diverse crowd of people in colorful clothing walking past, and a double-decker bus smoothly passing by towering glass skyscrapers.', 'Please generate only the enhanced description for the prompt below and avoid including any additional commentary or evaluations:', 'User Prompt: ']) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_video/pipeline_sana_video_i2v.py#L739) **Parámetros:** image (`PipelineImageInput`) : La imagen de entrada para condicionar la generación del video. El primer fotograma del video generado estará condicionado por esta imagen. 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. 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 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. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. 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`. guidance_scale (`float`, *opcional*, valor predeterminado 4.5) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de videos estrechamente vinculados al `prompt` de texto, generalmente a costa de una menor calidad de video. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de videos a generar por indicación. height (`int`, *opcional*, valor predeterminado 480) : La altura en píxeles del video generado. width (`int`, *opcional*, valor predeterminado 832) : El ancho en píxeles del video generado. frames (`int`, *opcional*, valor predeterminado 81) : El número de fotogramas en el video generado. eta (`float`, *opcional*, valor predeterminado 0.0) : Corresponde al parámetro eta (η) en el artículo de DDIM: https://huggingface.co/papers/2010.02502. Solo se aplica a [schedulers.DDIMScheduler](/docs/diffusers/main/es/api/schedulers/ddim#diffusers.DDIMScheduler), se ignorará en los demás. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](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 proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Para PixArt-Sigma, este prompt negativo debe ser "". Si no se proporciona, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. negative_prompt_attention_mask (`torch.Tensor`, *opcional*) : Máscara de atención pregenerada para los embeddings de texto negativos. output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida del video generado. Elija entre mp4 o `np.array`. return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver una `SanaVideoPipelineOutput` en lugar de una tupla simple. attention_kwargs : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` definido bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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. use_resolution_binning (`bool` por defecto `True`) : Si se establece en `True`, la altura y el ancho solicitados se mapean primero a las resoluciones más cercanas usando `ASPECT_RATIO_480_BIN` o `ASPECT_RATIO_720_BIN`. Después de que los latentes generados se decodifican en videos, se redimensionan de nuevo a la resolución solicitada. Útil para generar videos que no son cuadrados. callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama 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á incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. max_sequence_length (`int` por defecto `300`) : Longitud máxima de secuencia para usar con `prompt`. complex_human_instruction (`list[str]`, *opcional*) : Instrucciones para la atención humana compleja: https://github.com/NVlabs/Sana/blob/main/configs/sana_app_config/Sana_1600M_app.yaml#L55. **Devuelve:** [SanaVideoPipelineOutput](/docs/diffusers/main/es/api/pipelines/sana_video#diffusers.pipelines.sana_video.pipeline_output.SanaVideoPipelineOutput) o `tuple` Si `return_dict` es `True`, se devuelve [SanaVideoPipelineOutput](/docs/diffusers/main/es/api/pipelines/sana_video#diffusers.pipelines.sana_video.pipeline_output.SanaVideoPipelineOutput); en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con los videos generados Función invocada al llamar a la pipeline para la generación. Ejemplos: ```py >>> import torch >>> from diffusers import SanaImageToVideoPipeline >>> from diffusers.utils import export_to_video, load_image >>> pipe = SanaImageToVideoPipeline.from_pretrained("Efficient-Large-Model/SANA-Video_2B_480p_diffusers") >>> pipe.transformer.to(torch.bfloat16) >>> pipe.text_encoder.to(torch.bfloat16) >>> pipe.vae.to(torch.float32) >>> pipe.to("cuda") >>> motion_score = 30 >>> prompt = "A woman stands against a stunning sunset backdrop, her long, wavy brown hair gently blowing in the breeze. She wears a sleeveless, light-colored blouse with a deep V-neckline, which accentuates her graceful posture. The warm hues of the setting sun cast a golden glow across her face and hair, creating a serene and ethereal atmosphere. The background features a blurred landscape with soft, rolling hills and scattered clouds, adding depth to the scene. The camera remains steady, capturing the tranquil moment from a medium close-up angle." >>> negative_prompt = "A chaotic sequence with misshapen, deformed limbs in heavy motion blur, sudden disappearance, jump cuts, jerky movements, rapid shot changes, frames out of sync, inconsistent character shapes, temporal artifacts, jitter, and ghosting effects, creating a disorienting visual experience." >>> motion_prompt = f" motion score: {motion_score}." >>> prompt = prompt + motion_prompt >>> image = load_image("https://raw.githubusercontent.com/NVlabs/Sana/refs/heads/main/asset/samples/i2v-1.png") >>> output = pipe( ... image=image, ... prompt=prompt, ... negative_prompt=negative_prompt, ... height=480, ... width=832, ... frames=81, ... guidance_scale=6, ... num_inference_steps=50, ... generator=torch.Generator(device="cuda").manual_seed(42), ... ).frames[0] >>> export_to_video(output, "sana-ti2v-output.mp4", fps=16) ``` #### encode_prompt[[diffusers.SanaImageToVideoPipeline.encode_prompt]] ```python encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, negative_prompt: str = '', num_videos_per_prompt: int = 1, device: typing.Optional[torch.device] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, clean_caption: bool = False, max_sequence_length: int = 300, complex_human_instruction: list[str] | None = None, lora_scale: float | None = None) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_video/pipeline_sana_video_i2v.py#L301) **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 PixArt-Alpha, esto debería ser "". do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : si se debe usar classifier free guidance o no num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : número de vídeos que deben generarse por indicación device : (`torch.device`, *opcional*): dispositivo de torch en el que colocar las incrustaciones resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados. Para Sana, deben ser los embeddings de la cadena "". clean_caption (`bool`, por defecto `False`) : Si `True`, la función preprocesará y limpiará la descripción proporcionada antes de codificarla. max_sequence_length (`int`, por defecto 300) : Longitud máxima de la secuencia a utilizar para el prompt. complex_human_instruction (`list[str]`, por defecto `complex_human_instruction`) : Si `complex_human_instruction` no está vacío, la función utilizará la instrucción humana compleja para el prompt. Codifica el prompt en estados ocultos del codificador de texto. ## SanaVideoPipelineOutput[[diffusers.pipelines.sana_video.pipeline_output.SanaVideoPipelineOutput]] #### diffusers.pipelines.sana_video.pipeline_output.SanaVideoPipelineOutput[[diffusers.pipelines.sana_video.pipeline_output.SanaVideoPipelineOutput]] ```python diffusers.pipelines.sana_video.pipeline_output.SanaVideoPipelineOutput(frames: Tensor) ``` [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/sana_video/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 Sana-Video.