# Copyright 2025 The Helios Team and The HuggingFace Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import glob import json import math import os from functools import lru_cache from typing import Any, Dict, List, Optional, Tuple, Union import einops import torch import torch.nn as nn import torch.nn.functional as F from einops import rearrange from diffusers.configuration_utils import ConfigMixin, register_to_config from diffusers.loaders import FromOriginalModelMixin, PeftAdapterMixin from diffusers.models._modeling_parallel import ContextParallelInput, ContextParallelOutput from diffusers.models.attention import AttentionMixin, AttentionModuleMixin, FeedForward from diffusers.models.cache_utils import CacheMixin from diffusers.models.embeddings import ( PixArtAlphaTextProjection, TimestepEmbedding, Timesteps, ) from diffusers.models.modeling_outputs import Transformer2DModelOutput from diffusers.models.modeling_utils import ModelMixin from diffusers.models.normalization import FP32LayerNorm from diffusers.utils import apply_lora_scale, deprecate, logging from diffusers.utils.torch_utils import maybe_allow_in_graph from .helios_kernels import attn_varlen_func, create_navit_attention_masks logger = logging.get_logger(__name__) # pylint: disable=invalid-name def _short_attn_debug_target_matches(value, targets, total=None): if targets is None: return True if not isinstance(targets, (list, tuple, set)): targets = [targets] for target in targets: if target == "last" and total is not None and value == total - 1: return True if target == "first" and value == 0: return True if isinstance(target, int) and value == target: return True return False @torch.no_grad() def _save_short_attn_debug(attn, query, key, original_context_length, original_context_length_list=None): config = getattr(attn, "_short_attn_debug_config", None) state = getattr(attn, "_short_attn_debug_state", None) if not config or not config.get("enabled", True) or attn.is_cross_attention: return if original_context_length_list is not None and len(original_context_length_list) != 1: return block_idx = getattr(attn, "_helios_block_idx", None) if not _short_attn_debug_target_matches(block_idx, config.get("blocks")): return if state is None: state = {} if not _short_attn_debug_target_matches(state.get("chunk_index", 0), config.get("chunks")): return if not _short_attn_debug_target_matches( state.get("step_index", 0), config.get("steps"), state.get("total_steps") ): return pass_names = config.get("pass_names", ["cond"]) if state.get("pass_name", "cond") not in pass_names: return if original_context_length is None: return history_seq_len = key.shape[1] - original_context_length if history_seq_len <= 0: return grid_h, grid_w = config.get("grid", (24, 40)) grid_tokens = int(grid_h) * int(grid_w) if grid_tokens <= 0 or original_context_length % grid_tokens != 0: return current_frames = original_context_length // grid_tokens current_frame = int(config.get("current_frame", current_frames - 1)) if current_frame < 0: current_frame += current_frames if current_frame < 0 or current_frame >= current_frames: return short_history_frames = int(config.get("short_history_frames", 2)) prev_short_frame = int(config.get("prev_short_frame", short_history_frames - 1)) if prev_short_frame < 0: prev_short_frame += short_history_frames short_len = short_history_frames * grid_tokens if history_seq_len < short_len or prev_short_frame < 0 or prev_short_frame >= short_history_frames: return short_start = history_seq_len - short_len prev_start = short_start + prev_short_frame * grid_tokens if query.shape[1] == history_seq_len + original_context_length: current_start = history_seq_len + current_frame * grid_tokens elif query.shape[1] == original_context_length: current_start = current_frame * grid_tokens else: return batch_index = int(config.get("batch_index", 0)) if batch_index < 0 or batch_index >= query.shape[0]: return q_frame = query[batch_index, current_start : current_start + grid_tokens].float() k_prev = key[batch_index, prev_start : prev_start + grid_tokens].float() if q_frame.shape[0] != grid_tokens or k_prev.shape[0] != grid_tokens: return topk = max(2, int(config.get("topk", 2))) query_chunk_size = int(config.get("query_chunk_size", 128)) scale = 1.0 / math.sqrt(q_frame.shape[-1]) top_scores = [] top_indices = [] for start in range(0, grid_tokens, query_chunk_size): q_chunk = q_frame[start : start + query_chunk_size] scores = torch.einsum("qhd,khd->hqk", q_chunk, k_prev) * scale scores = scores.mean(dim=0) values, indices = scores.topk(topk, dim=-1) top_scores.append(values.cpu()) top_indices.append(indices.cpu()) top_scores = torch.cat(top_scores, dim=0) top_indices = torch.cat(top_indices, dim=0) top1 = top_indices[:, 0] match_y = torch.div(top1, grid_w, rounding_mode="floor") match_x = top1 % grid_w query_positions = torch.arange(grid_tokens) query_y = torch.div(query_positions, grid_w, rounding_mode="floor") query_x = query_positions % grid_w match_yx = torch.stack([match_y, match_x], dim=-1).reshape(grid_h, grid_w, 2) query_yx = torch.stack([query_y, query_x], dim=-1).reshape(grid_h, grid_w, 2) displacement_yx = match_yx - query_yx artifact = { "block": block_idx, "chunk_index": state.get("chunk_index"), "stage": state.get("stage"), "stage_index": state.get("stage_index"), "step_index": state.get("step_index"), "total_steps": state.get("total_steps"), "pass_name": state.get("pass_name"), "timestep": state.get("timestep"), "current_frame": current_frame, "prev_short_frame": prev_short_frame, "grid": (grid_h, grid_w), "match_yx": match_yx, "query_yx": query_yx, "displacement_yx": displacement_yx, "topk_indices": top_indices.reshape(grid_h, grid_w, topk), "topk_scores": top_scores.reshape(grid_h, grid_w, topk), "top1_score": top_scores[:, 0].reshape(grid_h, grid_w), "top2_score": top_scores[:, 1].reshape(grid_h, grid_w), "margin": (top_scores[:, 0] - top_scores[:, 1]).reshape(grid_h, grid_w), } output_dir = config.get("output_dir", "short_attn_debug") os.makedirs(output_dir, exist_ok=True) filename = ( f"short_attn_chunk{state.get('chunk_index', 0)}" f"_step{state.get('step_index', 0)}" f"_block{block_idx}" f"_frame{current_frame}" f"_{state.get('pass_name', 'cond')}.pt" ) path = os.path.join(output_dir, filename) if os.path.exists(path) and not config.get("overwrite", True): return torch.save(artifact, path) def pad_for_3d_conv(x, kernel_size): b, c, t, h, w = x.shape pt, ph, pw = kernel_size pad_t = (pt - (t % pt)) % pt pad_h = (ph - (h % ph)) % ph pad_w = (pw - (w % pw)) % pw return torch.nn.functional.pad(x, (0, pad_w, 0, pad_h, 0, pad_t), mode="replicate") def center_down_sample_3d(x, kernel_size): return torch.nn.functional.avg_pool3d(x, kernel_size, stride=kernel_size) def apply_rotary_emb_transposed( hidden_states: torch.Tensor, freqs_cis: torch.Tensor, ): x_1, x_2 = hidden_states.unflatten(-1, (-1, 2)).unbind(-1) cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1) out = torch.empty_like(hidden_states) out[..., 0::2] = x_1 * cos[..., 0::2] - x_2 * sin[..., 1::2] out[..., 1::2] = x_1 * sin[..., 1::2] + x_2 * cos[..., 0::2] return out.type_as(hidden_states) def _get_qkv_projections(attn: "HeliosAttention", hidden_states: torch.Tensor, encoder_hidden_states: torch.Tensor): # encoder_hidden_states is only passed for cross-attention if encoder_hidden_states is None: encoder_hidden_states = hidden_states if attn.fused_projections: if not attn.is_cross_attention: # In self-attention layers, we can fuse the entire QKV projection into a single linear query, key, value = attn.to_qkv(hidden_states).chunk(3, dim=-1) else: # In cross-attention layers, we can only fuse the KV projections into a single linear query = attn.to_q(hidden_states) key, value = attn.to_kv(encoder_hidden_states).chunk(2, dim=-1) else: query = attn.to_q(hidden_states) key = attn.to_k(encoder_hidden_states) value = attn.to_v(encoder_hidden_states) return query, key, value class Discriminator3DHead(nn.Module): def __init__(self, input_channel, cond_map_dim=768): super().__init__() self.head3d = nn.Sequential( nn.Conv3d(input_channel, cond_map_dim, 3, stride=(1, 1, 1), padding=(1, 1, 1)), # [31, 8, 8] nn.GroupNorm(32, cond_map_dim), nn.SiLU(False), nn.Conv3d(cond_map_dim, cond_map_dim, 4, stride=[2, 2, 2], padding=(1, 1, 1)), # [15, 4, 4] nn.GroupNorm(32, cond_map_dim), nn.SiLU(False), nn.Conv3d(cond_map_dim, cond_map_dim, 4, stride=[2, 2, 2], padding=(1, 1, 1)), # [7, 2, 2] nn.GroupNorm(32, cond_map_dim), nn.SiLU(False), nn.Conv3d(cond_map_dim, cond_map_dim, 3, stride=[2, 1, 1], padding=(1, 1, 1)), # [3, 2, 2] nn.GroupNorm(32, cond_map_dim), nn.SiLU(False), nn.Conv3d(cond_map_dim, cond_map_dim, 3, stride=[2, 1, 1], padding=(1, 1, 1)), # [1, 2, 2] nn.GroupNorm(32, cond_map_dim), nn.SiLU(False), nn.Conv3d( cond_map_dim, cond_map_dim, kernel_size=[1, 3, 3], stride=[1, 1, 1], padding=(0, 1, 1) ), # [b, 768, 1, 1, 2] nn.GroupNorm(32, cond_map_dim), nn.SiLU(False), nn.AdaptiveAvgPool3d((1, 1, 1)), nn.Flatten(), nn.Linear(cond_map_dim, 1), ) def forward(self, x): return self.head3d(x) class LoRALinearLayer(nn.Module): def __init__( self, in_features: int, out_features: int, rank: int = 128, device="cuda", dtype: Optional[torch.dtype] = torch.float32, ): super().__init__() self.down = nn.Linear(in_features, rank, bias=False, device=device, dtype=dtype) self.up = nn.Linear(rank, out_features, bias=False, device=device, dtype=dtype) self.rank = rank self.out_features = out_features self.in_features = in_features nn.init.normal_(self.down.weight, std=1 / rank) nn.init.zeros_(self.up.weight) def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: orig_dtype = hidden_states.dtype dtype = self.down.weight.dtype down_hidden_states = self.down(hidden_states.to(dtype)) up_hidden_states = self.up(down_hidden_states) return up_hidden_states.to(orig_dtype) class HeliosOutputNorm(nn.Module): def __init__(self, dim: int, eps: float = 1e-6, elementwise_affine: bool = False): super().__init__() self.scale_shift_table = nn.Parameter(torch.randn(1, 2, dim) / dim**0.5) self.norm = FP32LayerNorm(dim, eps, elementwise_affine=False) def forward(self, hidden_states: torch.Tensor, temb: torch.Tensor, original_context_length: int): temb = temb[:, -original_context_length:, :] shift, scale = (self.scale_shift_table.unsqueeze(0).to(temb.device) + temb.unsqueeze(2)).chunk(2, dim=2) shift, scale = shift.squeeze(2).to(hidden_states.device), scale.squeeze(2).to(hidden_states.device) hidden_states = hidden_states[:, -original_context_length:, :] hidden_states = (self.norm(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states) return hidden_states class HeliosAttnProcessor: _attention_backend = None _parallel_config = None def __init__(self): if not hasattr(F, "scaled_dot_product_attention"): raise ImportError( "HeliosAttnProcessor requires PyTorch 2.0. To use it, please upgrade PyTorch to version 2.0 or higher." ) self.kv_cache = None self.cache_enabled = False def enable_cache(self): self.cache_enabled = True self.kv_cache = None def disable_cache(self): self.cache_enabled = False self.kv_cache = None def clear_cache(self): self.kv_cache = None def __call__( self, attn: "HeliosAttention", hidden_states: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, original_context_length: int = None, original_context_length_list: list = None, enable_navit: bool = False, is_first_denoising_step: bool = False, ) -> torch.Tensor: use_cache = False history_seq_len = None enable_cross = attn.is_cross_attention if not enable_cross: history_seq_len = (hidden_states.shape[1] - original_context_length) // len(original_context_length_list) if attn.restrict_self_attn: use_cache = self.cache_enabled and not is_first_denoising_step and self.kv_cache is not None assert not (use_cache and enable_navit), "Cache and NAViT are incompatible" if use_cache: key_history = self.kv_cache["key_history"] value_history = self.kv_cache["value_history"] history_hidden_states = self.kv_cache["history_hidden_states"] hidden_states = hidden_states[:, history_seq_len:] rotary_emb = rotary_emb[:, history_seq_len:] if rotary_emb is not None else None query, key, value = _get_qkv_projections(attn, hidden_states, encoder_hidden_states) query = attn.norm_q(query) key = attn.norm_k(key) if attn.restrict_self_attn and not use_cache: if enable_navit: seq_start = 0 num_seqs = len(original_context_length_list) query_list = [None] * num_seqs key_list = [None] * num_seqs value_list = [None] * num_seqs query_history_list = [None] * num_seqs key_history_list = [None] * num_seqs value_history_list = [None] * num_seqs if attn.restrict_lora: history_hidden_states_list = [None] * num_seqs if rotary_emb is not None: rotary_emb_list = [None] * num_seqs history_rotary_emb_list = [None] * num_seqs for idx, cur_seq_len in enumerate(original_context_length_list[::-1]): seq_end = seq_start + cur_seq_len + history_seq_len slice_qkv = slice(seq_start, seq_end) cur_query = query[:, slice_qkv, :] cur_key = key[:, slice_qkv, :] cur_value = value[:, slice_qkv, :] query_history_list[idx] = cur_query[:, :history_seq_len] query_list[idx] = cur_query[:, history_seq_len:] key_history_list[idx] = cur_key[:, :history_seq_len] key_list[idx] = cur_key[:, history_seq_len:] value_history_list[idx] = cur_value[:, :history_seq_len] value_list[idx] = cur_value[:, history_seq_len:] if attn.restrict_lora: cur_hidden = hidden_states[:, slice_qkv, :] history_hidden_states_list[idx] = cur_hidden[:, :history_seq_len] if rotary_emb is not None: cur_rotary_emb = rotary_emb[:, slice_qkv, :] history_rotary_emb_list[idx] = cur_rotary_emb[:, :history_seq_len] rotary_emb_list[idx] = cur_rotary_emb[:, history_seq_len:] seq_start = seq_end query = torch.cat(query_list, dim=1) key = torch.cat(key_list, dim=1) value = torch.cat(value_list, dim=1) query_history = torch.cat(query_history_list, dim=1) key_history = torch.cat(key_history_list, dim=1) value_history = torch.cat(value_history_list, dim=1) if attn.restrict_lora: history_hidden_states = torch.cat(history_hidden_states_list, dim=1) query_history = query_history + attn.q_loras(history_hidden_states) key_history = key_history + attn.k_loras(history_hidden_states) value_history = value_history + attn.v_loras(history_hidden_states) query_history = query_history.unflatten(2, (attn.heads, -1)) key_history = key_history.unflatten(2, (attn.heads, -1)) value_history = value_history.unflatten(2, (attn.heads, -1)) if rotary_emb is not None: rotary_emb = torch.cat(rotary_emb_list, dim=1) history_rotary_emb = torch.cat(history_rotary_emb_list, dim=1) query_history = apply_rotary_emb_transposed(query_history, history_rotary_emb) key_history = apply_rotary_emb_transposed(key_history, history_rotary_emb) else: history_hidden_states = hidden_states[:, :history_seq_len] query_history, query = query[:, :history_seq_len], query[:, history_seq_len:] key_history, key = key[:, :history_seq_len], key[:, history_seq_len:] value_history, value = value[:, :history_seq_len], value[:, history_seq_len:] if attn.restrict_lora: query_history = query_history + attn.q_loras(history_hidden_states) key_history = key_history + attn.k_loras(history_hidden_states) value_history = value_history + attn.v_loras(history_hidden_states) query_history = query_history.unflatten(2, (attn.heads, -1)) key_history = key_history.unflatten(2, (attn.heads, -1)) value_history = value_history.unflatten(2, (attn.heads, -1)) if rotary_emb is not None: history_rotary_emb, rotary_emb = (rotary_emb[:, :history_seq_len], rotary_emb[:, history_seq_len:]) query_history = apply_rotary_emb_transposed(query_history, history_rotary_emb) key_history = apply_rotary_emb_transposed(key_history, history_rotary_emb) query = query.unflatten(2, (attn.heads, -1)) key = key.unflatten(2, (attn.heads, -1)) value = value.unflatten(2, (attn.heads, -1)) if rotary_emb is not None: query = apply_rotary_emb_transposed(query, rotary_emb) key = apply_rotary_emb_transposed(key, rotary_emb) if attn.restrict_self_attn: if use_cache: key = torch.cat([key_history, key], dim=1) value = torch.cat([value_history, value], dim=1) else: if enable_navit: num_seqs = len(original_context_length_list) key_list = [None] * num_seqs value_list = [None] * num_seqs seq_start = 0 seq_start_history = 0 for idx, cur_seq_len in enumerate(original_context_length_list[::-1]): key_list[idx] = torch.cat( [ key_history[:, seq_start_history : seq_start_history + history_seq_len, :], key[:, seq_start : seq_start + cur_seq_len, :], ], dim=1, ) value_list[idx] = torch.cat( [ value_history[:, seq_start_history : seq_start_history + history_seq_len, :], value[:, seq_start : seq_start + cur_seq_len, :], ], dim=1, ) seq_start += cur_seq_len seq_start_history += history_seq_len key = torch.cat(key_list, dim=1) value = torch.cat(value_list, dim=1) history_hidden_states = attn_varlen_func( query_history, key_history, value_history, attention_mask=attention_mask[1], ) else: key = torch.cat([key_history, key], dim=1) value = torch.cat([value_history, value], dim=1) history_hidden_states = attn_varlen_func( query_history, key_history, value_history, ) history_hidden_states = history_hidden_states.flatten(2, 3) history_hidden_states = history_hidden_states.type_as(query) if self.cache_enabled and is_first_denoising_step and not enable_navit: self.kv_cache = { "key_history": key_history, "value_history": value_history, "history_hidden_states": history_hidden_states, } if enable_cross and enable_navit: key = key.repeat(1, len(original_context_length_list), 1, 1) value = value.repeat(1, len(original_context_length_list), 1, 1) if not enable_cross and history_seq_len > 0 and attn.is_amplify_history: scale_key = attn.get_scale_key() if attn.history_scale_mode == "per_head": scale_key = scale_key.view(1, 1, -1, 1) if enable_navit: key_new = key.clone() seq_start = 0 for cur_seq_len in original_context_length_list[::-1]: hist_slice = slice(seq_start, seq_start + history_seq_len) key_new[:, hist_slice] = key[:, hist_slice] * scale_key seq_start += history_seq_len + cur_seq_len key = key_new else: key = torch.cat([key[:, :history_seq_len] * scale_key, key[:, history_seq_len:]], dim=1) _save_short_attn_debug(attn, query, key, original_context_length, original_context_length_list) hidden_states = attn_varlen_func( query, key, value, attention_mask=attention_mask[0] if isinstance(attention_mask, list) else attention_mask, ) hidden_states = hidden_states.flatten(2, 3) hidden_states = hidden_states.type_as(query) if attn.restrict_self_attn: if enable_navit: num_seqs = len(original_context_length_list) hidden_states_list = [None] * num_seqs seq_start = 0 seq_start_history = 0 for idx, cur_seq_len in enumerate(original_context_length_list[::-1]): hidden_states_list[idx] = torch.cat( [ history_hidden_states[:, seq_start_history : seq_start_history + history_seq_len, :], hidden_states[:, seq_start : seq_start + cur_seq_len, :], ], dim=1, ) seq_start += cur_seq_len seq_start_history += history_seq_len hidden_states = torch.cat(hidden_states_list, dim=1) else: hidden_states = torch.cat([history_hidden_states, hidden_states], dim=1) hidden_states = attn.to_out[0](hidden_states) hidden_states = attn.to_out[1](hidden_states) return hidden_states class HeliosAttnProcessor2_0: def __new__(cls, *args, **kwargs): deprecation_message = ( "The HeliosAttnProcessor2_0 class is deprecated and will be removed in a future version. " "Please use HeliosAttnProcessor instead. " ) deprecate("HeliosAttnProcessor2_0", "1.0.0", deprecation_message, standard_warn=False) return HeliosAttnProcessor(*args, **kwargs) class HeliosAttention(torch.nn.Module, AttentionModuleMixin): _default_processor_cls = HeliosAttnProcessor _available_processors = [HeliosAttnProcessor] def __init__( self, dim: int, heads: int = 8, dim_head: int = 64, eps: float = 1e-5, dropout: float = 0.0, added_kv_proj_dim: Optional[int] = None, cross_attention_dim_head: Optional[int] = None, processor=None, is_cross_attention=None, restrict_self_attn=False, is_train_restrict_lora=False, restrict_lora=False, restrict_lora_rank=128, is_amplify_history=False, history_scale_mode="per_head", # [scalar, per_head] ): super().__init__() self.inner_dim = dim_head * heads self.heads = heads self.added_kv_proj_dim = added_kv_proj_dim self.cross_attention_dim_head = cross_attention_dim_head self.kv_inner_dim = self.inner_dim if cross_attention_dim_head is None else cross_attention_dim_head * heads self.to_q = torch.nn.Linear(dim, self.inner_dim, bias=True) self.to_k = torch.nn.Linear(dim, self.kv_inner_dim, bias=True) self.to_v = torch.nn.Linear(dim, self.kv_inner_dim, bias=True) self.to_out = torch.nn.ModuleList( [ torch.nn.Linear(self.inner_dim, dim, bias=True), torch.nn.Dropout(dropout), ] ) self.norm_q = torch.nn.RMSNorm(dim_head * heads, eps=eps, elementwise_affine=True) self.norm_k = torch.nn.RMSNorm(dim_head * heads, eps=eps, elementwise_affine=True) self.add_k_proj = self.add_v_proj = None if added_kv_proj_dim is not None: self.add_k_proj = torch.nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True) self.add_v_proj = torch.nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True) self.norm_added_k = torch.nn.RMSNorm(dim_head * heads, eps=eps) if is_cross_attention is not None: self.is_cross_attention = is_cross_attention else: self.is_cross_attention = cross_attention_dim_head is not None self.set_processor(processor) self.restrict_self_attn = restrict_self_attn self.restrict_lora = restrict_lora if restrict_lora: self.init_lora(is_train=is_train_restrict_lora, lora_rank=restrict_lora_rank) self.is_amplify_history = is_amplify_history if is_amplify_history: if history_scale_mode == "scalar": self.history_key_scale = nn.Parameter(torch.ones(1)) elif history_scale_mode == "per_head": self.history_key_scale = nn.Parameter(torch.ones(heads)) else: raise ValueError(f"Unknown history_scale_mode: {history_scale_mode}") self.history_scale_mode = history_scale_mode self.max_scale = 10.0 self.register_buffer("_scale_cache", None) def get_scale_key(self): if self.history_key_scale.requires_grad: scale = 1.0 + torch.sigmoid(self.history_key_scale) * (self.max_scale - 1.0) else: if self._scale_cache is None: self._scale_cache = 1.0 + torch.sigmoid(self.history_key_scale) * (self.max_scale - 1.0) scale = self._scale_cache return scale def init_lora(self, is_train=False, lora_rank=128): dim = self.inner_dim self.q_loras = LoRALinearLayer(dim, dim, rank=lora_rank) self.k_loras = LoRALinearLayer(dim, dim, rank=lora_rank) self.v_loras = LoRALinearLayer(dim, dim, rank=lora_rank) requires_grad = is_train for lora in [self.q_loras, self.k_loras, self.v_loras]: for param in lora.parameters(): param.requires_grad = requires_grad def fuse_projections(self): if getattr(self, "fused_projections", False): return if not self.is_cross_attention: concatenated_weights = torch.cat([self.to_q.weight.data, self.to_k.weight.data, self.to_v.weight.data]) concatenated_bias = torch.cat([self.to_q.bias.data, self.to_k.bias.data, self.to_v.bias.data]) out_features, in_features = concatenated_weights.shape with torch.device("meta"): self.to_qkv = nn.Linear(in_features, out_features, bias=True) self.to_qkv.load_state_dict( {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True ) else: concatenated_weights = torch.cat([self.to_k.weight.data, self.to_v.weight.data]) concatenated_bias = torch.cat([self.to_k.bias.data, self.to_v.bias.data]) out_features, in_features = concatenated_weights.shape with torch.device("meta"): self.to_kv = nn.Linear(in_features, out_features, bias=True) self.to_kv.load_state_dict( {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True ) if self.added_kv_proj_dim is not None: concatenated_weights = torch.cat([self.add_k_proj.weight.data, self.add_v_proj.weight.data]) concatenated_bias = torch.cat([self.add_k_proj.bias.data, self.add_v_proj.bias.data]) out_features, in_features = concatenated_weights.shape with torch.device("meta"): self.to_added_kv = nn.Linear(in_features, out_features, bias=True) self.to_added_kv.load_state_dict( {"weight": concatenated_weights, "bias": concatenated_bias}, strict=True, assign=True ) self.fused_projections = True @torch.no_grad() def unfuse_projections(self): if not getattr(self, "fused_projections", False): return if hasattr(self, "to_qkv"): delattr(self, "to_qkv") if hasattr(self, "to_kv"): delattr(self, "to_kv") if hasattr(self, "to_added_kv"): delattr(self, "to_added_kv") self.fused_projections = False def forward( self, hidden_states: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, attention_mask: Optional[torch.Tensor] = None, rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, original_context_length: int = None, original_context_length_list: list = None, enable_navit: bool = False, **kwargs, ) -> torch.Tensor: return self.processor( self, hidden_states, encoder_hidden_states, attention_mask, rotary_emb, original_context_length, original_context_length_list, enable_navit, **kwargs, ) class HeliosTimeTextEmbedding(nn.Module): def __init__( self, dim: int, time_freq_dim: int, time_proj_dim: int, text_embed_dim: int, ): super().__init__() self.timesteps_proj = Timesteps(num_channels=time_freq_dim, flip_sin_to_cos=True, downscale_freq_shift=0) self.time_embedder = TimestepEmbedding(in_channels=time_freq_dim, time_embed_dim=dim) self.act_fn = nn.SiLU() self.time_proj = nn.Linear(dim, time_proj_dim) self.text_embedder = PixArtAlphaTextProjection(text_embed_dim, dim, act_fn="gelu_tanh") def forward( self, timestep: torch.Tensor, encoder_hidden_states: Optional[torch.Tensor] = None, is_return_encoder_hidden_states: bool = True, ): B = None F = None if timestep.ndim == 2: B, F = timestep.shape timestep = timestep.flatten() timestep = self.timesteps_proj(timestep) # torch.Size([2]) -> torch.Size([2, 256]) time_embedder_dtype = next(iter(self.time_embedder.parameters())).dtype if timestep.dtype != time_embedder_dtype and time_embedder_dtype != torch.int8: timestep = timestep.to(time_embedder_dtype) temb = self.time_embedder(timestep).type_as(encoder_hidden_states) # torch.Size([2, 1536]) timestep_proj = self.time_proj(self.act_fn(temb)) # torch.Size([2, 9216] if B is not None and F is not None: temb = temb.reshape(B, F, -1) timestep_proj = timestep_proj.reshape(B, F, -1) if encoder_hidden_states is not None and is_return_encoder_hidden_states: encoder_hidden_states = self.text_embedder(encoder_hidden_states) # torch.Size([2, 512, 1536]) return temb, timestep_proj, encoder_hidden_states class HeliosRotaryPosEmbed(nn.Module): def __init__(self, rope_dim, theta): super().__init__() self.DT, self.DY, self.DX = rope_dim self.theta = theta self.register_buffer("freqs_base_t", self._get_freqs_base(self.DT), persistent=False) self.register_buffer("freqs_base_y", self._get_freqs_base(self.DY), persistent=False) self.register_buffer("freqs_base_x", self._get_freqs_base(self.DX), persistent=False) def _get_freqs_base(self, dim): return 1.0 / (self.theta ** (torch.arange(0, dim, 2, dtype=torch.float32)[: (dim // 2)] / dim)) @torch.no_grad() def get_frequency_batched(self, freqs_base, pos): freqs = torch.einsum("d,bthw->dbthw", freqs_base, pos) freqs = freqs.repeat_interleave(2, dim=0) return freqs.cos(), freqs.sin() @torch.no_grad() @lru_cache(maxsize=32) def _get_spatial_meshgrid(self, height, width, device_str): device = torch.device(device_str) gy = torch.arange(height, device=device, dtype=torch.float32) gx = torch.arange(width, device=device, dtype=torch.float32) GY, GX = torch.meshgrid(gy, gx, indexing="ij") return GY, GX @torch.no_grad() def forward(self, frame_indices, height, width, device): B = frame_indices.shape[0] T = frame_indices.shape[1] frame_indices = frame_indices.to(device=device, dtype=torch.float32) GY, GX = self._get_spatial_meshgrid(height, width, str(device)) GT = frame_indices[:, :, None, None].expand(B, T, height, width) GY_batch = GY[None, None, :, :].expand(B, T, -1, -1) GX_batch = GX[None, None, :, :].expand(B, T, -1, -1) FCT, FST = self.get_frequency_batched(self.freqs_base_t, GT) FCY, FSY = self.get_frequency_batched(self.freqs_base_y, GY_batch) FCX, FSX = self.get_frequency_batched(self.freqs_base_x, GX_batch) result = torch.cat([FCT, FCY, FCX, FST, FSY, FSX], dim=0) return result.permute(1, 0, 2, 3, 4) @maybe_allow_in_graph class HeliosTransformerBlock(nn.Module): def __init__( self, dim: int, ffn_dim: int, num_heads: int, qk_norm: str = "rms_norm_across_heads", cross_attn_norm: bool = False, eps: float = 1e-6, added_kv_proj_dim: Optional[int] = None, restrict_self_attn: bool = False, guidance_cross_attn: bool = False, is_train_restrict_lora: bool = False, restrict_lora: bool = False, restrict_lora_rank: int = 128, is_amplify_history: bool = False, history_scale_mode: str = "per_head", # [scalar, per_head], ): super().__init__() # 1. Self-attention self.norm1 = FP32LayerNorm(dim, eps, elementwise_affine=False) self.attn1 = HeliosAttention( dim=dim, heads=num_heads, dim_head=dim // num_heads, eps=eps, cross_attention_dim_head=None, processor=HeliosAttnProcessor(), restrict_self_attn=restrict_self_attn, is_train_restrict_lora=is_train_restrict_lora, restrict_lora=restrict_lora, restrict_lora_rank=restrict_lora_rank, is_amplify_history=is_amplify_history, history_scale_mode=history_scale_mode, ) # 2. Cross-attention self.attn2 = HeliosAttention( dim=dim, heads=num_heads, dim_head=dim // num_heads, eps=eps, added_kv_proj_dim=added_kv_proj_dim, cross_attention_dim_head=dim // num_heads, processor=HeliosAttnProcessor(), ) self.norm2 = FP32LayerNorm(dim, eps, elementwise_affine=True) if cross_attn_norm else nn.Identity() # 3. Feed-forward self.ffn = FeedForward(dim, inner_dim=ffn_dim, activation_fn="gelu-approximate") self.norm3 = FP32LayerNorm(dim, eps, elementwise_affine=False) self.scale_shift_table = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5) # 4. Guidance cross-attention self.guidance_cross_attn = guidance_cross_attn def forward( self, hidden_states: torch.Tensor, encoder_hidden_states: torch.Tensor, temb: torch.Tensor, rotary_emb: torch.Tensor, navit_hidden_attention_mask: Optional[torch.Tensor] = None, navit_encoder_attention_mask: Optional[torch.Tensor] = None, original_context_length: int = None, original_context_length_list: list = None, is_first_denoising_step: bool = False, ) -> torch.Tensor: enable_navit = False if len(original_context_length_list) > 1: enable_navit = True if temb.ndim == 4: shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = ( self.scale_shift_table.unsqueeze(0) + temb.float() ).chunk(6, dim=2) # batch_size, seq_len, 1, inner_dim shift_msa = shift_msa.squeeze(2) scale_msa = scale_msa.squeeze(2) gate_msa = gate_msa.squeeze(2) c_shift_msa = c_shift_msa.squeeze(2) c_scale_msa = c_scale_msa.squeeze(2) c_gate_msa = c_gate_msa.squeeze(2) else: shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = ( self.scale_shift_table + temb.float() ).chunk(6, dim=1) # 1. Self-attention norm_hidden_states = (self.norm1(hidden_states.float()) * (1 + scale_msa) + shift_msa).type_as(hidden_states) attn_output = self.attn1( norm_hidden_states, None, navit_hidden_attention_mask, rotary_emb, original_context_length, original_context_length_list, enable_navit, is_first_denoising_step=is_first_denoising_step, ) hidden_states = (hidden_states.float() + attn_output * gate_msa).type_as(hidden_states) # 2. Cross-attention if self.guidance_cross_attn: history_seq_len = (hidden_states.shape[1] - original_context_length) // len(original_context_length_list) if enable_navit: num_seqs = len(original_context_length_list) hidden_states_list = [None] * num_seqs history_hidden_states_list = [None] * num_seqs seq_start = 0 for idx, cur_seq_len in enumerate(original_context_length_list[::-1]): seq_end = seq_start + cur_seq_len + history_seq_len cur_hidden_states = hidden_states[:, seq_start:seq_end, :] history_hidden_states_list[idx] = cur_hidden_states[:, :history_seq_len] hidden_states_list[idx] = cur_hidden_states[:, history_seq_len:] seq_start += cur_seq_len + history_seq_len hidden_states = torch.cat(hidden_states_list, dim=1) norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states) attn_output = self.attn2( norm_hidden_states, encoder_hidden_states, navit_encoder_attention_mask, None, original_context_length, original_context_length_list, enable_navit, ) hidden_states = hidden_states + attn_output seq_start = 0 for idx, cur_seq_len in enumerate(original_context_length_list[::-1]): cur_hidden_states = hidden_states[:, seq_start : seq_start + cur_seq_len, :] hidden_states_list[idx] = torch.cat([history_hidden_states_list[idx], cur_hidden_states], dim=1) seq_start += cur_seq_len hidden_states = torch.cat(hidden_states_list, dim=1) else: history_hidden_states, hidden_states = ( hidden_states[:, :history_seq_len], hidden_states[:, history_seq_len:], ) norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states) attn_output = self.attn2( norm_hidden_states, encoder_hidden_states, navit_encoder_attention_mask, None, original_context_length, original_context_length_list, enable_navit, ) hidden_states = hidden_states + attn_output hidden_states = torch.cat([history_hidden_states, hidden_states], dim=1) else: norm_hidden_states = self.norm2(hidden_states.float()).type_as(hidden_states) attn_output = self.attn2( norm_hidden_states, encoder_hidden_states, navit_encoder_attention_mask, None, original_context_length, original_context_length_list, enable_navit, ) hidden_states = hidden_states + attn_output # 3. Feed-forward norm_hidden_states = (self.norm3(hidden_states.float()) * (1 + c_scale_msa) + c_shift_msa).type_as( hidden_states ) ff_output = self.ffn(norm_hidden_states) hidden_states = (hidden_states.float() + ff_output.float() * c_gate_msa).type_as(hidden_states) return hidden_states class HeliosTransformer3DModel( ModelMixin, ConfigMixin, PeftAdapterMixin, FromOriginalModelMixin, CacheMixin, AttentionMixin ): r""" A Transformer model for video-like data used in the Helios model. Args: patch_size (`Tuple[int]`, defaults to `(1, 2, 2)`): 3D patch dimensions for video embedding (t_patch, h_patch, w_patch). num_attention_heads (`int`, defaults to `40`): Fixed length for text embeddings. attention_head_dim (`int`, defaults to `128`): The number of channels in each head. in_channels (`int`, defaults to `16`): The number of channels in the input. out_channels (`int`, defaults to `16`): The number of channels in the output. text_dim (`int`, defaults to `512`): Input dimension for text embeddings. freq_dim (`int`, defaults to `256`): Dimension for sinusoidal time embeddings. ffn_dim (`int`, defaults to `13824`): Intermediate dimension in feed-forward network. num_layers (`int`, defaults to `40`): The number of layers of transformer blocks to use. window_size (`Tuple[int]`, defaults to `(-1, -1)`): Window size for local attention (-1 indicates global attention). cross_attn_norm (`bool`, defaults to `True`): Enable cross-attention normalization. qk_norm (`bool`, defaults to `True`): Enable query/key normalization. eps (`float`, defaults to `1e-6`): Epsilon value for normalization layers. add_img_emb (`bool`, defaults to `False`): Whether to use img_emb. added_kv_proj_dim (`int`, *optional*, defaults to `None`): The number of channels to use for the added key and value projections. If `None`, no projection is used. """ _supports_gradient_checkpointing = True _skip_layerwise_casting_patterns = [ "patch_embedding", "patch_short", "patch_mid", "patch_long", "condition_embedder", "norm", ] _no_split_modules = ["HeliosTransformerBlock", "HeliosOutputNorm"] _keep_in_fp32_modules = [ "time_embedder", "scale_shift_table", "norm1", "norm2", "norm3", "history_key_scale", ] _keys_to_ignore_on_load_unexpected = ["norm_added_q"] _repeated_blocks = ["HeliosTransformerBlock"] _cp_plan = { # Input split at attn level and ffn level. "blocks.*.attn1": { "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False), "rotary_emb": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False), }, "blocks.*.attn2": { "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False), }, "blocks.*.ffn": { "hidden_states": ContextParallelInput(split_dim=1, expected_dims=3, split_output=False), }, # Output gather at attn level and ffn level. **{f"blocks.{i}.attn1": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)}, **{f"blocks.{i}.attn2": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)}, **{f"blocks.{i}.ffn": ContextParallelOutput(gather_dim=1, expected_dims=3) for i in range(40)}, } @register_to_config def __init__( self, patch_size: tuple[int, ...] = (1, 2, 2), num_attention_heads: int = 40, attention_head_dim: int = 128, in_channels: int = 16, out_channels: int = 16, text_dim: int = 4096, freq_dim: int = 256, ffn_dim: int = 13824, num_layers: int = 40, cross_attn_norm: bool = True, qk_norm: str | None = "rms_norm_across_heads", eps: float = 1e-6, image_dim: int | None = None, added_kv_proj_dim: int | None = None, rope_dim: tuple[int, ...] = (44, 42, 42), rope_theta: float = 10000.0, restrict_self_attn: bool = False, guidance_cross_attn: bool = False, is_train_restrict_lora: bool = False, restrict_lora: bool = False, restrict_lora_rank: int = 128, zero_history_timestep: bool = False, has_multi_term_memory_patch: bool = False, is_amplify_history: bool = False, history_scale_mode: str = "per_head", # [scalar, per_head] is_use_gan: bool = False, is_use_gan_hooks: bool = False, is_use_gan_final: bool = False, gan_cond_map_dim: int = 768, gan_hooks: List[int] = [5, 15, 25, 35], ) -> None: super().__init__() inner_dim = num_attention_heads * attention_head_dim out_channels = out_channels or in_channels # 1. Patch & position embedding self.rope = HeliosRotaryPosEmbed(rope_dim=rope_dim, theta=rope_theta) self.patch_embedding = nn.Conv3d(in_channels, inner_dim, kernel_size=patch_size, stride=patch_size) # 2. Condition embeddings self.condition_embedder = HeliosTimeTextEmbedding( dim=inner_dim, time_freq_dim=freq_dim, time_proj_dim=inner_dim * 6, text_embed_dim=text_dim, ) # 3. Transformer blocks self.blocks = nn.ModuleList( [ HeliosTransformerBlock( inner_dim, ffn_dim, num_attention_heads, qk_norm, cross_attn_norm, eps, added_kv_proj_dim, restrict_self_attn=restrict_self_attn, guidance_cross_attn=guidance_cross_attn, is_train_restrict_lora=is_train_restrict_lora, restrict_lora=restrict_lora, restrict_lora_rank=restrict_lora_rank, is_amplify_history=is_amplify_history, history_scale_mode=history_scale_mode, ) for _ in range(num_layers) ] ) self.short_attn_debug_config = None self.short_attn_debug_state = {} self._refresh_short_attn_debug_hooks() # 4. Output norm & projection self.norm_out = HeliosOutputNorm(inner_dim, eps, elementwise_affine=False) self.proj_out = nn.Linear(inner_dim, out_channels * math.prod(patch_size)) self.init_weights() # 5. Initial Stage1 self.zero_history_timestep = zero_history_timestep self.inner_dim = inner_dim if has_multi_term_memory_patch: self.patch_short = nn.Conv3d(in_channels, self.inner_dim, kernel_size=(1, 2, 2), stride=(1, 2, 2)) self.patch_mid = nn.Conv3d(in_channels, self.inner_dim, kernel_size=(2, 4, 4), stride=(2, 4, 4)) self.patch_long = nn.Conv3d(in_channels, self.inner_dim, kernel_size=(4, 8, 8), stride=(4, 8, 8)) self.initialize_weight_from_another_conv3d(self.patch_embedding) # 6. Initial Gan self.is_use_gan = is_use_gan if is_use_gan: self.is_use_gan_hooks = is_use_gan_hooks self.is_use_gan_final = is_use_gan_final if is_use_gan_hooks: gan_heads = [] self.gan_hooks = gan_hooks for hook in self.gan_hooks: gan_heads.append((str(hook), Discriminator3DHead(inner_dim, gan_cond_map_dim))) self.gan_heads = nn.ModuleDict(gan_heads) if is_use_gan_final: self.gan_final_head = Discriminator3DHead(out_channels, gan_cond_map_dim) self.gradient_checkpointing = False def _refresh_short_attn_debug_hooks(self): for block_idx, block in enumerate(self.blocks): block.attn1._helios_block_idx = block_idx block.attn1._short_attn_debug_config = self.short_attn_debug_config block.attn1._short_attn_debug_state = self.short_attn_debug_state block.attn2._short_attn_debug_config = None block.attn2._short_attn_debug_state = None def configure_short_attn_debug(self, config: Dict[str, Any] | None = None): self.short_attn_debug_config = dict(config) if config else None if self.short_attn_debug_config is not None: self.short_attn_debug_config.setdefault("enabled", True) self.short_attn_debug_config.setdefault("blocks", [30]) self.short_attn_debug_config.setdefault("steps", ["last"]) self.short_attn_debug_config.setdefault("current_frame", -1) self.short_attn_debug_config.setdefault("prev_short_frame", 1) self.short_attn_debug_config.setdefault("short_history_frames", 2) self.short_attn_debug_config.setdefault("pass_names", ["cond"]) self.short_attn_debug_config.setdefault("topk", 2) self.short_attn_debug_config.setdefault("query_chunk_size", 128) self.short_attn_debug_state = {} self._refresh_short_attn_debug_hooks() def set_short_attn_debug_context(self, **state): if self.short_attn_debug_config is None: return self.short_attn_debug_state.clear() self.short_attn_debug_state.update(state) @torch.no_grad() def initialize_weight_from_another_conv3d(self, another_layer): weight = another_layer.weight.detach().clone() bias = another_layer.bias.detach().clone() weight = weight[:, :16, :, :, :] sd = { "patch_short.weight": weight.clone(), "patch_short.bias": bias.clone(), "patch_mid.weight": einops.repeat(weight, "b c t h w -> b c (t tk) (h hk) (w wk)", tk=2, hk=2, wk=2) / 8.0, "patch_mid.bias": bias.clone(), "patch_long.weight": einops.repeat(weight, "b c t h w -> b c (t tk) (h hk) (w wk)", tk=4, hk=4, wk=4) / 64.0, "patch_long.bias": bias.clone(), } sd = {k: v.clone() for k, v in sd.items()} self.load_state_dict(sd, strict=False) def gradient_checkpointing_method(self, block, *args): if torch.is_grad_enabled() and self.gradient_checkpointing: result = self._gradient_checkpointing_func(block, *args) else: result = block(*args) return result def enable_kv_cache(self): for block in self.blocks: if hasattr(block.attn1, "processor") and hasattr(block.attn1.processor, "enable_cache"): block.attn1.processor.enable_cache() def disable_kv_cache(self): for block in self.blocks: if hasattr(block.attn1, "processor") and hasattr(block.attn1.processor, "disable_cache"): block.attn1.processor.disable_cache() def clear_kv_cache(self): for block in self.blocks: if hasattr(block.attn1, "processor") and hasattr(block.attn1.processor, "clear_cache"): block.attn1.processor.clear_cache() def process_input_hidden_states( self, latents, indices_hidden_states=None, indices_latents_history_short=None, indices_latents_history_mid=None, indices_latents_history_long=None, latents_history_short=None, latents_history_mid=None, latents_history_long=None, ): height_list = [] width_list = [] temporal_list = [] seq_list = [] if isinstance(latents, list): hidden_states = None rope_freqs = None for idx, cur_hidden_states in enumerate(latents): cur_hidden_states = self.gradient_checkpointing_method( self.patch_embedding, cur_hidden_states.to(self.device, dtype=self.dtype) ) B, C, T, H, W = cur_hidden_states.shape cur_hidden_states = cur_hidden_states.flatten(2).transpose(1, 2) if indices_hidden_states is None: indices_hidden_states = torch.arange(0, T).unsqueeze(0).expand(B, -1) cur_indices_latents = indices_hidden_states cur_rope_freqs = self.rope( frame_indices=cur_indices_latents, height=H, width=W, device=cur_hidden_states.device ) cur_rope_freqs = cur_rope_freqs.flatten(2).transpose(1, 2) height_list.append(H) width_list.append(W) temporal_list.append(T) seq_list.append(cur_hidden_states.shape[1]) if hidden_states is None: hidden_states = cur_hidden_states rope_freqs = cur_rope_freqs else: hidden_states = torch.cat([cur_hidden_states, hidden_states], dim=1) rope_freqs = torch.cat([cur_rope_freqs, rope_freqs], dim=1) else: hidden_states = self.gradient_checkpointing_method(self.patch_embedding, latents) B, C, T, H, W = hidden_states.shape if indices_hidden_states is None: indices_hidden_states = torch.arange(0, T).unsqueeze(0).expand(B, -1) hidden_states = hidden_states.flatten(2).transpose( 1, 2 ) # torch.Size([1, 3072, 9, 44, 34]) -> torch.Size([1, 13464, 3072]) rope_freqs = self.rope( frame_indices=indices_hidden_states, height=H, width=W, device=hidden_states.device, ) # torch.Size([1, 9]) -> torch.Size([1, 256, 9, 44, 34]) rope_freqs = rope_freqs.flatten(2).transpose(1, 2) # torch.Size([1, 13464, 256]) height_list.append(H) width_list.append(W) temporal_list.append(T) seq_list.append(hidden_states.shape[1]) # Process short history latents if latents_history_short is not None and indices_latents_history_short is not None: latents_history_short = latents_history_short.to(hidden_states) latents_history_short = self.gradient_checkpointing_method(self.patch_short, latents_history_short) _, _, _, H1, W1 = latents_history_short.shape latents_history_short = latents_history_short.flatten(2).transpose(1, 2) rope_freqs_history_short = self.rope( frame_indices=indices_latents_history_short, height=H1, width=W1, device=latents_history_short.device, ) rope_freqs_history_short = rope_freqs_history_short.flatten(2).transpose(1, 2) hidden_states = torch.cat([latents_history_short, hidden_states], dim=1) rope_freqs = torch.cat([rope_freqs_history_short, rope_freqs], dim=1) # Process mid history latents if latents_history_mid is not None and indices_latents_history_mid is not None: latents_history_mid = latents_history_mid.to(hidden_states) latents_history_mid = pad_for_3d_conv(latents_history_mid, (2, 4, 4)) latents_history_mid = self.gradient_checkpointing_method(self.patch_mid, latents_history_mid) latents_history_mid = latents_history_mid.flatten(2).transpose(1, 2) rope_freqs_history_mid = self.rope( frame_indices=indices_latents_history_mid, height=H1, width=W1, device=latents_history_mid.device, ) rope_freqs_history_mid = pad_for_3d_conv(rope_freqs_history_mid, (2, 2, 2)) rope_freqs_history_mid = center_down_sample_3d(rope_freqs_history_mid, (2, 2, 2)) rope_freqs_history_mid = rope_freqs_history_mid.flatten(2).transpose(1, 2) hidden_states = torch.cat([latents_history_mid, hidden_states], dim=1) rope_freqs = torch.cat([rope_freqs_history_mid, rope_freqs], dim=1) # Process long history latents if latents_history_long is not None and indices_latents_history_long is not None: latents_history_long = latents_history_long.to(hidden_states) latents_history_long = pad_for_3d_conv(latents_history_long, (4, 8, 8)) latents_history_long = self.gradient_checkpointing_method(self.patch_long, latents_history_long) latents_history_long = latents_history_long.flatten(2).transpose(1, 2) rope_freqs_history_long = self.rope( frame_indices=indices_latents_history_long, height=H1, width=W1, device=latents_history_long.device, ) rope_freqs_history_long = pad_for_3d_conv(rope_freqs_history_long, (4, 4, 4)) rope_freqs_history_long = center_down_sample_3d(rope_freqs_history_long, (4, 4, 4)) rope_freqs_history_long = rope_freqs_history_long.flatten(2).transpose(1, 2) hidden_states = torch.cat([latents_history_long, hidden_states], dim=1) rope_freqs = torch.cat([rope_freqs_history_long, rope_freqs], dim=1) return ( hidden_states, rope_freqs, height_list, width_list, temporal_list, seq_list, ) @apply_lora_scale("attention_kwargs") def forward( self, hidden_states: torch.Tensor, timestep: torch.LongTensor, encoder_hidden_states: torch.Tensor, # ------------ Stage 1 ------------ indices_hidden_states=None, indices_latents_history_short=None, indices_latents_history_mid=None, indices_latents_history_long=None, latents_history_short=None, latents_history_mid=None, latents_history_long=None, is_first_denoising_step: bool = False, # ------------ GAN ------------ gan_mode: bool = False, return_dict: bool = True, attention_kwargs: dict[str, Any] | None = None, ) -> Union[torch.Tensor, Dict[str, torch.Tensor]]: assert ( len( { x is None for x in [ indices_hidden_states, indices_latents_history_short, indices_latents_history_mid, indices_latents_history_long, latents_history_short, latents_history_mid, latents_history_long, ] } ) == 1 ), "All history latents and indices must either all exist or all be None" if indices_hidden_states is not None and indices_hidden_states.ndim == 1: indices_hidden_states = indices_hidden_states.unsqueeze(0) if indices_latents_history_short is not None and indices_latents_history_short.ndim == 1: indices_latents_history_short = indices_latents_history_short.unsqueeze(0) if indices_latents_history_mid is not None and indices_latents_history_mid.ndim == 1: indices_latents_history_mid = indices_latents_history_mid.unsqueeze(0) if indices_latents_history_long is not None and indices_latents_history_long.ndim == 1: indices_latents_history_long = indices_latents_history_long.unsqueeze(0) if gan_mode: assert self.is_use_gan if isinstance(hidden_states, list): assert gan_mode is False and self.is_use_gan is False enable_navit = True navit_len = len(hidden_states) batch_size = hidden_states[0].shape[0] else: enable_navit = False batch_size = hidden_states.shape[0] p_t, p_h, p_w = self.config.patch_size ( hidden_states, rotary_emb, post_patch_height_list, post_patch_width_list, post_patch_num_frames_list, original_context_length_list, ) = self.process_input_hidden_states( latents=hidden_states, indices_hidden_states=indices_hidden_states, indices_latents_history_short=indices_latents_history_short, indices_latents_history_mid=indices_latents_history_mid, indices_latents_history_long=indices_latents_history_long, latents_history_short=latents_history_short, latents_history_mid=latents_history_mid, latents_history_long=latents_history_long, ) # hidden: [high, mid, low] -> [low, mid, high] post_patch_num_frames = sum(post_patch_num_frames_list) post_patch_height = sum(post_patch_height_list) post_patch_width = sum(post_patch_width_list) original_context_length = sum(original_context_length_list) history_context_length = hidden_states.shape[1] - original_context_length if indices_hidden_states is not None and self.zero_history_timestep: if isinstance(timestep, list): timestep_t0 = torch.zeros((1), dtype=timestep[0].dtype, device=timestep[0].device) else: timestep_t0 = torch.zeros((1), dtype=timestep.dtype, device=timestep.device) temb_t0, timestep_proj_t0, _ = self.condition_embedder( timestep_t0, encoder_hidden_states, is_return_encoder_hidden_states=False ) temb_t0 = temb_t0.unsqueeze(1).expand(batch_size, history_context_length, -1) timestep_proj_t0 = ( timestep_proj_t0.unflatten(-1, (6, -1)) .view(1, 6, 1, -1) .expand(batch_size, -1, history_context_length, -1) ) navit_hidden_attention_mask = None navit_encoder_attention_mask = None if enable_navit: assert navit_len == len(original_context_length_list) navit_hidden_attention_mask, navit_encoder_attention_mask, navit_history_hidden_attention_mask = ( create_navit_attention_masks( batch_size=batch_size, original_context_length_list=original_context_length_list[::-1], history_context_length=history_context_length, encoder_hidden_states_seq_len=encoder_hidden_states.shape[1], device=hidden_states.device, restrict_self_attn=self.config.restrict_self_attn, guidance_cross_attn=self.config.guidance_cross_attn, ) ) navit_hidden_attention_mask = [navit_hidden_attention_mask, navit_history_hidden_attention_mask] history_hidden_states, hidden_states = ( hidden_states[:, :history_context_length], hidden_states[:, history_context_length:], ) history_rotary_emb, rotary_emb = ( rotary_emb[:, :history_context_length], rotary_emb[:, history_context_length:], ) timestep = timestep[::-1] hidden_states_list = [None] * navit_len rotary_emb_list = [None] * navit_len temb_list = [None] * navit_len timestep_proj_list = [None] * navit_len seq_start = 0 for idx, cur_seq_len in zip(range(navit_len), original_context_length_list[::-1]): cur_hidden_states = hidden_states[:, seq_start : seq_start + cur_seq_len, :] cur_rotary_emb = rotary_emb[:, seq_start : seq_start + cur_seq_len, :] hidden_states_list[idx] = torch.cat([history_hidden_states, cur_hidden_states], dim=1) rotary_emb_list[idx] = torch.cat([history_rotary_emb, cur_rotary_emb], dim=1) seq_start += cur_seq_len if idx == 0: cur_temb, cur_timestep_proj, encoder_hidden_states = self.condition_embedder( timestep[idx], encoder_hidden_states ) else: cur_temb, cur_timestep_proj, _ = self.condition_embedder( timestep[idx], encoder_hidden_states, is_return_encoder_hidden_states=False ) cur_temb = cur_temb.view(batch_size, 1, -1).expand(-1, cur_seq_len, -1) cur_timestep_proj = cur_timestep_proj.view(batch_size, 6, 1, -1).expand(-1, -1, cur_seq_len, -1) if self.zero_history_timestep: temb_list[idx] = torch.cat([temb_t0, cur_temb], dim=1) timestep_proj_list[idx] = torch.cat([timestep_proj_t0, cur_timestep_proj], dim=2) else: temb_list[idx] = cur_temb timestep_proj_list[idx] = cur_timestep_proj hidden_states = torch.cat(hidden_states_list, dim=1) rotary_emb = torch.cat(rotary_emb_list, dim=1) temb = torch.cat(temb_list, dim=1) timestep_proj = torch.cat(timestep_proj_list, dim=2) else: temb, timestep_proj, encoder_hidden_states = self.condition_embedder(timestep, encoder_hidden_states) timestep_proj = timestep_proj.unflatten(-1, (6, -1)) if indices_hidden_states is not None and not self.zero_history_timestep: main_repeat_size = hidden_states.shape[1] else: main_repeat_size = original_context_length temb = temb.view(batch_size, 1, -1).expand(batch_size, main_repeat_size, -1) timestep_proj = timestep_proj.view(batch_size, 6, 1, -1).expand(batch_size, 6, main_repeat_size, -1) if indices_hidden_states is not None and self.zero_history_timestep: temb = torch.cat([temb_t0, temb], dim=1) timestep_proj = torch.cat([timestep_proj_t0, timestep_proj], dim=2) if timestep_proj.ndim == 4: timestep_proj = timestep_proj.permute(0, 2, 1, 3) # 4. Transformer blocks logits_hidden = [] hidden_states = hidden_states.contiguous() encoder_hidden_states = encoder_hidden_states.contiguous() rotary_emb = rotary_emb.contiguous() if torch.is_grad_enabled() and self.gradient_checkpointing: for iidx, block in enumerate(self.blocks): hidden_states = self._gradient_checkpointing_func( block, hidden_states, encoder_hidden_states, timestep_proj, rotary_emb, navit_hidden_attention_mask, navit_encoder_attention_mask, original_context_length, original_context_length_list, is_first_denoising_step, ) if gan_mode and self.is_use_gan and self.is_use_gan_hooks and iidx in self.gan_hooks: logits_hidden.append(hidden_states[:, -original_context_length:, :]) else: for iidx, block in enumerate(self.blocks): hidden_states = block( hidden_states, encoder_hidden_states, timestep_proj, rotary_emb, navit_hidden_attention_mask, navit_encoder_attention_mask, original_context_length, original_context_length_list, is_first_denoising_step, ) if gan_mode and self.is_use_gan and self.is_use_gan_hooks and iidx in self.gan_hooks: logits_hidden.append(hidden_states[:, -original_context_length:, :]) # 5. Output norm, projection & unpatchify if temb.ndim == 3: if not enable_navit: temb = temb[:, -original_context_length:, :] shift, scale = (self.norm_out.scale_shift_table.unsqueeze(0).to(temb.device) + temb.unsqueeze(2)).chunk( 2, dim=2 ) shift = shift.squeeze(2) scale = scale.squeeze(2) else: # batch_size, inner_dim shift, scale = (self.norm_out.scale_shift_table.to(temb.device) + temb.unsqueeze(1)).chunk(2, dim=1) # Move the shift and scale tensors to the same device as hidden_states. # When using multi-GPU inference via accelerate these will be on the # first device rather than the last device, which hidden_states ends up # on. shift = shift.to(hidden_states.device) scale = scale.to(hidden_states.device) if enable_navit: hidden_states = (self.norm_out.norm(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states) output = [] seq_start = 0 for ( cur_original_context_length, cur_post_patch_num_frames, cur_post_patch_height, cur_post_patch_width, ) in zip( reversed(original_context_length_list), reversed(post_patch_num_frames_list), reversed(post_patch_height_list), reversed(post_patch_width_list), ): cur_hidden_states = hidden_states[ :, seq_start : seq_start + cur_original_context_length + history_context_length, : ] # (B, T*H*W, C) cur_hidden_states = cur_hidden_states[:, history_context_length:, :] cur_hidden_states = self.proj_out(cur_hidden_states) seq_start += cur_original_context_length + history_context_length cur_hidden_states = cur_hidden_states.reshape( batch_size, cur_post_patch_num_frames, cur_post_patch_height, cur_post_patch_width, p_t, p_h, p_w, -1, ) cur_hidden_states = cur_hidden_states.permute(0, 7, 1, 4, 2, 5, 3, 6) cur_hidden_states = cur_hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3) output.append(cur_hidden_states) output = output[::-1] else: hidden_states = hidden_states[:, -original_context_length:, :] hidden_states = (self.norm_out.norm(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states) hidden_states = self.proj_out(hidden_states) hidden_states = hidden_states.reshape( batch_size, post_patch_num_frames, post_patch_height, post_patch_width, p_t, p_h, p_w, -1 ) hidden_states = hidden_states.permute(0, 7, 1, 4, 2, 5, 3, 6) output = hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3) logits = [] if gan_mode and self.is_use_gan: if self.is_use_gan_final: logits.append(self.gradient_checkpointing_method(self.gan_final_head, output)) if self.is_use_gan_hooks: for idx, (_, gan_head) in enumerate(self.gan_heads.items()): activation = rearrange( logits_hidden[idx], "b (f h w) c -> b c f h w", f=post_patch_num_frames, h=post_patch_height, w=post_patch_width, ) logits.append(self.gradient_checkpointing_method(gan_head, activation.contiguous())) logits = torch.cat(logits, dim=1) if len(logits) > 1 else logits[0] logits_hidden = None del logits_hidden if not return_dict: return (output, logits) return Transformer2DModelOutput(sample=output, logits=logits) def init_weights(self): r""" Initialize model parameters using Xavier initialization. """ # basic init for m in self.modules(): if isinstance(m, nn.Linear): nn.init.xavier_uniform_(m.weight) if m.bias is not None: nn.init.zeros_(m.bias) # init embeddings nn.init.xavier_uniform_(self.patch_embedding.weight.flatten(1)) for m in self.condition_embedder.modules(): if isinstance(m, nn.Linear): nn.init.normal_(m.weight, std=0.02) # init output layer nn.init.zeros_(self.proj_out.weight) @classmethod def from_pretrained( cls, pretrained_model_path, subfolder=None, transformer_additional_kwargs={}, low_cpu_mem_usage=False, torch_dtype=torch.float32, device_map="cpu", max_workers=8, use_default_loader=False, ): if use_default_loader: return super().from_pretrained( pretrained_model_path, subfolder=subfolder, device_map=device_map, torch_dtype=torch_dtype ) import os from concurrent.futures import ThreadPoolExecutor, as_completed from huggingface_hub import snapshot_download from diffusers.utils import WEIGHTS_NAME if os.path.exists(pretrained_model_path): if subfolder is not None: pretrained_model_path = os.path.join(pretrained_model_path, subfolder) else: print(f"Downloading from Hugging Face Hub: {pretrained_model_path}") cache_dir = snapshot_download( repo_id=pretrained_model_path, # allow_patterns=["*.json", "*.safetensors", "*.bin"], ) pretrained_model_path = cache_dir if subfolder is not None: pretrained_model_path = os.path.join(cache_dir, subfolder) print(f"loaded 3D transformer's pretrained weights from {pretrained_model_path} ...") config_file = os.path.join(pretrained_model_path, "config.json") if not os.path.isfile(config_file): raise RuntimeError(f"{config_file} does not exist") with open(config_file, "r") as f: config = json.load(f) model_file = os.path.join(pretrained_model_path, WEIGHTS_NAME) model_file_safetensors = model_file.replace(".bin", ".safetensors") if "dict_mapping" in transformer_additional_kwargs.keys(): for key in transformer_additional_kwargs["dict_mapping"]: transformer_additional_kwargs[transformer_additional_kwargs["dict_mapping"][key]] = config[key] def remap_state_dict_keys(state_dict): """Remap old key names to new key names for compatibility.""" remapped = {} for key, value in state_dict.items(): new_key = key # Only remap top-level scale_shift_table, not blocks.*.scale_shift_table if key == "scale_shift_table": new_key = "norm_out.scale_shift_table" print(f"Remapping key: {key} -> {new_key}") remapped[new_key] = value return remapped if low_cpu_mem_usage: try: import re from diffusers import __version__ as diffusers_version from diffusers.models.model_loading_utils import load_model_dict_into_meta from diffusers.utils import is_accelerate_available if is_accelerate_available(): import accelerate # Instantiate model with empty weights with accelerate.init_empty_weights(): model = cls.from_config(config, **transformer_additional_kwargs) param_device = "cpu" if os.path.exists(model_file): state_dict = torch.load(model_file, map_location="cpu") elif os.path.exists(model_file_safetensors): from safetensors.torch import load_file state_dict = load_file(model_file_safetensors) else: from safetensors.torch import load_file model_files_safetensors = glob.glob(os.path.join(pretrained_model_path, "*.safetensors")) state_dict = {} print(f"Loading {len(model_files_safetensors)} safetensors files with {max_workers} workers...") with ThreadPoolExecutor(max_workers=max_workers) as executor: future_to_file = {executor.submit(load_file, f): f for f in model_files_safetensors} for future in as_completed(future_to_file): _state_dict = future.result() state_dict.update(_state_dict) # Remap keys before loading into meta model state_dict = remap_state_dict_keys(state_dict) if diffusers_version >= "0.33.0": # Diffusers has refactored `load_model_dict_into_meta` since version 0.33.0 in this commit: # https://github.com/huggingface/diffusers/commit/f5929e03060d56063ff34b25a8308833bec7c785. load_model_dict_into_meta( model, state_dict, dtype=torch_dtype, model_name_or_path=pretrained_model_path, keep_in_fp32_modules=cls._keep_in_fp32_modules, ) else: model._convert_deprecated_attention_blocks(state_dict) # move the params from meta device to cpu missing_keys = set(model.state_dict().keys()) - set(state_dict.keys()) if len(missing_keys) > 0: raise ValueError( f"Cannot load {cls} from {pretrained_model_path} because the following keys are" f" missing: \n {', '.join(missing_keys)}. \n Please make sure to pass" " `low_cpu_mem_usage=False` and `device_map=None` if you want to randomly initialize" " those weights or else make sure your checkpoint file is correct." ) unexpected_keys = load_model_dict_into_meta( model, state_dict, device=param_device, dtype=torch_dtype, model_name_or_path=pretrained_model_path, ) if cls._keys_to_ignore_on_load_unexpected is not None: for pat in cls._keys_to_ignore_on_load_unexpected: unexpected_keys = [k for k in unexpected_keys if re.search(pat, k) is None] if len(unexpected_keys) > 0: print( f"Some weights of the model checkpoint were not used when initializing {cls.__name__}: \n {[', '.join(unexpected_keys)]}" ) return model except Exception as e: print(f"The low_cpu_mem_usage mode is not work because {e}. Use low_cpu_mem_usage=False instead.") model = cls.from_config(config, **transformer_additional_kwargs) if os.path.exists(model_file): state_dict = torch.load(model_file, map_location="cpu") elif os.path.exists(model_file_safetensors): from safetensors.torch import load_file state_dict = load_file(model_file_safetensors) else: from safetensors.torch import load_file model_files_safetensors = glob.glob(os.path.join(pretrained_model_path, "*.safetensors")) state_dict = {} print(f"Loading {len(model_files_safetensors)} safetensors files with {max_workers} workers...") with ThreadPoolExecutor(max_workers=max_workers) as executor: future_to_file = {executor.submit(load_file, f): f for f in model_files_safetensors} for future in as_completed(future_to_file): _state_dict = future.result() state_dict.update(_state_dict) # Remap keys before size check and loading state_dict = remap_state_dict_keys(state_dict) tmp_state_dict = {} for key in state_dict: if key in model.state_dict().keys() and model.state_dict()[key].size() == state_dict[key].size(): tmp_state_dict[key] = state_dict[key] else: print(key, "Size don't match, skip") state_dict = tmp_state_dict m, u = model.load_state_dict(state_dict, strict=False) print(f"### missing keys: {len(m)}; \n### unexpected keys: {len(u)};") print(m) for name, param in model.named_parameters(): should_keep_fp32 = any(pattern in name for pattern in cls._keep_in_fp32_modules) if should_keep_fp32: param.data = param.data.to(torch.float32) # print(f"Keeping parameter {name} in fp32") else: param.data = param.data.to(torch_dtype) model = model.to(device_map) params = [p.numel() if "." in n else 0 for n, p in model.named_parameters()] print(f"### All Parameters: {sum(params) / 1e6} M") params = [p.numel() if "attn1." in n else 0 for n, p in model.named_parameters()] print(f"### attn1 Parameters: {sum(params) / 1e6} M") params = [p.numel() if "attn2." in n else 0 for n, p in model.named_parameters()] print(f"### attn2 Parameters: {sum(params) / 1e6} M") return model if __name__ == "__main__": import os os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes" os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes" # export DIFFUSERS_ENABLE_HUB_KERNELS=yes # def compare_models(model1, model2): # for (name1, param1), (name2, param2) in zip(model1.named_parameters(), model2.named_parameters()): # if name1 != name2: # print(f"参数名不同: {name1} vs {name2}") # return False # if not torch.equal(param1, param2): # print(f"参数 {name1} 的值不同") # print(f"最大差异: {torch.max(torch.abs(param1 - param2))}") # return False # print("所有参数完全相同！") # return True # compare_models(transformer, transformer1) gan_mode = False is_use_gan_hooks = False transformer_additional_kwargs = { "has_multi_term_memory_patch": True, "zero_history_timestep": True, "guidance_cross_attn": True, "restrict_self_attn": False, "restrict_lora": False, "is_train_restrict_lora": False, "is_amplify_history": False, "history_scale_mode": "per_head", # [scalar, per_head] "is_use_gan": gan_mode, "is_use_gan_hooks": is_use_gan_hooks, "gan_hooks": [13, 21, 29], "gan_cond_map_dim": 768, # "gan_hooks": [10, 20, 30], # "gan_cond_map_dim": 512, } # transformer_additional_kwargs={} device = "cuda" weight_dtype = torch.bfloat16 transformer = HeliosTransformer3DModel.from_pretrained( "Wan-AI/Wan2.1-T2V-1.3B-Diffusers", subfolder="transformer", torch_dtype=torch.bfloat16, transformer_additional_kwargs=transformer_additional_kwargs, ) transformer.requires_grad_(False) transformer.eval() transformer = transformer.to(device, dtype=weight_dtype) # import sys # from argparse import Namespace # sys.path.append("../../") # from helios.utils.utils_helios_base import save_extra_components, load_extra_components # args = Namespace() # args.training_config = Namespace() # args.training_config.is_enable_stage1 = True # args.training_config.is_train_restrict_lora = True # save_extra_components(args, transformer, "./temp") # load_extra_components(args, transformer, "./temp/transformer_partial.pth") is_navit = False batch_size = 4 max_length = 512 if is_navit: noisy_model_input = [ torch.randn(batch_size, 16, 9, 12, 20), torch.randn(batch_size, 16, 9, 24, 40), torch.randn(batch_size, 16, 9, 48, 80), ] timesteps = [ torch.randint(0, 1000, (batch_size,)).to(device), torch.randint(0, 1000, (batch_size,)).to(device), torch.randint(0, 1000, (batch_size,)).to(device), ] else: noisy_model_input = torch.randn(batch_size, 16, 9, 48, 80).to(device, dtype=weight_dtype) timesteps = torch.randint(0, 1000, (batch_size,)).to(device) prompt_embeds = torch.randn(batch_size, max_length, 4096).to(device, dtype=weight_dtype) indices_hidden_states = torch.randint(0, 10, (batch_size, 9)).to(device) indices_latents_history_short = torch.randint(0, 3, (batch_size, 2)).to(device) indices_latents_history_mid = torch.randint(0, 3, (batch_size, 2)).to(device) indices_latents_history_long = torch.randint(0, 17, (batch_size, 16)).to(device) latents_history_short = torch.randn(batch_size, 16, 2, 48, 80).to(device, dtype=weight_dtype) latents_history_mid = torch.randn(batch_size, 16, 2, 48, 80).to(device, dtype=weight_dtype) latents_history_long = torch.randn(batch_size, 16, 16, 48, 80).to(device, dtype=weight_dtype) # 16 2 2: 2400 # 16 2 3: 3360 # 16 4 2: 2640 # 16 4 3: 3600 # 8 2 2: 2280 # 8 2 3: 3240 # noisy_model_input_1 = torch.randn(batch_size, 16, 9, 12, 20).to(device, dtype=weight_dtype) # timesteps_1 = torch.randint(0, 1000, (batch_size,)).to(device) # noisy_model_input = [noisy_model_input_1, noisy_model_input_1, noisy_model_input_1] # timesteps = [timesteps_1, timesteps_1, torch.randint(0, 1000, (batch_size,)).to(device)] model_pred = transformer( hidden_states=noisy_model_input, timestep=timesteps, encoder_hidden_states=prompt_embeds, indices_hidden_states=indices_hidden_states, indices_latents_history_short=indices_latents_history_short, indices_latents_history_mid=indices_latents_history_mid, indices_latents_history_long=indices_latents_history_long, latents_history_short=latents_history_short.to(weight_dtype), latents_history_mid=latents_history_mid.to(weight_dtype), latents_history_long=latents_history_long.to(weight_dtype), gan_mode=gan_mode, return_dict=False, )[0]