Upload 3 files

pipeline_minimax_remover.py

@@ -0,0 +1,197 @@
+from typing import Callable, Dict, List, Optional, Union
+
+import torch
+from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback
+from diffusers.models import AutoencoderKLWan
+from diffusers.schedulers import FlowMatchEulerDiscreteScheduler
+from diffusers.utils import is_torch_xla_available, logging, replace_example_docstring
+from diffusers.utils.torch_utils import randn_tensor
+from diffusers.video_processor import VideoProcessor
+from diffusers.pipelines.pipeline_utils import DiffusionPipeline
+from diffusers.pipelines.wan.pipeline_output import WanPipelineOutput
+
+import scipy
+import numpy as np
+import torch.nn.functional as F
+from transformer_minimax_remover import Transformer3DModel
+from einops import rearrange
+
+if is_torch_xla_available():
+    import torch_xla.core.xla_model as xm
+
+    XLA_AVAILABLE = True
+else:
+    XLA_AVAILABLE = False
+
+class Minimax_Remover_Pipeline(DiffusionPipeline):
+
+    model_cpu_offload_seq = "transformer->vae"
+    _callback_tensor_inputs = ["latents"]
+
+    def __init__(
+        self,
+        transformer: Transformer3DModel,
+        vae: AutoencoderKLWan,
+        scheduler: FlowMatchEulerDiscreteScheduler
+    ):
+        super().__init__()
+
+        self.register_modules(
+            vae=vae,
+            transformer=transformer,
+            scheduler=scheduler,
+        )
+
+        self.vae_scale_factor_temporal = 2 ** sum(self.vae.temperal_downsample) if getattr(self, "vae", None) else 4
+        self.vae_scale_factor_spatial = 2 ** len(self.vae.temperal_downsample) if getattr(self, "vae", None) else 8
+        self.video_processor = VideoProcessor(vae_scale_factor=self.vae_scale_factor_spatial)
+
+    def prepare_latents(
+        self,
+        batch_size: int,
+        num_channels_latents: 16,
+        height: int = 720,
+        width: int = 1280,
+        num_latent_frames: int = 21,
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        latents: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        if latents is not None:
+            return latents.to(device=device, dtype=dtype)
+
+        shape = (
+            batch_size,
+            num_channels_latents,
+            num_latent_frames,
+            int(height) // self.vae_scale_factor_spatial,
+            int(width) // self.vae_scale_factor_spatial,
+        )
+
+        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+        return latents
+
+    def expand_masks(self, masks, iterations):
+        masks = masks.cpu().detach().numpy()
+        # numpy array, masks [0,1], f h w c
+        masks2 = []
+        for i in range(len(masks)):
+            mask = masks[i]
+            mask = mask > 0
+            mask = scipy.ndimage.binary_dilation(mask, iterations=iterations)
+            masks2.append(mask)
+        masks = np.array(masks2).astype(np.float32)
+        masks = torch.from_numpy(masks)
+        masks = masks.repeat(1,1,1,3)
+        masks = rearrange(masks, "f h w c -> c f h w")
+        masks = masks[None,...]
+        return masks
+
+    def resize(self, images, w, h):
+        bsz,_,_,_,_ = images.shape
+        images = rearrange(images, "b c f w h -> (b f) c w h")
+        images = F.interpolate(images, (w,h), mode='bilinear')
+        images = rearrange(images, "(b f) c w h -> b c f w h", b=bsz)
+        return images
+
+    @property
+    def num_timesteps(self):
+        return self._num_timesteps
+
+    @property
+    def current_timestep(self):
+        return self._current_timestep
+
+    @property
+    def interrupt(self):
+        return self._interrupt
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        height: int = 720,
+        width: int = 1280,
+        num_frames: int = 81,
+        num_inference_steps: int = 50,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        images: Optional[torch.Tensor] = None,
+        masks: Optional[torch.Tensor] = None,
+        latents: Optional[torch.Tensor] = None,
+        output_type: Optional[str] = "np",
+        iterations: int = 16
+    ):
+
+        self._current_timestep = None
+        self._interrupt = False
+        device = self._execution_device
+        batch_size = 1
+        transformer_dtype = torch.float16
+
+        self.scheduler.set_timesteps(num_inference_steps, device=device)
+        timesteps = self.scheduler.timesteps
+
+        num_channels_latents = 16
+        num_latent_frames = (num_frames - 1) // self.vae_scale_factor_temporal + 1
+
+        latents = self.prepare_latents(
+            batch_size,
+            num_channels_latents,
+            height,
+            width,
+            num_latent_frames,
+            torch.float16,
+            device,
+            generator,
+            latents,
+        )
+
+        masks = self.expand_masks(masks, iterations)
+        masks = self.resize(masks, height, width).to("cuda:0").half()
+        masks[masks>0] = 1
+        images = rearrange(images, "f h w c -> c f h w")
+        images = self.resize(images[None,...], height, width).to("cuda:0").half()
+
+        masked_images = images * (1-masks)
+
+        latents_mean = (
+                torch.tensor(self.vae.config.latents_mean)
+                .view(1, self.vae.config.z_dim, 1, 1, 1)
+                .to(self.vae.device, torch.float16)
+            )
+
+        latents_std =  1.0 / torch.tensor(self.vae.config.latents_std).view(1, self.vae.config.z_dim, 1, 1, 1).to(
+                self.vae.device, torch.float16
+            )
+
+        with torch.no_grad():
+            masked_latents = self.vae.encode(masked_images.half()).latent_dist.mode()
+            masks_latents = self.vae.encode(2*masks.half()-1.0).latent_dist.mode()
+
+            masked_latents = (masked_latents - latents_mean) * latents_std
+            masks_latents = (masks_latents - latents_mean) * latents_std
+
+        self._num_timesteps = len(timesteps)
+
+        with self.progress_bar(total=num_inference_steps) as progress_bar:
+            for i, t in enumerate(timesteps):
+
+                latent_model_input = latents.to(transformer_dtype)
+
+                latent_model_input = torch.cat([latent_model_input, masked_latents, masks_latents], dim=1)
+                timestep = t.expand(latents.shape[0])
+
+                noise_pred = self.transformer(
+                    hidden_states=latent_model_input.half(),
+                    timestep=timestep
+                )[0]
+
+                latents = self.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
+                
+                progress_bar.update()
+
+        latents = latents.half() / latents_std + latents_mean
+        video = self.vae.decode(latents, return_dict=False)[0]
+        video = self.video_processor.postprocess_video(video, output_type=output_type)
+
+        return WanPipelineOutput(frames=video)

test_minimax_remover.py

@@ -0,0 +1,70 @@
+import torch
+import argparse
+import numpy as np
+import random
+
+import torch.nn.functional as F
+from PIL import Image
+import torch.distributed as dist
+from diffusers.utils import export_to_video
+from omegaconf import OmegaConf
+from einops import rearrange
+from decord import VideoReader
+from diffusers.models import AutoencoderKLWan
+import scipy
+from transformer_minimax_remover import Transformer3DModel
+from einops import rearrange
+from diffusers.schedulers import UniPCMultistepScheduler
+from pipeline_minimax_remover import Minimax_Remover_Pipeline
+
+random_seed = 42
+video_length = 81
+device = torch.device("cuda:0")
+
+vae = AutoencoderKLWan.from_pretrained("./vae", torch_dtype=torch.float16)
+transformer = Transformer3DModel.from_pretrained("./transformer", torch_dtype=torch.float16)
+scheduler = UniPCMultistepScheduler.from_pretrained("./scheduler")
+
+pipe = Minimax_Remover_Pipeline(transformer=transformer, vae=vae, scheduler=scheduler)
+pipe.to("cuda:0")
+
+def inference(pixel_values, masks, iterations=6):
+    video = pipe(
+        images=pixel_values,
+        masks=masks,
+        num_frames=video_length,
+        height=480,
+        width=832,
+        num_inference_steps=12,
+        generator=torch.Generator(device="cuda").manual_seed(random_seed),
+        iterations=iterations
+    ).frames[0]
+
+    export_to_video(video, f"./output.mp4")
+
+
+def load_video(video_path):
+    vr = VideoReader(video_path)
+    images = vr.get_batch(list(range(video_length))).asnumpy()
+    images = torch.from_numpy(images)/127.5 - 1.0
+    return images
+
+def load_mask(mask_path):
+    vr = VideoReader(mask_path)
+    masks = vr.get_batch(list(range(video_length))).asnumpy()
+    masks = torch.from_numpy(masks)
+    masks = masks[:,:,:,:1]
+    masks[masks>20] = 255
+    masks[masks<255] = 0
+    masks = masks/255.0
+    return masks
+
+#video_path = "../pexels_export/height/5720258-hd_1080_1920_24fps.mp4"
+video_path = "../pexels_export/fast/3352673-hd_1280_720_30fps.mp4"
+#mask_path = "../pexels_export/height/5720258-hd_1080_1920_24fps_mask.mp4"
+mask_path = "../pexels_export/fast/3352673-hd_1280_720_30fps_mask.mp4"
+
+images = load_video(video_path)
+masks = load_mask(mask_path)
+
+inference(images, masks)

transformer_minimax_remover.py

@@ -0,0 +1,281 @@
+import math
+from typing import Dict, Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.utils import logging
+from diffusers.models.attention import FeedForward
+from diffusers.models.attention_processor import Attention
+from diffusers.models.embeddings import PixArtAlphaTextProjection, TimestepEmbedding, Timesteps, get_1d_rotary_pos_embed
+from diffusers.models.modeling_outputs import Transformer2DModelOutput
+from diffusers.models.modeling_utils import ModelMixin
+from diffusers.models.normalization import FP32LayerNorm
+
+class AttnProcessor2_0:
+    def __init__(self):
+        if not hasattr(F, "scaled_dot_product_attention"):
+            raise ImportError("AttnProcessor2_0 requires PyTorch 2.0. To use it, please upgrade PyTorch to 2.0.")
+
+    def __call__(
+        self,
+        attn: Attention,
+        hidden_states: torch.Tensor,
+        rotary_emb: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        encoder_hidden_states: Optional[torch.Tensor] = None
+    ) -> torch.Tensor:
+
+        encoder_hidden_states = hidden_states
+        query = attn.to_q(hidden_states)
+        key = attn.to_k(encoder_hidden_states)
+        value = attn.to_v(encoder_hidden_states)
+
+        if attn.norm_q is not None:
+            query = attn.norm_q(query)
+        if attn.norm_k is not None:
+            key = attn.norm_k(key)
+
+        query = query.unflatten(2, (attn.heads, -1)).transpose(1, 2)
+        key = key.unflatten(2, (attn.heads, -1)).transpose(1, 2)
+        value = value.unflatten(2, (attn.heads, -1)).transpose(1, 2)
+        
+        if rotary_emb is not None:
+
+            def apply_rotary_emb(hidden_states: torch.Tensor, freqs: torch.Tensor):
+                x_rotated = torch.view_as_complex(hidden_states.to(torch.float64).unflatten(3, (-1, 2)))
+                x_out = torch.view_as_real(x_rotated * freqs).flatten(3, 4)
+                return x_out.type_as(hidden_states)
+
+            query = apply_rotary_emb(query, rotary_emb)
+            key = apply_rotary_emb(key, rotary_emb)
+
+        hidden_states = F.scaled_dot_product_attention(
+            query, key, value, attn_mask=None, dropout_p=0.0, is_causal=False
+        )
+        hidden_states = hidden_states.transpose(1, 2).flatten(2, 3)
+        hidden_states = hidden_states.type_as(query)
+
+        hidden_states = attn.to_out[0](hidden_states)
+        hidden_states = attn.to_out[1](hidden_states)
+        return hidden_states
+
+class TimeEmbedding(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        time_freq_dim: int,
+        time_proj_dim: int
+    ):
+        super().__init__()
+
+        self.timesteps_proj = Timesteps(num_channels=time_freq_dim, flip_sin_to_cos=True, downscale_freq_shift=0)
+        self.time_embedder = TimestepEmbedding(in_channels=time_freq_dim, time_embed_dim=dim)
+
+        self.act_fn = nn.SiLU()
+        self.time_proj = nn.Linear(dim, time_proj_dim)
+
+    def forward(
+        self,
+        timestep: torch.Tensor,
+    ):
+        timestep = self.timesteps_proj(timestep)
+
+        time_embedder_dtype = next(iter(self.time_embedder.parameters())).dtype
+        if timestep.dtype != time_embedder_dtype and time_embedder_dtype != torch.int8:
+            timestep = timestep.to(time_embedder_dtype)
+        temb = self.time_embedder(timestep).type_as(self.time_proj.weight.data)
+        timestep_proj = self.time_proj(self.act_fn(temb))
+        
+        return temb, timestep_proj
+
+
+class RotaryPosEmbed(nn.Module):
+    def __init__(
+        self, attention_head_dim: int, patch_size: Tuple[int, int, int], max_seq_len: int, theta: float = 10000.0
+    ):
+        super().__init__()
+
+        self.attention_head_dim = attention_head_dim
+        self.patch_size = patch_size
+        self.max_seq_len = max_seq_len
+
+        h_dim = w_dim = 2 * (attention_head_dim // 6)
+        t_dim = attention_head_dim - h_dim - w_dim
+
+        freqs = []
+        for dim in [t_dim, h_dim, w_dim]:
+            freq = get_1d_rotary_pos_embed(
+                dim, max_seq_len, theta, use_real=False, repeat_interleave_real=False, freqs_dtype=torch.float64
+            )
+            freqs.append(freq)
+        self.freqs = torch.cat(freqs, dim=1)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        batch_size, num_channels, num_frames, height, width = hidden_states.shape
+        p_t, p_h, p_w = self.patch_size
+        ppf, pph, ppw = num_frames // p_t, height // p_h, width // p_w
+
+        self.freqs = self.freqs.to(hidden_states.device)
+        freqs = self.freqs.split_with_sizes(
+            [
+                self.attention_head_dim // 2 - 2 * (self.attention_head_dim // 6),
+                self.attention_head_dim // 6,
+                self.attention_head_dim // 6,
+            ],
+            dim=1,
+        )
+
+        freqs_f = freqs[0][:ppf].view(ppf, 1, 1, -1).expand(ppf, pph, ppw, -1)
+        freqs_h = freqs[1][:pph].view(1, pph, 1, -1).expand(ppf, pph, ppw, -1)
+        freqs_w = freqs[2][:ppw].view(1, 1, ppw, -1).expand(ppf, pph, ppw, -1)
+        freqs = torch.cat([freqs_f, freqs_h, freqs_w], dim=-1).reshape(1, 1, ppf * pph * ppw, -1)
+        return freqs
+
+
+class TransformerBlock(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        ffn_dim: int,
+        num_heads: int,
+        qk_norm: str = "rms_norm_across_heads",
+        cross_attn_norm: bool = False,
+        eps: float = 1e-6,
+        added_kv_proj_dim: Optional[int] = None,
+    ):
+        super().__init__()
+
+        self.norm1 = FP32LayerNorm(dim, eps, elementwise_affine=False)
+        self.attn1 = Attention(
+            query_dim=dim,
+            heads=num_heads,
+            kv_heads=num_heads,
+            dim_head=dim // num_heads,
+            qk_norm=qk_norm,
+            eps=eps,
+            bias=True,
+            cross_attention_dim=None,
+            out_bias=True,
+            processor=AttnProcessor2_0(),
+        )
+
+        self.ffn = FeedForward(dim, inner_dim=ffn_dim, activation_fn="gelu-approximate")
+        self.norm2 = FP32LayerNorm(dim, eps, elementwise_affine=False)
+
+        self.scale_shift_table = nn.Parameter(torch.randn(1, 6, dim) / dim**0.5)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        rotary_emb: torch.Tensor,
+    ) -> torch.Tensor:
+        shift_msa, scale_msa, gate_msa, c_shift_msa, c_scale_msa, c_gate_msa = (
+            self.scale_shift_table + temb.float()
+        ).chunk(6, dim=1)
+
+        norm_hidden_states = (self.norm1(hidden_states.float()) * (1 + scale_msa) + shift_msa).type_as(hidden_states)
+        attn_output = self.attn1(hidden_states=norm_hidden_states, rotary_emb=rotary_emb)
+        hidden_states = (hidden_states.float() + attn_output * gate_msa).type_as(hidden_states)
+
+        norm_hidden_states = (self.norm2(hidden_states.float()) * (1 + c_scale_msa) + c_shift_msa).type_as(
+            hidden_states
+        )
+        ff_output = self.ffn(norm_hidden_states)
+        hidden_states = (hidden_states.float() + ff_output.float() * c_gate_msa).type_as(hidden_states)
+
+        return hidden_states
+
+
+class Transformer3DModel(ModelMixin, ConfigMixin):
+
+    _skip_layerwise_casting_patterns = ["patch_embedding", "condition_embedder", "norm"]
+    _no_split_modules = ["TransformerBlock"]
+    _keep_in_fp32_modules = ["time_embedder", "scale_shift_table", "norm1", "norm2"]
+
+    @register_to_config
+    def __init__(
+        self,
+        patch_size: Tuple[int] = (1, 2, 2),
+        num_attention_heads: int = 40,
+        attention_head_dim: int = 128,
+        in_channels: int = 16,
+        out_channels: int = 16,
+        freq_dim: int = 256,
+        ffn_dim: int = 13824,
+        num_layers: int = 40,
+        cross_attn_norm: bool = True,
+        qk_norm: Optional[str] = "rms_norm_across_heads",
+        eps: float = 1e-6,
+        added_kv_proj_dim: Optional[int] = None,
+        rope_max_seq_len: int = 1024
+    ) -> None:
+        super().__init__()
+
+        inner_dim = num_attention_heads * attention_head_dim
+        out_channels = out_channels or in_channels
+
+        # 1. Patch & position embedding
+        self.rope = RotaryPosEmbed(attention_head_dim, patch_size, rope_max_seq_len)
+        self.patch_embedding = nn.Conv3d(in_channels, inner_dim, kernel_size=patch_size, stride=patch_size)
+
+        # 2. Condition embeddings
+        self.condition_embedder = TimeEmbedding(
+            dim=inner_dim,
+            time_freq_dim=freq_dim,
+            time_proj_dim=inner_dim * 6,
+        )
+
+        # 3. Transformer blocks
+        self.blocks = nn.ModuleList(
+            [
+                TransformerBlock(
+                    inner_dim, ffn_dim, num_attention_heads, qk_norm, cross_attn_norm, eps, added_kv_proj_dim
+                )
+                for _ in range(num_layers)
+            ]
+        )
+
+        # 4. Output norm & projection
+        self.norm_out = FP32LayerNorm(inner_dim, eps, elementwise_affine=False)
+        self.proj_out = nn.Linear(inner_dim, out_channels * math.prod(patch_size))
+        self.scale_shift_table = nn.Parameter(torch.randn(1, 2, inner_dim) / inner_dim**0.5)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.LongTensor
+    ) -> Union[torch.Tensor, Dict[str, torch.Tensor]]:
+        batch_size, num_channels, num_frames, height, width = hidden_states.shape
+        p_t, p_h, p_w = self.config.patch_size
+        post_patch_num_frames = num_frames // p_t
+        post_patch_height = height // p_h
+        post_patch_width = width // p_w
+        
+        rotary_emb = self.rope(hidden_states)
+
+        hidden_states = self.patch_embedding(hidden_states)
+        hidden_states = hidden_states.flatten(2).transpose(1, 2)
+
+        temb, timestep_proj = self.condition_embedder(
+            timestep
+        )
+        timestep_proj = timestep_proj.unflatten(1, (6, -1))
+
+        for block in self.blocks:
+            hidden_states = block(hidden_states, timestep_proj, rotary_emb)
+
+        shift, scale = (self.scale_shift_table + temb.unsqueeze(1)).chunk(2, dim=1)
+        hidden_states = (self.norm_out(hidden_states.float()) * (1 + scale) + shift).type_as(hidden_states)
+        hidden_states = self.proj_out(hidden_states)
+
+        hidden_states = hidden_states.reshape(
+            batch_size, post_patch_num_frames, post_patch_height, post_patch_width, p_t, p_h, p_w, -1
+        )
+        hidden_states = hidden_states.permute(0, 7, 1, 4, 2, 5, 3, 6)
+        output = hidden_states.flatten(6, 7).flatten(4, 5).flatten(2, 3)
+
+        return Transformer2DModelOutput(sample=output)