Flat token indices of *tile*'s generated tokens in the full sequence.

Generate audio position embeddings using ltx_core's native implementation. Args: num_time_steps: Number of audio time steps (T, no

Load audio from an audio or video file, optionally trimming to max_duration.

Apply *norm* in-place, using an optimised path for ``PixelNorm``.

Extract the caption text from a model response. Backend-agnostic: works for any model that follows the combined-caption prompt. Handles the fo

Resize [N, C, H, W] tensor to cover target dims (preserving aspect ratio) and center-crop.

Instantiate a Vocoder from a flat config dict. Args: cfg: Vocoder config dict (keys match Vocoder constructor args). apply_final_a

Total number of AdaLN parameters per block.

Apply the mapping to the given name.

Clear the conditioning from the latent state. This method removes extra tokens from the end of the latent. Therefore, conditioning it

Process videos and save latent representations. Under ``accelerate launch``, each process handles an interleaved shard of the dataset (ra

Generate a 1D trapezoidal blending mask with linear ramps. Args: length: Output length of the mask. ramp_left: Fade-in length

Create an initial latent state. If initial_latent is provided, it will be used to create the latent state.

Create a model on the meta device and apply module operations.

Decodes audio from a file, optionally seeking to a start time and limiting duration. Args: path: Path to the audio/video file containing a

Free GPU memory by running garbage collection and emptying CUDA cache. Args: log: If True, log memory stats after clearing

Yield ``(key, fused_tensor)`` for each weight modified by at least one LoRA. The fusion math is delegated to ``fuse_rule``. Output dtypes are

Return one contiguous CPU buffer for block *idx*.

Get current GPU memory usage in GB using nvidia-smi. Args: device: torch.device to get memory usage for Returns: Current GPU m

Get phi value with caching.

Load the audio VAE decoder. Args: checkpoint_path: Path to the safetensors checkpoint file device: Device to load model on

Load the audio VAE encoder (for preprocessing). Args: checkpoint_path: Path to the safetensors checkpoint file device: Device to l

Load the embeddings processor (feature extractor + video/audio connectors). Args: checkpoint_path: Path to the LTX-2 safetensors checkpoin

Loads an image from a path and preprocesses it for conditioning. Note: The image is resized to the nearest multiple of 2 for compatibility wi

Load the Gemma text encoder. Args: gemma_model_path: Path to Gemma model directory device: Device to load model on dtype:

Load the video VAE decoder (for inference/validation). Args: checkpoint_path: Path to the safetensors checkpoint file device: Devi

Load the video VAE encoder (for preprocessing). Args: checkpoint_path: Path to the safetensors checkpoint file device: Device to l

Load the vocoder (for audio waveform generation). Args: checkpoint_path: Path to the safetensors checkpoint file device: Device to

Return the state-dict key for *param_name* under block *block_idx*.

Full pipeline: feature extraction -> connectors -> final embeddings. Args: hidden_states: Raw Gemma hidden states (tuple of tensor

Read metadata from the first shard of a checkpoint.

Resize tensor preserving aspect ratio (filling target), then center crop to exact dimensions. Args: latent: Input tensor with shape (

Generate validation samples, save outputs, and optionally log to W&B. Args: work_items: Optional list of ``(sample_index, save_out

Sample timesteps for a specific batch tensor. Args: batch: Input tensor of shape (batch_size, seq_length, ...) Returns:

Save a video tensor to a file using PyAV, optionally with audio. Args: video_tensor: Video tensor of shape [C, F, H, W] or [F, C, H, W] in

Enqueue a read of block *idx* into the caller-carved *buffer*, return its handle.

Decode a latent tensor into video frames using tiled processing. Splits the latent tensor into tiles, decodes each tile individually,

Compute timesteps from a denoise mask and sigma value. Multiplies the denoise mask by sigma to produce timesteps for each position in the late

Preprocesses a video frame generator for conditioning. Args: frames: Generator of video frames as tensors of shape (1, H, W, C), dtype uin

Return a copy of this builder with the given module operations (e.g. quantization).

Replace the forward method of the fp8-cast Linear layers (per :data:`_FP8_CAST_LINEAR_SUFFIXES`) to forward with upcast and optional stoc

Rewrite sd_ops/module_ops/LoRAs for compiled blocks (params land under ``_orig_mod``).

Apply a precomputed right-pad permutation (from ``_compute_right_pad_order``) to features.

Apply text cross-attention, with optional AdaLN modulation. ``x_normed`` is the RMS-normalized self-attention output produced by ``pos

Expand scalar sigma to (n * B,) matching the repeated state.

Streamed-eligible tensors of a block: parameters then buffers. Block streaming swaps both params and checkpoint-backed buffers (e.g. Gemma4's

Create a noised latent state from a modality spec and tools.

Build a causal-padded buffer of shape ``[B, C, T+pad_size, H, W]``. Copies ``x`` into ``padded[:, :, pad_size:]`` and replicates the first rea

Compute per-element MSE loss for a single modality. Returns [B,].

Create conditioning items for video generation.

Create conditioning mask for first frame conditioning. Args: batch_size: Batch size sequence_length: Total sequence le

Create per-token timesteps based on conditioning mask. Args: conditioning_mask: Boolean mask of shape (batch_size, sequence_length

Encode audio waveform into latent representation. Args: audio_vae_encoder: Audio VAE encoder model from ltx-core audio_processor:

``model_sd_ops`` restricted to *allowed_model_keys* (post-rename keys). The loader skips keys filtered to None before reading them, so a restr

Clear conditioning tokens, unpatchify, and decode a modality (generated or frozen).

Look up the cached media for the first condition matching the given type.

Find a file matching a glob pattern and return its parent directory.

Converts latent indices into real-time seconds while honoring causal offsets and the configured hop length. Args:

Get the expected file path for a given data source.

Get the nearest resolution bucket for the given media tensor.

Core guided denoising — batches all guidance passes into one transformer call. Collects per-pass contexts first, then builds a single batched Moda

Compute the byte offset of each key in *layout* and the total aligned size. The size is at least one byte so empty layouts still produce a valid b

Load video paths from the specified data source, validating existence.

Per-rank CUDA device for early init (before Accelerator exists). DDP-safe: ``LOCAL_RANK`` is set by accelerate before trainer init; loading on bar

Log metrics to Weights & Biases.

Concatenate tensors along batch dim, or return None if all are None.

Build a Modality object from a LatentState, text context, and sigma.

Context manager that offloads optimizer state to CPU during validation. Opt-in via `acceleration.offload_optimizer_during_validation`. Frees V

Patchify latent data and extract metadata.

Blend denoised output with clean latent according to the denoise mask.

Prepare positional embeddings.

Prepare timestep embeddings.

Process a single modality: load latents, add noise, apply conditions, build Modality.

Process output for LTXV.

Repeat a ``LatentState`` *n* times along the batch dimension. ``(B, ...) → (n*B, ...)`` by tiling the whole tensor n times, so the ordering is

Rescale normalization: x * sqrt(target_dim / source_dim).

Resize and crop tensor to target size.

Return the custom instruction, or the image/video default for this input.

Run the ffmpeg binary bundled with ``imageio-ffmpeg`` (a dependency).

Run distributed validation by delegating to the ValidationRunner. Each rank generates its assigned subset of validation samples (round-robin b