Buckets:

hf-doc-build
/

doc

Helios: Real Real-Time Long Video Generation Model da Universidade de Pequim & ByteDance & etc, por Shenghai Yuan, Yuanyang Yin, Zongjian Li, Xinwei Huang, Xiao Yang, Li Yuan.

Apresentamos o Helios, o primeiro modelo de geração de vídeo de 14B que roda a 17 FPS em uma única GPU NVIDIA H100 e suporta geração em escala de minutos, mantendo a qualidade de uma forte linha de base. Alcançamos avanços em três dimensões-chave: (1) robustez à deriva em vídeos longos, sem o uso de heurísticas comuns de anti-deriva, como self-forcing, error banks ou amostragem de keyframes; (2) geração em tempo real, sem técnicas padrão de aceleração, como KV-cache, causal masking ou atenção esparsa; e (3) treinamento sem frameworks de paralelismo ou sharding, permitindo tamanhos de lote na escala de difusão de imagem, enquanto acomoda até quatro modelos de 14B em 80 GB de memória de GPU. Especificamente, o Helios é um modelo de difusão autoregressivo de 14B com uma representação de entrada unificada que suporta nativamente as tarefas T2V, I2V e V2V. Para mitigar a deriva na geração de vídeos longos, caracterizamos seus modos de falha típicos e propomos estratégias de treinamento simples, porém eficazes, que simulam explicitamente a deriva durante o treinamento, eliminando o movimento repetitivo na sua origem. Para eficiência, comprimimos fortemente o contexto histórico e ruidoso e reduzimos o número de etapas de amostragem, resultando em custos computacionais comparáveis — ou inferiores — aos de modelos generativos de vídeo de 1.3B. Além disso, introduzimos otimizações em nível de infraestrutura que aceleram tanto a inferência quanto o treinamento, reduzindo o consumo de memória. Experimentos extensos demonstram que o Helios supera consistentemente métodos anteriores tanto na geração de vídeos curtos quanto longos. Todo o código e os modelos estão disponíveis em este URL.

Os seguintes modelos Helios são suportados no Diffusers:

Helios-Base: Melhor qualidade, com v-prediction, CFG padrão e HeliosScheduler personalizado.
Helios-Mid: Peso intermediário, com v-prediction, CFG-Zero* e HeliosScheduler personalizado.
Helios-Distilled: Melhor eficiência, com x0-prediction e HeliosDMDScheduler personalizado.

Clique nos modelos Helios na barra lateral à direita para mais exemplos de geração de vídeo.

Otimizando memória e velocidade de inferência

O exemplo abaixo demonstra como gerar um vídeo a partir de texto otimizado para memória ou velocidade de inferência.

Consulte o guia Reduzir o uso de memória para mais detalhes sobre as diversas técnicas de economia de memória.

O modelo Helios abaixo requer ~6GB 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)

Compilation é lento na primeira vez, mas as chamadas subsequentes ao pipeline são mais rápidas. Attention Backends como FlashAttention e SageAttention podem aumentar significativamente a velocidade ao otimizar o cálculo do mecanismo de atenção. Context Parallelism divide a sequência de entrada entre vários dispositivos para permitir o processamento de contextos longos em paralelo, reduzindo a pressão de memória e a latência. Caching também pode acelerar a inferência ao armazenar e reutilizar saídas intermediárias.

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)

Geração com Helios-Base

O exemplo abaixo demonstra como usar o Helios-Base para gerar vídeo com base em texto, imagem ou vídeo.

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)

Geração com Helios-Mid

O exemplo abaixo demonstra como usar o Helios-Mid para gerar vídeo com base em texto, imagem ou vídeo.

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)

Geração com Helios-Distilled

O exemplo abaixo demonstra como usar o Helios-Distilled para gerar vídeo com base em texto, imagem ou vídeo.

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)

Exibições de Texto para Vídeo

Vídeo Gerado por Prompt


Um guerreiro viking dirigindo um ônibus urbano moderno cheio de passageiros. O viking tem cabelos loiros longos presos para trás, barba e usa um capacete forrado de pele e armadura. Ele veste uma túnica e calças tradicionais, mas também usa cinto de segurança enquanto se concentra em navegar pelas ruas movimentadas. O interior do ônibus é típico, com fileiras de assentos ocupados por passageiros diversos seguindo suas rotinas diárias. As imagens externas mostram o ambiente urbano agitado, incluindo prédios altos e trânsito. Plano médio focando no viking ao volante, com close-ups ocasionais de sua expressão determinada.


  
    
  



Uma fotografia de natureza em estilo documental, filmada de um caminhão de câmera em movimento para a esquerda, capturando um caranguejo correndo rapidamente para sua toca. O caranguejo tem uma concha dura, de cor verde-marron, e garras longas, movendo-se com velocidade determinada pelo chão arenoso. Seu corpo está levemente arqueado enquanto se enterra na areia, deixando um pequeno rastro atrás. O fundo mostra uma praia rasa com pedras e conchas espalhadas, e o horizonte apresenta uma curva suave da linha costeira. A foto tem uma textura natural e realista, enfatizando o movimento natural do caranguejo e a textura da areia. Um close-up de um ângulo levemente elevado.

Exemplos de Imagem para Vídeo

Prompt de Imagem Vídeo Gerado



Um elegante carro vermelho da Kia percorre em alta velocidade uma estrada rural sob um céu nublado, com seu design moderno e movimento dinâmico destacados pelo desfoque de movimento dos campos e árvores ao redor que se estendem até o horizonte. A carroceria brilhante do carro reflete o céu encoberto, realçando sua forma aerodinâmica e postura esportiva. A placa de licença exibe "KIA 626" e os faróis do veículo estão acesos, aumentando a sensação de movimento e energia. A estrada faz uma curva suave, com o carro posicionado ligeiramente fora do centro, criando uma sensação de impulso para frente. Uma vista frontal dinâmica em três quartos captura a presença poderosa do carro contra o cenário sereno de colinas ondulantes e árvores espalhadas.


  
    
  




Um close-up captura um gato laranja fofo, com olhos verdes marcantes e bigodes brancos, olhando fixamente para a câmera. O pelo do gato é macio e bem cuidado, com uma mistura de tons quentes de laranja e creme. Seus grandes olhos expressivos são de um verde vívido, refletindo curiosidade e alerta. O nariz do gato é pequeno e rosa, e sua boca está levemente aberta, revelando um vislumbre de sua língua rosa. O fundo está suavemente desfocado, sugerindo um ambiente interno aconchegante com tons neutros. A foto tem uma profundidade de campo rasa, focando nitidamente no rosto do gato, enquanto o fundo permanece fora de foco. Um close-up tirado de uma perspectiva levemente elevada.

Vitrine de Vídeos Interativos

Vídeo Gerado por Prompt


O prompt pode ser encontrado aqui

  
    
  



O prompt pode ser encontrado aqui

Recursos

Saiba mais sobre o Helios com os seguintes recursos.

Assista a video1 e video2 para uma demonstração dos principais recursos do Helios.
O artigo de pesquisa, Helios: Real Real-Time Long Video Generation Model, para mais detalhes.

HeliosPipeline[[diffusers.HeliosPipeline]]

diffusers.HeliosPipeline[[diffusers.HeliosPipeline]]

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

Fonte

Parâmetros:

tokenizer (T5Tokenizer) : Tokenizer do T5, especificamente a variante google/umt5-xxl.

text_encoder (T5EncoderModel) : T5, especificamente a variante google/umt5-xxl.

transformer (HeliosTransformer3DModel) : Transformer condicional para desruidar os latentes de entrada.

scheduler (HeliosScheduler) : Um agendador a ser usado em combinação com transformer para desruidar os latentes da imagem codificada.

vae (AutoencoderKLWan) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.

Pipeline para geração de texto-para-vídeo / imagem-para-vídeo / vídeo-para-vídeo usando Helios.

Este modelo herda de DiffusionPipeline. Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.).

call[[diffusers.HeliosPipeline.call]]

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

Fonte

Parâmetros:

prompt (str ou list[str], opcional) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, passe prompt_embeds em vez disso.

negative_prompt (str ou list[str], opcional) : O prompt ou os prompts a evitar durante a geração de imagem. Se não definido, passe negative_prompt_embeds em vez disso. Ignorado quando não está usando orientação (guidance_scale < 1).

height (int, padrão 384) : A altura em pixels da imagem gerada.

width (int, padrão 640) : A largura em pixels da imagem gerada.

num_frames (int, padrão 132) : O número de quadros no vídeo gerado.

num_inference_steps (int, padrão 50) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta.

sigmas (list[float], opcional) : Sigmas personalizados para usar no processo de desruidamento. Se não definidos, o agendamento padrão do agendador é utilizado.

guidance_scale (float, padrão 5.0) : Escala de orientação definida em Classifier-Free Diffusion Guidance. guidance_scale é definido como w da equação 2. do Imagen Paper. A escala de orientação é ativada ao definir guidance_scale > 1. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao prompt de texto, geralmente em detrimento de uma menor qualidade de imagem.

num_videos_per_prompt (int, opcional, padrão 1) : O número de imagens a serem geradas por prompt.

generator (torch.Generator ou list[torch.Generator], opcional) : Um torch.Generator para tornar a geração determinística.

latents (torch.Tensor, opcional) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o generator aleatório fornecido.

prompt_embeds (torch.Tensor, opcional) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada prompt.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativos pré-gerados. Se não fornecidos, são gerados a partir de negative_prompt.

output_type (str, opcional, padrão "np") : O formato de saída da imagem gerada. Escolha entre PIL.Image ou np.array.

return_dict (bool, opcional, padrão True) : Se deve ou não retornar um HeliosPipelineOutput em vez de uma tupla simples.

attention_kwargs (dict, opcional) : Um dicionário de kwargs que, se especificado, é passado para o AttentionProcessor conforme definido em self.processor em diffusers.models.attention_processor.

callback_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, opcional) : Uma função ou uma subclasse de PipelineCallback ou MultiPipelineCallbacks que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs incluirá uma lista de todos os tensores, conforme especificado por callback_on_step_end_tensor_inputs.

callback_on_step_end_tensor_inputs (list, opcional) : A lista de entradas de tensor para a função callback_on_step_end. Os tensores especificados na lista serão passados como argumento callback_kwargs. Você só poderá incluir variáveis listadas no atributo ._callback_tensor_inputs da sua classe de pipeline.

max_sequence_length (int, padrão 512) : O comprimento máximo da sequência do codificador de texto. Se o prompt for mais longo que isso, ele será truncado. Se o prompt for mais curto, ele será preenchido até esse comprimento.

image (PipelineImageInput, opcional) : Imagem de entrada usada para a condicionamento de imagem para vídeo.

image_latents (torch.Tensor, opcional) : Latentes de imagem pré-codificados para usar no lugar de image.

fake_image_latents (torch.Tensor, opcional) : Latentes de imagem falsos opcionais usados durante o condicionamento.

add_noise_to_image_latents (bool, opcional, padrão True) : Se deve adicionar ruído aos latentes da imagem antes do desruidamento.

image_noise_sigma_min (float, opcional, padrão 0.111) : Valor mínimo de sigma para o ruído adicionado aos latentes da imagem.

image_noise_sigma_max (float, opcional, padrão 0.135) : Valor máximo de sigma para o ruído adicionado aos latentes da imagem.

video (PipelineImageInput, opcional) : Vídeo de entrada usado para condicionamento de vídeo para vídeo.

video_latents (torch.Tensor, opcional) : Latentes de vídeo pré-codificados para usar no lugar de video.

add_noise_to_video_latents (bool, opcional, padrão True) : Se deve adicionar ruído aos latentes do vídeo antes do desruidamento.

video_noise_sigma_min (float, opcional, padrão 0.111) : Valor mínimo de sigma para o ruído adicionado aos latentes de vídeo.

video_noise_sigma_max (float, opcional, padrão 0.135) : Valor máximo de sigma para o ruído adicionado aos latentes de vídeo.

history_sizes (list, opcional, padrão [16, 2, 1]) : Tamanhos das janelas de histórico usados para geração autoregressiva em blocos.

num_latent_frames_per_chunk (int, opcional, padrão 9) : Número de quadros latentes produzidos por bloco durante a geração autoregressiva.

keep_first_frame (bool, opcional, padrão True) : Se deve reter o primeiro quadro entre os blocos.

is_skip_first_chunk (bool, opcional, padrão False) : Se deve pular a geração do primeiro bloco.

Retorna: ~HeliosPipelineOutput ou tuple

Se return_dict for True, HeliosPipelineOutput é retornado; caso contrário, uma tuple é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de bools indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw).

A função de chamada do pipeline para geração.

Exemplos:

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

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)

Fonte

Parâmetros:

prompt (str ou list[str], opcional) : prompt a ser codificado

negative_prompt (str ou list[str], opcional) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar negative_prompt_embeds em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se guidance_scale for menor que 1).

do_classifier_free_guidance (bool, opcional, padrão True) : Se deve ou não usar classifier free guidance.

num_videos_per_prompt (int, opcional, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes

prompt_embeds (torch.Tensor, opcional) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada prompt.

negative_prompt_embeds (torch.Tensor, opcional) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, por exemplo, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada negative_prompt.

device : (torch.device, opcional): dispositivo torch

dtype : (torch.dtype, opcional): dtype do torch

Codifica o prompt em estados ocultos do codificador de texto.

HeliosPyramidPipeline[[diffusers.HeliosPyramidPipeline]]

diffusers.HeliosPyramidPipeline[[diffusers.HeliosPyramidPipeline]]

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)

Fonte

Parâmetros:

tokenizer (T5Tokenizer) : Tokenizer do T5, especificamente a variante google/umt5-xxl.

text_encoder (T5EncoderModel) : T5, especificamente a variante google/umt5-xxl.

transformer (HeliosTransformer3DModel) : Transformer condicional para desruidar os latentes de entrada.

scheduler ([HeliosScheduler, HeliosDMDScheduler]) : Um scheduler a ser usado em combinação com transformer para desruidar os latentes da imagem codificada.

vae (AutoencoderKLWan) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes.

Pipeline para geração de texto-para-vídeo / imagem-para-vídeo / vídeo-para-vídeo usando Helios.

call[[diffusers.HeliosPyramidPipeline.call]]

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