Skip to content

vllm_omni.diffusion.models.ltx2.pipeline_ltx2_latent_upsample

logger module-attribute 

logger = init_logger(__name__)

LTX2LatentUpsamplePipeline

Bases: Module

device instance-attribute 

device = get_local_device()

latent_upsampler instance-attribute 

latent_upsampler = latent_upsampler

vae instance-attribute 

vae = vae

vae_spatial_compression_ratio instance-attribute 

vae_spatial_compression_ratio = (
    spatial_compression_ratio
    if getattr(self, "vae", None) is not None
    else 32
)

vae_temporal_compression_ratio instance-attribute 

vae_temporal_compression_ratio = (
    temporal_compression_ratio
    if getattr(self, "vae", None) is not None
    else 8
)

video_processor instance-attribute 

video_processor = VideoProcessor(
    vae_scale_factor=vae_spatial_compression_ratio
)

adain_filter_latent 

adain_filter_latent(
    latents: Tensor,
    reference_latents: Tensor,
    factor: float = 1.0,
)

check_inputs 

check_inputs(
    video,
    height,
    width,
    latents,
    tone_map_compression_ratio,
)

forward 

forward(
    video: list[PipelineImageInput] | None = None,
    height: int = 512,
    width: int = 768,
    num_frames: int = 121,
    spatial_patch_size: int = 1,
    temporal_patch_size: int = 1,
    latents: Tensor | None = None,
    latents_normalized: bool = False,
    decode_timestep: float | list[float] = 0.0,
    decode_noise_scale: float | list[float] | None = None,
    adain_factor: float = 0.0,
    tone_map_compression_ratio: float = 0.0,
    generator: Generator | list[Generator] | None = None,
    output_type: str | None = "pil",
    return_dict: bool = True,
)

prepare_latents 

prepare_latents(
    video: Tensor | None = None,
    batch_size: int = 1,
    num_frames: int = 121,
    height: int = 512,
    width: int = 768,
    spatial_patch_size: int = 1,
    temporal_patch_size: int = 1,
    dtype: dtype | None = None,
    device: device | None = None,
    generator: Generator | None = None,
    latents: Tensor | None = None,
) -> Tensor

tone_map_latents 

tone_map_latents(
    latents: Tensor, compression: float
) -> Tensor