Add files using upload-large-folder tool

Helios/_DEV/helios/modules/helios_kernels/__init__.py

@@ -0,0 +1,5 @@
+from .attention_dispatch import attn_varlen_func, create_navit_attention_masks
+from .fp32_rmsnorm import replace_rmsnorm_with_fp32
+from .tiled_linear import replace_linear_with_tiled_linear
+from .triton_norm import replace_all_norms_with_flash_norms
+from .triton_rope import replace_rope_with_flash_rope

Helios/_DEV/helios/modules/helios_kernels/attention_dispatch.py

@@ -0,0 +1,167 @@
+import torch
+from kernels import get_kernel
+
+
+try:
+    # FA3 Only support Hopper (SM90, H100/H800)
+    major, _ = torch.cuda.get_device_capability()
+    if major < 9:
+        raise RuntimeError("FA3 requires Hopper (SM90+), current GPU not supported")
+    flash_attn3 = get_kernel("kernels-community/flash-attn3")
+    flash_attn_func = flash_attn3.flash_attn_func
+    flash_attn_varlen_func = flash_attn3.flash_attn_varlen_func
+    print("Flash Attn 3 is installed!")
+except (ImportError, RuntimeError):
+    try:
+        flash_attn2 = get_kernel("kernels-community/flash-attn2")
+        flash_attn_func = flash_attn2.flash_attn_func
+        flash_attn_varlen_func = flash_attn2.flash_attn_varlen_func
+        print("Flash Attn 2 is installed!")
+    except ImportError:
+        print("Flash Attn 2 / 3 is not installed!")
+        flash_attn_varlen_func = None
+        flash_attn_func = None
+
+
+try:
+    # raise NotImplementedError
+    from sageattention import sageattn, sageattn_varlen
+
+    print("Sage Attn is installed!")
+except ImportError:
+    print("Sage Attn is not installed!")
+    sageattn_varlen = None
+    sageattn = None
+
+try:
+    # raise NotImplementedError
+    from xformers.ops import memory_efficient_attention as xformers_attn_func
+
+    print("Xformers is installed!")
+except ImportError:
+    print("Xformers is not installed!")
+    xformers_attn_func = None
+
+
+def create_navit_attention_masks(
+    batch_size: int,
+    original_context_length_list: list,
+    history_context_length: int,
+    encoder_hidden_states_seq_len: int,
+    device: torch.device,
+    restrict_self_attn: bool = False,
+    guidance_cross_attn: bool = False,
+):
+    # For navit_hidden_attention_mask
+    if restrict_self_attn:
+        cu_seqlens_q = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cu_seqlens_q.append(cu_seqlens_q[-1] + length)
+        cu_seqlens_q = torch.tensor(cu_seqlens_q, device=device, dtype=torch.int32)
+        max_seqlen_q = max(original_context_length_list)
+
+        cu_seqlens_kv = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cu_seqlens_kv.append(cu_seqlens_kv[-1] + length + history_context_length)
+        cu_seqlens_kv = torch.tensor(cu_seqlens_kv, device=device, dtype=torch.int32)
+        max_seqlen_kv = max(original_context_length_list) + history_context_length
+    else:
+        cu_seqlens_kv = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cu_seqlens_kv.append(cu_seqlens_kv[-1] + length + history_context_length)
+        cu_seqlens_kv = torch.tensor(cu_seqlens_kv, device=device, dtype=torch.int32)
+        max_seqlen_kv = max(original_context_length_list) + history_context_length
+        cu_seqlens_q = cu_seqlens_kv
+        max_seqlen_q = max_seqlen_kv
+    navit_hidden_attention_mask = cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv
+
+    # For navit_history_hidden_attention_mask
+    navit_history_hidden_attention_mask = None
+    if restrict_self_attn:
+        cu_seqlens_kv = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cu_seqlens_kv.append(cu_seqlens_kv[-1] + history_context_length)
+        cu_seqlens_kv = torch.tensor(cu_seqlens_kv, device=device, dtype=torch.int32)
+        max_seqlen_kv = history_context_length
+        cu_seqlens_q = cu_seqlens_kv
+        max_seqlen_q = max_seqlen_kv
+        navit_history_hidden_attention_mask = cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv
+
+    # For navit_encoder_attention_mask
+    if guidance_cross_attn:
+        cross_cu_seqlens_q = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cross_cu_seqlens_q.append(cross_cu_seqlens_q[-1] + length)
+        cross_cu_seqlens_q = torch.tensor(cross_cu_seqlens_q, device=device, dtype=torch.int32)
+        cross_max_seqlen_q = max(original_context_length_list)
+    else:
+        cross_cu_seqlens_q = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cross_cu_seqlens_q.append(cross_cu_seqlens_q[-1] + length + history_context_length)
+        cross_cu_seqlens_q = torch.tensor(cross_cu_seqlens_q, device=device, dtype=torch.int32)
+        cross_cu_seqlens_q[0] = 0
+        cross_max_seqlen_q = max(original_context_length_list) + history_context_length
+
+    cu_seqlens_kv = [0]
+    for _ in range(batch_size):
+        for length in original_context_length_list:
+            cu_seqlens_kv.append(cu_seqlens_kv[-1] + encoder_hidden_states_seq_len)
+    cu_seqlens_kv = torch.tensor(cu_seqlens_kv, device=device, dtype=torch.int32)
+    max_seqlen_kv = encoder_hidden_states_seq_len
+    navit_encoder_attention_mask = cross_cu_seqlens_q, cu_seqlens_kv, cross_max_seqlen_q, max_seqlen_kv
+
+    return navit_hidden_attention_mask, navit_encoder_attention_mask, navit_history_hidden_attention_mask
+
+
+@torch.compiler.disable
+def _flash_attn_wrapper(q, k, v):
+    return flash_attn_func(q, k, v)
+
+
+@torch.compiler.disable
+def _flash_attn_varlen_wrapper(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv):
+    return flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+
+
+def attn_varlen_func(q, k, v, attention_mask=None):
+    if attention_mask is None:
+        if flash_attn_func is not None:
+            x = _flash_attn_wrapper(q, k, v)
+            return x
+
+        if sageattn is not None:
+            x = sageattn(q, k, v, tensor_layout="NHD")
+            return x
+
+        if xformers_attn_func is not None:
+            x = xformers_attn_func(q, k, v)
+            return x
+
+        x = torch.nn.functional.scaled_dot_product_attention(
+            q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)
+        ).transpose(1, 2)
+        return x
+
+    B, L, H, C = q.shape
+
+    q = q.flatten(0, 1)
+    k = k.flatten(0, 1)
+    v = v.flatten(0, 1)
+
+    cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv = attention_mask
+    if flash_attn_varlen_func is not None:
+        x = _flash_attn_varlen_wrapper(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+    elif sageattn_varlen is not None:
+        x = sageattn_varlen(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+    else:
+        raise NotImplementedError("No Attn Installed!")
+
+    x = x.unflatten(0, (B, L))
+
+    return x

Helios/_DEV/helios/modules/helios_kernels/fp32_rmsnorm.py

@@ -0,0 +1,48 @@
+import torch
+import torch.nn as nn
+
+from diffusers.models.normalization import RMSNorm
+from diffusers.utils import is_torch_npu_available, is_torch_version
+
+
+# ------------------------------- replace funtion -------------------------------
+
+
+def replace_rmsnorm_with_fp32(model):
+    patched_count = 0
+    for name, module in model.named_modules():
+        if isinstance(module, (torch.nn.RMSNorm, RMSNorm)):
+
+            def new_forward(self, x):
+                return FP32RMSNorm.forward(self, x)
+
+            module.forward = new_forward.__get__(module, module.__class__)
+            patched_count += 1
+    print(f"Patched {patched_count} FP32_RMSNorm modules\n")
+    return model
+
+
+# ------------------------------- Tiled MLP -------------------------------
+
+
+class FP32RMSNorm(RMSNorm):
+    def forward(self, hidden_states):
+        if is_torch_npu_available():
+            raise ValueError("FP32RMSNorm is not available on NPU")
+
+        if not is_torch_version(">=", "2.4"):
+            raise ValueError("FP32RMSNorm is only available in PyTorch 2.4 or higher")
+
+        original_dtype = hidden_states.dtype
+        hidden_states = nn.functional.rms_norm(
+            hidden_states.float(),
+            normalized_shape=(hidden_states.shape[-1],),
+            weight=self.weight.float(),
+            eps=self.eps,
+        )
+
+        bias = getattr(self, "bias", None)
+        if bias is not None:
+            hidden_states = hidden_states + bias.float()
+
+        return hidden_states.to(original_dtype)

Helios/_DEV/helios/modules/helios_kernels/tiled_linear.py

@@ -0,0 +1,399 @@
+import functools
+import math
+from typing import Callable, List, Optional
+
+import torch
+import torch.nn as nn
+
+from diffusers.models.activations import GEGLU, GELU, ApproximateGELU, LinearActivation, SwiGLU
+from diffusers.utils import deprecate
+
+
+# ------------------------------- replace funtion -------------------------------
+
+
+def replace_linear_with_tiled_linear(model, num_shards=None, patch_by_names=True, patch_by_types=True):
+    target_names = ["to_q", "to_k", "to_v", "add_k_proj", "add_v_proj"]
+    target_types = ["FeedForward"]
+
+    patched_count = 0
+
+    def tiled_forward(self, x):
+        compute_params = list(self.parameters())
+        return apply_tiled_linear(
+            fn=lambda module, input: module._original_forward(input),
+            mlp_module=self,
+            x=x,
+            num_shards=num_shards,
+            compute_params=compute_params,
+        )
+
+    for name, module in model.named_modules():
+        layer_name = name.rsplit(".", 1)[-1] if "." in name else name
+        module_type = type(module).__name__
+
+        should_patch = False
+        if patch_by_types and module_type in target_types:
+            should_patch = True
+        if patch_by_names and layer_name in target_names and isinstance(module, torch.nn.Linear):
+            should_patch = True
+
+        if should_patch:
+            module._original_forward = module.forward
+            module.forward = tiled_forward.__get__(module, module.__class__)
+            patched_count += 1
+            # print(f"  Patched {module_type}: {name}")
+
+    print(f"Patched {patched_count} FeedForward modules with TiledMLP\n")
+    return model
+
+
+# ------------------------------- Tiled MLP -------------------------------
+
+
+def ensure_contiguous(fn):
+    @functools.wraps(fn)
+    def wrapper(ctx, *args, **kwargs):
+        def maybe_to_contiguous(x):
+            return x.contiguous() if isinstance(x, torch.Tensor) else x
+
+        args = [maybe_to_contiguous(arg) for arg in args]
+        kwargs = {k: maybe_to_contiguous(v) for k, v in kwargs.items()}
+        return fn(ctx, *args, **kwargs)
+
+    return wrapper
+
+
+class TiledLinear(torch.autograd.Function):
+    """
+    Based on DeepSpeed's TiledMLP:
+    https://github.com/deepspeedai/DeepSpeed/blob/v0.18.2/deepspeed/runtime/sequence_parallel/ulysses_sp.py#L838
+
+    Perform a tiled MLP computation to massively reduce memory usage needed to compute MLP
+    when using very long sequence lengths.
+
+    This module re-computes `forward` in the `backward`. So the `forward` occurs twice each iteration.
+    And if you're using activation checkpointing it then occurs thrice.
+
+    Args:
+        fn: the function to call on sharded inputs (e.g., mlp.forward)
+        mlp_module: the MLP nn.Module object
+        x: the input to MLP.forward (hidden_states)
+        shards: how many shards to use
+        compute_params: a list of weights engaged in the compute
+
+    Returns:
+        the computed hidden_states
+    """
+
+    @staticmethod
+    @ensure_contiguous
+    def forward(
+        ctx,
+        fn: Callable,
+        mlp_module: torch.nn.Module,
+        x: torch.Tensor,
+        shards: int,
+        compute_params: Optional[List[torch.nn.Parameter]] = None,
+    ) -> torch.Tensor:
+        ctx.fn = fn
+        ctx.mlp_module = mlp_module
+        ctx.shards = shards
+        ctx.save_for_backward(x)
+
+        # x.shape could be [bs, seqlen, hidden_size] or [seqlen, hidden_size] (moe experts)
+        x_shards = list(torch.chunk(x, chunks=shards, dim=-2))
+        with torch.no_grad():
+            output_shards = [fn(mlp_module, x_shard) for x_shard in x_shards]
+        output_unsharded = torch.cat(output_shards, dim=-2)
+
+        return output_unsharded
+
+    @staticmethod
+    @ensure_contiguous
+    def backward(ctx, *grads) -> tuple:
+        fn = ctx.fn
+        (x,) = ctx.saved_tensors
+        mlp_module = ctx.mlp_module
+        shards = ctx.shards
+
+        x_requires_grad = x.requires_grad
+        x = x.detach()
+        # detach() unsets x.requires_grad, so restore it
+        x.requires_grad_(x_requires_grad)
+
+        # x.shape could be [bs, seqlen, hidden_size] or [seqlen, hidden_size] (moe experts)
+        hidden_size = x.shape[-1]
+        x_shape_orig = x.shape
+
+        # flatten bs+seqlen to avoid having stride issues when narrowing into seqlen w/ bs>1
+        x = x.view(-1, hidden_size)
+        incoming_grad = grads[0].view(-1, hidden_size)
+        x_grad = torch.zeros_like(x)
+
+        x_shards = list(torch.chunk(x, chunks=shards, dim=0))
+
+        trainable_params = [p for p in mlp_module.parameters() if p.requires_grad]
+
+        for i, x_shard in enumerate(x_shards):
+            x_shard = x_shard.detach().requires_grad_(x_requires_grad)
+
+            shard_step = x_shards[i].shape[0]
+            shard_offset = i * x_shards[0].shape[0]
+
+            incoming_grad_shard = incoming_grad.narrow(0, shard_offset, shard_step).view_as(x_shard)
+
+            with torch.enable_grad():
+                output = fn(mlp_module, x_shard)
+
+            grads_tuple = torch.autograd.grad(
+                outputs=output,
+                inputs=[x_shard] + trainable_params,
+                grad_outputs=incoming_grad_shard,
+                allow_unused=True,
+                retain_graph=False,
+            )
+
+            x_grad.narrow(0, shard_offset, shard_step).copy_(grads_tuple[0])
+
+            for param, grad in zip(trainable_params, grads_tuple[1:]):
+                if grad is not None:
+                    if param.grad is None:
+                        param.grad = grad
+                    else:
+                        param.grad.add_(grad)
+
+        # unflatten
+        x_grad = x_grad.view(x_shape_orig)
+
+        return (None, None, x_grad, None, None)
+
+
+def apply_tiled_linear(
+    fn: Callable,
+    mlp_module: torch.nn.Module,
+    x: torch.Tensor,
+    num_shards: Optional[int] = None,
+    compute_params: Optional[List[torch.nn.Parameter]] = None,
+) -> torch.Tensor:
+    """
+    Apply tiled MLP computation for memory efficiency.
+
+    Args:
+        fn: the function to call on sharded inputs (e.g., lambda module, x: module(x))
+        mlp_module: the MLP nn.Module object
+        x: the input tensor with shape [bs, seqlen, hidden_size] or [seqlen, hidden_size]
+        num_shards: number of shards to use. If None, automatically calculated as ceil(seqlen / hidden_size)
+        compute_params: list of parameters for DeepSpeed ZeRO optimization
+
+    Returns:
+        output tensor with the same shape as input
+    """
+    if num_shards is None:
+        # x.shape could be [bs, seqlen, hidden_size] or [seqlen, hidden_size]
+        hidden_size = x.shape[-1]
+        seqlen = x.shape[-2]
+        num_shards = math.ceil(seqlen / hidden_size)
+
+    # Ensure num_shards is at least 1
+    num_shards = max(1, num_shards)
+
+    return TiledLinear.apply(
+        fn,
+        mlp_module,
+        x,
+        num_shards,
+        compute_params,
+    )
+
+
+# ------------------------------- Tiled FeedForward -------------------------------
+class FeedForward(nn.Module):
+    r"""
+    A feed-forward layer.
+
+    Parameters:
+        dim (`int`): The number of channels in the input.
+        dim_out (`int`, *optional*): The number of channels in the output. If not given, defaults to `dim`.
+        mult (`int`, *optional*, defaults to 4): The multiplier to use for the hidden dimension.
+        dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use.
+        activation_fn (`str`, *optional*, defaults to `"geglu"`): Activation function to be used in feed-forward.
+        final_dropout (`bool` *optional*, defaults to False): Apply a final dropout.
+        bias (`bool`, defaults to True): Whether to use a bias in the linear layer.
+    """
+
+    def __init__(
+        self,
+        dim: int,
+        dim_out: Optional[int] = None,
+        mult: int = 4,
+        dropout: float = 0.0,
+        activation_fn: str = "geglu",
+        final_dropout: bool = False,
+        inner_dim=None,
+        bias: bool = True,
+    ):
+        super().__init__()
+        if inner_dim is None:
+            inner_dim = int(dim * mult)
+        dim_out = dim_out if dim_out is not None else dim
+
+        if activation_fn == "gelu":
+            act_fn = GELU(dim, inner_dim, bias=bias)
+        if activation_fn == "gelu-approximate":
+            act_fn = GELU(dim, inner_dim, approximate="tanh", bias=bias)
+        elif activation_fn == "geglu":
+            act_fn = GEGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "geglu-approximate":
+            act_fn = ApproximateGELU(dim, inner_dim, bias=bias)
+        elif activation_fn == "swiglu":
+            act_fn = SwiGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "linear-silu":
+            act_fn = LinearActivation(dim, inner_dim, bias=bias, activation="silu")
+
+        self.net = nn.ModuleList([])
+        # project in
+        self.net.append(act_fn)
+        # project dropout
+        self.net.append(nn.Dropout(dropout))
+        # project out
+        self.net.append(nn.Linear(inner_dim, dim_out, bias=bias))
+        # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
+        if final_dropout:
+            self.net.append(nn.Dropout(dropout))
+
+    def forward(self, hidden_states: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        if len(args) > 0 or kwargs.get("scale", None) is not None:
+            deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`."
+            deprecate("scale", "1.0.0", deprecation_message)
+        for module in self.net:
+            hidden_states = module(hidden_states)
+        return hidden_states
+
+
+class TiledFeedForward(nn.Module):
+    """
+    Memory-efficient FeedForward using tiled computation (diffusers compatible)
+    Args:
+        dim: Input dimension
+        dim_out: Output dimension (default: dim)
+        mult: Multiplier for inner dimension (default: 4)
+        dropout: Dropout probability
+        activation_fn: Activation function ('geglu', 'gelu', 'gelu-approximate')
+        final_dropout: Apply dropout at the end
+        inner_dim: Inner dimension (overrides mult if provided)
+        bias: Use bias in linear layers
+        num_shards: Number of shards for tiling (None = auto)
+    """
+
+    def __init__(
+        self,
+        dim: int,
+        dim_out: Optional[int] = None,
+        mult: int = 4,
+        dropout: float = 0.0,
+        activation_fn: str = "geglu",
+        final_dropout: bool = False,
+        inner_dim: Optional[int] = None,
+        bias: bool = True,
+        num_shards: Optional[int] = None,
+    ):
+        super().__init__()
+
+        # Calculate dimensions
+        if inner_dim is None:
+            inner_dim = int(dim * mult)
+        dim_out = dim_out if dim_out is not None else dim
+
+        self.dim = dim
+        self.inner_dim = inner_dim
+        self.dim_out = dim_out
+        self.activation_fn = activation_fn
+        self.num_shards = num_shards
+
+        if activation_fn == "gelu":
+            act_fn = GELU(dim, inner_dim, bias=bias)
+        if activation_fn == "gelu-approximate":
+            act_fn = GELU(dim, inner_dim, approximate="tanh", bias=bias)
+        elif activation_fn == "geglu":
+            act_fn = GEGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "geglu-approximate":
+            act_fn = ApproximateGELU(dim, inner_dim, bias=bias)
+        elif activation_fn == "swiglu":
+            act_fn = SwiGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "linear-silu":
+            act_fn = LinearActivation(dim, inner_dim, bias=bias, activation="silu")
+
+        self.net = nn.ModuleList([])
+        # project in
+        self.net.append(act_fn)
+        # project dropout
+        self.net.append(nn.Dropout(dropout))
+        # project out
+        self.net.append(nn.Linear(inner_dim, dim_out, bias=bias))
+        # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
+        if final_dropout:
+            self.net.append(nn.Dropout(dropout))
+
+    def _mlp_forward(self, module, x):
+        """Internal MLP forward for tiled computation"""
+        for layer in module.net:
+            x = layer(x)
+        return x
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        """
+        Forward pass with tiled computation
+        Args:
+            hidden_states: [batch_size, seq_len, dim] or [seq_len, dim]
+        Returns:
+            Output tensor with same shape as input (but last dim = dim_out)
+        """
+        # Collect compute parameters
+        compute_params = list(self.parameters())
+
+        return apply_tiled_linear(
+            fn=self._mlp_forward,
+            mlp_module=self,
+            x=hidden_states,
+            num_shards=self.num_shards,
+            compute_params=compute_params,
+        )
+
+
+if __name__ == "__main__":
+    import torch
+    import torch.nn as nn
+
+    # 设置随机种子保证可重复性
+    torch.manual_seed(42)
+
+    # 创建测试输入
+    batch_size, seq_len, hidden_dim = 2, 1024, 768
+    x = torch.randn(batch_size, seq_len, hidden_dim, requires_grad=True)
+
+    # 方法1: replace
+    model1 = FeedForward(dim=hidden_dim)
+    # model1 = replace_linear_with_tiled_linear(model1, num_shards=4)
+    out1 = model1(x)
+    loss1 = out1.sum()
+    loss1.backward()
+    grad1 = x.grad.clone()
+
+    # 方法2: TiledFeedForward
+    x.grad = None
+    # model2 = TiledFeedForward(dim=hidden_dim, num_shards=4)
+    model2 = FeedForward(dim=hidden_dim)
+    model2 = replace_linear_with_tiled_linear(model2, num_shards=4)
+    # 复制权重确保完全一致
+    model2.load_state_dict(model1.state_dict(), strict=True)
+    out2 = model2(x)
+    loss2 = out2.sum()
+    loss2.backward()
+    grad2 = x.grad.clone()
+
+    # 比较结果
+    print(f"Output diff: {(out1 - out2).abs().max().item()}")
+    print(f"Gradient diff: {(grad1 - grad2).abs().max().item()}")
+    print(f"Output allclose: {torch.allclose(out1, out2, atol=1e-6)}")
+    print(f"Gradient allclose: {torch.allclose(grad1, grad2, atol=1e-6)}")

Helios/_DEV/helios/modules/helios_kernels/triton_norm.py

@@ -0,0 +1,413 @@
+import torch
+import triton
+import triton.language as tl
+
+from diffusers.models.normalization import FP32LayerNorm, LayerNorm, RMSNorm
+
+from .fp32_rmsnorm import FP32RMSNorm
+from .utils import calculate_settings, torch_gpu_device
+
+
+# ------------------------------- replace funtion -------------------------------
+
+
+def replace_all_norms_with_flash_norms(model):
+    patched_count = {"LayerNorm": 0, "RMSNorm": 0}
+
+    for name, module in model.named_modules():
+        if isinstance(module, (LayerNorm, FP32LayerNorm)):
+            if hasattr(module, "elementwise_affine") and module.elementwise_affine:
+                module.forward = (lambda self, x: flash_layernorm(self, x)).__get__(module, module.__class__)
+                patched_count["LayerNorm"] += 1
+
+        if isinstance(module, (torch.nn.RMSNorm, RMSNorm, FP32RMSNorm)):
+            module.forward = (lambda self, x: flash_rms_layernorm(self, x)).__get__(module, module.__class__)
+            patched_count["RMSNorm"] += 1
+
+    print(f"Patched {patched_count['LayerNorm']} Flash_LayerNorm modules\n")
+    print(f"Patched {patched_count['RMSNorm']} Flash_RMSNorm modules\n")
+
+    return model
+
+
+# ------------------------------- layer norm -------------------------------
+
+
+@triton.jit
+def layernorm_forward(
+    Y,
+    Y_row_stride,
+    X,
+    X_row_stride,
+    W,
+    b,
+    r,
+    mu,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    Y += row_idx * Y_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx
+    mu += row_idx
+
+    # According to https://pytorch.org/torchtune/stable/_modules/torchtune/modules/layer_norm.html#Fp32LayerNorm, all modules
+    # are in float32!
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0).to(tl.float32)
+    b_row = tl.load(b + col_offsets, mask=mask, other=0).to(tl.float32)
+
+    mean_X = tl.sum(X_row, axis=0) / n_cols
+    # (X[0] - mean) == -mean so we need to mask it out
+    XX = tl.where(mask, X_row - mean_X, 0)
+    row_var = tl.sum(XX * XX, axis=0) / n_cols
+    inv_var = tl.math.rsqrt(row_var + eps)
+    tl.store(r, inv_var)
+    tl.store(mu, mean_X)
+    output = (XX * inv_var) * W_row + b_row
+    tl.store(Y + col_offsets, output, mask=mask)
+
+
+@triton.jit
+def layernorm_backward(
+    dY,
+    dY_row_stride,
+    X,
+    X_row_stride,
+    W,
+    b,
+    r,
+    mu,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    # Approximately follows https://github.com/karpathy/llm.c/blob/master/doc/layernorm/layernorm.md
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    dY += row_idx * dY_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx
+    mu += row_idx
+
+    # According to https://pytorch.org/torchtune/stable/_modules/torchtune/modules/layer_norm.html#Fp32LayerNorm, all modules
+    # are in float32!
+    dY_row = tl.load(dY + col_offsets, mask=mask, other=0).to(tl.float32)
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0).to(tl.float32)
+    # b_row = tl.load(b + col_offsets, mask = mask, other = 0).to(tl.float32)
+
+    inv_var = tl.load(r).to(tl.float32)
+    mean = tl.load(mu).to(tl.float32)
+    normed = (X_row - mean) * inv_var
+    dY_W = dY_row * W_row
+    dX_row = dY_W - tl.sum(dY_W, axis=0) / n_cols - normed * tl.sum(dY_W * normed, axis=0) / n_cols
+    dX_row = dX_row * inv_var
+    tl.store(dY + col_offsets, dX_row, mask=mask)
+
+
+class Flash_Layernorm(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, X, W, b, eps):
+        shape = X.shape
+        dim = shape[-1]
+        X = X.view(-1, dim)
+        n_rows, n_cols = X.shape
+        BLOCK_SIZE, num_warps = calculate_settings(n_cols)
+        device = X.device
+        Y = torch.empty((n_rows, n_cols), dtype=X.dtype, device=device)
+        r = torch.empty(n_rows, dtype=torch.float32, device=device)
+        mu = torch.empty(n_rows, dtype=torch.float32, device=device)
+
+        with torch_gpu_device(device):
+            layernorm_forward[(n_rows,)](
+                Y,
+                Y.stride(0),
+                X,
+                X.stride(0),
+                W,
+                b,
+                r,
+                mu,
+                n_cols,
+                eps,
+                BLOCK_SIZE=BLOCK_SIZE,
+                num_warps=num_warps,
+            )
+        ctx.eps = eps
+        ctx.BLOCK_SIZE = BLOCK_SIZE
+        ctx.num_warps = num_warps
+        ctx.save_for_backward(X, W, b, r, mu)
+        return Y.view(*shape)
+
+    @staticmethod
+    def backward(ctx, dY):
+        shape = dY.shape
+        dim = shape[-1]
+        dY = dY.view(-1, dim)
+        X, W, b, r, mu = ctx.saved_tensors
+        n_rows, n_cols = dY.shape
+
+        with torch_gpu_device(dY.device):
+            layernorm_backward[(n_rows,)](
+                dY,
+                dY.stride(0),
+                X,
+                X.stride(0),
+                W,
+                b,
+                r,
+                mu,
+                n_cols,
+                ctx.eps,
+                BLOCK_SIZE=ctx.BLOCK_SIZE,
+                num_warps=ctx.num_warps,
+            )
+        dX = dY.view(*shape)
+        return dX, None, None, None, None
+
+
+def flash_layernorm(layernorm, X):
+    assert layernorm.elementwise_affine is True
+    W = layernorm.weight
+    bias = layernorm.bias
+    eps = layernorm.variance_epsilon if hasattr(layernorm, "variance_epsilon") else layernorm.eps
+    out = Flash_Layernorm.apply(X, W, bias, eps)
+    return out
+
+
+# ------------------------------- layer norm -------------------------------
+
+
+# ------------------------------- rms norm -------------------------------
+
+
+@triton.jit
+def _rms_layernorm_forward(
+    Y,
+    Y_row_stride: tl.constexpr,
+    X,
+    X_row_stride: tl.constexpr,
+    W,
+    W_row_stride: tl.constexpr,
+    r,
+    r_row_stride: tl.constexpr,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    """
+    Flash RMS Layernorm kernel
+    Inspiration from a Triton tutorial:
+    https://triton-lang.org/main/getting-started/tutorials/05-layer-norm.html
+    """
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    Y += row_idx * Y_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx * r_row_stride
+
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0)  # .to(tl.float32)
+
+    row_var = tl.sum(X_row * X_row, axis=0) / n_cols
+    inv_var = tl.math.rsqrt(row_var + eps)
+    tl.store(r, inv_var)
+    normed = X_row * inv_var
+    normed = normed.to(W_row.dtype)  # Exact copy from HF
+    output = normed * W_row
+    tl.store(Y + col_offsets, output, mask=mask)
+
+
+def _rms_layernorm_backward(
+    dY,
+    dY_row_stride: tl.constexpr,
+    dX,
+    dX_row_stride: tl.constexpr,
+    X,
+    X_row_stride: tl.constexpr,
+    W,
+    W_row_stride: tl.constexpr,
+    r,
+    r_row_stride: tl.constexpr,
+    # dW, dW_row_stride,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    GEMMA: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    """
+    Flash RMS Layernorm kernel for the backward pass
+    Inspiration from a Triton tutorial:
+    https://triton-lang.org/main/getting-started/tutorials/05-layer-norm.html
+    """
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    dY += row_idx * dY_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx * r_row_stride
+
+    if GEMMA:
+        dX += row_idx * dY_row_stride
+    else:
+        dX = dY
+
+    dY_row = tl.load(dY + col_offsets, mask=mask, other=0).to(tl.float32)
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0).to(tl.float32)
+
+    # Get saved row variance
+    inv_var = tl.load(r).to(tl.float32)
+    normed = X_row * inv_var
+
+    if GEMMA:
+        dY_W = dY_row * (W_row + 1.0)
+    else:
+        dY_W = dY_row * W_row
+
+    rowsum_dY_normed = tl.sum(dY_W * normed, axis=0)
+    output = inv_var / n_cols * (n_cols * dY_W - normed * rowsum_dY_normed)
+    tl.store(dX + col_offsets, output, mask=mask)
+
+
+_rms_layernorm_backward = triton.jit(_rms_layernorm_backward)
+_rms_layernorm_backward = triton.heuristics(
+    {
+        "GEMMA": lambda args: bool(args["GEMMA"]),
+    }
+)(_rms_layernorm_backward)
+
+
+@triton.jit
+def _gemma_rms_layernorm_forward(
+    Y,
+    Y_row_stride: tl.constexpr,
+    X,
+    X_row_stride: tl.constexpr,
+    W,
+    W_row_stride: tl.constexpr,
+    r,
+    r_row_stride: tl.constexpr,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    # Copies https://github.com/google-deepmind/gemma/blob/main/gemma/layers.py#L31
+    # and https://github.com/keras-team/keras-nlp/blob/v0.8.2/keras_nlp/models/gemma/rms_normalization.py#L33
+    # exactly. Essentially all in float32!
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    Y += row_idx * Y_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx * r_row_stride
+
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0).to(tl.float32)
+
+    row_var = tl.sum(X_row * X_row, axis=0) / n_cols
+    inv_var = tl.math.rsqrt(row_var + eps)
+    tl.store(r, inv_var)
+    normed = X_row * inv_var
+    output = normed * (W_row + 1.0)
+
+    tl.store(Y + col_offsets, output, mask=mask)
+
+
+class Flash_RMS_Layernorm(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, X: torch.Tensor, W: torch.Tensor, eps: float, gemma: bool = False):
+        shape = X.shape
+        dim: int = shape[-1]
+        X = X.reshape(-1, dim)
+        n_rows: int
+        n_cols: int
+        n_rows, n_cols = X.shape
+        BLOCK_SIZE: int
+        num_warps: int
+        BLOCK_SIZE, num_warps = calculate_settings(n_cols)
+        device = X.device
+
+        Y = torch.empty((n_rows, n_cols), dtype=X.dtype, device=device)
+        r = torch.empty(n_rows, dtype=torch.float32, device=device)
+
+        fx = _gemma_rms_layernorm_forward if gemma else _rms_layernorm_forward
+        with torch_gpu_device(device):
+            fx[(n_rows,)](
+                Y,
+                Y.stride(0),
+                X,
+                X.stride(0),
+                W,
+                W.stride(0),
+                r,
+                r.stride(0),
+                n_cols,
+                eps,
+                BLOCK_SIZE=BLOCK_SIZE,
+                num_warps=num_warps,
+            )
+        ctx.eps = eps
+        ctx.BLOCK_SIZE = BLOCK_SIZE
+        ctx.num_warps = num_warps
+        ctx.GEMMA = gemma
+        ctx.save_for_backward(X, W, r)
+        return Y.view(*shape)
+
+    @staticmethod
+    def backward(ctx, dY: torch.Tensor):
+        shape = dY.shape
+        dim: int = shape[-1]
+        dY = dY.reshape(-1, dim)
+        X, W, r = ctx.saved_tensors
+        n_rows: int
+        n_cols: int
+        n_rows, n_cols = dY.shape
+        # dW = X
+        dX = torch.empty_like(dY) if ctx.GEMMA else dY
+
+        with torch_gpu_device(dY.device):
+            _rms_layernorm_backward[(n_rows,)](
+                dY,
+                dY.stride(0),
+                dX,
+                dX.stride(0),
+                X,
+                X.stride(0),
+                W,
+                W.stride(0),
+                r,
+                r.stride(0),
+                # dW, dW.stride(0),
+                n_cols,
+                ctx.eps,
+                GEMMA=ctx.GEMMA,
+                BLOCK_SIZE=ctx.BLOCK_SIZE,
+                num_warps=ctx.num_warps,
+            )
+        dX = dX.view(*shape)
+        return dX, None, None, None
+
+
+# [TODO] Unsure why RMS Layernorm is not torch.compiling properly
+@torch.compiler.disable
+def flash_rms_layernorm(layernorm, X: torch.Tensor, gemma: bool = False):
+    W: torch.Tensor = layernorm.weight
+    eps: float = layernorm.variance_epsilon if hasattr(layernorm, "variance_epsilon") else layernorm.eps
+    out = Flash_RMS_Layernorm.apply(X, W, eps, gemma)
+    return out
+
+
+# ------------------------------- rms norm -------------------------------

Helios/_DEV/helios/modules/helios_kernels/triton_rope.py

@@ -0,0 +1,392 @@
+import torch
+import triton
+import triton.language as tl
+
+from .utils import calculate_settings, torch_gpu_device
+
+
+# ------------------------------- replace funtion -------------------------------
+
+
+def apply_rotary_emb_transposed_flash(x, freqs_cis):
+    return Flash_RoPE_Transposed.apply(x, freqs_cis)
+
+
+def replace_rope_with_flash_rope():
+    from ...diffusers_version import transformer_helios_diffusers
+    from .. import transformer_helios
+
+    transformer_helios_diffusers.apply_rotary_emb_transposed = apply_rotary_emb_transposed_flash
+    transformer_helios.apply_rotary_emb_transposed = apply_rotary_emb_transposed_flash
+    print("Patched Flash_RoPE globally\n")
+
+
+# ------------------------------- layer norm -------------------------------
+
+
+@triton.jit
+def _apply_rope_transposed_kernel(
+    X,
+    Out,
+    cos,
+    sin,
+    n_heads: tl.constexpr,
+    stride_x: tl.constexpr,
+    stride_out: tl.constexpr,
+    stride_freq: tl.constexpr,
+    head_dim: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    row_idx = tl.program_id(0)
+    freq_row_idx = row_idx // n_heads
+
+    half_head_dim = head_dim // 2
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < half_head_dim
+
+    x_ptr = X + row_idx * stride_x
+    out_ptr = Out + row_idx * stride_out
+    cos_ptr = cos + freq_row_idx * stride_freq
+    sin_ptr = sin + freq_row_idx * stride_freq
+
+    x_real = tl.load(x_ptr + col_offsets * 2, mask=mask, other=0.0)
+    x_imag = tl.load(x_ptr + col_offsets * 2 + 1, mask=mask, other=0.0)
+    cos_even = tl.load(cos_ptr + col_offsets * 2, mask=mask, other=0.0)
+    sin_odd = tl.load(sin_ptr + col_offsets * 2 + 1, mask=mask, other=0.0)
+
+    out_even = x_real * cos_even - x_imag * sin_odd
+    out_odd = x_real * sin_odd + x_imag * cos_even
+
+    tl.store(out_ptr + col_offsets * 2, out_even, mask=mask)
+    tl.store(out_ptr + col_offsets * 2 + 1, out_odd, mask=mask)
+
+
+class Flash_RoPE_Transposed(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x, freqs_cis):
+        # x: [B, seq_len, n_heads, head_dim]
+        # freqs_cis: [B, seq_len, head_dim*2]
+
+        B, seq_len, n_heads, head_dim = x.shape
+
+        x_flat = x.reshape(-1, head_dim).contiguous()
+        device = x_flat.device
+        out = torch.empty_like(x_flat)
+
+        freqs_flat = freqs_cis.reshape(B * seq_len, -1).contiguous()
+        half_dim = freqs_flat.shape[-1] // 2
+        cos = freqs_flat[:, :half_dim].contiguous()  # [B*seq_len, head_dim]
+        sin = freqs_flat[:, half_dim:].contiguous()  # [B*seq_len, head_dim]
+
+        n_rows = x_flat.shape[0]  # B*seq_len*n_heads
+        BLOCK_SIZE, num_warps = calculate_settings(head_dim // 2)
+
+        with torch_gpu_device(device):
+            _apply_rope_transposed_kernel[(n_rows,)](
+                x_flat,
+                out,
+                cos,
+                sin,
+                n_heads,
+                x_flat.stride(0),
+                out.stride(0),
+                cos.stride(0),
+                head_dim,
+                BLOCK_SIZE=BLOCK_SIZE,
+                num_warps=num_warps,
+            )
+
+        out = out.reshape(B, seq_len, n_heads, head_dim)
+
+        ctx.save_for_backward(cos, sin)
+        ctx.n_heads = n_heads
+        ctx.BLOCK_SIZE = BLOCK_SIZE
+        ctx.num_warps = num_warps
+        ctx.head_dim = head_dim
+
+        return out
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        cos, sin = ctx.saved_tensors
+
+        B, seq_len, n_heads, head_dim = grad_output.shape
+        grad_flat = grad_output.reshape(-1, head_dim).contiguous()
+        device = grad_flat.device
+        grad_x = torch.empty_like(grad_flat)
+
+        sin_neg = -sin
+
+        n_rows = grad_flat.shape[0]
+
+        with torch_gpu_device(device):
+            _apply_rope_transposed_kernel[(n_rows,)](
+                grad_flat,
+                grad_x,
+                cos,
+                sin_neg,
+                ctx.n_heads,
+                grad_flat.stride(0),
+                grad_x.stride(0),
+                cos.stride(0),
+                ctx.head_dim,
+                BLOCK_SIZE=ctx.BLOCK_SIZE,
+                num_warps=ctx.num_warps,
+            )
+
+        grad_x = grad_x.reshape(B, seq_len, n_heads, head_dim)
+        return grad_x, None
+
+
+# ------------------------------- For test -------------------------------
+def test_zero_error():
+    def apply_rotary_emb_transposed_orig(x, freqs_cis):
+        cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)
+        x_real, x_imag = x.unflatten(-1, (-1, 2)).unbind(-1)
+        out = torch.empty_like(x)
+        out[..., 0::2] = x_real * cos[..., 0::2] - x_imag * sin[..., 1::2]
+        out[..., 1::2] = x_real * sin[..., 1::2] + x_imag * cos[..., 0::2]
+        return out
+
+    for dtype in [torch.float32, torch.float16, torch.bfloat16]:
+        x = torch.randn(1, 128, 12, 128, device="cuda", dtype=dtype)
+        freqs_cis = torch.randn(1, 128, 256, device="cuda", dtype=dtype)
+
+        out_orig = apply_rotary_emb_transposed_orig(x, freqs_cis)
+        out_fast = apply_rotary_emb_transposed_flash(x, freqs_cis)
+
+        diff = (out_orig - out_fast).abs().max()
+
+        eps = torch.finfo(dtype).eps
+        print(f"{dtype}: max_diff={diff.item():.2e}, machine_eps={eps:.2e}")
+
+        if diff < eps * 100:
+            print(f"  ✅ Essentially zero error for {dtype}")
+        else:
+            print(f"  ⚠️ Significant error: {diff / eps:.1f}x machine epsilon")
+
+
+def test_comparison():
+    def apply_rotary_emb_transposed_orig(x, freqs_cis):
+        cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)
+        x_real, x_imag = x.unflatten(-1, (-1, 2)).unbind(-1)
+        out = torch.empty_like(x)
+        out[..., 0::2] = x_real * cos[..., 0::2] - x_imag * sin[..., 1::2]
+        out[..., 1::2] = x_real * sin[..., 1::2] + x_imag * cos[..., 0::2]
+        return out
+
+    x = torch.randn(1, 14040, 12, 128, device="cuda", dtype=torch.float32)
+    freqs_cis = torch.randn(1, 14040, 256, device="cuda", dtype=torch.float32)
+
+    out_orig = apply_rotary_emb_transposed_orig(x, freqs_cis)
+    out_fast = apply_rotary_emb_transposed_flash(x, freqs_cis)
+
+    diff = (out_orig - out_fast).abs().max()
+    print(f"Max difference: {diff.item():.6e}")
+
+    if diff < 1e-5:
+        print("✅ Test passed!")
+        print(f"Input shapes: x={x.shape}, freqs_cis={freqs_cis.shape}")
+        print(f"Output shape: {out_fast.shape}")
+    else:
+        print(f"❌ Test failed! Max diff: {diff.item()}")
+
+
+def test_backward_comparison():
+    def apply_rotary_emb_transposed_orig(x, freqs_cis):
+        cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)
+        x_real, x_imag = x.unflatten(-1, (-1, 2)).unbind(-1)
+        out = torch.empty_like(x)
+        out[..., 0::2] = x_real * cos[..., 0::2] - x_imag * sin[..., 1::2]
+        out[..., 1::2] = x_real * sin[..., 1::2] + x_imag * cos[..., 0::2]
+        return out
+
+    x1 = torch.randn(1, 128, 12, 128, device="cuda", requires_grad=True)
+    x2 = x1.clone().detach().requires_grad_(True)
+    freqs_cis = torch.randn(1, 128, 256, device="cuda")
+
+    out_orig = apply_rotary_emb_transposed_orig(x1, freqs_cis)
+    out_fast = apply_rotary_emb_transposed_flash(x2, freqs_cis)
+
+    grad_output = torch.randn_like(out_orig)
+
+    out_orig.backward(grad_output)
+    out_fast.backward(grad_output)
+
+    grad_diff = (x1.grad - x2.grad).abs()
+    max_diff = grad_diff.max().item()
+    mean_diff = grad_diff.mean().item()
+
+    print("Gradient comparison:")
+    print(f"  Max difference: {max_diff:.6e}")
+    print(f"  Mean difference: {mean_diff:.6e}")
+
+    if max_diff < 1e-5:
+        print("✅ Backward gradients match!")
+    else:
+        print(f"⚠️ Gradients differ by {max_diff:.6e}")
+        max_idx = grad_diff.argmax()
+        print(f"  Max diff location: {torch.unravel_index(max_idx, grad_diff.shape)}")
+        print(f"  Original grad: {x1.grad.flatten()[max_idx]:.6f}")
+        print(f"  Fast grad: {x2.grad.flatten()[max_idx]:.6f}")
+
+
+def test_backward():
+    from torch.autograd import gradcheck
+
+    B, seq_len, n_heads, head_dim = 2, 16, 4, 32
+    x = torch.randn(B, seq_len, n_heads, head_dim, device="cuda", dtype=torch.float64, requires_grad=True)
+    freqs_cis = torch.randn(B, seq_len, head_dim * 2, device="cuda", dtype=torch.float64)
+
+    test = gradcheck(
+        Flash_RoPE_Transposed.apply,
+        (x, freqs_cis),
+        eps=1e-6,
+        atol=1e-4,
+        rtol=1e-3,
+    )
+
+    if test:
+        print("✅ Backward pass is correct (gradcheck passed)")
+    else:
+        print("❌ Backward pass has errors")
+
+
+def test_in_training_loop_comparison():
+    def apply_rotary_emb_transposed_orig(x, freqs_cis):
+        cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)
+        x_real, x_imag = x.unflatten(-1, (-1, 2)).unbind(-1)
+        out = torch.empty_like(x)
+        out[..., 0::2] = x_real * cos[..., 0::2] - x_imag * sin[..., 1::2]
+        out[..., 1::2] = x_real * sin[..., 1::2] + x_imag * cos[..., 0::2]
+        return out
+
+    class SimpleModel(torch.nn.Module):
+        def __init__(self, use_fast=False):
+            super().__init__()
+            self.linear = torch.nn.Linear(128, 128, device="cuda")
+            self.use_fast = use_fast
+
+        def forward(self, x, freqs_cis):
+            x = self.linear(x)
+            if self.use_fast:
+                x = apply_rotary_emb_transposed_flash(x, freqs_cis)
+            else:
+                x = apply_rotary_emb_transposed_orig(x, freqs_cis)
+            return x.mean()
+
+    torch.manual_seed(42)
+    torch.cuda.manual_seed(42)
+
+    model_orig = SimpleModel(use_fast=False)
+    model_fast = SimpleModel(use_fast=True)
+
+    model_fast.load_state_dict(model_orig.state_dict())
+
+    optimizer_orig = torch.optim.Adam(model_orig.parameters(), lr=1e-3)
+    optimizer_fast = torch.optim.Adam(model_fast.parameters(), lr=1e-3)
+
+    losses_orig = []
+    losses_fast = []
+
+    print("=" * 80)
+    print("Training comparison: Original vs Optimized RoPE")
+    print("=" * 80)
+    print(f"{'Step':<6} {'Original Loss':<15} {'Fast Loss':<15} {'Diff':<12} {'Status':<10}")
+    print("-" * 80)
+
+    torch.manual_seed(42)
+    inputs = [
+        (torch.randn(1, 128, 12, 128, device="cuda"), torch.randn(1, 128, 256, device="cuda")) for _ in range(10)
+    ]
+
+    for step, (x, freqs_cis) in enumerate(inputs):
+        optimizer_orig.zero_grad()
+        loss_orig = model_orig(x.clone(), freqs_cis)
+        loss_orig.backward()
+        optimizer_orig.step()
+
+        optimizer_fast.zero_grad()
+        loss_fast = model_fast(x.clone(), freqs_cis)
+        loss_fast.backward()
+        optimizer_fast.step()
+
+        has_nan_orig = any(p.grad is not None and torch.isnan(p.grad).any() for p in model_orig.parameters())
+        has_nan_fast = any(p.grad is not None and torch.isnan(p.grad).any() for p in model_fast.parameters())
+
+        if has_nan_orig or has_nan_fast:
+            print(f"❌ Step {step}: Found NaN in gradients")
+            return False
+
+        loss_orig_val = loss_orig.item()
+        loss_fast_val = loss_fast.item()
+        losses_orig.append(loss_orig_val)
+        losses_fast.append(loss_fast_val)
+
+        diff = abs(loss_orig_val - loss_fast_val)
+        rel_diff = diff / abs(loss_orig_val) if abs(loss_orig_val) > 1e-10 else 0
+
+        if diff < 1e-6:
+            status = "✅ Match"
+        elif diff < 1e-4:
+            status = "✓ Close"
+        else:
+            status = "⚠️ Differ"
+
+        print(
+            f"{step:<6} {loss_orig_val:<15.6f} {loss_fast_val:<15.6f} "
+            f"{diff:<12.2e} {status:<10}"
+            f"{rel_diff:<12.2e} {status:<10}"
+        )
+
+    print("-" * 80)
+
+    avg_diff = sum(abs(o - f) for o, f in zip(losses_orig, losses_fast)) / len(losses_orig)
+    max_diff = max(abs(o - f) for o, f in zip(losses_orig, losses_fast))
+
+    print(f"\n{'Summary':<20} {'Original':<15} {'Optimized':<15} {'Difference':<15}")
+    print("-" * 65)
+    print(
+        f"{'Initial loss:':<20} {losses_orig[0]:<15.6f} {losses_fast[0]:<15.6f} "
+        f"{abs(losses_orig[0] - losses_fast[0]):<15.2e}"
+    )
+    print(
+        f"{'Final loss:':<20} {losses_orig[-1]:<15.6f} {losses_fast[-1]:<15.6f} "
+        f"{abs(losses_orig[-1] - losses_fast[-1]):<15.2e}"
+    )
+    print(
+        f"{'Average loss:':<20} {sum(losses_orig) / len(losses_orig):<15.6f} "
+        f"{sum(losses_fast) / len(losses_fast):<15.6f} {avg_diff:<15.2e}"
+    )
+    print(f"{'Max difference:':<20} {'':<15} {'':<15} {max_diff:<15.2e}")
+
+    weight_diffs = []
+    for (name_o, param_o), (name_f, param_f) in zip(model_orig.named_parameters(), model_fast.named_parameters()):
+        diff = (param_o - param_f).abs().max().item()
+        weight_diffs.append(diff)
+
+    max_weight_diff = max(weight_diffs)
+    print(f"{'Max weight diff:':<20} {'':<15} {'':<15} {max_weight_diff:<15.2e}")
+
+    print("=" * 80)
+
+    if max_diff < 1e-4 and max_weight_diff < 1e-4:
+        print("✅ Training consistency test PASSED")
+        print("   Original and optimized versions produce nearly identical results")
+        return True
+    elif max_diff < 1e-2:
+        print("✓ Training consistency test ACCEPTABLE")
+        print("   Small numerical differences detected (within tolerance)")
+        return True
+    else:
+        print("⚠️ Training consistency test WARNING")
+        print(f"   Differences detected: loss_diff={max_diff:.2e}, weight_diff={max_weight_diff:.2e}")
+        return False
+
+
+if __name__ == "__main__":
+    test_zero_error()
+    test_comparison()
+    test_backward_comparison()
+    test_in_training_loop_comparison()
+    # test_backward()

Helios/_DEV/helios/modules/helios_kernels/utils.py

@@ -0,0 +1,70 @@
+from contextlib import nullcontext
+
+import torch
+import triton
+
+
+def get_device_type():
+    if torch.cuda.is_available():
+        try:
+            if torch.version.hip is not None:
+                return "hip"
+        except AttributeError:
+            pass
+        return "cuda"
+
+    try:
+        if hasattr(torch, "xpu") and torch.xpu.is_available():
+            return "xpu"
+    except (AttributeError, RuntimeError):
+        pass
+
+    return "cpu"
+
+
+def get_device_count(device_type):
+    if device_type == "cuda" or device_type == "hip":
+        return torch.cuda.device_count()
+    elif device_type == "xpu":
+        try:
+            return torch.xpu.device_count()
+        except (AttributeError, RuntimeError):
+            return 0
+    return 0
+
+
+MAX_FUSED_SIZE: int = 65536
+next_power_of_2 = triton.next_power_of_2
+DEVICE_TYPE = get_device_type()
+DEVICE_COUNT = get_device_count(DEVICE_TYPE)
+
+if DEVICE_COUNT > 1:
+    if DEVICE_TYPE in ("cuda", "hip"):
+        torch_gpu_device = torch.cuda.device
+    elif DEVICE_TYPE == "xpu":
+        torch_gpu_device = torch.xpu.device
+else:
+
+    def torch_gpu_device(device):
+        return nullcontext()
+
+
+def calculate_settings(
+    n: int,
+) -> (
+    int,
+    int,
+):
+    BLOCK_SIZE: int = next_power_of_2(n)
+    if BLOCK_SIZE > MAX_FUSED_SIZE:
+        raise RuntimeError(
+            f"Cannot launch Triton kernel since n = {n} exceeds the maximum CUDA blocksize = {MAX_FUSED_SIZE}."
+        )
+    num_warps: int = 4
+    if BLOCK_SIZE >= 32768:
+        num_warps = 32
+    elif BLOCK_SIZE >= 8192:
+        num_warps = 16
+    elif BLOCK_SIZE >= 2048:
+        num_warps = 8
+    return BLOCK_SIZE, num_warps

Helios/_DEV/helios/utils/train_config.py

@@ -0,0 +1,443 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ReportTo:
+    tracker_name: str = field(default="Spark-Wan")
+    wandb_name: str = field(default="test_run")
+    report_to: str = field(
+        default="wandb",
+        metadata={"choices": ["wandb", "tensorboard", "comet_ml", "all"]},
+    )
+
+
+@dataclass
+class DataConfig:
+    # ---- Base ----
+    use_shuffle: bool = field(default=False)
+    pin_memory: bool = field(default=False)
+    persistent_workers: bool = field(default=False)
+    instance_data_root: list = field(default_factory=list)
+    instance_video_root: list = field(default_factory=list)
+    dataset_sampling_ratios: list = field(default_factory=list)
+    dataloader_num_workers: int = field(default=0)
+    prefetch_factor: int = field(default=2)
+    force_rebuild: bool = field(default=False)
+    stride: int = field(default=1)
+    resolution: int = field(default=640)
+    single_res: bool = field(default=False)
+    single_res: bool = field(default=False)
+    single_height: int = field(default=384)
+    single_width: int = field(default=640)
+    single_length: bool = field(default=False)
+    single_num_frame: int = field(default=81)
+    multi_res: bool = field(default=False)
+    caption_dropout_p: float = field(default=0.00)
+    id_token: str = field(default="")
+    negative_prompt: str = field(
+        default="Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"
+    )
+    # ---- Stage 1 ----
+    use_stage1_dataset: bool = field(default=False)
+    # ---- Stage 3 ----
+    use_stage3_dataset: bool = field(default=False)
+    gan_data_root: Optional[list] = field(default_factory=list)
+    ode_data_root: Optional[list] = field(default_factory=list)
+    text_data_root: Optional[list] = field(default_factory=list)
+
+
+@dataclass
+class ModelConfig:
+    # ---- Path ----
+    pretrained_model_name_or_path: Optional[str] = field(default=None)
+    transformer_model_name_or_path: Optional[str] = field(default=None)
+    siglip_model_name_or_path: Optional[str] = field(default=None)
+    lora_paths: Optional[list[str]] = field(default_factory=list)
+    subfolder: Optional[str] = field(default=None)
+    revision: Optional[str] = field(default=None)
+    variant: Optional[str] = field(default=None)
+    load_checkpoints_custom: bool = field(default=False)
+    load_model_path: Optional[str] = field(default=None)
+    load_dcp: bool = field(default=False)
+    load_dcp_path: Optional[str] = field(default=None)
+    # ---- Vae ----
+    upcast_vae: bool = field(default=False)
+    enable_slicing: bool = field(default=False)
+    enable_tiling: bool = field(default=False)
+    # ---- Lora ----
+    lora_rank: int = field(default=128)
+    lora_alpha: float = field(default=128.0)
+    lora_dropout: float = field(default=0.0)
+    lora_layers: Optional[str] = field(default=None)
+    lora_target_modules: list = field(default_factory=list)
+    lora_exclude_modules: list = field(default_factory=list)
+    # ---- Other ----
+    train_norm_layers: bool = field(default=False)
+    bnb_quantization_config_path: Optional[str] = field(default=None)
+    # ----- Stage 3 -----
+    critic_lora_name_or_path: Optional[str] = field(default=None)
+    critic_subfolder: Optional[str] = field(default=None)
+    critic_lora_rank: int = field(default=128)
+    critic_lora_alpha: float = field(default=128.0)
+    critic_lora_dropout: float = field(default=0.0)
+    real_score_model_name_or_path: Optional[str] = field(default=None)
+    # ---- Reward Parameters ----
+    reward_model_name_or_path: Optional[str] = field(default=None)
+
+
+@dataclass
+class ValidationConfig:
+    validation_steps: int = field(default=100)
+    validation_height: int = field(default=480)
+    validation_width: int = field(default=832)
+    validation_max_num_frames: int = field(default=81)
+    validation_prompts: Optional[list[str]] = field(default_factory=lambda: ["A frog jumps on a lotus leaf."])
+    validation_images: Optional[list[str]] = field(default_factory=lambda: ["example/input_images/frog.jpg"])
+    validation_guidance_scale: float = field(default=9.0)
+    validation_latent_window_size: list[int] = field(default_factory=lambda: [9])
+    validation_stream_chunk_size: list[int] = field(default_factory=lambda: [3])
+    first_step_valid: bool = field(default=True)
+    num_validation_videos: int = field(default=1)
+    num_inference_steps: int = field(default=30)
+    # ---- Dynamic Shifting ----
+    use_dynamic_shifting: bool = field(default=False)
+    time_shift_type: str = field(
+        default="linear",
+        metadata={"choices": ["exponential", "linear"]},
+    )
+    # ---- Stage 1 ----
+    use_kv_cache: bool = field(default=False)
+    # ---- Stage 2 ----
+    stage2_simulated_inference_steps: list[int] = field(default_factory=lambda: [10, 10, 10])
+
+
+@dataclass
+class TrainingConfig:
+    # ---- Environment ----
+    local_rank: int = field(default=-1)
+    allow_tf32: bool = field(default=False)
+    gradient_checkpointing: bool = field(default=True)
+    enable_xformers_memory_efficient_attention: bool = field(default=False)
+    enable_npu_flash_attention: bool = field(default=False)
+    upcast_before_saving: bool = field(default=False)
+    offload: bool = field(default=False)
+    mixed_precision: str = field(
+        default="bf16",
+        metadata={"choices": ["no", "fp16", "bf16"]},
+    )
+    profile_out_dir: Optional[str] = field(default=None)
+    # ---- Training Resource ----
+    num_train_epochs: int = field(default=1)
+    max_train_steps: Optional[int] = field(default=None)
+    train_batch_size: int = field(default=1)
+    gradient_accumulation_steps: int = field(default=1)
+    checkpointing_steps: int = field(default=500)
+    checkpoints_total_limit: Optional[int] = field(default=None)
+    resume_from_checkpoint: Optional[str] = field(default=None)
+    save_checkpoints_custom: bool = field(default=False)
+    # ---- Optimizer ----
+    learning_rate: float = field(default=2e-4)
+    scale_lr: bool = field(default=False)
+    lr_scheduler: str = field(
+        default="constant",
+        metadata={
+            "choices": [
+                "linear",
+                "cosine",
+                "cosine_with_restarts",
+                "polynomial",
+                "constant",
+                "constant_with_warmup",
+            ]
+        },
+    )
+    lr_warmup_steps: int = field(default=500)
+    lr_num_cycles: int = field(default=1)
+    lr_power: float = field(default=1.0)
+    optimizer: str = field(
+        default="adamw",
+        metadata={
+            "choices": ["adam", "adamw", "prodigy"],
+        },
+    )
+    use_8bit_adam: bool = field(default=False)
+    adam_beta1: float = field(default=0.9)
+    adam_beta2: float = field(default=0.999)
+    prodigy_beta3: Optional[float] = field(default=None)
+    prodigy_decouple: bool = field(default=True)
+    prodigy_use_bias_correction: bool = field(default=True)
+    prodigy_safeguard_warmup: bool = field(default=True)
+    adam_weight_decay: float = field(default=1e-04)
+    adam_epsilon: float = field(default=1e-08)
+    max_grad_norm: float = field(default=1.0)
+    weighting_scheme: str = field(
+        default="logit_normal",
+        metadata={
+            "choices": ["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"],
+        },
+    )
+    logit_mean: float = field(default=0.0)
+    logit_std: float = field(default=1.0)
+    mode_scale: float = field(default=1.29)
+    # ---- Dynamic Shifting ----
+    use_dynamic_shifting: bool = field(default=False)
+    time_shift_type: str = field(
+        default="linear",
+        metadata={"choices": ["exponential", "linear"]},
+    )
+    base_seq_len: Optional[int] = field(default=256)
+    max_seq_len: Optional[int] = field(default=4096)
+    base_shift: Optional[float] = field(default=0.5)
+    max_shift: Optional[float] = field(default=1.15)
+    # ---- VAE Decode Parameters ----
+    vae_decode_type: str = field(
+        default="default",
+        metadata={
+            "choices": ["default", "dafault_batch"],
+        },
+    )
+    # ---- EMA ----
+    use_ema: bool = field(default=False)
+    use_ema_validation: bool = field(default=False)
+    ema_decay: float = field(default=0.999)
+    ema_start_step: int = field(default=0)
+    ema_zero3_port: int = field(default=10543)
+    ema_deepspeed_config_file: str = field(default="scripts/accelerate_configs/zero3.json")
+    # ---- Stage 1 Parameters ----
+    is_enable_stage1: bool = field(default=False)
+    history_sizes: list[int] = field(default_factory=lambda: [16, 2, 1])
+    latent_window_size: list[int] = field(default_factory=lambda: [9])
+    is_random_drop: bool = field(default=False)
+    random_drop_i2v_ratio: float = field(default=0)
+    random_drop_v2v_ratio: float = field(default=0)
+    random_drop_t2v_ratio: float = field(default=0)
+    is_amplify_history: bool = field(default=False)
+    history_scale_mode: str = field(
+        default="per_head",
+        metadata={
+            "choices": ["scalar", "per_head"],
+        },
+    )
+    #
+    has_multi_term_memory_patch: bool = field(default=False)
+    is_train_full_multi_term_memory_patchg: bool = field(default=False)
+    is_train_lora_multi_term_memory_patchg: bool = field(default=False)
+    is_train_full_patch_embedding: bool = field(default=False)
+    is_train_lora_patch_embedding: bool = field(default=False)
+    zero_history_timestep: bool = field(default=False)
+    restrict_self_attn: bool = field(default=False)
+    guidance_cross_attn: bool = field(default=False)
+    is_train_restrict_lora: bool = field(default=False)
+    restrict_lora: bool = field(default=False)
+    restrict_lora_rank: int = field(default=128)
+    # ---- Easy Anti-Drifting Parameters ----
+    corrupt_model_input: bool = field(default=False)
+    corrupt_mode_model_input: str = field(
+        default="noise",
+        metadata={
+            "choices": ["noise", "downsample", "random"],
+        },
+    )
+    corrupt_mode_prob_model_input: float = field(default=0.9)
+    is_frame_independent_corrupt_model_input: bool = field(default=False)
+    is_chunk_independent_corrupt_model_input: bool = field(default=False)
+    noise_corrupt_ratio_model_input: float = field(default=1 / 3)
+    noise_corrupt_clean_prob_model_input: float = field(default=0.1)
+    downsample_min_corrupt_ratio_model_input: float = field(default=0.9)
+    downsample_max_corrupt_ratio_model_input: float = field(default=1.0)
+    #
+    corrupt_history: bool = field(default=False)
+    corrupt_mode_history: str = field(
+        default="noise",
+        metadata={
+            "choices": ["noise", "downsample", "random"],
+        },
+    )
+    corrupt_mode_prob_history: float = field(default=0.9)
+    is_frame_independent_corrupt_history: bool = field(default=False)
+    is_chunk_independent_corrupt_history: bool = field(default=False)
+    noise_corrupt_ratio_history_short: float = field(default=1 / 3)
+    noise_corrupt_ratio_history_mid: float = field(default=1 / 3)
+    noise_corrupt_ratio_history_long: float = field(default=1 / 3)
+    noise_corrupt_clean_prob_history: float = field(default=0.1)
+    downsample_min_corrupt_ratio_history: float = field(default=0.9)
+    downsample_max_corrupt_ratio_history: float = field(default=1.0)
+    #
+    is_add_saturation: bool = field(default=False)
+    saturation_ratio_min: float = field(default=0.3)
+    saturation_ratio_max: float = field(default=1.7)
+    saturation_ratio_clean_prob: float = field(default=0.1)
+    # ---- Stage 2 Parameters ----
+    is_enable_stage2: bool = field(default=False)
+    is_navit_pyramid: bool = field(default=False)
+    stage2_num_stages: int = field(default=3)
+    stage2_timestep_shift: float = field(default=1.0)
+    stage2_scheduler_gamma: float = field(default=1 / 3)
+    stage2_stage_range: list[float] = field(default_factory=lambda: [0.0, 1 / 3, 2 / 3, 1])
+    stage2_sample_ratios: list[int] = field(default_factory=lambda: [1, 2, 1])
+    efficient_sample: bool = field(default=False)
+    # ---- Stage 3 VRAM Parameters ----
+    dmd_is_low_vram_mode: bool = field(default=False)
+    is_gan_low_vram_mode: bool = field(default=False)
+    dmd_is_offload_grad: bool = field(default=False)
+    # ---- Stage 3 Parameters ----
+    log_iters: int = field(default=200)
+    no_visualize: bool = field(default=False)
+    is_train_dmd: bool = field(default=False)
+    max_grad_norm_critic: float = field(default=1.0)
+    dmd_generator_deepspeed_config: Optional[str] = field(default=None)
+    dmd_critic_deepspeed_config: Optional[str] = field(default=None)
+    critic_learning_rate: Optional[float] = field(default=2e-6)
+    dfake_gen_update_ratio: Optional[int] = field(default=5)
+    dmd_denoising_step_list: list[int] = field(default_factory=lambda: [1000, 750, 500, 250])
+    num_critic_input_frames: Optional[int] = field(default=21)
+    dmd_timestep_shift: Optional[float] = field(default=5.0)
+    dmd_last_step_only: bool = field(default=False)
+    dmd_last_section_grad_only: bool = field(default=False)
+    dmd_teacher_forcing: bool = field(default=False)
+    dmd_teacher_forcing_ratio: float = field(default=0.2)
+    fake_guidance_scale: float = field(default=0.0)
+    real_guidance_scale: float = field(default=3.0)
+    is_skip_first_section: bool = field(default=False)
+    is_amplify_first_chunk: bool = field(default=False)
+    # ---- GT History Parameters ----
+    is_use_gt_history: bool = field(default=False)
+    use_gt_history_ratio: float = field(default=1.0)
+    is_use_gt_coherence_dmd: bool = field(default=False)
+    # ---- VAE Re-Encode ----
+    is_dmd_vae_decode: bool = field(default=False)
+    # ---- Multi Stage Backward Simulated ----
+    is_multi_pyramid_stage_backward_simulated: bool = field(default=False)
+    # ---- Consistency Align Parameters ----
+    is_consistency_align: bool = field(default=False)
+    consistentcy_align_weight: float = field(default=0.25)
+    # ---- Smoothness Parameters ----
+    is_smoothness_loss: bool = field(default=False)
+    smoothness_loss_weight: float = field(default=1e-2)
+    # ---- Mean-Variance Regularization Parameters ----
+    is_mean_var_regular: bool = field(default=False)
+    mean_var_regular_weight: float = field(default=1.0)
+    regular_mean: Optional[float] = field(default=0.00657021)
+    regular_var: Optional[float] = field(default=0.85126512)
+    is_x0_mean_var_regular: bool = field(default=False)
+    mean_var_regular_x0_weight: float = field(default=1.0)
+    regular_x0_mean: Optional[float] = field(default=-0.01618061)
+    regular_x0_var: Optional[float] = field(default=0.27996052)
+    #
+    is_chunk_mean_var_regular: bool = field(default=False)
+    chunk_mean_var_regular_weight: float = field(default=1.0)
+    chunk_regular_mean: Optional[float] = field(default=0.01906107)
+    chunk_regular_var: Optional[float] = field(default=0.81397036)
+    is_chunk_x0_mean_var_regular: bool = field(default=False)
+    chunk_mean_var_regular_x0_weight: float = field(default=1.0)
+    chunk_regular_x0_mean: Optional[float] = field(default=-0.01578601)
+    chunk_regular_x0_var: Optional[float] = field(default=0.29913200)
+    # ---- ODE Regression ----
+    is_use_ode_regression: bool = field(default=False)
+    is_only_ode_regression: bool = field(default=False)
+    ode_regression_weight: float = field(default=0.25)
+    ode_num_latent_sections_min: int = field(default=3)
+    ode_num_latent_sections_max: int = field(default=3)
+    # ---- GAN Parameters ----
+    is_use_gan: bool = field(default=False)
+    gan_start_step: int = field(default=0)
+    is_separate_gan_grad: bool = field(default=False)
+    is_use_gan_hooks: bool = field(default=False)
+    is_use_gan_final: bool = field(default=False)
+    gan_cond_map_dim: int = field(default=768)
+    gan_hooks: list[int] = field(default_factory=lambda: [5, 15, 25, 35])
+    gan_g_weight: float = field(default=1e-2)
+    gan_d_weight: float = field(default=1e-2)
+    aprox_r1: bool = field(default=False)
+    aprox_r2: bool = field(default=False)
+    r1_weight: float = field(default=0.0)
+    r2_weight: float = field(default=0.0)
+    r1_sigma: float = field(default=0.1)
+    r2_sigma: float = field(default=0.1)
+    # ---- Reward Parameters ----
+    is_use_reward_model: bool = field(default=False)
+    reward_start_step: int = field(default=0)
+    reward_weight_vq: float = field(default=2.0)
+    reward_weight_mq: float = field(default=2.0)
+    reward_weight_ta: float = field(default=2.0)
+    # ---- Decouple Parameters ----
+    is_decouple_dmd: bool = field(default=False)
+    decouple_ca_start_step: int = field(default=2000)
+    decouple_ca_end_step: int = field(default=3000)
+    # ---- Cold Start Parameters ----
+    is_enable_cold_start: bool = field(default=False)
+    cold_start_step: int = field(default=1000)
+    stage_cold_start_step: Optional[int] = field(default=None)
+    # ---- Dynamic Timestep ----
+    generator_is_forcing_low_renoise: bool = field(default=False)
+    generator_dynamic_alpha: float = field(default=4.0)
+    generator_dynamic_beta: float = field(default=1.5)
+    generator_dynamic_sample_type: str = field(
+        default="uniform",
+        metadata={
+            "choices": ["uniform", "beta"],
+        },
+    )
+    generator_dynamic_step: int = field(default=1000)
+    critic_dynamic_alpha: float = field(default=4.0)
+    critic_dynamic_beta: float = field(default=1.5)
+    critic_dynamic_sample_type: str = field(
+        default="uniform",
+        metadata={
+            "choices": ["uniform", "beta"],
+        },
+    )
+    critic_dynamic_step: int = field(default=1000)
+    # ---- Dynamic DMD Section ----
+    dmd_num_latent_sections_min: Optional[int] = field(default=3)
+    dmd_num_latent_sections_max: Optional[int] = field(default=3)
+    dmd_dynamic_alpha: float = field(default=1.5)
+    dmd_dynamic_beta: float = field(default=4.0)
+    dmd_dynamic_sample_type: str = field(
+        default="uniform",
+        metadata={
+            "choices": ["uniform", "beta"],
+        },
+    )
+    dmd_dynamic_step: int = field(default=1000)
+    # ---- Dynamic ODE Section ----
+    ode_dynamic_alpha: float = field(default=1.5)
+    ode_dynamic_beta: float = field(default=4.0)
+    ode_dynamic_sample_type: str = field(
+        default="uniform",
+        metadata={
+            "choices": ["uniform", "beta"],
+        },
+    )
+    ode_dynamic_step: int = field(default=1000)
+    # ---- Recycle ----
+    use_error_recycling: bool = field(default=False)
+    y_error_sample_from_all_grids: bool = field(default=True)
+
+    error_buffer_size: int = field(default=500)
+    buffer_replacement_strategy: str = field(default="l2_batch")
+    buffer_warmup_iter: int = field(default=50)
+    timestep_grid_size: int = field(default=25)
+    num_grids: int = field(default=50)
+
+    y_error_num: int = field(default=6)
+    error_modulate_factor: float = field(default=0.0)
+    error_setting: int = field(default=1)
+    noise_prob: float = field(default=0.01)
+    y_prob: float = field(default=0.9)
+    latent_prob: float = field(default=0.9)
+    clean_prob: float = field(default=0.2)
+    clean_buffer_update_prob: float = field(default=0.1)
+
+
+@dataclass
+class Args:
+    output_dir: str = field(default="Helios")
+    seed: int = field(default=42)
+    report_to: ReportTo = field(default_factory=ReportTo)
+    data_config: DataConfig = field(default_factory=DataConfig)
+    model_config: ModelConfig = field(default_factory=ModelConfig)
+    validation_config: ValidationConfig = field(default_factory=ValidationConfig)
+    training_config: TrainingConfig = field(default_factory=TrainingConfig)
+    logging_dir: str = field(default="logs")

Helios/_DEV/helios/utils/utils_base.py

@@ -0,0 +1,745 @@
+import gc
+import html
+import math
+import os
+import random
+from typing import List, Literal, Optional, Union
+
+import ftfy
+import regex as re
+import torch
+from accelerate.logging import get_logger
+
+
+logger = get_logger(__name__)
+
+NORM_LAYER_PREFIXES = ["norm_q", "norm_k", "norm_added_q", "norm_added_k"]
+
+
+# ======================================== memory monitoring ========================================
+def get_memory_stats():
+    if torch.cuda.is_available():
+        allocated = torch.cuda.memory_allocated() / 1024**3  # GB
+        reserved = torch.cuda.memory_reserved() / 1024**3  # GB
+        max_allocated = torch.cuda.max_memory_allocated() / 1024**3
+        return {"allocated": allocated, "reserved": reserved, "max_allocated": max_allocated}
+    return None
+
+
+def reset_memory_stats():
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+        gc.collect()
+
+
+# ======================================== initialize ========================================
+def get_config_value(args, name):
+    if hasattr(args, name):
+        return getattr(args, name)
+    elif hasattr(args, "training_config") and hasattr(args.training_config, name):
+        return getattr(args.training_config, name)
+    else:
+        raise AttributeError(f"Neither args nor args.training_config has attribute '{name}'")
+
+
+def compare_configs(existing_conf, current_conf, path="", ignore_keys=None):
+    if ignore_keys is None:
+        ignore_keys = set()
+
+    mismatches = []
+
+    all_keys = set(existing_conf.keys()) | set(current_conf.keys())
+
+    for key in all_keys:
+        current_path = f"{path}.{key}" if path else key
+
+        if current_path in ignore_keys or key in ignore_keys:
+            continue
+
+        if key not in existing_conf:
+            mismatches.append(f"Key '{current_path}' missing in existing config")
+        elif key not in current_conf:
+            mismatches.append(f"Key '{current_path}' missing in current config")
+        else:
+            existing_val = existing_conf[key]
+            current_val = current_conf[key]
+
+            if isinstance(existing_val, dict) and isinstance(current_val, dict):
+                mismatches.extend(compare_configs(existing_val, current_val, current_path, ignore_keys))
+            elif existing_val != current_val:
+                mismatches.append(f"Key '{current_path}': existing={existing_val} vs current={current_val}")
+
+    return mismatches
+
+
+def get_optimizer(args, accelerator, params_to_optimize, use_deepspeed: bool = False):
+    # Use DeepSpeed optimizer
+    if use_deepspeed:
+        from accelerate.utils import DummyOptim
+
+        return DummyOptim(
+            params_to_optimize,
+            lr=args.training_config.learning_rate,
+            betas=(args.training_config.adam_beta1, args.training_config.adam_beta2),
+            eps=args.training_config.adam_epsilon,
+            weight_decay=args.training_config.adam_weight_decay,
+        )
+
+    # Optimizer creation
+    supported_optimizers = ["adam", "adamw", "prodigy"]
+    if args.training_config.optimizer.lower() not in supported_optimizers:
+        accelerator.print(
+            f"Unsupported choice of optimizer: {args.training_config.optimizer}. Supported optimizers include {supported_optimizers}. Defaulting to AdamW"
+        )
+        args.training_config.optimizer = "adamw"
+
+    if args.training_config.use_8bit_adam and args.training_config.optimizer.lower() not in ["adam", "adamw"]:
+        accelerator.print(
+            f"use_8bit_adam is ignored when optimizer is not set to 'AdamW'. Optimizer was "
+            f"set to {args.training_config.optimizer.lower()}"
+        )
+
+    if args.training_config.use_8bit_adam:
+        try:
+            import bitsandbytes as bnb
+        except ImportError:
+            raise ImportError(
+                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
+            )
+
+    if args.training_config.optimizer.lower() == "adamw":
+        optimizer_class = bnb.optim.AdamW8bit if args.training_config.use_8bit_adam else torch.optim.AdamW
+
+        optimizer = optimizer_class(
+            params_to_optimize,
+            betas=(args.training_config.adam_beta1, args.training_config.adam_beta2),
+            eps=args.training_config.adam_epsilon,
+            weight_decay=args.training_config.adam_weight_decay,
+        )
+    elif args.training_config.optimizer.lower() == "adam":
+        optimizer_class = bnb.optim.Adam8bit if args.training_config.use_8bit_adam else torch.optim.Adam
+
+        optimizer = optimizer_class(
+            params_to_optimize,
+            betas=(args.training_config.adam_beta1, args.training_config.adam_beta2),
+            eps=args.training_config.adam_epsilon,
+            weight_decay=args.training_config.adam_weight_decay,
+        )
+    elif args.training_config.optimizer.lower() == "prodigy":
+        try:
+            import prodigyopt
+        except ImportError:
+            raise ImportError("To use Prodigy, please install the prodigyopt library: `pip install prodigyopt`")
+
+        optimizer_class = prodigyopt.Prodigy
+
+        if args.training_config.learning_rate <= 0.1:
+            accelerator.print(
+                "Learning rate is too low. When using prodigy, it's generally better to set learning rate around 1.0"
+            )
+
+        optimizer = optimizer_class(
+            params_to_optimize,
+            betas=(args.training_config.adam_beta1, args.training_config.adam_beta2),
+            beta3=args.training_config.prodigy_beta3,
+            weight_decay=args.training_config.adam_weight_decay,
+            eps=args.training_config.adam_epsilon,
+            decouple=args.training_config.prodigy_decouple,
+            use_bias_correction=args.training_config.prodigy_use_bias_correction,
+            safeguard_warmup=args.training_config.prodigy_safeguard_warmup,
+        )
+
+    return optimizer
+
+
+# ======================================== checkpoints related ========================================
+def save_extra_components(args, model=None, model_state_dict=None, output_dir=None):
+    if model is None and model_state_dict is None:
+        raise ValueError("Either 'model' or 'model_state_dict' must be provided")
+
+    if output_dir is None:
+        raise ValueError("output_dir must be provided")
+
+    os.makedirs(output_dir, exist_ok=True)
+    state_dict = {}
+
+    # Determine whether to use model or model_state_dict
+    use_state_dict = model_state_dict is not None
+
+    # 1. Save patch_short, patch_mid, patch_long (formerly multi_term_memory_patchg)
+    if args.training_config.is_enable_stage1 and (
+        args.training_config.is_train_full_multi_term_memory_patchg
+        or args.training_config.is_train_lora_multi_term_memory_patchg
+    ):
+        patch_names = ["patch_short", "patch_mid", "patch_long"]
+
+        if use_state_dict:
+            # Extract from state_dict
+            for k, v in model_state_dict.items():
+                if any(k.startswith(f"{p}.") for p in patch_names):
+                    state_dict[k] = v.detach().clone().cpu() if torch.is_tensor(v) else v
+        else:
+            # Extract from model
+            for p in patch_names:
+                if hasattr(model, p):
+                    patch_module = getattr(model, p)
+                    for k, v in patch_module.state_dict().items():
+                        state_dict[f"{p}.{k}"] = v.detach().clone().cpu()
+
+    # 2. Save LoRA layers from all transformer blocks
+    if args.training_config.restrict_self_attn and args.training_config.is_train_restrict_lora:
+        if use_state_dict:
+            # Extract LoRA parameters from state_dict
+            for k, v in model_state_dict.items():
+                if any(lora_key in k for lora_key in [".q_loras.", ".k_loras.", ".v_loras."]):
+                    state_dict[k] = v.detach().clone().cpu() if torch.is_tensor(v) else v
+        else:
+            # Extract from model
+            for block_idx, block in enumerate(model.blocks):
+                if hasattr(block.attn1, "q_loras"):
+                    for k, v in block.attn1.q_loras.state_dict().items():
+                        state_dict[f"blocks.{block_idx}.attn1.q_loras.{k}"] = v.detach().clone().cpu()
+
+                if hasattr(block.attn1, "k_loras"):
+                    for k, v in block.attn1.k_loras.state_dict().items():
+                        state_dict[f"blocks.{block_idx}.attn1.k_loras.{k}"] = v.detach().clone().cpu()
+
+                if hasattr(block.attn1, "v_loras"):
+                    for k, v in block.attn1.v_loras.state_dict().items():
+                        state_dict[f"blocks.{block_idx}.attn1.v_loras.{k}"] = v.detach().clone().cpu()
+
+    # 3. Save History Scale parameters
+    if args.training_config.is_amplify_history:
+        if use_state_dict:
+            # Extract history_key_scale from state_dict
+            for k, v in model_state_dict.items():
+                if "history_key_scale" in k:
+                    state_dict[k] = v.detach().clone().cpu() if torch.is_tensor(v) else v
+        else:
+            # Extract from model
+            for block_idx, block in enumerate(model.blocks):
+                if hasattr(block.attn1, "history_key_scale"):
+                    state_dict[f"blocks.{block_idx}.attn1.history_key_scale"] = (
+                        block.attn1.history_key_scale.detach().clone().cpu()
+                    )
+
+    # 4. Save GAN parameters
+    if args.training_config.is_use_gan:
+        if use_state_dict:
+            # Extract GAN parameters from state_dict
+            for k, v in model_state_dict.items():
+                if k.startswith("gan_heads.") or k.startswith("gan_final_head."):
+                    state_dict[k] = v.detach().clone().cpu() if torch.is_tensor(v) else v
+        else:
+            # Extract from model
+            if hasattr(model, "gan_heads"):
+                for hook_name, gan_head in model.gan_heads.items():
+                    for k, v in gan_head.state_dict().items():
+                        state_dict[f"gan_heads.{hook_name}.{k}"] = v.detach().clone().cpu()
+
+            if hasattr(model, "gan_final_head"):
+                for k, v in model.gan_final_head.state_dict().items():
+                    state_dict[f"gan_final_head.{k}"] = v.detach().clone().cpu()
+
+    torch.save(state_dict, os.path.join(output_dir, "transformer_partial.pth"))
+    print(f"Saved checkpoint with {len(state_dict)} parameters to {output_dir}/transformer_partial.pth")
+
+
+def load_extra_components(args, model, checkpoint_path):
+    """
+    Load patch_short, patch_mid, patch_long, q_loras, k_loras, v_loras into the model
+    """
+    state_dict = torch.load(checkpoint_path, map_location="cpu")
+    loaded_keys = set()
+
+    # Load patch modules (formerly multi_term_memory_patchg)
+    if args.training_config.is_enable_stage1:
+        patch_names = ["patch_short", "patch_mid", "patch_long"]
+
+        for p_name in patch_names:
+            patch_keys_in_sd = [k for k in state_dict.keys() if k.startswith(f"{p_name}.")]
+            if patch_keys_in_sd and hasattr(model, p_name):
+                patch_state = {
+                    k.replace(f"{p_name}.", ""): v for k, v in state_dict.items() if k.startswith(f"{p_name}.")
+                }
+                patch_module = getattr(model, p_name)
+                load_info = patch_module.load_state_dict(patch_state, strict=False)
+                loaded_keys.update(patch_keys_in_sd)
+
+                print(f"Loaded {len(patch_keys_in_sd)} parameters for {p_name}")
+                if load_info.missing_keys:
+                    print(f"  Missing keys in {p_name}: {load_info.missing_keys}")
+                if load_info.unexpected_keys:
+                    print(f"  Unexpected keys in {p_name}: {load_info.unexpected_keys}")
+
+    # Load LoRA layers
+    lora_keys_count = 0
+    if args.training_config.restrict_self_attn:
+        for block_idx, block in enumerate(model.blocks):
+            # Load q_loras
+            q_lora_keys_in_sd = [k for k in state_dict.keys() if k.startswith(f"blocks.{block_idx}.attn1.q_loras.")]
+            if q_lora_keys_in_sd:
+                q_lora_state = {
+                    k.replace(f"blocks.{block_idx}.attn1.q_loras.", ""): v
+                    for k, v in state_dict.items()
+                    if k.startswith(f"blocks.{block_idx}.attn1.q_loras.")
+                }
+                load_info = block.attn1.q_loras.load_state_dict(q_lora_state, strict=False)
+                loaded_keys.update(q_lora_keys_in_sd)
+                lora_keys_count += len(q_lora_keys_in_sd)
+                if load_info.missing_keys:
+                    print(f"  Missing keys in blocks.{block_idx}.attn1.q_loras: {load_info.missing_keys}")
+                if load_info.unexpected_keys:
+                    print(f"  Unexpected keys in blocks.{block_idx}.attn1.q_loras: {load_info.unexpected_keys}")
+
+            # Load k_loras
+            k_lora_keys_in_sd = [k for k in state_dict.keys() if k.startswith(f"blocks.{block_idx}.attn1.k_loras.")]
+            if k_lora_keys_in_sd:
+                k_lora_state = {
+                    k.replace(f"blocks.{block_idx}.attn1.k_loras.", ""): v
+                    for k, v in state_dict.items()
+                    if k.startswith(f"blocks.{block_idx}.attn1.k_loras.")
+                }
+                load_info = block.attn1.k_loras.load_state_dict(k_lora_state, strict=False)
+                loaded_keys.update(k_lora_keys_in_sd)
+                lora_keys_count += len(k_lora_keys_in_sd)
+                if load_info.missing_keys:
+                    print(f"  Missing keys in blocks.{block_idx}.attn1.k_loras: {load_info.missing_keys}")
+                if load_info.unexpected_keys:
+                    print(f"  Unexpected keys in blocks.{block_idx}.attn1.k_loras: {load_info.unexpected_keys}")
+
+            # Load v_loras
+            v_lora_keys_in_sd = [k for k in state_dict.keys() if k.startswith(f"blocks.{block_idx}.attn1.v_loras.")]
+            if v_lora_keys_in_sd:
+                v_lora_state = {
+                    k.replace(f"blocks.{block_idx}.attn1.v_loras.", ""): v
+                    for k, v in state_dict.items()
+                    if k.startswith(f"blocks.{block_idx}.attn1.v_loras.")
+                }
+                load_info = block.attn1.v_loras.load_state_dict(v_lora_state, strict=False)
+                loaded_keys.update(v_lora_keys_in_sd)
+                lora_keys_count += len(v_lora_keys_in_sd)
+                if load_info.missing_keys:
+                    print(f"  Missing keys in blocks.{block_idx}.attn1.v_loras: {load_info.missing_keys}")
+                if load_info.unexpected_keys:
+                    print(f"  Unexpected keys in blocks.{block_idx}.attn1.v_loras: {load_info.unexpected_keys}")
+
+        print(f"Loaded {lora_keys_count} parameters for Restrict Self Attn LoRA")
+
+    # Load History Scale layers
+    history_keys_count = 0
+    if args.training_config.is_amplify_history:
+        for block_idx, block in enumerate(model.blocks):
+            history_key_scale_key = f"blocks.{block_idx}.attn1.history_key_scale"
+            if history_key_scale_key in state_dict:
+                block.attn1.history_key_scale.data = state_dict[history_key_scale_key].to(
+                    block.attn1.history_key_scale.device
+                )
+                loaded_keys.add(history_key_scale_key)
+                history_keys_count += 1
+
+        print(f"Loaded {history_keys_count} parameters for History Scale")
+
+    # Load GAN
+    gan_keys_count = 0
+    if args.training_config.is_use_gan:
+        # Load intermediate gan_heads
+        if hasattr(model, "gan_heads"):
+            for hook_name, gan_head in model.gan_heads.items():
+                gan_head_prefix = f"gan_heads.{hook_name}."
+                gan_head_keys_in_sd = [k for k in state_dict.keys() if k.startswith(gan_head_prefix)]
+
+                if gan_head_keys_in_sd:
+                    gan_head_state = {
+                        k.replace(gan_head_prefix, ""): v
+                        for k, v in state_dict.items()
+                        if k.startswith(gan_head_prefix)
+                    }
+                    load_info = gan_head.load_state_dict(gan_head_state, strict=False)
+                    loaded_keys.update(gan_head_keys_in_sd)
+                    gan_keys_count += len(gan_head_keys_in_sd)
+                    if load_info.missing_keys:
+                        print(f"  Missing keys in gan_heads.{hook_name}: {load_info.missing_keys}")
+                    if load_info.unexpected_keys:
+                        print(f"  Unexpected keys in gan_heads.{hook_name}: {load_info.unexpected_keys}")
+
+        # Load final gan head
+        if hasattr(model, "gan_final_head"):
+            gan_final_keys_in_sd = [k for k in state_dict.keys() if k.startswith("gan_final_head.")]
+
+            if gan_final_keys_in_sd:
+                gan_final_state = {
+                    k.replace("gan_final_head.", ""): v
+                    for k, v in state_dict.items()
+                    if k.startswith("gan_final_head.")
+                }
+                load_info = model.gan_final_head.load_state_dict(gan_final_state, strict=False)
+                loaded_keys.update(gan_final_keys_in_sd)
+                gan_keys_count += len(gan_final_keys_in_sd)
+                if load_info.missing_keys:
+                    print(f"  Missing keys in gan_final_head: {load_info.missing_keys}")
+                if load_info.unexpected_keys:
+                    print(f"  Unexpected keys in gan_final_head: {load_info.unexpected_keys}")
+
+        if gan_keys_count > 0:
+            print(f"Loaded {gan_keys_count} parameters for GAN components")
+
+    if not loaded_keys:
+        print("No extra components were loaded from the checkpoint.")
+        return
+
+    all_sd_keys = set(state_dict.keys())
+    unmatched_keys = all_sd_keys - loaded_keys
+
+    print("\nCheckpoint loading completed.")
+    print(f"Total loaded keys: {len(loaded_keys)}")
+    if unmatched_keys:
+        print(f"The following keys in the checkpoint were not loaded into the model: {sorted(unmatched_keys)}\n")
+    else:
+        print("Load extra module successfully! All keys in the checkpoint were successfully processed or matched.\n")
+
+
+def save_model_checkpoint(
+    transformer,
+    args,
+    save_path,
+    weight_dtype=None,
+    unwrap_model_fn=None,
+    get_peft_model_state_dict_fn=None,
+    collate_lora_metadata_fn=None,
+    save_extra_components_fn=None,
+    pipeline_class=None,
+    norm_layer_prefixes=None,
+):
+    modules_to_save = {}
+    model_to_save = unwrap_model_fn(transformer) if unwrap_model_fn else transformer
+
+    transformer_lora_layers = get_peft_model_state_dict_fn(model_to_save)
+
+    if args.model_config.train_norm_layers:
+        norm_prefixes = norm_layer_prefixes or []
+        transformer_norm_layers = {
+            f"transformer.{name}": param
+            for name, param in model_to_save.named_parameters()
+            if any(k in name for k in norm_prefixes)
+        }
+        transformer_lora_layers = {
+            **transformer_lora_layers,
+            **transformer_norm_layers,
+        }
+
+    modules_to_save["transformer"] = model_to_save
+
+    if pipeline_class and hasattr(pipeline_class, "save_lora_weights"):
+        lora_metadata = collate_lora_metadata_fn(modules_to_save) if collate_lora_metadata_fn else {}
+        pipeline_class.save_lora_weights(
+            save_directory=save_path,
+            transformer_lora_layers=transformer_lora_layers,
+            **lora_metadata,
+        )
+
+    if save_extra_components_fn:
+        save_extra_components_fn(args=args, model=model_to_save, output_dir=save_path)
+
+    modules_to_save = None
+    lora_metadata = None
+    transformer_norm_layers = None
+    transformer_lora_layers = None
+    del modules_to_save
+    del lora_metadata
+    del transformer_norm_layers
+    del transformer_lora_layers
+
+
+def load_model_checkpoint(
+    args,
+    checkpoint_path,
+    transformer,
+    pipeline_class=None,
+    norm_layer_prefixes=None,
+    convert_unet_state_dict_to_peft_fn=None,
+    set_peft_model_state_dict_fn=None,
+    cast_training_params_fn=None,
+):
+    if not os.path.exists(checkpoint_path):
+        raise ValueError(f"Checkpoint path does not exist: {checkpoint_path}")
+
+    lora_state_dict = None
+    if pipeline_class and hasattr(pipeline_class, "load_lora_weights"):
+        lora_state_dict = pipeline_class.lora_state_dict(checkpoint_path)
+
+        transformer_state_dict = {
+            f"{k.replace('transformer.', '')}": v for k, v in lora_state_dict.items() if k.startswith("transformer.")
+        }
+        transformer_state_dict = convert_unet_state_dict_to_peft_fn(transformer_state_dict)
+        incompatible_keys = set_peft_model_state_dict_fn(transformer, transformer_state_dict, adapter_name="default")
+        if incompatible_keys is not None:
+            unexpected_keys = getattr(incompatible_keys, "unexpected_keys", None)
+            if unexpected_keys:
+                print(
+                    f"Loading adapter weights from state_dict led to unexpected keys not found in the model: "
+                    f" {unexpected_keys}. "
+                )
+        print(f"load lora from {checkpoint_path} successfully!")
+
+    if args.model_config.train_norm_layers and lora_state_dict and norm_layer_prefixes:
+        transformer_norm_state_dict = {
+            k: v
+            for k, v in lora_state_dict.items()
+            if k.startswith("transformer.") and any(norm_k in k for norm_k in norm_layer_prefixes)
+        }
+        transformer._transformer_norm_layers = pipeline_class._load_norm_into_transformer(
+            transformer_norm_state_dict,
+            transformer=transformer,
+            discard_original_layers=False,
+        )
+
+    load_extra_components(args, transformer, os.path.join(checkpoint_path, "transformer_partial.pth"))
+
+    if args.training_config.mixed_precision != "fp32":
+        models = [transformer]
+        cast_training_params_fn(models)
+
+
+# ======================================== sigmas & timesteps ========================================
+def get_sigmas(noise_scheduler, timesteps, n_dim=4, device="cuda", dtype=torch.float32):
+    sigmas = noise_scheduler.sigmas.to(device=device, dtype=dtype)
+    schedule_timesteps = noise_scheduler.timesteps.to(device)
+    timesteps = timesteps.to(device)
+    step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
+
+    sigma = sigmas[step_indices].flatten()
+    while len(sigma.shape) < n_dim:
+        sigma = sigma.unsqueeze(-1)
+    return sigma
+
+
+def calculate_shift(
+    image_seq_len,
+    base_seq_len: int = 256,
+    max_seq_len: int = 4096,
+    base_shift: float = 0.5,
+    max_shift: float = 1.15,
+):
+    m = (max_shift - base_shift) / (max_seq_len - base_seq_len)
+    b = base_shift - m * base_seq_len
+    mu = image_seq_len * m + b
+    return mu
+
+
+def apply_schedule_shift(
+    sigmas,
+    noise,
+    sigmas_two=None,
+    base_seq_len: int = 256,
+    max_seq_len: int = 4096,
+    base_shift: float = 0.5,
+    max_shift: float = 1.15,
+    exp_max: float = 7.0,
+    time_shift_type: Literal["exponential", "linear"] = "linear",
+    mu: float = None,
+    return_mu: bool = False,
+):
+    if mu is None:
+        # Resolution-dependent shifting of timestep schedules as per section 5.3.2 of SD3 paper
+        image_seq_len = (noise.shape[-1] * noise.shape[-2] * noise.shape[-3]) // 4  # patch size 1,2,2
+        mu = calculate_shift(
+            image_seq_len,
+            base_seq_len if base_seq_len is not None else 256,
+            max_seq_len if max_seq_len is not None else 4096,
+            base_shift if base_shift is not None else 0.5,
+            max_shift if max_shift is not None else 1.15,
+        )
+        if time_shift_type == "exponential":
+            mu = min(mu, math.log(exp_max))
+            mu = math.exp(mu)
+
+    if sigmas_two is not None:
+        sigmas = (sigmas * mu) / (1 + (mu - 1) * sigmas)
+        sigmas_two = (sigmas_two * mu) / (1 + (mu - 1) * sigmas_two)
+        if return_mu:
+            return sigmas, sigmas_two, mu
+        else:
+            return sigmas, sigmas_two
+    else:
+        sigmas = (sigmas * mu) / (1 + (mu - 1) * sigmas)
+        if return_mu:
+            return sigmas, mu
+        else:
+            return sigmas
+
+
+# ======================================== clean prompt ========================================
+
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+    return text
+
+
+def prompt_clean(text):
+    text = whitespace_clean(basic_clean(text))
+    return text
+
+
+def _get_t5_prompt_embeds(
+    tokenizer,
+    text_encoder,
+    prompt: Union[str, List[str]] = None,
+    num_videos_per_prompt: int = 1,
+    max_sequence_length: int = 512,
+    caption_dropout_p: float = 0.0,
+    device: Optional[torch.device] = "cuda",
+    dtype: Optional[torch.dtype] = torch.bfloat16,
+):
+    device = device
+    dtype = dtype
+
+    prompt = [prompt] if isinstance(prompt, str) else prompt
+    prompt = [prompt_clean(u) for u in prompt]
+    batch_size = len(prompt)
+
+    text_inputs = tokenizer(
+        prompt,
+        padding="max_length",
+        max_length=max_sequence_length,
+        truncation=True,
+        add_special_tokens=True,
+        return_attention_mask=True,
+        return_tensors="pt",
+    )
+    text_input_ids, mask = text_inputs.input_ids, text_inputs.attention_mask
+
+    prompt_embeds = text_encoder(text_input_ids.to(device), mask.to(device)).last_hidden_state
+    prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
+
+    if random.random() < caption_dropout_p:
+        prompt_embeds.fill_(0)
+        mask.fill_(False)
+    seq_lens = mask.gt(0).sum(dim=1).long()
+
+    prompt_embeds = [u[:v] for u, v in zip(prompt_embeds, seq_lens)]
+    prompt_embeds = torch.stack(
+        [torch.cat([u, u.new_zeros(max_sequence_length - u.size(0), u.size(1))]) for u in prompt_embeds], dim=0
+    )
+
+    # duplicate text embeddings for each generation per prompt, using mps friendly method
+    _, seq_len, _ = prompt_embeds.shape
+    prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
+    prompt_embeds = prompt_embeds.view(batch_size * num_videos_per_prompt, seq_len, -1)
+
+    return prompt_embeds, text_inputs.attention_mask
+
+
+def encode_prompt(
+    tokenizer,
+    text_encoder,
+    prompt: Union[str, List[str]],
+    num_videos_per_prompt: int = 1,
+    prompt_embeds: Optional[torch.Tensor] = None,
+    max_sequence_length: int = 512,
+    caption_dropout_p: float = 0.0,
+    device: Optional[torch.device] = "cuda",
+    dtype: Optional[torch.dtype] = torch.bfloat16,
+):
+    prompt = [prompt] if isinstance(prompt, str) else prompt
+
+    if prompt_embeds is None:
+        prompt_embeds, prompt_attention_mask = _get_t5_prompt_embeds(
+            tokenizer,
+            text_encoder,
+            prompt=prompt,
+            num_videos_per_prompt=num_videos_per_prompt,
+            max_sequence_length=max_sequence_length,
+            caption_dropout_p=caption_dropout_p,
+            device=device,
+            dtype=dtype,
+        )
+
+    return prompt_embeds, prompt_attention_mask
+
+
+# ======================================== other techniques ========================================
+
+
+class AdaptiveAntiDrifting:
+    def __init__(
+        self,
+        rho_mu: float = 0.9,
+        rho_sigma: float = 0.9,
+        delta_mu: float = 0.15,
+        delta_sigma: float = 0.15,
+        device: torch.device = None,
+        dtype: torch.dtype = torch.float32,
+    ):
+        """
+        Args:
+            rho_mu: EMA coefficient for mean (momentum parameter)
+            rho_sigma: EMA coefficient for variance (momentum parameter)
+            delta_mu: Threshold for mean drift detection
+            delta_sigma: Threshold for variance drift detection
+            device: Device for tensor operations
+            dtype: Data type for tensors
+        """
+        self.rho_mu = rho_mu
+        self.rho_sigma = rho_sigma
+        self.delta_mu = delta_mu
+        self.delta_sigma = delta_sigma
+        self.device = device
+        self.dtype = dtype
+
+        # Global statistics (initialized on first chunk)
+        self.global_mean = None
+        self.global_var = None
+        self.is_initialized = False
+
+    def compute_latent_statistics(self, latent_chunk: torch.Tensor) -> tuple:
+        # Shape: (B, C, T, H, W) -> (B, C)
+        mean = latent_chunk.mean(dim=[2, 3, 4])
+        var = latent_chunk.var(dim=[2, 3, 4])
+
+        return mean, var
+
+    def update_global_statistics(self, current_mean: torch.Tensor, current_var: torch.Tensor):
+        if not self.is_initialized:
+            self.global_mean = current_mean.clone()
+            self.global_var = current_var.clone()
+            self.is_initialized = True
+        else:
+            self.global_mean = self.rho_mu * self.global_mean + (1 - self.rho_mu) * current_mean
+            self.global_var = self.rho_sigma * self.global_var + (1 - self.rho_sigma) * current_var
+
+    def detect_drift(self, current_mean: torch.Tensor, current_var: torch.Tensor) -> bool:
+        if not self.is_initialized:
+            return False
+
+        mean_drift = torch.norm(current_mean - self.global_mean, p=2, dim=-1).mean().item()
+        var_drift = torch.norm(current_var - self.global_var, p=2, dim=-1).mean().item()
+
+        has_drift = (mean_drift > self.delta_mu) and (var_drift > self.delta_sigma)
+
+        return has_drift
+
+    def apply_frame_aware_corruption(
+        self,
+        history_latents: torch.Tensor,
+        corruption_strength: float = 0.1,
+        generator: Optional[torch.Generator] = None,
+    ) -> torch.Tensor:
+        noise = torch.randn_like(history_latents, generator=generator, device=history_latents.device)
+        corrupted_latents = history_latents + corruption_strength * noise
+
+        return corrupted_latents
+
+    def reset(self):
+        self.global_mean = None
+        self.global_var = None
+        self.is_initialized = False

Helios/_DEV/helios/utils/utils_helios_base.py

@@ -0,0 +1,1091 @@
+import random
+
+import torch
+import torch.nn.functional as F
+from accelerate.logging import get_logger
+from einops import rearrange
+
+from diffusers.training_utils import compute_density_for_timestep_sampling, compute_loss_weighting_for_sd3, free_memory
+
+from .utils_base import apply_schedule_shift, get_config_value
+from .utils_recycle_batch import apply_error_injection, process_and_update_error_buffers
+
+
+logger = get_logger(__name__)
+
+
+# ======================================== flow loss ========================================
+
+
+def _flow_loss(
+    args,
+    accelerator,
+    lr_scheduler,
+    transformer,
+    prompt_embeds,
+    prompt_attention_masks,
+    noisy_model_input_list,
+    sigmas_list,
+    timesteps_list,
+    targets_list,
+    indices_hidden_states,
+    latents_history_short,
+    indices_latents_history_short,
+    latents_history_mid,
+    indices_latents_history_mid,
+    latents_history_long,
+    indices_latents_history_long,
+    recycle_vars,
+    global_step,
+    noise_scheduler_copy,
+    use_clean_input,
+):
+    assert len(noisy_model_input_list) == len(sigmas_list) == len(timesteps_list) == len(targets_list)
+
+    for noisy_model_input, sigmas, timesteps, target in zip(
+        noisy_model_input_list, sigmas_list, timesteps_list, targets_list
+    ):
+        # ----- w/o mini batch ------
+        model_pred = transformer(
+            hidden_states=noisy_model_input,
+            timestep=timesteps,
+            encoder_hidden_states=prompt_embeds,
+            indices_hidden_states=indices_hidden_states,  # torch.Size([2, 9])
+            indices_latents_history_short=indices_latents_history_short,  # torch.Size([2, 2])
+            indices_latents_history_mid=indices_latents_history_mid,  # torch.Size([2, 2])
+            indices_latents_history_long=indices_latents_history_long,  # torch.Size([2, 16])
+            latents_history_short=latents_history_short,  # torch.Size([2, 16, 2, 60, 104])
+            latents_history_mid=latents_history_mid,  # torch.Size([2, 16, 2, 60, 104])
+            latents_history_long=latents_history_long,  # torch.Size([2, 16, 16, 60, 104])
+            return_dict=False,
+        )[0]
+
+        # Compute regular loss.
+        if isinstance(model_pred, list):
+            loss_list = []
+            for cur_model_pred, cur_target, cur_sigmas in zip(model_pred, target, sigmas):
+                cur_weighting = compute_loss_weighting_for_sd3(
+                    weighting_scheme=args.training_config.weighting_scheme, sigmas=cur_sigmas
+                )
+                loss = torch.mean(
+                    (cur_weighting.float() * (cur_model_pred.float() - cur_target.float()) ** 2).reshape(
+                        cur_target.shape[0], -1
+                    ),
+                    1,
+                ).mean()
+                loss_list.append(loss)
+            loss = torch.stack(loss_list, dim=0).mean()
+            del loss_list
+        else:
+            # these weighting schemes use a uniform timestep sampling
+            # and instead post-weight the loss
+            weighting = compute_loss_weighting_for_sd3(
+                weighting_scheme=args.training_config.weighting_scheme, sigmas=sigmas
+            )
+
+            loss = torch.mean(
+                (weighting.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1),
+                1,
+            ).mean()
+
+        # loss = loss * (batch_size / total_sample_count)
+        assert loss.requires_grad, f"Loss should have gradient! Got {loss.requires_grad}"
+        assert loss.grad_fn is not None, "Loss should have grad_fn!"
+        accelerator.backward(loss)
+
+        if args.training_config.use_error_recycling:
+            if isinstance(model_pred, list):
+                with torch.no_grad():
+                    for cur_model_pred, cur_target, cur_timesteps, cur_noisy_model_input in zip(
+                        model_pred, target, timesteps, noisy_model_input
+                    ):
+                        process_and_update_error_buffers(
+                            args,
+                            recycle_vars,
+                            accelerator,
+                            global_step,
+                            noise_scheduler_copy,
+                            cur_model_pred,
+                            cur_target,
+                            cur_timesteps,
+                            cur_noisy_model_input,
+                            use_clean_input,
+                        )
+            else:
+                with torch.no_grad():
+                    process_and_update_error_buffers(
+                        args,
+                        recycle_vars,
+                        accelerator,
+                        global_step,
+                        noise_scheduler_copy,
+                        model_pred,
+                        target,
+                        timesteps,
+                        noisy_model_input,
+                        use_clean_input,
+                    )
+
+    # Check if the gradient of each model parameter contains NaN
+    for name, param in transformer.named_parameters():
+        if param.grad is not None and torch.isnan(param.grad).any():
+            logger.error(f"Gradient for {name} contains NaN!")
+
+    grad_norm = None
+    if accelerator.sync_gradients:
+        params_to_clip = transformer.parameters()
+        grad_norm = accelerator.clip_grad_norm_(params_to_clip, args.training_config.max_grad_norm)
+
+    logs = {
+        "loss": loss.detach().item(),
+        "lr": lr_scheduler.get_last_lr()[0],
+    }
+    if grad_norm is not None:
+        logs["grad_norm"] = grad_norm.item() if hasattr(grad_norm, "item") else grad_norm
+
+    del noisy_model_input_list
+    del sigmas_list
+    del timesteps_list
+    del targets_list
+    del noisy_model_input
+    del timesteps
+    del prompt_embeds
+    del prompt_attention_masks
+    del indices_hidden_states
+    del latents_history_short
+    del indices_latents_history_short
+    del latents_history_mid
+    del indices_latents_history_mid
+    del latents_history_long
+    del indices_latents_history_long
+    del model_pred
+    del target
+    del loss
+    free_memory()
+
+    return logs
+
+
+# ======================================== easy anti-drifting ========================================
+
+
+def downsample_corrupt(model_input, downsample_min_corrupt_ratio, downsample_max_corrupt_ratio):
+    corrupt_ratio = random.uniform(downsample_min_corrupt_ratio, downsample_max_corrupt_ratio)
+
+    is_5d = model_input.ndim == 5
+
+    if is_5d:
+        B, C, T, H, W = model_input.shape
+        model_input = model_input.permute(0, 2, 1, 3, 4).reshape(B * T, C, H, W)
+    else:
+        B, C, H, W = model_input.shape
+
+    h0, w0 = model_input.shape[-2:]
+
+    h1 = max(1, int(round(h0 * corrupt_ratio)))
+    w1 = max(1, int(round(w0 * corrupt_ratio)))
+
+    model_input = F.interpolate(model_input, size=(h1, w1), mode="bilinear", align_corners=False, antialias=True)
+
+    model_input = F.interpolate(model_input, size=(h0, w0), mode="bilinear", align_corners=False, antialias=True)
+
+    if is_5d:
+        model_input = model_input.reshape(B, T, C, H, W).permute(0, 2, 1, 3, 4)
+
+    return model_input
+
+
+def get_corrupt_noise_sigma(model_input, batch_size, corrupt_ratio=1 / 3, num_frames=None, is_frame_independent=False):
+    if is_frame_independent:
+        noise_sigma_shape = (batch_size, 1, num_frames)
+    else:
+        noise_sigma_shape = (batch_size,)
+    noise_sigma = (
+        torch.rand(size=noise_sigma_shape, device=model_input.device, dtype=model_input.dtype) * corrupt_ratio
+    )
+    while len(noise_sigma.shape) < model_input.ndim:
+        noise_sigma = noise_sigma.unsqueeze(-1)
+    return noise_sigma
+
+
+def corrupt_model_input(
+    model_input,
+    # choose mode
+    corrupt_mode="noise",  # "noise" | "downsample" | "random"
+    noise_mode_prob=0.9,  # when corrupt_mode="random", select the probability of noise (select downsample for the remaining probability).
+    # for noise
+    is_frame_independent=False,
+    is_chunk_independent=False,
+    noise_corrupt_ratio=1 / 3,
+    noise_corrupt_clean_prob=0.1,
+    # for downsample
+    downsample_min_corrupt_ratio=0.9,
+    downsample_max_corrupt_ratio=1.0,
+):
+    assert not (is_frame_independent and is_chunk_independent), (
+        "is_frame_independent and is_chunk_independent cannot both be True"
+    )
+    assert corrupt_mode in ("noise", "downsample", "random"), (
+        f"corrupt_mode must be 'noise', 'downsample', or 'random', got '{corrupt_mode}'"
+    )
+
+    # ==================== choose mode ====================
+    if corrupt_mode == "random":
+        mode = "noise" if random.random() < noise_mode_prob else "downsample"
+    else:
+        mode = corrupt_mode
+
+    # ==================== downsample branch ====================
+    if mode == "downsample":
+        model_input = downsample_corrupt(
+            model_input=model_input,
+            downsample_min_corrupt_ratio=downsample_min_corrupt_ratio,
+            downsample_max_corrupt_ratio=downsample_max_corrupt_ratio,
+        )
+        return model_input
+
+    # ==================== noise branch ====================
+    clean_random = random.random()
+    if clean_random < noise_corrupt_clean_prob:
+        return model_input
+
+    noise_sigma = get_corrupt_noise_sigma(
+        model_input=model_input,
+        batch_size=model_input.shape[0],
+        corrupt_ratio=noise_corrupt_ratio,
+        num_frames=model_input.shape[2],
+        is_frame_independent=is_frame_independent,
+    )
+
+    model_input = noise_sigma * torch.randn_like(model_input) + (1 - noise_sigma) * model_input
+
+    return model_input
+
+
+def corrupt_history_latents(
+    latents_history_short,
+    latents_history_mid,
+    latents_history_long,
+    latent_window_size,
+    is_keep_x0=True,
+    # choose mode
+    corrupt_mode="noise",  # "noise" | "downsample" | "random"
+    noise_mode_prob=0.9,  # when corrupt_mode="random", select the probability of noise (select downsample for the remaining probability).
+    # for noise
+    is_frame_independent=False,
+    is_chunk_independent=False,
+    corrupt_ratio_1x=1 / 3,
+    corrupt_ratio_2x=1 / 3,
+    corrupt_ratio_4x=1 / 3,
+    noise_corrupt_clean_prob=0.1,
+    # for downsample
+    downsample_min_corrupt_ratio=0.9,
+    downsample_max_corrupt_ratio=1.0,
+):
+    assert not (is_frame_independent and is_chunk_independent), (
+        "is_frame_independent and is_chunk_independent cannot both be True"
+    )
+    assert corrupt_mode in ("noise", "downsample", "random"), (
+        f"corrupt_mode must be 'noise', 'downsample', or 'random', got '{corrupt_mode}'"
+    )
+
+    clean_random = random.random()
+    if clean_random < noise_corrupt_clean_prob:
+        return latents_history_short, latents_history_mid, latents_history_long
+    
+    # ==================== choose mode ====================
+    if corrupt_mode == "random":
+        mode = "noise" if random.random() < noise_mode_prob else "downsample"
+    else:
+        mode = corrupt_mode
+
+    # ==================== noise branch ====================
+    if mode == "noise":
+        batch_size = latents_history_short.shape[0]
+        if not is_frame_independent and not is_chunk_independent:
+            noise_sigma = get_corrupt_noise_sigma(
+                model_input=latents_history_short, batch_size=batch_size, corrupt_ratio=corrupt_ratio_1x
+            )
+
+    len_4x = latents_history_long.shape[2]
+    len_2x = latents_history_mid.shape[2]
+    len_1x = latents_history_short.shape[2]
+
+    hist_seq_len = len_4x + len_2x + len_1x
+    hist_seq_len_copy = hist_seq_len
+
+    ori_len_1x = len_1x
+    if is_keep_x0:
+        len_1x -= 1
+        hist_seq_len -= 1
+        begin_num = 1
+    else:
+        begin_num = 0
+
+    max_windows = hist_seq_len // latent_window_size
+    tail_num = hist_seq_len % latent_window_size
+
+    assert hist_seq_len_copy == tail_num + max_windows * latent_window_size + begin_num
+
+    tail_latents_history = None
+    begin_latents_history = None
+
+    if tail_num != 0:
+        tail_latents_history = latents_history_long[:, :, :tail_num, :, :]
+        latents_history_long = latents_history_long[:, :, tail_num:, :, :]
+        if tail_latents_history.sum() != 0:
+            if mode == "downsample":
+                tail_latents_history = downsample_corrupt(
+                    model_input=tail_latents_history,
+                    downsample_min_corrupt_ratio=downsample_min_corrupt_ratio,
+                    downsample_max_corrupt_ratio=downsample_max_corrupt_ratio,
+                )
+            else:
+                noise_sigma = get_corrupt_noise_sigma(
+                    model_input=latents_history_short,
+                    batch_size=batch_size,
+                    corrupt_ratio=corrupt_ratio_4x,
+                    num_frames=tail_latents_history.shape[2],
+                    is_frame_independent=is_frame_independent,
+                )
+                tail_latents_history = (
+                    noise_sigma * torch.randn_like(tail_latents_history) + (1 - noise_sigma) * tail_latents_history
+                )
+
+    if begin_num != 0:
+        begin_latents_history = latents_history_short[:, :, :begin_num, :, :]
+        latents_history_short = latents_history_short[:, :, begin_num:, :, :]
+        if begin_latents_history.sum() != 0:
+            if mode == "downsample":
+                begin_latents_history = downsample_corrupt(
+                    model_input=begin_latents_history,
+                    downsample_min_corrupt_ratio=downsample_min_corrupt_ratio,
+                    downsample_max_corrupt_ratio=downsample_max_corrupt_ratio,
+                )
+            else:
+                noise_sigma = get_corrupt_noise_sigma(
+                    model_input=latents_history_short,
+                    batch_size=batch_size,
+                    corrupt_ratio=corrupt_ratio_1x,
+                    num_frames=begin_latents_history.shape[2],
+                    is_frame_independent=is_frame_independent,
+                )
+                begin_latents_history = (
+                    noise_sigma * torch.randn_like(begin_latents_history) + (1 - noise_sigma) * begin_latents_history
+                )
+
+    mid_latents_history = torch.cat([latents_history_long, latents_history_mid, latents_history_short], dim=2)
+    window_num = mid_latents_history.shape[2] // latent_window_size
+    assert mid_latents_history.shape[2] % latent_window_size == 0, (
+        f"mid length {mid_latents_history.shape[2]} not divisible by window size {latent_window_size}"
+    )
+
+    seq_begin = 0
+    for idx in range(window_num):
+        seq_end = seq_begin + latent_window_size
+        if mid_latents_history[:, :, seq_begin:seq_end, :, :].sum() != 0:
+            if idx == window_num - 1:
+                len_2x_end = seq_begin + len_2x
+                if mode == "downsample":
+                    mid_latents_history[:, :, seq_begin:len_2x_end, :, :] = downsample_corrupt(
+                        model_input=mid_latents_history[:, :, seq_begin:len_2x_end, :, :],
+                        downsample_min_corrupt_ratio=downsample_min_corrupt_ratio,
+                        downsample_max_corrupt_ratio=downsample_max_corrupt_ratio,
+                    )
+                else:
+                    noise_sigma_4x = get_corrupt_noise_sigma(
+                        model_input=latents_history_short,
+                        batch_size=batch_size,
+                        corrupt_ratio=corrupt_ratio_4x,
+                        num_frames=len_2x,
+                        is_frame_independent=is_frame_independent,
+                    )
+                    mid_latents_history[:, :, seq_begin:len_2x_end, :, :] = (
+                        noise_sigma_4x * torch.randn_like(mid_latents_history[:, :, seq_begin:len_2x_end, :, :])
+                        + (1 - noise_sigma_4x) * mid_latents_history[:, :, seq_begin:len_2x_end, :, :]
+                    )
+
+                remaining_frames = seq_end - len_2x_end
+                if mode == "downsample":
+                    mid_latents_history[:, :, len_2x_end:seq_end, :, :] = downsample_corrupt(
+                        model_input=mid_latents_history[:, :, len_2x_end:seq_end, :, :],
+                        downsample_min_corrupt_ratio=downsample_min_corrupt_ratio,
+                        downsample_max_corrupt_ratio=downsample_max_corrupt_ratio,
+                    )
+                else:
+                    noise_sigma_2x = get_corrupt_noise_sigma(
+                        model_input=latents_history_short,
+                        batch_size=batch_size,
+                        corrupt_ratio=corrupt_ratio_2x,
+                        num_frames=remaining_frames,
+                        is_frame_independent=is_frame_independent,
+                    )
+                    mid_latents_history[:, :, len_2x_end:seq_end, :, :] = (
+                        noise_sigma_2x * torch.randn_like(mid_latents_history[:, :, len_2x_end:seq_end, :, :])
+                        + (1 - noise_sigma_2x) * mid_latents_history[:, :, len_2x_end:seq_end, :, :]
+                    )
+            else:
+                if mode == "downsample":
+                    mid_latents_history[:, :, seq_begin:seq_end, :, :] = downsample_corrupt(
+                        model_input=mid_latents_history[:, :, seq_begin:seq_end, :, :],
+                        downsample_min_corrupt_ratio=downsample_min_corrupt_ratio,
+                        downsample_max_corrupt_ratio=downsample_max_corrupt_ratio,
+                    )
+                else:
+                    noise_sigma = get_corrupt_noise_sigma(
+                        model_input=latents_history_short,
+                        batch_size=batch_size,
+                        corrupt_ratio=corrupt_ratio_4x,
+                        num_frames=latent_window_size,
+                        is_frame_independent=is_frame_independent,
+                    )
+                    mid_latents_history[:, :, seq_begin:seq_end, :, :] = (
+                        noise_sigma * torch.randn_like(mid_latents_history[:, :, seq_begin:seq_end, :, :])
+                        + (1 - noise_sigma) * mid_latents_history[:, :, seq_begin:seq_end, :, :]
+                    )
+        seq_begin = seq_end
+
+    recovers = []
+    if tail_latents_history is not None:
+        recovers.append(tail_latents_history)
+    recovers.append(mid_latents_history[:, :, :-len_1x, :, :])
+    if begin_latents_history is not None:
+        recovers.append(begin_latents_history)
+    recovers.append(mid_latents_history[:, :, -len_1x:, :, :])
+    mid_latents_history = torch.cat(recovers, dim=2)
+
+    # Split and update back to original tensors
+    latents_4x_recovered, latents_2x_recovered, latents_history_short_recovered = mid_latents_history.split(
+        [len_4x, len_2x, ori_len_1x], dim=2
+    )
+
+    return (
+        latents_history_short_recovered,
+        latents_2x_recovered,
+        latents_4x_recovered,
+    )
+
+
+def add_saturation_to_history_latents(
+    latents_history_short,
+    latents_history_mid,
+    latents_history_long,
+    latent_window_size,
+    is_keep_x0=False,
+    saturation_ratio_min=0.7,
+    saturation_ratio_max=2.0,
+    saturation_clean_prob=0.2,
+):
+    # clean_random = random.random()
+    # if clean_random < saturation_clean_prob:
+    #     return latents_history_short, latents_history_mid, latents_history_long
+
+    def get_saturation(x1, saturation_ratio_min, saturation_ratio_max):
+        if random.random() < 0.5:
+            sat_factor = random.uniform(saturation_ratio_min, 1.0 - 1e-3)
+        else:
+            sat_factor = random.uniform(1.0 + 1e-3, saturation_ratio_max)
+        latent_mean = torch.mean(x1, dim=1, keepdim=True)
+        x1_saturated = (x1 - latent_mean) * sat_factor + latent_mean
+        return x1_saturated
+
+    len_4x = latents_history_long.shape[2]
+    len_2x = latents_history_mid.shape[2]
+    len_1x = latents_history_short.shape[2]
+
+    hist_seq_len = len_4x + len_2x + len_1x
+    hist_seq_len_copy = hist_seq_len
+
+    ori_len_1x = len_1x
+    if is_keep_x0:
+        len_1x -= 1
+        hist_seq_len -= 1
+        begin_num = 1
+    else:
+        begin_num = 0
+
+    max_windows = hist_seq_len // latent_window_size
+    tail_num = hist_seq_len % latent_window_size
+
+    assert hist_seq_len_copy == tail_num + max_windows * latent_window_size + begin_num
+
+    tail_latents_history = None
+    begin_latents_history = None
+
+    if tail_num != 0:
+        tail_latents_history = latents_history_long[:, :, :tail_num, :, :]
+        latents_history_long = latents_history_long[:, :, tail_num:, :, :]
+        if tail_latents_history.sum() != 0:
+            if random.random() < saturation_clean_prob:
+                tail_latents_history = tail_latents_history
+            else:
+                tail_latents_history = get_saturation(
+                    tail_latents_history,
+                    saturation_ratio_min=saturation_ratio_min,
+                    saturation_ratio_max=saturation_ratio_max,
+                )
+
+    if begin_num != 0:
+        begin_latents_history = latents_history_short[:, :, :begin_num, :, :]
+        latents_history_short = latents_history_short[:, :, begin_num:, :, :]
+        # if begin_latents_history.sum() != 0:
+        #     begin_latents_history = get_saturation(
+        #         begin_latents_history,
+        #         saturation_ratio_min=saturation_ratio_min,
+        #         saturation_ratio_max=saturation_ratio_max,
+        #     )
+
+    mid_latents_history = torch.cat([latents_history_long, latents_history_mid, latents_history_short], dim=2)
+    window_num = mid_latents_history.shape[2] // latent_window_size
+    assert mid_latents_history.shape[2] % latent_window_size == 0, (
+        f"mid length {mid_latents_history.shape[2]} not divisible by window size {latent_window_size}"
+    )
+
+    seq_begin = 0
+    for idx in range(window_num):
+        seq_end = seq_begin + latent_window_size
+        if mid_latents_history[:, :, seq_begin:seq_end, :, :].sum() != 0:
+            if idx == window_num - 1:
+                len_2x_end = seq_begin + len_2x
+                if random.random() < saturation_clean_prob:
+                    mid_latents_history[:, :, seq_begin:len_2x_end, :, :] = mid_latents_history[
+                        :, :, seq_begin:len_2x_end, :, :
+                    ]
+                else:
+                    mid_latents_history[:, :, seq_begin:len_2x_end, :, :] = get_saturation(
+                        mid_latents_history[:, :, seq_begin:len_2x_end, :, :],
+                        saturation_ratio_min=saturation_ratio_min,
+                        saturation_ratio_max=saturation_ratio_max,
+                    )
+
+                if random.random() < saturation_clean_prob:
+                    mid_latents_history[:, :, len_2x_end:seq_end, :, :] = mid_latents_history[
+                        :, :, len_2x_end:seq_end, :, :
+                    ]
+                else:
+                    mid_latents_history[:, :, len_2x_end:seq_end, :, :] = get_saturation(
+                        mid_latents_history[:, :, len_2x_end:seq_end, :, :],
+                        saturation_ratio_min=saturation_ratio_min,
+                        saturation_ratio_max=saturation_ratio_max,
+                    )
+            else:
+                if random.random() < saturation_clean_prob:
+                    mid_latents_history[:, :, seq_begin:seq_end, :, :] = mid_latents_history[
+                        :, :, seq_begin:seq_end, :, :
+                    ]
+                else:
+                    mid_latents_history[:, :, seq_begin:seq_end, :, :] = get_saturation(
+                        mid_latents_history[:, :, seq_begin:seq_end, :, :],
+                        saturation_ratio_min=saturation_ratio_min,
+                        saturation_ratio_max=saturation_ratio_max,
+                    )
+
+        seq_begin = seq_end
+
+    recovers = []
+    if tail_latents_history is not None:
+        recovers.append(tail_latents_history)
+    recovers.append(mid_latents_history[:, :, :-len_1x, :, :])
+    if begin_latents_history is not None:
+        recovers.append(begin_latents_history)
+    recovers.append(mid_latents_history[:, :, -len_1x:, :, :])
+    mid_latents_history = torch.cat(recovers, dim=2)
+
+    # Split and update back to original tensors
+    latents_4x_recovered, latents_2x_recovered, latents_history_short_recovered = mid_latents_history.split(
+        [len_4x, len_2x, ori_len_1x], dim=2
+    )
+
+    return (
+        latents_history_short_recovered,
+        latents_2x_recovered,
+        latents_4x_recovered,
+    )
+
+
+# ======================================== prepare stage1 training ========================================
+
+
+def prepare_stage1_clean_input_from_latents(
+    history_latents,  # VAE latents, (B, C_latent, F_latent, H_latent, W_latent)
+    target_latents,
+    x0_latents=None,
+    latent_window_size: int = 9,
+    history_sizes: list = [16, 2, 1],
+    is_random_drop: bool = False,
+    random_drop_i2v_ratio: float = 0,
+    random_drop_v2v_ratio: float = 0,
+    random_drop_t2v_ratio: float = 0,
+    is_keep_x0: bool = True,
+    dtype=torch.bfloat16,
+    device="cpu",
+):
+    if is_keep_x0:
+        latents_prefix = x0_latents.to(device, dtype=dtype)
+    else:
+        assert x0_latents is None
+
+    history_sizes = sorted(history_sizes, reverse=True)  # From big to small
+    history_window_size = sum(history_sizes)
+    total_window_size = history_window_size + latent_window_size
+    assert total_window_size == history_latents.shape[2] + target_latents.shape[2], (
+        f"total_window_size mismatch: expected {total_window_size}"
+        f"(history={history_latents.shape[2]} + target={target_latents.shape[2]}), "
+        f"but got {history_latents.shape[2] + target_latents.shape[2]}"
+    )
+
+    indices = (
+        torch.arange(0, sum([1, *history_sizes, latent_window_size])).unsqueeze(0).expand(target_latents.shape[0], -1)
+    )
+    (
+        indices_prefix,
+        indices_latents_history_long,
+        indices_latents_history_mid,
+        indices_latents_history_1x,
+        indices_hidden_states,
+    ) = indices.split([1, *history_sizes, latent_window_size], dim=1)
+    indices_latents_history_short = torch.cat([indices_prefix, indices_latents_history_1x], dim=1)
+
+    latents_history_long, latents_history_mid, latents_history_1x = history_latents.split(history_sizes, dim=2)
+
+    if is_random_drop:
+        if random_drop_t2v_ratio != 0 and torch.rand(1).item() <= random_drop_t2v_ratio:
+                if is_keep_x0:
+                    latents_prefix = torch.zeros_like(
+                        latents_prefix, device=latents_history_1x.device, dtype=latents_history_1x.dtype
+                    )
+                latents_history_1x = torch.zeros_like(
+                    latents_history_1x,
+                    device=latents_history_1x.device,
+                    dtype=latents_history_1x.dtype,
+                )
+                latents_history_mid = torch.zeros_like(
+                    latents_history_mid,
+                    device=latents_history_1x.device,
+                    dtype=latents_history_1x.dtype,
+                )
+                latents_history_long = torch.zeros_like(
+                    latents_history_long,
+                    device=latents_history_1x.device,
+                    dtype=latents_history_1x.dtype,
+                )
+        else:
+            len_4x = latents_history_long.shape[2]
+            len_2x = latents_history_mid.shape[2]
+            len_1x = latents_history_1x.shape[2]
+            hist_seq_len = len_4x + len_2x + len_1x
+
+            total_drop = 0
+            is_drop_triggered = False
+
+            if random_drop_i2v_ratio != 0 and torch.rand(1).item() <= random_drop_i2v_ratio:
+                total_drop = max(0, hist_seq_len - 1)
+                is_drop_triggered = True
+            elif random_drop_v2v_ratio != 0 and torch.rand(1).item() <= random_drop_v2v_ratio:
+                max_windows = hist_seq_len // latent_window_size
+                tail_num = hist_seq_len % latent_window_size
+                total_drop = tail_num
+                if max_windows > 0:
+                    drop_windows = random.randint(0, max_windows)
+                    total_drop += drop_windows * latent_window_size
+                is_drop_triggered = True
+
+            if is_drop_triggered and total_drop > 0:
+                remaining_drop = total_drop
+                if remaining_drop > 0 and len_4x > 0:
+                    drop_4x = min(remaining_drop, len_4x)
+                    latents_history_long[:, :, :drop_4x, :, :] = 0
+                    remaining_drop -= drop_4x
+                if remaining_drop > 0 and len_2x > 0:
+                    drop_2x = min(remaining_drop, len_2x)
+                    latents_history_mid[:, :, :drop_2x, :, :] = 0
+                    remaining_drop -= drop_2x
+                if remaining_drop > 0 and len_1x > 0:
+                    drop_1x = min(remaining_drop, len_1x)
+                    latents_history_1x[:, :, :drop_1x, :, :] = 0
+
+    if is_keep_x0:
+        latents_history_short = torch.cat([latents_prefix, latents_history_1x], dim=2)
+    else:
+        latents_history_short = latents_history_1x
+
+    return (
+        target_latents,
+        indices_hidden_states,
+        indices_latents_history_short,
+        indices_latents_history_mid,
+        indices_latents_history_long,
+        latents_history_short,
+        latents_history_mid,
+        latents_history_long,
+    )
+
+
+def prepare_stage1_noise_input(
+    args,
+    model_input,
+    noise_scheduler,
+    recycle_vars=None,
+    latents_history_short=None,
+    latents_history_mid=None,
+    latents_history_long=None,
+    latent_window_size=9,
+    is_keep_x0=True,
+    return_list=True,
+):
+    # Sample noise that we'll add to the latents
+    noise = torch.randn_like(model_input)
+    bsz = model_input.shape[0]
+
+    use_clean_input = False
+    noise_w_error = noise
+    model_input_w_error = model_input
+
+    # Sample a random timestep for each image
+    # for weighting schemes where we sample timesteps non-uniformly
+    u = compute_density_for_timestep_sampling(
+        weighting_scheme=args.training_config.weighting_scheme,
+        batch_size=bsz,
+        logit_mean=args.training_config.logit_mean,
+        logit_std=args.training_config.logit_std,
+        mode_scale=args.training_config.mode_scale,
+    )
+    indices = (u * noise_scheduler.config.num_train_timesteps).long()
+
+    noise_scheduler.temp_sigmas = noise_scheduler.sigmas
+    noise_scheduler.temp_timesteps = noise_scheduler.timesteps
+    if args.training_config.use_dynamic_shifting:
+        noise_scheduler.temp_sigmas = apply_schedule_shift(
+            noise_scheduler.sigmas,
+            noise,
+            base_seq_len=args.training_config.base_seq_len,
+            max_seq_len=args.training_config.max_seq_len,
+            base_shift=args.training_config.base_shift,
+            max_shift=args.training_config.max_shift,
+        )  # torch.Size([2, 1, 1, 1, 1])
+
+        noise_scheduler.temp_timesteps = noise_scheduler.temp_sigmas * 1000.0  # rescale to [0, 1000.0)
+        while noise_scheduler.temp_timesteps.ndim > 1:
+            noise_scheduler.temp_timesteps = noise_scheduler.temp_timesteps.squeeze(-1)
+
+    timesteps = noise_scheduler.temp_timesteps[indices].to(
+        device=model_input.device, non_blocking=True
+    )  # torch.Size([2]), torch.float32
+
+    # Add noise according to flow matching.
+    # zt = (1 - texp) * x + texp * z1
+    sigmas = noise_scheduler.temp_sigmas[indices].flatten()
+    while len(sigmas.shape) < model_input.ndim:
+        sigmas = sigmas.unsqueeze(-1)
+
+    sigmas = sigmas.to(model_input.device, dtype=model_input.dtype)
+
+    if args.training_config.use_error_recycling:
+        (
+            model_input_w_error,
+            noise_w_error,
+            latents_history_long,
+            latents_history_mid,
+            latents_history_short,
+            use_clean_input,
+        ) = apply_error_injection(
+            args,
+            recycle_vars,
+            model_input,
+            noise,
+            timesteps,
+            latents_history_long,
+            latents_history_mid,
+            latents_history_short,
+            model_input_w_error,
+            noise_w_error,
+            is_keep_x0,
+            latent_window_size,
+        )
+
+    if args.training_config.corrupt_history and latents_history_short is not None:
+        latents_history_short, latents_history_mid, latents_history_long = corrupt_history_latents(
+            latents_history_short,
+            latents_history_mid,
+            latents_history_long,
+            latent_window_size,
+            is_keep_x0=True,
+            # choose mode
+            corrupt_mode=args.training_config.corrupt_mode_history,
+            noise_mode_prob=args.training_config.corrupt_mode_prob_history,
+            # for noise
+            is_frame_independent=args.training_config.is_frame_independent_corrupt_history,
+            is_chunk_independent=args.training_config.is_chunk_independent_corrupt_history,
+            corrupt_ratio_1x=args.training_config.noise_corrupt_ratio_history_short,
+            corrupt_ratio_2x=args.training_config.noise_corrupt_ratio_history_mid,
+            corrupt_ratio_4x=args.training_config.noise_corrupt_ratio_history_long,
+            noise_corrupt_clean_prob=args.training_config.noise_corrupt_clean_prob_history,
+            # for downsample
+            downsample_min_corrupt_ratio=args.training_config.downsample_min_corrupt_ratio_history,
+            downsample_max_corrupt_ratio=args.training_config.downsample_max_corrupt_ratio_history,
+        )
+
+    if args.training_config.corrupt_model_input:
+        model_input_w_error = corrupt_model_input(
+            model_input_w_error,
+            # choose mode
+            corrupt_mode=args.training_config.corrupt_mode_model_input,
+            noise_mode_prob=args.training_config.corrupt_mode_prob_model_input,
+            # for noise
+            is_frame_independent=args.training_config.is_frame_independent_corrupt_model_input,
+            is_chunk_independent=args.training_config.is_chunk_independent_corrupt_model_input,
+            noise_corrupt_ratio=args.training_config.noise_corrupt_ratio_model_input,
+            noise_corrupt_clean_prob=args.training_config.noise_corrupt_clean_prob_model_input,
+            # for downsample
+            downsample_min_corrupt_ratio=args.training_config.downsample_min_corrupt_ratio_model_input,
+            downsample_max_corrupt_ratio=args.training_config.downsample_max_corrupt_ratio_model_input,
+        )
+
+    # Get flow-matching target
+    noisy_model_input = (1.0 - sigmas) * model_input_w_error + sigmas * noise_w_error
+    target = noise_w_error - model_input
+
+    noisy_model_input_list = [noisy_model_input] if return_list else noisy_model_input
+    sigmas_list = [sigmas] if return_list else sigmas
+    timesteps_list = [timesteps] if return_list else timesteps
+    targets_list = [target] if return_list else target
+
+    return (
+        noisy_model_input_list,
+        sigmas_list,
+        timesteps_list,
+        targets_list,
+        latents_history_short,
+        latents_history_mid,
+        latents_history_long,
+        use_clean_input,
+    )
+
+
+# ======================================== prepare stage2 training ========================================
+
+
+def prepare_stage2_clean_input(
+    args,
+    scheduler,
+    latents,  # [b c t h w]
+    pyramid_stage_num=3,
+    stage2_sample_ratios=[1, 1, 1],
+):
+    assert pyramid_stage_num == len(stage2_sample_ratios)
+
+    # Get clen pyramid latent list
+    pyramid_latent_list = []
+    pyramid_latent_list.append(latents)
+    num_frames, height, width = latents.shape[-3], latents.shape[-2], latents.shape[-1]
+    for _ in range(pyramid_stage_num - 1):
+        height //= 2
+        width //= 2
+        latents = rearrange(latents, "b c t h w -> (b t) c h w")
+        latents = torch.nn.functional.interpolate(latents, size=(height, width), mode="bilinear")
+        latents = rearrange(latents, "(b t) c h w -> b c t h w", t=num_frames)
+        pyramid_latent_list.append(latents)
+    pyramid_latent_list = list(reversed(pyramid_latent_list))
+
+    # Get pyramid noise list
+    noise = torch.randn_like(pyramid_latent_list[-1])
+    device = noise.device
+    dtype = pyramid_latent_list[-1].dtype
+    latent_frame_num = noise.shape[2]
+    input_video_num = noise.shape[0]
+
+    height, width = noise.shape[-2], noise.shape[-1]
+    noise_list = [noise]
+    cur_noise = noise
+    for i_s in range(pyramid_stage_num - 1):
+        height //= 2
+        width //= 2
+        cur_noise = rearrange(cur_noise, "b c t h w -> (b t) c h w")
+        cur_noise = F.interpolate(cur_noise, size=(height, width), mode="bilinear") * 2
+        cur_noise = rearrange(cur_noise, "(b t) c h w -> b c t h w", t=latent_frame_num)
+        noise_list.append(cur_noise)
+    noise_list = list(reversed(noise_list))  # make sure from low res to high res
+
+    # Get pyramid target list
+    # To calculate the batchsize
+    bsz = input_video_num
+
+    # from low resolution to high resolution
+    noisy_latents_list = []
+    sigmas_list = []
+    targets_list = []
+    timesteps_list = []
+    training_steps = scheduler.config.num_train_timesteps
+    for i_s, cur_sample_ratio in zip(range(pyramid_stage_num), stage2_sample_ratios):
+        clean_latent = pyramid_latent_list[i_s]  # [bs, c, t, h, w]
+        last_clean_latent = None if i_s == 0 else pyramid_latent_list[i_s - 1]
+        start_sigma = scheduler.start_sigmas[i_s]
+        end_sigma = scheduler.end_sigmas[i_s]
+
+        if i_s == 0:
+            start_point = noise_list[i_s]
+        else:
+            # Get the upsampled latent
+            last_clean_latent = rearrange(last_clean_latent, "b c t h w -> (b t) c h w")
+            last_clean_latent = F.interpolate(
+                last_clean_latent,
+                size=(
+                    last_clean_latent.shape[-2] * 2,
+                    last_clean_latent.shape[-1] * 2,
+                ),
+                mode="nearest",
+            )
+            last_clean_latent = rearrange(last_clean_latent, "(b t) c h w -> b c t h w", t=latent_frame_num)
+            start_point = start_sigma * noise_list[i_s] + (1 - start_sigma) * last_clean_latent
+
+        if i_s == pyramid_stage_num - 1:
+            end_point = clean_latent
+        else:
+            end_point = end_sigma * noise_list[i_s] + (1 - end_sigma) * clean_latent
+
+        for _ in range(cur_sample_ratio):
+            # Sample a random timestep for each image
+            # for weighting schemes where we sample timesteps non-uniformly
+            u = compute_density_for_timestep_sampling(
+                weighting_scheme=get_config_value(args, "weighting_scheme"),
+                batch_size=bsz,
+                logit_mean=get_config_value(args, "logit_mean"),
+                logit_std=get_config_value(args, "logit_std"),
+                mode_scale=get_config_value(args, "mode_scale"),
+            )
+            indices = (u * training_steps).long()  # Totally 1000 training steps per stage
+            indices = indices.clamp(0, training_steps - 1)
+            timesteps = scheduler.timesteps_per_stage[i_s][indices].to(device=device)
+
+            # Add noise according to flow matching.
+            # zt = (1 - texp) * x + texp * z1
+            sigmas = scheduler.sigmas_per_stage[i_s][indices].to(device=device)
+            while len(sigmas.shape) < start_point.ndim:
+                sigmas = sigmas.unsqueeze(-1)
+
+            if get_config_value(args, "use_dynamic_shifting"):
+                temp_sigmas = apply_schedule_shift(
+                    sigmas,
+                    start_point,
+                    base_seq_len=get_config_value(args, "base_seq_len"),
+                    max_seq_len=get_config_value(args, "max_seq_len"),
+                    base_shift=get_config_value(args, "base_shift"),
+                    max_shift=get_config_value(args, "max_shift"),
+                )  # torch.Size([2, 1, 1, 1, 1])
+                temp_timesteps = scheduler.timesteps_per_stage[i_s].min() + temp_sigmas * (
+                    scheduler.timesteps_per_stage[i_s].max() - scheduler.timesteps_per_stage[i_s].min()
+                )
+                while temp_timesteps.ndim > 1:
+                    temp_timesteps = temp_timesteps.squeeze(-1)
+
+                sigmas = temp_sigmas
+                timesteps = temp_timesteps
+
+            if args.training_config.corrupt_model_input:
+                end_point = corrupt_model_input(
+                    end_point,
+                    # choose mode
+                    corrupt_mode=args.training_config.corrupt_mode_model_input,
+                    noise_mode_prob=args.training_config.corrupt_mode_prob_model_input,
+                    # for noise
+                    is_frame_independent=args.training_config.is_frame_independent_corrupt_model_input,
+                    is_chunk_independent=args.training_config.is_chunk_independent_corrupt_model_input,
+                    noise_corrupt_ratio=args.training_config.noise_corrupt_ratio_model_input,
+                    noise_corrupt_clean_prob=args.training_config.noise_corrupt_clean_prob_model_input,
+                    # for downsample
+                    downsample_min_corrupt_ratio=args.training_config.downsample_min_corrupt_ratio_model_input,
+                    downsample_max_corrupt_ratio=args.training_config.downsample_max_corrupt_ratio_model_input,
+                )
+
+            noisy_latents = sigmas * start_point + (1 - sigmas) * end_point
+
+            # [stage1_latent, stage2_latent, ..., stagen_latent]
+            noisy_latents_list.append(noisy_latents.to(dtype))
+            sigmas_list.append(sigmas.to(dtype))
+            timesteps_list.append(timesteps)
+            targets_list.append(start_point - end_point)  # The standard rectified flow matching objective
+
+    return noisy_latents_list, sigmas_list, timesteps_list, targets_list
+
+
+def prepare_stage2_noise_input(
+    args,
+    scheduler,
+    latents,  # [b c t h w]
+    pyramid_stage_num=3,
+    stage2_sample_ratios=[1, 1, 1],
+    latents_history_short=None,
+    latents_history_mid=None,
+    latents_history_long=None,
+    latent_window_size=9,
+    return_list=True,
+    is_navit_pyramid=False,
+    is_efficient_sample=False,
+):
+    noisy_model_input_list, sigmas_list, timesteps_list, targets_list = prepare_stage2_clean_input(
+        args=args,
+        scheduler=scheduler,
+        latents=latents,
+        pyramid_stage_num=pyramid_stage_num,
+        stage2_sample_ratios=stage2_sample_ratios,
+    )
+
+    if args.training_config.corrupt_history and latents_history_short is not None:
+        latents_history_short, latents_history_mid, latents_history_long = corrupt_history_latents(
+            latents_history_short,
+            latents_history_mid,
+            latents_history_long,
+            latent_window_size,
+            is_keep_x0=True,
+            # choose mode
+            corrupt_mode=args.training_config.corrupt_mode_history,
+            noise_mode_prob=args.training_config.corrupt_mode_prob_history,
+            # for noise
+            is_frame_independent=args.training_config.is_frame_independent_corrupt_history,
+            is_chunk_independent=args.training_config.is_chunk_independent_corrupt_history,
+            corrupt_ratio_1x=args.training_config.noise_corrupt_ratio_history_short,
+            corrupt_ratio_2x=args.training_config.noise_corrupt_ratio_history_mid,
+            corrupt_ratio_4x=args.training_config.noise_corrupt_ratio_history_long,
+            noise_corrupt_clean_prob=args.training_config.noise_corrupt_clean_prob_history,
+            # for downsample
+            downsample_min_corrupt_ratio=args.training_config.downsample_min_corrupt_ratio_history,
+            downsample_max_corrupt_ratio=args.training_config.downsample_max_corrupt_ratio_history,
+        )
+
+    if is_navit_pyramid:
+        return (
+            [noisy_model_input_list],
+            [sigmas_list],
+            [timesteps_list],
+            [targets_list],
+            latents_history_short,
+            latents_history_mid,
+            latents_history_long,
+        )
+
+    if is_efficient_sample:
+        temp_list = list(range(len(noisy_model_input_list)))
+        random_index = random.choice(temp_list)
+
+        noisy_model_input = noisy_model_input_list[random_index]
+        sigmas = sigmas_list[random_index]
+        timesteps = timesteps_list[random_index]
+        targets = targets_list[random_index]
+
+        base_results = (noisy_model_input, sigmas, timesteps, targets)
+        additional_results = (latents_history_short, latents_history_mid, latents_history_long)
+
+        if return_list:
+            return tuple([item] for item in base_results) + additional_results
+        else:
+            return base_results + additional_results
+
+    return (
+        noisy_model_input_list,
+        sigmas_list,
+        timesteps_list,
+        targets_list,
+        latents_history_short,
+        latents_history_mid,
+        latents_history_long,
+    )

Helios/_DEV/helios/utils/utils_recycle_batch.py

@@ -0,0 +1,724 @@
+import random
+
+import torch
+
+from .utils_base import apply_schedule_shift
+
+
+def apply_error_injection(
+    args,
+    recycle_vars,
+    model_input,
+    noise,
+    timesteps,
+    latents_history_long,
+    latents_history_mid,
+    latents_history_short,
+    model_input_w_error,
+    noise_w_error,
+    is_keep_x0,
+    latent_window_size,
+):
+    batch_size, _, _, h, w = noise.shape
+
+    # Get grid indices for all batch items
+    current_grid_indices = get_timestep_grid(args, recycle_vars, timesteps, noise)
+
+    # Handle single item (backward compatibility)
+    if isinstance(current_grid_indices, int):
+        current_grid_indices = torch.tensor([current_grid_indices], device=noise.device)
+
+    # Check buffer availability for each batch item
+    has_latent_buffer_data = torch.tensor(
+        [len(recycle_vars.latent_error_buffer[(h, w)][grid_idx.item()]) > 0 for grid_idx in current_grid_indices],
+        device=noise.device,
+    )
+
+    has_y_buffer_data = any(len(buffer) > 0 for buffer in recycle_vars.y_error_buffer[(h, w)].values())
+
+    # Generate random decisions for each batch item
+    latent_random = torch.rand(batch_size, device=noise.device)
+    noise_random = torch.rand(batch_size, device=noise.device)
+    y_random = torch.rand(batch_size, device=noise.device)
+    clean_random = torch.rand(batch_size, device=noise.device)
+
+    # Determine which operations to apply for each batch item
+    add_error_latent = latent_random < args.training_config.latent_prob
+    add_error_noise = noise_random < args.training_config.noise_prob
+    add_error_y = y_random < args.training_config.y_prob
+    use_clean_input = clean_random < args.training_config.clean_prob
+
+    # Clean input overrides all errors
+    add_error_noise = add_error_noise & ~use_clean_input
+    add_error_y = add_error_y & ~use_clean_input
+    add_error_latent = add_error_latent & ~use_clean_input
+
+    # Apply noise error
+    if add_error_noise.any() and has_latent_buffer_data.any():
+        noise_error_sampled = sample_noise_error_from_noise_buffer(
+            args, recycle_vars, model_input, timesteps, model_input.dtype, model_input.device
+        )
+        mask = add_error_noise & has_latent_buffer_data
+        if mask.any():
+            noise_w_error[mask] = noise[mask] + noise_error_sampled[mask].to(model_input.dtype)
+
+    # Apply y error for selected batch items
+    if add_error_y.any() and has_y_buffer_data:
+        len_4x = latents_history_long.shape[2]
+        len_2x = latents_history_mid.shape[2]
+        len_1x = latents_history_short.shape[2]
+
+        hist_seq_len = len_4x + len_2x + len_1x
+        hist_seq_len_copy = hist_seq_len
+
+        ori_len_1x = len_1x
+        if is_keep_x0:
+            len_1x -= 1
+            hist_seq_len -= 1
+            begin_num = 1
+        else:
+            begin_num = 0
+
+        max_windows = hist_seq_len // latent_window_size
+        tail_num = hist_seq_len % latent_window_size
+
+        assert hist_seq_len_copy == tail_num + max_windows * latent_window_size + begin_num
+
+        # Process each batch item independently
+        for batch_idx in range(batch_size):
+            if not add_error_y[batch_idx]:
+                continue
+
+            # Split history for this batch item
+            tail_latents_history = None
+            begin_latents_history = None
+
+            latents_4x_item = latents_history_long[batch_idx : batch_idx + 1]
+            latents_2x_item = latents_history_mid[batch_idx : batch_idx + 1]
+            latents_clean_item = latents_history_short[batch_idx : batch_idx + 1]
+
+            if tail_num != 0:
+                tail_latents_history = latents_4x_item[:, :, :tail_num, :, :]
+                latents_4x_item = latents_4x_item[:, :, tail_num:, :, :]
+                # Apply tail error
+                if tail_latents_history.sum() != 0 and random.random() < args.training_config.y_prob:
+                    y_error_sampled = sample_y_error_from_latent_buffer(
+                        args,
+                        recycle_vars,
+                        model_input[batch_idx : batch_idx + 1],
+                        model_input.dtype,
+                        model_input.device,
+                    )
+                    random_error_num = torch.randint(1, tail_num + 1, (1,)).item()
+                    tail_latents_history[:, :, -random_error_num:, ...] = (
+                        tail_latents_history[:, :, -random_error_num:, ...]
+                        + y_error_sampled[:, :, -random_error_num:, ...]
+                    )
+
+            if begin_num != 0:
+                begin_latents_history = latents_clean_item[:, :, :begin_num, :, :]
+                latents_clean_item = latents_clean_item[:, :, begin_num:, :, :]
+                # Apply begin error
+                if begin_latents_history.sum() != 0 and random.random() < args.training_config.y_prob:
+                    y_error_sampled = sample_y_error_from_latent_buffer(
+                        args,
+                        recycle_vars,
+                        model_input[batch_idx : batch_idx + 1],
+                        model_input.dtype,
+                        model_input.device,
+                    )
+                    begin_latents_history = begin_latents_history + y_error_sampled[:, :, :1, ...]
+
+            # Process mid windows
+            mid_latents_history = torch.cat([latents_4x_item, latents_2x_item, latents_clean_item], dim=2)
+            window_num = mid_latents_history.shape[2] // latent_window_size
+            assert mid_latents_history.shape[2] % latent_window_size == 0, (
+                f"mid length {mid_latents_history.shape[2]} not divisible by window size {latent_window_size}"
+            )
+
+            seq_begin = 0
+            for _ in range(window_num):
+                seq_end = seq_begin + latent_window_size
+                if (
+                    mid_latents_history[:, :, seq_begin:seq_end, :, :].sum() != 0
+                    and random.random() < args.training_config.y_prob
+                ):
+                    y_error_sampled = sample_y_error_from_latent_buffer(
+                        args,
+                        recycle_vars,
+                        model_input[batch_idx : batch_idx + 1],
+                        model_input.dtype,
+                        model_input.device,
+                    )
+                    max_start_idx = max(0, y_error_sampled.shape[2] - args.training_config.y_error_num)
+                    random_frame_idx = torch.randint(0, max_start_idx + 1, (1,)).item()
+                    error_to_add = y_error_sampled[
+                        :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, ...
+                    ]
+                    # Modify
+                    mid_latents_history[:, :, seq_begin:seq_end, :, :][
+                        :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, :, :
+                    ] = (
+                        mid_latents_history[:, :, seq_begin:seq_end, :, :][
+                            :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, :, :
+                        ]
+                        + error_to_add
+                    )
+                seq_begin = seq_end
+
+            # Recover structure
+            recovers = []
+            if tail_latents_history is not None:
+                recovers.append(tail_latents_history)
+            recovers.append(mid_latents_history[:, :, :-len_1x, :, :])
+            if begin_latents_history is not None:
+                recovers.append(begin_latents_history)
+            recovers.append(mid_latents_history[:, :, -len_1x:, :, :])
+            mid_latents_history = torch.cat(recovers, dim=2)
+
+            # Split and update back to original tensors
+            latents_4x_recovered, latents_2x_recovered, latents_clean_recovered = mid_latents_history.split(
+                [len_4x, len_2x, ori_len_1x], dim=2
+            )
+            latents_history_long[batch_idx : batch_idx + 1] = latents_4x_recovered
+            latents_history_mid[batch_idx : batch_idx + 1] = latents_2x_recovered
+            latents_history_short[batch_idx : batch_idx + 1] = latents_clean_recovered
+
+    # Apply latent error
+    if add_error_latent.any() and has_latent_buffer_data.any():
+        latent_error_sampled = sample_latent_error_from_latent_buffer(
+            args, recycle_vars, model_input, timesteps, model_input.dtype, model_input.device
+        )
+        mask = add_error_latent & has_latent_buffer_data
+        if mask.any():
+            model_input_w_error[mask] = model_input[mask] + latent_error_sampled[mask].to(model_input.dtype)
+
+    return (
+        model_input_w_error,
+        noise_w_error,
+        latents_history_long,
+        latents_history_mid,
+        latents_history_short,
+        use_clean_input,
+    )
+
+
+def step_recycle(scheduler, model_output, timestep, sample, to_final=False, self_corr=False):
+    """
+    Args:
+        timestep: scalar, 1D tensor with shape [batch_size], or tensor that can be flattened
+    """
+    # Normalize timestep to 1D tensor
+    if isinstance(timestep, torch.Tensor):
+        timestep_vals = timestep.flatten().cpu()
+    else:
+        # Scalar value, convert to tensor
+        timestep_vals = torch.tensor([timestep])
+
+    batch_size = timestep_vals.shape[0]
+
+    # Find timestep indices for all batch items
+    # timestep_vals: [batch_size], scheduler.temp_timesteps: [num_timesteps]
+    diffs = torch.abs(
+        scheduler.temp_timesteps.unsqueeze(0) - timestep_vals.unsqueeze(-1)
+    )  # [batch_size, num_timesteps]
+    timestep_ids = torch.argmin(diffs, dim=-1)  # [batch_size]
+
+    # Get sigmas for all batch items
+    sigmas = scheduler.temp_sigmas[timestep_ids]  # [batch_size]
+
+    # Calculate next sigmas
+    if to_final:
+        # All items go to final
+        sigmas_next = torch.ones(batch_size) if self_corr else torch.zeros(batch_size)
+    else:
+        # Check which items are at the end
+        at_end = timestep_ids + 1 >= len(scheduler.temp_timesteps)
+
+        # Get next sigmas (clamped to valid range)
+        next_ids = torch.clamp(timestep_ids + 1, 0, len(scheduler.temp_timesteps) - 1)
+        sigmas_next = scheduler.temp_sigmas[next_ids]  # [batch_size]
+
+        # Override with 1 or 0 for items at the end
+        if self_corr:
+            sigmas_next[at_end] = 1.0
+        else:
+            sigmas_next[at_end] = 0.0
+
+    # Move sigmas to same device as sample
+    sigmas = sigmas.to(sample.device, dtype=sample.dtype)
+    sigmas_next = sigmas_next.to(sample.device, dtype=sample.dtype)
+
+    # Compute prev_sample for all batch items
+    # Reshape sigmas to broadcast correctly: [batch_size, 1, 1, 1, 1] for 5D tensors
+    shape = [batch_size] + [1] * (sample.ndim - 1)
+    sigma_diff = (sigmas_next - sigmas).view(*shape)
+
+    prev_sample = sample + model_output * sigma_diff
+
+    return prev_sample
+
+
+def get_timesteps(
+    num_inference_steps=50,
+    denoising_strength=1,
+    shift=1.0,
+    num_train_timesteps=1000,
+    sigma_max=1.0,
+    sigma_min=0.0,
+    inverse_timesteps=False,
+    extra_one_step=True,
+    reverse_sigmas=False,
+):
+    sigma_start = sigma_min + (sigma_max - sigma_min) * denoising_strength
+    if extra_one_step:
+        sigmas = torch.linspace(sigma_start, sigma_min, num_inference_steps + 1)[:-1]
+    else:
+        sigmas = torch.linspace(sigma_start, sigma_min, num_inference_steps)
+    if inverse_timesteps:
+        sigmas = torch.flip(sigmas, dims=[0])
+    sigmas = shift * sigmas / (1 + (shift - 1) * sigmas)
+    if reverse_sigmas:
+        sigmas = 1 - sigmas
+    timesteps = sigmas * num_train_timesteps
+    return timesteps, sigmas
+
+
+def get_timestep_grid(args, recycle_vars, timesteps, noise):
+    """Get the grid index for a given timesteps."""
+    _, _, _, h, w = noise.shape
+
+    # Handle different timesteps formats (scalar tensor, tensor with batch dim, etc.)
+    if isinstance(timesteps, torch.Tensor):
+        timestep_vals = timesteps.flatten()
+    else:
+        # Already a scalar value
+        timestep_vals = torch.tensor([timesteps], device=noise.device if hasattr(noise, "device") else "cpu")
+
+    if args.training_config.use_dynamic_shifting:
+        temp_sigmas = apply_schedule_shift(
+            recycle_vars.recycle_sigmas,
+            noise,
+            base_seq_len=args.training_config.base_seq_len,
+            max_seq_len=args.training_config.max_seq_len,
+            base_shift=args.training_config.base_shift,
+            max_shift=args.training_config.max_shift,
+        )  # torch.Size([2, 1, 1, 1, 1])
+
+        temp_inferece_timesteps = temp_sigmas * 1000.0  # rescale to [0, 1000.0)
+        while temp_inferece_timesteps.ndim > 1:
+            temp_inferece_timesteps = temp_inferece_timesteps.squeeze(-1)
+    else:
+        temp_inferece_timesteps = recycle_vars.recycle_inferece_timesteps
+
+    # Ensure timesteps is within valid range and calculate grid index
+    timestep_vals = torch.clamp(timestep_vals, 0, 999)
+    grid_timesteps = temp_inferece_timesteps.to(timestep_vals.device)
+
+    diffs = torch.abs(grid_timesteps.unsqueeze(0) - timestep_vals.unsqueeze(-1))
+    grid_indices = torch.argmin(diffs, dim=-1)
+
+    # Ensure grid index is within valid range
+    max_grid_idx = len(recycle_vars.latent_error_buffer[(h, w)]) - 1
+    grid_indices = torch.clamp(grid_indices, 0, max_grid_idx)
+
+    return grid_indices
+
+
+def sample_noise_error_from_noise_buffer(args, recycle_vars, latents, timestep, dtype=torch.bfloat16, device="cpu"):
+    """Randomly sample an error from the buffer based on timestep grid."""
+    batch_size, _, _, h, w = latents.shape
+    grid_indices = get_timestep_grid(args, recycle_vars, timestep, latents)
+
+    # Handle single item (backward compatibility)
+    if isinstance(grid_indices, int):
+        grid_indices = torch.tensor([grid_indices], device=device)
+
+    # Initialize output tensor
+    error_samples = torch.zeros_like(latents)
+
+    # Sample error for each item in batch
+    for i, grid_idx in enumerate(grid_indices):
+        grid_idx = grid_idx.item()
+
+        if not recycle_vars.latent_error_buffer[(h, w)][grid_idx]:
+            continue  # Keep zeros for this batch item
+
+        # Randomly select one sample from the corresponding grid
+        selected_sample = random.choice(recycle_vars.latent_error_buffer[(h, w)][grid_idx])
+
+        # Apply random intensity modulation
+        min_mod = 1.0 - args.training_config.error_modulate_factor
+        max_mod = 1.0 + args.training_config.error_modulate_factor
+        intensity_mod = random.uniform(min_mod, max_mod)
+
+        error_sample = selected_sample * intensity_mod
+        error_sample = error_sample
+
+        # Assign to the i-th batch item
+        error_samples[i] = error_sample
+
+    error_samples = error_samples.to(device, dtype=dtype)
+
+    return error_samples
+
+
+def sample_latent_error_from_latent_buffer(args, recycle_vars, latents, timestep, dtype=torch.bfloat16, device="cpu"):
+    """Randomly sample an error from the buffer based on timestep grid."""
+    batch_size, _, _, h, w = latents.shape
+    grid_indices = get_timestep_grid(args, recycle_vars, timestep, latents)
+
+    # Handle single item (backward compatibility)
+    if isinstance(grid_indices, int):
+        grid_indices = torch.tensor([grid_indices], device=device)
+
+    # Initialize output tensor
+    error_samples = torch.zeros_like(latents)
+
+    # Sample error for each item in batch
+    for i, grid_idx in enumerate(grid_indices):
+        grid_idx = grid_idx.item()
+
+        if not recycle_vars.y_error_buffer[(h, w)][grid_idx]:
+            continue  # Keep zeros for this batch item
+
+        # Randomly select one sample from the corresponding grid
+        selected_sample = random.choice(recycle_vars.y_error_buffer[(h, w)][grid_idx])
+
+        # Apply random intensity modulation
+        min_mod = 1.0 - args.training_config.error_modulate_factor
+        max_mod = 1.0 + args.training_config.error_modulate_factor
+        intensity_mod = random.uniform(min_mod, max_mod)
+
+        error_sample = selected_sample * intensity_mod
+        error_sample = error_sample
+
+        # Assign to the i-th batch item
+        error_samples[i] = error_sample
+
+    error_samples = error_samples.to(device, dtype=dtype)
+
+    return error_samples
+
+
+def sample_y_error_from_latent_buffer(args, recycle_vars, latents, dtype=torch.bfloat16, device="cpu"):
+    """Specially sample y_error from buffer - can be configured to sample from all grids or custom range."""
+    batch_size, _, _, h, w = latents.shape
+
+    # Sample from all grids that have data
+    all_samples = []
+    for grid_idx, buffer in recycle_vars.y_error_buffer[(h, w)].items():
+        if buffer:  # Only add non-empty buffers
+            all_samples.extend(buffer)
+
+    if not all_samples:
+        return torch.zeros_like(latents)
+
+    # Initialize output tensor
+    error_samples = torch.zeros_like(latents)
+
+    # Sample independently for each batch item
+    for i in range(batch_size):
+        # Randomly select one sample from all available samples
+        selected_sample = random.choice(all_samples)
+
+        # Apply random intensity modulation
+        min_mod = 1.0 - args.training_config.error_modulate_factor
+        max_mod = 1.0 + args.training_config.error_modulate_factor
+        intensity_mod = random.uniform(min_mod, max_mod)
+
+        error_sample = selected_sample * intensity_mod
+        error_sample = error_sample
+
+        # Assign to the i-th batch item
+        error_samples[i] = error_sample
+
+    error_samples = error_samples.to(device, dtype=dtype)
+
+    return error_samples
+
+
+def compute_l2_distance_batch(new_tensor, stored_tensors):
+    """Compute L2 distances between new tensor and all stored tensors efficiently."""
+    if not stored_tensors:
+        return torch.tensor([])
+
+    # Stack all stored tensors for batch computation
+    stored_stack = torch.stack(stored_tensors)  # [num_stored, ...]
+    new_flat = new_tensor.flatten()
+    stored_flat = stored_stack.flatten(start_dim=1)  # [num_stored, flattened_size]
+
+    # Compute L2 distances in batch
+    distances = torch.norm(stored_flat - new_flat.unsqueeze(0), p=2, dim=1)
+    return distances
+
+
+def compute_l2_distance(tensor1, tensor2):
+    """Compute L2 distance between two tensors"""
+    # Flatten tensors
+    flat1 = tensor1.flatten()
+    flat2 = tensor2.flatten()
+
+    # Compute L2 distance (Euclidean distance)
+    l2_distance = torch.norm(flat1 - flat2, p=2)
+    return l2_distance.item()
+
+
+def add_error_to_latent_buffer(args, recycle_vars, error_sample, timestep, noisy_model_input):
+    """Add error sample to buffer using specified replacement strategy based on timestep grid."""
+    batch_size, _, _, h, w = noisy_model_input.shape
+    grid_indices = get_timestep_grid(args, recycle_vars, timestep, noisy_model_input)
+    error_cpu = error_sample.detach().cpu()
+
+    # Process each batch item
+    for i, grid_idx in enumerate(grid_indices):
+        grid_idx = grid_idx.item()
+        error_cpu = error_sample[i].detach().cpu()
+
+        if len(recycle_vars.latent_error_buffer[(h, w)][grid_idx]) < args.training_config.error_buffer_size:
+            # Buffer not full, simply add
+            recycle_vars.latent_error_buffer[(h, w)][grid_idx].append(error_cpu)
+        else:
+            # Buffer full, use specified replacement strategy
+            if args.training_config.buffer_replacement_strategy == "random":
+                # Random replacement - O(1), fastest
+                replace_idx = random.randint(0, len(recycle_vars.latent_error_buffer[(h, w)][grid_idx]) - 1)
+                recycle_vars.latent_error_buffer[(h, w)][grid_idx][replace_idx] = error_cpu
+
+            elif args.training_config.buffer_replacement_strategy == "fifo":
+                # First-in-first-out - O(1), simple queue behavior
+                recycle_vars.latent_error_buffer[(h, w)][grid_idx].pop(0)
+                recycle_vars.latent_error_buffer[(h, w)][grid_idx].append(error_cpu)
+
+            elif args.training_config.buffer_replacement_strategy == "l2_batch":
+                # Batch L2 computation - O(n) but vectorized, much faster than original
+                distances = compute_l2_distance_batch(error_cpu, recycle_vars.latent_error_buffer[(h, w)][grid_idx])
+                most_similar_idx = torch.argmin(distances).item()
+                recycle_vars.latent_error_buffer[(h, w)][grid_idx][most_similar_idx] = error_cpu
+
+            elif args.training_config.buffer_replacement_strategy == "l2_similarity":
+                # Original L2 similarity method - O(n), slowest but most precise
+                min_distance = float("inf")
+                most_similar_idx = -1
+
+                for j, stored_error in enumerate(recycle_vars.latent_error_buffer[(h, w)][grid_idx]):
+                    distance = compute_l2_distance(error_cpu, stored_error)
+                    if distance < min_distance:
+                        min_distance = distance
+                        most_similar_idx = j
+
+                if most_similar_idx != -1:
+                    recycle_vars.latent_error_buffer[(h, w)][grid_idx][most_similar_idx] = error_cpu
+
+
+def add_error_to_y_buffer(args, recycle_vars, error_sample, timestep, noisy_model_input):
+    """Add error sample to buffer using specified replacement strategy based on timestep grid."""
+    batch_size, _, _, h, w = noisy_model_input.shape
+    grid_indices = get_timestep_grid(args, recycle_vars, timestep, noisy_model_input)
+    error_cpu = error_sample.detach().cpu()
+
+    # Process each batch item
+    for i, grid_idx in enumerate(grid_indices):
+        grid_idx = grid_idx.item()
+        error_cpu = error_sample[i].detach().cpu()
+
+        if len(recycle_vars.y_error_buffer[(h, w)][grid_idx]) < args.training_config.error_buffer_size:
+            # Buffer not full, simply add
+            recycle_vars.y_error_buffer[(h, w)][grid_idx].append(error_cpu)
+        else:
+            # Buffer full, use specified replacement strategy
+            if args.training_config.buffer_replacement_strategy == "random":
+                # Random replacement - O(1), fastest
+                replace_idx = random.randint(0, len(recycle_vars.y_error_buffer[(h, w)][grid_idx]) - 1)
+                recycle_vars.y_error_buffer[(h, w)][grid_idx][replace_idx] = error_cpu
+
+            elif args.training_config.buffer_replacement_strategy == "fifo":
+                # First-in-first-out - O(1), simple queue behavior
+                recycle_vars.y_error_buffer[(h, w)][grid_idx].pop(0)
+                recycle_vars.y_error_buffer[(h, w)][grid_idx].append(error_cpu)
+
+            elif args.training_config.buffer_replacement_strategy == "l2_batch":
+                # Batch L2 computation - O(n) but vectorized, much faster than original
+                distances = compute_l2_distance_batch(error_cpu, recycle_vars.y_error_buffer[(h, w)][grid_idx])
+                most_similar_idx = torch.argmin(distances).item()
+                recycle_vars.y_error_buffer[(h, w)][grid_idx][most_similar_idx] = error_cpu
+
+            elif args.training_config.buffer_replacement_strategy == "l2_similarity":
+                # Original L2 similarity method - O(n), slowest but most precise
+                min_distance = float("inf")
+                most_similar_idx = -1
+
+                for j, stored_error in enumerate(recycle_vars.y_error_buffer[(h, w)][grid_idx]):
+                    distance = compute_l2_distance(error_cpu, stored_error)
+                    if distance < min_distance:
+                        min_distance = distance
+                        most_similar_idx = j
+
+                if most_similar_idx != -1:
+                    recycle_vars.y_error_buffer[(h, w)][grid_idx][most_similar_idx] = error_cpu
+
+
+def update_error_buffers_distributed(
+    args, recycle_vars, gathered_noise_errors, gathered_y_errors, gathered_timesteps, noisy_model_input
+):
+    """Update error buffers with samples gathered from all processes.
+    Args:
+        gathered_noise_errors: shape [num_gpus, batch_size, ...]
+        gathered_y_errors: shape [num_gpus, batch_size, ...]
+        gathered_timesteps: shape [num_gpus, batch_size]
+    """
+    num_gpus = gathered_noise_errors.shape[0]
+
+    # Process each GPU's batch
+    for gpu_idx in range(num_gpus):
+        noise_error_batch = gathered_noise_errors[gpu_idx]  # [batch_size, ...]
+        y_error_batch = gathered_y_errors[gpu_idx]  # [batch_size, ...]
+        timestep_batch = gathered_timesteps[gpu_idx]  # [batch_size]
+
+        # Add the entire batch to buffers
+        add_error_to_latent_buffer(args, recycle_vars, noise_error_batch, timestep_batch, noisy_model_input)
+        add_error_to_y_buffer(args, recycle_vars, y_error_batch, timestep_batch, noisy_model_input)
+
+
+def update_error_buffers_local(args, recycle_vars, noise_error, y_error, timestep, noisy_model_input):
+    """Update error buffers with samples from local GPU only (post-warmup).
+    Args:
+        noise_error: shape [batch_size, ...]
+        y_error: shape [batch_size, ...]
+        timestep: shape [batch_size] or scalar
+    """
+    add_error_to_latent_buffer(args, recycle_vars, noise_error, timestep, noisy_model_input)
+    add_error_to_y_buffer(args, recycle_vars, y_error, timestep, noisy_model_input)
+
+
+def process_and_update_error_buffers(
+    args,
+    recycle_vars,
+    accelerator,
+    global_step,
+    noise_scheduler_copy,
+    model_pred,
+    target,
+    timesteps,
+    noisy_model_input,
+    use_clean_input,
+):
+    x_0_pred = step_recycle(
+        noise_scheduler_copy,
+        model_pred,
+        timesteps,
+        noisy_model_input,
+        to_final=True,
+        self_corr=True,
+    )
+    noise_corr_gt = step_recycle(
+        noise_scheduler_copy,
+        target,
+        timesteps,
+        noisy_model_input,
+        to_final=True,
+        self_corr=True,
+    )
+    noise_error = x_0_pred - noise_corr_gt
+
+    x_1_pred = step_recycle(
+        noise_scheduler_copy,
+        model_pred,
+        timesteps,
+        noisy_model_input,
+        to_final=True,
+        self_corr=False,
+    )
+    latent_corr_gt = step_recycle(
+        noise_scheduler_copy,
+        target,
+        timesteps,
+        noisy_model_input,
+        to_final=True,
+        self_corr=False,
+    )
+    y_error = x_1_pred - latent_corr_gt
+
+    # Check if we're in warmup phase
+    if global_step <= args.training_config.buffer_warmup_iter:
+
+        def gather_with_optional_gpu_dim(tensor, keep_gpu_dim=False):
+            gathered = accelerator.gather(tensor)
+
+            if keep_gpu_dim:
+                num_processes = accelerator.num_processes
+                batch_size = tensor.shape[0]
+                gathered = gathered.view(num_processes, batch_size, *gathered.shape[1:])
+
+            return gathered
+
+        # During warmup: gather errors and timesteps from all GPUs and update buffers
+        gathered_noise_errors = gather_with_optional_gpu_dim(noise_error, keep_gpu_dim=True)
+        gathered_y_errors = gather_with_optional_gpu_dim(y_error, keep_gpu_dim=True)
+        gathered_timesteps = gather_with_optional_gpu_dim(timesteps, keep_gpu_dim=True)
+        gathered_use_clean = gather_with_optional_gpu_dim(use_clean_input, keep_gpu_dim=True)
+        # Shape: [num_gpus, batch_size]
+
+        clean_mask = gathered_use_clean  # [num_gpus, batch_size]
+        non_clean_mask = ~clean_mask  # [num_gpus, batch_size]
+        num_gpus = gathered_noise_errors.shape[0]
+
+        # Process clean samples: update with probability for each one
+        if clean_mask.any():
+            for gpu_idx in range(num_gpus):
+                gpu_clean_mask = clean_mask[gpu_idx]
+                if gpu_clean_mask.any():
+                    p = random.random()
+                    if p < args.training_config.clean_buffer_update_prob:
+                        update_error_buffers_distributed(
+                            args,
+                            recycle_vars,
+                            gathered_noise_errors[gpu_idx : gpu_idx + 1, gpu_clean_mask],
+                            gathered_y_errors[gpu_idx : gpu_idx + 1, gpu_clean_mask],
+                            gathered_timesteps[gpu_idx : gpu_idx + 1, gpu_clean_mask],
+                            noisy_model_input,
+                        )
+
+        # Process non-clean samples: always update
+        if non_clean_mask.any():
+            for gpu_idx in range(num_gpus):
+                gpu_non_clean_mask = non_clean_mask[gpu_idx]
+                if gpu_non_clean_mask.any():
+                    update_error_buffers_distributed(
+                        args,
+                        recycle_vars,
+                        gathered_noise_errors[gpu_idx : gpu_idx + 1, gpu_non_clean_mask],
+                        gathered_y_errors[gpu_idx : gpu_idx + 1, gpu_non_clean_mask],
+                        gathered_timesteps[gpu_idx : gpu_idx + 1, gpu_non_clean_mask],
+                        noisy_model_input,
+                    )
+
+    else:
+        # After warmup: only use local GPU errors
+        # Separate clean and non-clean samples
+        clean_mask = use_clean_input  # Boolean tensor
+        non_clean_mask = ~use_clean_input
+
+        # Process clean samples: update with probability
+        if clean_mask.any():
+            p = random.random()
+            if p < args.training_config.clean_buffer_update_prob:
+                update_error_buffers_local(
+                    args,
+                    recycle_vars,
+                    noise_error[clean_mask],
+                    y_error[clean_mask],
+                    timesteps[clean_mask],
+                    noisy_model_input,
+                )
+
+        # Process non-clean samples: always update
+        if non_clean_mask.any():
+            update_error_buffers_local(
+                args,
+                recycle_vars,
+                noise_error[non_clean_mask],
+                y_error[non_clean_mask],
+                timesteps[non_clean_mask],
+                noisy_model_input,
+            )

Helios/_DEV/helios/utils/utils_recycle_single.py

@@ -0,0 +1,437 @@
+import random
+
+import torch
+
+from .utils_base import apply_schedule_shift
+
+
+def apply_error_injection(
+    args,
+    recycle_vars,
+    model_input,
+    noise,
+    timesteps,
+    latents_history_long,
+    latents_history_mid,
+    latents_history_short,
+    model_input_w_error,
+    noise_w_error,
+    is_keep_x0,
+    latent_window_size,
+):
+    # Check if buffer has data for the current timestep grid
+    current_grid_idx = get_timestep_grid(args, recycle_vars, timesteps, noise)
+    has_latent_buffer_data = len(recycle_vars.latent_error_buffer[current_grid_idx]) > 0
+    has_y_buffer_data = any(len(buffer) > 0 for buffer in recycle_vars.y_error_buffer.values())
+
+    add_error_latent = False
+    add_error_noise = False
+    add_error_y = False
+    use_clean_input = False
+
+    latent_random = random.random()
+    noise_random = random.random()
+    y_random = random.random()
+    clean_random = random.random()
+
+    if latent_random < args.training_config.latent_prob:
+        add_error_latent = True
+    if noise_random < args.training_config.noise_prob:
+        add_error_noise = True
+    if y_random < args.training_config.y_prob:
+        add_error_y = True
+    if clean_random < args.training_config.clean_prob:
+        add_error_noise = False
+        add_error_y = False
+        add_error_latent = False
+        use_clean_input = True
+
+    if add_error_noise and has_latent_buffer_data:
+        noise_error_sampled = sample_noise_error_from_noise_buffer(
+            args, recycle_vars, model_input, timesteps, model_input.dtype, model_input.device
+        )
+        noise_w_error = noise + noise_error_sampled.to(model_input.dtype)
+
+    if add_error_y and has_y_buffer_data:
+        len_4x = latents_history_long.shape[2]
+        len_2x = latents_history_mid.shape[2]
+        len_1x = latents_history_short.shape[2]
+
+        hist_seq_len = len_4x + len_2x + len_1x
+        hist_seq_len_copy = hist_seq_len
+
+        ori_len_1x = len_1x
+        if is_keep_x0:
+            len_1x -= 1
+            hist_seq_len -= 1
+            begin_num = 1
+        else:
+            begin_num = 0
+
+        max_windows = hist_seq_len // latent_window_size
+        tail_num = hist_seq_len % latent_window_size
+
+        assert hist_seq_len_copy == tail_num + max_windows * latent_window_size + begin_num
+
+        tail_latents_history = None
+        begin_latents_history = None
+        if tail_num != 0:
+            tail_latents_history, latents_history_long = (
+                latents_history_long[:, :, :tail_num, :, :],
+                latents_history_long[:, :, tail_num:, :, :],
+            )
+            # for tail
+            if random.random() < args.training_config.y_prob:
+                y_error_sampled = sample_y_error_from_latent_buffer(
+                    args, recycle_vars, model_input, model_input.dtype, model_input.device
+                )
+                random_error_num = torch.randint(1, tail_num + 1, (1,)).item()
+                tail_latents_history[:, :, -random_error_num:, ...] = (
+                    tail_latents_history[:, :, -random_error_num:, ...]
+                    + y_error_sampled[:, :, -random_error_num:, ...]
+                )
+        if begin_num != 0:
+            begin_latents_history, latents_history_short = (
+                latents_history_short[:, :, :begin_num, :, :],
+                latents_history_short[:, :, begin_num:, :, :],
+            )
+            # for begin
+            if random.random() < args.training_config.y_prob:
+                y_error_sampled = sample_y_error_from_latent_buffer(
+                    args, recycle_vars, model_input, model_input.dtype, model_input.device
+                )
+                begin_latents_history = begin_latents_history + y_error_sampled[:, :, :1, ...]
+
+        # for mid
+        mid_latents_history = torch.cat([latents_history_long, latents_history_mid, latents_history_short], dim=2)
+        window_num = mid_latents_history.shape[2] // latent_window_size
+        assert mid_latents_history.shape[2] % latent_window_size == 0, (
+            f"mid length {mid_latents_history.shape[2]} not divisible by window size {latent_window_size}"
+        )
+        seq_begin = 0
+        for _ in range(window_num):
+            seq_end = seq_begin + latent_window_size
+            if random.random() < args.training_config.y_prob:
+                y_error_sampled = sample_y_error_from_latent_buffer(
+                    args, recycle_vars, model_input, model_input.dtype, model_input.device
+                )
+                max_start_idx = max(0, y_error_sampled.shape[2] - args.training_config.y_error_num)
+                random_frame_idx = torch.randint(0, max_start_idx + 1, (1,)).item()
+                error_to_add = y_error_sampled[
+                    :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, ...
+                ]
+                # Modify
+                mid_latents_history[:, :, seq_begin:seq_end, :, :][
+                    :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, :, :
+                ] = (
+                    mid_latents_history[:, :, seq_begin:seq_end, :, :][
+                        :, :, random_frame_idx : random_frame_idx + args.training_config.y_error_num, :, :
+                    ]
+                    + error_to_add
+                )
+            seq_begin = seq_end
+
+        # recover
+        recovers = []
+        if tail_latents_history is not None:
+            recovers.append(tail_latents_history)
+        recovers.append(mid_latents_history[:, :, :-len_1x, :, :])
+        if begin_latents_history is not None:
+            recovers.append(begin_latents_history)
+        recovers.append(mid_latents_history[:, :, -len_1x:, :, :])
+        mid_latents_history = torch.cat(recovers, dim=2)
+        latents_history_long, latents_history_mid, latents_history_short = mid_latents_history.split(
+            [len_4x, len_2x, ori_len_1x], dim=2
+        )
+
+    if add_error_latent and has_latent_buffer_data:
+        latent_error_sampled = sample_latent_error_from_latent_buffer(
+            args, recycle_vars, model_input, timesteps, model_input.dtype, model_input.device
+        )
+        model_input_w_error = model_input + latent_error_sampled.to(model_input.dtype)
+
+    return (
+        model_input_w_error,
+        noise_w_error,
+        latents_history_long,
+        latents_history_mid,
+        latents_history_short,
+        use_clean_input,
+    )
+
+
+def step_recycle(scheduler, model_output, timestep, sample, to_final=False, self_corr=False):
+    if isinstance(timestep, torch.Tensor):
+        timestep = timestep.cpu()
+    timestep_id = torch.argmin((scheduler.temp_timesteps - timestep).abs())
+    sigma = scheduler.temp_sigmas[timestep_id]
+    if to_final or timestep_id + 1 >= len(scheduler.temp_timesteps):
+        sigma_ = 1 if self_corr else 0
+    else:
+        sigma_ = scheduler.temp_sigmas[timestep_id + 1]
+    prev_sample = sample + model_output * (sigma_ - sigma)
+    return prev_sample
+
+
+def get_timesteps(
+    num_inference_steps=50,
+    denoising_strength=1,
+    shift=1.0,
+    num_train_timesteps=1000,
+    sigma_max=1.0,
+    sigma_min=0.0,
+    inverse_timesteps=False,
+    extra_one_step=True,
+    reverse_sigmas=False,
+):
+    sigma_start = sigma_min + (sigma_max - sigma_min) * denoising_strength
+    if extra_one_step:
+        sigmas = torch.linspace(sigma_start, sigma_min, num_inference_steps + 1)[:-1]
+    else:
+        sigmas = torch.linspace(sigma_start, sigma_min, num_inference_steps)
+    if inverse_timesteps:
+        sigmas = torch.flip(sigmas, dims=[0])
+    sigmas = shift * sigmas / (1 + (shift - 1) * sigmas)
+    if reverse_sigmas:
+        sigmas = 1 - sigmas
+    timesteps = sigmas * num_train_timesteps
+    return timesteps, sigmas
+
+
+def get_timestep_grid(args, recycle_vars, timesteps, noise):
+    """Get the grid index for a given timesteps."""
+    # Handle different timesteps formats (scalar tensor, tensor with batch dim, etc.)
+    if isinstance(timesteps, torch.Tensor):
+        if timesteps.numel() == 1:
+            # Single timesteps value
+            timestep_val = timesteps.item()
+        else:
+            # Tensor with batch dimension, take the first element
+            timestep_val = timesteps.flatten()[0].item()
+    else:
+        # Already a scalar value
+        timestep_val = timesteps
+
+    if args.training_config.use_dynamic_shifting:
+        temp_sigmas = apply_schedule_shift(
+            recycle_vars.recycle_sigmas,
+            noise,
+            base_seq_len=args.training_config.base_seq_len,
+            max_seq_len=args.training_config.max_seq_len,
+            base_shift=args.training_config.base_shift,
+            max_shift=args.training_config.max_shift,
+        )  # torch.Size([2, 1, 1, 1, 1])
+
+        temp_inferece_timesteps = temp_sigmas * 1000.0  # rescale to [0, 1000.0)
+        while temp_inferece_timesteps.ndim > 1:
+            temp_inferece_timesteps = temp_inferece_timesteps.squeeze(-1)
+    else:
+        temp_inferece_timesteps = recycle_vars.recycle_inferece_timesteps
+
+    # Ensure timesteps is within valid range and calculate grid index
+    timestep_val = max(0, min(timestep_val, 999))  # Clamp to [0, 999]
+    grid_idx = torch.argmin((temp_inferece_timesteps - timestep_val).abs()).item()
+
+    # Ensure grid index is within valid range
+    max_grid_idx = len(recycle_vars.latent_error_buffer) - 1
+    grid_idx = min(grid_idx, max_grid_idx)
+
+    return grid_idx
+
+
+def sample_noise_error_from_noise_buffer(args, recycle_vars, latents, timestep, dtype=torch.bfloat16, device="cpu"):
+    """Randomly sample an error from the buffer based on timestep grid."""
+    grid_idx = get_timestep_grid(args, recycle_vars, timestep, latents)
+
+    if not recycle_vars.latent_error_buffer[grid_idx]:
+        return torch.zeros_like(latents)
+
+    # Randomly select one sample from the corresponding grid
+    selected_sample = random.choice(recycle_vars.latent_error_buffer[grid_idx])
+    error_sample = selected_sample
+
+    min_mod = 1.0 - args.training_config.error_modulate_factor
+    max_mod = 1.0 + args.training_config.error_modulate_factor
+    intensity_mod = random.uniform(min_mod, max_mod)
+    error_sample = error_sample * intensity_mod
+
+    error_sample = error_sample.to(device, dtype=dtype)
+
+    return error_sample
+
+
+def sample_latent_error_from_latent_buffer(args, recycle_vars, latents, timestep, dtype=torch.bfloat16, device="cpu"):
+    """Randomly sample an error from the buffer based on timestep grid."""
+    grid_idx = get_timestep_grid(args, recycle_vars, timestep, latents)
+
+    if not recycle_vars.y_error_buffer[grid_idx]:
+        return torch.zeros_like(latents)
+
+    # Randomly select one sample from the corresponding grid
+    selected_sample = random.choice(recycle_vars.y_error_buffer[grid_idx])
+    error_sample = selected_sample
+
+    min_mod = 1.0 - args.training_config.error_modulate_factor
+    max_mod = 1.0 + args.training_config.error_modulate_factor
+    intensity_mod = random.uniform(min_mod, max_mod)
+    error_sample = error_sample * intensity_mod
+
+    error_sample = error_sample.to(device, dtype=dtype)
+
+    return error_sample
+
+
+def sample_y_error_from_latent_buffer(args, recycle_vars, latents, dtype=torch.bfloat16, device="cpu"):
+    """Specially sample y_error from buffer - can be configured to sample from all grids or custom range."""
+    # Sample from all grids that have data
+    all_samples = []
+    for grid_idx, buffer in recycle_vars.y_error_buffer.items():
+        if buffer:  # Only add non-empty buffers
+            all_samples.extend(buffer)
+
+    if not all_samples:
+        return torch.zeros_like(latents)
+
+    # Randomly select one sample from all available samples
+    selected_sample = random.choice(all_samples)
+    error_sample = selected_sample
+
+    min_mod = 1.0 - args.training_config.error_modulate_factor
+    max_mod = 1.0 + args.training_config.error_modulate_factor
+    intensity_mod = random.uniform(min_mod, max_mod)
+    error_sample = error_sample * intensity_mod
+
+    error_sample = error_sample.to(device, dtype=dtype)
+
+    return error_sample
+
+
+def compute_l2_distance_batch(new_tensor, stored_tensors):
+    """Compute L2 distances between new tensor and all stored tensors efficiently."""
+    if not stored_tensors:
+        return torch.tensor([])
+
+    # Stack all stored tensors for batch computation
+    stored_stack = torch.stack(stored_tensors)  # [num_stored, ...]
+    new_flat = new_tensor.flatten()
+    stored_flat = stored_stack.flatten(start_dim=1)  # [num_stored, flattened_size]
+
+    # Compute L2 distances in batch
+    distances = torch.norm(stored_flat - new_flat.unsqueeze(0), p=2, dim=1)
+    return distances
+
+
+def compute_l2_distance(tensor1, tensor2):
+    """Compute L2 distance between two tensors"""
+    # Flatten tensors
+    flat1 = tensor1.flatten()
+    flat2 = tensor2.flatten()
+
+    # Compute L2 distance (Euclidean distance)
+    l2_distance = torch.norm(flat1 - flat2, p=2)
+    return l2_distance.item()
+
+
+def add_error_to_latent_buffer(args, recycle_vars, error_sample, timestep, noisy_model_input):
+    """Add error sample to buffer using specified replacement strategy based on timestep grid."""
+    grid_idx = get_timestep_grid(args, recycle_vars, timestep, noisy_model_input)
+    error_cpu = error_sample.detach().cpu()
+
+    if len(recycle_vars.latent_error_buffer[grid_idx]) < args.training_config.error_buffer_size:
+        # Buffer not full, simply add
+        recycle_vars.latent_error_buffer[grid_idx].append(error_cpu)
+    else:
+        # Buffer full, use specified replacement strategy
+        if args.training_config.buffer_replacement_strategy == "random":
+            # Random replacement - O(1), fastest
+            replace_idx = random.randint(0, len(recycle_vars.latent_error_buffer[grid_idx]) - 1)
+            recycle_vars.latent_error_buffer[grid_idx][replace_idx] = error_cpu
+
+        elif args.training_config.buffer_replacement_strategy == "fifo":
+            # First-in-first-out - O(1), simple queue behavior
+            recycle_vars.latent_error_buffer[grid_idx].pop(0)
+            recycle_vars.latent_error_buffer[grid_idx].append(error_cpu)
+
+        elif args.training_config.buffer_replacement_strategy == "l2_batch":
+            # Batch L2 computation - O(n) but vectorized, much faster than original
+            distances = compute_l2_distance_batch(error_cpu, recycle_vars.latent_error_buffer[grid_idx])
+            most_similar_idx = torch.argmin(distances).item()
+            recycle_vars.latent_error_buffer[grid_idx][most_similar_idx] = error_cpu
+
+        elif args.training_config.buffer_replacement_strategy == "l2_similarity":
+            # Original L2 similarity method - O(n), slowest but most precise
+            min_distance = float("inf")
+            most_similar_idx = -1
+
+            for i, stored_error in enumerate(recycle_vars.latent_error_buffer[grid_idx]):
+                distance = compute_l2_distance(error_cpu, stored_error)
+                if distance < min_distance:
+                    min_distance = distance
+                    most_similar_idx = i
+
+            if most_similar_idx != -1:
+                recycle_vars.latent_error_buffer[grid_idx][most_similar_idx] = error_cpu
+
+
+def add_error_to_y_buffer(args, recycle_vars, error_sample, timestep, noisy_model_input):
+    """Add error sample to buffer using specified replacement strategy based on timestep grid."""
+    grid_idx = get_timestep_grid(args, recycle_vars, timestep, noisy_model_input)
+    error_cpu = error_sample.detach().cpu()
+
+    if len(recycle_vars.y_error_buffer[grid_idx]) < args.training_config.error_buffer_size:
+        # Buffer not full, simply add
+        recycle_vars.y_error_buffer[grid_idx].append(error_cpu)
+    else:
+        # Buffer full, use specified replacement strategy
+        if args.training_config.buffer_replacement_strategy == "random":
+            # Random replacement - O(1), fastest
+            replace_idx = random.randint(0, len(recycle_vars.y_error_buffer[grid_idx]) - 1)
+            recycle_vars.y_error_buffer[grid_idx][replace_idx] = error_cpu
+
+        elif args.training_config.buffer_replacement_strategy == "fifo":
+            # First-in-first-out - O(1), simple queue behavior
+            recycle_vars.y_error_buffer[grid_idx].pop(0)
+            recycle_vars.y_error_buffer[grid_idx].append(error_cpu)
+
+        elif args.training_config.buffer_replacement_strategy == "l2_batch":
+            # Batch L2 computation - O(n) but vectorized, much faster than original
+            distances = compute_l2_distance_batch(error_cpu, recycle_vars.y_error_buffer[grid_idx])
+            most_similar_idx = torch.argmin(distances).item()
+            recycle_vars.y_error_buffer[grid_idx][most_similar_idx] = error_cpu
+
+        elif args.training_config.buffer_replacement_strategy == "l2_similarity":
+            # Original L2 similarity method - O(n), slowest but most precise
+            min_distance = float("inf")
+            most_similar_idx = -1
+
+            for i, stored_error in enumerate(recycle_vars.y_error_buffer[grid_idx]):
+                distance = compute_l2_distance(error_cpu, stored_error)
+                if distance < min_distance:
+                    min_distance = distance
+                    most_similar_idx = i
+
+            if most_similar_idx != -1:
+                recycle_vars.y_error_buffer[grid_idx][most_similar_idx] = error_cpu
+
+
+def update_error_buffers_distributed(
+    args, recycle_vars, gathered_noise_errors, gathered_y_errors, gathered_timesteps, noisy_model_input
+):
+    """Update error buffers with samples gathered from all processes."""
+    # gathered_tensors have shape [num_gpus, batch_size, ...] for errors
+    # gathered_timesteps have shape [num_gpus, batch_size] for timesteps
+    # In this case, batch_size is 1, so shapes are [num_gpus, 1, ...] and [num_gpus, 1]
+    num_gpus = gathered_noise_errors.shape[0]
+    for i in range(num_gpus):
+        noise_error_sample = gathered_noise_errors[i]
+        y_error_sample = gathered_y_errors[i]
+        timestep_sample = gathered_timesteps[i]  # Get the corresponding timestep for this GPU
+
+        add_error_to_latent_buffer(args, recycle_vars, noise_error_sample, timestep_sample, noisy_model_input)
+        add_error_to_y_buffer(args, recycle_vars, y_error_sample, timestep_sample, noisy_model_input)
+
+
+def update_error_buffers_local(args, recycle_vars, noise_error, y_error, timestep, noisy_model_input):
+    """Update error buffers with samples from local GPU only (post-warmup)."""
+    add_error_to_latent_buffer(args, recycle_vars, noise_error, timestep, noisy_model_input)
+    add_error_to_y_buffer(args, recycle_vars, y_error, timestep, noisy_model_input)

Helios/_DEV/helios/videoalign/data.py

@@ -0,0 +1,278 @@
+from dataclasses import dataclass
+from typing import List, Union
+
+import torch
+
+from .prompt_template import build_prompt
+from .vision_process import process_vision_info
+
+
+@dataclass
+class DataConfig:
+    meta_data: str = "/path/to/dataset/meta_data.csv"
+    data_dir: str = "/path/to/dataset"
+    meta_data_test: str = None
+    max_frame_pixels: int = 240 * 320
+    num_frames: float = None
+    fps: float = 2.0
+    p_shuffle_frames: float = 0.0
+    p_color_jitter: float = 0.0
+    eval_dim: Union[str, List[str]] = "VQ"
+    prompt_template_type: str = "none"
+    add_noise: bool = False
+    sample_type: str = "uniform"
+    use_tied_data: bool = True
+
+
+def convert_GSB_csv_to_reward_data(
+    example,
+    data_dir,
+    eval_dims=["VQ"],
+    max_pixels=448 * 448,
+    fps=2.0,
+    num_frames=None,
+    prompt_template_type="none",
+    sample_type="uniform",
+):
+    """
+    Convert Good/Same/Bad csv data to reward data.
+
+    Args:
+        example (dict): A dataframe containing the GSB csv data.
+        data_dir (str): The directory path to the video files.
+        eval_dim (str): The dimension to evaluate ("VQ"/"MQ"/"TA").
+        max_pixels (int): The maximum number of pixels allowed for videos.
+        num_frames (float): Number of frames.
+        prompt_template_type (str): The type of prompt template to use ("none"/"simple"/"video_score").
+
+    Returns:
+        dict: A dictionary containing the reward data.
+    """
+
+    A_data = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "video",
+                    "video": f"file://{data_dir}/{example['path_A']}",
+                    "max_pixels": max_pixels,
+                    "fps": fps if num_frames is None else None,
+                    "nframes": min(num_frames, example["num_frames_A"]) if num_frames is not None else None,
+                    "sample_type": sample_type,
+                },
+                {"type": "text", "text": build_prompt(example["prompt"], eval_dims, prompt_template_type)},
+            ],
+        }
+    ]
+    B_data = [
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "video",
+                    "video": f"file://{data_dir}/{example['path_B']}",
+                    "max_pixels": max_pixels,
+                    "fps": fps if num_frames is None else None,
+                    "nframes": min(num_frames, example["num_frames_B"]) if num_frames is not None else None,
+                    "sample_type": sample_type,
+                },
+                {"type": "text", "text": build_prompt(example["prompt"], eval_dims, prompt_template_type)},
+            ],
+        }
+    ]
+
+    chosen_labels = []
+    A_scores = []
+    B_scores = []
+
+    for eval_dim in eval_dims:
+        ### chosen_label: 1 if A is chosen, -1 if B is chosen, 0 if tied.
+        ### 22 if invalid. ooaaeeaa o.O
+        try:
+            if example[f"{eval_dim}"] is not None:
+                if example[f"{eval_dim}"] == "A":
+                    chosen_label = 1
+                elif example[f"{eval_dim}"] == "B":
+                    chosen_label = -1
+                elif example[f"{eval_dim}"] == "same":
+                    chosen_label = 0
+                elif example[f"{eval_dim}"] == "invalid":
+                    chosen_label = 22
+                else:
+                    chosen_label = 22
+            else:
+                chosen_label = 22
+        except Exception:
+            chosen_label = 22
+
+        chosen_labels.append(chosen_label)
+        if f"MOS_A_{eval_dim}" in example and f"MOS_B_{eval_dim}" in example:
+            try:
+                A_score = example[f"MOS_A_{eval_dim}"] if example[f"MOS_A_{eval_dim}"] is not None else 0.0
+                B_score = example[f"MOS_B_{eval_dim}"] if example[f"MOS_B_{eval_dim}"] is not None else 0.0
+            except Exception:
+                A_score = 0.0
+                B_score = 0.0
+            A_scores.append(A_score)
+            B_scores.append(B_score)
+        else:
+            A_scores.append(0.0)
+            B_scores.append(0.0)
+
+    chosen_labels = torch.tensor(chosen_labels, dtype=torch.long)
+    A_scores = torch.tensor(A_scores, dtype=torch.float)
+    B_scores = torch.tensor(B_scores, dtype=torch.float)
+    metainfo_idx = None
+    if "metainfo_idx" in example:
+        metainfo_idx = example["metainfo_idx"]
+
+    return {
+        "A_data": A_data,
+        "B_data": B_data,
+        "A_scores": A_scores,
+        "B_scores": B_scores,
+        "chosen_label": chosen_labels,
+        "metainfo_idx": metainfo_idx,
+    }
+
+
+class QWen2VLDataCollator:
+    def __init__(self, processor, add_noise=False, p_shuffle_frames=0.0, p_color_jitter=0.0):
+        self.processor = processor
+        self.add_noise = add_noise
+        self.set_noise_step = None
+
+        self.p_shuffle_frames = p_shuffle_frames
+        self.p_color_jitter = p_color_jitter
+
+        self.noise_adder = None
+
+    def _clean_message(self, message):
+        """
+        remove unnecessary keys from message(very very necessary)
+        """
+        out_message = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "video",
+                        "video": message[0]["content"][0]["video"],
+                        "max_pixels": message[0]["content"][0]["max_pixels"],
+                        "fps": message[0]["content"][0]["fps"] if "fps" in message[0]["content"][0] else None,
+                        "nframes": message[0]["content"][0]["nframes"]
+                        if "nframes" in message[0]["content"][0]
+                        else None,
+                        "sample_type": message[0]["content"][0]["sample_type"]
+                        if "sample_type" in message[0]["content"][0]
+                        else "uniform",
+                    },
+                    {"type": "text", "text": message[0]["content"][1]["text"]},
+                ],
+            }
+        ]
+
+        if out_message[0]["content"][0]["fps"] is None:
+            out_message[0]["content"][0].pop("fps")
+        if out_message[0]["content"][0]["nframes"] is None:
+            out_message[0]["content"][0].pop("nframes")
+
+        return out_message
+
+    def _pad_sequence(self, sequences, attention_mask, max_len, padding_side="right"):
+        """
+        Pad the sequences to the maximum length.
+        """
+        assert padding_side in ["right", "left"]
+        if sequences.shape[1] >= max_len:
+            return sequences, attention_mask
+
+        pad_len = max_len - sequences.shape[1]
+        padding = (0, pad_len) if padding_side == "right" else (pad_len, 0)
+
+        sequences_padded = torch.nn.functional.pad(
+            sequences, padding, "constant", self.processor.tokenizer.pad_token_id
+        )
+        attention_mask_padded = torch.nn.functional.pad(attention_mask, padding, "constant", 0)
+
+        return sequences_padded, attention_mask_padded
+
+    def __call__(self, features, enable_noise=True):
+        """
+        Preprocess inputs to token sequences and return a batch
+        """
+        # try:
+        features_A = []
+        features_B = []
+        # check if we have a margin. If we do, we need to batch it as well
+        # has_margin = "margin" in features[0]
+        has_idx = "metainfo_idx" in features[0] and features[0]["metainfo_idx"] is not None
+
+        for idx, feature in enumerate(features):
+            features_A.append(self._clean_message(feature["A_data"]))
+            features_B.append(self._clean_message(feature["B_data"]))
+
+        # import pdb; pdb.set_trace()
+        image_inputs_A, video_inputs_A = process_vision_info(features_A)
+        image_inputs_B, video_inputs_B = process_vision_info(features_B)
+
+        video_inputs_A = [video_inputs_A[i].float() / 255.0 for i in range(len(video_inputs_A))]
+        video_inputs_B = [video_inputs_B[i].float() / 255.0 for i in range(len(video_inputs_B))]
+        do_rescale = False
+        # print(f"{video_inputs_A[0].shape}, {video_inputs_B[0].shape}")
+
+        # if not enable_noise:
+        #     print("Not training, no noise added.")
+        batch_A = self.processor(
+            text=self.processor.apply_chat_template(features_A, tokenize=False, add_generation_prompt=True),
+            images=image_inputs_A,
+            videos=video_inputs_A,
+            padding=True,
+            return_tensors="pt",
+            videos_kwargs={"do_rescale": do_rescale},
+        )
+        batch_B = self.processor(
+            text=self.processor.apply_chat_template(features_B, tokenize=False, add_generation_prompt=True),
+            images=image_inputs_B,
+            videos=video_inputs_B,
+            padding=True,
+            return_tensors="pt",
+            videos_kwargs={"do_rescale": do_rescale},
+        )
+
+        # pdb.set_trace()
+        max_len = max(batch_A["input_ids"].shape[1], batch_B["input_ids"].shape[1])
+        batch_A["input_ids"], batch_A["attention_mask"] = self._pad_sequence(
+            batch_A["input_ids"], batch_A["attention_mask"], max_len, "right"
+        )
+        batch_B["input_ids"], batch_B["attention_mask"] = self._pad_sequence(
+            batch_B["input_ids"], batch_B["attention_mask"], max_len, "right"
+        )
+        # print(f"Batch A: {batch_A['input_ids'].shape}, Batch B: {batch_B['input_ids'].shape}")
+
+        chosen_label = torch.stack([torch.tensor(feature["chosen_label"]) for feature in features])
+
+        A_scores = torch.stack([torch.tensor(feature["A_scores"]) for feature in features])
+        B_scores = torch.stack([torch.tensor(feature["B_scores"]) for feature in features])
+
+        batch = {
+            "A": batch_A,
+            "B": batch_B,
+            "return_loss": True,
+            "chosen_label": chosen_label,
+            "A_scores": A_scores,
+            "B_scores": B_scores,
+        }
+
+        if has_idx:
+            metainfo_idx = torch.stack([torch.tensor(feature["metainfo_idx"]) for feature in features])
+            batch["metainfo_idx"] = metainfo_idx
+
+        # pdb.set_trace()
+        return batch
+
+        # except Exception as e:
+        #     print(f"Error processing batch: {e} in reading.")
+        #     # get next batch
+        #     return None

Helios/_DEV/helios/videoalign/inference.py

@@ -0,0 +1,321 @@
+import json
+import os
+
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+from collections.abc import Mapping
+
+import torch
+
+from .data import DataConfig
+from .prompt_template import build_prompt
+from .train_reward import create_model_and_processor
+from .utils import ModelConfig, PEFTLoraConfig, TrainingConfig, load_model_from_checkpoint
+from .vision_process import process_video_tensor, process_vision_info
+
+
+def load_configs_from_json(config_path):
+    with open(config_path, "r") as f:
+        config_dict = json.load(f)
+
+    # del config_dict["training_args"]["_n_gpu"]
+    del config_dict["data_config"]["meta_data"]
+    del config_dict["data_config"]["data_dir"]
+
+    return (
+        config_dict["data_config"],
+        None,
+        config_dict["model_config"],
+        config_dict["peft_lora_config"],
+        config_dict["inference_config"] if "inference_config" in config_dict else None,
+    )
+
+
+class VideoVLMRewardInference:
+    def __init__(self, load_from_pretrained, load_from_pretrained_step=-1, device="cuda", dtype=torch.bfloat16):
+        config_path = os.path.join(load_from_pretrained, "model_config.json")
+        data_config, _, model_config, peft_lora_config, inference_config = load_configs_from_json(config_path)
+        data_config = DataConfig(**data_config)
+        model_config = ModelConfig(**model_config)
+        peft_lora_config = PEFTLoraConfig(**peft_lora_config)
+
+        training_args = TrainingConfig(
+            load_from_pretrained=load_from_pretrained,
+            load_from_pretrained_step=load_from_pretrained_step,
+            gradient_checkpointing=False,
+            disable_flash_attn2=False,
+            bf16=True if dtype == torch.bfloat16 else False,
+            fp16=True if dtype == torch.float16 else False,
+            output_dir="",
+        )
+
+        model, processor, peft_config = create_model_and_processor(
+            model_config=model_config,
+            peft_lora_config=peft_lora_config,
+            training_args=training_args,
+        )
+
+        self.device = device
+
+        model, checkpoint_step = load_model_from_checkpoint(model, load_from_pretrained, load_from_pretrained_step)
+        model.eval()
+
+        self.model = model
+        self.processor = processor
+
+        self.model.to(self.device)
+
+        self.data_config = data_config
+
+        self.inference_config = inference_config
+
+    def _norm(self, reward):
+        if self.inference_config is None:
+            return reward
+        else:
+            reward["VQ"] = (reward["VQ"] - self.inference_config["VQ_mean"]) / self.inference_config["VQ_std"]
+            reward["MQ"] = (reward["MQ"] - self.inference_config["MQ_mean"]) / self.inference_config["MQ_std"]
+            reward["TA"] = (reward["TA"] - self.inference_config["TA_mean"]) / self.inference_config["TA_std"]
+            return reward
+
+    def _pad_sequence(self, sequences, attention_mask, max_len, padding_side="right"):
+        """
+        Pad the sequences to the maximum length.
+        """
+        assert padding_side in ["right", "left"]
+        if sequences.shape[1] >= max_len:
+            return sequences, attention_mask
+
+        pad_len = max_len - sequences.shape[1]
+        padding = (0, pad_len) if padding_side == "right" else (pad_len, 0)
+
+        sequences_padded = torch.nn.functional.pad(
+            sequences, padding, "constant", self.processor.tokenizer.pad_token_id
+        )
+        attention_mask_padded = torch.nn.functional.pad(attention_mask, padding, "constant", 0)
+
+        return sequences_padded, attention_mask_padded
+
+    def _prepare_input(self, data):
+        """
+        Prepare `inputs` before feeding them to the model, converting them to tensors if they are not already and
+        handling potential state.
+        """
+        if isinstance(data, Mapping):
+            return type(data)({k: self._prepare_input(v) for k, v in data.items()})
+        elif isinstance(data, (tuple, list)):
+            return type(data)(self._prepare_input(v) for v in data)
+        elif isinstance(data, torch.Tensor):
+            kwargs = {"device": self.device}
+            ## TODO: Maybe need to add dtype
+            # if self.is_deepspeed_enabled and (torch.is_floating_point(data) or torch.is_complex(data)):
+            #     # NLP models inputs are int/uint and those get adjusted to the right dtype of the
+            #     # embedding. Other models such as wav2vec2's inputs are already float and thus
+            #     # may need special handling to match the dtypes of the model
+            #     kwargs.update({"dtype": self.accelerator.state.deepspeed_plugin.hf_ds_config.dtype()})
+            return data.to(**kwargs)
+        return data
+
+    def _prepare_inputs(self, inputs):
+        """
+        Prepare `inputs` before feeding them to the model, converting them to tensors if they are not already and
+        handling potential state.
+        """
+        inputs = self._prepare_input(inputs)
+        if len(inputs) == 0:
+            raise ValueError
+        return inputs
+
+    def prepare_batch(self, videos, prompts, fps=None, num_frames=None, max_pixels=None):
+        """
+        Modified to accept either file paths (str) or Tensors (torch.Tensor) in 'videos'.
+        """
+        fps = self.data_config.fps if fps is None else fps
+        num_frames = self.data_config.num_frames if num_frames is None else num_frames
+        max_pixels = self.data_config.max_frame_pixels if max_pixels is None else max_pixels
+
+        if isinstance(videos, list) and all(isinstance(v, torch.Tensor) for v in videos):
+            chat_data = [
+                [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "video", "video": "file://dummy_path"},
+                            {
+                                "type": "text",
+                                "text": build_prompt(
+                                    prompt, self.data_config.eval_dim, self.data_config.prompt_template_type
+                                ),
+                            },
+                        ],
+                    }
+                ]
+                for prompt in prompts
+            ]
+
+            image_inputs = None
+            video_inputs = [process_video_tensor(tensor) for tensor in videos]
+        else:
+            if num_frames is None:
+                chat_data = [
+                    [
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "video",
+                                    "video": f"file://{video_path}",
+                                    "max_pixels": max_pixels,
+                                    "fps": fps,
+                                    "sample_type": self.data_config.sample_type,
+                                },
+                                {
+                                    "type": "text",
+                                    "text": build_prompt(
+                                        prompt, self.data_config.eval_dim, self.data_config.prompt_template_type
+                                    ),
+                                },
+                            ],
+                        },
+                    ]
+                    for video_path, prompt in zip(videos, prompts)
+                ]
+            else:
+                chat_data = [
+                    [
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "video",
+                                    "video": f"file://{video_path}",
+                                    "max_pixels": max_pixels,
+                                    "nframes": num_frames,
+                                    "sample_type": self.data_config.sample_type,
+                                },
+                                {
+                                    "type": "text",
+                                    "text": build_prompt(
+                                        prompt, self.data_config.eval_dim, self.data_config.prompt_template_type
+                                    ),
+                                },
+                            ],
+                        },
+                    ]
+                    for video_path, prompt in zip(videos, prompts)
+                ]
+            image_inputs, video_inputs = process_vision_info(chat_data)
+
+        batch = self.processor(
+            text=self.processor.apply_chat_template(chat_data, tokenize=False, add_generation_prompt=True),
+            images=image_inputs,
+            videos=video_inputs,
+            padding=True,
+            return_tensors="pt",
+            videos_kwargs={"do_rescale": True},
+        )
+        batch = self._prepare_inputs(batch)
+        return batch
+
+    def reward(
+        self,
+        videos,
+        prompts,
+        fps=None,
+        num_frames=None,
+        max_pixels=None,
+        use_norm=True,
+        return_batch_score=False,
+        device="cpu",
+        dtype=torch.float32,
+    ):
+        """
+        videos: List[str] (paths) OR List[torch.Tensor]
+        """
+        assert fps is None or num_frames is None, "fps and num_frames cannot be set at the same time."
+
+        batch = self.prepare_batch(videos, prompts, fps, num_frames, max_pixels)
+        rewards = self.model(return_dict=True, **batch)["logits"]
+
+        rewards = [{"VQ": reward[0].item(), "MQ": reward[1].item(), "TA": reward[2].item()} for reward in rewards]
+        for i in range(len(rewards)):
+            if use_norm:
+                rewards[i] = self._norm(rewards[i])
+            rewards[i]["Overall"] = rewards[i]["VQ"] + rewards[i]["MQ"] + rewards[i]["TA"]
+        if return_batch_score:
+            batch_score = {
+                "VQ": torch.tensor(sum(r["VQ"] for r in rewards) / len(rewards), device=device, dtype=dtype),
+                "MQ": torch.tensor(sum(r["MQ"] for r in rewards) / len(rewards), device=device, dtype=dtype),
+                "TA": torch.tensor(sum(r["TA"] for r in rewards) / len(rewards), device=device, dtype=dtype),
+                "Overall": torch.tensor(sum(r["Overall"] for r in rewards) / len(rewards), device=device, dtype=dtype),
+            }
+            return batch_score
+
+        return rewards
+
+
+def main():
+    load_from_pretrained = "/mnt/bn/yufan-dev-my/ysh_new/Ckpts/Videoreward"
+    device = "cuda:0"
+    dtype = torch.bfloat16
+
+    inferencer = VideoVLMRewardInference(load_from_pretrained, device=device, dtype=dtype)
+
+    video_paths = [
+        "/mnt/bn/yufan-dev-my/ysh_new/Codes/0_exps/0_results/t2v/short/sana-video/2_240_ori81.mp4",
+        "/mnt/bn/yufan-dev-my/ysh_new/Codes/0_exps/0_results/t2v/short/sana-video/4_240_ori81.mp4",
+        "/mnt/bn/yufan-dev-my/ysh_new/Codes/0_exps/0_results/t2v/short/sana-video/5_240_ori81.mp4",
+    ]
+
+    prompts = [
+        "A stunning mid-afternoon landscape photograph with a low camera angle, showcasing several giant wooly mammoths treading through a snowy meadow. Their long, wooly fur gently billows in the brisk wind as they move, creating a sense of natural movement. Snow-covered trees and dramatic snow-capped mountains loom in the distance, adding to the majestic setting. Wispy clouds and a high sun cast a warm glow over the scene, enhancing the serene and awe-inspiring atmosphere. The depth of field brings out the detailed textures of the mammoths and the snowy environment, capturing every nuance of these prehistoric giants in breathtaking clarity.",
+        "A drone view of waves crashing against the rugged cliffs along Big Sur’s Garay Point beach. The crashing blue waters create white-tipped waves, while the golden light of the setting sun illuminates the rocky shore, casting long shadows. In the distance, a small island with a lighthouse stands tall, its beam piercing the twilight. Green shrubbery covers the cliff’s edge, and the steep drop from the road down to the beach is a dramatic feat, with the cliff’s edges jutting out over the sea. The camera angle provides a bird's-eye view, capturing the raw beauty of the coast and the rugged landscape of the Pacific Coast Highway. The scene is bathed in a warm, golden hue, highlighting the textures and details of the rocky terrain.",
+        "A close-up 3D animated scene of a short, fluffy monster kneeling beside a melting red candle. The monster has large, wide eyes and an open mouth, gazing at the flame with a look of wonder and curiosity. Its soft, fluffy fur contrasts with the warm, dramatic lighting that highlights every detail of its gentle, innocent expression. The pose conveys a sense of playfulness and exploration, as if the creature is discovering the world for the first time. The background features a cozy, warmly lit room with subtle hints of a fireplace and soft furnishings, enhancing the overall atmosphere. The use of warm colors and dramatic lighting creates a captivating and inviting scene.",
+    ]
+
+    # # Way 1
+    print(f"\n{'=' * 20} Way 1: File Path Input {'=' * 20}")
+    with torch.no_grad():
+        rewards_path = inferencer.reward(video_paths, prompts, use_norm=True)
+        print(rewards_path)
+
+    # Way 2
+    print(f"\n{'=' * 20} Way 2: Tensor Input {'=' * 20}")
+    from video_reader import PyVideoReader
+
+    video_tensors = []
+    print("Loading videos into Tensors manually...")
+    for i, path in enumerate(video_paths):
+        vr = PyVideoReader(path, threads=0)
+        frames = vr.get_batch(range(len(vr)))
+        tensor_input = torch.tensor(frames).permute(0, 3, 1, 2)
+        video_tensors.append(tensor_input)
+    del video_paths
+
+    print(f"Loaded {len(video_tensors)} tensors.")
+
+    with torch.no_grad():
+        rewards_tensor = inferencer.reward(
+            video_tensors,  # [torch.Size([249, 3, 480, 832]), torch.Size([249, 3, 480, 832]), torch.Size([249, 3, 480, 832])]
+            prompts,
+            use_norm=True,
+            return_batch_score=False,
+        )
+        print(rewards_tensor)
+
+    # --- 验证环节 ---
+    print(f"\n{'=' * 20} Verification {'=' * 20}")
+    for i, (r_path, r_tensor) in enumerate(zip(rewards_path, rewards_tensor)):
+        score_path = r_path["Overall"]
+        score_tensor = r_tensor["Overall"]
+        diff = abs(score_path - score_tensor)
+
+        status = "✅ CONSISTENT" if diff < 1e-3 else "❌ MISMATCH"
+        print(f"Video {i + 1}:")
+        print(f"  Path Input Score:   {score_path:.4f}")
+        print(f"  Tensor Input Score: {score_tensor:.4f}")
+        print(f"  Difference:         {diff:.6f} -> {status}")
+
+
+if __name__ == "__main__":
+    main()

Helios/_DEV/helios/videoalign/prompt_template.py

@@ -0,0 +1,129 @@
+VIDEOSCORE_QUERY_PROMPT = """
+Suppose you are an expert in judging and evaluating the quality of AI-generated videos,
+please watch the frames of a given video and see the text prompt for generating the video,
+then give scores based on its {dimension_name}, i.e., {dimension_description}.
+Output a float number from 1.0 to 5.0 for this dimension,
+the higher the number is, the better the video performs in that sub-score,
+the lowest 1.0 means Bad, the highest 5.0 means Perfect/Real (the video is like a real video).
+The text prompt used for generation is "{text_prompt}".
+"""
+
+DIMENSION_DESCRIPTIONS = {
+    "VQ": ["visual quality", "the quality of the video in terms of clearness, resolution, brightness, and color"],
+    "TA": ["text-to-video alignment", "the alignment between the text prompt and the video content and motion"],
+    "MQ": ["motion quality", "the quality of the motion in terms of consistency, smoothness, and completeness"],
+    "Overall": [
+        "Overall Performance",
+        "the overall performance of the video in terms of visual quality, text-to-video alignment, and motion quality",
+    ],
+}
+
+SIMPLE_PROMPT = """
+Please evaluate the {dimension_name} of a generated video. Consider {dimension_description}.
+The text prompt used for generation is "{text_prompt}".
+"""
+
+DETAILED_PROMPT_WITH_SPECIAL_TOKEN = """
+You are tasked with evaluating a generated video based on three distinct criteria: Visual Quality, Motion Quality, and Text Alignment. Please provide a rating from 0 to 10 for each of the three categories, with 0 being the worst and 10 being the best. Each evaluation should be independent of the others.
+
+**Visual Quality:**
+Evaluate the overall visual quality of the video, with a focus on static factors. The following sub-dimensions should be considered:
+- **Reasonableness:** The video should not contain any significant biological or logical errors, such as abnormal body structures or nonsensical environmental setups.
+- **Clarity:** Evaluate the sharpness and visibility of the video. The image should be clear and easy to interpret, with no blurring or indistinct areas.
+- **Detail Richness:** Consider the level of detail in textures, materials, lighting, and other visual elements (e.g., hair, clothing, shadows).
+- **Aesthetic and Creativity:** Assess the artistic aspects of the video, including the color scheme, composition, atmosphere, depth of field, and the overall creative appeal. The scene should convey a sense of harmony and balance.
+- **Safety:** The video should not contain harmful or inappropriate content, such as political, violent, or adult material. If such content is present, the image quality and satisfaction score should be the lowest possible.
+
+Please provide the ratings of Visual Quality: <|VQ_reward|>
+END
+
+**Motion Quality:**
+Assess the dynamic aspects of the video, with a focus on dynamic factors. Consider the following sub-dimensions:
+- **Stability:** Evaluate the continuity and stability between frames. There should be no sudden, unnatural jumps, and the video should maintain stable attributes (e.g., no fluctuating colors, textures, or missing body parts).
+- **Naturalness:** The movement should align with physical laws and be realistic. For example, clothing should flow naturally with motion, and facial expressions should change appropriately (e.g., blinking, mouth movements).
+- **Aesthetic Quality:** The movement should be smooth and fluid. The transitions between different motions or camera angles should be seamless, and the overall dynamic feel should be visually pleasing.
+- **Fusion:** Ensure that elements in motion (e.g., edges of the subject, hair, clothing) blend naturally with the background, without obvious artifacts or the feeling of cut-and-paste effects.
+- **Clarity of Motion:** The video should be clear and smooth in motion. Pay attention to any areas where the video might have blurry or unsteady sections that hinder visual continuity.
+- **Amplitude:** If the video is largely static or has little movement, assign a low score for motion quality.
+
+Please provide the ratings of Motion Quality: <|MQ_reward|>
+END
+
+**Text Alignment:**
+Assess how well the video matches the textual prompt across the following sub-dimensions:
+- **Subject Relevance** Evaluate how accurately the subject(s) in the video (e.g., person, animal, object) align with the textual description. The subject should match the description in terms of number, appearance, and behavior.
+- **Motion Relevance:** Evaluate if the dynamic actions (e.g., gestures, posture, facial expressions like talking or blinking) align with the described prompt. The motion should match the prompt in terms of type, scale, and direction.
+- **Environment Relevance:** Assess whether the background and scene fit the prompt. This includes checking if real-world locations or scenes are accurately represented, though some stylistic adaptation is acceptable.
+- **Style Relevance:** If the prompt specifies a particular artistic or stylistic style, evaluate how well the video adheres to this style.
+- **Camera Movement Relevance:** Check if the camera movements (e.g., following the subject, focus shifts) are consistent with the expected behavior from the prompt.
+
+Textual prompt - {text_prompt}
+Please provide the ratings of Text Alignment: <|TA_reward|>
+END
+"""
+
+DETAILED_PROMPT = """
+You are tasked with evaluating a generated video based on three distinct criteria: Visual Quality, Motion Quality, and Text Alignment. Please provide a rating from 0 to 10 for each of the three categories, with 0 being the worst and 10 being the best. Each evaluation should be independent of the others.
+
+**Visual Quality:**
+Evaluate the overall visual quality of the video, with a focus on static factors. The following sub-dimensions should be considered:
+- **Reasonableness:** The video should not contain any significant biological or logical errors, such as abnormal body structures or nonsensical environmental setups.
+- **Clarity:** Evaluate the sharpness and visibility of the video. The image should be clear and easy to interpret, with no blurring or indistinct areas.
+- **Detail Richness:** Consider the level of detail in textures, materials, lighting, and other visual elements (e.g., hair, clothing, shadows).
+- **Aesthetic and Creativity:** Assess the artistic aspects of the video, including the color scheme, composition, atmosphere, depth of field, and the overall creative appeal. The scene should convey a sense of harmony and balance.
+- **Safety:** The video should not contain harmful or inappropriate content, such as political, violent, or adult material. If such content is present, the image quality and satisfaction score should be the lowest possible.
+
+**Motion Quality:**
+Assess the dynamic aspects of the video, with a focus on dynamic factors. Consider the following sub-dimensions:
+- **Stability:** Evaluate the continuity and stability between frames. There should be no sudden, unnatural jumps, and the video should maintain stable attributes (e.g., no fluctuating colors, textures, or missing body parts).
+- **Naturalness:** The movement should align with physical laws and be realistic. For example, clothing should flow naturally with motion, and facial expressions should change appropriately (e.g., blinking, mouth movements).
+- **Aesthetic Quality:** The movement should be smooth and fluid. The transitions between different motions or camera angles should be seamless, and the overall dynamic feel should be visually pleasing.
+- **Fusion:** Ensure that elements in motion (e.g., edges of the subject, hair, clothing) blend naturally with the background, without obvious artifacts or the feeling of cut-and-paste effects.
+- **Clarity of Motion:** The video should be clear and smooth in motion. Pay attention to any areas where the video might have blurry or unsteady sections that hinder visual continuity.
+- **Amplitude:** If the video is largely static or has little movement, assign a low score for motion quality.
+
+
+**Text Alignment:**
+Assess how well the video matches the textual prompt across the following sub-dimensions:
+- **Subject Relevance** Evaluate how accurately the subject(s) in the video (e.g., person, animal, object) align with the textual description. The subject should match the description in terms of number, appearance, and behavior.
+- **Motion Relevance:** Evaluate if the dynamic actions (e.g., gestures, posture, facial expressions like talking or blinking) align with the described prompt. The motion should match the prompt in terms of type, scale, and direction.
+- **Environment Relevance:** Assess whether the background and scene fit the prompt. This includes checking if real-world locations or scenes are accurately represented, though some stylistic adaptation is acceptable.
+- **Style Relevance:** If the prompt specifies a particular artistic or stylistic style, evaluate how well the video adheres to this style.
+- **Camera Movement Relevance:** Check if the camera movements (e.g., following the subject, focus shifts) are consistent with the expected behavior from the prompt.
+
+Textual prompt - {text_prompt}
+Please provide the ratings of Visual Quality, Motion Quality, and Text Alignment.
+"""
+
+SIMPLE_PROMPT_NO_PROMPT = """
+Please evaluate the {dimension_name} of a generated video. Consider {dimension_description}.
+"""
+
+
+def build_prompt(prompt, dimension, template_type):
+    if isinstance(dimension, list) and len(dimension) > 1:
+        dimension_name = ", ".join([DIMENSION_DESCRIPTIONS[d][0] for d in dimension])
+        dimension_name = f"overall performance({dimension_name})"
+        dimension_description = "the overall performance of the video"
+    else:
+        if isinstance(dimension, list):
+            dimension = dimension[0]
+        dimension_name = DIMENSION_DESCRIPTIONS[dimension][0]
+        dimension_description = DIMENSION_DESCRIPTIONS[dimension][1]
+
+    if template_type == "none":
+        return prompt
+    elif template_type == "simple":
+        return SIMPLE_PROMPT.format(
+            dimension_name=dimension_name, dimension_description=dimension_description, text_prompt=prompt
+        )
+    elif template_type == "video_score":
+        return VIDEOSCORE_QUERY_PROMPT.format(
+            dimension_name=dimension_name, dimension_description=dimension_description, text_prompt=prompt
+        )
+    elif template_type == "detailed_special":
+        return DETAILED_PROMPT_WITH_SPECIAL_TOKEN.format(text_prompt=prompt)
+    elif template_type == "detailed":
+        return DETAILED_PROMPT.format(text_prompt=prompt)
+    else:
+        raise ValueError("Invalid template type")

Helios/_DEV/helios/videoalign/train_reward.py

@@ -0,0 +1,118 @@
+import torch
+from peft import LoraConfig, get_peft_model
+from transformers import AutoProcessor
+
+from diffusers.utils import is_flash_attn_3_available, is_flash_attn_available
+
+from .trainer import Qwen2VLRewardModelBT
+
+
+def find_target_linear_names(model, num_lora_modules=-1, lora_namespan_exclude=[], verbose=False):
+    """
+    Find the target linear modules for LoRA.
+    """
+    linear_cls = torch.nn.Linear
+    embedding_cls = torch.nn.Embedding
+    lora_module_names = []
+
+    for name, module in model.named_modules():
+        if any(ex_keyword in name for ex_keyword in lora_namespan_exclude):
+            # print(f"Excluding module: {name}")
+            continue
+
+        if isinstance(module, (linear_cls, embedding_cls)):
+            lora_module_names.append(name)
+
+    if num_lora_modules > 0:
+        lora_module_names = lora_module_names[-num_lora_modules:]
+    if verbose:
+        print(f"Found {len(lora_module_names)} lora modules: {lora_module_names}")
+    return lora_module_names
+
+
+def set_requires_grad(parameters, requires_grad):
+    for p in parameters:
+        p.requires_grad = requires_grad
+
+
+def create_model_and_processor(
+    model_config,
+    peft_lora_config,
+    training_args,
+    cache_dir=None,
+):
+    # create model
+    torch_dtype = (
+        model_config.torch_dtype
+        if model_config.torch_dtype in ["auto", None]
+        else getattr(torch, model_config.torch_dtype)
+    )
+    model_kwargs = {
+        "revision": model_config.model_revision,
+        "use_cache": True if training_args.gradient_checkpointing else False,
+    }
+    # pdb.set_trace()
+
+    # create processor and set padding
+    processor = AutoProcessor.from_pretrained(
+        model_config.model_name_or_path, padding_side="right", cache_dir=cache_dir
+    )
+
+    special_token_ids = None
+    if model_config.use_special_tokens:
+        special_tokens = ["<|VQ_reward|>", "<|MQ_reward|>", "<|TA_reward|>"]
+        processor.tokenizer.add_special_tokens({"additional_special_tokens": special_tokens})
+        special_token_ids = processor.tokenizer.convert_tokens_to_ids(special_tokens)
+
+    if is_flash_attn_3_available():
+        attn_implementation = "flash_attention_3"
+    elif is_flash_attn_available():
+        attn_implementation = "flash_attention_2"
+    else:
+        attn_implementation = "sdpa"
+
+    print(f"Using {attn_implementation} for Reward!")
+
+    model = Qwen2VLRewardModelBT.from_pretrained(
+        model_config.model_name_or_path,
+        output_dim=model_config.output_dim,
+        reward_token=model_config.reward_token,
+        special_token_ids=special_token_ids,
+        dtype=torch_dtype,
+        attn_implementation=attn_implementation,
+        cache_dir=cache_dir,
+        **model_kwargs,
+    )
+    if model_config.use_special_tokens:
+        model.resize_token_embeddings(len(processor.tokenizer))
+
+    if training_args.bf16:
+        model.to(torch.bfloat16)
+    if training_args.fp16:
+        model.to(torch.float16)
+
+    # create lora and peft model
+    if peft_lora_config.lora_enable:
+        target_modules = find_target_linear_names(
+            model,
+            num_lora_modules=peft_lora_config.num_lora_modules,
+            lora_namespan_exclude=peft_lora_config.lora_namespan_exclude,
+        )
+        peft_config = LoraConfig(
+            target_modules=target_modules,
+            r=peft_lora_config.lora_r,
+            lora_alpha=peft_lora_config.lora_alpha,
+            lora_dropout=peft_lora_config.lora_dropout,
+            task_type=peft_lora_config.lora_task_type,
+            use_rslora=peft_lora_config.use_rslora,
+            bias="none",
+            modules_to_save=peft_lora_config.lora_modules_to_save,
+        )
+        model = get_peft_model(model, peft_config)
+    else:
+        peft_config = None
+
+    model.config.tokenizer_padding_side = processor.tokenizer.padding_side
+    model.config.pad_token_id = processor.tokenizer.pad_token_id
+
+    return model, processor, peft_config

Helios/_DEV/helios/videoalign/trainer.py

@@ -0,0 +1,133 @@
+# from training.train_utils import get_peft_state_maybe_zero_3, get_peft_state_non_lora_maybe_zero_3
+from typing import List, Optional
+
+import torch
+import torch.nn as nn
+from transformers import Qwen2VLForConditionalGeneration
+from transformers.trainer import (
+    is_torch_xla_available,
+)
+
+
+if is_torch_xla_available():
+    pass
+else:
+    IS_XLA_FSDPV2_POST_2_2 = False
+
+
+class Qwen2VLRewardModelBT(Qwen2VLForConditionalGeneration):
+    def __init__(self, config, output_dim=4, reward_token="last", special_token_ids=None):
+        super().__init__(config)
+        # pdb.set_trace()
+        self.output_dim = output_dim
+        self.rm_head = nn.Linear(config.hidden_size, output_dim, bias=False)
+        self.reward_token = reward_token
+
+        self.special_token_ids = special_token_ids
+        if self.special_token_ids is not None:
+            self.reward_token = "special"
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = None,
+        past_key_values: Optional[List[torch.FloatTensor]] = None,
+        inputs_embeds: Optional[torch.FloatTensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        use_cache: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+        pixel_values: Optional[torch.Tensor] = None,
+        pixel_values_videos: Optional[torch.FloatTensor] = None,
+        image_grid_thw: Optional[torch.LongTensor] = None,
+        video_grid_thw: Optional[torch.LongTensor] = None,
+        rope_deltas: Optional[torch.LongTensor] = None,
+    ):
+        ## modified from the origin class Qwen2VLForConditionalGeneration
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        # pdb.set_trace()
+        if inputs_embeds is None:
+            # inputs_embeds = self.model.embed_tokens(input_ids)
+            inputs_embeds = self.get_input_embeddings()(input_ids)
+            if pixel_values is not None:
+                pixel_values = pixel_values.type(self.visual.get_dtype())
+                image_embeds = self.visual(pixel_values, grid_thw=image_grid_thw)
+                image_mask = (input_ids == self.config.image_token_id).unsqueeze(-1).expand_as(inputs_embeds)
+                image_embeds = image_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+                inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+            if pixel_values_videos is not None:
+                pixel_values_videos = pixel_values_videos.type(self.visual.get_dtype())
+                video_embeds = self.visual(pixel_values_videos, grid_thw=video_grid_thw)
+                video_mask = (input_ids == self.config.video_token_id).unsqueeze(-1).expand_as(inputs_embeds)
+                video_embeds = video_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+                inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+            if attention_mask is not None:
+                attention_mask = attention_mask.to(inputs_embeds.device)
+
+        outputs = self.model(
+            input_ids=None,
+            position_ids=position_ids,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        hidden_states = outputs[0]  # [B, L, D]
+
+        logits = self.rm_head(hidden_states)  # [B, L, N]
+
+        if input_ids is not None:
+            batch_size = input_ids.shape[0]
+        else:
+            batch_size = inputs_embeds.shape[0]
+
+        ## get sequence length
+        if self.config.pad_token_id is None and batch_size != 1:
+            raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.")
+        if self.config.pad_token_id is None:
+            sequence_lengths = -1
+        else:
+            if input_ids is not None:
+                # if no pad token found, use modulo instead of reverse indexing for ONNX compatibility
+                sequence_lengths = torch.eq(input_ids, self.config.pad_token_id).int().argmax(-1) - 1
+                sequence_lengths = sequence_lengths % input_ids.shape[-1]
+                sequence_lengths = sequence_lengths.to(logits.device)
+            else:
+                sequence_lengths = -1
+
+        ## get the last token's logits
+        if self.reward_token == "last":
+            pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths]
+        elif self.reward_token == "mean":
+            ## get the mean of all valid tokens' logits
+            valid_lengths = torch.clamp(sequence_lengths, min=0, max=logits.size(1) - 1)
+            pooled_logits = torch.stack([logits[i, : valid_lengths[i]].mean(dim=0) for i in range(batch_size)])
+        elif self.reward_token == "special":
+            # special_token_ids = self.tokenizer.convert_tokens_to_ids(self.special_tokens)
+            # create a mask for special tokens
+            special_token_mask = torch.zeros_like(input_ids, dtype=torch.bool)
+            for special_token_id in self.special_token_ids:
+                special_token_mask = special_token_mask | (input_ids == special_token_id)
+            pooled_logits = logits[special_token_mask, ...]
+            pooled_logits = pooled_logits.view(batch_size, 3, -1)  # [B, 3, N] assert 3 attributes
+            if self.output_dim == 3:
+                pooled_logits = pooled_logits.diagonal(dim1=1, dim2=2)
+            pooled_logits = pooled_logits.view(batch_size, -1)
+
+            # pdb.set_trace()
+        else:
+            raise ValueError("Invalid reward_token")
+
+        return {"logits": pooled_logits}

Helios/_DEV/helios/videoalign/utils.py

@@ -0,0 +1,236 @@
+import glob
+import os
+from dataclasses import dataclass, field
+from typing import List, Literal, Optional
+
+import safetensors
+import torch
+from transformers import TrainingArguments
+
+
+########## DataClass For Configure ##########
+
+
+@dataclass
+class TrainingConfig(TrainingArguments):
+    max_length: Optional[int] = None
+    dataset_num_proc: Optional[int] = None
+    center_rewards_coefficient: Optional[float] = None
+    disable_flash_attn2: bool = field(default=False)
+
+    vision_lr: Optional[float] = None
+    merger_lr: Optional[float] = None
+    special_token_lr: Optional[float] = None
+
+    conduct_eval: Optional[bool] = True
+    load_from_pretrained: str = None
+    load_from_pretrained_step: int = None
+    logging_epochs: Optional[float] = None
+    eval_epochs: Optional[float] = None
+    save_epochs: Optional[float] = None
+    remove_unused_columns: Optional[bool] = False
+
+    save_full_model: Optional[bool] = False
+
+
+@dataclass
+class PEFTLoraConfig:
+    lora_enable: bool = False
+    vision_lora: bool = False
+    lora_r: int = 16
+    lora_alpha: int = 32
+    lora_dropout: float = 0.05
+    lora_target_modules: Optional[List[str]] = None
+    lora_namespan_exclude: Optional[List[str]] = None
+    lora_modules_to_save: Optional[List[str]] = None
+    lora_task_type: str = "CAUSAL_LM"
+    use_rslora: bool = False
+    num_lora_modules: int = -1
+
+    def __post_init__(self):
+        if isinstance(self.lora_target_modules, list) and len(self.lora_target_modules) == 1:
+            self.lora_target_modules = self.lora_target_modules[0]
+
+        if isinstance(self.lora_namespan_exclude, list) and len(self.lora_namespan_exclude) == 1:
+            self.lora_namespan_exclude = self.lora_namespan_exclude[0]
+
+
+@dataclass
+class ModelConfig:
+    model_name_or_path: Optional[str] = None
+    model_revision: str = "main"
+
+    output_dim: int = 1
+
+    use_special_tokens: bool = False
+
+    freeze_vision_tower: bool = field(default=False)
+    freeze_llm: bool = field(default=False)
+    tune_merger: bool = field(default=False)
+
+    torch_dtype: Optional[Literal["auto", "bfloat16", "float16", "float32"]] = None
+    trust_remote_code: bool = False
+    attn_implementation: Optional[str] = None
+    load_in_8bit: bool = False
+    load_in_4bit: bool = False
+    bnb_4bit_quant_type: Literal["fp4", "nf4"] = "nf4"
+    use_bnb_nested_quant: bool = False
+    reward_token: Literal["last", "mean", "special"] = "last"
+    loss_type: Literal["bt", "reg", "btt", "margin", "constant_margin", "scaled"] = "regular"
+
+    def __post_init__(self):
+        if self.load_in_8bit and self.load_in_4bit:
+            raise ValueError("You can't use 8 bit and 4 bit precision at the same time")
+
+        # if isinstance(self.lora_target_modules, list) and len(self.lora_target_modules) == 1:
+        #     self.lora_target_modules = self.lora_target_modules[0]
+
+        # if isinstance(self.lora_namespan_exclude, list) and len(self.lora_namespan_exclude) == 1:
+        #     self.lora_namespan_exclude = self.lora_namespan_exclude[0]
+
+
+########## Functions for get trainable modules' parameters ##########
+
+
+def maybe_zero_3(param, ignore_status=False, name=None):
+    from deepspeed import zero
+
+    if hasattr(param, "ds_id"):
+        # if param.ds_status == ZeroParamStatus.NOT_AVAILABLE:
+        #     if not ignore_status:
+        #         logging.warning(f"{name}: param.ds_status != ZeroParamStatus.NOT_AVAILABLE: {param.ds_status}")
+        with zero.GatheredParameters([param]):
+            param = param.data.detach().cpu().clone()
+    else:
+        param = param.detach().cpu().clone()
+    return param
+
+
+# Borrowed from peft.utils.get_peft_model_state_dict
+def get_peft_state_maybe_zero_3(named_params, bias):
+    if bias == "none":
+        to_return = {k: t for k, t in named_params if "lora_" in k}
+    elif bias == "all":
+        to_return = {k: t for k, t in named_params if "lora_" in k or "bias" in k}
+    elif bias == "lora_only":
+        to_return = {}
+        maybe_lora_bias = {}
+        lora_bias_names = set()
+        for k, t in named_params:
+            if "lora_" in k:
+                to_return[k] = t
+                bias_name = k.split("lora_")[0] + "bias"
+                lora_bias_names.add(bias_name)
+            elif "bias" in k:
+                maybe_lora_bias[k] = t
+        for k, t in maybe_lora_bias:
+            if bias_name in lora_bias_names:
+                to_return[bias_name] = t
+    else:
+        raise NotImplementedError
+    to_return = {k: maybe_zero_3(v, ignore_status=True) for k, v in to_return.items()}
+    return to_return
+
+
+def get_peft_state_non_lora_maybe_zero_3(named_params, require_grad_only=True):
+    to_return = {k: t for k, t in named_params if "lora_" not in k}
+    if require_grad_only:
+        to_return = {k: t for k, t in to_return.items() if t.requires_grad}
+    to_return = {k: maybe_zero_3(v, ignore_status=True).cpu() for k, v in to_return.items()}
+    return to_return
+
+
+########## Load Models From Folder ##########
+
+
+def _insert_adapter_name_into_state_dict(
+    state_dict: dict[str, torch.Tensor], adapter_name: str, parameter_prefix: str
+) -> dict[str, torch.Tensor]:
+    """Utility function to remap the state_dict keys to fit the PEFT model by inserting the adapter name."""
+    peft_model_state_dict = {}
+    for key, val in state_dict.items():
+        if parameter_prefix in key:
+            suffix = key.split(parameter_prefix)[1]
+            if "." in suffix:
+                suffix_to_replace = ".".join(suffix.split(".")[1:])
+                key = key.replace(suffix_to_replace, f"{adapter_name}.{suffix_to_replace}")
+            else:
+                key = f"{key}.{adapter_name}"
+            peft_model_state_dict[key] = val
+        else:
+            peft_model_state_dict[key] = val
+    return peft_model_state_dict
+
+
+def save_video(tensor, path):
+    from torchvision.io import write_video
+
+    tensor = tensor * 255.0
+    tensor = tensor.permute(0, 2, 3, 1)
+    tensor = tensor.clamp(0, 255).byte()
+    write_video(path, tensor, 4, video_codec="h264")
+
+
+def load_model_from_checkpoint(model, checkpoint_dir, checkpoint_step):
+    checkpoint_paths = glob.glob(os.path.join(checkpoint_dir, "checkpoint-*"))
+    checkpoint_paths.sort(key=lambda x: int(x.split("-")[-1]), reverse=True)
+
+    if checkpoint_step is None or checkpoint_step == -1:
+        # get the latest checkpoint
+        checkpoint_path = checkpoint_paths[0]
+        print(f"===> Checkpoint step is not provided, using the latest checkpoint: {checkpoint_path}")
+    else:
+        checkpoint_path = os.path.join(checkpoint_dir, f"checkpoint-{checkpoint_step}")
+        if checkpoint_path not in checkpoint_paths:
+            checkpoint_path = checkpoint_paths[0]
+            print(f"===> Checkpoint step {checkpoint_step} not found, using the latest checkpoint: {checkpoint_path}")
+        else:
+            print(f"===> Checkpoint step {checkpoint_step} found, using the specified checkpoint: {checkpoint_path}")
+
+    checkpoint_step = checkpoint_path.split("checkpoint-")[-1].split("/")[0]
+
+    full_ckpt = os.path.join(checkpoint_path, "model.pth")
+    lora_ckpt = os.path.join(checkpoint_path, "adapter_model.safetensors")
+    non_lora_ckpt = os.path.join(checkpoint_path, "non_lora_state_dict.pth")
+    if os.path.exists(full_ckpt):
+        model_state_dict = torch.load(full_ckpt, map_location="cpu", weights_only=True)
+        # Create a new state_dict to store the modified key-value pairs
+        new_state_dict = {}
+
+        # for key, value in model_state_dict.items():
+        #     if key.startswith("base_model.model.model"):
+        #         new_key = "base_model.model.model.language_model" + key[len("base_model.model.model"):]
+        #         new_state_dict[new_key] = value
+        #     elif key.startswith("base_model.model.visual"):
+        #         new_key = "base_model.model.model.visual" + key[len("base_model.model.visual"):]
+        #         new_state_dict[new_key] = value
+        #     else:
+        #         new_state_dict[key] = value
+        for key, value in model_state_dict.items():
+            if key.startswith("base_model.model.model"):
+                new_key = "base_model.model.model.language_model" + key[len("base_model.model.model") :]
+                new_state_dict[new_key] = value
+            elif key.startswith("base_model.model.visual"):
+                new_key = "base_model.model.model.visual" + key[len("base_model.model.visual") :]
+                new_state_dict[new_key] = value
+            else:
+                new_state_dict[key] = value
+
+        # Load the modified state_dict into the model
+        model.load_state_dict(new_state_dict)
+        # model_state_dict = torch.load(full_ckpt, map_location="cpu")
+        # model.load_state_dict(model_state_dict)
+    else:
+        lora_state_dict = safetensors.torch.load_file(lora_ckpt)
+        non_lora_state_dict = torch.load(non_lora_ckpt, map_location="cpu")
+
+        lora_state_dict = _insert_adapter_name_into_state_dict(
+            lora_state_dict, adapter_name="default", parameter_prefix="lora_"
+        )
+
+        model_state_dict = model.state_dict()
+        model_state_dict.update(non_lora_state_dict)
+        model_state_dict.update(lora_state_dict)
+        model.load_state_dict(model_state_dict)
+
+    return model, checkpoint_step

Helios/_DEV/helios/videoalign/vision_process.py

@@ -0,0 +1,396 @@
+import base64
+import logging
+import math
+import os
+import sys
+import warnings
+from functools import lru_cache
+from io import BytesIO
+
+import requests
+import torch
+import torchvision
+from packaging import version
+from PIL import Image
+from torchvision import io, transforms
+from torchvision.transforms import InterpolationMode
+
+
+logger = logging.getLogger(__name__)
+
+IMAGE_FACTOR = 28
+MIN_PIXELS = 4 * 28 * 28
+MAX_PIXELS = 16384 * 28 * 28
+MAX_RATIO = 200
+
+VIDEO_MIN_PIXELS = 128 * 28 * 28
+VIDEO_MAX_PIXELS = 768 * 28 * 28
+VIDEO_TOTAL_PIXELS = 24576 * 28 * 28
+FRAME_FACTOR = 2
+FPS = 2.0
+FPS_MIN_FRAMES = 4
+FPS_MAX_FRAMES = 768
+
+
+def round_by_factor(number: int, factor: int) -> int:
+    """Returns the closest integer to 'number' that is divisible by 'factor'."""
+    return round(number / factor) * factor
+
+
+def ceil_by_factor(number: int, factor: int) -> int:
+    """Returns the smallest integer greater than or equal to 'number' that is divisible by 'factor'."""
+    return math.ceil(number / factor) * factor
+
+
+def floor_by_factor(number: int, factor: int) -> int:
+    """Returns the largest integer less than or equal to 'number' that is divisible by 'factor'."""
+    return math.floor(number / factor) * factor
+
+
+def smart_resize(
+    height: int, width: int, factor: int = IMAGE_FACTOR, min_pixels: int = MIN_PIXELS, max_pixels: int = MAX_PIXELS
+) -> tuple[int, int]:
+    """
+    Rescales the image so that the following conditions are met:
+
+    1. Both dimensions (height and width) are divisible by 'factor'.
+
+    2. The total number of pixels is within the range ['min_pixels', 'max_pixels'].
+
+    3. The aspect ratio of the image is maintained as closely as possible.
+    """
+    if max(height, width) / min(height, width) > MAX_RATIO:
+        raise ValueError(
+            f"absolute aspect ratio must be smaller than {MAX_RATIO}, got {max(height, width) / min(height, width)}"
+        )
+    h_bar = max(factor, round_by_factor(height, factor))
+    w_bar = max(factor, round_by_factor(width, factor))
+    if h_bar * w_bar > max_pixels:
+        beta = math.sqrt((height * width) / max_pixels)
+        h_bar = floor_by_factor(height / beta, factor)
+        w_bar = floor_by_factor(width / beta, factor)
+    elif h_bar * w_bar < min_pixels:
+        beta = math.sqrt(min_pixels / (height * width))
+        h_bar = ceil_by_factor(height * beta, factor)
+        w_bar = ceil_by_factor(width * beta, factor)
+    return h_bar, w_bar
+
+
+def fetch_image(ele: dict[str, str | Image.Image], size_factor: int = IMAGE_FACTOR) -> Image.Image:
+    if "image" in ele:
+        image = ele["image"]
+    else:
+        image = ele["image_url"]
+    image_obj = None
+    if isinstance(image, Image.Image):
+        image_obj = image
+    elif image.startswith("http://") or image.startswith("https://"):
+        image_obj = Image.open(requests.get(image, stream=True).raw)
+    elif image.startswith("file://"):
+        image_obj = Image.open(image[7:])
+    elif image.startswith("data:image"):
+        if "base64," in image:
+            _, base64_data = image.split("base64,", 1)
+            data = base64.b64decode(base64_data)
+            image_obj = Image.open(BytesIO(data))
+    else:
+        image_obj = Image.open(image)
+    if image_obj is None:
+        raise ValueError(f"Unrecognized image input, support local path, http url, base64 and PIL.Image, got {image}")
+    image = image_obj.convert("RGB")
+    ## resize
+    if "resized_height" in ele and "resized_width" in ele:
+        resized_height, resized_width = smart_resize(
+            ele["resized_height"],
+            ele["resized_width"],
+            factor=size_factor,
+        )
+    else:
+        width, height = image.size
+        min_pixels = ele.get("min_pixels", MIN_PIXELS)
+        max_pixels = ele.get("max_pixels", MAX_PIXELS)
+        resized_height, resized_width = smart_resize(
+            height,
+            width,
+            factor=size_factor,
+            min_pixels=min_pixels,
+            max_pixels=max_pixels,
+        )
+    image = image.resize((resized_width, resized_height))
+
+    return image
+
+
+def smart_nframes(
+    ele: dict,
+    total_frames: int,
+    video_fps: int | float,
+) -> int:
+    """calculate the number of frames for video used for model inputs.
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+            support either `fps` or `nframes`:
+                - nframes: the number of frames to extract for model inputs.
+                - fps: the fps to extract frames for model inputs.
+                    - min_frames: the minimum number of frames of the video, only used when fps is provided.
+                    - max_frames: the maximum number of frames of the video, only used when fps is provided.
+        total_frames (int): the original total number of frames of the video.
+        video_fps (int | float): the original fps of the video.
+
+    Raises:
+        ValueError: nframes should in interval [FRAME_FACTOR, total_frames].
+
+    Returns:
+        int: the number of frames for video used for model inputs.
+    """
+    assert not ("fps" in ele and "nframes" in ele), "Only accept either `fps` or `nframes`"
+    if "nframes" in ele:
+        nframes = round_by_factor(ele["nframes"], FRAME_FACTOR)
+    else:
+        fps = ele.get("fps", FPS)
+        min_frames = ceil_by_factor(ele.get("min_frames", FPS_MIN_FRAMES), FRAME_FACTOR)
+        max_frames = floor_by_factor(ele.get("max_frames", min(FPS_MAX_FRAMES, total_frames)), FRAME_FACTOR)
+        nframes = total_frames / video_fps * fps
+        nframes = min(max(nframes, min_frames), max_frames)
+        nframes = round_by_factor(nframes, FRAME_FACTOR)
+    if nframes > total_frames:
+        nframes = total_frames
+    if not (FRAME_FACTOR <= nframes and nframes <= total_frames):
+        raise ValueError(f"nframes should in interval [{FRAME_FACTOR}, {total_frames}], but got {nframes}.")
+    return nframes
+
+
+def _read_video_torchvision(
+    ele: dict,
+) -> torch.Tensor:
+    """read video using torchvision.io.read_video
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+        support keys:
+            - video: the path of video. support "file://", "http://", "https://" and local path.
+            - video_start: the start time of video.
+            - video_end: the end time of video.
+    Returns:
+        torch.Tensor: the video tensor with shape (T, C, H, W).
+    """
+    video_path = ele["video"]
+    if version.parse(torchvision.__version__) < version.parse("0.19.0"):
+        if "http://" in video_path or "https://" in video_path:
+            warnings.warn("torchvision < 0.19.0 does not support http/https video path, please upgrade to 0.19.0.")
+        if "file://" in video_path:
+            video_path = video_path[7:]
+    # st = time.time()
+    video, audio, info = io.read_video(
+        video_path,
+        start_pts=ele.get("video_start", 0.0),
+        end_pts=ele.get("video_end", None),
+        pts_unit="sec",
+        output_format="TCHW",
+    )
+
+    total_frames, video_fps = video.size(0), info["video_fps"]
+    # logger.info(f"torchvision:  {video_path=}, {total_frames=}, {video_fps=}, time={time.time() - st:.3f}s")
+    if ele["sample_type"] == "uniform":
+        nframes = smart_nframes(ele, total_frames=total_frames, video_fps=video_fps)
+        idx = torch.linspace(0, total_frames - 1, nframes).round().long().tolist()
+    elif ele["sample_type"] == "multi_pts":
+        frames_each_pts = 6
+        num_pts = 4
+        fps = 8
+        nframes = int(total_frames * fps // video_fps)
+        frames_idx = torch.linspace(0, total_frames - 1, nframes).round().long().tolist()
+
+        start_pt = int(frames_each_pts // 2)
+        end_pt = int(nframes - frames_each_pts // 2 - 1)
+        pts = torch.linspace(start_pt, end_pt, num_pts).round().long().tolist()
+        idx = []
+        for pt in pts:
+            idx.extend(frames_idx[pt - frames_each_pts // 2 : pt + frames_each_pts // 2])
+
+    video = video[idx]
+    return video
+
+
+def is_video_reader_available() -> bool:
+    import importlib.util
+
+    return importlib.util.find_spec("video_reader") is not None
+
+
+def _read_video_video_reader(
+    ele: dict,
+) -> torch.Tensor:
+    """read video using video_reader.VideoReader
+
+    Args:
+        ele (dict): a dict contains the configuration of video.
+        support keys:
+            - video: the path of video. support "file://", "http://", "https://" and local path.
+            - video_start: the start time of video.
+            - video_end: the end time of video.
+    Returns:
+        torch.Tensor: the video tensor with shape (T, C, H, W).
+    """
+    from video_reader import PyVideoReader
+
+    video_path = ele["video"]
+    # st = time.time()
+    vr = PyVideoReader(video_path, threads=0)
+    # TODO: support start_pts and end_pts
+    if "video_start" in ele or "video_end" in ele:
+        raise NotImplementedError("not support start_pts and end_pts in video_reader for now.")
+    total_frames, video_fps = int(len(vr)), float(vr.get_info()["fps"])
+    if total_frames <= 93:
+        video_fps = 16
+    elif total_frames <= 49:
+        video_fps = 8
+    # logger.info(f"video_reader:  {video_path=}, {total_frames=}, {video_fps=}, time={time.time() - st:.3f}s")
+    if ele["sample_type"] == "uniform":
+        nframes = smart_nframes(ele, total_frames=total_frames, video_fps=video_fps)
+        # nframes = max(nframes, 8)
+        # import pdb; pdb.set_trace()
+        idx = torch.linspace(0, total_frames - 1, nframes).round().long().tolist()
+    elif ele["sample_type"] == "multi_pts":
+        frames_each_pts = 6
+        num_pts = 4
+        fps = 8
+        nframes = int(total_frames * fps // video_fps)
+        frames_idx = torch.linspace(0, total_frames - 1, nframes).round().long().tolist()
+
+        start_pt = int(frames_each_pts // 2)
+        end_pt = int(nframes - frames_each_pts // 2 - 1)
+        pts = torch.linspace(start_pt, end_pt, num_pts).round().long().tolist()
+        idx = []
+        for pt in pts:
+            idx.extend(frames_idx[pt - frames_each_pts // 2 : pt + frames_each_pts // 2])
+    video = vr.get_batch(idx)
+    video = torch.tensor(video).permute(0, 3, 1, 2)  # Convert to TCHW format
+    return video
+
+
+VIDEO_READER_BACKENDS = {
+    "video_reader": _read_video_video_reader,
+    "torchvision": _read_video_torchvision,
+}
+
+FORCE_QWENVL_VIDEO_READER = os.getenv("FORCE_QWENVL_VIDEO_READER", None)
+
+
+@lru_cache(maxsize=1)
+def get_video_reader_backend() -> str:
+    if FORCE_QWENVL_VIDEO_READER is not None:
+        video_reader_backend = FORCE_QWENVL_VIDEO_READER
+    elif is_video_reader_available():
+        video_reader_backend = "video_reader"
+    else:
+        video_reader_backend = "torchvision"
+    print(f"qwen-vl-utils using {video_reader_backend} to read video.", file=sys.stderr)
+    return video_reader_backend
+
+
+def fetch_video(ele: dict, image_factor: int = IMAGE_FACTOR) -> torch.Tensor | list[Image.Image]:
+    if isinstance(ele["video"], str):
+        video_reader_backend = get_video_reader_backend()
+        video = VIDEO_READER_BACKENDS[video_reader_backend](ele)
+        # import pdb; pdb.set_trace()
+        nframes, _, height, width = video.shape
+
+        min_pixels = ele.get("min_pixels", VIDEO_MIN_PIXELS)
+        total_pixels = ele.get("total_pixels", VIDEO_TOTAL_PIXELS)
+        max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR), int(min_pixels * 1.05))
+        max_pixels = ele.get("max_pixels", max_pixels)
+        if "resized_height" in ele and "resized_width" in ele:
+            resized_height, resized_width = smart_resize(
+                ele["resized_height"],
+                ele["resized_width"],
+                factor=image_factor,
+            )
+        else:
+            resized_height, resized_width = smart_resize(
+                height,
+                width,
+                factor=image_factor,
+                min_pixels=min_pixels,
+                max_pixels=max_pixels,
+            )
+        video = transforms.functional.resize(
+            video,
+            [resized_height, resized_width],
+            interpolation=InterpolationMode.BICUBIC,
+            antialias=True,
+        ).float()
+        return video
+    else:
+        assert isinstance(ele["video"], (list, tuple))
+        process_info = ele.copy()
+        process_info.pop("type", None)
+        process_info.pop("video", None)
+        images = [
+            fetch_image({"image": video_element, **process_info}, size_factor=image_factor)
+            for video_element in ele["video"]
+        ]
+        nframes = ceil_by_factor(len(images), FRAME_FACTOR)
+        if len(images) < nframes:
+            images.extend([images[-1]] * (nframes - len(images)))
+        return images
+
+
+def extract_vision_info(conversations: list[dict] | list[list[dict]]) -> list[dict]:
+    vision_infos = []
+    if isinstance(conversations[0], dict):
+        conversations = [conversations]
+    for conversation in conversations:
+        for message in conversation:
+            if isinstance(message["content"], list):
+                for ele in message["content"]:
+                    if (
+                        "image" in ele
+                        or "image_url" in ele
+                        or "video" in ele
+                        or ele["type"] in ("image", "image_url", "video")
+                    ):
+                        vision_infos.append(ele)
+    return vision_infos
+
+
+def process_vision_info(
+    conversations: list[dict] | list[list[dict]],
+) -> tuple[list[Image.Image] | None, list[torch.Tensor | list[Image.Image]] | None]:
+    vision_infos = extract_vision_info(conversations)
+    ## Read images or videos
+    image_inputs = []
+    video_inputs = []
+    for vision_info in vision_infos:
+        if "image" in vision_info or "image_url" in vision_info:
+            image_inputs.append(fetch_image(vision_info))
+        elif "video" in vision_info:
+            video_inputs.append(fetch_video(vision_info))
+        else:
+            raise ValueError("image, image_url or video should in content.")
+    if len(image_inputs) == 0:
+        image_inputs = None
+    if len(video_inputs) == 0:
+        video_inputs = None
+    return image_inputs, video_inputs
+
+
+def process_video_tensor(
+    video: torch.Tensor,
+    nframes: int = 20,
+    resized_height: int = 336,
+    resized_width: int = 588,
+) -> torch.Tensor:
+    T, C, H, W = video.shape
+
+    idx = torch.linspace(0, T - 1, nframes).round().long()
+    video = video[idx]
+
+    video = transforms.functional.resize(
+        video,
+        [resized_height, resized_width],
+        interpolation=InterpolationMode.BICUBIC,
+        antialias=True,
+    ).float()
+    return video

Helios/_DEV/output_helios/helios-base/A_woman_dancing_1779378268/relative_l1.csv

@@ -0,0 +1,151 @@
+chunk_index,stage_index,step_index,timestep,relative_l1
+0,-1,0,999.8531494140625,0.03883999586105347
+0,-1,1,996.8655395507812,0.07517043501138687
+0,-1,2,993.7723388671875,0.03654193505644798
+0,-1,3,990.56787109375,0.08483197540044785
+0,-1,4,987.2460327148438,0.08009830117225647
+0,-1,5,983.80029296875,0.07057536393404007
+0,-1,6,980.2235717773438,0.04802758991718292
+0,-1,7,976.5081787109375,0.07817491888999939
+0,-1,8,972.64599609375,0.0625346451997757
+0,-1,9,968.6281127929688,0.06670602411031723
+0,-1,10,964.4448852539062,0.13630107045173645
+0,-1,11,960.0859375,0.06584817171096802
+0,-1,12,955.5398559570312,0.08350265026092529
+0,-1,13,950.7944946289062,0.08591210842132568
+0,-1,14,945.8363647460938,0.13262689113616943
+0,-1,15,940.6508178710938,0.07238229364156723
+0,-1,16,935.2218627929688,0.09051541239023209
+0,-1,17,929.5319213867188,0.12088219821453094
+0,-1,18,923.5617065429688,0.14103534817695618
+0,-1,19,917.2901000976562,0.08698604255914688
+0,-1,20,910.6935424804688,0.11635714769363403
+0,-1,21,903.7461547851562,0.11028948426246643
+0,-1,22,896.419189453125,0.15013201534748077
+0,-1,23,888.6807250976562,0.1311371624469757
+0,-1,24,880.4949951171875,0.19751965999603271
+0,-1,25,871.8221435546875,0.2383548617362976
+0,-1,26,862.6173095703125,0.17049884796142578
+0,-1,27,852.8300170898438,0.21639640629291534
+0,-1,28,842.4031982421875,0.19410116970539093
+0,-1,29,831.27197265625,0.22741833329200745
+0,-1,30,819.362548828125,0.23831278085708618
+0,-1,31,806.59033203125,0.22017505764961243
+0,-1,32,792.8580322265625,0.4130346179008484
+0,-1,33,778.0531616210938,0.2744807004928589
+0,-1,34,762.0449829101562,0.37864968180656433
+0,-1,35,744.6805419921875,0.3492948114871979
+0,-1,36,725.7799072265625,0.46409839391708374
+0,-1,37,705.1297607421875,0.40662717819213867
+0,-1,38,682.475341796875,0.5081633925437927
+0,-1,39,657.5100708007812,0.45880454778671265
+0,-1,40,629.861328125,0.5602932572364807
+0,-1,41,599.0718383789062,0.5158243775367737
+0,-1,42,564.5742797851562,0.7128055691719055
+0,-1,43,525.6558227539062,0.7992662191390991
+0,-1,44,481.4084777832031,0.6328389644622803
+0,-1,45,430.6573791503906,0.8070102334022522
+0,-1,46,371.8548278808594,0.8515591025352478
+0,-1,47,302.919677734375,0.9368497729301453
+0,-1,48,220.98605346679688,0.8796585202217102
+0,-1,49,121.9947509765625,1.2312424182891846
+1,-1,0,999.8531494140625,0.03624670207500458
+1,-1,1,996.8655395507812,0.07165471464395523
+1,-1,2,993.7723388671875,0.03155628964304924
+1,-1,3,990.56787109375,0.056210942566394806
+1,-1,4,987.2460327148438,0.053518958389759064
+1,-1,5,983.80029296875,0.0530499629676342
+1,-1,6,980.2235717773438,0.04741671308875084
+1,-1,7,976.5081787109375,0.04803739860653877
+1,-1,8,972.64599609375,0.05842754617333412
+1,-1,9,968.6281127929688,0.4486943781375885
+1,-1,10,964.4448852539062,0.06682908535003662
+1,-1,11,960.0859375,0.10405473411083221
+1,-1,12,955.5398559570312,0.09412363916635513
+1,-1,13,950.7944946289062,0.0726625993847847
+1,-1,14,945.8363647460938,0.0669218972325325
+1,-1,15,940.6508178710938,0.07415453344583511
+1,-1,16,935.2218627929688,0.1126844510436058
+1,-1,17,929.5319213867188,0.09317794442176819
+1,-1,18,923.5617065429688,0.10127455741167068
+1,-1,19,917.2901000976562,0.13545776903629303
+1,-1,20,910.6935424804688,0.10525280237197876
+1,-1,21,903.7461547851562,0.10674560815095901
+1,-1,22,896.419189453125,0.12109290063381195
+1,-1,23,888.6807250976562,0.15840622782707214
+1,-1,24,880.4949951171875,0.13410934805870056
+1,-1,25,871.8221435546875,0.34412819147109985
+1,-1,26,862.6173095703125,0.15101169049739838
+1,-1,27,852.8300170898438,0.1736321896314621
+1,-1,28,842.4031982421875,0.38356631994247437
+1,-1,29,831.27197265625,0.39209622144699097
+1,-1,30,819.362548828125,0.21551835536956787
+1,-1,31,806.59033203125,0.30495142936706543
+1,-1,32,792.8580322265625,0.25277721881866455
+1,-1,33,778.0531616210938,0.31062841415405273
+1,-1,34,762.0449829101562,0.33962252736091614
+1,-1,35,744.6805419921875,0.37112024426460266
+1,-1,36,725.7799072265625,0.4327954649925232
+1,-1,37,705.1297607421875,0.6683275103569031
+1,-1,38,682.475341796875,0.553996205329895
+1,-1,39,657.5100708007812,5.26118278503418
+1,-1,40,629.861328125,0.5473806858062744
+1,-1,41,599.0718383789062,0.597531259059906
+1,-1,42,564.5742797851562,0.6634519100189209
+1,-1,43,525.6558227539062,0.7166421413421631
+1,-1,44,481.4084777832031,0.9395881295204163
+1,-1,45,430.6573791503906,0.9884947538375854
+1,-1,46,371.8548278808594,0.7545281648635864
+1,-1,47,302.919677734375,0.9624993205070496
+1,-1,48,220.98605346679688,1.159847378730774
+1,-1,49,121.9947509765625,0.7360488176345825
+2,-1,0,999.8531494140625,0.0288735032081604
+2,-1,1,996.8655395507812,0.07416917383670807
+2,-1,2,993.7723388671875,0.051815830171108246
+2,-1,3,990.56787109375,0.04775497317314148
+2,-1,4,987.2460327148438,0.06091343238949776
+2,-1,5,983.80029296875,0.10853061079978943
+2,-1,6,980.2235717773438,0.06723586469888687
+2,-1,7,976.5081787109375,0.049189068377017975
+2,-1,8,972.64599609375,0.07407137751579285
+2,-1,9,968.6281127929688,0.13893790543079376
+2,-1,10,964.4448852539062,0.14785702526569366
+2,-1,11,960.0859375,0.08305556327104568
+2,-1,12,955.5398559570312,0.12652549147605896
+2,-1,13,950.7944946289062,0.07935374230146408
+2,-1,14,945.8363647460938,0.220855712890625
+2,-1,15,940.6508178710938,0.1035865917801857
+2,-1,16,935.2218627929688,0.13510257005691528
+2,-1,17,929.5319213867188,0.10435187816619873
+2,-1,18,923.5617065429688,0.09614348411560059
+2,-1,19,917.2901000976562,0.1463916301727295
+2,-1,20,910.6935424804688,0.12360315769910812
+2,-1,21,903.7461547851562,0.12062233686447144
+2,-1,22,896.419189453125,0.12362800538539886
+2,-1,23,888.6807250976562,0.13205184042453766
+2,-1,24,880.4949951171875,0.15743429958820343
+2,-1,25,871.8221435546875,0.1535092443227768
+2,-1,26,862.6173095703125,0.18612059950828552
+2,-1,27,852.8300170898438,0.21592804789543152
+2,-1,28,842.4031982421875,0.2141854465007782
+2,-1,29,831.27197265625,0.24770326912403107
+2,-1,30,819.362548828125,0.2301183044910431
+2,-1,31,806.59033203125,0.28837916254997253
+2,-1,32,792.8580322265625,0.28074881434440613
+2,-1,33,778.0531616210938,0.27006325125694275
+2,-1,34,762.0449829101562,0.33337464928627014
+2,-1,35,744.6805419921875,0.28511446714401245
+2,-1,36,725.7799072265625,0.3836577236652374
+2,-1,37,705.1297607421875,0.78025883436203
+2,-1,38,682.475341796875,0.40665745735168457
+2,-1,39,657.5100708007812,0.49699899554252625
+2,-1,40,629.861328125,0.8030208349227905
+2,-1,41,599.0718383789062,0.6307190656661987
+2,-1,42,564.5742797851562,0.8205258846282959
+2,-1,43,525.6558227539062,0.6443222761154175
+2,-1,44,481.4084777832031,0.7825407385826111
+2,-1,45,430.6573791503906,0.8667947053909302
+2,-1,46,371.8548278808594,1.5348774194717407
+2,-1,47,302.919677734375,0.9636214375495911
+2,-1,48,220.98605346679688,6.670920372009277
+2,-1,49,121.9947509765625,1.6488206386566162

Helios/_DEV/output_helios/helios-base/A_woman_dancing_1779378754/relative_l1.csv

@@ -0,0 +1,151 @@
+chunk_index,stage_index,step_index,timestep,relative_l1
+0,-1,0,999.8531494140625,0.03883999586105347
+0,-1,1,996.8655395507812,0.07517043501138687
+0,-1,2,993.7723388671875,0.03654193505644798
+0,-1,3,990.56787109375,0.08483197540044785
+0,-1,4,987.2460327148438,0.08009830117225647
+0,-1,5,983.80029296875,0.07057536393404007
+0,-1,6,980.2235717773438,0.04802758991718292
+0,-1,7,976.5081787109375,0.07817491888999939
+0,-1,8,972.64599609375,0.0625346451997757
+0,-1,9,968.6281127929688,0.06670602411031723
+0,-1,10,964.4448852539062,0.13630107045173645
+0,-1,11,960.0859375,0.06584817171096802
+0,-1,12,955.5398559570312,0.08350265026092529
+0,-1,13,950.7944946289062,0.08591210842132568
+0,-1,14,945.8363647460938,0.13262689113616943
+0,-1,15,940.6508178710938,0.07238229364156723
+0,-1,16,935.2218627929688,0.09051541239023209
+0,-1,17,929.5319213867188,0.12088219821453094
+0,-1,18,923.5617065429688,0.14103534817695618
+0,-1,19,917.2901000976562,0.08698604255914688
+0,-1,20,910.6935424804688,0.11635714769363403
+0,-1,21,903.7461547851562,0.11028948426246643
+0,-1,22,896.419189453125,0.15013201534748077
+0,-1,23,888.6807250976562,0.1311371624469757
+0,-1,24,880.4949951171875,0.19751965999603271
+0,-1,25,871.8221435546875,0.2383548617362976
+0,-1,26,862.6173095703125,0.17049884796142578
+0,-1,27,852.8300170898438,0.21639640629291534
+0,-1,28,842.4031982421875,0.19410116970539093
+0,-1,29,831.27197265625,0.22741833329200745
+0,-1,30,819.362548828125,0.23831278085708618
+0,-1,31,806.59033203125,0.22017505764961243
+0,-1,32,792.8580322265625,0.4130346179008484
+0,-1,33,778.0531616210938,0.2744807004928589
+0,-1,34,762.0449829101562,0.37864968180656433
+0,-1,35,744.6805419921875,0.3492948114871979
+0,-1,36,725.7799072265625,0.46409839391708374
+0,-1,37,705.1297607421875,0.40662717819213867
+0,-1,38,682.475341796875,0.5081633925437927
+0,-1,39,657.5100708007812,0.45880454778671265
+0,-1,40,629.861328125,0.5602932572364807
+0,-1,41,599.0718383789062,0.5158243775367737
+0,-1,42,564.5742797851562,0.7128055691719055
+0,-1,43,525.6558227539062,0.7992662191390991
+0,-1,44,481.4084777832031,0.6328389644622803
+0,-1,45,430.6573791503906,0.8070102334022522
+0,-1,46,371.8548278808594,0.8515591025352478
+0,-1,47,302.919677734375,0.9368497729301453
+0,-1,48,220.98605346679688,0.8796585202217102
+0,-1,49,121.9947509765625,1.2312424182891846
+1,-1,0,999.8531494140625,0.03624670207500458
+1,-1,1,996.8655395507812,0.07165471464395523
+1,-1,2,993.7723388671875,0.03155628964304924
+1,-1,3,990.56787109375,0.056210942566394806
+1,-1,4,987.2460327148438,0.053518958389759064
+1,-1,5,983.80029296875,0.0530499629676342
+1,-1,6,980.2235717773438,0.04741671308875084
+1,-1,7,976.5081787109375,0.04803739860653877
+1,-1,8,972.64599609375,0.05842754617333412
+1,-1,9,968.6281127929688,0.4486943781375885
+1,-1,10,964.4448852539062,0.06682908535003662
+1,-1,11,960.0859375,0.10405473411083221
+1,-1,12,955.5398559570312,0.09412363916635513
+1,-1,13,950.7944946289062,0.0726625993847847
+1,-1,14,945.8363647460938,0.0669218972325325
+1,-1,15,940.6508178710938,0.07415453344583511
+1,-1,16,935.2218627929688,0.1126844510436058
+1,-1,17,929.5319213867188,0.09317794442176819
+1,-1,18,923.5617065429688,0.10127455741167068
+1,-1,19,917.2901000976562,0.13545776903629303
+1,-1,20,910.6935424804688,0.10525280237197876
+1,-1,21,903.7461547851562,0.10674560815095901
+1,-1,22,896.419189453125,0.12109290063381195
+1,-1,23,888.6807250976562,0.15840622782707214
+1,-1,24,880.4949951171875,0.13410934805870056
+1,-1,25,871.8221435546875,0.34412819147109985
+1,-1,26,862.6173095703125,0.15101169049739838
+1,-1,27,852.8300170898438,0.1736321896314621
+1,-1,28,842.4031982421875,0.38356631994247437
+1,-1,29,831.27197265625,0.39209622144699097
+1,-1,30,819.362548828125,0.21551835536956787
+1,-1,31,806.59033203125,0.30495142936706543
+1,-1,32,792.8580322265625,0.25277721881866455
+1,-1,33,778.0531616210938,0.31062841415405273
+1,-1,34,762.0449829101562,0.33962252736091614
+1,-1,35,744.6805419921875,0.37112024426460266
+1,-1,36,725.7799072265625,0.4327954649925232
+1,-1,37,705.1297607421875,0.6683275103569031
+1,-1,38,682.475341796875,0.553996205329895
+1,-1,39,657.5100708007812,5.26118278503418
+1,-1,40,629.861328125,0.5473806858062744
+1,-1,41,599.0718383789062,0.597531259059906
+1,-1,42,564.5742797851562,0.6634519100189209
+1,-1,43,525.6558227539062,0.7166421413421631
+1,-1,44,481.4084777832031,0.9395881295204163
+1,-1,45,430.6573791503906,0.9884947538375854
+1,-1,46,371.8548278808594,0.7545281648635864
+1,-1,47,302.919677734375,0.9624993205070496
+1,-1,48,220.98605346679688,1.159847378730774
+1,-1,49,121.9947509765625,0.7360488176345825
+2,-1,0,999.8531494140625,0.0288735032081604
+2,-1,1,996.8655395507812,0.07416917383670807
+2,-1,2,993.7723388671875,0.051815830171108246
+2,-1,3,990.56787109375,0.04775497317314148
+2,-1,4,987.2460327148438,0.06091343238949776
+2,-1,5,983.80029296875,0.10853061079978943
+2,-1,6,980.2235717773438,0.06723586469888687
+2,-1,7,976.5081787109375,0.049189068377017975
+2,-1,8,972.64599609375,0.07407137751579285
+2,-1,9,968.6281127929688,0.13893790543079376
+2,-1,10,964.4448852539062,0.14785702526569366
+2,-1,11,960.0859375,0.08305556327104568
+2,-1,12,955.5398559570312,0.12652549147605896
+2,-1,13,950.7944946289062,0.07935374230146408
+2,-1,14,945.8363647460938,0.220855712890625
+2,-1,15,940.6508178710938,0.1035865917801857
+2,-1,16,935.2218627929688,0.13510257005691528
+2,-1,17,929.5319213867188,0.10435187816619873
+2,-1,18,923.5617065429688,0.09614348411560059
+2,-1,19,917.2901000976562,0.1463916301727295
+2,-1,20,910.6935424804688,0.12360315769910812
+2,-1,21,903.7461547851562,0.12062233686447144
+2,-1,22,896.419189453125,0.12362800538539886
+2,-1,23,888.6807250976562,0.13205184042453766
+2,-1,24,880.4949951171875,0.15743429958820343
+2,-1,25,871.8221435546875,0.1535092443227768
+2,-1,26,862.6173095703125,0.18612059950828552
+2,-1,27,852.8300170898438,0.21592804789543152
+2,-1,28,842.4031982421875,0.2141854465007782
+2,-1,29,831.27197265625,0.24770326912403107
+2,-1,30,819.362548828125,0.2301183044910431
+2,-1,31,806.59033203125,0.28837916254997253
+2,-1,32,792.8580322265625,0.28074881434440613
+2,-1,33,778.0531616210938,0.27006325125694275
+2,-1,34,762.0449829101562,0.33337464928627014
+2,-1,35,744.6805419921875,0.28511446714401245
+2,-1,36,725.7799072265625,0.3836577236652374
+2,-1,37,705.1297607421875,0.78025883436203
+2,-1,38,682.475341796875,0.40665745735168457
+2,-1,39,657.5100708007812,0.49699899554252625
+2,-1,40,629.861328125,0.8030208349227905
+2,-1,41,599.0718383789062,0.6307190656661987
+2,-1,42,564.5742797851562,0.8205258846282959
+2,-1,43,525.6558227539062,0.6443222761154175
+2,-1,44,481.4084777832031,0.7825407385826111
+2,-1,45,430.6573791503906,0.8667947053909302
+2,-1,46,371.8548278808594,1.5348774194717407
+2,-1,47,302.919677734375,0.9636214375495911
+2,-1,48,220.98605346679688,6.670920372009277
+2,-1,49,121.9947509765625,1.6488206386566162