# Copyright (c) 2025 SandAI. 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 gc import json import math import os from collections import Counter from dataclasses import dataclass, field from queue import Queue from typing import Dict, Generator, List, Optional, Tuple, Union from types import MethodType import torch import torch.distributed as dist from tqdm import tqdm import inference.infra.distributed.parallel_state as mpu from inference.common import InferenceParams, event_path_timer, print_rank_0 from inference.infra.parallelism import pp_scheduler from .prompt_process import get_negative_special_token_keys, get_special_token_keys, pad_special_token @dataclass(frozen=True) class InferenceInput: caption_embs: torch.Tensor emb_masks: torch.Tensor y: torch.Tensor prefix_video: Union[torch.Tensor, None] latent_size: Tuple[int] t_schedule_config: Dict = field(default_factory=dict) num_steps: int = None vae_ckpt: str = None task_idx_list: List[int] = None report_chunk_num_list: List[int] = None chunk_num: int = None def _process_txt_embeddings( caption_embs: torch.Tensor, emb_masks: torch.Tensor, null_emb: torch.Tensor, infer_chunk_num: int, clean_chunk_num: int ) -> Tuple[torch.Tensor, torch.Tensor]: special_token_keys = get_special_token_keys() print_rank_0(f"special_token = {list(special_token_keys)}") # denoise chunk with caption_embs caption_embs = caption_embs.repeat(1, infer_chunk_num - clean_chunk_num, 1, 1) emb_masks = emb_masks.unsqueeze(1).repeat(1, infer_chunk_num - clean_chunk_num, 1) caption_embs, emb_masks = pad_special_token(special_token_keys, caption_embs, emb_masks) # clean chunk with null_emb caption_embs = torch.cat([null_emb.repeat(1, clean_chunk_num, 1, 1), caption_embs], dim=1) emb_masks = torch.cat( [torch.zeros(1, clean_chunk_num, emb_masks.size(2), dtype=emb_masks.dtype, device=emb_masks.device), emb_masks], dim=1 ) return caption_embs, emb_masks def _process_null_embeddings( null_caption_embedding: torch.Tensor, null_emb_masks: torch.Tensor, infer_chunk_num: int ) -> Tuple[torch.Tensor, torch.Tensor]: null_embs = null_caption_embedding.repeat(1, infer_chunk_num, 1, 1) negative_special_token_keys = get_negative_special_token_keys() if negative_special_token_keys: null_embs, _ = pad_special_token(negative_special_token_keys, null_embs, None) null_token_length = 50 null_emb_masks[:, :, :null_token_length] = 1 null_emb_masks[:, :, null_token_length:] = 0 return null_embs, null_emb_masks @torch.inference_mode() def extract_feature_for_inference( model: torch.nn.Module, prefix_video: torch.Tensor, caption_embs: torch.Tensor, emb_masks: torch.Tensor ) -> InferenceInput: model_config = model.model_config runtime_config = model.runtime_config ### Prepare prefix video feature clean_chunk_num = 0 if prefix_video is not None: clean_chunk_num = prefix_video.size(2) // runtime_config.chunk_width infer_chunk_num = math.ceil( (runtime_config.num_frames // runtime_config.temporal_downsample_factor * 1.0 + prefix_video.size(2)) / runtime_config.chunk_width ) else: infer_chunk_num = math.ceil( (runtime_config.num_frames // runtime_config.temporal_downsample_factor * 1.0) / runtime_config.chunk_width ) ### Prepare text feature # [1, caption_max_length (800), hidden_size(4096)] null_caption_embedding = model.y_embedder.null_caption_embedding.unsqueeze(0) caption_embs, caption_emb_masks = _process_txt_embeddings( caption_embs, emb_masks, null_caption_embedding, infer_chunk_num, clean_chunk_num ) null_emb_masks = torch.zeros_like(caption_emb_masks) null_embs, null_emb_masks = _process_null_embeddings(null_caption_embedding, null_emb_masks, infer_chunk_num) if emb_masks.sum() == 0: emb_masks = torch.cat([null_emb_masks, null_emb_masks], dim=0) y = torch.cat([null_embs, null_embs]) else: emb_masks = torch.cat([caption_emb_masks, null_emb_masks], dim=0) y = torch.cat([caption_embs, null_embs]) ### Prepare latent feature dims in_channels = model_config.in_channels if model_config.half_channel_vae: in_channels = 16 latent_size_t = infer_chunk_num * runtime_config.chunk_width latent_size_h = runtime_config.video_size_h // 8 latent_size_w = runtime_config.video_size_w // 8 return InferenceInput( caption_embs=caption_embs, # [1, 4, 800, 4096] emb_masks=emb_masks, # [2, 4, 800] y=y, # [2, 4, 800, 4096] prefix_video=prefix_video, latent_size=(1, in_channels, latent_size_t, latent_size_h, latent_size_w), # NCTHW t_schedule_config={}, num_steps=runtime_config.num_steps, task_idx_list=[0], report_chunk_num_list=[infer_chunk_num - clean_chunk_num], chunk_num=latent_size_t // runtime_config.chunk_width, ) # Example1: when chunk_num=8, window_size=8 # clip_start: [0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7] # clip_end : [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8] # t_start : [0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7] # t_end : [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8, 8, 8, 8, 8] # Example2: when chunk_num=8, window_size=4 # clip_start: [0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7] # clip_end : [1, 2, 3, 4, 5, 6, 7, 8, 8, 8, 8] # t_start : [0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3] # t_end : [1, 2, 3, 4, 4, 4, 4, 4, 4, 4, 4] # Example3: when chunk_num=8, window_size=4, chunk_offset=2 # clip_start: [2, 2, 2, 2, 3, 4, 5, 6, 7] # clip_end : [3, 4, 5, 6, 7, 8, 8, 8, 8] # t_start : [0, 0, 0, 0, 0, 0, 1, 2, 3] # t_end : [1, 2, 3, 4, 4, 4, 4, 4, 4] # Example4: when chunk_num=8, window_size=1 # clip_start: [0, 1, 2, 3, 4, 5, 6, 7] # clip_end : [1, 2, 3, 4, 5, 6, 7, 8] # t_start : [0, 0, 0, 0, 0, 0, 0, 0] # t_end : [1, 1, 1, 1, 1, 1, 1, 1] def generate_sequences(chunk_num, window_size, chunk_offset): # Adjust range to include the offset start_index = chunk_offset end_index = chunk_num + window_size - 1 # Generate clip_start and clip_end clip_start = [max(chunk_offset, i - window_size + 1) for i in range(start_index, end_index)] clip_end = [min(chunk_num, i + 1) for i in range(start_index, end_index)] # Generate t_start and t_end t_start = [max(0, i - chunk_num + 1) for i in range(start_index, end_index)] t_end = [ min(window_size, i - chunk_offset + 1) if i - chunk_offset < window_size else window_size for i in range(start_index, end_index) ] return clip_start, clip_end, t_start, t_end def init_t(t_schedule_config: Union[Dict, None], num_steps: int, device: torch.device, shortcut_mode: str = ""): """Init Timestep and Transform t""" if num_steps == 12: base_t = torch.linspace(0, 1, 4 + 1, device=device) / 4 accu_num = torch.linspace(0, 1, 4 + 1, device=device) if shortcut_mode == "16,16,8": base_t = base_t[:3] else: base_t = torch.cat([base_t[:1], base_t[2:4]], dim=0) t = torch.cat([base_t + accu for accu in accu_num], dim=0)[: (num_steps + 1)] else: t = torch.linspace(0, 1, num_steps + 1, device=device) t_schedule_func = t_schedule_config.get("tSchedulerFunc", "sd3") if t_schedule_func == "sd3": def t_resolution_transform(x, shift=3.0): # sd3: with a **reverse** time-schedule (0: clean, 1: noise) # ours (0: noise, 1: clean) # https://github.com/Stability-AI/sd3-ref/blob/master/sd3_impls.py#L33 assert shift >= 1.0, "shift should >=1" shift_inv = 1.0 / shift return shift_inv * x / (1 + (shift_inv - 1) * x) t = t**2 shift = t_schedule_config.get("shift", 3.0) t = t_resolution_transform(t, shift) elif t_schedule_func == "square": t = t**2 elif t_schedule_func == "piecewise": def t_transform(x): mask = x < 0.875 x[mask] = x[mask] * (0.5 / 0.875) x[~mask] = 0.5 + (x[~mask] - 0.875) * (0.5 / (1 - 0.875)) return x t = t_transform(t) else: # identity pass return t def init_intervel(num_steps: int, device: torch.device, shortcut_mode: str = ""): """Init intervel""" base_intervel = torch.ones(num_steps, device=device) if num_steps % 3 == 0: repeat_times = num_steps // 3 if shortcut_mode == "16,16,8": base_intervel = torch.tensor([1, 1, 2] * repeat_times, device=device) else: base_intervel = torch.tensor([2, 1, 1] * repeat_times, device=device) return base_intervel @dataclass class WorkStatus: infer_idx: int cur_denoise_step: int class ResidualDiffTracker: def __init__(self, save_path: Optional[str]): self.save_path = save_path self.prev_residuals = {} self.prev_timesteps = {} self.records = [] @property def enabled(self) -> bool: return bool(self.save_path) def is_writer_rank(self) -> bool: return not dist.is_available() or not dist.is_initialized() or dist.get_rank() == 0 def update( self, infer_idx: int, cur_denoise_step: int, denoise_stage: int, denoise_idx: int, chunk_offset: int, chunk_start: int, x_chunk: torch.Tensor, velocity: torch.Tensor, timesteps: torch.Tensor, chunk_width: int, ) -> None: residual = (velocity[0:1] - x_chunk[0:1]).detach() self.update_residuals( infer_idx=infer_idx, cur_denoise_step=cur_denoise_step, denoise_stage=denoise_stage, denoise_idx=denoise_idx, chunk_offset=chunk_offset, chunk_start=chunk_start, residual=residual, timesteps=timesteps, chunk_width=chunk_width, ) def update_residuals( self, infer_idx: int, cur_denoise_step: int, denoise_stage: int, denoise_idx: int, chunk_offset: int, chunk_start: int, residual: torch.Tensor, timesteps: torch.Tensor, chunk_width: int, ) -> None: if not self.enabled or not self.is_writer_rank(): return residual = residual[0:1].detach() timesteps = timesteps.detach() assert residual.size(2) % chunk_width == 0 chunk_num = residual.size(2) // chunk_width assert timesteps.size(0) == chunk_num residual = residual.reshape(residual.size(0), residual.size(1), chunk_num, chunk_width, *residual.shape[3:]) for local_chunk_idx in range(chunk_num): chunk_idx = chunk_start + local_chunk_idx key = (infer_idx, chunk_idx) cur_residual = residual[:, :, local_chunk_idx].clone() cur_timestep = float(timesteps[local_chunk_idx].item()) if key in self.prev_residuals: prev_residual = self.prev_residuals[key] diff_norm = torch.linalg.vector_norm(cur_residual.float() - prev_residual.float()).item() residual_norm = torch.linalg.vector_norm(cur_residual.float()).item() self.records.append( { "infer_idx": infer_idx, "cur_denoise_step": cur_denoise_step, "denoise_stage": denoise_stage, "denoise_idx": denoise_idx, "chunk_idx": chunk_idx, "generated_chunk_idx": chunk_idx - chunk_offset, "prev_timestep": self.prev_timesteps[key], "timestep": cur_timestep, "residual_diff_norm": diff_norm, "residual_norm": residual_norm, } ) self.prev_residuals[key] = cur_residual self.prev_timesteps[key] = cur_timestep def save(self) -> None: if not self.enabled or not self.is_writer_rank(): return save_dir = os.path.dirname(self.save_path) if save_dir: os.makedirs(save_dir, exist_ok=True) payload = { "description": ( "Per-chunk norm of residual differences across denoise timesteps. " "For vanilla MAGI residual = velocity - x; for FlowCache residual = X_next - X_t." ), "records": self.records, } if self.save_path.endswith((".pt", ".pth")): torch.save(payload, self.save_path) else: with open(self.save_path, "w") as f: json.dump(payload, f, indent=2) print_rank_0(f"Saved residual diff stats to {self.save_path}") class L1RelChangeTracker: def __init__(self, save_path: Optional[str], eps: float = 1e-6): self.save_path = save_path self.eps = eps self.records = [] @property def enabled(self) -> bool: return bool(self.save_path) def is_writer_rank(self) -> bool: return not dist.is_available() or not dist.is_initialized() or dist.get_rank() == 0 def update( self, infer_idx: int, cur_denoise_step: int, denoise_stage: int, denoise_idx: int, chunk_offset: int, chunk_start: int, x_before: torch.Tensor, x_after: torch.Tensor, timesteps: torch.Tensor, next_timesteps: torch.Tensor, chunk_width: int, x_embedder_before: Optional[torch.Tensor] = None, x_embedder_after: Optional[torch.Tensor] = None, x_embedder_chunk_width: Optional[int] = None, ) -> None: if not self.enabled or not self.is_writer_rank(): return x_before = x_before[0:1].detach() x_after = x_after[0:1].detach() timesteps = timesteps.detach() next_timesteps = next_timesteps.detach() assert x_before.size(2) == x_after.size(2) assert x_before.size(2) % chunk_width == 0 chunk_num = x_before.size(2) // chunk_width assert timesteps.size(0) == chunk_num assert next_timesteps.size(0) == chunk_num x_before = x_before.reshape(x_before.size(0), x_before.size(1), chunk_num, chunk_width, *x_before.shape[3:]) x_after = x_after.reshape(x_after.size(0), x_after.size(1), chunk_num, chunk_width, *x_after.shape[3:]) x_embedder_before_by_chunk = None x_embedder_after_by_chunk = None if x_embedder_before is not None and x_embedder_after is not None and x_embedder_chunk_width is not None: x_embedder_before = x_embedder_before[0:1].detach() x_embedder_after = x_embedder_after[0:1].detach() assert x_embedder_before.size(2) == x_embedder_after.size(2) assert x_embedder_before.size(2) % x_embedder_chunk_width == 0 assert x_embedder_before.size(2) // x_embedder_chunk_width == chunk_num x_embedder_before_by_chunk = x_embedder_before.reshape( x_embedder_before.size(0), x_embedder_before.size(1), chunk_num, x_embedder_chunk_width, *x_embedder_before.shape[3:], ) x_embedder_after_by_chunk = x_embedder_after.reshape( x_embedder_after.size(0), x_embedder_after.size(1), chunk_num, x_embedder_chunk_width, *x_embedder_after.shape[3:], ) for local_chunk_idx in range(chunk_num): chunk_idx = chunk_start + local_chunk_idx cur_x = x_before[:, :, local_chunk_idx].float() next_x = x_after[:, :, local_chunk_idx].float() delta = next_x - cur_x denom = cur_x.abs().clamp_min(self.eps) l1_rel = (delta.abs() / denom).mean().item() delta_l1_norm = delta.abs().sum().item() x_l1_norm = cur_x.abs().sum().item() l1_rel_ratio = delta_l1_norm / max(x_l1_norm, self.eps) self.records.append( { "infer_idx": infer_idx, "cur_denoise_step": cur_denoise_step, "denoise_stage": denoise_stage, "denoise_idx": denoise_idx, "chunk_idx": chunk_idx, "generated_chunk_idx": chunk_idx - chunk_offset, "timestep": float(timesteps[local_chunk_idx].item()), "next_timestep": float(next_timesteps[local_chunk_idx].item()), "l1_rel": l1_rel, "l1_rel_ratio": l1_rel_ratio, "delta_l1_norm": delta_l1_norm, "x_l1_norm": x_l1_norm, } ) if x_embedder_before_by_chunk is not None and x_embedder_after_by_chunk is not None: cur_x_embedder = x_embedder_before_by_chunk[:, :, local_chunk_idx].float() next_x_embedder = x_embedder_after_by_chunk[:, :, local_chunk_idx].float() x_embedder_delta = next_x_embedder - cur_x_embedder x_embedder_denom = cur_x_embedder.abs().clamp_min(self.eps) x_embedder_l1_rel = (x_embedder_delta.abs() / x_embedder_denom).mean().item() x_embedder_delta_l1_norm = x_embedder_delta.abs().sum().item() x_embedder_l1_norm = cur_x_embedder.abs().sum().item() x_embedder_l1_rel_ratio = x_embedder_delta_l1_norm / max(x_embedder_l1_norm, self.eps) self.records[-1].update( { "x_embedder_l1_rel": x_embedder_l1_rel, "x_embedder_l1_rel_ratio": x_embedder_l1_rel_ratio, "x_embedder_delta_l1_norm": x_embedder_delta_l1_norm, "x_embedder_x_l1_norm": x_embedder_l1_norm, } ) def save(self) -> None: if not self.enabled or not self.is_writer_rank(): return save_dir = os.path.dirname(self.save_path) if save_dir: os.makedirs(save_dir, exist_ok=True) payload = { "description": ( "Per-chunk relative L1 change across MAGI denoise steps. MAGI timesteps increase from noise " "to clean, so next_timestep is the cleaner step. l1_rel = mean(abs((X_next - X_t) / " "(abs(X_t) + eps))). x_embedder_* fields apply the same computation after DiT x_embedder." ), "eps": self.eps, "records": self.records, } if self.save_path.endswith((".pt", ".pth")): torch.save(payload, self.save_path) else: with open(self.save_path, "w") as f: json.dump(payload, f, indent=2) print_rank_0(f"Saved L1 relative change stats to {self.save_path}") def find_dit_model(model): if hasattr(model, "y_embedder"): return model if hasattr(model, "module"): return find_dit_model(model.module) raise ValueError("Cannot find the real model") class SampleTransport: def __init__( self, model: torch.nn.Module, transport_inputs: List[InferenceInput], device: torch.device, residual_stats_path: Optional[str] = None, l1_rel_stats_path: Optional[str] = None, ): # ========= Input Tensor ========= self.model = model self.transport_inputs = transport_inputs self.device = device # ========= Init Global Members ========= self.model_config = model.model_config self.runtime_config = model.runtime_config self.engine_config = model.engine_config self.chunk_width = self.runtime_config.chunk_width self.window_size = self.runtime_config.window_size self.residual_diff_tracker = ResidualDiffTracker(residual_stats_path or os.getenv("MAGI_RESIDUAL_STATS_PATH")) self.l1_rel_change_tracker = L1RelChangeTracker(l1_rel_stats_path or os.getenv("MAGI_L1_REL_STATS_PATH")) # ========= Init Batched Inputs and Work Queue ========= self.work_queue = Queue() self.chunk_denoise_count: List[Counter] = [] self.ts: List[torch.Tensor] = [] self.time_interval: List[torch.Tensor] = [] self.xs: List[torch.Tensor] = [] self.x_chunks: List[torch.Tensor] = [] self.velocities: List[torch.Tensor] = [] self.time_record: List[tqdm] = [] self.inference_params: List[InferenceParams] = [] self.init_work_queue() def init_work_queue(self) -> None: shortcut_mode = self.engine_config.shortcut_mode if mpu.get_pp_world_size() > 1: if len(self.transport_inputs) == 1: print_rank_0("Warning: For better performance, please use multiple inputs for PP>1") else: assert len(self.transport_inputs) == 1, "Only support single input for PP=1" for idx, tran_input in enumerate(self.transport_inputs): self.work_queue.put(WorkStatus(infer_idx=idx, cur_denoise_step=0)) self.chunk_denoise_count.append(Counter()) self.ts.append( init_t(tran_input.t_schedule_config, tran_input.num_steps, self.device, shortcut_mode=shortcut_mode) ) self.time_interval.append(init_intervel(tran_input.num_steps, self.device, shortcut_mode=shortcut_mode)) self.x_chunks.append(None) self.velocities.append(None) if torch.distributed.get_rank() == 0: report_chunk_num = sum( dict( zip(self.transport_inputs[idx].task_idx_list, self.transport_inputs[idx].report_chunk_num_list) ).values() ) progress_bar = tqdm(total=report_chunk_num, desc=f"InferBatch {idx}") self.time_record.append(progress_bar) print_rank_0(f"transport_inputs len: {len(self.transport_inputs)}") x = torch.randn(*tran_input.latent_size, device=self.device) # NCTHW x = torch.cat([x, x], 0) # [2 * N, C, T, H, W] self.xs.append(x) max_sequence_length = ( x.shape[2] * (x.shape[3] // self.model_config.patch_size) * (x.shape[4] // self.model_config.patch_size) ) self.inference_params.append(InferenceParams(max_batch_size=1, max_sequence_length=max_sequence_length)) def append_dims(self, x, target_dims): """Appends dimensions to the end of a tensor until it has target_dims dimensions.""" dims_to_append = target_dims - x.ndim if dims_to_append < 0: raise ValueError(f"input has {x.ndim} dims but target_dims is {target_dims}, which is less") return x[(...,) + (None,) * dims_to_append] def embed_x_for_l1_rel_stats(self, x: torch.Tensor) -> Tuple[torch.Tensor, int]: dit_model = find_dit_model(self.model) x_embedder_chunk_width = self.chunk_width // dit_model.model_config.t_patch_size assert self.chunk_width % dit_model.model_config.t_patch_size == 0 x = x[0:1] * dit_model.model_config.x_rescale_factor if dit_model.model_config.half_channel_vae: assert x.shape[1] == 16 x = torch.cat([x, x], dim=1) x = x.float() with torch.no_grad(): x = dit_model.x_embedder(x) return x, x_embedder_chunk_width def get_timestep( self, t_total: torch.Tensor, denoise_step_per_stage: int, start: int, end: int, denoise_idx: int, has_clean_t: bool = False, ) -> torch.Tensor: """Const Method""" t_index = [] for i in range(start, end): t_index.append(i * denoise_step_per_stage + denoise_idx) t_index.reverse() # t_index is the timestep timestep = t_total[t_index] if has_clean_t: ones = torch.ones(1, device=self.device) * self.runtime_config.clean_t timestep = torch.cat([ones, timestep], 0) return timestep def get_denoise_step_of_each_chunk( self, infer_idx: int, denoise_step_per_stage: int, t_start: int, t_end: int, denoise_idx: int, has_clean_t: bool = False, ): denoise_step_of_each_chunk = [] for i in range(t_start, t_end): denoise_step_of_each_chunk.append(i * denoise_step_per_stage + denoise_idx) denoise_step_of_each_chunk.reverse() if has_clean_t: denoise_step_of_each_chunk = [self.transport_inputs[infer_idx].num_steps] + denoise_step_of_each_chunk return denoise_step_of_each_chunk def get_batch_size_and_chunk_token_nums(self, infer_idx: int): """Const Method""" batch_size = 1 # T H W chunk_token_nums = ( self.chunk_width * (self.transport_inputs[infer_idx].latent_size[3] // self.model_config.patch_size) * (self.transport_inputs[infer_idx].latent_size[4] // self.model_config.patch_size) ) return batch_size, chunk_token_nums def generate_kvrange_for_prefix_video(self, infer_idx: int, range_num: int): """Const Method""" batch_size, chunk_token_nums = self.get_batch_size_and_chunk_token_nums(infer_idx) if self.runtime_config.clean_chunk_kvrange != -1: prev_chunk_num = self.runtime_config.clean_chunk_kvrange elif len(self.runtime_config.noise2clean_kvrange) > 0: prev_chunk_num = self.runtime_config.noise2clean_kvrange[-1] else: prev_chunk_num = 8 k_chunk_end = torch.linspace(1, range_num, steps=range_num).reshape((range_num, 1)) k_chunk_start = torch.clamp(k_chunk_end - prev_chunk_num, min=0).reshape((range_num, 1)) k_chunk_range = torch.concat([k_chunk_start, k_chunk_end], dim=1) k_batch_range = ( torch.concat([k_chunk_range + i * range_num for i in range(batch_size)], dim=0).to(torch.int32).to(self.device) ) return k_batch_range * chunk_token_nums def extract_prefix_video_feature( self, infer_idx: int, prefix_video: torch.Tensor, y: torch.Tensor, chunk_offset: int, model_kwargs: dict ): """Non-Const Method""" print_rank_0(f"extract clean feature for prefix video, chunk_offset: {chunk_offset}") x_chunk = prefix_video[:, :, : chunk_offset * self.chunk_width] x_chunk = torch.cat([x_chunk, x_chunk], 0) # [2 * N, C, T, H, W] # clean feature without y embedding null_y_chunk = self.transport_inputs[infer_idx].y[1:2, :chunk_offset] null_y_chunk = torch.cat([null_y_chunk, null_y_chunk], 0) mask_chunk = self.transport_inputs[infer_idx].emb_masks[1:2, :chunk_offset] mask_chunk = torch.cat([mask_chunk, mask_chunk], 0) null_y_chunk_flatten = null_y_chunk.flatten(start_dim=0, end_dim=1).unsqueeze(1) mask_chunk_flatten = mask_chunk.flatten(start_dim=0, end_dim=1).unsqueeze(1) t = torch.ones(chunk_offset, device=self.device) * self.runtime_config.clean_t t = t.unsqueeze(0).repeat(x_chunk.size(0), 1) fwd_model_kwargs = model_kwargs.copy() fwd_model_kwargs.update( { "slice_point": 0, "range_num": chunk_offset, "denoising_range_num": chunk_offset, "fwd_extra_1st_chunk": False, "extract_prefix_video_feature": True, } ) # Adapt to chunkwise forward fwd_model_kwargs["start_chunk_id"] = 0 fwd_model_kwargs["end_chunk_id"] = chunk_offset fwd_model_kwargs["chunk_num"] = self.transport_inputs[infer_idx].chunk_num kv_range = self.generate_kvrange_for_prefix_video(infer_idx, chunk_offset) forward_fn = find_dit_model(self.model).forward_dispatcher fwd_model_kwargs["distill_interval"] = self.time_interval[infer_idx][0] forward_fn( x=x_chunk, timestep=t, y=null_y_chunk_flatten, mask=mask_chunk_flatten, kv_range=kv_range, inference_params=self.inference_params[infer_idx], **fwd_model_kwargs, ) # for kv cache def try_pad_prefix_video( self, infer_idx: int, x_chunk: torch.Tensor, t: torch.Tensor, prefix_video_start: int ) -> Tuple[torch.Tensor, torch.Tensor]: """Non-Const Method""" prefix_length = self.transport_inputs[infer_idx].prefix_video.size(2) if prefix_length <= prefix_video_start: return x_chunk, t padding_length = min(prefix_length - prefix_video_start, x_chunk.size(2)) prefix_video_end = prefix_video_start + padding_length ret = x_chunk.clone() ret[:, :, :padding_length] = self.transport_inputs[infer_idx].prefix_video[:, :, prefix_video_start:prefix_video_end] num_clean_t = (prefix_length - prefix_video_start) // self.chunk_width if num_clean_t > 0: t[:, :num_clean_t] = 1.0 return ret, t def generate_default_kvrange(self, infer_idx: int, slice_point: int, denoising_range_num: int) -> torch.Tensor: """Const Method""" batch_size, chunk_token_nums = self.get_batch_size_and_chunk_token_nums(infer_idx) range_num = slice_point + denoising_range_num k_chunk_end = torch.linspace(slice_point + 1, range_num, steps=denoising_range_num).reshape((denoising_range_num, 1)) k_chunk_start = torch.Tensor([0] * denoising_range_num).reshape((denoising_range_num, 1)) k_chunk_range = torch.concat([k_chunk_start, k_chunk_end], dim=1) k_batch_range = ( torch.concat([k_chunk_range + i * range_num for i in range(batch_size)], dim=0).to(torch.int32).to(self.device) ) return k_batch_range * chunk_token_nums def generate_noise2clean_kvrange( self, infer_idx: int, slice_point: int, denoising_range_num: int, noise2clean_kvrange: List[int], clean_chunk_kvrange: int, denoise_step_of_each_chunk: List[int], ) -> torch.Tensor: """Const Method""" assert len(denoise_step_of_each_chunk) == denoising_range_num assert len(noise2clean_kvrange) > 0 if clean_chunk_kvrange == -1: clean_chunk_kvrange = noise2clean_kvrange[-1] num_steps = self.transport_inputs[infer_idx].num_steps assert num_steps % len(noise2clean_kvrange) == 0 denoise_step_per_stage = num_steps // len(noise2clean_kvrange) denoise_kv_range = [] for cur_chunk_denoise_step in denoise_step_of_each_chunk: if cur_chunk_denoise_step == num_steps: denoise_kv_range.append(clean_chunk_kvrange) else: denoise_kv_range.append(noise2clean_kvrange[cur_chunk_denoise_step // denoise_step_per_stage]) range_num = slice_point + denoising_range_num batch_size, chunk_token_nums = self.get_batch_size_and_chunk_token_nums(infer_idx) k_ranges = [] for i in range(batch_size): k_batch_start = i * range_num for j in range(denoising_range_num): k_chunk_end = slice_point + j + 1 k_chunk_start = max(0, k_chunk_end - denoise_kv_range[j]) k_ranges.append( torch.Tensor( [(k_batch_start + k_chunk_start) * chunk_token_nums, (k_batch_start + k_chunk_end) * chunk_token_nums] ) .reshape(1, 2) .to(self.device) ) k_range = torch.concat(k_ranges, dim=0).to(torch.int32).to(self.device) return k_range def generate_kvrange_for_denoising_video( self, infer_idx: int, slice_point: int, denoising_range_num: int, denoise_step_of_each_chunk: List[int] ) -> torch.Tensor: """Const Method""" noise2clean_kvrange = self.runtime_config.noise2clean_kvrange clean_chunk_kvrange = self.runtime_config.clean_chunk_kvrange if len(noise2clean_kvrange) == 0: k_range = self.generate_default_kvrange(infer_idx, slice_point, denoising_range_num) else: k_range = self.generate_noise2clean_kvrange( infer_idx, slice_point, denoising_range_num, noise2clean_kvrange, clean_chunk_kvrange, denoise_step_of_each_chunk, ) return k_range def integrate( self, x_chunk: torch.Tensor, velocity: torch.Tensor, t_total: torch.Tensor, denoise_step_per_stage: int, t_start: int, t_end: int, i: int, delta_t_index: int = None, ) -> torch.Tensor: """Non-Const Method""" t_before = self.get_timestep(t_total, denoise_step_per_stage, t_start, t_end, i) t_after = self.get_timestep(t_total, denoise_step_per_stage, t_start, t_end, i + 1) delta_t = t_after - t_before N, C, T, H, W = x_chunk.shape x_chunk = x_chunk.reshape(N, C, -1, self.chunk_width, H, W) velocity = velocity.reshape(N, C, -1, self.chunk_width, H, W) if x_chunk.size(2) < delta_t.size(0) and delta_t_index is not None: delta_t = delta_t[delta_t_index:delta_t_index+1] assert x_chunk.size(2) == delta_t.size(0) x_chunk = x_chunk + velocity * delta_t.reshape(1, 1, -1, 1, 1, 1) x_chunk = x_chunk.reshape(N, C, T, H, W) return x_chunk def generate_denoise_status_and_sequences( self, infer_idx: int, cur_denoise_step: int ) -> Tuple[Tuple[int, int, int], Tuple[int, int, int, int, int]]: """Const Method""" chunk_offset = 0 if self.transport_inputs[infer_idx].prefix_video is not None: chunk_offset = self.transport_inputs[infer_idx].prefix_video.size(2) // self.chunk_width transport_input = self.transport_inputs[infer_idx] denoise_step_per_stage = transport_input.num_steps // self.window_size denoise_stage, denoise_idx = (cur_denoise_step // denoise_step_per_stage, cur_denoise_step % denoise_step_per_stage) chunk_start_s, chunk_end_s, t_start_s, t_end_s = generate_sequences( transport_input.chunk_num, self.window_size, chunk_offset ) chunk_start, chunk_end, t_start, t_end = ( chunk_start_s[denoise_stage], chunk_end_s[denoise_stage], t_start_s[denoise_stage], t_end_s[denoise_stage], ) return (denoise_step_per_stage, denoise_stage, denoise_idx), (chunk_offset, chunk_start, chunk_end, t_start, t_end) def total_forward_step(self, infer_idx: int) -> int: denoise_step_per_stage = self.transport_inputs[infer_idx].num_steps // self.window_size chunk_offset = 0 if self.transport_inputs[infer_idx].prefix_video is not None: chunk_offset = self.transport_inputs[infer_idx].prefix_video.size(2) // self.chunk_width total_forward_step = denoise_step_per_stage * ( self.transport_inputs[infer_idx].chunk_num + self.window_size - 1 - chunk_offset ) return total_forward_step def forward_velocity(self, infer_idx: int, cur_denoise_step: int) -> torch.Tensor: # 1. Get current work status x = self.xs[infer_idx] transport_input = self.transport_inputs[infer_idx] # 2. Extract prefix video KV cache (denoise_step_per_stage, denoise_stage, denoise_idx), ( chunk_offset, chunk_start, chunk_end, t_start, t_end, ) = self.generate_denoise_status_and_sequences(infer_idx, cur_denoise_step) model_kwargs = dict(chunk_width=self.chunk_width, fwd_extra_1st_chunk=False, num_steps=transport_input.num_steps) model_kwargs.update( {"denoise_step_per_stage": denoise_step_per_stage, "denoise_stage": denoise_stage, "denoise_idx": denoise_idx }) if chunk_offset > 0 and cur_denoise_step == 0: self.extract_prefix_video_feature( infer_idx, transport_input.prefix_video, transport_input.y, chunk_offset, model_kwargs ) # 3. Prepare inputs x_chunk = x[:, :, chunk_start * self.chunk_width : chunk_end * self.chunk_width].clone() y_chunk = transport_input.y[:, chunk_start:chunk_end] mask_chunk = transport_input.emb_masks[:, chunk_start:chunk_end] model_kwargs.update( {"slice_point": chunk_start, "range_num": chunk_end, "denoising_range_num": chunk_end - chunk_start} ) batch_size, chunk_token_nums = self.get_batch_size_and_chunk_token_nums(infer_idx) model_kwargs["chunk_token_nums"] = chunk_token_nums model_kwargs["start_chunk_id"] = chunk_start model_kwargs["end_chunk_id"] = chunk_end # 4. Forward clean chunk and get clean kv fwd_extra_1st_chunk = chunk_start > chunk_offset and denoise_idx == 0 if fwd_extra_1st_chunk: clean_x = x[:, :, (chunk_start - 1) * self.chunk_width : chunk_start * self.chunk_width].clone() x_chunk = torch.cat([clean_x, x_chunk], dim=2) # Clean feature without y embedding y_chunk = torch.cat([transport_input.y[1:2, 0:1].expand(y_chunk.size(0), -1, -1, -1), y_chunk], dim=1) mask_chunk = torch.cat([transport_input.emb_masks[1:2, 1:2].expand(mask_chunk.size(0), -1, -1), mask_chunk], dim=1) model_kwargs["slice_point"] = chunk_start - 1 model_kwargs["denoising_range_num"] = chunk_end - chunk_start + 1 model_kwargs["fwd_extra_1st_chunk"] = True # 5. Prepare inputs y_chunk_flatten = y_chunk.flatten(start_dim=0, end_dim=1).unsqueeze(1) mask_chunk_flatten = mask_chunk.flatten(start_dim=0, end_dim=1).unsqueeze(1) denoise_step_of_each_chunk = self.get_denoise_step_of_each_chunk( infer_idx, denoise_step_per_stage, t_start, t_end, denoise_idx, has_clean_t=fwd_extra_1st_chunk ) t = self.get_timestep( self.ts[infer_idx], denoise_step_per_stage, t_start, t_end, denoise_idx, has_clean_t=fwd_extra_1st_chunk ) t = t.unsqueeze(0).repeat(x_chunk.size(0), 1) kv_range = self.generate_kvrange_for_denoising_video( infer_idx=infer_idx, slice_point=model_kwargs["slice_point"], denoising_range_num=model_kwargs["denoising_range_num"], denoise_step_of_each_chunk=denoise_step_of_each_chunk, ) # 6. Padding prefix video if transport_input.prefix_video is not None: x_chunk, t = self.try_pad_prefix_video( infer_idx, x_chunk, t, prefix_video_start=model_kwargs["slice_point"] * self.chunk_width ) # 7. Model forward forward_fn = find_dit_model(self.model).forward_dispatcher nearly_clean_chunk_t = t[0, int(model_kwargs["fwd_extra_1st_chunk"])].item() model_kwargs["distill_nearly_clean_chunk"] = ( nearly_clean_chunk_t > self.engine_config.distill_nearly_clean_chunk_threshold ) model_kwargs["distill_interval"] = self.time_interval[infer_idx][denoise_idx] model_kwargs["total_num_steps"] = self.total_forward_step(infer_idx) if model_kwargs.get("distill_nearly_clean_chunk", False): model_kwargs["end_chunk_id"] += 1 model_kwargs["chunk_num"] = transport_input.chunk_num velocity = forward_fn( x=x_chunk, timestep=t, y=y_chunk_flatten, mask=mask_chunk_flatten, kv_range=kv_range, inference_params=self.inference_params[infer_idx], **model_kwargs, ) self.x_chunks[infer_idx] = x_chunk self.velocities[infer_idx] = velocity return velocity def integrate_velocity(self, infer_idx: int, cur_denoise_step: int): transport_input = self.transport_inputs[infer_idx] x_chunk = self.x_chunks[infer_idx] velocity = self.velocities[infer_idx] chunk_denoise_count = self.chunk_denoise_count[infer_idx] (denoise_step_per_stage, denoise_stage, denoise_idx), ( chunk_offset, chunk_start, chunk_end, t_start, t_end, ) = self.generate_denoise_status_and_sequences(infer_idx, cur_denoise_step) fwd_extra_1st_chunk = chunk_start > chunk_offset and denoise_idx == 0 # 8. Remove clean chunk if fwd_extra_1st_chunk: x_chunk = x_chunk[:, :, self.chunk_width :] velocity = velocity[:, :, self.chunk_width :] t = self.get_timestep( self.ts[infer_idx], denoise_step_per_stage, t_start, t_end, denoise_idx, has_clean_t=fwd_extra_1st_chunk ) if fwd_extra_1st_chunk: t = t[1:] self.residual_diff_tracker.update( infer_idx=infer_idx, cur_denoise_step=cur_denoise_step, denoise_stage=denoise_stage, denoise_idx=denoise_idx, chunk_offset=chunk_offset, chunk_start=chunk_start, x_chunk=x_chunk, velocity=velocity, timesteps=t, chunk_width=self.chunk_width, ) next_t = self.get_timestep( self.ts[infer_idx], denoise_step_per_stage, t_start, t_end, denoise_idx + 1, has_clean_t=fwd_extra_1st_chunk ) if fwd_extra_1st_chunk: next_t = next_t[1:] x_before_integrate = x_chunk x_embedder_before = None x_embedder_after = None x_embedder_chunk_width = None if self.l1_rel_change_tracker.enabled and self.l1_rel_change_tracker.is_writer_rank(): x_embedder_before, x_embedder_chunk_width = self.embed_x_for_l1_rel_stats(x_before_integrate) # 9. Walk and integrate x_chunk = self.integrate(x_chunk, velocity, self.ts[infer_idx], denoise_step_per_stage, t_start, t_end, denoise_idx) if self.l1_rel_change_tracker.enabled and self.l1_rel_change_tracker.is_writer_rank(): x_embedder_after, _ = self.embed_x_for_l1_rel_stats(x_chunk) self.l1_rel_change_tracker.update( infer_idx=infer_idx, cur_denoise_step=cur_denoise_step, denoise_stage=denoise_stage, denoise_idx=denoise_idx, chunk_offset=chunk_offset, chunk_start=chunk_start, x_before=x_before_integrate, x_after=x_chunk, timesteps=t, next_timesteps=next_t, chunk_width=self.chunk_width, x_embedder_before=x_embedder_before, x_embedder_after=x_embedder_after, x_embedder_chunk_width=x_embedder_chunk_width, ) # 10. chunk denoise count for chunk_index in range(chunk_start, chunk_end): chunk_denoise_count[chunk_index] += 1 self.xs[infer_idx][:, :, chunk_start * self.chunk_width : chunk_end * self.chunk_width] = x_chunk self.chunk_denoise_count[infer_idx] = chunk_denoise_count # 11. Return clean chunk if chunk_denoise_count[chunk_start] == transport_input.num_steps: if transport_input.prefix_video is not None: prefix_video_length = transport_input.prefix_video.size(2) if (chunk_start + 1) * self.chunk_width <= prefix_video_length: return None, None real_start = max(chunk_start * self.chunk_width, prefix_video_length) # Keep the first 4-frames only for I2V Job if chunk_start == 0 and prefix_video_length == 1: real_start = 0 clean_chunk, _ = self.xs[infer_idx][:, :, real_start : (chunk_start + 1) * self.chunk_width].chunk(2, dim=0) return clean_chunk, chunk_start - chunk_offset else: clean_chunk, _ = self.xs[infer_idx][ :, :, chunk_start * self.chunk_width : (chunk_start + 1) * self.chunk_width ].chunk(2, dim=0) return clean_chunk, chunk_start - chunk_offset return None, None def walk(self): event_path_timer().synced_record("begin_walk") infer_batch_size = len(self.transport_inputs) for infer_idx in range(infer_batch_size): velocity = self.forward_velocity(infer_idx, 0) if mpu.get_pp_world_size() > 1 and mpu.is_pipeline_first_stage(): pp_scheduler().queue_irecv_prev(velocity.shape, velocity.dtype) if mpu.get_pp_world_size() > 1 and mpu.is_pipeline_last_stage(): pp_scheduler().isend_next(velocity) while not self.work_queue.empty(): work_status: WorkStatus = self.work_queue.get() if mpu.get_pp_world_size() > 1 and mpu.is_pipeline_first_stage(): self.velocities[work_status.infer_idx] = pp_scheduler().queue_irecv_prev_data() clean_chunk, chunk_idx = self.integrate_velocity(work_status.infer_idx, work_status.cur_denoise_step) if clean_chunk is not None: if torch.distributed.get_rank() == 0: self.time_record[work_status.infer_idx].update(1) yield work_status.infer_idx, chunk_idx, clean_chunk if work_status.cur_denoise_step + 1 == self.total_forward_step(work_status.infer_idx): if torch.distributed.get_rank() == 0: self.time_record[work_status.infer_idx].close() continue self.work_queue.put(WorkStatus(infer_idx=work_status.infer_idx, cur_denoise_step=work_status.cur_denoise_step + 1)) velocity = self.forward_velocity(work_status.infer_idx, work_status.cur_denoise_step + 1) if mpu.get_pp_world_size() > 1 and mpu.is_pipeline_first_stage(): pp_scheduler().queue_irecv_prev(velocity.shape, velocity.dtype) if mpu.get_pp_world_size() > 1 and mpu.is_pipeline_last_stage(): pp_scheduler().isend_next(velocity) def generate_per_chunk( model: torch.nn.Module, prefix_video: torch.Tensor, caption_embs: torch.Tensor, emb_masks: torch.Tensor, residual_stats_path: Optional[str] = None, l1_rel_stats_path: Optional[str] = None, ) -> Generator[Tuple[int, int, int, int, int, torch.Tensor], None, None]: print_rank_0("Begin to generate per chunk") device = f"cuda:{torch.cuda.current_device()}" transport_inputs: InferenceInput = extract_feature_for_inference(model, prefix_video, caption_embs, emb_masks) sample_transport = SampleTransport( model=model, transport_inputs=[transport_inputs], device=device, residual_stats_path=residual_stats_path, l1_rel_stats_path=l1_rel_stats_path, ) for _, _, chunk in sample_transport.walk(): yield chunk sample_transport.residual_diff_tracker.save() sample_transport.l1_rel_change_tracker.save() cache_reuse_manager = getattr(SampleTransport, "cache_reuse_manager", None) if cache_reuse_manager is not None and hasattr(cache_reuse_manager, "save_metric_stats"): cache_reuse_manager.save_metric_stats() dist.barrier(device_ids=[torch.cuda.current_device()]) gc.collect() torch.cuda.empty_cache()