#
# Sous licence Apache License, Version 2.0 (la « Licence ») ;
# vous ne pouvez utiliser ce fichier que conformément à la Licence.
# Vous pouvez obtenir un exemplaire de la Licence à
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Sauf exigence légale ou accord écrit
# distribué sous la Licence est distribué sur une base « EN L'ÉTAT »,
# SANS AUCUNE GARANTIE NI CONDITION, explicite ou implicite.
# Voir la Licence pour le langage spécifique régissant les autorisations et
# limitations under the License. -->

  
    
      
    
  

# Helios

[Helios : modèle de génération de vidéos longues en temps réel](https://huggingface.co/papers/2603.04379) de l'Université de Pékin & ByteDance & autres, par Shenghai Yuan, Yuanyang Yin, Zongjian Li, Xinwei Huang, Xiao Yang, Li Yuan.

*  Nous présentons Helios, le premier modèle de génération vidéo de 14B qui fonctionne à 17 FPS sur un seul GPU NVIDIA H100 et qui prend en charge la génération à l'échelle de la minute tout en égalant un solide modèle de référence en termes de qualité. Nous réalisons des percées le long de trois dimensions clés : (1) la robustesse au dérive des vidéos longues sans les heuristiques anti-dérive couramment utilisées telles que le self-forcing, les banques d'erreurs ou l'échantillonnage de plans-clés ; (2) la génération en temps réel sans les techniques d'accélération standard telles que le KV-cache, le masquage causal ou l'attention creuse ; et (3) l'entraînement sans cadres de parallélisme ou de fractionnement, permettant des tailles de lot à l'échelle de la diffusion d'images tout en faisant tenir jusqu'à quatre modèles de 14B dans 80 Go de mémoire GPU. Plus précisément, Helios est un modèle de diffusion autorégressif de 14B avec une représentation d'entrée unifiée qui prend nativement en charge les tâches T2V, I2V et V2V. Pour atténuer la dérive dans la génération de vidéos longues, nous caractérisons ses modes de défaillance typiques et proposons des stratégies d'entraînement simples mais efficaces qui simulent explicitement la dérive pendant l'entraînement, tout en éliminant le mouvement répétitif à sa source. Pour l'efficacité, nous compressons fortement le contexte historique et bruité et réduisons le nombre d'étapes d'échantillonnage, ce qui donne des coûts de calcul comparables à — ou inférieurs à — ceux des modèles génératifs vidéo de 1,3B. De plus, nous introduisons des optimisations au niveau de l'infrastructure qui accélèrent à la fois l'inférence et l'entraînement tout en réduisant la consommation de mémoire. Des expériences étendues démontrent que Helios surpasse systématiquement les méthodes antérieures sur la génération de vidéos courtes et longues. Tout le code et les modèles sont disponibles à [cette URL https](https://pku-yuangroup.github.io/Helios-Page).

Les modèles Helios suivants sont pris en charge dans Diffusers :

- [Helios-Base](https://huggingface.co/BestWishYsh/Helios-Base) : Meilleure qualité, avec v-prediction, CFG standard et HeliosScheduler personnalisé.
- [Helios-Mid](https://huggingface.co/BestWishYsh/Helios-Mid) : Poids intermédiaire, avec v-prediction, CFG-Zero* et HeliosScheduler personnalisé.
- [Helios-Distilled](https://huggingface.co/BestWishYsh/Helios-Distilled) : meilleure efficacité, avec x0-prediction et HeliosDMDScheduler personnalisé.

> [!TIP]
> Cliquez sur les modèles Helios dans la barre latérale droite pour plus d’exemples de génération de vidéos.

### Optimisation de la mémoire et de la vitesse d’inférence

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

Reportez-vous au guide [Réduire l'utilisation de la mémoire](../../optimization/memory) pour plus de détails sur les différentes techniques d'économie de mémoire.

Le modèle Helios ci-dessous nécessite environ 6 Go 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) est lente lors de la première exécution, mais les appels suivants au pipeline sont plus rapides. Les [Attention Backends](../../optimization/attention_backends) tels que FlashAttention et SageAttention peuvent augmenter considérablement la vitesse en optimisant le calcul du mécanisme d'attention. Le [Context Parallelism](../../optimization/context_parallelism) répartit la séquence d'entrée sur plusieurs appareils pour permettre le traitement de contextes longs en parallèle, réduisant ainsi la pression sur la mémoire et la latence. Le [Caching](../../optimization/cache) peut également accélérer l'inférence en stockant et en réutilisant les sorties intermédiaires.

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

### Génération avec Helios-Base

L'exemple ci-dessous montre comment utiliser Helios-Base pour générer une vidéo à partir d'un texte, d'une image ou d'une vidéo.

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

### Génération avec Helios-Mid

L'exemple ci-dessous montre comment utiliser Helios-Mid pour générer une vidéo à partir d'un texte, d'une image ou d'une vidéo.

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

### Génération avec Helios-Distilled

L'exemple ci-dessous montre comment utiliser Helios-Distilled pour générer une vidéo à partir d'un texte, d'une image ou d'une vidéo.

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

## Présentations de la génération de vidéos à partir de texte

  
    Vidéo générée par prompt
  
  
    Un guerrier viking conduisant un bus de ville moderne rempli de passagers. Le viking a de longs cheveux blonds attachés en arrière, une barbe, et porte un casque doublé de fourrure ainsi qu'une armure. Il est vêtu d'une tunique et d'un pantalon traditionnels, mais porte également une ceinture de sécurité tout en se concentrant sur la navigation dans les rues animées. L'intérieur du bus est typique, avec des rangées de sièges occupées par des passagers variés qui mènent leurs activités quotidiennes. Les plans extérieurs montrent l'environnement urbain animé, y compris des immeubles de grande hauteur et la circulation. Plan moyen mettant en focus le viking au volant, avec des gros plans occasionnels sur son expression déterminée.
    
    
      
        
      
    
  
  
    Une photographie de nature de style documentaire, prise depuis un camion-caméra se déplaçant vers la gauche, capturant un crabe qui se précipite dans son terrier. Le crabe possède une carapace dure, de couleur vert-brun, et de longues pinces, se déplaçant avec une vitesse déterminée sur le sol sablonneux. Son corps est légèrement voûté alors qu'il s'enfonce dans le sable, laissant derrière lui une petite trace. L'arrière-plan montre une plage peu profonde parsemée de rochers et de coquillages, et l'horizon présente une courbe douce de la ligne de côte. La photo a une texture naturelle et réaliste, mettant en valeur le mouvement naturel du crabe et la texture du sable. Un plan rapproché pris d'un angle légèrement surélevé.
    
    
      
        
      
    
  

## Présentations de la génération de vidéos à partir d'images

  
    Image Prompt Vidéo Générée
  
  
    
    Une élégante voiture rouge Kia file sur une route rurale sous un ciel nuageux, son design moderne et son mouvement dynamique étant mis en valeur par le flou de mouvement des champs et des arbres environnants qui s'étendent à perte de vue. L'extérieur brillant de la voiture reflète le ciel couvert, soulignant sa forme aérodynamique et sa posture sportive. La plaque d'immatriculation indique « KIA 626 » et les phares du véhicule sont allumés, ajoutant au sentiment de mouvement et d'énergie. La route s'incurve doucement, la voiture étant positionnée légèrement hors du centre, créant un sentiment d'élan vers l'avant. Une vue dynamique de trois quarts avant capture la présence puissante de la voiture sur le fond paisible de collines ondulantes et d'arbres épars.
    
    
      
        
      
    
  
  
    
    Un gros plan capture un chat orange touffu aux yeux verts saisissants et aux moustaches blanches, fixant intensément l'objectif. La fourrure du chat est douce et bien entretenue, mêlant des teintes chaudes d'orange et de crème. Ses grands yeux expressifs sont d'un vert vif, reflétant curiosité et vigilance. Son nez est petit et rose, et sa bouche est légèrement entrouverte, laissant entrevoir une pointe de sa langue rose. L'arrière-plan est flou, suggérant un intérieur confortable aux tons neutres. La photo présente une faible profondeur de champ, mettant nettement en valeur le visage du chat tandis que l'arrière-plan reste flou. Un plan rapproché pris d'un point de vue légèrement surélevé.
    
    
      
        
      
    
  

## Présentations de vidéos interactives

  
    Vidéo générée par prompt
  
  
    Le prompt peut être trouvé ici
    
      
        
      
    
  
  
    Le prompt peut être trouvé ici
    
      
        
      
    
  

## Ressources

En savoir plus sur Helios grâce aux ressources suivantes.
- Regardez [video1](https://www.youtube.com/watch?v=vd_AgHtOUFQ) et [video2](https://www.youtube.com/watch?v=1GeIU2Dn7UY) pour une démonstration des fonctionnalités clés de Helios.
- Le papier de recherche, [Helios: Real Real-Time Long Video Generation Model](https://huggingface.co/papers/2603.04379) pour plus de détails.

## HeliosPipeline[[diffusers.HeliosPipeline]]

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

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

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

**Paramètres :**

tokenizer (`T5Tokenizer`) : Tokenizer de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), plus précisément 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), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([HeliosTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/helios_transformer3d#diffusers.HeliosTransformer3DModel)) : Transformer conditionnel pour débruyer les latents d'entrée.

scheduler ([HeliosScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/helios#diffusers.HeliosScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.

vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes.

Pipeline pour la génération de texte vers vidéo / image vers vidéo / vidéo vers vidéo à l'aide de Helios.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline). Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).

#### __appel__[[diffusers.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)
```

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, passez plutôt `prompt_embeds`.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à éviter lors de la génération d’image. S’il n’est pas défini, passez plutôt `negative_prompt_embeds`. Ignoré lorsque le guidage n’est pas utilisé (`guidance_scale` < `1`).

height (`int`, par défaut `384`) : La hauteur en pixels de l'image générée.

width (`int`, par défaut `640`) : La largeur en pixels de l'image générée.

num_frames (`int`, par défaut `132`) : Le nombre de frames dans la vidéo générée.

num_inference_steps (`int`, par défaut `50`) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, le planificateur utilise son calendrier par défaut.

guidance_scale (`float`, par défaut `5.0`) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents est généré par échantillonnage à l'aide du `generator` aléatoire fourni.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Si elles ne sont pas fournies, elles sont générées à partir de `negative_prompt`.

output_type (`str`, *facultatif*, par défaut `"np"`) : Le format de sortie de l'image générée. Choisissez entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `HeliosPipelineOutput` plutôt qu'un simple tuple.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *facultatif*) : une fonction ou une sous-classe de `PipelineCallback` ou `MultiPipelineCallbacks` qui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.

max_sequence_length (`int`, par défaut `512`) : La longueur de séquence maximale du codeur de texte. Si le prompt est plus long que cela, il sera tronqué. S'il est plus court, il sera complété jusqu'à cette longueur.

image (`PipelineImageInput`, *facultatif*) : Image d'entrée utilisée pour le conditionnement image-vers-vidéo.

image_latents (`torch.Tensor`, *facultatif*) : Latents d'image pré-encodés à utiliser à la place de `image`.

fake_image_latents (`torch.Tensor`, *facultatif*) : Latents d'image factices facultatifs utilisés lors du conditionnement.

add_noise_to_image_latents (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter du bruit aux latents de l'image avant le débruitage.

image_noise_sigma_min (`float`, *facultatif*, valeur par défaut `0.111`) : Valeur minimale de sigma pour le bruit ajouté aux latents de l'image.

image_noise_sigma_max (`float`, *facultatif*, valeur par défaut `0.135`) : Valeur maximale de sigma pour le bruit ajouté aux latents de l'image.

video (`PipelineImageInput`, *facultatif*) : Vidéo d'entrée utilisée pour le conditionnement vidéo-vers-vidéo.

video_latents (`torch.Tensor`, *facultatif*) : Latents vidéo pré-encodés à utiliser à la place de `video`.

add_noise_to_video_latents (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter du bruit aux latents vidéo avant le débruitage.

video_noise_sigma_min (`float`, *facultatif*, valeur par défaut `0.111`) : Valeur minimale de sigma pour le bruit ajouté aux latents vidéo.

video_noise_sigma_max (`float`, *facultatif*, valeur par défaut `0.135`) : Valeur maximale de sigma pour le bruit ajouté aux latents vidéo.

history_sizes (`list`, *facultatif*, par défaut `[16, 2, 1]`) : Tailles des fenêtres d’historique utilisées pour la génération par morceaux autorégressive.

num_latent_frames_per_chunk (`int`, *facultatif*, valeur par défaut `9`) : Nombre de trames latentes produites par bloc lors de la génération autorégressive.

keep_first_frame (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut conserver le premier frame entre les chunks.

is_skip_first_chunk (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ignorer la génération du premier bloc.

**Retourne :** `~HeliosPipelineOutput` ou `tuple`

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

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

Exemples :
```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)
```

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser le guidage sans classifieur ou non.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

device : (`torch.device`, *facultatif*) : appareil torch

dtype : (`torch.dtype`, *facultatif*) : torch dtype

Encode le prompt dans les états cachés de l'encodeur de texte.

## 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)
```

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

**Paramètres :**

tokenizer (`T5Tokenizer`) : Tokenizer de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), plus précisément 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), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl).

transformer ([HeliosTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/helios_transformer3d#diffusers.HeliosTransformer3DModel)) : Transformer conditionnel pour débruyer les latents d'entrée.

scheduler ([`HeliosScheduler`, `HeliosDMDScheduler`]) : Un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés.

vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes.

Pipeline pour la génération de texte vers vidéo / image vers vidéo / vidéo vers vidéo à l'aide de Helios.

Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.DiffusionPipeline). Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).

#### __appel__[[diffusers.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)
```

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, passez plutôt `prompt_embeds`.

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à éviter lors de la génération d’image. S’il n’est pas défini, passez plutôt `negative_prompt_embeds`. Ignoré lorsque le guidage n’est pas utilisé (`guidance_scale` < `1`).

height (`int`, par défaut `384`) : La hauteur en pixels de l'image générée.

width (`int`, par défaut `640`) : La largeur en pixels de l'image générée.

num_frames (`int`, par défaut `132`) : Le nombre de frames dans la vidéo générée.

sigmas (`list[float]`, *facultatif*) : Sigmas personnalisés à utiliser pour le processus de débruitage. S'ils ne sont pas définis, le planificateur utilise son calendrier par défaut.

guidance_scale (`float`, par défaut `5.0`) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). L'échelle de guidage est activée en définissant `guidance_scale > 1`. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au `prompt` texte, généralement au détriment de la qualité de l'image.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Le nombre d'images à générer par invite.

generator (`torch.Generator` ou `list[torch.Generator]`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre la génération déterministe.

latents (`torch.Tensor`, *facultatif*) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents est généré par échantillonnage à l'aide du `generator` aléatoire fourni.

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte négatif pré-générées. Si elles ne sont pas fournies, elles sont générées à partir de `negative_prompt`.

output_type (`str`, *facultatif*, par défaut `"np"`) : Le format de sortie de l'image générée. Choisissez entre `PIL.Image` ou `np.array`.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `HeliosPipelineOutput` plutôt qu'un simple tuple.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'`AttentionProcessor` tel que défini sous `self.processor` dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *facultatif*) : une fonction ou une sous-classe de `PipelineCallback` ou `MultiPipelineCallbacks` qui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants : `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` contiendra une liste de tous les tenseurs, tels que spécifiés par `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *facultatif*) : La liste des entrées tensorielles pour la fonction `callback_on_step_end`. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument `callback_kwargs`. Vous ne pourrez inclure que les variables listées dans l'attribut `._callback_tensor_inputs` de votre classe de pipeline.

max_sequence_length (`int`, par défaut `512`) : La longueur de séquence maximale du codeur de texte. Si le prompt est plus long que cela, il sera tronqué. S'il est plus court, il sera complété jusqu'à cette longueur.

image (`PipelineImageInput`, *facultatif*) : Image d'entrée utilisée pour le conditionnement image-vers-vidéo.

image_latents (`torch.Tensor`, *facultatif*) : Latents d'image pré-encodés à utiliser à la place de `image`.

fake_image_latents (`torch.Tensor`, *facultatif*) : Latents d'image factices facultatifs utilisés lors du conditionnement.

add_noise_to_image_latents (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter du bruit aux latents de l'image avant le débruitage.

image_noise_sigma_min (`float`, *facultatif*, valeur par défaut `0.111`) : Valeur minimale de sigma pour le bruit ajouté aux latents de l'image.

image_noise_sigma_max (`float`, *facultatif*, valeur par défaut `0.135`) : Valeur maximale de sigma pour le bruit ajouté aux latents de l'image.

video (`PipelineImageInput`, *facultatif*) : Vidéo d'entrée utilisée pour le conditionnement vidéo-vers-vidéo.

video_latents (`torch.Tensor`, *facultatif*) : Latents vidéo pré-encodés à utiliser à la place de `video`.

add_noise_to_video_latents (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut ajouter du bruit aux latents vidéo avant le débruitage.

video_noise_sigma_min (`float`, *facultatif*, valeur par défaut `0.111`) : Valeur minimale de sigma pour le bruit ajouté aux latents vidéo.

video_noise_sigma_max (`float`, *facultatif*, valeur par défaut `0.135`) : Valeur maximale de sigma pour le bruit ajouté aux latents vidéo.

history_sizes (`list`, *facultatif*, par défaut `[16, 2, 1]`) : Tailles des fenêtres d’historique utilisées pour la génération par morceaux autorégressive.

num_latent_frames_per_chunk (`int`, *facultatif*, valeur par défaut `9`) : Nombre de trames latentes produites par bloc lors de la génération autorégressive.

keep_first_frame (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut conserver le premier frame entre les chunks.

is_skip_first_chunk (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ignorer la génération du premier bloc.

pyramid_num_inference_steps_list (`list`, *facultatif*, valeur par défaut `[10, 10, 10]`) : Nombre d'étapes d'inférence pour chaque étape de la pyramide lors de la génération de l'étape 2.

use_zero_init (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut appliquer l'initialisation à zéro du CFG au début du débruitage.

zero_steps (`int`, *facultatif*, valeur par défaut `1`) : Nombre d'étapes initiales utilisant CFG zero-init.

is_amplify_first_chunk (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut amplifier le guidage sur le premier bloc (lié à DMD).

**Retourne :** `~HeliosPipelineOutput` ou `tuple`

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

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

Exemples :
```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)
```

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

**Paramètres :**

prompt (`str` ou `list[str]`, *facultatif*) : invite à encoder

negative_prompt (`str` ou `list[str]`, *facultatif*) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer `negative_prompt_embeds` à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si `guidance_scale` est inférieur à `1`).

do_classifier_free_guidance (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser le guidage sans classifieur ou non.

num_videos_per_prompt (`int`, *facultatif*, valeur par défaut 1) : Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants

prompt_embeds (`torch.Tensor`, *facultatif*) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, *par ex.* pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée `prompt`.

negative_prompt_embeds (`torch.Tensor`, *facultatif*) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, *par exemple* le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée `negative_prompt`.

device : (`torch.device`, *facultatif*) : appareil torch

dtype : (`torch.dtype`, *facultatif*) : torch dtype

Encode le prompt dans les états cachés de l'encodeur de texte.

## 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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/helios/pipeline_output.py#L9)

**Paramètres :**

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

Classe de sortie pour les pipelines Helios.