src/musubi_tuner/ltx_2/env.py

from __future__ import annotations

import os
from dataclasses import dataclass

from musubi_tuner.ltx_2.model.ltx2_custom_offloading_utils import (
    set_fp8_offload_keep_fp8,
    set_fp8_offload_restore_bf16,
    set_fp8_offload_restore_stochastic,
    set_fp8_offload_upcast,
)


@dataclass(frozen=True)
class LTX2Env:
    # Apply audio_lengths mask to audio loss.
    # recommended=True
    use_audio_length_mask: bool = True

    # Upcast FP8 Linear weights to compute dtype during forward for stability.
    # recommended=True
    fp8_upcast: bool = False

    # Add stochastic rounding during FP8 upcast (extra stability, more noise).
    # recommended=False
    fp8_upcast_stochastic: bool = False

    # Seed for stochastic FP8 upcast (only used if fp8_upcast_stochastic=True).
    # recommended=0
    fp8_upcast_seed: int = 0

    # Allow FP8 weights to be offloaded to CPU by upcasting to bf16.
    # recommended=True
    fp8_offload_upcast: bool = False

    # Keep FP8-offloaded weights in bf16 on GPU after restore (avoid FP8 round-trip).
    # recommended=True
    fp8_offload_restore_bf16: bool = False

    # Keep FP8 weights in FP8 on CPU (avoid bf16 upcast and GPU re-cast cost).
    # recommended=False
    fp8_offload_keep_fp8: bool = False

    # Allow FP8 CPU offload only when blockwise checkpointing is enabled.
    # recommended=False
    blockwise_fp8_offload_upcast: bool = True

    # Add stochastic noise before restoring FP8 weights (experimental).
    # recommended=False
    fp8_offload_restore_stochastic: bool = False

    # Keep attention weights on GPU during block swap (stability, higher VRAM).
    # recommended=True
    swap_keep_attn: bool = False

    # Keep cross-attn weights on GPU during swap (stability).
    # recommended=True
    swap_keep_cross_attn: bool = False

    # Keep audio-related weights on GPU during swap (stability).
    # recommended=True
    swap_keep_audio: bool = False

    # Force PyTorch attention for audio ctx + cross-attn in swapped blocks.
    # recommended=True
    attn_stability: bool = False

    # Force FP32 attention for audio ctx + cross-attn in swapped blocks.
    # recommended=False
    attn_stability_fp32: bool = False

    # Keep prompt-AdaLN modulation in float32 for consistency with the other
    # AdaLN stability fixes.
    # recommended=True
    prompt_adaln_fp32: bool = True

    # Combined safe swap attention preset (keep attn + PyTorch + FP32 retry).
    # recommended=True
    safe_swap_attn: bool = False

    # FP8 swap safety preset (strict sync + safe swap attn).
    # recommended=True
    fp8_swap_safe: bool = True

    # Ensure FP8 weights are on device after swap-in.
    # recommended=True
    swap_fp8_sync: bool = False

    # Strict CUDA sync after FP8 swap-in.
    # recommended=False
    swap_fp8_sync_strict: bool = True

    # Force PyTorch attention for swapped blocks.
    # recommended=False
    swap_force_pytorch_attn: bool = False

    # Retry attention in FP32 if non-finite detected.
    # recommended=True
    attn_fp32_retry: bool = False

    # Force PyTorch attention for audio context.
    # recommended=False
    force_pytorch_audio_ctx_attn: bool = False

    # Force FP32 for audio context attention.
    # recommended=False
    audio_ctx_attn_fp32: bool = False

    # Force PyTorch for cross-attn.
    # recommended=False
    force_pytorch_cross_attn: bool = False

    # Force FP32 for cross-attn.
    # recommended=False
    cross_attn_fp32: bool = False

    # Apply cross-attn forcing only in swapped blocks.
    # recommended=True
    cross_attn_swap_only: bool = True

    # Apply audio-ctx forcing only in swapped blocks.
    # recommended=True
    audio_ctx_attn_swap_only: bool = True

    # Async prefetch stream for swap (faster but can be unstable).
    # recommended=False
    swap_async_prefetch: bool = False

    # Pinned memory for swap/offload (faster, can destabilize).
    # recommended=False
    swap_pinned: bool = False

    # Swap RMSNorm/LayerNorm weights to CPU during block swap (VRAM saver).
    # recommended=False
    swap_norms: bool = False

    # Log sublayer-level non-finite diagnostics.
    # recommended=False
    nan_sublayer_diag: bool = False

    # Log block-level non-finite diagnostics.
    # recommended=False
    nan_block_diag: bool = False

    # Log NaN debug stats (latents/text/etc).
    # recommended=False
    nan_diag: bool = False

    # Trainer loss diagnostics (LTX2_LOSS_DIAG / LTX2_LOSS_DIAG_EVERY).
    # recommended=False
    loss_diag: bool = False

    # Frequency for loss diagnostics.
    # recommended=10
    loss_diag_every: int = 10

    # Swap/offloader diagnostics.
    # recommended=False
    swap_diag: bool = False

    # Offloader debug prints (LTX2_OFFLOADER_DEBUG).
    # recommended=False
    offloader_debug: bool = False

    # Extra debug flag used by hv_train_network (LTX2_DEBUG).
    # recommended=False
    debug: bool = False

    # Log V2A (video-to-audio) internal stats.
    # recommended=False
    v2a_diag: bool = False

    # Align audio latents to video duration during training.
    # recommended=False
    align_audio_latents_train: bool = False

    # Align audio latents to video duration during cache_latents.
    # recommended=False
    align_audio_latents_cache: bool = False

    # Use video_prompt_embeds as AV fallback when audio missing.
    # recommended=False
    av_use_video_prompt_embeds: bool = False

    # Use 5D video loss mask (broadcast-friendly).
    # recommended=False
    video_loss_mask_5d: bool = False

    # Align transformer outputs to proj_out device.
    # recommended=False
    align_output_device: bool = False

    # Skip steps on non-finite tensors instead of erroring.
    # recommended=False
    skip_nonfinite_steps: bool = True

    # Auto-set blocks_to_checkpoint when blockwise+swap are both enabled.
    # recommended=False
    auto_blocks_to_checkpoint: bool = False

    # Require gemma_root (no gemma_safetensors-only usage).
    # recommended=True
    require_gemma_root: bool = True

    # Skip no-op attention masks to enable Flash Attention on cross-attn.
    # recommended=False
    skip_noop_attn_mask: bool = False

    # Max FPS difference (after ceiling source FPS) below which resampling is skipped.
    # e.g. threshold=1: 23.976->ceil=24 vs 25, diff=1, skip. 30 vs 25, diff=5, resample.
    # recommended=1
    fps_resampling_threshold: int = 1

    # Number of blocks to prefetch ahead during block swap (1 = current behavior).
    # Higher values overlap more transfers with compute but use more VRAM.
    # recommended=1
    swap_prefetch_window: int = 1

    # Use pre-allocated pinned slab pool instead of lazy per-parameter _pinned_buffer_cache.
    # recommended=False
    swap_slab_pool: bool = False


DEFAULT_ENV = LTX2Env()


def _set_env_bool(key: str, enabled: bool) -> None:
    os.environ[key] = "1" if enabled else "0"


def get_ltx2_env() -> LTX2Env:
    return DEFAULT_ENV


def apply_ltx2_tweaks(args) -> None:
    t = DEFAULT_ENV

    args.use_audio_length_mask = t.use_audio_length_mask

    args.fp8_upcast = t.fp8_upcast
    args.fp8_upcast_stochastic = t.fp8_upcast_stochastic
    args.fp8_upcast_seed = int(t.fp8_upcast_seed)

    args.fp8_offload_upcast = t.fp8_offload_upcast
    args.fp8_offload_restore_bf16 = t.fp8_offload_restore_bf16
    args.fp8_offload_restore_stochastic = t.fp8_offload_restore_stochastic
    args.fp8_offload_keep_fp8 = t.fp8_offload_keep_fp8

    args.swap_keep_attn = t.swap_keep_attn
    args.swap_keep_cross_attn = t.swap_keep_cross_attn
    args.swap_keep_audio = t.swap_keep_audio
    args.attn_stability = t.attn_stability
    args.attn_stability_fp32 = t.attn_stability_fp32
    args.prompt_adaln_fp32 = t.prompt_adaln_fp32
    args.safe_swap_attn = t.safe_swap_attn
    args.fp8_swap_safe = t.fp8_swap_safe
    args.swap_fp8_sync = t.swap_fp8_sync
    args.swap_fp8_sync_strict = t.swap_fp8_sync_strict
    args.swap_force_pytorch_attn = t.swap_force_pytorch_attn
    args.attn_fp32_retry = t.attn_fp32_retry
    args.force_pytorch_audio_ctx_attn = t.force_pytorch_audio_ctx_attn
    args.audio_ctx_attn_fp32 = t.audio_ctx_attn_fp32
    args.force_pytorch_cross_attn = t.force_pytorch_cross_attn
    args.cross_attn_fp32 = t.cross_attn_fp32
    args.cross_attn_swap_only = t.cross_attn_swap_only
    args.audio_ctx_attn_swap_only = t.audio_ctx_attn_swap_only

    args.swap_async_prefetch = t.swap_async_prefetch
    args.swap_no_async_prefetch = not t.swap_async_prefetch
    cli_swap_pinned = bool(getattr(args, "use_pinned_memory_for_block_swap", False))
    effective_swap_pinned = bool(t.swap_pinned or cli_swap_pinned)
    args.swap_pinned = effective_swap_pinned
    args.swap_no_pinned = not effective_swap_pinned
    args.swap_norms = t.swap_norms

    args.nan_sublayer_diag = t.nan_sublayer_diag
    args.nan_block_diag = t.nan_block_diag

    args.align_audio_latents_train = t.align_audio_latents_train
    args.align_audio_latents_cache = t.align_audio_latents_cache
    args.av_use_video_prompt_embeds = t.av_use_video_prompt_embeds
    args.video_loss_mask_5d = t.video_loss_mask_5d
    args.align_output_device = t.align_output_device
    args.skip_nonfinite_steps = t.skip_nonfinite_steps
    args.auto_blocks_to_checkpoint = t.auto_blocks_to_checkpoint
    args.require_gemma_root = t.require_gemma_root
    args.skip_noop_attn_mask = t.skip_noop_attn_mask

    # Apply global FP8 offload behavior.
    fp8_offload_enabled = t.fp8_offload_upcast
    if (
        getattr(args, "blockwise_checkpointing", False)
        and t.blockwise_fp8_offload_upcast
    ):
        fp8_offload_enabled = True
    set_fp8_offload_upcast(fp8_offload_enabled)
    set_fp8_offload_restore_bf16(t.fp8_offload_restore_bf16)
    set_fp8_offload_restore_stochastic(t.fp8_offload_restore_stochastic)
    set_fp8_offload_keep_fp8(t.fp8_offload_keep_fp8)

    # Apply env vars consumed in transformer/offloading code.
    _set_env_bool("LTX2_SWAP_KEEP_ATTN", t.swap_keep_attn)
    _set_env_bool("LTX2_SWAP_KEEP_CROSS_ATTN", t.swap_keep_cross_attn)
    _set_env_bool("LTX2_SWAP_SKIP_AUDIO", t.swap_keep_audio)
    _set_env_bool("LTX2_SWAP_ASYNC_PREFETCH", t.swap_async_prefetch)
    _set_env_bool("LTX2_SWAP_PINNED", effective_swap_pinned)
    _set_env_bool("LTX2_SWAP_FP8_SYNC", t.swap_fp8_sync)
    _set_env_bool("LTX2_SWAP_FP8_SYNC_STRICT", t.swap_fp8_sync_strict)
    _set_env_bool("LTX2_FP8_OFFLOAD_KEEP_FP8", t.fp8_offload_keep_fp8)
    _set_env_bool("LTX2_SWAP_STRICT_SYNC", t.fp8_swap_safe)
    _set_env_bool("LTX2_SWAP_FORCE_PYTORCH_ATTN", t.swap_force_pytorch_attn)
    _set_env_bool(
        "LTX2_FORCE_PYTORCH_AUDIO_CTX_ATTN",
        t.force_pytorch_audio_ctx_attn or t.attn_stability or t.safe_swap_attn,
    )
    _set_env_bool(
        "LTX2_AUDIO_CTX_ATTN_FP32", t.audio_ctx_attn_fp32 or t.attn_stability_fp32
    )
    _set_env_bool(
        "LTX2_FORCE_PYTORCH_CROSS_ATTN",
        t.force_pytorch_cross_attn or t.attn_stability or t.safe_swap_attn,
    )
    _set_env_bool("LTX2_CROSS_ATTN_FP32", t.cross_attn_fp32 or t.attn_stability_fp32)
    _set_env_bool("LTX2_PROMPT_ADALN_FP32", t.prompt_adaln_fp32)
    _set_env_bool("LTX2_CROSS_ATTN_SWAP_ONLY", t.cross_attn_swap_only)
    _set_env_bool("LTX2_AUDIO_CTX_ATTN_SWAP_ONLY", t.audio_ctx_attn_swap_only)
    _set_env_bool(
        "LTX2_ATTN_FP32_RETRY", t.attn_fp32_retry or t.safe_swap_attn or t.fp8_swap_safe
    )
    _set_env_bool("LTX2_NAN_SUBLAYER_DIAG", t.nan_sublayer_diag)
    _set_env_bool("LTX2_NAN_BLOCK_DIAG", t.nan_block_diag)
    _set_env_bool("LTX2_NAN_DIAG", t.nan_diag)
    _set_env_bool("LTX2_LOSS_DIAG", t.loss_diag)
    os.environ["LTX2_LOSS_DIAG_EVERY"] = str(int(t.loss_diag_every))
    _set_env_bool("LTX2_SWAP_DIAG", t.swap_diag)
    _set_env_bool("LTX2_OFFLOADER_DEBUG", t.offloader_debug)
    _set_env_bool("LTX2_DEBUG", t.debug)
    _set_env_bool("LTX2_V2A_DIAG", t.v2a_diag)
    _set_env_bool("LTX2_ALIGN_OUTPUT_DEVICE", t.align_output_device)
    _set_env_bool("LTX2_REQUIRE_GEMMA_ROOT", t.require_gemma_root)
    _set_env_bool("LTX2_SKIP_NOOP_ATTN_MASK", t.skip_noop_attn_mask)
    os.environ["LTX2_SWAP_PREFETCH_WINDOW"] = str(int(t.swap_prefetch_window))
    _set_env_bool("LTX2_SWAP_SLAB_POOL", t.swap_slab_pool)