Hugging Face's logo

Diffusers documentation

Helios

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v0.43.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

LoRA

Helios

Helios : modèle de génération de vidéos longues en temps réel 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 une référence solide 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 à [this https URL](https://pku-yuangroup.github.io/Helios-Page).

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

  • Helios-Base : Meilleure qualité, avec v-prediction, CFG standard et HeliosScheduler personnalisé.
  • Helios-Mid : Poids intermédiaire, avec v-prediction, CFG-Zero* et HeliosScheduler personnalisé.
  • Helios-Distilled : meilleure efficacité, avec x0-prediction et HeliosDMDScheduler personnalisé.

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.

mémoire
vitesse d'inférence

Reportez-vous au guide Réduire l'utilisation de la mémoire 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.

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)

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.

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

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

utilisation
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

PromptVidéo générée
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 au 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 depuis un angle légèrement surélevé.

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

ImagePromptVidé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 gros plan pris d'un point de vue légèrement surélevé.

Présentations de vidéos interactives

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

Ressources

En savoir plus sur Helios grâce aux ressources suivantes.

HeliosPipeline

classe diffusers.HeliosPipeline

< >

( tokenizer: AutoTokenizertext_encoder: UMT5EncoderModelvae: AutoencoderKLWanscheduler: HeliosSchedulertransformer: HeliosTransformer3DModel )

Paramètres

  • tokenizer (T5Tokenizer) — Tokenizer issu de T5, plus précisément la variante google/umt5-xxl.
  • text_encoder (T5EncoderModel) — T5, plus précisément la variante google/umt5-xxl.
  • transformer (HeliosTransformer3DModel) — Transformer conditionnel pour débruyer les latents d’entrée.
  • scheduler (HeliosScheduler) — Un planificateur à utiliser en combinaison avec transformer pour débruyer les latents d'image encodés.
  • vae (AutoencoderKLWan) — Modèle de Variational Auto-Encoder (VAE) pour encoder et 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. 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.).

__call__

< >

( prompt: str | list[str] = Nonenegative_prompt: str | list[str] = Noneheight: int = 384width: int = 640num_frames: int = 132num_inference_steps: int = 50sigmas: list[float] = Noneguidance_scale: float = 5.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'np'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list[str] = ['latents']max_sequence_length: int = 512image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneimage_latents: typing.Optional[torch.Tensor] = Nonefake_image_latents: typing.Optional[torch.Tensor] = Noneadd_noise_to_image_latents: bool = Trueimage_noise_sigma_min: float = 0.111image_noise_sigma_max: float = 0.135video: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonevideo_latents: typing.Optional[torch.Tensor] = Noneadd_noise_to_video_latents: bool = Truevideo_noise_sigma_min: float = 0.111video_noise_sigma_max: float = 0.135history_sizes: list = [16, 2, 1]num_latent_frames_per_chunk: int = 9keep_first_frame: bool = Trueis_skip_first_chunk: bool = False ) → ~HeliosPipelineOutput or tuple

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 d'images 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. guidance_scale est défini comme w de l’équation 2 de Imagen Paper. 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 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 servir à 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) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entrée prompt.
  • negative_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. S'ils ne sont pas fournis, ils sont générés à 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 défini sous self.processor dans diffusers.models.attention_processor.
  • 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 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 de l’encodeur 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 factuels facultatifs utilisés lors du conditionnement.
  • add_noise_to_image_latents (bool, facultatif, valeur 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 d'image.
  • image_noise_sigma_max (float, facultatif, valeur par défaut 0.135) — Valeur maximale de sigma pour le bruit ajouté aux latents d'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, valeur 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 auto-ré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 la première image d'un bloc à l'autre.
  • 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 :

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

< >

( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 226device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )

Paramètres

  • prompt (str ou list[str], facultatif) — prompt à encoder
  • negative_prompt (str ou list[str], facultatif) — Le 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, valeur par défaut True) — Indique s'il faut utiliser le classifier free guidance 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) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée prompt.
  • negative_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. 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) : torch device
  • dtype — (torch.dtype, facultatif) : dtype torch

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

HeliosPyramidPipeline

classe diffusers.HeliosPyramidPipeline

< >

( tokenizer: AutoTokenizertext_encoder: UMT5EncoderModelvae: AutoencoderKLWanscheduler: diffusers.schedulers.scheduling_helios.HeliosScheduler | diffusers.schedulers.scheduling_helios_dmd.HeliosDMDSchedulertransformer: HeliosTransformer3DModelis_cfg_zero_star: bool = Falseis_distilled: bool = False )

Paramètres

  • tokenizer (T5Tokenizer) — Tokenizer issu de T5, plus précisément la variante google/umt5-xxl.
  • text_encoder (T5EncoderModel) — T5, plus précisément la variante google/umt5-xxl.
  • transformer (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) — Modèle de Variational Auto-Encoder (VAE) pour encoder et 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. 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.).

__call__

< >

( prompt: str | list[str] = Nonenegative_prompt: str | list[str] = Noneheight: int = 384width: int = 640num_frames: int = 132sigmas: list[float] = Noneguidance_scale: float = 5.0num_videos_per_prompt: int | None = 1generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = Nonelatents: typing.Optional[torch.Tensor] = Noneprompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Noneoutput_type: str | None = 'np'return_dict: bool = Trueattention_kwargs: dict[str, typing.Any] | None = Nonecallback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = Nonecallback_on_step_end_tensor_inputs: list[str] = ['latents']max_sequence_length: int = 512image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Noneimage_latents: typing.Optional[torch.Tensor] = Nonefake_image_latents: typing.Optional[torch.Tensor] = Noneadd_noise_to_image_latents: bool = Trueimage_noise_sigma_min: float = 0.111image_noise_sigma_max: float = 0.135video: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = Nonevideo_latents: typing.Optional[torch.Tensor] = Noneadd_noise_to_video_latents: bool = Truevideo_noise_sigma_min: float = 0.111video_noise_sigma_max: float = 0.135history_sizes: list = [16, 2, 1]num_latent_frames_per_chunk: int = 9keep_first_frame: bool = Trueis_skip_first_chunk: bool = Falsepyramid_num_inference_steps_list: list = [10, 10, 10]use_zero_init: bool | None = Truezero_steps: int | None = 1is_amplify_first_chunk: bool = False ) → ~HeliosPipelineOutput or tuple

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 d'images 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. guidance_scale est défini comme w de l’équation 2 de Imagen Paper. 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 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 servir à 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) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). S'il n'est pas fourni, les embeddings de texte sont générés à partir de l'argument d'entrée prompt.
  • negative_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. S'ils ne sont pas fournis, ils sont générés à 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 défini sous self.processor dans diffusers.models.attention_processor.
  • 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 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 de l’encodeur 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 factuels facultatifs utilisés lors du conditionnement.
  • add_noise_to_image_latents (bool, facultatif, valeur 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 d'image.
  • image_noise_sigma_max (float, facultatif, valeur par défaut 0.135) — Valeur maximale de sigma pour le bruit ajouté aux latents d'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, valeur 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 auto-ré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 la première image d'un bloc à l'autre.
  • 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, 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, valeur par défaut True) — Indique s'il faut appliquer l'initialisation à zéro de CFG au début du débruitage.
  • zero_steps (int, facultatif, par défaut 1) — Nombre d'étapes initiales utilisant l'initialisation à zéro de CFG.
  • is_amplify_first_chunk (bool, facultatif, par défaut False) — Indique s'il faut amplifier le guidage sur le premier chunk (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 :

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

< >

( prompt: str | list[str]negative_prompt: str | list[str] | None = Nonedo_classifier_free_guidance: bool = Truenum_videos_per_prompt: int = 1prompt_embeds: typing.Optional[torch.Tensor] = Nonenegative_prompt_embeds: typing.Optional[torch.Tensor] = Nonemax_sequence_length: int = 226device: typing.Optional[torch.device] = Nonedtype: typing.Optional[torch.dtype] = None )

Paramètres

  • prompt (str ou list[str], facultatif) — prompt à encoder
  • negative_prompt (str ou list[str], facultatif) — Le 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, valeur par défaut True) — Indique s'il faut utiliser le classifier free guidance 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) — Embeddings de texte pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. le pondération des prompts. S'il n'est pas fourni, les embeddings de texte seront générés à partir de l'argument d'entrée prompt.
  • negative_prompt_embeds (torch.Tensor, facultatif) — Embeddings de texte négatifs pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. 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) : torch device
  • dtype — (torch.dtype, facultatif) : dtype torch

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

HeliosPipelineOutput

classe diffusers.pipelines.helios.pipeline_output.HeliosPipelineOutput

< >

( frames: Tensor )

Paramètres

  • frames (torch.Tensor, np.ndarray ou List[List[PIL.Image.Image]]) — Liste des 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.

Update on GitHub

←Framepack HunyuanVideo→