hf-doc-build/doc / diffusers /main /pt /api /pipelines /ltx_video.md

|

raw

85.9 kB

Licenciado sob a Apache License, Versão 2.0 (a "Licença");

você não pode usar este arquivo, exceto em conformidade com a Licença.

Você pode obter uma cópia da Licença em

http://www.apache.org/licenses/LICENSE-2.0

A menos que exigido pela lei aplicável ou acordado por escrito, o software

distribuído sob a Licença é distribuído em uma base "COMO ESTÁ",

SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas.

Consulte a Licença para o idioma específico que rege as permissões e

limitações sob a Licença. -->

LTX-Video

LTX-Video é um diffusion transformer projetado para a geração rápida e em tempo real de vídeos em alta resolução a partir de texto e imagens. O principal recurso do LTX-Video é o Video-VAE. O Video-VAE possui uma taxa de compressão de pixel para latente mais alta (1:192), o que permite um processamento de dados de vídeo mais eficiente e uma velocidade de geração mais rápida. Para suportar e evitar que detalhes mais finos sejam perdidos durante a geração, o decodificador do Video-VAE executa a conversão de latente para pixel e a última etapa de desruido.

Você pode encontrar todos os checkpoints originais do LTX-Video sob a organização Lightricks.

Clique nos modelos LTX-Video na barra lateral à direita para ver mais exemplos de outras tarefas de geração de vídeo.

O exemplo abaixo demonstra como gerar um vídeo 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 LTX-Video abaixo requer ~10GB de VRAM.

import torch
from diffusers import LTXPipeline, AutoModel
from diffusers.hooks import apply_group_offloading
from diffusers.utils import export_to_video

# fp8 layerwise weight-casting
transformer = AutoModel.from_pretrained(
    "Lightricks/LTX-Video",
    subfolder="transformer",
    dtype=torch.bfloat16
)
transformer.enable_layerwise_casting(
    storage_dtype=torch.float8_e4m3fn, compute_dtype=torch.bfloat16
)

pipeline = LTXPipeline.from_pretrained("Lightricks/LTX-Video", transformer=transformer, dtype=torch.bfloat16)

# group-offloading
onload_device = torch.device("cuda")
offload_device = torch.device("cpu")
pipeline.transformer.enable_group_offload(onload_device=onload_device, offload_device=offload_device, offload_type="leaf_level", use_stream=True)
apply_group_offloading(pipeline.text_encoder, onload_device=onload_device, offload_type="block_level", num_blocks_per_group=2)
apply_group_offloading(pipeline.vae, onload_device=onload_device, offload_type="leaf_level")

prompt = """
A woman with long brown hair and light skin smiles at another woman with long blonde hair.
The woman with brown hair wears a black jacket and has a small, barely noticeable mole on her right cheek.
The camera angle is a close-up, focused on the woman with brown hair's face. The lighting is warm and 
natural, likely from the setting sun, casting a soft glow on the scene. The scene appears to be real-life footage
"""
negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

video = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=768,
    height=512,
    num_frames=161,
    decode_timestep=0.03,
    decode_noise_scale=0.025,
    num_inference_steps=50,
).frames[0]
export_to_video(video, "output.mp4", fps=24)

Compilation é lento na primeira vez, mas as chamadas subsequentes ao pipeline são mais rápidas. Caching também pode acelerar a inferência ao armazenar e reutilizar saídas intermediárias.

import torch
from diffusers import LTXPipeline
from diffusers.utils import export_to_video

pipeline = LTXPipeline.from_pretrained(
    "Lightricks/LTX-Video", dtype=torch.bfloat16
)

# torch.compile
pipeline.transformer.to(memory_format=torch.channels_last)
pipeline.transformer = torch.compile(
    pipeline.transformer, mode="max-autotune", fullgraph=True
)

prompt = """
A woman with long brown hair and light skin smiles at another woman with long blonde hair.
The woman with brown hair wears a black jacket and has a small, barely noticeable mole on her right cheek.
The camera angle is a close-up, focused on the woman with brown hair's face. The lighting is warm and 
natural, likely from the setting sun, casting a soft glow on the scene. The scene appears to be real-life footage
"""
negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

video = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=768,
    height=512,
    num_frames=161,
    decode_timestep=0.03,
    decode_noise_scale=0.025,
    num_inference_steps=50,
).frames[0]
export_to_video(video, "output.mp4", fps=24)

Observações

Consulte as configurações recomendadas a seguir para geração a partir do repositório LTX-Video.
- O dtype recomendado para o transformer, o VAE e o text encoder é torch.bfloat16. O VAE e o text encoder também podem ser torch.float32 ou torch.float16.
- Para as variantes destiladas por orientação do LTX-Video, defina guidance_scale como 1.0. O guidance_scale para qualquer outro modelo deve ser definido com um valor maior, como 5.0, para uma boa qualidade de geração.
- Para as variantes de VAE com consciência de timestep (LTX-Video 0.9.1 e superiores), defina decode_timestep como 0.05 e image_cond_noise_scale como 0.025.
- Para as variantes que suportam interpolação entre múltiplas imagens e vídeos de condicionamento (LTX-Video 0.9.5 e superiores), utilize imagens e vídeos semelhantes para obter os melhores resultados. A divergência em relação às entradas de condicionamento pode levar a transições abruptas no vídeo gerado.

O LTX-Video 0.9.7 inclui um upscaler espacial de latentes e um transformer com 13B de parâmetros. Durante a inferência, um vídeo de baixa resolução é gerado rapidamente primeiro e, em seguida, é ampliado e refinado.

Exibir código de exemplo

import torch
from diffusers import LTXConditionPipeline, LTXLatentUpsamplePipeline
from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition
from diffusers.utils import export_to_video, load_video

pipeline = LTXConditionPipeline.from_pretrained("Lightricks/LTX-Video-0.9.7-dev", dtype=torch.bfloat16)
pipeline_upsample = LTXLatentUpsamplePipeline.from_pretrained("Lightricks/ltxv-spatial-upscaler-0.9.7", vae=pipeline.vae, dtype=torch.bfloat16)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"
pipe_upsample.to("cuda")
pipeline.vae.enable_tiling()

def round_to_nearest_resolution_acceptable_by_vae(height, width):
    height = height - (height % pipeline.vae_temporal_compression_ratio)
    width = width - (width % pipeline.vae_temporal_compression_ratio)
    return height, width

video = load_video(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cosmos/cosmos-video2world-input-vid.mp4"
)[:21]  # only use the first 21 frames as conditioning
condition1 = LTXVideoCondition(video=video, frame_index=0)

prompt = """
The video depicts a winding mountain road covered in snow, with a single vehicle 
traveling along it. The road is flanked by steep, rocky cliffs and sparse vegetation. 
The landscape is characterized by rugged terrain and a river visible in the distance. 
The scene captures the solitude and beauty of a winter drive through a mountainous region.
"""
negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"
expected_height, expected_width = 768, 1152
downscale_factor = 2 / 3
num_frames = 161

# 1. Generate video at smaller resolution
# Text-only conditioning is also supported without the need to pass `conditions`
downscaled_height, downscaled_width = int(expected_height * downscale_factor), int(expected_width * downscale_factor)
downscaled_height, downscaled_width = round_to_nearest_resolution_acceptable_by_vae(downscaled_height, downscaled_width)
latents = pipeline(
    conditions=[condition1],
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=downscaled_width,
    height=downscaled_height,
    num_frames=num_frames,
    num_inference_steps=30,
    decode_timestep=0.05,
    decode_noise_scale=0.025,
    image_cond_noise_scale=0.0,
    guidance_scale=5.0,
    guidance_rescale=0.7,
    generator=torch.Generator().manual_seed(0),
    output_type="latent",
).frames

# 2. Upscale generated video using latent upsampler with fewer inference steps
# The available latent upsampler upscales the height/width by 2x
upscaled_height, upscaled_width = downscaled_height * 2, downscaled_width * 2
upscaled_latents = pipe_upsample(
    latents=latents,
    output_type="latent"
).frames

# 3. Denoise the upscaled video with few steps to improve texture (optional, but recommended)
video = pipeline(
    conditions=[condition1],
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=upscaled_width,
    height=upscaled_height,
    num_frames=num_frames,
    denoise_strength=0.4,  # Effectively, 4 inference steps out of 10
    num_inference_steps=10,
    latents=upscaled_latents,
    decode_timestep=0.05,
    decode_noise_scale=0.025,
    image_cond_noise_scale=0.0,
    guidance_scale=5.0,
    guidance_rescale=0.7,
    generator=torch.Generator().manual_seed(0),
    output_type="pil",
).frames[0]

# 4. Downscale the video to the expected resolution
video = [frame.resize((expected_width, expected_height)) for frame in video]

export_to_video(video, "output.mp4", fps=24)

O modelo destilado LTX-Video 0.9.7 é destilado em relação ao guidance e aos timesteps para acelerar a geração. É necessário definir guidance_scale como 1.0 e num_inference_steps deve estar entre 4 e 10 para uma boa qualidade de geração. Você também deve usar os seguintes timesteps personalizados para obter os melhores resultados.

Inferência do modelo base para preparar o upscaling: [1000, 993, 987, 981, 975, 909, 725, 0.03].
Upscaling: [1000, 909, 725, 421, 0].

Exibir código de exemplo

import torch
from diffusers import LTXConditionPipeline, LTXLatentUpsamplePipeline
from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition
from diffusers.utils import export_to_video, load_video

pipeline = LTXConditionPipeline.from_pretrained("Lightricks/LTX-Video-0.9.7-distilled", dtype=torch.bfloat16)
pipe_upsample = LTXLatentUpsamplePipeline.from_pretrained("Lightricks/ltxv-spatial-upscaler-0.9.7", vae=pipeline.vae, dtype=torch.bfloat16)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"
pipe_upsample.to("cuda")
pipeline.vae.enable_tiling()

def round_to_nearest_resolution_acceptable_by_vae(height, width):
    height = height - (height % pipeline.vae_spatial_compression_ratio)
    width = width - (width % pipeline.vae_spatial_compression_ratio)
    return height, width

prompt = """
artistic anatomical 3d render, utlra quality, human half full male body with transparent 
skin revealing structure instead of organs, muscular, intricate creative patterns, 
monochromatic with backlighting, lightning mesh, scientific concept art, blending biology 
with botany, surreal and ethereal quality, unreal engine 5, ray tracing, ultra realistic, 
16K UHD, rich details. camera zooms out in a rotating fashion
"""
negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"
expected_height, expected_width = 768, 1152
downscale_factor = 2 / 3
num_frames = 161

# 1. Generate video at smaller resolution
downscaled_height, downscaled_width = int(expected_height * downscale_factor), int(expected_width * downscale_factor)
downscaled_height, downscaled_width = round_to_nearest_resolution_acceptable_by_vae(downscaled_height, downscaled_width)
latents = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=downscaled_width,
    height=downscaled_height,
    num_frames=num_frames,
    timesteps=[1000, 993, 987, 981, 975, 909, 725, 0.03],
    decode_timestep=0.05,
    decode_noise_scale=0.025,
    image_cond_noise_scale=0.0,
    guidance_scale=1.0,
    guidance_rescale=0.7,
    generator=torch.Generator().manual_seed(0),
    output_type="latent",
).frames

# 2. Upscale generated video using latent upsampler with fewer inference steps
# The available latent upsampler upscales the height/width by 2x
upscaled_height, upscaled_width = downscaled_height * 2, downscaled_width * 2
upscaled_latents = pipe_upsample(
    latents=latents,
    adain_factor=1.0,
    output_type="latent"
).frames

# 3. Denoise the upscaled video with few steps to improve texture (optional, but recommended)
video = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=upscaled_width,
    height=upscaled_height,
    num_frames=num_frames,
    denoise_strength=0.999,  # Effectively, 4 inference steps out of 5
    timesteps=[1000, 909, 725, 421, 0],
    latents=upscaled_latents,
    decode_timestep=0.05,
    decode_noise_scale=0.025,
    image_cond_noise_scale=0.0,
    guidance_scale=1.0,
    guidance_rescale=0.7,
    generator=torch.Generator().manual_seed(0),
    output_type="pil",
).frames[0]

# 4. Downscale the video to the expected resolution
video = [frame.resize((expected_width, expected_height)) for frame in video]

export_to_video(video, "output.mp4", fps=24)

O modelo destilado LTX-Video 0.9.8 é semelhante à variante 0.9.7. Ele é destilado em relação ao guidance e ao timestep, e um código de inferência semelhante ao mostrado acima pode ser utilizado. Uma melhoria desta versão é o suporte à geração de vídeos muito longos. Além disso, ele suporta o uso de tone mapping para melhorar a qualidade do vídeo gerado, por meio do parâmetro tone_map_compression_ratio. O valor padrão de 0.6 é recomendado.

Exibir código de exemplo

import torch
from diffusers import LTXConditionPipeline, LTXLatentUpsamplePipeline
from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition
from diffusers.models.latent_upscaler import LTXLatentUpsamplerModel
from diffusers.utils import export_to_video, load_video

pipeline = LTXConditionPipeline.from_pretrained("Lightricks/LTX-Video-0.9.8-13B-distilled", dtype=torch.bfloat16)
# TODO: Update the checkpoint here once updated in LTX org
upsampler = LTXLatentUpsamplerModel.from_pretrained("a-r-r-o-w/LTX-0.9.8-Latent-Upsampler", dtype=torch.bfloat16)
pipe_upsample = LTXLatentUpsamplePipeline(vae=pipeline.vae, latent_upsampler=upsampler).to(torch.bfloat16)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"
pipe_upsample.to("cuda")
pipeline.vae.enable_tiling()

def round_to_nearest_resolution_acceptable_by_vae(height, width):
    height = height - (height % pipeline.vae_spatial_compression_ratio)
    width = width - (width % pipeline.vae_spatial_compression_ratio)
    return height, width

prompt = """The camera pans over a snow-covered mountain range, revealing a vast expanse of snow-capped peaks and valleys.The mountains are covered in a thick layer of snow, with some areas appearing almost white while others have a slightly darker, almost grayish hue. The peaks are jagged and irregular, with some rising sharply into the sky while others are more rounded. The valleys are deep and narrow, with steep slopes that are also covered in snow. The trees in the foreground are mostly bare, with only a few leaves remaining on their branches. The sky is overcast, with thick clouds obscuring the sun. The overall impression is one of peace and tranquility, with the snow-covered mountains standing as a testament to the power and beauty of nature."""
# prompt = """A woman walks away from a white Jeep parked on a city street at night, then ascends a staircase and knocks on a door. The woman, wearing a dark jacket and jeans, walks away from the Jeep parked on the left side of the street, her back to the camera; she walks at a steady pace, her arms swinging slightly by her sides; the street is dimly lit, with streetlights casting pools of light on the wet pavement; a man in a dark jacket and jeans walks past the Jeep in the opposite direction; the camera follows the woman from behind as she walks up a set of stairs towards a building with a green door; she reaches the top of the stairs and turns left, continuing to walk towards the building; she reaches the door and knocks on it with her right hand; the camera remains stationary, focused on the doorway; the scene is captured in real-life footage."""
negative_prompt = "bright colors, symbols, graffiti, watermarks, worst quality, inconsistent motion, blurry, jittery, distorted"
expected_height, expected_width = 480, 832
downscale_factor = 2 / 3
# num_frames = 161
num_frames = 361

# 1. Generate video at smaller resolution
downscaled_height, downscaled_width = int(expected_height * downscale_factor), int(expected_width * downscale_factor)
downscaled_height, downscaled_width = round_to_nearest_resolution_acceptable_by_vae(downscaled_height, downscaled_width)
latents = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=downscaled_width,
    height=downscaled_height,
    num_frames=num_frames,
    timesteps=[1000, 993, 987, 981, 975, 909, 725, 0.03],
    decode_timestep=0.05,
    decode_noise_scale=0.025,
    image_cond_noise_scale=0.0,
    guidance_scale=1.0,
    guidance_rescale=0.7,
    generator=torch.Generator().manual_seed(0),
    output_type="latent",
).frames

# 2. Upscale generated video using latent upsampler with fewer inference steps
# The available latent upsampler upscales the height/width by 2x
upscaled_height, upscaled_width = downscaled_height * 2, downscaled_width * 2
upscaled_latents = pipe_upsample(
    latents=latents,
    adain_factor=1.0,
    tone_map_compression_ratio=0.6,
    output_type="latent"
).frames

# 3. Denoise the upscaled video with few steps to improve texture (optional, but recommended)
video = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    width=upscaled_width,
    height=upscaled_height,
    num_frames=num_frames,
    denoise_strength=0.999,  # Effectively, 4 inference steps out of 5
    timesteps=[1000, 909, 725, 421, 0],
    latents=upscaled_latents,
    decode_timestep=0.05,
    decode_noise_scale=0.025,
    image_cond_noise_scale=0.0,
    guidance_scale=1.0,
    guidance_rescale=0.7,
    generator=torch.Generator().manual_seed(0),
    output_type="pil",
).frames[0]

# 4. Downscale the video to the expected resolution
video = [frame.resize((expected_width, expected_height)) for frame in video]

export_to_video(video, "output.mp4", fps=24)

O LTX-Video suporta LoRAs com load_lora_weights().

Exibir código de exemplo

import torch
from diffusers import LTXConditionPipeline
from diffusers.utils import export_to_video, load_image

pipeline = LTXConditionPipeline.from_pretrained(
    "Lightricks/LTX-Video-0.9.5", dtype=torch.bfloat16
)

pipeline.load_lora_weights("Lightricks/LTX-Video-Cakeify-LoRA", adapter_name="cakeify")
pipeline.set_adapters("cakeify")

# use "CAKEIFY" to trigger the LoRA
prompt = "CAKEIFY a person using a knife to cut a cake shaped like a Pikachu plushie"
image = load_image("https://huggingface.co/Lightricks/LTX-Video-Cakeify-LoRA/resolve/main/assets/images/pikachu.png")

video = pipeline(
    prompt=prompt,
    image=image,
    width=576,
    height=576,
    num_frames=161,
    decode_timestep=0.03,
    decode_noise_scale=0.025,
    num_inference_steps=50,
).frames[0]
export_to_video(video, "output.mp4", fps=26)

O LTX-Video suporta o carregamento a partir de arquivos únicos, como checkpoints GGUF, com loaders.FromOriginalModelMixin.from_single_file() ou loaders.FromSingleFileMixin.from_single_file().

Exibir código de exemplo

import torch
from diffusers.utils import export_to_video
from diffusers import LTXPipeline, AutoModel, GGUFQuantizationConfig

transformer = AutoModel.from_single_file(
    "https://huggingface.co/city96/LTX-Video-gguf/blob/main/ltx-video-2b-v0.9-Q3_K_S.gguf"
    quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
    dtype=torch.bfloat16
)
pipeline = LTXPipeline.from_pretrained(
    "Lightricks/LTX-Video",
    transformer=transformer,
    dtype=torch.bfloat16
)

LTXI2VLongMultiPromptPipeline[[diffusers.LTXI2VLongMultiPromptPipeline]]

diffusers.LTXI2VLongMultiPromptPipeline[[diffusers.LTXI2VLongMultiPromptPipeline]]

diffusers.LTXI2VLongMultiPromptPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTXVideo, text_encoder: T5EncoderModel, tokenizer: T5TokenizerFast, transformer: LTXVideoTransformer3DModel)

Fonte

Parâmetros:

transformer (LTXVideoTransformer3DModel) : Arquitetura de Transformer condicional para desruidar os latentes de vídeo codificados.

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

vae (AutoencoderKLLTXVideo) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

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

tokenizer (T5TokenizerFast) : Tokenizer da classe T5TokenizerFast.

Pipeline multi-prompt de I2V (imagem para vídeo) de longa duração com paridade com o ComfyUI.

Principais recursos:

Amostragem por janela deslizante temporal apenas (sem divisão espacial em H/W); fusão autoregressiva entre janelas.
Segmentação multi-prompt por janela com transições suaves nas cabeças das janelas.
Condição rígida do primeiro quadro por meio de máscara por token para I2V.
Controle de VRAM por janelamento temporal e decodificação em blocos do VAE.

Referência: https://github.com/Lightricks/LTX-Video

call[[diffusers.LTXI2VLongMultiPromptPipeline.call]]

__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, prompt_segments: list[dict[str, Any]] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: float = 25, guidance_scale: float = 1.0, guidance_rescale: float = 0.0, num_inference_steps: int | None = 8, sigmas: list[float, torch.Tensor] | None = None, generator: torch.Generator | list[torch.Generator] | None = None, seed: int | None = 0, cond_image: 'PIL.Image.Image' | torch.Tensor | None = None, cond_strength: float = 0.5, latents: torch.Tensor | None = None, temporal_tile_size: int = 80, temporal_overlap: int = 24, temporal_overlap_cond_strength: float = 0.5, adain_factor: float = 0.25, guidance_latents: torch.Tensor | None = None, guiding_strength: float = 1.0, negative_index_latents: torch.Tensor | None = None, negative_index_strength: float = 1.0, skip_steps_sigma_threshold: float | None = 1, decode_timestep: float | None = 0.05, decode_noise_scale: float | None = 0.025, decode_horizontal_tiles: int = 4, decode_vertical_tiles: int = 4, decode_overlap: int = 3, output_type: str | None = 'latent', return_dict: bool = True, attention_kwargs: dict[str, Any] | None = None, callback_on_step_end: Callable[[int, int], None] | None = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 128)

Fonte

Parâmetros:

prompt (str ou list[str], opcional) : Prompt(s) de texto positivo(s) por janela. Se uma única string contiver '|', as partes serão divididas pelas barras.

negative_prompt (str ou list[str], opcional) : Prompt(s) negativo(s) para suprimir conteúdo indesejado.

prompt_segments (list[dict], opcional) : Mapeamento de segmentos com {"start_window", "end_window", "text"} para substituir prompts por janela.

height (int, padrão 512) : Altura da imagem de saída em pixels; deve ser divisível por 32.

width (int, padrão 704) : Largura da imagem de saída em pixels; deve ser divisível por 32.

num_frames (int, padrão 161) : Número de quadros de saída (no espaço de pixels decodificados).

frame_rate (float, padrão 25) : Quadros por segundo; usado para normalizar as coordenadas temporais em video_coords.

guidance_scale (float, padrão 1.0) : escala de CFG; valores > 1 ativam a orientação sem classificador.

guidance_rescale (float, padrão 0.0) : Resscalamento opcional para mitigar a superexposição sob CFG (veja rescale_noise_cfg).

num_inference_steps (int, opcional, padrão 8) : Etapas de desruidamento por janela. Ignorado se sigmas for fornecido.

sigmas (list[float] ou torch.Tensor, opcional) : Agenda explícita de sigma por janela; se definida, substitui num_inference_steps.

generator (torch.Generator ou list[torch.Generator], opcional) : Controla a estocasticidade; listas são aceitas, mas apenas o primeiro elemento é utilizado (batch=1).

seed (int, opcional, padrão 0) : Se fornecido, define a semente do gerador compartilhado para latentes globais e deriva um gerador local de janela com seed + w_start por janela temporal.

cond_image (PIL.Image.Image ou torch.Tensor, opcional) : Imagem de condicionamento; fixa o quadro 0 por meio de uma máscara por token quando cond_strength > 0.

cond_strength (float, padrão 0.5) : Força do condicionamento rígido do primeiro quadro (cond_mask menor ⇒ preservação mais forte).

latents (torch.Tensor, opcional) : Latentes iniciais [B, C_lat, F_lat, H_lat, W_lat]; se None, amostrados com randn_tensor.

temporal_tile_size (int, padrão 80) : Tamanho da janela temporal (em frames decodificados); escalado internamente pela compressão temporal do VAE.

temporal_overlap (int, padrão 24) : Sobreposição entre janelas consecutivas (em frames decodificados); escalada internamente pela compressão.

temporal_overlap_cond_strength (float, padrão 0.5) : Força para injetar os latentes da cauda da janela anterior no início da nova janela.

adain_factor (float, padrão 0.25) : Força da normalização AdaIN para consistência entre janelas (0 desativa).

guidance_latents (torch.Tensor, opcional) : Latentes de referência injetados na cabeça da janela; o comprimento é reduzido pela sobreposição para as janelas subsequentes.

guiding_strength (float, padrão 1.0) : Força de injeção para guidance_latents.

negative_index_latents (torch.Tensor, opcional) : Um latente de quadro único adicionado no início da janela para a semântica de "índice negativo".

negative_index_strength (float, padrão 1.0) : Força de injeção para negative_index_latents.

skip_steps_sigma_threshold (float, opcional, padrão 1) : Pula etapas cujo sigma excede este limite.

decode_timestep (float, opcional, padrão 0.05) : Timestep no momento da decodificação (se o VAE suportar timestep_conditioning).

decode_noise_scale (float, opcional, padrão 0.025) : Escala de mistura de ruído no momento da decodificação (se o VAE suportar timestep_conditioning).

decode_horizontal_tiles (int, padrão 4) : Número de tiles horizontais durante a decodificação do VAE.

decode_vertical_tiles (int, padrão 4) : Número de tiles verticais durante a decodificação do VAE.

decode_overlap (int, padrão 3) : Sobreposição (em pixels latentes) entre as tiles durante a decodificação do VAE.

output_type (str, opcional, padrão "latent") : O formato de saída do vídeo gerado. Escolha entre "latent", "pt", "np" ou "pil". Se "latent", retorna os latentes sem decodificação.

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

attention_kwargs (dict, opcional) : Parâmetros de atenção extras encaminhados ao transformer.

callback_on_step_end (PipelineCallback ou MultiPipelineCallbacks, opcional) : Gancho de callback por etapa.

callback_on_step_end_tensor_inputs (list[str], padrão ["latents"]) : Chaves de locals() para passar ao callback.

max_sequence_length (int, padrão 128) : Comprimento máximo do Tokenizer para a codificação do prompt.

Retorna: ~pipelines.ltx.LTXPipelineOutput ou tuple

Se return_dict for True, ~pipelines.ltx.LTXPipelineOutput é retornado; caso contrário, uma tuple é retornada, em que o primeiro elemento é uma lista com os quadros gerados. O formato de saída depende de output_type:

"latent"/"pt": torch.Tensor [B, C, F, H, W]; "latent" está no espaço latente normalizado, "pt" está no espaço de saída do VAE.
"np": pós-processado np.ndarray.
"pil": list[PIL.Image.Image] lista de imagens PIL.

Gere uma sequência de imagem para vídeo por meio de janelas deslizantes temporais e agendamento de múltiplos prompts.

Exemplos:

>>> import torch
>>> from diffusers import LTXEulerAncestralRFScheduler, LTXI2VLongMultiPromptPipeline

>>> pipe = LTXI2VLongMultiPromptPipeline.from_pretrained("LTX-Video-0.9.8-13B-distilled")
>>> # For ComfyUI parity, swap in the RF scheduler (keeps the original config).
>>> pipe.scheduler = LTXEulerAncestralRFScheduler.from_config(pipe.scheduler.config)
>>> pipe = pipe.to("cuda").to(dtype=torch.bfloat16)
>>> # Example A: get decoded frames (PIL)
>>> out = pipe(
...     prompt="a chimpanzee walks | a chimpanzee eats",
...     num_frames=161,
...     height=512,
...     width=704,
...     temporal_tile_size=80,
...     temporal_overlap=24,
...     output_type="pil",
...     return_dict=True,
... )
>>> frames = out.frames[0]  # list of PIL.Image.Image
>>> # Example B: get latent video and decode later (saves VRAM during sampling)
>>> out_latent = pipe(prompt="a chimpanzee walking", output_type="latent", return_dict=True).frames
>>> frames = pipe.vae_decode_tiled(out_latent, output_type="pil")[0]

Formas: tamanhos latentes (quando gerados automaticamente):

F_lat = (num_frames - 1) // vae_temporal_compression_ratio + 1
H_lat = height // vae_spatial_compression_ratio
W_lat = width // vae_spatial_compression_ratio

Observações:

Seeding: quando seed é fornecido, cada janela temporal usa um gerador local semeado com seed + w_start, enquanto o gerador compartilhado é semeado uma vez para os latentes globais se nenhum gerador for passado; caso contrário, o gerador passado é reutilizado.
CFG: noise_pred = uncond + w * (text - uncond) unificado com guidance_rescale opcional.
Memória: o desruidamento realiza previsões de quadro completo (sem divisão espacial); a decodificação pode ser dividida em blocos para evitar OOM.

encode_prompt[[diffusers.LTXI2VLongMultiPromptPipeline.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: torch.Tensor | None = None, negative_prompt_embeds: torch.Tensor | None = None, prompt_attention_mask: torch.Tensor | None = None, negative_prompt_attention_mask: torch.Tensor | None = None, max_sequence_length: int = 128, device: torch.device | None = None, dtype: torch.dtype | None = 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.

prepare_latents[[diffusers.LTXI2VLongMultiPromptPipeline.prepare_latents]]

prepare_latents(batch_size: int, num_channels_latents: int, height: int, width: int, num_frames: int, device: torch.device, generator: torch.Generator | None, dtype: torch.dtype = torch.float32, latents: torch.Tensor | None = None, cond_latents: torch.Tensor | None = None, cond_strength: float = 0.0, negative_index_latents: torch.Tensor | None = None)

Fonte

Retorna:

latents, negative_index_latents, latent_num_frames, latent_height, latent_width

Prepare os latentes base e, opcionalmente, injete os latentes de condicionamento do primeiro quadro.

vae_decode_tiled[[diffusers.LTXI2VLongMultiPromptPipeline.vae_decode_tiled]]

vae_decode_tiled(latents: torch.Tensor, decode_timestep: float | None = None, decode_noise_scale: float | None = None, horizontal_tiles: int = 4, vertical_tiles: int = 4, overlap: int = 3, last_frame_fix: bool = True, generator: torch.Generator | None = None, output_type: str = 'pt', auto_denormalize: bool = True, compute_dtype: torch.dtype = torch.float32, enable_vae_tiling: bool = False)

Fonte

Parâmetros:

latents : [B, C_latent, F_latent, H_latent, W_latent]

decode_timestep : passo de tempo de decodificação opcional (efetivo apenas se o VAE suportar timestep_conditioning)

decode_noise_scale : Interpolação de ruído de decodificação opcional (efetiva apenas se o VAE suportar timestep_conditioning)

horizontal_tiles, vertical_tiles : Número de tiles horizontal/verticalmente (>= 1)

overlap : Sobreposição no espaço latente (em pixels latentes, >= 0)

last_frame_fix : Se deve ativar a correção "repetir o último quadro"

generator : Gerador aleatório (usado para o ruído de decode_noise_scale)

output_type : "latent" | "pt" | "np" | "pil" - "latent": retorna os latentes sem alterações (útil para processamento posterior) - "pt": retorna o tensor no espaço de saída do VAE - "np"/"pil": saídas pós-processadas via VideoProcessor.postprocess_video

auto_denormalize : Se True, aplica a desnormalização do LTX aos latents internamente (recomendado)

compute_dtype : Precisão usada durante a fusão de tiles (padrão float32; reduz significativamente o desfoque nas emendas)

enable_vae_tiling : Se True, delega o tiling para o tiled_decode embutido do VAE (define vae.use_tiling).

Retorna: - If output_type="latent"

retorna a entrada latents inalterada

Se output_type="pt": retorna [B, C, F, H, W] (valores aproximadamente em [-1, 1])
Se output_type="np"/"pil": retorna as saídas pós-processadas via postprocess_video

Decodificação espacial em mosaicos baseada em VAE (paridade com ComfyUI) implementada no estilo Diffusers.

Faça a transição linear e a mistura das tiles sobrepostas para evitar emendas.
Opcional last_frame_fix: duplica o último frame latente antes da decodificação e, em seguida, remove time_scale_factor frames no final.
Suporta a injeção de timestep_conditioning e decode_noise_scale.
Por padrão, os "latentes normalizados" (a saída do desruido) são desnormalizados internamente (auto_denormalize=True).
A fusão de tiles é calculada em compute_dtype (float32 por padrão) para reduzir o desfoque e as alterações de cor.

LTXPipeline[[diffusers.LTXPipeline]]

diffusers.LTXPipeline[[diffusers.LTXPipeline]]

diffusers.LTXPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTXVideo, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: LTXVideoTransformer3DModel)

Fonte

Parâmetros:

transformer (LTXVideoTransformer3DModel) : Arquitetura de Transformer condicional para desruidar os latentes de vídeo codificados.

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

vae (AutoencoderKLLTXVideo) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

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

tokenizer (CLIPTokenizer) : Tokenizer da classe CLIPTokenizer.

tokenizer (T5TokenizerFast) : Segundo Tokenizer da classe T5TokenizerFast.

Pipeline para geração de texto para vídeo.

Referência: https://github.com/Lightricks/LTX-Video

call[[diffusers.LTXPipeline.call]]

__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: int = 25, num_inference_steps: int = 50, timesteps: list[int] = None, guidance_scale: float = 3, guidance_rescale: float = 0.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, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 128)

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, é necessário passar prompt_embeds em vez disso.

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 está usando orientação (guidance_scale < 1).

height (int, padrão 512) : A altura em pixels da imagem gerada. Por padrão, é definido como 480 para os melhores resultados.

width (int, padrão 704) : A largura em pixels da imagem gerada. Por padrão, é definido como 848 para os melhores resultados.

num_frames (int, padrão 161) : O número de quadros de vídeo a serem gerados

frame_rate (int, padrão 25) : Taxa de quadros-alvo do vídeo gerado.

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

timesteps (list[int], opcional) : Passos de tempo personalizados para usar no processo de remoção de ruído com agendadores que suportam um argumento timesteps em seu método set_timesteps. Se não definido, o comportamento padrão quando num_inference_steps é passado será usado. Deve estar em ordem decrescente.

guidance_scale (float, padrão 3 ) : 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.

guidance_rescale (float, opcional, padrão 0.0) : Fator de rescalonamento de orientação proposto por Common Diffusion Noise Schedules and Sample Steps are Flawed guidance_scale é definido como φ na equação 16. de Common Diffusion Noise Schedules and Sample Steps are Flawed. O fator de rescalonamento de orientação deve corrigir a sobreexposição ao usar SNR terminal zero.

num_videos_per_prompt (int, opcional, padrão 1) : O número de vídeos a serem gerados por prompt.

generator (torch.Generator ou list[torch.Generator], opcional) : Um ou uma lista de geradores do torch 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 será gerado por amostragem usando o generator aleatório fornecido.

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.

prompt_attention_mask (torch.Tensor, opcional) : Máscara de atenção pré-gerada para embeddings de texto.

negative_prompt_embeds (torch.FloatTensor, opcional) : Embeddings de texto negativo pré-gerados. Para o PixArt-Sigma, este prompt negativo deve ser "". Se não for fornecido, negative_prompt_embeds será gerado a partir do argumento de entrada negative_prompt.

negative_prompt_attention_mask (torch.FloatTensor, opcional) : Máscara de atenção pré-gerada para embeddings de texto negativos.

decode_timestep (float, padrão 0.0) : O timestep em que o vídeo gerado é decodificado.

decode_noise_scale (float, padrão None) : O fator de interpolação entre o ruído aleatório e os latentes desruídos no passo de decodificação.

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

return_dict (bool, opcional, padrão True) : Se deve ou não retornar um ~pipelines.ltx.LTXPipelineOutput 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, opcional) : Uma função que é chamada no final de cada etapa de desruidamento durante a inferência. A função é chamada 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 é 128 ) : Comprimento máximo da sequência a ser usado com o prompt.

Retorna: ~pipelines.ltx.LTXPipelineOutput ou tuple

Se return_dict for True, ~pipelines.ltx.LTXPipelineOutput é retornado; caso contrário, uma tuple é retornada, onde o primeiro elemento é uma lista com as imagens geradas.

Função invocada ao chamar o pipeline para geração.

Exemplos:

>>> import torch
>>> from diffusers import LTXPipeline
>>> from diffusers.utils import export_to_video

>>> pipe = LTXPipeline.from_pretrained("Lightricks/LTX-Video", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> prompt = "A woman with long brown hair and light skin smiles at another woman with long blonde hair. The woman with brown hair wears a black jacket and has a small, barely noticeable mole on her right cheek. The camera angle is a close-up, focused on the woman with brown hair's face. The lighting is warm and natural, likely from the setting sun, casting a soft glow on the scene. The scene appears to be real-life footage"
>>> negative_prompt = "worst quality, inconsistent motion, blurry, jittery, distorted"

>>> video = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     width=704,
...     height=480,
...     num_frames=161,
...     num_inference_steps=50,
... ).frames[0]
>>> export_to_video(video, "output.mp4", fps=24)

encode_prompt[[diffusers.LTXPipeline.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, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 128, 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.

LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

diffusers.LTXImageToVideoPipeline[[diffusers.LTXImageToVideoPipeline]]

diffusers.LTXImageToVideoPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLLTXVideo, text_encoder: T5EncoderModel, tokenizer: T5Tokenizer, transformer: LTXVideoTransformer3DModel)

Fonte

Parâmetros:

transformer (LTXVideoTransformer3DModel) : Arquitetura de Transformer condicional para desruidar os latentes de vídeo codificados.

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

vae (AutoencoderKLLTXVideo) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar imagens para e a partir de representações latentes.

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

tokenizer (CLIPTokenizer) : Tokenizer da classe CLIPTokenizer.

tokenizer (T5TokenizerFast) : Segundo Tokenizer da classe T5TokenizerFast.

Pipeline para geração de vídeo a partir de imagem.

Referência: https://github.com/Lightricks/LTX-Video

call[[diffusers.LTXImageToVideoPipeline.call]]

__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] | None = None, height: int = 512, width: int = 704, num_frames: int = 161, frame_rate: int = 25, num_inference_steps: int = 50, timesteps: list[int] = None, guidance_scale: float = 3, guidance_rescale: float = 0.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, prompt_attention_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_attention_mask: typing.Optional[torch.Tensor] = None, decode_timestep: float | list[float] = 0.0, decode_noise_scale: float | list[float] | None = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 128)

Fonte

Parâmetros:

image (PipelineImageInput) : A imagem de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou um torch.Tensor.