{"repo_name": "FramePack", "file_name": "/FramePack/diffusers_helper/k_diffusion/uni_pc_fm.py", "inference_info": {"prefix_code": "# Better Flow Matching UniPC by Lvmin Zhang\n# (c) 2025\n# CC BY-SA 4.0\n# Attribution-ShareAlike 4.0 International Licence\n\n\nimport torch\n\nfrom tqdm.auto import trange\n\n\ndef expand_dims(v, dims):\n    return v[(...,) + (None,) * (dims - 1)]\n\n\nclass FlowMatchUniPC:\n    def __init__(self, model, extra_args, variant='bh1'):\n        self.model = model\n        self.variant = variant\n        self.extra_args = extra_args\n\n    def model_fn(self, x, t):\n        return self.model(x, t, **self.extra_args)\n\n    def update_fn(self, x, model_prev_list, t_prev_list, t, order):\n        assert order <= len(model_prev_list)\n        dims = x.dim()\n\n        t_prev_0 = t_prev_list[-1]\n        lambda_prev_0 = - torch.log(t_prev_0)\n        lambda_t = - torch.log(t)\n        model_prev_0 = model_prev_list[-1]\n\n        h = lambda_t - lambda_prev_0\n\n        rks = []\n        D1s = []\n        for i in range(1, order):\n            t_prev_i = t_prev_list[-(i + 1)]\n            model_prev_i = model_prev_list[-(i + 1)]\n            lambda_prev_i = - torch.log(t_prev_i)\n            rk = ((lambda_prev_i - lambda_prev_0) / h)[0]\n            rks.append(rk)\n            D1s.append((model_prev_i - model_prev_0) / rk)\n\n        rks.append(1.)\n        rks = torch.tensor(rks, device=x.device)\n\n        R = []\n        b = []\n\n        hh = -h[0]\n        h_phi_1 = torch.expm1(hh)\n        h_phi_k = h_phi_1 / hh - 1\n\n        factorial_i = 1\n\n        if self.variant == 'bh1':\n            B_h = hh\n        elif self.variant == 'bh2':\n            B_h = torch.expm1(hh)\n        else:\n            raise NotImplementedError('Bad variant!')\n\n        for i in range(1, order + 1):\n            R.append(torch.pow(rks, i - 1))\n            b.append(h_phi_k * factorial_i / B_h)\n            factorial_i *= (i + 1)\n            h_phi_k = h_phi_k / hh - 1 / factorial_i\n\n        R = torch.stack(R)\n        b = torch.tensor(b, device=x.device)\n\n        use_predictor = len(D1s) > 0\n\n        if use_predictor:\n            D1s = torch.stack(D1s, dim=1)\n            if order == 2:\n                rhos_p = torch.tensor([0.5], device=b.device)\n            else:\n                rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1])\n        else:\n            D1s = None\n            rhos_p = None\n\n        if order == 1:\n            rhos_c = torch.tensor([0.5], device=b.device)\n        else:\n            rhos_c = torch.linalg.solve(R, b)\n\n        x_t_ = expand_dims(t / t_prev_0, dims) * x - expand_dims(h_phi_1, dims) * model_prev_0\n\n        if use_predictor:\n            pred_res = torch.tensordot(D1s, rhos_p, dims=([1], [0]))\n        else:\n            pred_res = 0\n\n        x_t = x_t_ - expand_dims(B_h, dims) * pred_res\n        model_t = self.model_fn(x_t, t)\n\n        if D1s is not None:\n            corr_res = torch.tensordot(D1s, rhos_c[:-1], dims=([1], [0]))\n        else:\n            corr_res = 0\n\n        D1_t = (model_t - model_prev_0)\n        x_t = x_t_ - expand_dims(B_h, dims) * (corr_res + rhos_c[-1] * D1_t)\n\n        return x_t, model_t\n\n    def sample(self, x, sigmas, callback=None, disable_pbar=False):\n        order = min(3, len(sigmas) - 2)\n        model_prev_list, t_prev_list = [], []\n        for i in trange(len(sigmas) - 1, disable=disable_pbar):\n            vec_t = sigmas[i].expand(x.shape[0])\n\n            ", "suffix_code": "\n\n            model_prev_list = model_prev_list[-order:]\n            t_prev_list = t_prev_list[-order:]\n\n            if callback is not None:\n                callback({'x': x, 'i': i, 'denoised': model_prev_list[-1]})\n\n        return model_prev_list[-1]\n\n\ndef sample_unipc(model, noise, sigmas, extra_args=None, callback=None, disable=False, variant='bh1'):\n    assert variant in ['bh1', 'bh2']\n    return FlowMatchUniPC(model, extra_args=extra_args, variant=variant).sample(noise, sigmas=sigmas, callback=callback, disable_pbar=disable)\n", "middle_code": "if i == 0:\n                model_prev_list = [self.model_fn(x, vec_t)]\n                t_prev_list = [vec_t]\n            elif i < order:\n                init_order = i\n                x, model_x = self.update_fn(x, model_prev_list, t_prev_list, vec_t, init_order)\n                model_prev_list.append(model_x)\n                t_prev_list.append(vec_t)\n            else:\n                x, model_x = self.update_fn(x, model_prev_list, t_prev_list, vec_t, order)\n                model_prev_list.append(model_x)\n                t_prev_list.append(vec_t)", "code_description": null, "fill_type": "BLOCK_TYPE", "language_type": "python", "sub_task_type": "if_statement"}, "context_code": [["/FramePack/diffusers_helper/models/hunyuan_video_packed.py", "from typing import Any, Dict, List, Optional, Tuple, Union\n\nimport torch\nimport einops\nimport torch.nn as nn\nimport numpy as np\n\nfrom diffusers.loaders import FromOriginalModelMixin\nfrom diffusers.configuration_utils import ConfigMixin, register_to_config\nfrom diffusers.loaders import PeftAdapterMixin\nfrom diffusers.utils import logging\nfrom diffusers.models.attention import FeedForward\nfrom diffusers.models.attention_processor import Attention\nfrom diffusers.models.embeddings import TimestepEmbedding, Timesteps, PixArtAlphaTextProjection\nfrom diffusers.models.modeling_outputs import Transformer2DModelOutput\nfrom diffusers.models.modeling_utils import ModelMixin\nfrom diffusers_helper.dit_common import LayerNorm\nfrom diffusers_helper.utils import zero_module\n\n\nenabled_backends = []\n\nif torch.backends.cuda.flash_sdp_enabled():\n    enabled_backends.append(\"flash\")\nif torch.backends.cuda.math_sdp_enabled():\n    enabled_backends.append(\"math\")\nif torch.backends.cuda.mem_efficient_sdp_enabled():\n    enabled_backends.append(\"mem_efficient\")\nif torch.backends.cuda.cudnn_sdp_enabled():\n    enabled_backends.append(\"cudnn\")\n\nprint(\"Currently enabled native sdp backends:\", enabled_backends)\n\ntry:\n    # raise NotImplementedError\n    from xformers.ops import memory_efficient_attention as xformers_attn_func\n    print('Xformers is installed!')\nexcept:\n    print('Xformers is not installed!')\n    xformers_attn_func = None\n\ntry:\n    # raise NotImplementedError\n    from flash_attn import flash_attn_varlen_func, flash_attn_func\n    print('Flash Attn is installed!')\nexcept:\n    print('Flash Attn is not installed!')\n    flash_attn_varlen_func = None\n    flash_attn_func = None\n\ntry:\n    # raise NotImplementedError\n    from sageattention import sageattn_varlen, sageattn\n    print('Sage Attn is installed!')\nexcept:\n    print('Sage Attn is not installed!')\n    sageattn_varlen = None\n    sageattn = None\n\n\nlogger = logging.get_logger(__name__)  # pylint: disable=invalid-name\n\n\ndef pad_for_3d_conv(x, kernel_size):\n    b, c, t, h, w = x.shape\n    pt, ph, pw = kernel_size\n    pad_t = (pt - (t % pt)) % pt\n    pad_h = (ph - (h % ph)) % ph\n    pad_w = (pw - (w % pw)) % pw\n    return torch.nn.functional.pad(x, (0, pad_w, 0, pad_h, 0, pad_t), mode='replicate')\n\n\ndef center_down_sample_3d(x, kernel_size):\n    # pt, ph, pw = kernel_size\n    # cp = (pt * ph * pw) // 2\n    # xp = einops.rearrange(x, 'b c (t pt) (h ph) (w pw) -> (pt ph pw) b c t h w', pt=pt, ph=ph, pw=pw)\n    # xc = xp[cp]\n    # return xc\n    return torch.nn.functional.avg_pool3d(x, kernel_size, stride=kernel_size)\n\n\ndef get_cu_seqlens(text_mask, img_len):\n    batch_size = text_mask.shape[0]\n    text_len = text_mask.sum(dim=1)\n    max_len = text_mask.shape[1] + img_len\n\n    cu_seqlens = torch.zeros([2 * batch_size + 1], dtype=torch.int32, device=\"cuda\")\n\n    for i in range(batch_size):\n        s = text_len[i] + img_len\n        s1 = i * max_len + s\n        s2 = (i + 1) * max_len\n        cu_seqlens[2 * i + 1] = s1\n        cu_seqlens[2 * i + 2] = s2\n\n    return cu_seqlens\n\n\ndef apply_rotary_emb_transposed(x, freqs_cis):\n    cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)\n    x_real, x_imag = x.unflatten(-1, (-1, 2)).unbind(-1)\n    x_rotated = torch.stack([-x_imag, x_real], dim=-1).flatten(3)\n    out = x.float() * cos + x_rotated.float() * sin\n    out = out.to(x)\n    return out\n\n\ndef attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv):\n    if cu_seqlens_q is None and cu_seqlens_kv is None and max_seqlen_q is None and max_seqlen_kv is None:\n        if sageattn is not None:\n            x = sageattn(q, k, v, tensor_layout='NHD')\n            return x\n\n        if flash_attn_func is not None:\n            x = flash_attn_func(q, k, v)\n            return x\n\n        if xformers_attn_func is not None:\n            x = xformers_attn_func(q, k, v)\n            return x\n\n        x = torch.nn.functional.scaled_dot_product_attention(q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)).transpose(1, 2)\n        return x\n\n    B, L, H, C = q.shape\n\n    q = q.flatten(0, 1)\n    k = k.flatten(0, 1)\n    v = v.flatten(0, 1)\n\n    if sageattn_varlen is not None:\n        x = sageattn_varlen(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)\n    elif flash_attn_varlen_func is not None:\n        x = flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)\n    else:\n        raise NotImplementedError('No Attn Installed!')\n\n    x = x.unflatten(0, (B, L))\n\n    return x\n\n\nclass HunyuanAttnProcessorFlashAttnDouble:\n    def __call__(self, attn, hidden_states, encoder_hidden_states, attention_mask, image_rotary_emb):\n        cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv = attention_mask\n\n        query = attn.to_q(hidden_states)\n        key = attn.to_k(hidden_states)\n        value = attn.to_v(hidden_states)\n\n        query = query.unflatten(2, (attn.heads, -1))\n        key = key.unflatten(2, (attn.heads, -1))\n        value = value.unflatten(2, (attn.heads, -1))\n\n        query = attn.norm_q(query)\n        key = attn.norm_k(key)\n\n        query = apply_rotary_emb_transposed(query, image_rotary_emb)\n        key = apply_rotary_emb_transposed(key, image_rotary_emb)\n\n        encoder_query = attn.add_q_proj(encoder_hidden_states)\n        encoder_key = attn.add_k_proj(encoder_hidden_states)\n        encoder_value = attn.add_v_proj(encoder_hidden_states)\n\n        encoder_query = encoder_query.unflatten(2, (attn.heads, -1))\n        encoder_key = encoder_key.unflatten(2, (attn.heads, -1))\n        encoder_value = encoder_value.unflatten(2, (attn.heads, -1))\n\n        encoder_query = attn.norm_added_q(encoder_query)\n        encoder_key = attn.norm_added_k(encoder_key)\n\n        query = torch.cat([query, encoder_query], dim=1)\n        key = torch.cat([key, encoder_key], dim=1)\n        value = torch.cat([value, encoder_value], dim=1)\n\n        hidden_states = attn_varlen_func(query, key, value, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)\n        hidden_states = hidden_states.flatten(-2)\n\n        txt_length = encoder_hidden_states.shape[1]\n        hidden_states, encoder_hidden_states = hidden_states[:, :-txt_length], hidden_states[:, -txt_length:]\n\n        hidden_states = attn.to_out[0](hidden_states)\n        hidden_states = attn.to_out[1](hidden_states)\n        encoder_hidden_states = attn.to_add_out(encoder_hidden_states)\n\n        return hidden_states, encoder_hidden_states\n\n\nclass HunyuanAttnProcessorFlashAttnSingle:\n    def __call__(self, attn, hidden_states, encoder_hidden_states, attention_mask, image_rotary_emb):\n        cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv = attention_mask\n\n        hidden_states = torch.cat([hidden_states, encoder_hidden_states], dim=1)\n\n        query = attn.to_q(hidden_states)\n        key = attn.to_k(hidden_states)\n        value = attn.to_v(hidden_states)\n\n        query = query.unflatten(2, (attn.heads, -1))\n        key = key.unflatten(2, (attn.heads, -1))\n        value = value.unflatten(2, (attn.heads, -1))\n\n        query = attn.norm_q(query)\n        key = attn.norm_k(key)\n\n        txt_length = encoder_hidden_states.shape[1]\n\n        query = torch.cat([apply_rotary_emb_transposed(query[:, :-txt_length], image_rotary_emb), query[:, -txt_length:]], dim=1)\n        key = torch.cat([apply_rotary_emb_transposed(key[:, :-txt_length], image_rotary_emb), key[:, -txt_length:]], dim=1)\n\n        hidden_states = attn_varlen_func(query, key, value, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)\n        hidden_states = hidden_states.flatten(-2)\n\n        hidden_states, encoder_hidden_states = hidden_states[:, :-txt_length], hidden_states[:, -txt_length:]\n\n        return hidden_states, encoder_hidden_states\n\n\nclass CombinedTimestepGuidanceTextProjEmbeddings(nn.Module):\n    def __init__(self, embedding_dim, pooled_projection_dim):\n        super().__init__()\n\n        self.time_proj = Timesteps(num_channels=256, flip_sin_to_cos=True, downscale_freq_shift=0)\n        self.timestep_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=embedding_dim)\n        self.guidance_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=embedding_dim)\n        self.text_embedder = PixArtAlphaTextProjection(pooled_projection_dim, embedding_dim, act_fn=\"silu\")\n\n    def forward(self, timestep, guidance, pooled_projection):\n        timesteps_proj = self.time_proj(timestep)\n        timesteps_emb = self.timestep_embedder(timesteps_proj.to(dtype=pooled_projection.dtype))\n\n        guidance_proj = self.time_proj(guidance)\n        guidance_emb = self.guidance_embedder(guidance_proj.to(dtype=pooled_projection.dtype))\n\n        time_guidance_emb = timesteps_emb + guidance_emb\n\n        pooled_projections = self.text_embedder(pooled_projection)\n        conditioning = time_guidance_emb + pooled_projections\n\n        return conditioning\n\n\nclass CombinedTimestepTextProjEmbeddings(nn.Module):\n    def __init__(self, embedding_dim, pooled_projection_dim):\n        super().__init__()\n\n        self.time_proj = Timesteps(num_channels=256, flip_sin_to_cos=True, downscale_freq_shift=0)\n        self.timestep_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=embedding_dim)\n        self.text_embedder = PixArtAlphaTextProjection(pooled_projection_dim, embedding_dim, act_fn=\"silu\")\n\n    def forward(self, timestep, pooled_projection):\n        timesteps_proj = self.time_proj(timestep)\n        timesteps_emb = self.timestep_embedder(timesteps_proj.to(dtype=pooled_projection.dtype))\n\n        pooled_projections = self.text_embedder(pooled_projection)\n\n        conditioning = timesteps_emb + pooled_projections\n\n        return conditioning\n\n\nclass HunyuanVideoAdaNorm(nn.Module):\n    def __init__(self, in_features: int, out_features: Optional[int] = None) -> None:\n        super().__init__()\n\n        out_features = out_features or 2 * in_features\n        self.linear = nn.Linear(in_features, out_features)\n        self.nonlinearity = nn.SiLU()\n\n    def forward(\n        self, temb: torch.Tensor\n    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\n        temb = self.linear(self.nonlinearity(temb))\n        gate_msa, gate_mlp = temb.chunk(2, dim=-1)\n        gate_msa, gate_mlp = gate_msa.unsqueeze(1), gate_mlp.unsqueeze(1)\n        return gate_msa, gate_mlp\n\n\nclass HunyuanVideoIndividualTokenRefinerBlock(nn.Module):\n    def __init__(\n        self,\n        num_attention_heads: int,\n        attention_head_dim: int,\n        mlp_width_ratio: str = 4.0,\n        mlp_drop_rate: float = 0.0,\n        attention_bias: bool = True,\n    ) -> None:\n        super().__init__()\n\n        hidden_size = num_attention_heads * attention_head_dim\n\n        self.norm1 = LayerNorm(hidden_size, elementwise_affine=True, eps=1e-6)\n        self.attn = Attention(\n            query_dim=hidden_size,\n            cross_attention_dim=None,\n            heads=num_attention_heads,\n            dim_head=attention_head_dim,\n            bias=attention_bias,\n        )\n\n        self.norm2 = LayerNorm(hidden_size, elementwise_affine=True, eps=1e-6)\n        self.ff = FeedForward(hidden_size, mult=mlp_width_ratio, activation_fn=\"linear-silu\", dropout=mlp_drop_rate)\n\n        self.norm_out = HunyuanVideoAdaNorm(hidden_size, 2 * hidden_size)\n\n    def forward(\n        self,\n        hidden_states: torch.Tensor,\n        temb: torch.Tensor,\n        attention_mask: Optional[torch.Tensor] = None,\n    ) -> torch.Tensor:\n        norm_hidden_states = self.norm1(hidden_states)\n\n        attn_output = self.attn(\n            hidden_states=norm_hidden_states,\n            encoder_hidden_states=None,\n            attention_mask=attention_mask,\n        )\n\n        gate_msa, gate_mlp = self.norm_out(temb)\n        hidden_states = hidden_states + attn_output * gate_msa\n\n        ff_output = self.ff(self.norm2(hidden_states))\n        hidden_states = hidden_states + ff_output * gate_mlp\n\n        return hidden_states\n\n\nclass HunyuanVideoIndividualTokenRefiner(nn.Module):\n    def __init__(\n        self,\n        num_attention_heads: int,\n        attention_head_dim: int,\n        num_layers: int,\n        mlp_width_ratio: float = 4.0,\n        mlp_drop_rate: float = 0.0,\n        attention_bias: bool = True,\n    ) -> None:\n        super().__init__()\n\n        self.refiner_blocks = nn.ModuleList(\n            [\n                HunyuanVideoIndividualTokenRefinerBlock(\n                    num_attention_heads=num_attention_heads,\n                    attention_head_dim=attention_head_dim,\n                    mlp_width_ratio=mlp_width_ratio,\n                    mlp_drop_rate=mlp_drop_rate,\n                    attention_bias=attention_bias,\n                )\n                for _ in range(num_layers)\n            ]\n        )\n\n    def forward(\n        self,\n        hidden_states: torch.Tensor,\n        temb: torch.Tensor,\n        attention_mask: Optional[torch.Tensor] = None,\n    ) -> None:\n        self_attn_mask = None\n        if attention_mask is not None:\n            batch_size = attention_mask.shape[0]\n            seq_len = attention_mask.shape[1]\n            attention_mask = attention_mask.to(hidden_states.device).bool()\n            self_attn_mask_1 = attention_mask.view(batch_size, 1, 1, seq_len).repeat(1, 1, seq_len, 1)\n            self_attn_mask_2 = self_attn_mask_1.transpose(2, 3)\n            self_attn_mask = (self_attn_mask_1 & self_attn_mask_2).bool()\n            self_attn_mask[:, :, :, 0] = True\n\n        for block in self.refiner_blocks:\n            hidden_states = block(hidden_states, temb, self_attn_mask)\n\n        return hidden_states\n\n\nclass HunyuanVideoTokenRefiner(nn.Module):\n    def __init__(\n        self,\n        in_channels: int,\n        num_attention_heads: int,\n        attention_head_dim: int,\n        num_layers: int,\n        mlp_ratio: float = 4.0,\n        mlp_drop_rate: float = 0.0,\n        attention_bias: bool = True,\n    ) -> None:\n        super().__init__()\n\n        hidden_size = num_attention_heads * attention_head_dim\n\n        self.time_text_embed = CombinedTimestepTextProjEmbeddings(\n            embedding_dim=hidden_size, pooled_projection_dim=in_channels\n        )\n        self.proj_in = nn.Linear(in_channels, hidden_size, bias=True)\n        self.token_refiner = HunyuanVideoIndividualTokenRefiner(\n            num_attention_heads=num_attention_heads,\n            attention_head_dim=attention_head_dim,\n            num_layers=num_layers,\n            mlp_width_ratio=mlp_ratio,\n            mlp_drop_rate=mlp_drop_rate,\n            attention_bias=attention_bias,\n        )\n\n    def forward(\n        self,\n        hidden_states: torch.Tensor,\n        timestep: torch.LongTensor,\n        attention_mask: Optional[torch.LongTensor] = None,\n    ) -> torch.Tensor:\n        if attention_mask is None:\n            pooled_projections = hidden_states.mean(dim=1)\n        else:\n            original_dtype = hidden_states.dtype\n            mask_float = attention_mask.float().unsqueeze(-1)\n            pooled_projections = (hidden_states * mask_float).sum(dim=1) / mask_float.sum(dim=1)\n            pooled_projections = pooled_projections.to(original_dtype)\n\n        temb = self.time_text_embed(timestep, pooled_projections)\n        hidden_states = self.proj_in(hidden_states)\n        hidden_states = self.token_refiner(hidden_states, temb, attention_mask)\n\n        return hidden_states\n\n\nclass HunyuanVideoRotaryPosEmbed(nn.Module):\n    def __init__(self, rope_dim, theta):\n        super().__init__()\n        self.DT, self.DY, self.DX = rope_dim\n        self.theta = theta\n\n    @torch.no_grad()\n    def get_frequency(self, dim, pos):\n        T, H, W = pos.shape\n        freqs = 1.0 / (self.theta ** (torch.arange(0, dim, 2, dtype=torch.float32, device=pos.device)[: (dim // 2)] / dim))\n        freqs = torch.outer(freqs, pos.reshape(-1)).unflatten(-1, (T, H, W)).repeat_interleave(2, dim=0)\n        return freqs.cos(), freqs.sin()\n\n    @torch.no_grad()\n    def forward_inner(self, frame_indices, height, width, device):\n        GT, GY, GX = torch.meshgrid(\n            frame_indices.to(device=device, dtype=torch.float32),\n            torch.arange(0, height, device=device, dtype=torch.float32),\n            torch.arange(0, width, device=device, dtype=torch.float32),\n            indexing=\"ij\"\n        )\n\n        FCT, FST = self.get_frequency(self.DT, GT)\n        FCY, FSY = self.get_frequency(self.DY, GY)\n        FCX, FSX = self.get_frequency(self.DX, GX)\n\n        result = torch.cat([FCT, FCY, FCX, FST, FSY, FSX], dim=0)\n\n        return result.to(device)\n\n    @torch.no_grad()\n    def forward(self, frame_indices, height, width, device):\n        frame_indices = frame_indices.unbind(0)\n        results = [self.forward_inner(f, height, width, device) for f in frame_indices]\n        results = torch.stack(results, dim=0)\n        return results\n\n\nclass AdaLayerNormZero(nn.Module):\n    def __init__(self, embedding_dim: int, norm_type=\"layer_norm\", bias=True):\n        super().__init__()\n        self.silu = nn.SiLU()\n        self.linear = nn.Linear(embedding_dim, 6 * embedding_dim, bias=bias)\n        if norm_type == \"layer_norm\":\n            self.norm = LayerNorm(embedding_dim, elementwise_affine=False, eps=1e-6)\n        else:\n            raise ValueError(f\"unknown norm_type {norm_type}\")\n\n    def forward(\n        self,\n        x: torch.Tensor,\n        emb: Optional[torch.Tensor] = None,\n    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\n        emb = emb.unsqueeze(-2)\n        emb = self.linear(self.silu(emb))\n        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = emb.chunk(6, dim=-1)\n        x = self.norm(x) * (1 + scale_msa) + shift_msa\n        return x, gate_msa, shift_mlp, scale_mlp, gate_mlp\n\n\nclass AdaLayerNormZeroSingle(nn.Module):\n    def __init__(self, embedding_dim: int, norm_type=\"layer_norm\", bias=True):\n        super().__init__()\n\n        self.silu = nn.SiLU()\n        self.linear = nn.Linear(embedding_dim, 3 * embedding_dim, bias=bias)\n        if norm_type == \"layer_norm\":\n            self.norm = LayerNorm(embedding_dim, elementwise_affine=False, eps=1e-6)\n        else:\n            raise ValueError(f\"unknown norm_type {norm_type}\")\n\n    def forward(\n        self,\n        x: torch.Tensor,\n        emb: Optional[torch.Tensor] = None,\n    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\n        emb = emb.unsqueeze(-2)\n        emb = self.linear(self.silu(emb))\n        shift_msa, scale_msa, gate_msa = emb.chunk(3, dim=-1)\n        x = self.norm(x) * (1 + scale_msa) + shift_msa\n        return x, gate_msa\n\n\nclass AdaLayerNormContinuous(nn.Module):\n    def __init__(\n        self,\n        embedding_dim: int,\n        conditioning_embedding_dim: int,\n        elementwise_affine=True,\n        eps=1e-5,\n        bias=True,\n        norm_type=\"layer_norm\",\n    ):\n        super().__init__()\n        self.silu = nn.SiLU()\n        self.linear = nn.Linear(conditioning_embedding_dim, embedding_dim * 2, bias=bias)\n        if norm_type == \"layer_norm\":\n            self.norm = LayerNorm(embedding_dim, eps, elementwise_affine, bias)\n        else:\n            raise ValueError(f\"unknown norm_type {norm_type}\")\n\n    def forward(self, x: torch.Tensor, emb: torch.Tensor) -> torch.Tensor:\n        emb = emb.unsqueeze(-2)\n        emb = self.linear(self.silu(emb))\n        scale, shift = emb.chunk(2, dim=-1)\n        x = self.norm(x) * (1 + scale) + shift\n        return x\n\n\nclass HunyuanVideoSingleTransformerBlock(nn.Module):\n    def __init__(\n        self,\n        num_attention_heads: int,\n        attention_head_dim: int,\n        mlp_ratio: float = 4.0,\n        qk_norm: str = \"rms_norm\",\n    ) -> None:\n        super().__init__()\n\n        hidden_size = num_attention_heads * attention_head_dim\n        mlp_dim = int(hidden_size * mlp_ratio)\n\n        self.attn = Attention(\n            query_dim=hidden_size,\n            cross_attention_dim=None,\n            dim_head=attention_head_dim,\n            heads=num_attention_heads,\n            out_dim=hidden_size,\n            bias=True,\n            processor=HunyuanAttnProcessorFlashAttnSingle(),\n            qk_norm=qk_norm,\n            eps=1e-6,\n            pre_only=True,\n        )\n\n        self.norm = AdaLayerNormZeroSingle(hidden_size, norm_type=\"layer_norm\")\n        self.proj_mlp = nn.Linear(hidden_size, mlp_dim)\n        self.act_mlp = nn.GELU(approximate=\"tanh\")\n        self.proj_out = nn.Linear(hidden_size + mlp_dim, hidden_size)\n\n    def forward(\n        self,\n        hidden_states: torch.Tensor,\n        encoder_hidden_states: torch.Tensor,\n        temb: torch.Tensor,\n        attention_mask: Optional[torch.Tensor] = None,\n        image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,\n    ) -> torch.Tensor:\n        text_seq_length = encoder_hidden_states.shape[1]\n        hidden_states = torch.cat([hidden_states, encoder_hidden_states], dim=1)\n\n        residual = hidden_states\n\n        # 1. Input normalization\n        norm_hidden_states, gate = self.norm(hidden_states, emb=temb)\n        mlp_hidden_states = self.act_mlp(self.proj_mlp(norm_hidden_states))\n\n        norm_hidden_states, norm_encoder_hidden_states = (\n            norm_hidden_states[:, :-text_seq_length, :],\n            norm_hidden_states[:, -text_seq_length:, :],\n        )\n\n        # 2. Attention\n        attn_output, context_attn_output = self.attn(\n            hidden_states=norm_hidden_states,\n            encoder_hidden_states=norm_encoder_hidden_states,\n            attention_mask=attention_mask,\n            image_rotary_emb=image_rotary_emb,\n        )\n        attn_output = torch.cat([attn_output, context_attn_output], dim=1)\n\n        # 3. Modulation and residual connection\n        hidden_states = torch.cat([attn_output, mlp_hidden_states], dim=2)\n        hidden_states = gate * self.proj_out(hidden_states)\n        hidden_states = hidden_states + residual\n\n        hidden_states, encoder_hidden_states = (\n            hidden_states[:, :-text_seq_length, :],\n            hidden_states[:, -text_seq_length:, :],\n        )\n        return hidden_states, encoder_hidden_states\n\n\nclass HunyuanVideoTransformerBlock(nn.Module):\n    def __init__(\n        self,\n        num_attention_heads: int,\n        attention_head_dim: int,\n        mlp_ratio: float,\n        qk_norm: str = \"rms_norm\",\n    ) -> None:\n        super().__init__()\n\n        hidden_size = num_attention_heads * attention_head_dim\n\n        self.norm1 = AdaLayerNormZero(hidden_size, norm_type=\"layer_norm\")\n        self.norm1_context = AdaLayerNormZero(hidden_size, norm_type=\"layer_norm\")\n\n        self.attn = Attention(\n            query_dim=hidden_size,\n            cross_attention_dim=None,\n            added_kv_proj_dim=hidden_size,\n            dim_head=attention_head_dim,\n            heads=num_attention_heads,\n            out_dim=hidden_size,\n            context_pre_only=False,\n            bias=True,\n            processor=HunyuanAttnProcessorFlashAttnDouble(),\n            qk_norm=qk_norm,\n            eps=1e-6,\n        )\n\n        self.norm2 = LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)\n        self.ff = FeedForward(hidden_size, mult=mlp_ratio, activation_fn=\"gelu-approximate\")\n\n        self.norm2_context = LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)\n        self.ff_context = FeedForward(hidden_size, mult=mlp_ratio, activation_fn=\"gelu-approximate\")\n\n    def forward(\n        self,\n        hidden_states: torch.Tensor,\n        encoder_hidden_states: torch.Tensor,\n        temb: torch.Tensor,\n        attention_mask: Optional[torch.Tensor] = None,\n        freqs_cis: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,\n    ) -> Tuple[torch.Tensor, torch.Tensor]:\n        # 1. Input normalization\n        norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1(hidden_states, emb=temb)\n        norm_encoder_hidden_states, c_gate_msa, c_shift_mlp, c_scale_mlp, c_gate_mlp = self.norm1_context(encoder_hidden_states, emb=temb)\n\n        # 2. Joint attention\n        attn_output, context_attn_output = self.attn(\n            hidden_states=norm_hidden_states,\n            encoder_hidden_states=norm_encoder_hidden_states,\n            attention_mask=attention_mask,\n            image_rotary_emb=freqs_cis,\n        )\n\n        # 3. Modulation and residual connection\n        hidden_states = hidden_states + attn_output * gate_msa\n        encoder_hidden_states = encoder_hidden_states + context_attn_output * c_gate_msa\n\n        norm_hidden_states = self.norm2(hidden_states)\n        norm_encoder_hidden_states = self.norm2_context(encoder_hidden_states)\n\n        norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp\n        norm_encoder_hidden_states = norm_encoder_hidden_states * (1 + c_scale_mlp) + c_shift_mlp\n\n        # 4. Feed-forward\n        ff_output = self.ff(norm_hidden_states)\n        context_ff_output = self.ff_context(norm_encoder_hidden_states)\n\n        hidden_states = hidden_states + gate_mlp * ff_output\n        encoder_hidden_states = encoder_hidden_states + c_gate_mlp * context_ff_output\n\n        return hidden_states, encoder_hidden_states\n\n\nclass ClipVisionProjection(nn.Module):\n    def __init__(self, in_channels, out_channels):\n        super().__init__()\n        self.up = nn.Linear(in_channels, out_channels * 3)\n        self.down = nn.Linear(out_channels * 3, out_channels)\n\n    def forward(self, x):\n        projected_x = self.down(nn.functional.silu(self.up(x)))\n        return projected_x\n\n\nclass HunyuanVideoPatchEmbed(nn.Module):\n    def __init__(self, patch_size, in_chans, embed_dim):\n        super().__init__()\n        self.proj = nn.Conv3d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)\n\n\nclass HunyuanVideoPatchEmbedForCleanLatents(nn.Module):\n    def __init__(self, inner_dim):\n        super().__init__()\n        self.proj = nn.Conv3d(16, inner_dim, kernel_size=(1, 2, 2), stride=(1, 2, 2))\n        self.proj_2x = nn.Conv3d(16, inner_dim, kernel_size=(2, 4, 4), stride=(2, 4, 4))\n        self.proj_4x = nn.Conv3d(16, inner_dim, kernel_size=(4, 8, 8), stride=(4, 8, 8))\n\n    @torch.no_grad()\n    def initialize_weight_from_another_conv3d(self, another_layer):\n        weight = another_layer.weight.detach().clone()\n        bias = another_layer.bias.detach().clone()\n\n        sd = {\n            'proj.weight': weight.clone(),\n            'proj.bias': bias.clone(),\n            'proj_2x.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,\n            'proj_2x.bias': bias.clone(),\n            'proj_4x.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,\n            'proj_4x.bias': bias.clone(),\n        }\n\n        sd = {k: v.clone() for k, v in sd.items()}\n\n        self.load_state_dict(sd)\n        return\n\n\nclass HunyuanVideoTransformer3DModelPacked(ModelMixin, ConfigMixin, PeftAdapterMixin, FromOriginalModelMixin):\n    @register_to_config\n    def __init__(\n        self,\n        in_channels: int = 16,\n        out_channels: int = 16,\n        num_attention_heads: int = 24,\n        attention_head_dim: int = 128,\n        num_layers: int = 20,\n        num_single_layers: int = 40,\n        num_refiner_layers: int = 2,\n        mlp_ratio: float = 4.0,\n        patch_size: int = 2,\n        patch_size_t: int = 1,\n        qk_norm: str = \"rms_norm\",\n        guidance_embeds: bool = True,\n        text_embed_dim: int = 4096,\n        pooled_projection_dim: int = 768,\n        rope_theta: float = 256.0,\n        rope_axes_dim: Tuple[int] = (16, 56, 56),\n        has_image_proj=False,\n        image_proj_dim=1152,\n        has_clean_x_embedder=False,\n    ) -> None:\n        super().__init__()\n\n        inner_dim = num_attention_heads * attention_head_dim\n        out_channels = out_channels or in_channels\n\n        # 1. Latent and condition embedders\n        self.x_embedder = HunyuanVideoPatchEmbed((patch_size_t, patch_size, patch_size), in_channels, inner_dim)\n        self.context_embedder = HunyuanVideoTokenRefiner(\n            text_embed_dim, num_attention_heads, attention_head_dim, num_layers=num_refiner_layers\n        )\n        self.time_text_embed = CombinedTimestepGuidanceTextProjEmbeddings(inner_dim, pooled_projection_dim)\n\n        self.clean_x_embedder = None\n        self.image_projection = None\n\n        # 2. RoPE\n        self.rope = HunyuanVideoRotaryPosEmbed(rope_axes_dim, rope_theta)\n\n        # 3. Dual stream transformer blocks\n        self.transformer_blocks = nn.ModuleList(\n            [\n                HunyuanVideoTransformerBlock(\n                    num_attention_heads, attention_head_dim, mlp_ratio=mlp_ratio, qk_norm=qk_norm\n                )\n                for _ in range(num_layers)\n            ]\n        )\n\n        # 4. Single stream transformer blocks\n        self.single_transformer_blocks = nn.ModuleList(\n            [\n                HunyuanVideoSingleTransformerBlock(\n                    num_attention_heads, attention_head_dim, mlp_ratio=mlp_ratio, qk_norm=qk_norm\n                )\n                for _ in range(num_single_layers)\n            ]\n        )\n\n        # 5. Output projection\n        self.norm_out = AdaLayerNormContinuous(inner_dim, inner_dim, elementwise_affine=False, eps=1e-6)\n        self.proj_out = nn.Linear(inner_dim, patch_size_t * patch_size * patch_size * out_channels)\n\n        self.inner_dim = inner_dim\n        self.use_gradient_checkpointing = False\n        self.enable_teacache = False\n\n        if has_image_proj:\n            self.install_image_projection(image_proj_dim)\n\n        if has_clean_x_embedder:\n            self.install_clean_x_embedder()\n\n        self.high_quality_fp32_output_for_inference = False\n\n    def install_image_projection(self, in_channels):\n        self.image_projection = ClipVisionProjection(in_channels=in_channels, out_channels=self.inner_dim)\n        self.config['has_image_proj'] = True\n        self.config['image_proj_dim'] = in_channels\n\n    def install_clean_x_embedder(self):\n        self.clean_x_embedder = HunyuanVideoPatchEmbedForCleanLatents(self.inner_dim)\n        self.config['has_clean_x_embedder'] = True\n\n    def enable_gradient_checkpointing(self):\n        self.use_gradient_checkpointing = True\n        print('self.use_gradient_checkpointing = True')\n\n    def disable_gradient_checkpointing(self):\n        self.use_gradient_checkpointing = False\n        print('self.use_gradient_checkpointing = False')\n\n    def initialize_teacache(self, enable_teacache=True, num_steps=25, rel_l1_thresh=0.15):\n        self.enable_teacache = enable_teacache\n        self.cnt = 0\n        self.num_steps = num_steps\n        self.rel_l1_thresh = rel_l1_thresh  # 0.1 for 1.6x speedup, 0.15 for 2.1x speedup\n        self.accumulated_rel_l1_distance = 0\n        self.previous_modulated_input = None\n        self.previous_residual = None\n        self.teacache_rescale_func = np.poly1d([7.33226126e+02, -4.01131952e+02, 6.75869174e+01, -3.14987800e+00, 9.61237896e-02])\n\n    def gradient_checkpointing_method(self, block, *args):\n        if self.use_gradient_checkpointing:\n            result = torch.utils.checkpoint.checkpoint(block, *args, use_reentrant=False)\n        else:\n            result = block(*args)\n        return result\n\n    def process_input_hidden_states(\n            self,\n            latents, latent_indices=None,\n            clean_latents=None, clean_latent_indices=None,\n            clean_latents_2x=None, clean_latent_2x_indices=None,\n            clean_latents_4x=None, clean_latent_4x_indices=None\n    ):\n        hidden_states = self.gradient_checkpointing_method(self.x_embedder.proj, latents)\n        B, C, T, H, W = hidden_states.shape\n\n        if latent_indices is None:\n            latent_indices = torch.arange(0, T).unsqueeze(0).expand(B, -1)\n\n        hidden_states = hidden_states.flatten(2).transpose(1, 2)\n\n        rope_freqs = self.rope(frame_indices=latent_indices, height=H, width=W, device=hidden_states.device)\n        rope_freqs = rope_freqs.flatten(2).transpose(1, 2)\n\n        if clean_latents is not None and clean_latent_indices is not None:\n            clean_latents = clean_latents.to(hidden_states)\n            clean_latents = self.gradient_checkpointing_method(self.clean_x_embedder.proj, clean_latents)\n            clean_latents = clean_latents.flatten(2).transpose(1, 2)\n\n            clean_latent_rope_freqs = self.rope(frame_indices=clean_latent_indices, height=H, width=W, device=clean_latents.device)\n            clean_latent_rope_freqs = clean_latent_rope_freqs.flatten(2).transpose(1, 2)\n\n            hidden_states = torch.cat([clean_latents, hidden_states], dim=1)\n            rope_freqs = torch.cat([clean_latent_rope_freqs, rope_freqs], dim=1)\n\n        if clean_latents_2x is not None and clean_latent_2x_indices is not None:\n            clean_latents_2x = clean_latents_2x.to(hidden_states)\n            clean_latents_2x = pad_for_3d_conv(clean_latents_2x, (2, 4, 4))\n            clean_latents_2x = self.gradient_checkpointing_method(self.clean_x_embedder.proj_2x, clean_latents_2x)\n            clean_latents_2x = clean_latents_2x.flatten(2).transpose(1, 2)\n\n            clean_latent_2x_rope_freqs = self.rope(frame_indices=clean_latent_2x_indices, height=H, width=W, device=clean_latents_2x.device)\n            clean_latent_2x_rope_freqs = pad_for_3d_conv(clean_latent_2x_rope_freqs, (2, 2, 2))\n            clean_latent_2x_rope_freqs = center_down_sample_3d(clean_latent_2x_rope_freqs, (2, 2, 2))\n            clean_latent_2x_rope_freqs = clean_latent_2x_rope_freqs.flatten(2).transpose(1, 2)\n\n            hidden_states = torch.cat([clean_latents_2x, hidden_states], dim=1)\n            rope_freqs = torch.cat([clean_latent_2x_rope_freqs, rope_freqs], dim=1)\n\n        if clean_latents_4x is not None and clean_latent_4x_indices is not None:\n            clean_latents_4x = clean_latents_4x.to(hidden_states)\n            clean_latents_4x = pad_for_3d_conv(clean_latents_4x, (4, 8, 8))\n            clean_latents_4x = self.gradient_checkpointing_method(self.clean_x_embedder.proj_4x, clean_latents_4x)\n            clean_latents_4x = clean_latents_4x.flatten(2).transpose(1, 2)\n\n            clean_latent_4x_rope_freqs = self.rope(frame_indices=clean_latent_4x_indices, height=H, width=W, device=clean_latents_4x.device)\n            clean_latent_4x_rope_freqs = pad_for_3d_conv(clean_latent_4x_rope_freqs, (4, 4, 4))\n            clean_latent_4x_rope_freqs = center_down_sample_3d(clean_latent_4x_rope_freqs, (4, 4, 4))\n            clean_latent_4x_rope_freqs = clean_latent_4x_rope_freqs.flatten(2).transpose(1, 2)\n\n            hidden_states = torch.cat([clean_latents_4x, hidden_states], dim=1)\n            rope_freqs = torch.cat([clean_latent_4x_rope_freqs, rope_freqs], dim=1)\n\n        return hidden_states, rope_freqs\n\n    def forward(\n            self,\n            hidden_states, timestep, encoder_hidden_states, encoder_attention_mask, pooled_projections, guidance,\n            latent_indices=None,\n            clean_latents=None, clean_latent_indices=None,\n            clean_latents_2x=None, clean_latent_2x_indices=None,\n            clean_latents_4x=None, clean_latent_4x_indices=None,\n            image_embeddings=None,\n            attention_kwargs=None, return_dict=True\n    ):\n\n        if attention_kwargs is None:\n            attention_kwargs = {}\n\n        batch_size, num_channels, num_frames, height, width = hidden_states.shape\n        p, p_t = self.config['patch_size'], self.config['patch_size_t']\n        post_patch_num_frames = num_frames // p_t\n        post_patch_height = height // p\n        post_patch_width = width // p\n        original_context_length = post_patch_num_frames * post_patch_height * post_patch_width\n\n        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)\n\n        temb = self.gradient_checkpointing_method(self.time_text_embed, timestep, guidance, pooled_projections)\n        encoder_hidden_states = self.gradient_checkpointing_method(self.context_embedder, encoder_hidden_states, timestep, encoder_attention_mask)\n\n        if self.image_projection is not None:\n            assert image_embeddings is not None, 'You must use image embeddings!'\n            extra_encoder_hidden_states = self.gradient_checkpointing_method(self.image_projection, image_embeddings)\n            extra_attention_mask = torch.ones((batch_size, extra_encoder_hidden_states.shape[1]), dtype=encoder_attention_mask.dtype, device=encoder_attention_mask.device)\n\n            # must cat before (not after) encoder_hidden_states, due to attn masking\n            encoder_hidden_states = torch.cat([extra_encoder_hidden_states, encoder_hidden_states], dim=1)\n            encoder_attention_mask = torch.cat([extra_attention_mask, encoder_attention_mask], dim=1)\n\n        if batch_size == 1:\n            # When batch size is 1, we do not need any masks or var-len funcs since cropping is mathematically same to what we want\n            # If they are not same, then their impls are wrong. Ours are always the correct one.\n            text_len = encoder_attention_mask.sum().item()\n            encoder_hidden_states = encoder_hidden_states[:, :text_len]\n            attention_mask = None, None, None, None\n        else:\n            img_seq_len = hidden_states.shape[1]\n            txt_seq_len = encoder_hidden_states.shape[1]\n\n            cu_seqlens_q = get_cu_seqlens(encoder_attention_mask, img_seq_len)\n            cu_seqlens_kv = cu_seqlens_q\n            max_seqlen_q = img_seq_len + txt_seq_len\n            max_seqlen_kv = max_seqlen_q\n\n            attention_mask = cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv\n\n        if self.enable_teacache:\n            modulated_inp = self.transformer_blocks[0].norm1(hidden_states, emb=temb)[0]\n\n            if self.cnt == 0 or self.cnt == self.num_steps-1:\n                should_calc = True\n                self.accumulated_rel_l1_distance = 0\n            else:\n                curr_rel_l1 = ((modulated_inp - self.previous_modulated_input).abs().mean() / self.previous_modulated_input.abs().mean()).cpu().item()\n                self.accumulated_rel_l1_distance += self.teacache_rescale_func(curr_rel_l1)\n                should_calc = self.accumulated_rel_l1_distance >= self.rel_l1_thresh\n\n                if should_calc:\n                    self.accumulated_rel_l1_distance = 0\n\n            self.previous_modulated_input = modulated_inp\n            self.cnt += 1\n\n            if self.cnt == self.num_steps:\n                self.cnt = 0\n\n            if not should_calc:\n                hidden_states = hidden_states + self.previous_residual\n            else:\n                ori_hidden_states = hidden_states.clone()\n\n                for block_id, block in enumerate(self.transformer_blocks):\n                    hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(\n                        block,\n                        hidden_states,\n                        encoder_hidden_states,\n                        temb,\n                        attention_mask,\n                        rope_freqs\n                    )\n\n                for block_id, block in enumerate(self.single_transformer_blocks):\n                    hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(\n                        block,\n                        hidden_states,\n                        encoder_hidden_states,\n                        temb,\n                        attention_mask,\n                        rope_freqs\n                    )\n\n                self.previous_residual = hidden_states - ori_hidden_states\n        else:\n            for block_id, block in enumerate(self.transformer_blocks):\n                hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(\n                    block,\n                    hidden_states,\n                    encoder_hidden_states,\n                    temb,\n                    attention_mask,\n                    rope_freqs\n                )\n\n            for block_id, block in enumerate(self.single_transformer_blocks):\n                hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(\n                    block,\n                    hidden_states,\n                    encoder_hidden_states,\n                    temb,\n                    attention_mask,\n                    rope_freqs\n                )\n\n        hidden_states = self.gradient_checkpointing_method(self.norm_out, hidden_states, temb)\n\n        hidden_states = hidden_states[:, -original_context_length:, :]\n\n        if self.high_quality_fp32_output_for_inference:\n            hidden_states = hidden_states.to(dtype=torch.float32)\n            if self.proj_out.weight.dtype != torch.float32:\n                self.proj_out.to(dtype=torch.float32)\n\n        hidden_states = self.gradient_checkpointing_method(self.proj_out, hidden_states)\n\n        hidden_states = einops.rearrange(hidden_states, 'b (t h w) (c pt ph pw) -> b c (t pt) (h ph) (w pw)',\n                                         t=post_patch_num_frames, h=post_patch_height, w=post_patch_width,\n                                         pt=p_t, ph=p, pw=p)\n\n        if return_dict:\n            return Transformer2DModelOutput(sample=hidden_states)\n\n        return hidden_states,\n"], ["/FramePack/diffusers_helper/utils.py", "import os\nimport cv2\nimport json\nimport random\nimport glob\nimport torch\nimport einops\nimport numpy as np\nimport datetime\nimport torchvision\n\nimport safetensors.torch as sf\nfrom PIL import Image\n\n\ndef min_resize(x, m):\n    if x.shape[0] < x.shape[1]:\n        s0 = m\n        s1 = int(float(m) / float(x.shape[0]) * float(x.shape[1]))\n    else:\n        s0 = int(float(m) / float(x.shape[1]) * float(x.shape[0]))\n        s1 = m\n    new_max = max(s1, s0)\n    raw_max = max(x.shape[0], x.shape[1])\n    if new_max < raw_max:\n        interpolation = cv2.INTER_AREA\n    else:\n        interpolation = cv2.INTER_LANCZOS4\n    y = cv2.resize(x, (s1, s0), interpolation=interpolation)\n    return y\n\n\ndef d_resize(x, y):\n    H, W, C = y.shape\n    new_min = min(H, W)\n    raw_min = min(x.shape[0], x.shape[1])\n    if new_min < raw_min:\n        interpolation = cv2.INTER_AREA\n    else:\n        interpolation = cv2.INTER_LANCZOS4\n    y = cv2.resize(x, (W, H), interpolation=interpolation)\n    return y\n\n\ndef resize_and_center_crop(image, target_width, target_height):\n    if target_height == image.shape[0] and target_width == image.shape[1]:\n        return image\n\n    pil_image = Image.fromarray(image)\n    original_width, original_height = pil_image.size\n    scale_factor = max(target_width / original_width, target_height / original_height)\n    resized_width = int(round(original_width * scale_factor))\n    resized_height = int(round(original_height * scale_factor))\n    resized_image = pil_image.resize((resized_width, resized_height), Image.LANCZOS)\n    left = (resized_width - target_width) / 2\n    top = (resized_height - target_height) / 2\n    right = (resized_width + target_width) / 2\n    bottom = (resized_height + target_height) / 2\n    cropped_image = resized_image.crop((left, top, right, bottom))\n    return np.array(cropped_image)\n\n\ndef resize_and_center_crop_pytorch(image, target_width, target_height):\n    B, C, H, W = image.shape\n\n    if H == target_height and W == target_width:\n        return image\n\n    scale_factor = max(target_width / W, target_height / H)\n    resized_width = int(round(W * scale_factor))\n    resized_height = int(round(H * scale_factor))\n\n    resized = torch.nn.functional.interpolate(image, size=(resized_height, resized_width), mode='bilinear', align_corners=False)\n\n    top = (resized_height - target_height) // 2\n    left = (resized_width - target_width) // 2\n    cropped = resized[:, :, top:top + target_height, left:left + target_width]\n\n    return cropped\n\n\ndef resize_without_crop(image, target_width, target_height):\n    if target_height == image.shape[0] and target_width == image.shape[1]:\n        return image\n\n    pil_image = Image.fromarray(image)\n    resized_image = pil_image.resize((target_width, target_height), Image.LANCZOS)\n    return np.array(resized_image)\n\n\ndef just_crop(image, w, h):\n    if h == image.shape[0] and w == image.shape[1]:\n        return image\n\n    original_height, original_width = image.shape[:2]\n    k = min(original_height / h, original_width / w)\n    new_width = int(round(w * k))\n    new_height = int(round(h * k))\n    x_start = (original_width - new_width) // 2\n    y_start = (original_height - new_height) // 2\n    cropped_image = image[y_start:y_start + new_height, x_start:x_start + new_width]\n    return cropped_image\n\n\ndef write_to_json(data, file_path):\n    temp_file_path = file_path + \".tmp\"\n    with open(temp_file_path, 'wt', encoding='utf-8') as temp_file:\n        json.dump(data, temp_file, indent=4)\n    os.replace(temp_file_path, file_path)\n    return\n\n\ndef read_from_json(file_path):\n    with open(file_path, 'rt', encoding='utf-8') as file:\n        data = json.load(file)\n    return data\n\n\ndef get_active_parameters(m):\n    return {k: v for k, v in m.named_parameters() if v.requires_grad}\n\n\ndef cast_training_params(m, dtype=torch.float32):\n    result = {}\n    for n, param in m.named_parameters():\n        if param.requires_grad:\n            param.data = param.to(dtype)\n            result[n] = param\n    return result\n\n\ndef separate_lora_AB(parameters, B_patterns=None):\n    parameters_normal = {}\n    parameters_B = {}\n\n    if B_patterns is None:\n        B_patterns = ['.lora_B.', '__zero__']\n\n    for k, v in parameters.items():\n        if any(B_pattern in k for B_pattern in B_patterns):\n            parameters_B[k] = v\n        else:\n            parameters_normal[k] = v\n\n    return parameters_normal, parameters_B\n\n\ndef set_attr_recursive(obj, attr, value):\n    attrs = attr.split(\".\")\n    for name in attrs[:-1]:\n        obj = getattr(obj, name)\n    setattr(obj, attrs[-1], value)\n    return\n\n\ndef print_tensor_list_size(tensors):\n    total_size = 0\n    total_elements = 0\n\n    if isinstance(tensors, dict):\n        tensors = tensors.values()\n\n    for tensor in tensors:\n        total_size += tensor.nelement() * tensor.element_size()\n        total_elements += tensor.nelement()\n\n    total_size_MB = total_size / (1024 ** 2)\n    total_elements_B = total_elements / 1e9\n\n    print(f\"Total number of tensors: {len(tensors)}\")\n    print(f\"Total size of tensors: {total_size_MB:.2f} MB\")\n    print(f\"Total number of parameters: {total_elements_B:.3f} billion\")\n    return\n\n\n@torch.no_grad()\ndef batch_mixture(a, b=None, probability_a=0.5, mask_a=None):\n    batch_size = a.size(0)\n\n    if b is None:\n        b = torch.zeros_like(a)\n\n    if mask_a is None:\n        mask_a = torch.rand(batch_size) < probability_a\n\n    mask_a = mask_a.to(a.device)\n    mask_a = mask_a.reshape((batch_size,) + (1,) * (a.dim() - 1))\n    result = torch.where(mask_a, a, b)\n    return result\n\n\n@torch.no_grad()\ndef zero_module(module):\n    for p in module.parameters():\n        p.detach().zero_()\n    return module\n\n\n@torch.no_grad()\ndef supress_lower_channels(m, k, alpha=0.01):\n    data = m.weight.data.clone()\n\n    assert int(data.shape[1]) >= k\n\n    data[:, :k] = data[:, :k] * alpha\n    m.weight.data = data.contiguous().clone()\n    return m\n\n\ndef freeze_module(m):\n    if not hasattr(m, '_forward_inside_frozen_module'):\n        m._forward_inside_frozen_module = m.forward\n    m.requires_grad_(False)\n    m.forward = torch.no_grad()(m.forward)\n    return m\n\n\ndef get_latest_safetensors(folder_path):\n    safetensors_files = glob.glob(os.path.join(folder_path, '*.safetensors'))\n\n    if not safetensors_files:\n        raise ValueError('No file to resume!')\n\n    latest_file = max(safetensors_files, key=os.path.getmtime)\n    latest_file = os.path.abspath(os.path.realpath(latest_file))\n    return latest_file\n\n\ndef generate_random_prompt_from_tags(tags_str, min_length=3, max_length=32):\n    tags = tags_str.split(', ')\n    tags = random.sample(tags, k=min(random.randint(min_length, max_length), len(tags)))\n    prompt = ', '.join(tags)\n    return prompt\n\n\ndef interpolate_numbers(a, b, n, round_to_int=False, gamma=1.0):\n    numbers = a + (b - a) * (np.linspace(0, 1, n) ** gamma)\n    if round_to_int:\n        numbers = np.round(numbers).astype(int)\n    return numbers.tolist()\n\n\ndef uniform_random_by_intervals(inclusive, exclusive, n, round_to_int=False):\n    edges = np.linspace(0, 1, n + 1)\n    points = np.random.uniform(edges[:-1], edges[1:])\n    numbers = inclusive + (exclusive - inclusive) * points\n    if round_to_int:\n        numbers = np.round(numbers).astype(int)\n    return numbers.tolist()\n\n\ndef soft_append_bcthw(history, current, overlap=0):\n    if overlap <= 0:\n        return torch.cat([history, current], dim=2)\n\n    assert history.shape[2] >= overlap, f\"History length ({history.shape[2]}) must be >= overlap ({overlap})\"\n    assert current.shape[2] >= overlap, f\"Current length ({current.shape[2]}) must be >= overlap ({overlap})\"\n    \n    weights = torch.linspace(1, 0, overlap, dtype=history.dtype, device=history.device).view(1, 1, -1, 1, 1)\n    blended = weights * history[:, :, -overlap:] + (1 - weights) * current[:, :, :overlap]\n    output = torch.cat([history[:, :, :-overlap], blended, current[:, :, overlap:]], dim=2)\n\n    return output.to(history)\n\n\ndef save_bcthw_as_mp4(x, output_filename, fps=10, crf=0):\n    b, c, t, h, w = x.shape\n\n    per_row = b\n    for p in [6, 5, 4, 3, 2]:\n        if b % p == 0:\n            per_row = p\n            break\n\n    os.makedirs(os.path.dirname(os.path.abspath(os.path.realpath(output_filename))), exist_ok=True)\n    x = torch.clamp(x.float(), -1., 1.) * 127.5 + 127.5\n    x = x.detach().cpu().to(torch.uint8)\n    x = einops.rearrange(x, '(m n) c t h w -> t (m h) (n w) c', n=per_row)\n    torchvision.io.write_video(output_filename, x, fps=fps, video_codec='libx264', options={'crf': str(int(crf))})\n    return x\n\n\ndef save_bcthw_as_png(x, output_filename):\n    os.makedirs(os.path.dirname(os.path.abspath(os.path.realpath(output_filename))), exist_ok=True)\n    x = torch.clamp(x.float(), -1., 1.) * 127.5 + 127.5\n    x = x.detach().cpu().to(torch.uint8)\n    x = einops.rearrange(x, 'b c t h w -> c (b h) (t w)')\n    torchvision.io.write_png(x, output_filename)\n    return output_filename\n\n\ndef save_bchw_as_png(x, output_filename):\n    os.makedirs(os.path.dirname(os.path.abspath(os.path.realpath(output_filename))), exist_ok=True)\n    x = torch.clamp(x.float(), -1., 1.) * 127.5 + 127.5\n    x = x.detach().cpu().to(torch.uint8)\n    x = einops.rearrange(x, 'b c h w -> c h (b w)')\n    torchvision.io.write_png(x, output_filename)\n    return output_filename\n\n\ndef add_tensors_with_padding(tensor1, tensor2):\n    if tensor1.shape == tensor2.shape:\n        return tensor1 + tensor2\n\n    shape1 = tensor1.shape\n    shape2 = tensor2.shape\n\n    new_shape = tuple(max(s1, s2) for s1, s2 in zip(shape1, shape2))\n\n    padded_tensor1 = torch.zeros(new_shape)\n    padded_tensor2 = torch.zeros(new_shape)\n\n    padded_tensor1[tuple(slice(0, s) for s in shape1)] = tensor1\n    padded_tensor2[tuple(slice(0, s) for s in shape2)] = tensor2\n\n    result = padded_tensor1 + padded_tensor2\n    return result\n\n\ndef print_free_mem():\n    torch.cuda.empty_cache()\n    free_mem, total_mem = torch.cuda.mem_get_info(0)\n    free_mem_mb = free_mem / (1024 ** 2)\n    total_mem_mb = total_mem / (1024 ** 2)\n    print(f\"Free memory: {free_mem_mb:.2f} MB\")\n    print(f\"Total memory: {total_mem_mb:.2f} MB\")\n    return\n\n\ndef print_gpu_parameters(device, state_dict, log_count=1):\n    summary = {\"device\": device, \"keys_count\": len(state_dict)}\n\n    logged_params = {}\n    for i, (key, tensor) in enumerate(state_dict.items()):\n        if i >= log_count:\n            break\n        logged_params[key] = tensor.flatten()[:3].tolist()\n\n    summary[\"params\"] = logged_params\n\n    print(str(summary))\n    return\n\n\ndef visualize_txt_as_img(width, height, text, font_path='font/DejaVuSans.ttf', size=18):\n    from PIL import Image, ImageDraw, ImageFont\n\n    txt = Image.new(\"RGB\", (width, height), color=\"white\")\n    draw = ImageDraw.Draw(txt)\n    font = ImageFont.truetype(font_path, size=size)\n\n    if text == '':\n        return np.array(txt)\n\n    # Split text into lines that fit within the image width\n    lines = []\n    words = text.split()\n    current_line = words[0]\n\n    for word in words[1:]:\n        line_with_word = f\"{current_line} {word}\"\n        if draw.textbbox((0, 0), line_with_word, font=font)[2] <= width:\n            current_line = line_with_word\n        else:\n            lines.append(current_line)\n            current_line = word\n\n    lines.append(current_line)\n\n    # Draw the text line by line\n    y = 0\n    line_height = draw.textbbox((0, 0), \"A\", font=font)[3]\n\n    for line in lines:\n        if y + line_height > height:\n            break  # stop drawing if the next line will be outside the image\n        draw.text((0, y), line, fill=\"black\", font=font)\n        y += line_height\n\n    return np.array(txt)\n\n\ndef blue_mark(x):\n    x = x.copy()\n    c = x[:, :, 2]\n    b = cv2.blur(c, (9, 9))\n    x[:, :, 2] = ((c - b) * 16.0 + b).clip(-1, 1)\n    return x\n\n\ndef green_mark(x):\n    x = x.copy()\n    x[:, :, 2] = -1\n    x[:, :, 0] = -1\n    return x\n\n\ndef frame_mark(x):\n    x = x.copy()\n    x[:64] = -1\n    x[-64:] = -1\n    x[:, :8] = 1\n    x[:, -8:] = 1\n    return x\n\n\n@torch.inference_mode()\ndef pytorch2numpy(imgs):\n    results = []\n    for x in imgs:\n        y = x.movedim(0, -1)\n        y = y * 127.5 + 127.5\n        y = y.detach().float().cpu().numpy().clip(0, 255).astype(np.uint8)\n        results.append(y)\n    return results\n\n\n@torch.inference_mode()\ndef numpy2pytorch(imgs):\n    h = torch.from_numpy(np.stack(imgs, axis=0)).float() / 127.5 - 1.0\n    h = h.movedim(-1, 1)\n    return h\n\n\n@torch.no_grad()\ndef duplicate_prefix_to_suffix(x, count, zero_out=False):\n    if zero_out:\n        return torch.cat([x, torch.zeros_like(x[:count])], dim=0)\n    else:\n        return torch.cat([x, x[:count]], dim=0)\n\n\ndef weighted_mse(a, b, weight):\n    return torch.mean(weight.float() * (a.float() - b.float()) ** 2)\n\n\ndef clamped_linear_interpolation(x, x_min, y_min, x_max, y_max, sigma=1.0):\n    x = (x - x_min) / (x_max - x_min)\n    x = max(0.0, min(x, 1.0))\n    x = x ** sigma\n    return y_min + x * (y_max - y_min)\n\n\ndef expand_to_dims(x, target_dims):\n    return x.view(*x.shape, *([1] * max(0, target_dims - x.dim())))\n\n\ndef repeat_to_batch_size(tensor: torch.Tensor, batch_size: int):\n    if tensor is None:\n        return None\n\n    first_dim = tensor.shape[0]\n\n    if first_dim == batch_size:\n        return tensor\n\n    if batch_size % first_dim != 0:\n        raise ValueError(f\"Cannot evenly repeat first dim {first_dim} to match batch_size {batch_size}.\")\n\n    repeat_times = batch_size // first_dim\n\n    return tensor.repeat(repeat_times, *[1] * (tensor.dim() - 1))\n\n\ndef dim5(x):\n    return expand_to_dims(x, 5)\n\n\ndef dim4(x):\n    return expand_to_dims(x, 4)\n\n\ndef dim3(x):\n    return expand_to_dims(x, 3)\n\n\ndef crop_or_pad_yield_mask(x, length):\n    B, F, C = x.shape\n    device = x.device\n    dtype = x.dtype\n\n    if F < length:\n        y = torch.zeros((B, length, C), dtype=dtype, device=device)\n        mask = torch.zeros((B, length), dtype=torch.bool, device=device)\n        y[:, :F, :] = x\n        mask[:, :F] = True\n        return y, mask\n\n    return x[:, :length, :], torch.ones((B, length), dtype=torch.bool, device=device)\n\n\ndef extend_dim(x, dim, minimal_length, zero_pad=False):\n    original_length = int(x.shape[dim])\n\n    if original_length >= minimal_length:\n        return x\n\n    if zero_pad:\n        padding_shape = list(x.shape)\n        padding_shape[dim] = minimal_length - original_length\n        padding = torch.zeros(padding_shape, dtype=x.dtype, device=x.device)\n    else:\n        idx = (slice(None),) * dim + (slice(-1, None),) + (slice(None),) * (len(x.shape) - dim - 1)\n        last_element = x[idx]\n        padding = last_element.repeat_interleave(minimal_length - original_length, dim=dim)\n\n    return torch.cat([x, padding], dim=dim)\n\n\ndef lazy_positional_encoding(t, repeats=None):\n    if not isinstance(t, list):\n        t = [t]\n\n    from diffusers.models.embeddings import get_timestep_embedding\n\n    te = torch.tensor(t)\n    te = get_timestep_embedding(timesteps=te, embedding_dim=256, flip_sin_to_cos=True, downscale_freq_shift=0.0, scale=1.0)\n\n    if repeats is None:\n        return te\n\n    te = te[:, None, :].expand(-1, repeats, -1)\n\n    return te\n\n\ndef state_dict_offset_merge(A, B, C=None):\n    result = {}\n    keys = A.keys()\n\n    for key in keys:\n        A_value = A[key]\n        B_value = B[key].to(A_value)\n\n        if C is None:\n            result[key] = A_value + B_value\n        else:\n            C_value = C[key].to(A_value)\n            result[key] = A_value + B_value - C_value\n\n    return result\n\n\ndef state_dict_weighted_merge(state_dicts, weights):\n    if len(state_dicts) != len(weights):\n        raise ValueError(\"Number of state dictionaries must match number of weights\")\n\n    if not state_dicts:\n        return {}\n\n    total_weight = sum(weights)\n\n    if total_weight == 0:\n        raise ValueError(\"Sum of weights cannot be zero\")\n\n    normalized_weights = [w / total_weight for w in weights]\n\n    keys = state_dicts[0].keys()\n    result = {}\n\n    for key in keys:\n        result[key] = state_dicts[0][key] * normalized_weights[0]\n\n        for i in range(1, len(state_dicts)):\n            state_dict_value = state_dicts[i][key].to(result[key])\n            result[key] += state_dict_value * normalized_weights[i]\n\n    return result\n\n\ndef group_files_by_folder(all_files):\n    grouped_files = {}\n\n    for file in all_files:\n        folder_name = os.path.basename(os.path.dirname(file))\n        if folder_name not in grouped_files:\n            grouped_files[folder_name] = []\n        grouped_files[folder_name].append(file)\n\n    list_of_lists = list(grouped_files.values())\n    return list_of_lists\n\n\ndef generate_timestamp():\n    now = datetime.datetime.now()\n    timestamp = now.strftime('%y%m%d_%H%M%S')\n    milliseconds = f\"{int(now.microsecond / 1000):03d}\"\n    random_number = random.randint(0, 9999)\n    return f\"{timestamp}_{milliseconds}_{random_number}\"\n\n\ndef write_PIL_image_with_png_info(image, metadata, path):\n    from PIL.PngImagePlugin import PngInfo\n\n    png_info = PngInfo()\n    for key, value in metadata.items():\n        png_info.add_text(key, value)\n\n    image.save(path, \"PNG\", pnginfo=png_info)\n    return image\n\n\ndef torch_safe_save(content, path):\n    torch.save(content, path + '_tmp')\n    os.replace(path + '_tmp', path)\n    return path\n\n\ndef move_optimizer_to_device(optimizer, device):\n    for state in optimizer.state.values():\n        for k, v in state.items():\n            if isinstance(v, torch.Tensor):\n                state[k] = v.to(device)\n"], ["/FramePack/demo_gradio.py", "from diffusers_helper.hf_login import login\n\nimport os\n\nos.environ['HF_HOME'] = os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download')))\n\nimport gradio as gr\nimport torch\nimport traceback\nimport einops\nimport safetensors.torch as sf\nimport numpy as np\nimport argparse\nimport math\n\nfrom PIL import Image\nfrom diffusers import AutoencoderKLHunyuanVideo\nfrom transformers import LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer\nfrom diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake\nfrom diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, state_dict_weighted_merge, state_dict_offset_merge, generate_timestamp\nfrom diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked\nfrom diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan\nfrom diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete\nfrom diffusers_helper.thread_utils import AsyncStream, async_run\nfrom diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html\nfrom transformers import SiglipImageProcessor, SiglipVisionModel\nfrom diffusers_helper.clip_vision import hf_clip_vision_encode\nfrom diffusers_helper.bucket_tools import find_nearest_bucket\n\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--share', action='store_true')\nparser.add_argument(\"--server\", type=str, default='0.0.0.0')\nparser.add_argument(\"--port\", type=int, required=False)\nparser.add_argument(\"--inbrowser\", action='store_true')\nargs = parser.parse_args()\n\n# for win desktop probably use --server 127.0.0.1 --inbrowser\n# For linux server probably use --server 127.0.0.1 or do not use any cmd flags\n\nprint(args)\n\nfree_mem_gb = get_cuda_free_memory_gb(gpu)\nhigh_vram = free_mem_gb > 60\n\nprint(f'Free VRAM {free_mem_gb} GB')\nprint(f'High-VRAM Mode: {high_vram}')\n\ntext_encoder = LlamaModel.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='text_encoder', torch_dtype=torch.float16).cpu()\ntext_encoder_2 = CLIPTextModel.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='text_encoder_2', torch_dtype=torch.float16).cpu()\ntokenizer = LlamaTokenizerFast.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='tokenizer')\ntokenizer_2 = CLIPTokenizer.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='tokenizer_2')\nvae = AutoencoderKLHunyuanVideo.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='vae', torch_dtype=torch.float16).cpu()\n\nfeature_extractor = SiglipImageProcessor.from_pretrained(\"lllyasviel/flux_redux_bfl\", subfolder='feature_extractor')\nimage_encoder = SiglipVisionModel.from_pretrained(\"lllyasviel/flux_redux_bfl\", subfolder='image_encoder', torch_dtype=torch.float16).cpu()\n\ntransformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('lllyasviel/FramePackI2V_HY', torch_dtype=torch.bfloat16).cpu()\n\nvae.eval()\ntext_encoder.eval()\ntext_encoder_2.eval()\nimage_encoder.eval()\ntransformer.eval()\n\nif not high_vram:\n    vae.enable_slicing()\n    vae.enable_tiling()\n\ntransformer.high_quality_fp32_output_for_inference = True\nprint('transformer.high_quality_fp32_output_for_inference = True')\n\ntransformer.to(dtype=torch.bfloat16)\nvae.to(dtype=torch.float16)\nimage_encoder.to(dtype=torch.float16)\ntext_encoder.to(dtype=torch.float16)\ntext_encoder_2.to(dtype=torch.float16)\n\nvae.requires_grad_(False)\ntext_encoder.requires_grad_(False)\ntext_encoder_2.requires_grad_(False)\nimage_encoder.requires_grad_(False)\ntransformer.requires_grad_(False)\n\nif not high_vram:\n    # DynamicSwapInstaller is same as huggingface's enable_sequential_offload but 3x faster\n    DynamicSwapInstaller.install_model(transformer, device=gpu)\n    DynamicSwapInstaller.install_model(text_encoder, device=gpu)\nelse:\n    text_encoder.to(gpu)\n    text_encoder_2.to(gpu)\n    image_encoder.to(gpu)\n    vae.to(gpu)\n    transformer.to(gpu)\n\nstream = AsyncStream()\n\noutputs_folder = './outputs/'\nos.makedirs(outputs_folder, exist_ok=True)\n\n\n@torch.no_grad()\ndef worker(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf):\n    total_latent_sections = (total_second_length * 30) / (latent_window_size * 4)\n    total_latent_sections = int(max(round(total_latent_sections), 1))\n\n    job_id = generate_timestamp()\n\n    stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))\n\n    try:\n        # Clean GPU\n        if not high_vram:\n            unload_complete_models(\n                text_encoder, text_encoder_2, image_encoder, vae, transformer\n            )\n\n        # Text encoding\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Text encoding ...'))))\n\n        if not high_vram:\n            fake_diffusers_current_device(text_encoder, gpu)  # since we only encode one text - that is one model move and one encode, offload is same time consumption since it is also one load and one encode.\n            load_model_as_complete(text_encoder_2, target_device=gpu)\n\n        llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)\n\n        if cfg == 1:\n            llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)\n        else:\n            llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)\n\n        llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)\n        llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)\n\n        # Processing input image\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Image processing ...'))))\n\n        H, W, C = input_image.shape\n        height, width = find_nearest_bucket(H, W, resolution=640)\n        input_image_np = resize_and_center_crop(input_image, target_width=width, target_height=height)\n\n        Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))\n\n        input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1\n        input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]\n\n        # VAE encoding\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding ...'))))\n\n        if not high_vram:\n            load_model_as_complete(vae, target_device=gpu)\n\n        start_latent = vae_encode(input_image_pt, vae)\n\n        # CLIP Vision\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))\n\n        if not high_vram:\n            load_model_as_complete(image_encoder, target_device=gpu)\n\n        image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)\n        image_encoder_last_hidden_state = image_encoder_output.last_hidden_state\n\n        # Dtype\n\n        llama_vec = llama_vec.to(transformer.dtype)\n        llama_vec_n = llama_vec_n.to(transformer.dtype)\n        clip_l_pooler = clip_l_pooler.to(transformer.dtype)\n        clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)\n        image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)\n\n        # Sampling\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Start sampling ...'))))\n\n        rnd = torch.Generator(\"cpu\").manual_seed(seed)\n        num_frames = latent_window_size * 4 - 3\n\n        history_latents = torch.zeros(size=(1, 16, 1 + 2 + 16, height // 8, width // 8), dtype=torch.float32).cpu()\n        history_pixels = None\n        total_generated_latent_frames = 0\n\n        latent_paddings = reversed(range(total_latent_sections))\n\n        if total_latent_sections > 4:\n            # In theory the latent_paddings should follow the above sequence, but it seems that duplicating some\n            # items looks better than expanding it when total_latent_sections > 4\n            # One can try to remove below trick and just\n            # use `latent_paddings = list(reversed(range(total_latent_sections)))` to compare\n            latent_paddings = [3] + [2] * (total_latent_sections - 3) + [1, 0]\n\n        for latent_padding in latent_paddings:\n            is_last_section = latent_padding == 0\n            latent_padding_size = latent_padding * latent_window_size\n\n            if stream.input_queue.top() == 'end':\n                stream.output_queue.push(('end', None))\n                return\n\n            print(f'latent_padding_size = {latent_padding_size}, is_last_section = {is_last_section}')\n\n            indices = torch.arange(0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])).unsqueeze(0)\n            clean_latent_indices_pre, blank_indices, latent_indices, clean_latent_indices_post, clean_latent_2x_indices, clean_latent_4x_indices = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)\n            clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)\n\n            clean_latents_pre = start_latent.to(history_latents)\n            clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[:, :, :1 + 2 + 16, :, :].split([1, 2, 16], dim=2)\n            clean_latents = torch.cat([clean_latents_pre, clean_latents_post], dim=2)\n\n            if not high_vram:\n                unload_complete_models()\n                move_model_to_device_with_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=gpu_memory_preservation)\n\n            if use_teacache:\n                transformer.initialize_teacache(enable_teacache=True, num_steps=steps)\n            else:\n                transformer.initialize_teacache(enable_teacache=False)\n\n            def callback(d):\n                preview = d['denoised']\n                preview = vae_decode_fake(preview)\n\n                preview = (preview * 255.0).detach().cpu().numpy().clip(0, 255).astype(np.uint8)\n                preview = einops.rearrange(preview, 'b c t h w -> (b h) (t w) c')\n\n                if stream.input_queue.top() == 'end':\n                    stream.output_queue.push(('end', None))\n                    raise KeyboardInterrupt('User ends the task.')\n\n                current_step = d['i'] + 1\n                percentage = int(100.0 * current_step / steps)\n                hint = f'Sampling {current_step}/{steps}'\n                desc = f'Total generated frames: {int(max(0, total_generated_latent_frames * 4 - 3))}, Video length: {max(0, (total_generated_latent_frames * 4 - 3) / 30) :.2f} seconds (FPS-30). The video is being extended now ...'\n                stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))\n                return\n\n            generated_latents = sample_hunyuan(\n                transformer=transformer,\n                sampler='unipc',\n                width=width,\n                height=height,\n                frames=num_frames,\n                real_guidance_scale=cfg,\n                distilled_guidance_scale=gs,\n                guidance_rescale=rs,\n                # shift=3.0,\n                num_inference_steps=steps,\n                generator=rnd,\n                prompt_embeds=llama_vec,\n                prompt_embeds_mask=llama_attention_mask,\n                prompt_poolers=clip_l_pooler,\n                negative_prompt_embeds=llama_vec_n,\n                negative_prompt_embeds_mask=llama_attention_mask_n,\n                negative_prompt_poolers=clip_l_pooler_n,\n                device=gpu,\n                dtype=torch.bfloat16,\n                image_embeddings=image_encoder_last_hidden_state,\n                latent_indices=latent_indices,\n                clean_latents=clean_latents,\n                clean_latent_indices=clean_latent_indices,\n                clean_latents_2x=clean_latents_2x,\n                clean_latent_2x_indices=clean_latent_2x_indices,\n                clean_latents_4x=clean_latents_4x,\n                clean_latent_4x_indices=clean_latent_4x_indices,\n                callback=callback,\n            )\n\n            if is_last_section:\n                generated_latents = torch.cat([start_latent.to(generated_latents), generated_latents], dim=2)\n\n            total_generated_latent_frames += int(generated_latents.shape[2])\n            history_latents = torch.cat([generated_latents.to(history_latents), history_latents], dim=2)\n\n            if not high_vram:\n                offload_model_from_device_for_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=8)\n                load_model_as_complete(vae, target_device=gpu)\n\n            real_history_latents = history_latents[:, :, :total_generated_latent_frames, :, :]\n\n            if history_pixels is None:\n                history_pixels = vae_decode(real_history_latents, vae).cpu()\n            else:\n                section_latent_frames = (latent_window_size * 2 + 1) if is_last_section else (latent_window_size * 2)\n                overlapped_frames = latent_window_size * 4 - 3\n\n                current_pixels = vae_decode(real_history_latents[:, :, :section_latent_frames], vae).cpu()\n                history_pixels = soft_append_bcthw(current_pixels, history_pixels, overlapped_frames)\n\n            if not high_vram:\n                unload_complete_models()\n\n            output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')\n\n            save_bcthw_as_mp4(history_pixels, output_filename, fps=30, crf=mp4_crf)\n\n            print(f'Decoded. Current latent shape {real_history_latents.shape}; pixel shape {history_pixels.shape}')\n\n            stream.output_queue.push(('file', output_filename))\n\n            if is_last_section:\n                break\n    except:\n        traceback.print_exc()\n\n        if not high_vram:\n            unload_complete_models(\n                text_encoder, text_encoder_2, image_encoder, vae, transformer\n            )\n\n    stream.output_queue.push(('end', None))\n    return\n\n\ndef process(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf):\n    global stream\n    assert input_image is not None, 'No input image!'\n\n    yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)\n\n    stream = AsyncStream()\n\n    async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf)\n\n    output_filename = None\n\n    while True:\n        flag, data = stream.output_queue.next()\n\n        if flag == 'file':\n            output_filename = data\n            yield output_filename, gr.update(), gr.update(), gr.update(), gr.update(interactive=False), gr.update(interactive=True)\n\n        if flag == 'progress':\n            preview, desc, html = data\n            yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)\n\n        if flag == 'end':\n            yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)\n            break\n\n\ndef end_process():\n    stream.input_queue.push('end')\n\n\nquick_prompts = [\n    'The girl dances gracefully, with clear movements, full of charm.',\n    'A character doing some simple body movements.',\n]\nquick_prompts = [[x] for x in quick_prompts]\n\n\ncss = make_progress_bar_css()\nblock = gr.Blocks(css=css).queue()\nwith block:\n    gr.Markdown('# FramePack')\n    with gr.Row():\n        with gr.Column():\n            input_image = gr.Image(sources='upload', type=\"numpy\", label=\"Image\", height=320)\n            prompt = gr.Textbox(label=\"Prompt\", value='')\n            example_quick_prompts = gr.Dataset(samples=quick_prompts, label='Quick List', samples_per_page=1000, components=[prompt])\n            example_quick_prompts.click(lambda x: x[0], inputs=[example_quick_prompts], outputs=prompt, show_progress=False, queue=False)\n\n            with gr.Row():\n                start_button = gr.Button(value=\"Start Generation\")\n                end_button = gr.Button(value=\"End Generation\", interactive=False)\n\n            with gr.Group():\n                use_teacache = gr.Checkbox(label='Use TeaCache', value=True, info='Faster speed, but often makes hands and fingers slightly worse.')\n\n                n_prompt = gr.Textbox(label=\"Negative Prompt\", value=\"\", visible=False)  # Not used\n                seed = gr.Number(label=\"Seed\", value=31337, precision=0)\n\n                total_second_length = gr.Slider(label=\"Total Video Length (Seconds)\", minimum=1, maximum=120, value=5, step=0.1)\n                latent_window_size = gr.Slider(label=\"Latent Window Size\", minimum=1, maximum=33, value=9, step=1, visible=False)  # Should not change\n                steps = gr.Slider(label=\"Steps\", minimum=1, maximum=100, value=25, step=1, info='Changing this value is not recommended.')\n\n                cfg = gr.Slider(label=\"CFG Scale\", minimum=1.0, maximum=32.0, value=1.0, step=0.01, visible=False)  # Should not change\n                gs = gr.Slider(label=\"Distilled CFG Scale\", minimum=1.0, maximum=32.0, value=10.0, step=0.01, info='Changing this value is not recommended.')\n                rs = gr.Slider(label=\"CFG Re-Scale\", minimum=0.0, maximum=1.0, value=0.0, step=0.01, visible=False)  # Should not change\n\n                gpu_memory_preservation = gr.Slider(label=\"GPU Inference Preserved Memory (GB) (larger means slower)\", minimum=6, maximum=128, value=6, step=0.1, info=\"Set this number to a larger value if you encounter OOM. Larger value causes slower speed.\")\n\n                mp4_crf = gr.Slider(label=\"MP4 Compression\", minimum=0, maximum=100, value=16, step=1, info=\"Lower means better quality. 0 is uncompressed. Change to 16 if you get black outputs. \")\n\n        with gr.Column():\n            preview_image = gr.Image(label=\"Next Latents\", height=200, visible=False)\n            result_video = gr.Video(label=\"Finished Frames\", autoplay=True, show_share_button=False, height=512, loop=True)\n            gr.Markdown('Note that the ending actions will be generated before the starting actions due to the inverted sampling. If the starting action is not in the video, you just need to wait, and it will be generated later.')\n            progress_desc = gr.Markdown('', elem_classes='no-generating-animation')\n            progress_bar = gr.HTML('', elem_classes='no-generating-animation')\n\n    gr.HTML('<div style=\"text-align:center; margin-top:20px;\">Share your results and find ideas at the <a href=\"https://x.com/search?q=framepack&f=live\" target=\"_blank\">FramePack Twitter (X) thread</a></div>')\n\n    ips = [input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf]\n    start_button.click(fn=process, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button])\n    end_button.click(fn=end_process)\n\n\nblock.launch(\n    server_name=args.server,\n    server_port=args.port,\n    share=args.share,\n    inbrowser=args.inbrowser,\n)\n"], ["/FramePack/demo_gradio_f1.py", "from diffusers_helper.hf_login import login\n\nimport os\n\nos.environ['HF_HOME'] = os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download')))\n\nimport gradio as gr\nimport torch\nimport traceback\nimport einops\nimport safetensors.torch as sf\nimport numpy as np\nimport argparse\nimport math\n\nfrom PIL import Image\nfrom diffusers import AutoencoderKLHunyuanVideo\nfrom transformers import LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer\nfrom diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake\nfrom diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, state_dict_weighted_merge, state_dict_offset_merge, generate_timestamp\nfrom diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked\nfrom diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan\nfrom diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete\nfrom diffusers_helper.thread_utils import AsyncStream, async_run\nfrom diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html\nfrom transformers import SiglipImageProcessor, SiglipVisionModel\nfrom diffusers_helper.clip_vision import hf_clip_vision_encode\nfrom diffusers_helper.bucket_tools import find_nearest_bucket\n\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--share', action='store_true')\nparser.add_argument(\"--server\", type=str, default='0.0.0.0')\nparser.add_argument(\"--port\", type=int, required=False)\nparser.add_argument(\"--inbrowser\", action='store_true')\nargs = parser.parse_args()\n\n# for win desktop probably use --server 127.0.0.1 --inbrowser\n# For linux server probably use --server 127.0.0.1 or do not use any cmd flags\n\nprint(args)\n\nfree_mem_gb = get_cuda_free_memory_gb(gpu)\nhigh_vram = free_mem_gb > 60\n\nprint(f'Free VRAM {free_mem_gb} GB')\nprint(f'High-VRAM Mode: {high_vram}')\n\ntext_encoder = LlamaModel.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='text_encoder', torch_dtype=torch.float16).cpu()\ntext_encoder_2 = CLIPTextModel.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='text_encoder_2', torch_dtype=torch.float16).cpu()\ntokenizer = LlamaTokenizerFast.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='tokenizer')\ntokenizer_2 = CLIPTokenizer.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='tokenizer_2')\nvae = AutoencoderKLHunyuanVideo.from_pretrained(\"hunyuanvideo-community/HunyuanVideo\", subfolder='vae', torch_dtype=torch.float16).cpu()\n\nfeature_extractor = SiglipImageProcessor.from_pretrained(\"lllyasviel/flux_redux_bfl\", subfolder='feature_extractor')\nimage_encoder = SiglipVisionModel.from_pretrained(\"lllyasviel/flux_redux_bfl\", subfolder='image_encoder', torch_dtype=torch.float16).cpu()\n\ntransformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('lllyasviel/FramePack_F1_I2V_HY_20250503', torch_dtype=torch.bfloat16).cpu()\n\nvae.eval()\ntext_encoder.eval()\ntext_encoder_2.eval()\nimage_encoder.eval()\ntransformer.eval()\n\nif not high_vram:\n    vae.enable_slicing()\n    vae.enable_tiling()\n\ntransformer.high_quality_fp32_output_for_inference = True\nprint('transformer.high_quality_fp32_output_for_inference = True')\n\ntransformer.to(dtype=torch.bfloat16)\nvae.to(dtype=torch.float16)\nimage_encoder.to(dtype=torch.float16)\ntext_encoder.to(dtype=torch.float16)\ntext_encoder_2.to(dtype=torch.float16)\n\nvae.requires_grad_(False)\ntext_encoder.requires_grad_(False)\ntext_encoder_2.requires_grad_(False)\nimage_encoder.requires_grad_(False)\ntransformer.requires_grad_(False)\n\nif not high_vram:\n    # DynamicSwapInstaller is same as huggingface's enable_sequential_offload but 3x faster\n    DynamicSwapInstaller.install_model(transformer, device=gpu)\n    DynamicSwapInstaller.install_model(text_encoder, device=gpu)\nelse:\n    text_encoder.to(gpu)\n    text_encoder_2.to(gpu)\n    image_encoder.to(gpu)\n    vae.to(gpu)\n    transformer.to(gpu)\n\nstream = AsyncStream()\n\noutputs_folder = './outputs/'\nos.makedirs(outputs_folder, exist_ok=True)\n\n\n@torch.no_grad()\ndef worker(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf):\n    total_latent_sections = (total_second_length * 30) / (latent_window_size * 4)\n    total_latent_sections = int(max(round(total_latent_sections), 1))\n\n    job_id = generate_timestamp()\n\n    stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))\n\n    try:\n        # Clean GPU\n        if not high_vram:\n            unload_complete_models(\n                text_encoder, text_encoder_2, image_encoder, vae, transformer\n            )\n\n        # Text encoding\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Text encoding ...'))))\n\n        if not high_vram:\n            fake_diffusers_current_device(text_encoder, gpu)  # since we only encode one text - that is one model move and one encode, offload is same time consumption since it is also one load and one encode.\n            load_model_as_complete(text_encoder_2, target_device=gpu)\n\n        llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)\n\n        if cfg == 1:\n            llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)\n        else:\n            llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)\n\n        llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)\n        llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)\n\n        # Processing input image\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Image processing ...'))))\n\n        H, W, C = input_image.shape\n        height, width = find_nearest_bucket(H, W, resolution=640)\n        input_image_np = resize_and_center_crop(input_image, target_width=width, target_height=height)\n\n        Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))\n\n        input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1\n        input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]\n\n        # VAE encoding\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding ...'))))\n\n        if not high_vram:\n            load_model_as_complete(vae, target_device=gpu)\n\n        start_latent = vae_encode(input_image_pt, vae)\n\n        # CLIP Vision\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))\n\n        if not high_vram:\n            load_model_as_complete(image_encoder, target_device=gpu)\n\n        image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)\n        image_encoder_last_hidden_state = image_encoder_output.last_hidden_state\n\n        # Dtype\n\n        llama_vec = llama_vec.to(transformer.dtype)\n        llama_vec_n = llama_vec_n.to(transformer.dtype)\n        clip_l_pooler = clip_l_pooler.to(transformer.dtype)\n        clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)\n        image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)\n\n        # Sampling\n\n        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Start sampling ...'))))\n\n        rnd = torch.Generator(\"cpu\").manual_seed(seed)\n\n        history_latents = torch.zeros(size=(1, 16, 16 + 2 + 1, height // 8, width // 8), dtype=torch.float32).cpu()\n        history_pixels = None\n\n        history_latents = torch.cat([history_latents, start_latent.to(history_latents)], dim=2)\n        total_generated_latent_frames = 1\n\n        for section_index in range(total_latent_sections):\n            if stream.input_queue.top() == 'end':\n                stream.output_queue.push(('end', None))\n                return\n\n            print(f'section_index = {section_index}, total_latent_sections = {total_latent_sections}')\n\n            if not high_vram:\n                unload_complete_models()\n                move_model_to_device_with_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=gpu_memory_preservation)\n\n            if use_teacache:\n                transformer.initialize_teacache(enable_teacache=True, num_steps=steps)\n            else:\n                transformer.initialize_teacache(enable_teacache=False)\n\n            def callback(d):\n                preview = d['denoised']\n                preview = vae_decode_fake(preview)\n\n                preview = (preview * 255.0).detach().cpu().numpy().clip(0, 255).astype(np.uint8)\n                preview = einops.rearrange(preview, 'b c t h w -> (b h) (t w) c')\n\n                if stream.input_queue.top() == 'end':\n                    stream.output_queue.push(('end', None))\n                    raise KeyboardInterrupt('User ends the task.')\n\n                current_step = d['i'] + 1\n                percentage = int(100.0 * current_step / steps)\n                hint = f'Sampling {current_step}/{steps}'\n                desc = f'Total generated frames: {int(max(0, total_generated_latent_frames * 4 - 3))}, Video length: {max(0, (total_generated_latent_frames * 4 - 3) / 30) :.2f} seconds (FPS-30). The video is being extended now ...'\n                stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))\n                return\n\n            indices = torch.arange(0, sum([1, 16, 2, 1, latent_window_size])).unsqueeze(0)\n            clean_latent_indices_start, clean_latent_4x_indices, clean_latent_2x_indices, clean_latent_1x_indices, latent_indices = indices.split([1, 16, 2, 1, latent_window_size], dim=1)\n            clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)\n\n            clean_latents_4x, clean_latents_2x, clean_latents_1x = history_latents[:, :, -sum([16, 2, 1]):, :, :].split([16, 2, 1], dim=2)\n            clean_latents = torch.cat([start_latent.to(history_latents), clean_latents_1x], dim=2)\n\n            generated_latents = sample_hunyuan(\n                transformer=transformer,\n                sampler='unipc',\n                width=width,\n                height=height,\n                frames=latent_window_size * 4 - 3,\n                real_guidance_scale=cfg,\n                distilled_guidance_scale=gs,\n                guidance_rescale=rs,\n                # shift=3.0,\n                num_inference_steps=steps,\n                generator=rnd,\n                prompt_embeds=llama_vec,\n                prompt_embeds_mask=llama_attention_mask,\n                prompt_poolers=clip_l_pooler,\n                negative_prompt_embeds=llama_vec_n,\n                negative_prompt_embeds_mask=llama_attention_mask_n,\n                negative_prompt_poolers=clip_l_pooler_n,\n                device=gpu,\n                dtype=torch.bfloat16,\n                image_embeddings=image_encoder_last_hidden_state,\n                latent_indices=latent_indices,\n                clean_latents=clean_latents,\n                clean_latent_indices=clean_latent_indices,\n                clean_latents_2x=clean_latents_2x,\n                clean_latent_2x_indices=clean_latent_2x_indices,\n                clean_latents_4x=clean_latents_4x,\n                clean_latent_4x_indices=clean_latent_4x_indices,\n                callback=callback,\n            )\n\n            total_generated_latent_frames += int(generated_latents.shape[2])\n            history_latents = torch.cat([history_latents, generated_latents.to(history_latents)], dim=2)\n\n            if not high_vram:\n                offload_model_from_device_for_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=8)\n                load_model_as_complete(vae, target_device=gpu)\n\n            real_history_latents = history_latents[:, :, -total_generated_latent_frames:, :, :]\n\n            if history_pixels is None:\n                history_pixels = vae_decode(real_history_latents, vae).cpu()\n            else:\n                section_latent_frames = latent_window_size * 2\n                overlapped_frames = latent_window_size * 4 - 3\n\n                current_pixels = vae_decode(real_history_latents[:, :, -section_latent_frames:], vae).cpu()\n                history_pixels = soft_append_bcthw(history_pixels, current_pixels, overlapped_frames)\n\n            if not high_vram:\n                unload_complete_models()\n\n            output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')\n\n            save_bcthw_as_mp4(history_pixels, output_filename, fps=30, crf=mp4_crf)\n\n            print(f'Decoded. Current latent shape {real_history_latents.shape}; pixel shape {history_pixels.shape}')\n\n            stream.output_queue.push(('file', output_filename))\n    except:\n        traceback.print_exc()\n\n        if not high_vram:\n            unload_complete_models(\n                text_encoder, text_encoder_2, image_encoder, vae, transformer\n            )\n\n    stream.output_queue.push(('end', None))\n    return\n\n\ndef process(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf):\n    global stream\n    assert input_image is not None, 'No input image!'\n\n    yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)\n\n    stream = AsyncStream()\n\n    async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf)\n\n    output_filename = None\n\n    while True:\n        flag, data = stream.output_queue.next()\n\n        if flag == 'file':\n            output_filename = data\n            yield output_filename, gr.update(), gr.update(), gr.update(), gr.update(interactive=False), gr.update(interactive=True)\n\n        if flag == 'progress':\n            preview, desc, html = data\n            yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)\n\n        if flag == 'end':\n            yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)\n            break\n\n\ndef end_process():\n    stream.input_queue.push('end')\n\n\nquick_prompts = [\n    'The girl dances gracefully, with clear movements, full of charm.',\n    'A character doing some simple body movements.',\n]\nquick_prompts = [[x] for x in quick_prompts]\n\n\ncss = make_progress_bar_css()\nblock = gr.Blocks(css=css).queue()\nwith block:\n    gr.Markdown('# FramePack-F1')\n    with gr.Row():\n        with gr.Column():\n            input_image = gr.Image(sources='upload', type=\"numpy\", label=\"Image\", height=320)\n            prompt = gr.Textbox(label=\"Prompt\", value='')\n            example_quick_prompts = gr.Dataset(samples=quick_prompts, label='Quick List', samples_per_page=1000, components=[prompt])\n            example_quick_prompts.click(lambda x: x[0], inputs=[example_quick_prompts], outputs=prompt, show_progress=False, queue=False)\n\n            with gr.Row():\n                start_button = gr.Button(value=\"Start Generation\")\n                end_button = gr.Button(value=\"End Generation\", interactive=False)\n\n            with gr.Group():\n                use_teacache = gr.Checkbox(label='Use TeaCache', value=True, info='Faster speed, but often makes hands and fingers slightly worse.')\n\n                n_prompt = gr.Textbox(label=\"Negative Prompt\", value=\"\", visible=False)  # Not used\n                seed = gr.Number(label=\"Seed\", value=31337, precision=0)\n\n                total_second_length = gr.Slider(label=\"Total Video Length (Seconds)\", minimum=1, maximum=120, value=5, step=0.1)\n                latent_window_size = gr.Slider(label=\"Latent Window Size\", minimum=1, maximum=33, value=9, step=1, visible=False)  # Should not change\n                steps = gr.Slider(label=\"Steps\", minimum=1, maximum=100, value=25, step=1, info='Changing this value is not recommended.')\n\n                cfg = gr.Slider(label=\"CFG Scale\", minimum=1.0, maximum=32.0, value=1.0, step=0.01, visible=False)  # Should not change\n                gs = gr.Slider(label=\"Distilled CFG Scale\", minimum=1.0, maximum=32.0, value=10.0, step=0.01, info='Changing this value is not recommended.')\n                rs = gr.Slider(label=\"CFG Re-Scale\", minimum=0.0, maximum=1.0, value=0.0, step=0.01, visible=False)  # Should not change\n\n                gpu_memory_preservation = gr.Slider(label=\"GPU Inference Preserved Memory (GB) (larger means slower)\", minimum=6, maximum=128, value=6, step=0.1, info=\"Set this number to a larger value if you encounter OOM. Larger value causes slower speed.\")\n\n                mp4_crf = gr.Slider(label=\"MP4 Compression\", minimum=0, maximum=100, value=16, step=1, info=\"Lower means better quality. 0 is uncompressed. Change to 16 if you get black outputs. \")\n\n        with gr.Column():\n            preview_image = gr.Image(label=\"Next Latents\", height=200, visible=False)\n            result_video = gr.Video(label=\"Finished Frames\", autoplay=True, show_share_button=False, height=512, loop=True)\n            progress_desc = gr.Markdown('', elem_classes='no-generating-animation')\n            progress_bar = gr.HTML('', elem_classes='no-generating-animation')\n\n    gr.HTML('<div style=\"text-align:center; margin-top:20px;\">Share your results and find ideas at the <a href=\"https://x.com/search?q=framepack&f=live\" target=\"_blank\">FramePack Twitter (X) thread</a></div>')\n\n    ips = [input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache, mp4_crf]\n    start_button.click(fn=process, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button])\n    end_button.click(fn=end_process)\n\n\nblock.launch(\n    server_name=args.server,\n    server_port=args.port,\n    share=args.share,\n    inbrowser=args.inbrowser,\n)\n"], ["/FramePack/diffusers_helper/pipelines/k_diffusion_hunyuan.py", "import torch\nimport math\n\nfrom diffusers_helper.k_diffusion.uni_pc_fm import sample_unipc\nfrom diffusers_helper.k_diffusion.wrapper import fm_wrapper\nfrom diffusers_helper.utils import repeat_to_batch_size\n\n\ndef flux_time_shift(t, mu=1.15, sigma=1.0):\n    return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)\n\n\ndef calculate_flux_mu(context_length, x1=256, y1=0.5, x2=4096, y2=1.15, exp_max=7.0):\n    k = (y2 - y1) / (x2 - x1)\n    b = y1 - k * x1\n    mu = k * context_length + b\n    mu = min(mu, math.log(exp_max))\n    return mu\n\n\ndef get_flux_sigmas_from_mu(n, mu):\n    sigmas = torch.linspace(1, 0, steps=n + 1)\n    sigmas = flux_time_shift(sigmas, mu=mu)\n    return sigmas\n\n\n@torch.inference_mode()\ndef sample_hunyuan(\n        transformer,\n        sampler='unipc',\n        initial_latent=None,\n        concat_latent=None,\n        strength=1.0,\n        width=512,\n        height=512,\n        frames=16,\n        real_guidance_scale=1.0,\n        distilled_guidance_scale=6.0,\n        guidance_rescale=0.0,\n        shift=None,\n        num_inference_steps=25,\n        batch_size=None,\n        generator=None,\n        prompt_embeds=None,\n        prompt_embeds_mask=None,\n        prompt_poolers=None,\n        negative_prompt_embeds=None,\n        negative_prompt_embeds_mask=None,\n        negative_prompt_poolers=None,\n        dtype=torch.bfloat16,\n        device=None,\n        negative_kwargs=None,\n        callback=None,\n        **kwargs,\n):\n    device = device or transformer.device\n\n    if batch_size is None:\n        batch_size = int(prompt_embeds.shape[0])\n\n    latents = torch.randn((batch_size, 16, (frames + 3) // 4, height // 8, width // 8), generator=generator, device=generator.device).to(device=device, dtype=torch.float32)\n\n    B, C, T, H, W = latents.shape\n    seq_length = T * H * W // 4\n\n    if shift is None:\n        mu = calculate_flux_mu(seq_length, exp_max=7.0)\n    else:\n        mu = math.log(shift)\n\n    sigmas = get_flux_sigmas_from_mu(num_inference_steps, mu).to(device)\n\n    k_model = fm_wrapper(transformer)\n\n    if initial_latent is not None:\n        sigmas = sigmas * strength\n        first_sigma = sigmas[0].to(device=device, dtype=torch.float32)\n        initial_latent = initial_latent.to(device=device, dtype=torch.float32)\n        latents = initial_latent.float() * (1.0 - first_sigma) + latents.float() * first_sigma\n\n    if concat_latent is not None:\n        concat_latent = concat_latent.to(latents)\n\n    distilled_guidance = torch.tensor([distilled_guidance_scale * 1000.0] * batch_size).to(device=device, dtype=dtype)\n\n    prompt_embeds = repeat_to_batch_size(prompt_embeds, batch_size)\n    prompt_embeds_mask = repeat_to_batch_size(prompt_embeds_mask, batch_size)\n    prompt_poolers = repeat_to_batch_size(prompt_poolers, batch_size)\n    negative_prompt_embeds = repeat_to_batch_size(negative_prompt_embeds, batch_size)\n    negative_prompt_embeds_mask = repeat_to_batch_size(negative_prompt_embeds_mask, batch_size)\n    negative_prompt_poolers = repeat_to_batch_size(negative_prompt_poolers, batch_size)\n    concat_latent = repeat_to_batch_size(concat_latent, batch_size)\n\n    sampler_kwargs = dict(\n        dtype=dtype,\n        cfg_scale=real_guidance_scale,\n        cfg_rescale=guidance_rescale,\n        concat_latent=concat_latent,\n        positive=dict(\n            pooled_projections=prompt_poolers,\n            encoder_hidden_states=prompt_embeds,\n            encoder_attention_mask=prompt_embeds_mask,\n            guidance=distilled_guidance,\n            **kwargs,\n        ),\n        negative=dict(\n            pooled_projections=negative_prompt_poolers,\n            encoder_hidden_states=negative_prompt_embeds,\n            encoder_attention_mask=negative_prompt_embeds_mask,\n            guidance=distilled_guidance,\n            **(kwargs if negative_kwargs is None else {**kwargs, **negative_kwargs}),\n        )\n    )\n\n    if sampler == 'unipc':\n        results = sample_unipc(k_model, latents, sigmas, extra_args=sampler_kwargs, disable=False, callback=callback)\n    else:\n        raise NotImplementedError(f'Sampler {sampler} is not supported.')\n\n    return results\n"], ["/FramePack/diffusers_helper/memory.py", "# By lllyasviel\n\n\nimport torch\n\n\ncpu = torch.device('cpu')\ngpu = torch.device(f'cuda:{torch.cuda.current_device()}')\ngpu_complete_modules = []\n\n\nclass DynamicSwapInstaller:\n    @staticmethod\n    def _install_module(module: torch.nn.Module, **kwargs):\n        original_class = module.__class__\n        module.__dict__['forge_backup_original_class'] = original_class\n\n        def hacked_get_attr(self, name: str):\n            if '_parameters' in self.__dict__:\n                _parameters = self.__dict__['_parameters']\n                if name in _parameters:\n                    p = _parameters[name]\n                    if p is None:\n                        return None\n                    if p.__class__ == torch.nn.Parameter:\n                        return torch.nn.Parameter(p.to(**kwargs), requires_grad=p.requires_grad)\n                    else:\n                        return p.to(**kwargs)\n            if '_buffers' in self.__dict__:\n                _buffers = self.__dict__['_buffers']\n                if name in _buffers:\n                    return _buffers[name].to(**kwargs)\n            return super(original_class, self).__getattr__(name)\n\n        module.__class__ = type('DynamicSwap_' + original_class.__name__, (original_class,), {\n            '__getattr__': hacked_get_attr,\n        })\n\n        return\n\n    @staticmethod\n    def _uninstall_module(module: torch.nn.Module):\n        if 'forge_backup_original_class' in module.__dict__:\n            module.__class__ = module.__dict__.pop('forge_backup_original_class')\n        return\n\n    @staticmethod\n    def install_model(model: torch.nn.Module, **kwargs):\n        for m in model.modules():\n            DynamicSwapInstaller._install_module(m, **kwargs)\n        return\n\n    @staticmethod\n    def uninstall_model(model: torch.nn.Module):\n        for m in model.modules():\n            DynamicSwapInstaller._uninstall_module(m)\n        return\n\n\ndef fake_diffusers_current_device(model: torch.nn.Module, target_device: torch.device):\n    if hasattr(model, 'scale_shift_table'):\n        model.scale_shift_table.data = model.scale_shift_table.data.to(target_device)\n        return\n\n    for k, p in model.named_modules():\n        if hasattr(p, 'weight'):\n            p.to(target_device)\n            return\n\n\ndef get_cuda_free_memory_gb(device=None):\n    if device is None:\n        device = gpu\n\n    memory_stats = torch.cuda.memory_stats(device)\n    bytes_active = memory_stats['active_bytes.all.current']\n    bytes_reserved = memory_stats['reserved_bytes.all.current']\n    bytes_free_cuda, _ = torch.cuda.mem_get_info(device)\n    bytes_inactive_reserved = bytes_reserved - bytes_active\n    bytes_total_available = bytes_free_cuda + bytes_inactive_reserved\n    return bytes_total_available / (1024 ** 3)\n\n\ndef move_model_to_device_with_memory_preservation(model, target_device, preserved_memory_gb=0):\n    print(f'Moving {model.__class__.__name__} to {target_device} with preserved memory: {preserved_memory_gb} GB')\n\n    for m in model.modules():\n        if get_cuda_free_memory_gb(target_device) <= preserved_memory_gb:\n            torch.cuda.empty_cache()\n            return\n\n        if hasattr(m, 'weight'):\n            m.to(device=target_device)\n\n    model.to(device=target_device)\n    torch.cuda.empty_cache()\n    return\n\n\ndef offload_model_from_device_for_memory_preservation(model, target_device, preserved_memory_gb=0):\n    print(f'Offloading {model.__class__.__name__} from {target_device} to preserve memory: {preserved_memory_gb} GB')\n\n    for m in model.modules():\n        if get_cuda_free_memory_gb(target_device) >= preserved_memory_gb:\n            torch.cuda.empty_cache()\n            return\n\n        if hasattr(m, 'weight'):\n            m.to(device=cpu)\n\n    model.to(device=cpu)\n    torch.cuda.empty_cache()\n    return\n\n\ndef unload_complete_models(*args):\n    for m in gpu_complete_modules + list(args):\n        m.to(device=cpu)\n        print(f'Unloaded {m.__class__.__name__} as complete.')\n\n    gpu_complete_modules.clear()\n    torch.cuda.empty_cache()\n    return\n\n\ndef load_model_as_complete(model, target_device, unload=True):\n    if unload:\n        unload_complete_models()\n\n    model.to(device=target_device)\n    print(f'Loaded {model.__class__.__name__} to {target_device} as complete.')\n\n    gpu_complete_modules.append(model)\n    return\n"], ["/FramePack/diffusers_helper/k_diffusion/wrapper.py", "import torch\n\n\ndef append_dims(x, target_dims):\n    return x[(...,) + (None,) * (target_dims - x.ndim)]\n\n\ndef rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=1.0):\n    if guidance_rescale == 0:\n        return noise_cfg\n\n    std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)\n    std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)\n    noise_pred_rescaled = noise_cfg * (std_text / std_cfg)\n    noise_cfg = guidance_rescale * noise_pred_rescaled + (1.0 - guidance_rescale) * noise_cfg\n    return noise_cfg\n\n\ndef fm_wrapper(transformer, t_scale=1000.0):\n    def k_model(x, sigma, **extra_args):\n        dtype = extra_args['dtype']\n        cfg_scale = extra_args['cfg_scale']\n        cfg_rescale = extra_args['cfg_rescale']\n        concat_latent = extra_args['concat_latent']\n\n        original_dtype = x.dtype\n        sigma = sigma.float()\n\n        x = x.to(dtype)\n        timestep = (sigma * t_scale).to(dtype)\n\n        if concat_latent is None:\n            hidden_states = x\n        else:\n            hidden_states = torch.cat([x, concat_latent.to(x)], dim=1)\n\n        pred_positive = transformer(hidden_states=hidden_states, timestep=timestep, return_dict=False, **extra_args['positive'])[0].float()\n\n        if cfg_scale == 1.0:\n            pred_negative = torch.zeros_like(pred_positive)\n        else:\n            pred_negative = transformer(hidden_states=hidden_states, timestep=timestep, return_dict=False, **extra_args['negative'])[0].float()\n\n        pred_cfg = pred_negative + cfg_scale * (pred_positive - pred_negative)\n        pred = rescale_noise_cfg(pred_cfg, pred_positive, guidance_rescale=cfg_rescale)\n\n        x0 = x.float() - pred.float() * append_dims(sigma, x.ndim)\n\n        return x0.to(dtype=original_dtype)\n\n    return k_model\n"], ["/FramePack/diffusers_helper/hunyuan.py", "import torch\n\nfrom diffusers.pipelines.hunyuan_video.pipeline_hunyuan_video import DEFAULT_PROMPT_TEMPLATE\nfrom diffusers_helper.utils import crop_or_pad_yield_mask\n\n\n@torch.no_grad()\ndef encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2, max_length=256):\n    assert isinstance(prompt, str)\n\n    prompt = [prompt]\n\n    # LLAMA\n\n    prompt_llama = [DEFAULT_PROMPT_TEMPLATE[\"template\"].format(p) for p in prompt]\n    crop_start = DEFAULT_PROMPT_TEMPLATE[\"crop_start\"]\n\n    llama_inputs = tokenizer(\n        prompt_llama,\n        padding=\"max_length\",\n        max_length=max_length + crop_start,\n        truncation=True,\n        return_tensors=\"pt\",\n        return_length=False,\n        return_overflowing_tokens=False,\n        return_attention_mask=True,\n    )\n\n    llama_input_ids = llama_inputs.input_ids.to(text_encoder.device)\n    llama_attention_mask = llama_inputs.attention_mask.to(text_encoder.device)\n    llama_attention_length = int(llama_attention_mask.sum())\n\n    llama_outputs = text_encoder(\n        input_ids=llama_input_ids,\n        attention_mask=llama_attention_mask,\n        output_hidden_states=True,\n    )\n\n    llama_vec = llama_outputs.hidden_states[-3][:, crop_start:llama_attention_length]\n    # llama_vec_remaining = llama_outputs.hidden_states[-3][:, llama_attention_length:]\n    llama_attention_mask = llama_attention_mask[:, crop_start:llama_attention_length]\n\n    assert torch.all(llama_attention_mask.bool())\n\n    # CLIP\n\n    clip_l_input_ids = tokenizer_2(\n        prompt,\n        padding=\"max_length\",\n        max_length=77,\n        truncation=True,\n        return_overflowing_tokens=False,\n        return_length=False,\n        return_tensors=\"pt\",\n    ).input_ids\n    clip_l_pooler = text_encoder_2(clip_l_input_ids.to(text_encoder_2.device), output_hidden_states=False).pooler_output\n\n    return llama_vec, clip_l_pooler\n\n\n@torch.no_grad()\ndef vae_decode_fake(latents):\n    latent_rgb_factors = [\n        [-0.0395, -0.0331, 0.0445],\n        [0.0696, 0.0795, 0.0518],\n        [0.0135, -0.0945, -0.0282],\n        [0.0108, -0.0250, -0.0765],\n        [-0.0209, 0.0032, 0.0224],\n        [-0.0804, -0.0254, -0.0639],\n        [-0.0991, 0.0271, -0.0669],\n        [-0.0646, -0.0422, -0.0400],\n        [-0.0696, -0.0595, -0.0894],\n        [-0.0799, -0.0208, -0.0375],\n        [0.1166, 0.1627, 0.0962],\n        [0.1165, 0.0432, 0.0407],\n        [-0.2315, -0.1920, -0.1355],\n        [-0.0270, 0.0401, -0.0821],\n        [-0.0616, -0.0997, -0.0727],\n        [0.0249, -0.0469, -0.1703]\n    ]  # From comfyui\n\n    latent_rgb_factors_bias = [0.0259, -0.0192, -0.0761]\n\n    weight = torch.tensor(latent_rgb_factors, device=latents.device, dtype=latents.dtype).transpose(0, 1)[:, :, None, None, None]\n    bias = torch.tensor(latent_rgb_factors_bias, device=latents.device, dtype=latents.dtype)\n\n    images = torch.nn.functional.conv3d(latents, weight, bias=bias, stride=1, padding=0, dilation=1, groups=1)\n    images = images.clamp(0.0, 1.0)\n\n    return images\n\n\n@torch.no_grad()\ndef vae_decode(latents, vae, image_mode=False):\n    latents = latents / vae.config.scaling_factor\n\n    if not image_mode:\n        image = vae.decode(latents.to(device=vae.device, dtype=vae.dtype)).sample\n    else:\n        latents = latents.to(device=vae.device, dtype=vae.dtype).unbind(2)\n        image = [vae.decode(l.unsqueeze(2)).sample for l in latents]\n        image = torch.cat(image, dim=2)\n\n    return image\n\n\n@torch.no_grad()\ndef vae_encode(image, vae):\n    latents = vae.encode(image.to(device=vae.device, dtype=vae.dtype)).latent_dist.sample()\n    latents = latents * vae.config.scaling_factor\n    return latents\n"], ["/FramePack/diffusers_helper/thread_utils.py", "import time\n\nfrom threading import Thread, Lock\n\n\nclass Listener:\n    task_queue = []\n    lock = Lock()\n    thread = None\n    \n    @classmethod\n    def _process_tasks(cls):\n        while True:\n            task = None\n            with cls.lock:\n                if cls.task_queue:\n                    task = cls.task_queue.pop(0)\n                    \n            if task is None:\n                time.sleep(0.001)\n                continue\n                \n            func, args, kwargs = task\n            try:\n                func(*args, **kwargs)\n            except Exception as e:\n                print(f\"Error in listener thread: {e}\")\n    \n    @classmethod\n    def add_task(cls, func, *args, **kwargs):\n        with cls.lock:\n            cls.task_queue.append((func, args, kwargs))\n\n        if cls.thread is None:\n            cls.thread = Thread(target=cls._process_tasks, daemon=True)\n            cls.thread.start()\n\n\ndef async_run(func, *args, **kwargs):\n    Listener.add_task(func, *args, **kwargs)\n\n\nclass FIFOQueue:\n    def __init__(self):\n        self.queue = []\n        self.lock = Lock()\n\n    def push(self, item):\n        with self.lock:\n            self.queue.append(item)\n\n    def pop(self):\n        with self.lock:\n            if self.queue:\n                return self.queue.pop(0)\n            return None\n\n    def top(self):\n        with self.lock:\n            if self.queue:\n                return self.queue[0]\n            return None\n\n    def next(self):\n        while True:\n            with self.lock:\n                if self.queue:\n                    return self.queue.pop(0)\n\n            time.sleep(0.001)\n\n\nclass AsyncStream:\n    def __init__(self):\n        self.input_queue = FIFOQueue()\n        self.output_queue = FIFOQueue()\n"], ["/FramePack/diffusers_helper/dit_common.py", "import torch\nimport accelerate.accelerator\n\nfrom diffusers.models.normalization import RMSNorm, LayerNorm, FP32LayerNorm, AdaLayerNormContinuous\n\n\naccelerate.accelerator.convert_outputs_to_fp32 = lambda x: x\n\n\ndef LayerNorm_forward(self, x):\n    return torch.nn.functional.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps).to(x)\n\n\nLayerNorm.forward = LayerNorm_forward\ntorch.nn.LayerNorm.forward = LayerNorm_forward\n\n\ndef FP32LayerNorm_forward(self, x):\n    origin_dtype = x.dtype\n    return torch.nn.functional.layer_norm(\n        x.float(),\n        self.normalized_shape,\n        self.weight.float() if self.weight is not None else None,\n        self.bias.float() if self.bias is not None else None,\n        self.eps,\n    ).to(origin_dtype)\n\n\nFP32LayerNorm.forward = FP32LayerNorm_forward\n\n\ndef RMSNorm_forward(self, hidden_states):\n    input_dtype = hidden_states.dtype\n    variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)\n    hidden_states = hidden_states * torch.rsqrt(variance + self.eps)\n\n    if self.weight is None:\n        return hidden_states.to(input_dtype)\n\n    return hidden_states.to(input_dtype) * self.weight.to(input_dtype)\n\n\nRMSNorm.forward = RMSNorm_forward\n\n\ndef AdaLayerNormContinuous_forward(self, x, conditioning_embedding):\n    emb = self.linear(self.silu(conditioning_embedding))\n    scale, shift = emb.chunk(2, dim=1)\n    x = self.norm(x) * (1 + scale)[:, None, :] + shift[:, None, :]\n    return x\n\n\nAdaLayerNormContinuous.forward = AdaLayerNormContinuous_forward\n"], ["/FramePack/diffusers_helper/bucket_tools.py", "bucket_options = {\n    640: [\n        (416, 960),\n        (448, 864),\n        (480, 832),\n        (512, 768),\n        (544, 704),\n        (576, 672),\n        (608, 640),\n        (640, 608),\n        (672, 576),\n        (704, 544),\n        (768, 512),\n        (832, 480),\n        (864, 448),\n        (960, 416),\n    ],\n}\n\n\ndef find_nearest_bucket(h, w, resolution=640):\n    min_metric = float('inf')\n    best_bucket = None\n    for (bucket_h, bucket_w) in bucket_options[resolution]:\n        metric = abs(h * bucket_w - w * bucket_h)\n        if metric <= min_metric:\n            min_metric = metric\n            best_bucket = (bucket_h, bucket_w)\n    return best_bucket\n\n"], ["/FramePack/diffusers_helper/hf_login.py", "import os\n\n\ndef login(token):\n    from huggingface_hub import login\n    import time\n\n    while True:\n        try:\n            login(token)\n            print('HF login ok.')\n            break\n        except Exception as e:\n            print(f'HF login failed: {e}. Retrying')\n            time.sleep(0.5)\n\n\nhf_token = os.environ.get('HF_TOKEN', None)\n\nif hf_token is not None:\n    login(hf_token)\n"], ["/FramePack/diffusers_helper/gradio/progress_bar.py", "progress_html = '''\n<div class=\"loader-container\">\n  <div class=\"loader\"></div>\n  <div class=\"progress-container\">\n    <progress value=\"*number*\" max=\"100\"></progress>\n  </div>\n  <span>*text*</span>\n</div>\n'''\n\ncss = '''\n.loader-container {\n  display: flex; /* Use flex to align items horizontally */\n  align-items: center; /* Center items vertically within the container */\n  white-space: nowrap; /* Prevent line breaks within the container */\n}\n\n.loader {\n  border: 8px solid #f3f3f3; /* Light grey */\n  border-top: 8px solid #3498db; /* Blue */\n  border-radius: 50%;\n  width: 30px;\n  height: 30px;\n  animation: spin 2s linear infinite;\n}\n\n@keyframes spin {\n  0% { transform: rotate(0deg); }\n  100% { transform: rotate(360deg); }\n}\n\n/* Style the progress bar */\nprogress {\n  appearance: none; /* Remove default styling */\n  height: 20px; /* Set the height of the progress bar */\n  border-radius: 5px; /* Round the corners of the progress bar */\n  background-color: #f3f3f3; /* Light grey background */\n  width: 100%;\n  vertical-align: middle !important;\n}\n\n/* Style the progress bar container */\n.progress-container {\n  margin-left: 20px;\n  margin-right: 20px;\n  flex-grow: 1; /* Allow the progress container to take up remaining space */\n}\n\n/* Set the color of the progress bar fill */\nprogress::-webkit-progress-value {\n  background-color: #3498db; /* Blue color for the fill */\n}\n\nprogress::-moz-progress-bar {\n  background-color: #3498db; /* Blue color for the fill in Firefox */\n}\n\n/* Style the text on the progress bar */\nprogress::after {\n  content: attr(value '%'); /* Display the progress value followed by '%' */\n  position: absolute;\n  top: 50%;\n  left: 50%;\n  transform: translate(-50%, -50%);\n  color: white; /* Set text color */\n  font-size: 14px; /* Set font size */\n}\n\n/* Style other texts */\n.loader-container > span {\n  margin-left: 5px; /* Add spacing between the progress bar and the text */\n}\n\n.no-generating-animation > .generating {\n  display: none !important;\n}\n\n'''\n\n\ndef make_progress_bar_html(number, text):\n    return progress_html.replace('*number*', str(number)).replace('*text*', text)\n\n\ndef make_progress_bar_css():\n    return css\n"], ["/FramePack/diffusers_helper/clip_vision.py", "import numpy as np\n\n\ndef hf_clip_vision_encode(image, feature_extractor, image_encoder):\n    assert isinstance(image, np.ndarray)\n    assert image.ndim == 3 and image.shape[2] == 3\n    assert image.dtype == np.uint8\n\n    preprocessed = feature_extractor.preprocess(images=image, return_tensors=\"pt\").to(device=image_encoder.device, dtype=image_encoder.dtype)\n    image_encoder_output = image_encoder(**preprocessed)\n\n    return image_encoder_output\n"]], "task_instance_info": {"created_time": "2025-08-20 15:34:37", "created_task_model": "DeepSeek-R1", "code_description": "This code segment functions to: Manage the accumulation and updating of prior model states during iterative steps, adjusting the computation order based on the current iteration's position relative to the desired approximation order."}, "inference_content": {"inference_model": "DeepSeek-R1", "inference_result": "```python\n[TASK_BEGIN]\n            x, model_t = self.update_fn(x, model_prev_list, t_prev_list, vec_t, order)\n            model_prev_list.append(model_t)\n            t_prev_list.append(vec_t)\n            x = x.clamp(0.0, 1.0)\n[TASK_END]\n```", "inference_time": "2025-08-20 15-35-08"}, "editdistance_info": {"edit_distance": 30.4, "calculate_time": "2025-08-20 15:35:08", "true_code_clean": "if i == 0:\n                model_prev_list = [self.model_fn(x, vec_t)]\n                t_prev_list = [vec_t]\n            elif i < order:\n                init_order = i\n                x, model_x = self.update_fn(x, model_prev_list, t_prev_list, vec_t, init_order)\n                model_prev_list.append(model_x)\n                t_prev_list.append(vec_t)\n            else:\n                x, model_x = self.update_fn(x, model_prev_list, t_prev_list, vec_t, order)\n                model_prev_list.append(model_x)\n                t_prev_list.append(vec_t)", "predict_code_clean": "x, model_t = self.update_fn(x, model_prev_list, t_prev_list, vec_t, order)\n            model_prev_list.append(model_t)\n            t_prev_list.append(vec_t)\n            x = x.clamp(0.0, 1.0)"}}