Verify that every directory declared by the training strategy exists under the data root.

Validate that the dataset file exists and has the correct format.

Validate that the dataset setup is correct.

Write audio tensor to container as stereo AAC.

Advance the denoising step by one.

Compute aligned generation dimensions and crop-back size. Args: width: Source video width (need not be aligned). height: Source vi

Allocate one ``uint8`` buffer for :func:`allocate_layout_views`. For pinned host buffers, prefer ``cudaHostRegister`` to dodge the caching all

Allocate a single ``uint8`` buffer and return per-key tensor views into it. All keys in *layout* live in one contiguous allocation; each returned

Scale Y and UV planes to the specified color range, in-place. Args: y: Luma plane in ``[0, 1]``. uv: Chroma planes centered at 0.

Apply query/key AdaLN modulation then cross-attention. ``x_normed`` is already RMS-normalized by ``post_sa_function``; this only applies the a

Apply HDR decompress to VAE decode output for HDR recovery. Args: decoded_video: Tensor from VAE decode in [0, 1], shape [B, C, F, H, W].

Fuse LoRAs into ``model_sd`` and place the results in ``destination_sd``. When ``destination_sd`` is provided, the fused tensors are placed direct

Return a :class:`LoraStateDictWithStrength` view of the pinned A/B factors. Lets non-block fusion consume the already-loaded disk-streaming Lo

Assign *tensor* to the parameter/buffer at *dotted_name* inside *root*. Unlike ``param.data = tensor``, this works even when the existing paramete

Load audio from a file, and construct the audio latent conforming to video output shape. Args: audio_encoder: Model used to encode audio t

Cached AUTOMATIC pick for the unmasked path. Cached so every ``AttentionOps`` in the process shares one instance.

Cached AUTOMATIC pick for the masked path. See :func:`automatic_attention`.

Blend-weight tile results and accumulate into the full token space. Premultiplied (blend-weighted) data is **added** to *output*, allo

Per-block buffer layout (shape + dtype for each param).

Build a ``ModuleOps`` that compiles transformer blocks with the given settings.

Build the downsampling path with residual blocks, attention, and downsampling layers.

Build the upsampling path with residual blocks, attention, and upsampling layers.

Generate a caption for the given video or image. Args: path: Path to the video/image file to caption. fps: Frames per

Caption videos and images using the provided captioning model. Args: input_path: Path to input video file or directory output_path

Clean a response from curly quotes and leading non-letter characters which Gemma tends to insert.

Hide sampling task when done.

Release all resources (buffers, readers, events).

Compile each transformer block via ``torch.compile`` with the given settings. The patched forward emits ``torch.compiler.cudagraph_mark_step_begin

Compress LDR [0, 1] → [0, 1] (no log curve, just clamp).

Encode audio files into latent representations. Supports standalone audio files (.wav, .mp3, etc.) and audio tracks extracted from video files

Preprocess audio mask files to latent-space binary masks. For each sample, loads the mask (a 1D waveform-like signal or a simple tensor), resa

Compute masked MSE loss for video and audio predictions. Returns [B,].

Compute Canny edge detection on a batch of images. Args: images: Batch of images tensor of shape [B, C, H, W] Returns: Binary

Compute scaled resolution buckets and validate the results.

Preprocess video mask files to latent-space binary masks. For each sample, loads the mask video/image, applies the same spatial resize/crop as

Build a factory with constant params (same guider for all sigma).

Convert a video file to GIF format.

Create a scene detector based on the specified type and parameters. Args: detector_type: Type of detector to create threshold: Det

Create a noised latent state from empty state, conditionings, and noiser. Creates an empty latent state, applies conditionings, and then adds nois

Decode all audio latent files in the directory recursively. Args: latents_dir: Directory containing audio latent files (.pt)

Decode a video latent tensor, yielding float chunks ``[f, h, w, c]`` in ``[0, 1]``. Subclasses (e.g. ``DistributedVideoDecoder``) may override

Decodes video from a file using presentation timestamps for time-based trimming. If a frame with no pts is encountered, falls back to :func:`decod

Decompress LogC3 [0, 1] → linear HDR [0, ∞).

Argument parser for single-stage text-to-audio pipelines (audio-only).

Detect and split scenes in a video using the specified parameters. Args: video_path: Path to input video. output_dir: Directory to

Read column names from a dataset file without loading all data.

Downsample a pixel-space mask video to flattened latent token weights.

Save an audio waveform as a 16-bit PCM ``.wav`` file at the source sampling rate. Reuses :func:`_write_audio` (the same muxing path used by :func:

Encode audio waveform into latent representation. Args: audio: Audio container with waveform tensor of shape (batch, channels, samples) an

Convert a linear EXR frame sequence to sRGB and encode to H.264 .mp4 via PyAV. Exposure is fixed at EV=0 (no gain). Each EXR frame is clamped to [

Enhance a text prompt for I2V generation using a reference image.

Enhance a text prompt for T2V generation.

r""" Encode video frames into normalized latent representation. Args: sample: Input video (B, C, F, H, W). F should be 1 +

r""" Decode latent representation into video frames. Args: sample: Latent tensor (B, 128, F', H', W'). timeste

Construct from torch.load output with Pydantic validation.

Return ``(delta_bf16 + dequantize(weight_fp8)).to(weight_fp8.dtype)``. CUDA with Triton uses stochastic rounding via the fused kernel; otherwise

Generate an enhanced prompt from a text encoder and a prompt.

Return the :class:`LoraProduct` for *param_prefix*, or ``None``.

Include reference scale factors in checkpoint metadata for inference pipelines.

Return the FP8 swap ``ModuleOps`` for layers whose ``.weight`` is ``F8_E4M3`` and which have a sibling ``.weight_scale`` tensor in the checkpoint.

Return the mean loss for each bucket hit on the last update. Wandb handles smoothing in the UI.

Return the temporal bounds `[inclusive start, exclusive end)` for every patch emitted by `patchify`. For audio this corresponds to ti

Compute res_2s Runge-Kutta coefficients for a given step size. Args: h: Step size in log-space = log(sigma / sigma_next) phi_

Compute SDE coefficients (alpha_ratio, sigma_down, sigma_up) for the step. Given either ``sigma_down`` or ``sigma_up``, returns the m

This matches the implementation in Denoising Diffusion Probabilistic Models: Create sinusoidal timestep embeddings. Args timesteps (t

Factory function to create the appropriate training strategy. The strategy is determined by the `name` field in the configuration. Args:

Get the number of frames in a video file. Tries three approaches in order: stream metadata, duration*fps estimate, full decode. The estimate m

Read video stream FPS.

Argument parser for the lip-dub pipeline. Frame count and frame rate are derived from the reference video at runtime (the frame count is silen

Load state dict from path or paths (for sharded model storage) and apply sd_ops

Load the Gemma text encoder in 8-bit precision using bitsandbytes. Only the Gemma LLM backbone is loaded here. The embeddings processor (feat

Load a video and yield preprocessed frames for HDR IC-LoRA conditioning. Decodes through the standard path and applies the LDR compression that

Batch HDR IC-LoRA inference: per-frame EXR + tonemapped ProRes .mov.