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

  
    
      
    
  

# Helios

[Helios: Real Real-Time Long Video Generation Model](https://huggingface.co/papers/2603.04379) de Peking University & ByteDance & etc, por Shenghai Yuan, Yuanyang Yin, Zongjian Li, Xinwei Huang, Xiao Yang, Li Yuan.

*  Presentamos Helios, el primer modelo de generación de video de 14B que funciona a 17 FPS en una sola GPU NVIDIA H100 y soporta generación a escala de minutos, al tiempo que iguala la calidad de una línea base sólida. Logramos avances en tres dimensiones clave: (1) robustez ante la deriva en videos largos sin usar heurísticas comunes anti-deriva como self-forcing, error banks o muestreo de fotogramas clave; (2) generación en tiempo real sin técnicas estándar de aceleración como KV-cache, enmascarado causal o atención dispersa; y (3) entrenamiento sin marcos de paralelismo o particionamiento, lo que permite tamaños de lote a escala de difusión de imágenes mientras se ajustan hasta cuatro modelos de 14B en 80 GB de memoria de GPU. Específicamente, Helios es un modelo de difusión autoregresivo de 14B con una representación de entrada unificada que soporta de forma nativa las tareas T2V, I2V y V2V. Para mitigar la deriva en la generación de videos largos, caracterizamos sus modos de fallo típicos y proponemos estrategias de entrenamiento simples pero efectivas que simulan explícitamente la deriva durante el entrenamiento, eliminando al mismo tiempo el movimiento repetitivo en su origen. Para la eficiencia, comprimimos en gran medida el contexto histórico y ruidoso y reducimos el número de pasos de muestreo, lo que genera costos computacionales comparables o inferiores a los de los modelos generativos de video de 1.3B. Además, introducimos optimizaciones a nivel de infraestructura que aceleran tanto la inferencia como el entrenamiento, reduciendo al mismo tiempo el consumo de memoria. Experimentos extensos demuestran que Helios supera consistentemente a los métodos anteriores tanto en la generación de videos cortos como largos. Todo el código y los modelos están disponibles en [esta URL de https](https://pku-yuangroup.github.io/Helios-Page).

Los siguientes modelos de Helios son compatibles con Diffusers:

- [Helios-Base](https://huggingface.co/BestWishYsh/Helios-Base): Mejor calidad, con v-predicción, CFG estándar y HeliosScheduler personalizado.
- [Helios-Mid](https://huggingface.co/BestWishYsh/Helios-Mid): Peso intermedio, con v-predicción, CFG-Zero* y HeliosScheduler personalizado.
- [Helios-Distilled](https://huggingface.co/BestWishYsh/Helios-Distilled): la mejor eficiencia, con x0-prediction y HeliosDMDScheduler personalizado.

> [!TIP]
> Haz clic en los modelos Helios en la barra lateral derecha para ver más ejemplos de generación de video.

### Optimización de la memoria y la velocidad de inferencia

El siguiente ejemplo demuestra cómo generar un video a partir de texto 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.

El modelo Helios de abajo requiere ~6 GB de VRAM.

```py
import torch
from diffusers import AutoModel, HeliosPipeline
from diffusers.hooks.group_offloading import apply_group_offloading
from diffusers.utils import export_to_video

vae = AutoModel.from_pretrained("BestWishYsh/Helios-Base", subfolder="vae", dtype=torch.float32)

# group-offloading
pipeline = HeliosPipeline.from_pretrained(
    "BestWishYsh/Helios-Base",
    vae=vae,
    dtype=torch.bfloat16
)
pipeline.enable_group_offload(
    onload_device=torch.device("cuda"),
    offload_device=torch.device("cpu"),
    offload_type="leaf_level",
    use_stream=True,
    record_stream=True,
)

prompt = """
A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue 
and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with 
a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, 
allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades 
of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and 
the vivid colors of its surroundings. A close-up shot with dynamic movement.
"""
negative_prompt = """
Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
"""

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=99,
    num_inference_steps=50,
    guidance_scale=5.0,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_base_t2v_output.mp4", fps=24)
```

[Compilation](../../optimization/fp16#torchcompile) es lento la primera vez, pero las llamadas posteriores al pipeline son más rápidas. Los [Attention Backends](../../optimization/attention_backends), como FlashAttention y SageAttention, pueden aumentar significativamente la velocidad al optimizar el cálculo del mecanismo de atención. El [Context Parallelism](../../optimization/context_parallelism) divide la secuencia de entrada entre varios dispositivos para permitir el procesamiento de contextos largos en paralelo, reduciendo la presión de memoria y la latencia. El [Caching](../../optimization/cache) también puede acelerar la inferencia al almacenar y reutilizar salidas intermedias.

```py
import torch
from diffusers import AutoModel, HeliosPipeline
from diffusers.utils import export_to_video

vae = AutoModel.from_pretrained("BestWishYsh/Helios-Base", subfolder="vae", dtype=torch.float32)

pipeline = HeliosPipeline.from_pretrained(
    "BestWishYsh/Helios-Base",
    vae=vae,
    dtype=torch.bfloat16
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

# attention backend
# pipeline.transformer.set_attention_backend("flash")
pipeline.transformer.set_attention_backend("_flash_3_hub") # For Hopper GPUs

# torch.compile
torch.backends.cudnn.benchmark = True
pipeline.text_encoder.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
pipeline.vae.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
pipeline.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=False)

prompt = """
A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue 
and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with 
a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, 
allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades 
of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and 
the vivid colors of its surroundings. A close-up shot with dynamic movement.
"""
negative_prompt = """
Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
"""

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=99,
    num_inference_steps=50,
    guidance_scale=5.0,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_base_t2v_output.mp4", fps=24)
```

### Generación con Helios-Base

El siguiente ejemplo demuestra cómo usar Helios-Base para generar video a partir de texto, imagen o video.

```python
import torch
from diffusers import AutoModel, HeliosPipeline
from diffusers.utils import export_to_video, load_video, load_image

vae = AutoModel.from_pretrained("BestWishYsh/Helios-Base", subfolder="vae", dtype=torch.float32)

pipeline = HeliosPipeline.from_pretrained(
    "BestWishYsh/Helios-Base",
    vae=vae,
    dtype=torch.bfloat16
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

negative_prompt = """
Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
"""

# For Text-to-Video
prompt = """
A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue 
and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with 
a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, 
allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades 
of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and 
the vivid colors of its surroundings. A close-up shot with dynamic movement.
"""

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=99,
    num_inference_steps=50,
    guidance_scale=5.0,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_base_t2v_output.mp4", fps=24)

# For Image-to-Video
prompt = """
A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, 
illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, 
casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes 
apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and 
relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and 
respect for nature’s might.
"""
image_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg"

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=load_image(image_path).resize((640, 384)),
    num_frames=99,
    num_inference_steps=50,
    guidance_scale=5.0,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_base_i2v_output.mp4", fps=24)

# For Video-to-Video
prompt = """
A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees 
under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, 
emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to 
the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. 
A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.
"""
video_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4"

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    video=load_video(video_path),
    num_frames=99,
    num_inference_steps=50,
    guidance_scale=5.0,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_base_v2v_output.mp4", fps=24)
```

### Generación con Helios-Mid

El siguiente ejemplo demuestra cómo usar Helios-Mid para generar video a partir de texto, imagen o video.

```python
import torch
from diffusers import AutoModel, HeliosPyramidPipeline
from diffusers.utils import export_to_video, load_video, load_image

vae = AutoModel.from_pretrained("BestWishYsh/Helios-Mid", subfolder="vae", dtype=torch.float32)

pipeline = HeliosPyramidPipeline.from_pretrained(
    "BestWishYsh/Helios-Mid",
    vae=vae,
    dtype=torch.bfloat16
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

negative_prompt = """
Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
"""

# For Text-to-Video
prompt = """
A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue 
and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with 
a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, 
allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades 
of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and 
the vivid colors of its surroundings. A close-up shot with dynamic movement.
"""

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=99,
    pyramid_num_inference_steps_list=[20, 20, 20],
    guidance_scale=5.0,
    use_zero_init=True,
    zero_steps=1,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_pyramid_t2v_output.mp4", fps=24)

# For Image-to-Video
prompt = """
A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, 
illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, 
casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes 
apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and 
relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and 
respect for nature’s might.
"""
image_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg"

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=load_image(image_path).resize((640, 384)),
    num_frames=99,
    pyramid_num_inference_steps_list=[20, 20, 20],
    guidance_scale=5.0,
    use_zero_init=True,
    zero_steps=1,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_pyramid_i2v_output.mp4", fps=24)

# For Video-to-Video
prompt = """
A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees 
under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, 
emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to 
the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. 
A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.
"""
video_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4"

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    video=load_video(video_path),
    num_frames=99,
    pyramid_num_inference_steps_list=[20, 20, 20],
    guidance_scale=5.0,
    use_zero_init=True,
    zero_steps=1,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_pyramid_v2v_output.mp4", fps=24)
```

### Generación con Helios-Distilled

El siguiente ejemplo demuestra cómo usar Helios-Distilled para generar video a partir de texto, imagen o video.

```python
import torch
from diffusers import AutoModel, HeliosPyramidPipeline
from diffusers.utils import export_to_video, load_video, load_image

vae = AutoModel.from_pretrained("BestWishYsh/Helios-Distilled", subfolder="vae", dtype=torch.float32)

pipeline = HeliosPyramidPipeline.from_pretrained(
    "BestWishYsh/Helios-Distilled",
    vae=vae,
    dtype=torch.bfloat16
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

negative_prompt = """
Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
"""

# For Text-to-Video
prompt = """
A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue 
and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with 
a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, 
allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades 
of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and 
the vivid colors of its surroundings. A close-up shot with dynamic movement.
"""

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=240,
    pyramid_num_inference_steps_list=[2, 2, 2],
    guidance_scale=1.0,
    is_amplify_first_chunk=True,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_distilled_t2v_output.mp4", fps=24)

# For Image-to-Video
prompt = """
A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, 
illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, 
casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes 
apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and 
relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and 
respect for nature’s might.
"""
image_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg"

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=load_image(image_path).resize((640, 384)),
    num_frames=240,
    pyramid_num_inference_steps_list=[2, 2, 2],
    guidance_scale=1.0,
    is_amplify_first_chunk=True,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_distilled_i2v_output.mp4", fps=24)

# For Video-to-Video
prompt = """
A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees 
under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, 
emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to 
the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. 
A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.
"""
video_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4"

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    video=load_video(video_path),
    num_frames=240,
    pyramid_num_inference_steps_list=[2, 2, 2],
    guidance_scale=1.0,
    is_amplify_first_chunk=True,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]
export_to_video(output, "helios_distilled_v2v_output.mp4", fps=24)
```

## Muestras de Texto a Video

  
    Video generado por prompt
  
  
    Un guerrero vikingo conduciendo un autobús urbano moderno lleno de pasajeros. El vikingo tiene el cabello rubio largo recogido hacia atrás, barba, y viste un casco y una armadura forrados de piel. Lleva una túnica y pantalones tradicionales, pero también usa un cinturón de seguridad mientras se concentra en navegar por las calles concurridas. El interior del autobús es típico, con filas de asientos ocupados por diversos pasajeros que siguen sus rutinas diarias. Las tomas exteriores muestran el bullicioso entorno urbano, incluyendo edificios altos y tráfico. Plano medio centrado en el vikingo al volante, con primeros planos ocasionales de su expresión decidida.
    
    
      
        
      
    
  
  
    Un fotograma de fotografía de naturaleza estilo documental, tomado desde un camión de cámara en movimiento hacia la izquierda, que captura a un cangrejo que se escabulle rápidamente hacia su madriguera. El cangrejo tiene un caparazón duro de color verde-marrón y pinzas largas, y se mueve con una velocidad decidida sobre el suelo arenoso. Su cuerpo está ligeramente arqueado mientras se hunde en la arena, dejando un pequeño rastro detrás. El fondo muestra una playa poco profunda con rocas y conchas marinas dispersas, y el horizonte presenta una suave curva de la línea de costa. La foto tiene una textura natural y realista, que enfatiza el movimiento natural del cangrejo y la textura de la arena. Un primer plano desde un ángulo ligeramente elevado.
    
    
      
        
      
    
  

## Muestras de imagen a video

  
    Imagen Prompt Video generado
  
  
    
    Un elegante coche rojo Kia avanza a toda velocidad por una carretera rural bajo un cielo nublado, y su diseño moderno y movimiento dinámico se acentúan por el desenfoque de movimiento de los campos y árboles circundantes que se extienden hasta el horizonte. El exterior brillante del coche refleja el cielo cubierto, destacando su forma aerodinámica y su postura deportiva. La matrícula dice "KIA 626" y los faros del vehículo están encendidos, lo que añade a la sensación de movimiento y energía. La carretera curva suavemente, con el coche situado ligeramente fuera del centro, creando una sensación de impulso hacia adelante. Una vista frontal de tres cuartos dinámica captura la poderosa presencia del coche contra el sereno telón de fondo de colinas ondulantes y árboles dispersos.
    
    
      
        
      
    
  
  
    
    Un primer plano captura a un gato naranja esponjoso con ojos verdes llamativos y bigotes blancos, mirando fijamente hacia la cámara. El pelaje del gato es suave y bien cuidado, con una mezcla de tonos cálidos de naranja y crema. Sus grandes ojos expresivos son de un verde vívido, reflejando curiosidad y alerta. La nariz del gato es pequeña y rosada, y su boca está ligeramente abierta, dejando entrever un atisbo de su lengua rosada. El fondo está suavemente desenfocado, sugiriendo un ambiente interior acogedor con tonos neutros. La foto tiene una profundidad de campo reducida, enfocando nítidamente en la cara del gato mientras el fondo permanece desenfocado. Un disparo de primer plano desde una perspectiva ligeramente elevada.
    
    
      
        
      
    
  

## Vitrinas de video interactivas

  
    Video generado por prompt
  
  
    El prompt se puede encontrar aquí
    
      
        
      
    
  
  
    El prompt se puede encontrar aquí
    
      
        
      
    
  

## Recursos

Obtén más información sobre Helios con los siguientes recursos.
- Mira [video1](https://www.youtube.com/watch?v=vd_AgHtOUFQ) y [video2](https://www.youtube.com/watch?v=1GeIU2Dn7UY) para ver una demostración de las funciones clave de Helios.
- El artículo de investigación, [Helios: Real Real-Time Long Video Generation Model](https://huggingface.co/papers/2603.04379), para más detalles.

## HeliosPipeline[[diffusers.HeliosPipeline]]

#### diffusers.HeliosPipeline[[diffusers.HeliosPipeline]]

```python
diffusers.HeliosPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, vae: AutoencoderKLWan, scheduler: HeliosScheduler, transformer: HeliosTransformer3DModel)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/helios/pipeline_helios.py#L108)

**Parámetros:**

tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), concretamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([HeliosTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/helios_transformer3d#diffusers.HeliosTransformer3DModel)) : Transformer condicional para desruidar los latentes de entrada.

scheduler ([HeliosScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/helios#diffusers.HeliosScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

Pipeline para la generación de texto a video / imagen a video / video a video usando Helios.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/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.HeliosPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 384, width: int = 640, num_frames: int = 132, num_inference_steps: int = 50, sigmas: list[float] = None, guidance_scale: float = 5.0, 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, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, image_latents: typing.Optional[torch.Tensor] = None, fake_image_latents: typing.Optional[torch.Tensor] = None, add_noise_to_image_latents: bool = True, image_noise_sigma_min: float = 0.111, image_noise_sigma_max: float = 0.135, video: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, video_latents: typing.Optional[torch.Tensor] = None, add_noise_to_video_latents: bool = True, video_noise_sigma_min: float = 0.111, video_noise_sigma_max: float = 0.135, history_sizes: list = [16, 2, 1], num_latent_frames_per_chunk: int = 9, keep_first_frame: bool = True, is_skip_first_chunk: bool = False)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/helios/pipeline_helios.py#L445)

**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, pase `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts a evitar durante la generación de imágenes. Si no se define, pase `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale` < `1`).

height (`int`, por defecto `384`) : La altura en píxeles de la imagen generada.

width (`int`, por defecto `640`) : El ancho en píxeles de la imagen generada.

num_frames (`int`, por defecto `132`) : El número de fotogramas en el video generado.

num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido. Si no se definen, se utiliza la programación predeterminada del programador.

guidance_scale (`float`, por defecto `5.0`) : Escala de guía 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 guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes 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 imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Si no se proporcionan, se generan a partir de `negative_prompt`.

output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver una `HeliosPipelineOutput` 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).

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto. Si el prompt es más largo que esto, se truncará. Si el prompt es más corto, se rellenará hasta esta longitud.

image (`PipelineImageInput`, *opcional*) : Imagen de entrada utilizada para la condicionamiento de imagen a video.

image_latents (`torch.Tensor`, *opcional*) : Latentes de imagen precodificados para usar en lugar de `image`.

fake_image_latents (`torch.Tensor`, *opcional*) : Latentes de imagen falsos opcionales utilizados durante la condicionamiento.

add_noise_to_image_latents (`bool`, *opcional*, valor predeterminado `True`) : Si se debe añadir ruido a los latentes de la imagen antes del desruido.

image_noise_sigma_min (`float`, *opcional*, valor predeterminado `0.111`) : Valor mínimo de sigma para el ruido añadido a los latentes de la imagen.

image_noise_sigma_max (`float`, *opcional*, valor predeterminado `0.135`) : Valor máximo de sigma para el ruido añadido a los latentes de la imagen.

video (`PipelineImageInput`, *opcional*) : Video de entrada utilizado para la condición de video a video.

video_latents (`torch.Tensor`, *opcional*) : Latentes de video precodificados para usar en lugar de `video`.

add_noise_to_video_latents (`bool`, *opcional*, valor predeterminado `True`) : Si se debe añadir ruido a los latentes del vídeo antes del desruido.

video_noise_sigma_min (`float`, *opcional*, valor predeterminado `0.111`) : Valor mínimo de sigma para el ruido añadido a los latentes de video.

video_noise_sigma_max (`float`, *opcional*, valor predeterminado `0.135`) : Valor máximo de sigma para el ruido añadido a los latentes de video.

history_sizes (`list`, *opcional*, valor predeterminado `[16, 2, 1]`) : Tamaños de la ventana de historial utilizados para la generación por bloques autorregresiva.

num_latent_frames_per_chunk (`int`, *opcional*, valor predeterminado `9`) : Número de fotogramas latentes producidos por bloque durante la generación autoregresiva.

keep_first_frame (`bool`, *opcional*, valor predeterminado `True`) : Si se conserva el primer fotograma entre los fragmentos.

is_skip_first_chunk (`bool`, *opcional*, por defecto `False`) : Si se debe omitir la generación del primer fragmento.

**Devuelve:** `~HeliosPipelineOutput` o `tuple`

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

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

Ejemplos:
```python
>>> import torch
>>> from diffusers.utils import export_to_video
>>> from diffusers import AutoencoderKLWan, HeliosPipeline

>>> # Available models: BestWishYsh/Helios-Base, BestWishYsh/Helios-Mid, BestWishYsh/Helios-Distilled
>>> model_id = "BestWishYsh/Helios-Base"
>>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
>>> pipe = HeliosPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> 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 = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"

>>> output = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     height=384,
...     width=640,
...     num_frames=132,
...     guidance_scale=5.0,
... ).frames[0]
>>> export_to_video(output, "output.mp4", fps=24)
```

#### encode_prompt[[diffusers.HeliosPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 226, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/helios/pipeline_helios.py#L196)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. 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 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`.

device : (`torch.device`, *opcional*): dispositivo de torch

dtype : (`torch.dtype`, *opcional*): dtype de torch

Codifica el prompt en estados ocultos del codificador de texto.

## HeliosPyramidPipeline[[diffusers.HeliosPyramidPipeline]]

#### diffusers.HeliosPyramidPipeline[[diffusers.HeliosPyramidPipeline]]

```python
diffusers.HeliosPyramidPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, vae: AutoencoderKLWan, scheduler: diffusers.schedulers.scheduling_helios.HeliosScheduler | diffusers.schedulers.scheduling_helios_dmd.HeliosDMDScheduler, transformer: HeliosTransformer3DModel, is_cfg_zero_star: bool = False, is_distilled: bool = False)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/helios/pipeline_helios_pyramid.py#L121)

**Parámetros:**

tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), concretamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([HeliosTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/helios_transformer3d#diffusers.HeliosTransformer3DModel)) : Transformer condicional para desruidar los latentes de entrada.

scheduler ([`HeliosScheduler`, `HeliosDMDScheduler`]) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.

vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes.

Pipeline para la generación de texto a video / imagen a video / video a video usando Helios.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/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.HeliosPyramidPipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 384, width: int = 640, num_frames: int = 132, sigmas: list[float] = None, guidance_scale: float = 5.0, 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, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, image_latents: typing.Optional[torch.Tensor] = None, fake_image_latents: typing.Optional[torch.Tensor] = None, add_noise_to_image_latents: bool = True, image_noise_sigma_min: float = 0.111, image_noise_sigma_max: float = 0.135, video: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, video_latents: typing.Optional[torch.Tensor] = None, add_noise_to_video_latents: bool = True, video_noise_sigma_min: float = 0.111, video_noise_sigma_max: float = 0.135, history_sizes: list = [16, 2, 1], num_latent_frames_per_chunk: int = 9, keep_first_frame: bool = True, is_skip_first_chunk: bool = False, pyramid_num_inference_steps_list: list = [10, 10, 10], use_zero_init: bool | None = True, zero_steps: int | None = 1, is_amplify_first_chunk: bool = False)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/helios/pipeline_helios_pyramid.py#L508)

**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, pase `prompt_embeds` en su lugar.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts a evitar durante la generación de imágenes. Si no se define, pase `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale` < `1`).

height (`int`, por defecto `384`) : La altura en píxeles de la imagen generada.

width (`int`, por defecto `640`) : El ancho en píxeles de la imagen generada.

num_frames (`int`, por defecto `132`) : El número de fotogramas en el video generado.

sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido. Si no se definen, se utiliza la programación predeterminada del programador.

guidance_scale (`float`, por defecto `5.0`) : Escala de guía 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 guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes 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 imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Si no se proporcionan, se generan a partir de `negative_prompt`.

output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver una `HeliosPipelineOutput` 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).

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto. Si el prompt es más largo que esto, se truncará. Si el prompt es más corto, se rellenará hasta esta longitud.

image (`PipelineImageInput`, *opcional*) : Imagen de entrada utilizada para la condicionamiento de imagen a video.

image_latents (`torch.Tensor`, *opcional*) : Latentes de imagen precodificados para usar en lugar de `image`.

fake_image_latents (`torch.Tensor`, *opcional*) : Latentes de imagen falsos opcionales utilizados durante la condicionamiento.

add_noise_to_image_latents (`bool`, *opcional*, valor predeterminado `True`) : Si se debe añadir ruido a los latentes de la imagen antes del desruido.

image_noise_sigma_min (`float`, *opcional*, valor predeterminado `0.111`) : Valor mínimo de sigma para el ruido añadido a los latentes de la imagen.

image_noise_sigma_max (`float`, *opcional*, valor predeterminado `0.135`) : Valor máximo de sigma para el ruido añadido a los latentes de la imagen.

video (`PipelineImageInput`, *opcional*) : Video de entrada utilizado para la condición de video a video.

video_latents (`torch.Tensor`, *opcional*) : Latentes de video precodificados para usar en lugar de `video`.

add_noise_to_video_latents (`bool`, *opcional*, valor predeterminado `True`) : Si se debe añadir ruido a los latentes del vídeo antes del desruido.

video_noise_sigma_min (`float`, *opcional*, valor predeterminado `0.111`) : Valor mínimo de sigma para el ruido añadido a los latentes de video.

video_noise_sigma_max (`float`, *opcional*, valor predeterminado `0.135`) : Valor máximo de sigma para el ruido añadido a los latentes de video.

history_sizes (`list`, *opcional*, valor predeterminado `[16, 2, 1]`) : Tamaños de la ventana de historial utilizados para la generación por bloques autorregresiva.

num_latent_frames_per_chunk (`int`, *opcional*, valor predeterminado `9`) : Número de fotogramas latentes producidos por bloque durante la generación autoregresiva.

keep_first_frame (`bool`, *opcional*, valor predeterminado `True`) : Si se conserva el primer fotograma entre los fragmentos.

is_skip_first_chunk (`bool`, *opcional*, por defecto `False`) : Si se debe omitir la generación del primer fragmento.

pyramid_num_inference_steps_list (`list`, *opcional*, valor predeterminado `[10, 10, 10]`) : Número de pasos de inferencia para cada etapa de la pirámide durante la generación de la Etapa 2.

use_zero_init (`bool`, *opcional*, valor predeterminado `True`) : Si se aplica la inicialización a cero de CFG al inicio del desruido.

zero_steps (`int`, *opcional*, valor predeterminado `1`) : Número de pasos iniciales que utilizan CFG zero-init.

is_amplify_first_chunk (`bool`, *opcional*, valor predeterminado `False`) : Si se amplifica la guía en el primer fragmento (relacionado con DMD).

**Devuelve:** `~HeliosPipelineOutput` o `tuple`

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

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

Ejemplos:
```python
>>> import torch
>>> from diffusers.utils import export_to_video
>>> from diffusers import AutoencoderKLWan, HeliosPyramidPipeline

>>> # Available models: BestWishYsh/Helios-Base, BestWishYsh/Helios-Mid, BestWishYsh/Helios-Distilled
>>> model_id = "BestWishYsh/Helios-Base"
>>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
>>> pipe = HeliosPyramidPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> 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 = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"

>>> output = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     height=384,
...     width=640,
...     num_frames=132,
...     guidance_scale=5.0,
... ).frames[0]
>>> export_to_video(output, "output.mp4", fps=24)
```

#### encode_prompt[[diffusers.HeliosPyramidPipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 226, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/helios/pipeline_helios_pyramid.py#L214)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : prompt a codificar

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador.

num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. 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 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`.

device : (`torch.device`, *opcional*): dispositivo de torch

dtype : (`torch.dtype`, *opcional*): dtype de torch

Codifica el prompt en estados ocultos del codificador de texto.

## HeliosPipelineOutput[[diffusers.pipelines.helios.pipeline_output.HeliosPipelineOutput]]

#### diffusers.pipelines.helios.pipeline_output.HeliosPipelineOutput[[diffusers.pipelines.helios.pipeline_output.HeliosPipelineOutput]]

```python
diffusers.pipelines.helios.pipeline_output.HeliosPipelineOutput(frames: Tensor)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/helios/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 tuberías de Helios.