src/musubi_tuner/frame_pack/hunyuan_video_packed_inference.py

# Inference model for Hunyuan Video Packed
# We do not want to break the training accidentally, so we use a separate file for inference model.

# MagCache: modified from https://github.com/Zehong-Ma/MagCache/blob/main/MagCache4HunyuanVideo/magcache_sample_video.py

from types import SimpleNamespace
from typing import Optional
import einops
import numpy as np
import torch
from torch.nn import functional as F
from musubi_tuner.frame_pack.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked, get_cu_seqlens

import logging

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)


class HunyuanVideoTransformer3DModelPackedInference(HunyuanVideoTransformer3DModelPacked):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.enable_magcache = False

    def initialize_magcache(
        self,
        enable: bool = True,
        retention_ratio: float = 0.2,
        mag_ratios: Optional[list[float]] = None,
        magcache_thresh: float = 0.24,
        K: int = 6,
        calibration: bool = False,
    ):
        if mag_ratios is None:
            # Copy from original MagCache
            mag_ratios = np.array(
                [1.0]
                + [
                    1.06971,
                    1.29073,
                    1.11245,
                    1.09596,
                    1.05233,
                    1.01415,
                    1.05672,
                    1.00848,
                    1.03632,
                    1.02974,
                    1.00984,
                    1.03028,
                    1.00681,
                    1.06614,
                    1.05022,
                    1.02592,
                    1.01776,
                    1.02985,
                    1.00726,
                    1.03727,
                    1.01502,
                    1.00992,
                    1.03371,
                    0.9976,
                    1.02742,
                    1.0093,
                    1.01869,
                    1.00815,
                    1.01461,
                    1.01152,
                    1.03082,
                    1.0061,
                    1.02162,
                    1.01999,
                    0.99063,
                    1.01186,
                    1.0217,
                    0.99947,
                    1.01711,
                    0.9904,
                    1.00258,
                    1.00878,
                    0.97039,
                    0.97686,
                    0.94315,
                    0.97728,
                    0.91154,
                    0.86139,
                    0.76592,
                ]
            )
        self.enable_magcache = enable
        self.calibration = calibration
        self.retention_ratio = retention_ratio
        self.default_mag_ratios = mag_ratios
        self.magcache_thresh = magcache_thresh
        self.K = K
        self.reset_magcache()

    def reset_magcache(self, num_steps: int = 50):
        if not self.enable_magcache:
            return

        def nearest_interp(src_array, target_length):
            src_length = len(src_array)
            if target_length == 1:
                return np.array([src_array[-1]])

            scale = (src_length - 1) / (target_length - 1)
            mapped_indices = np.round(np.arange(target_length) * scale).astype(int)
            return np.array(src_array)[mapped_indices]

        if not self.calibration and num_steps != len(self.default_mag_ratios):
            logger.info(f"Interpolating mag_ratios from {len(self.default_mag_ratios)} to {num_steps} steps.")
            self.mag_ratios = nearest_interp(self.default_mag_ratios, num_steps)
        else:
            self.mag_ratios = self.default_mag_ratios

        self.cnt = 0
        self.num_steps = num_steps
        self.residual_cache = None
        self.accumulated_ratio = 1.0
        self.accumulated_steps = 0
        self.accumulated_err = 0
        self.norm_ratio = []
        self.norm_std = []
        self.cos_dis = []

    def get_calibration_data(self) -> tuple[list[float], list[float], list[float]]:
        if not self.enable_magcache or not self.calibration:
            raise ValueError("MagCache is not enabled or calibration is not set.")
        return self.norm_ratio, self.norm_std, self.cos_dis

    def forward(self, *args, **kwargs):
        # Forward pass for inference
        if self.enable_magcache:
            return self.magcache_forward(*args, **kwargs, calibration=self.calibration)
        else:
            return super().forward(*args, **kwargs)

    def magcache_forward(
        self,
        hidden_states,
        timestep,
        encoder_hidden_states,
        encoder_attention_mask,
        pooled_projections,
        guidance,
        latent_indices=None,
        clean_latents=None,
        clean_latent_indices=None,
        clean_latents_2x=None,
        clean_latent_2x_indices=None,
        clean_latents_4x=None,
        clean_latent_4x_indices=None,
        image_embeddings=None,
        attention_kwargs=None,
        return_dict=True,
        calibration=False,
    ):
        if attention_kwargs is None:
            attention_kwargs = {}

        # RoPE scaling: must be done before processing hidden states
        if self.rope_scaling_timestep_threshold is not None:
            if timestep >= self.rope_scaling_timestep_threshold:
                self.rope.h_w_scaling_factor = self.rope_scaling_factor
            else:
                self.rope.h_w_scaling_factor = 1.0

        batch_size, num_channels, num_frames, height, width = hidden_states.shape
        p, p_t = self.config_patch_size, self.config_patch_size_t
        post_patch_num_frames = num_frames // p_t
        post_patch_height = height // p
        post_patch_width = width // p
        original_context_length = post_patch_num_frames * post_patch_height * post_patch_width

        hidden_states, rope_freqs = self.process_input_hidden_states(
            hidden_states,
            latent_indices,
            clean_latents,
            clean_latent_indices,
            clean_latents_2x,
            clean_latent_2x_indices,
            clean_latents_4x,
            clean_latent_4x_indices,
        )
        del (
            latent_indices,
            clean_latents,
            clean_latent_indices,
            clean_latents_2x,
            clean_latent_2x_indices,
            clean_latents_4x,
            clean_latent_4x_indices,
        )  # free memory

        temb = self.gradient_checkpointing_method(self.time_text_embed, timestep, guidance, pooled_projections)
        encoder_hidden_states = self.gradient_checkpointing_method(
            self.context_embedder, encoder_hidden_states, timestep, encoder_attention_mask
        )

        if self.image_projection is not None:
            assert image_embeddings is not None, "You must use image embeddings!"
            extra_encoder_hidden_states = self.gradient_checkpointing_method(self.image_projection, image_embeddings)
            extra_attention_mask = torch.ones(
                (batch_size, extra_encoder_hidden_states.shape[1]),
                dtype=encoder_attention_mask.dtype,
                device=encoder_attention_mask.device,
            )

            # must cat before (not after) encoder_hidden_states, due to attn masking
            encoder_hidden_states = torch.cat([extra_encoder_hidden_states, encoder_hidden_states], dim=1)
            encoder_attention_mask = torch.cat([extra_attention_mask, encoder_attention_mask], dim=1)
            del extra_encoder_hidden_states, extra_attention_mask  # free memory

        with torch.no_grad():
            if batch_size == 1:
                # When batch size is 1, we do not need any masks or var-len funcs since cropping is mathematically same to what we want
                # If they are not same, then their impls are wrong. Ours are always the correct one.
                text_len = encoder_attention_mask.sum().item()
                encoder_hidden_states = encoder_hidden_states[:, :text_len]
                attention_mask = None, None, None, None, None
            else:
                img_seq_len = hidden_states.shape[1]
                txt_seq_len = encoder_hidden_states.shape[1]

                cu_seqlens_q, seq_len = get_cu_seqlens(encoder_attention_mask, img_seq_len)
                cu_seqlens_kv = cu_seqlens_q
                max_seqlen_q = img_seq_len + txt_seq_len
                max_seqlen_kv = max_seqlen_q

                attention_mask = cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len
                del cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len  # free memory
        del encoder_attention_mask  # free memory

        if self.enable_teacache:
            raise NotImplementedError("TEACache is not implemented for inference model.")

        skip_forward = False
        if (
            self.enable_magcache
            and not calibration
            and self.cnt >= max(int(self.retention_ratio * self.num_steps), 1)
            and self.cnt < self.num_steps - 1
        ):
            cur_mag_ratio = self.mag_ratios[self.cnt]
            self.accumulated_ratio = self.accumulated_ratio * cur_mag_ratio
            cur_skip_err = np.abs(1 - self.accumulated_ratio)
            self.accumulated_err += cur_skip_err
            self.accumulated_steps += 1
            if self.accumulated_err <= self.magcache_thresh and self.accumulated_steps <= self.K:
                skip_forward = True
            else:
                self.accumulated_ratio = 1.0
                self.accumulated_steps = 0
                self.accumulated_err = 0

        if skip_forward:
            # uncomment the following line to debug
            # print(
            #     f"Skipping forward pass at step {self.cnt}, accumulated ratio: {self.accumulated_ratio:.4f}, "
            #     f"accumulated error: {self.accumulated_err:.4f}, accumulated steps: {self.accumulated_steps}"
            # )
            hidden_states = hidden_states + self.residual_cache
        else:
            ori_hidden_states = hidden_states

            for block_id, block in enumerate(self.transformer_blocks):
                if self.blocks_to_swap:
                    self.offloader_double.wait_for_block(block_id)

                hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(
                    block, hidden_states, encoder_hidden_states, temb, attention_mask, rope_freqs
                )

                if self.blocks_to_swap:
                    self.offloader_double.submit_move_blocks_forward(self.transformer_blocks, block_id)

            for block_id, block in enumerate(self.single_transformer_blocks):
                if self.blocks_to_swap:
                    self.offloader_single.wait_for_block(block_id)

                hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(
                    block, hidden_states, encoder_hidden_states, temb, attention_mask, rope_freqs
                )

                if self.blocks_to_swap:
                    self.offloader_single.submit_move_blocks_forward(self.single_transformer_blocks, block_id)

            if self.enable_magcache:
                cur_residual = hidden_states - ori_hidden_states
                if calibration and self.cnt >= 1:
                    norm_ratio = ((cur_residual.norm(dim=-1) / self.residual_cache.norm(dim=-1)).mean()).item()
                    norm_std = (cur_residual.norm(dim=-1) / self.residual_cache.norm(dim=-1)).std().item()
                    cos_dis = (1 - F.cosine_similarity(cur_residual, self.residual_cache, dim=-1, eps=1e-8)).mean().item()
                    self.norm_ratio.append(round(norm_ratio, 5))
                    self.norm_std.append(round(norm_std, 5))
                    self.cos_dis.append(round(cos_dis, 5))
                    logger.info(f"time: {self.cnt}, norm_ratio: {norm_ratio}, norm_std: {norm_std}, cos_dis: {cos_dis}")
                self.residual_cache = cur_residual

            del ori_hidden_states  # free memory

        del attention_mask, rope_freqs  # free memory
        del encoder_hidden_states  # free memory

        hidden_states = self.gradient_checkpointing_method(self.norm_out, hidden_states, temb)

        hidden_states = hidden_states[:, -original_context_length:, :]

        if self.high_quality_fp32_output_for_inference:
            hidden_states = hidden_states.to(dtype=torch.float32)
            if self.proj_out.weight.dtype != torch.float32:
                self.proj_out.to(dtype=torch.float32)

        hidden_states = self.gradient_checkpointing_method(self.proj_out, hidden_states)

        hidden_states = einops.rearrange(
            hidden_states,
            "b (t h w) (c pt ph pw) -> b c (t pt) (h ph) (w pw)",
            t=post_patch_num_frames,
            h=post_patch_height,
            w=post_patch_width,
            pt=p_t,
            ph=p,
            pw=p,
        )

        if self.enable_magcache:
            self.cnt += 1
            if self.cnt >= self.num_steps:
                self.cnt = 0
                self.accumulated_ratio = 1.0
                self.accumulated_steps = 0
                self.accumulated_err = 0

        if return_dict:
            # return Transformer2DModelOutput(sample=hidden_states)
            return SimpleNamespace(sample=hidden_states)

        return (hidden_states,)