demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6bed43ce-5923-4e21-9362-4fd97480486f",
   "metadata": {},
   "source": [
    "# Import libraries and set up utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a4fb194-fc04-4447-8c72-d6a02edb320e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"8\" #restrict CUDA visibility\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import random\n",
    "import math\n",
    "from PIL import Image\n",
    "import torch\n",
    "from matplotlib import pyplot as plt\n",
    "import torch.nn.functional as F\n",
    "from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection\n",
    "from diffusers import StableVideoDiffusionPipeline, AutoencoderKLTemporalDecoder, UNetSpatioTemporalConditionModel, EulerDiscreteScheduler\n",
    "from diffusers.pipelines.stable_video_diffusion import StableVideoDiffusionPipelineOutput\n",
    "from diffusers.models.unets.unet_spatio_temporal_condition import UNetSpatioTemporalConditionOutput\n",
    "from diffusers.utils.torch_utils import randn_tensor\n",
    "from diffusers.pipelines.stable_video_diffusion.pipeline_stable_video_diffusion import _append_dims\n",
    "from IPython.display import HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5355586b-7968-48e5-898e-859313ac0412",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Define utils function\n",
    "\"\"\"\n",
    "\n",
    "def export_to_gif(\n",
    "    video_frames, save_path\n",
    "):\n",
    "    \"\"\"\n",
    "    write to gif\n",
    "    \"\"\"\n",
    "    if isinstance(video_frames[0], np.ndarray):\n",
    "        video_frames = [(frame * 255).astype(np.uint8) for frame in video_frames]\n",
    "    elif isinstance(video_frames[0], PIL.Image.Image):\n",
    "        video_frames = [np.array(frame) for frame in video_frames]\n",
    "    for i in range(len(video_frames)):\n",
    "        video_frames[i] = Image.fromarray(video_frames[i])\n",
    "    video_frames[0].save(save_path, save_all=True, append_images=video_frames[1:], loop=0, duration=110)\n",
    "    return video_frames\n",
    "\n",
    "def requires_grad(model, flag=True):\n",
    "    for p in model.parameters():\n",
    "        p.requires_grad = flag\n",
    "def tensor2vid(video, processor, output_type: str = \"np\"):\n",
    "    #ref: https://github.com/huggingface/diffusers/blob/687bc2772721af584d649129f8d2a28ca56a9ad8/src/diffusers/pipelines/stable_video_diffusion/pipeline_stable_video_diffusion.py#L61C1-L79C19\n",
    "    batch_size, channels, num_frames, height, width = video.shape\n",
    "    outputs = []\n",
    "    for batch_idx in range(batch_size):\n",
    "        batch_vid = video[batch_idx].permute(1, 0, 2, 3)\n",
    "        batch_output = processor.postprocess(batch_vid, output_type)\n",
    "        outputs.append(batch_output)\n",
    "    if output_type == \"np\":\n",
    "        outputs = np.stack(outputs)\n",
    "    elif output_type == \"pt\":\n",
    "        outputs = torch.stack(outputs)\n",
    "    elif not output_type == \"pil\":\n",
    "        raise ValueError(f\"{output_type} does not exist. Please choose one of ['np', 'pt', 'pil]\")    \n",
    "    return outputs\n",
    "def visualize_control(image, trajectory_points):\n",
    "    scale_factor = 1.5\n",
    "    image = np.array(image)\n",
    "    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)\n",
    "    for i in range(len(trajectory_points)):\n",
    "        frames = len(trajectory_points[i])\n",
    "        for j in range(frames):\n",
    "            source_point = trajectory_points[i][j]\n",
    "            sx, sy, tx, ty = source_point[0], source_point[1], source_point[2], source_point[3]\n",
    "            if j==0:\n",
    "                image2 = cv2.rectangle(image.copy(), (int(sy), int(sx)), (int(ty), int(tx)), (69, 27, 255), thickness=-1)\n",
    "                image = cv2.rectangle(image, (int(sy), int(sx)), (int(ty), int(tx)), (0, 0, 255), thickness=6)\n",
    "                image2 = cv2.rectangle(image2, (int(sy), int(sx)), (int(ty), int(tx)), (0, 0, 255), thickness=6)\n",
    "                image = cv2.addWeighted(image,0.4,image2,0.6,0)\n",
    "            if j + 1 < frames:\n",
    "                target_point = trajectory_points[i][j+1]\n",
    "                sx2, sy2, tx2, ty2 = target_point[0], target_point[1], target_point[2], target_point[3]\n",
    "                sx3 = (sx+tx)//2\n",
    "                tx3 = (sx2+tx2)//2\n",
    "                sy3 = (sy+ty)//2\n",
    "                ty3 = (sy2+ty2)//2\n",
    "                arrow_length = np.sqrt((sx3-tx3)**2 + (sy3-ty3)**2)\n",
    "                green = (0,255,0)\n",
    "                if j + 2 == frames:\n",
    "                    image = cv2.line(image, (int(sy3), int(sx3)), (int(ty3), int(tx3)), green, thickness = int(12*scale_factor))\n",
    "                    image = cv2.circle(image, (int(ty3), int(tx3)), radius = int(15*scale_factor), color = green, thickness = -1)\n",
    "                    #image = cv2.arrowedLine(image, (int(sy3), int(sx3)), (int(ty3), int(tx3)), green, 12, tipLength=2) #8/arrow_length)\n",
    "                else:\n",
    "                    image = cv2.line(image, (int(sy3), int(sx3)), (int(ty3), int(tx3)), green, thickness = int(12*scale_factor)) \n",
    "    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "    plt.imshow(image)\n",
    "    plt.show()\n",
    "def butterworth_low_pass_filter(latents, n=4, d_s=0.25):\n",
    "    \"\"\"\n",
    "    Return the butterworth low pass filter mask.\n",
    "    Modified from https://github.com/arthur-qiu/FreeTraj/blob/0b3ffdb932bba01ba707d689f4905c31b193468b/utils/utils_freetraj.py#L228\n",
    "    \"\"\"\n",
    "    shape = latents.shape\n",
    "    H, W = shape[-2], shape[-1]\n",
    "    mask = torch.zeros_like(latents)\n",
    "    if d_s==0:\n",
    "        return mask\n",
    "    for h in range(H):\n",
    "        for w in range(W):\n",
    "            d_square = ((2*h/H-1)**2 + (2*w/W-1)**2)\n",
    "            mask[..., h,w] = 1 / (1 + (d_square / d_s**2)**n)\n",
    "    return mask"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c76f2a08-680a-44a1-b51d-6b4020688d55",
   "metadata": {},
   "source": [
    "# Define denoising network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e86f1c9f-61b6-4cb1-bee1-dc6f327a0fbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Define denoising network (UNet)\n",
    "\"\"\"\n",
    "\n",
    "class MyUNet(UNetSpatioTemporalConditionModel):\n",
    "    \"\"\"\n",
    "    Modified from SVD implementation\n",
    "    https://github.com/huggingface/diffusers/blob/24c7d578baf6a8b79890101dd280278fff031d12/src/diffusers/models/unets/unet_spatio_temporal_condition.py#L32\n",
    "    \"\"\"\n",
    "    def inject(self):\n",
    "        #Replace self-attention blocks in the upsampling layers with our implementation\n",
    "        for (layer, upsample_block) in enumerate(self.up_blocks):\n",
    "            if layer == 0: \n",
    "                continue\n",
    "            for (sublayer, trans) in enumerate(upsample_block.attentions):\n",
    "                basictrans = trans.transformer_blocks[0] #BasicTransformerBlock\n",
    "                basictrans.attn1.processor = self.my_self_attention(layer, sublayer)\n",
    "\n",
    "    record_value_ = []\n",
    "    \n",
    "    def forward(\n",
    "        self,\n",
    "        sample,\n",
    "        timestep,\n",
    "        encoder_hidden_states,\n",
    "        added_time_ids,\n",
    "        return_dict: bool = True,\n",
    "    ):\n",
    "        #Modified from the original implementation such that it cuts redundant computation during the optimization\n",
    "        timesteps = timestep\n",
    "        if not torch.is_tensor(timesteps):\n",
    "            is_mps = False\n",
    "            if isinstance(timestep, float):\n",
    "                dtype = torch.float32 if is_mps else torch.float64\n",
    "            else:\n",
    "                dtype = torch.int32 if is_mps else torch.int64\n",
    "            timesteps = torch.tensor([timesteps], dtype=dtype, device=sample.device)\n",
    "        elif len(timesteps.shape) == 0:\n",
    "            timesteps = timesteps[None].to(sample.device)\n",
    "        batch_size, num_frames = sample.shape[:2]\n",
    "        timesteps = timesteps.expand(batch_size)\n",
    "        t_emb = self.time_proj(timesteps)\n",
    "        t_emb = t_emb.to(dtype=sample.dtype)\n",
    "        emb = self.time_embedding(t_emb)\n",
    "        time_embeds = self.add_time_proj(added_time_ids.flatten())\n",
    "        time_embeds = time_embeds.reshape((batch_size, -1))\n",
    "        time_embeds = time_embeds.to(emb.dtype)\n",
    "        aug_emb = self.add_embedding(time_embeds)\n",
    "        emb = emb + aug_emb\n",
    "        sample = sample.flatten(0, 1)\n",
    "        emb = emb.repeat_interleave(num_frames, dim=0)\n",
    "        encoder_hidden_states = encoder_hidden_states.repeat_interleave(num_frames, dim=0)\n",
    "        sample = self.conv_in(sample)\n",
    "        image_only_indicator = torch.zeros(batch_size, num_frames, dtype=sample.dtype, device=sample.device)\n",
    "        down_block_res_samples = (sample,)\n",
    "        for layer, downsample_block in enumerate(self.down_blocks):\n",
    "            if hasattr(downsample_block, \"has_cross_attention\") and downsample_block.has_cross_attention:\n",
    "                sample, res_samples = downsample_block(\n",
    "                    hidden_states=sample,\n",
    "                    temb=emb,\n",
    "                    encoder_hidden_states=encoder_hidden_states,\n",
    "                    image_only_indicator=image_only_indicator,\n",
    "                )\n",
    "            else:\n",
    "                sample, res_samples = downsample_block(\n",
    "                    hidden_states=sample,\n",
    "                    temb=emb,\n",
    "                    image_only_indicator=image_only_indicator,\n",
    "                )\n",
    "\n",
    "            down_block_res_samples += res_samples\n",
    "        sample = self.mid_block(\n",
    "            hidden_states=sample,\n",
    "            temb=emb,\n",
    "            encoder_hidden_states=encoder_hidden_states,\n",
    "            image_only_indicator=image_only_indicator,\n",
    "        )\n",
    "        for i, upsample_block in enumerate(self.up_blocks):\n",
    "            if self.training and i > max(self.record_layer_sublayer)[0]:\n",
    "                return None #skip redundant computation during optimization\n",
    "            res_samples = down_block_res_samples[-len(upsample_block.resnets) :]\n",
    "            down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]\n",
    "            if hasattr(upsample_block, \"has_cross_attention\") and upsample_block.has_cross_attention:\n",
    "                sample = upsample_block(\n",
    "                    hidden_states=sample,\n",
    "                    temb=emb,\n",
    "                    res_hidden_states_tuple=res_samples,\n",
    "                    encoder_hidden_states=encoder_hidden_states,\n",
    "                    image_only_indicator=image_only_indicator,\n",
    "                )\n",
    "            else:\n",
    "                sample = upsample_block(\n",
    "                    hidden_states=sample,\n",
    "                    temb=emb,\n",
    "                    res_hidden_states_tuple=res_samples,\n",
    "                    image_only_indicator=image_only_indicator,\n",
    "                )\n",
    "        if self.training:\n",
    "            return None #skip redundant computation during optimization\n",
    "        sample = self.conv_norm_out(sample)\n",
    "        sample = self.conv_act(sample)\n",
    "        sample = self.conv_out(sample)\n",
    "        sample = sample.reshape(batch_size, num_frames, *sample.shape[1:])\n",
    "        if not return_dict:\n",
    "            return (sample,)\n",
    "        return UNetSpatioTemporalConditionOutput(sample=sample)\n",
    "    \n",
    "    def my_self_attention(self, layer, sublayer):\n",
    "        compress_factor = [None, 4, 2, 1][layer]\n",
    "        #Modified from the original implementation so that we can record semantically aligned feature maps during the optimization\n",
    "        def processor(\n",
    "            attn,\n",
    "            hidden_states,\n",
    "            encoder_hidden_states = None,\n",
    "            attention_mask = None,\n",
    "            temb = None,\n",
    "        ):\n",
    "            residual = hidden_states\n",
    "\n",
    "            h = self.latent_shape[-2]//compress_factor\n",
    "            w = self.latent_shape[-1]//compress_factor\n",
    "            \n",
    "            input_ndim = hidden_states.ndim\n",
    "            batch_size, sequence_length, _ = (\n",
    "                hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape\n",
    "            )\n",
    "            query = attn.to_q(hidden_states)\n",
    "            if encoder_hidden_states is None:\n",
    "                encoder_hidden_states = hidden_states\n",
    "            key = attn.to_k(encoder_hidden_states)\n",
    "            value = attn.to_v(encoder_hidden_states)\n",
    "            inner_dim = key.shape[-1]\n",
    "            head_dim = inner_dim // attn.heads\n",
    "            query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)\n",
    "            key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)\n",
    "            value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)\n",
    "            \n",
    "            if self.training and ((layer, sublayer) in self.record_layer_sublayer):\n",
    "                #Modified self-attention computation\n",
    "                #inject key and value from the first frame to obtain semantically aligned fieature maps\n",
    "                frame = query.shape[0]\n",
    "                key2 = (key.reshape((1, frame)+key.shape[1:]))[:,:1].repeat((1,frame,1,1,1)).reshape(key.shape)\n",
    "                value2 = (value.reshape((1, frame)+value.shape[1:]))[:,:1].repeat((1,frame,1,1,1)).reshape(value.shape)\n",
    "\n",
    "                hidden_states = F.scaled_dot_product_attention(query, key2.clone().detach(), value2.clone().detach(), attn_mask=None, dropout_p=0.0, is_causal=False)\n",
    "                hid = hidden_states.permute((0, 2, 1, 3)) #(2*batch, h*w, head, channel)\n",
    "                hid = hid.reshape((hid.shape[0], h, w, -1))\n",
    "                self.record_value_.append(hid)\n",
    "            \n",
    "            hidden_states = F.scaled_dot_product_attention(\n",
    "                    query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False\n",
    "            )\n",
    "            hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)\n",
    "            hidden_states = hidden_states.to(query.dtype)\n",
    "            hidden_states = attn.to_out[0](hidden_states)\n",
    "            hidden_states = attn.to_out[1](hidden_states)\n",
    "            hidden_states = hidden_states / attn.rescale_output_factor\n",
    "            return hidden_states\n",
    "        return processor"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c4ad990-b123-4d95-9d2a-e9daf5765d9f",
   "metadata": {},
   "source": [
    "# Define pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9c8aa6af-40e8-40ce-aa0f-e7ca2b409424",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Define Pipeline\n",
    "\"\"\"\n",
    "\n",
    "class SGI2VPipe(StableVideoDiffusionPipeline):\n",
    "    \"\"\"\n",
    "    Modified from the original SVD pipeline\n",
    "    ref: https://github.com/huggingface/diffusers/blob/24c7d578baf6a8b79890101dd280278fff031d12/src/diffusers/pipelines/stable_video_diffusion/pipeline_stable_video_diffusion.py#L139\n",
    "    \"\"\"\n",
    "    heatmap = {}\n",
    "    def get_gaussian_heatmap(self, h, w):\n",
    "        \"\"\"\n",
    "        Generate gaussian heatmap\n",
    "        Modified from https://github.com/showlab/DragAnything/blob/main/demo.py#L380\n",
    "        \"\"\"\n",
    "        if (h,w) in self.heatmap:\n",
    "            isotropicGrayscaleImage = self.heatmap[(h,w)]\n",
    "        else:\n",
    "            sigy = self.unet.heatmap_sigma*(h/2)\n",
    "            sigx = self.unet.heatmap_sigma*(w/2)\n",
    "\n",
    "            cx = w/2\n",
    "            cy = h/2\n",
    "            isotropicGrayscaleImage = np.zeros((h, w), np.float32)\n",
    "            for y in range(h):\n",
    "                for x in range(w):\n",
    "                    isotropicGrayscaleImage[y, x] = 1 / 2 / np.pi / (sigx*sigy) * np.exp(\n",
    "                        -1 / 2 * ((x+0.5 - cx) ** 2 / (sigx ** 2) + (y+0.5 - cy) ** 2 / (sigy ** 2)))\n",
    "            isotropicGrayscaleImage = (isotropicGrayscaleImage / np.max(isotropicGrayscaleImage)).astype(np.float32)\n",
    "            self.heatmap[(h,w)] = isotropicGrayscaleImage\n",
    "        return torch.from_numpy(isotropicGrayscaleImage).cuda()\n",
    "    \n",
    "    def optimize_latent(self, latents, trajectory_points, t, image_latents, image_embeddings, added_time_ids):\n",
    "        \"\"\"\n",
    "        trajectory_points : N x frames x 4 (i.e. upper-left and bottom-right corners of bounding box : sx,sy,tx,ty)\n",
    "        \"\"\"\n",
    "        original_latents = latents.clone().detach()\n",
    "        \n",
    "        if self.unet.optimize_latent_iter > 0: \n",
    "            self.unet = self.unet.to(dtype=torch.float32)\n",
    "            self.unet.enable_gradient_checkpointing()\n",
    "            self.unet.train(True)\n",
    "            latents = latents.to(dtype=torch.float32)\n",
    "            image_latents = image_latents.to(dtype=torch.float32)\n",
    "            image_embeddings = image_embeddings.to(dtype=torch.float32)\n",
    "            added_time_ids = added_time_ids.to(dtype=torch.float32)\n",
    "            t = t.to(dtype=torch.float32)\n",
    "            \n",
    "            with torch.enable_grad():\n",
    "                latents = latents.clone().detach().requires_grad_(True)        \n",
    "                optimizer = None \n",
    "                scaler = torch.cuda.amp.GradScaler()\n",
    "                target_features = [None]*len(trajectory_points)\n",
    "                \n",
    "                for iter in range(self.unet.optimize_latent_iter):\n",
    "                    \n",
    "                    latent_model_input = self.scheduler.scale_model_input(latents, t)\n",
    "                    latent_model_input = torch.cat([latent_model_input, image_latents], dim=2)\n",
    "\n",
    "                    self.unet.record_value_ = []\n",
    "                    with torch.autocast(device_type = \"cuda\", dtype=torch.float16):\n",
    "                        self.unet(latent_model_input,t,encoder_hidden_states=image_embeddings,added_time_ids=added_time_ids,return_dict=False)\n",
    "                    \n",
    "                    features = [] #list([frame, h, w, feature])\n",
    "\n",
    "                    #Upsample recorded feature maps to the latent size\n",
    "                    h, w = (self.unet.latent_shape[-2], self.unet.latent_shape[-1])\n",
    "                    for i in range(len(self.unet.record_value_)):\n",
    "                        fet = self.unet.record_value_[i].to(dtype=torch.float32).permute((0,3,1,2)) #[frame, feature, h, w]\n",
    "                        fet = F.interpolate(fet, size=(h,w), mode=\"bilinear\")\n",
    "                        features.append(fet.permute((0,2,3,1)))\n",
    "\n",
    "                    feature = torch.cat(features, dim=-1) #[frames, h, w, features]\n",
    "                    \n",
    "                    self.unet.record_value_ = []\n",
    "                        \n",
    "                    compress_factor = 8*self.unet.latent_shape[-2]//h\n",
    "                        \n",
    "                    frames = features[0].shape[0]\n",
    "                        \n",
    "                    loss = 0\n",
    "                    loss_cnt = 0\n",
    "                    \n",
    "                    for j in range(frames):\n",
    "                        #iterate over each control point\n",
    "                        for point_idx in range(len(trajectory_points)):  \n",
    "                            cur_point = (trajectory_points[point_idx][j]//compress_factor).astype(np.int32)\n",
    "                            \n",
    "                            sx, sy = cur_point[0], cur_point[1]\n",
    "                            tx, ty = max(sx+1, cur_point[2]), max(sy+1, cur_point[3])\n",
    "                            \n",
    "                            #boundary check\n",
    "                            sx_, sy_, tx_, ty_ = max(sx, 0), max(sy, 0), min(tx, feature.shape[1]), min(ty, feature.shape[2])\n",
    "                            \n",
    "                            #compute offset\n",
    "                            osx, osy, otx, oty  = sx_ - sx, sy_ - sy, tx_ - sx, ty_ - sy\n",
    "\n",
    "                            if sx_ >= tx_ or sy_ >= ty_:\n",
    "                                #trajectory point goes beyond the image boundary\n",
    "                                if j==0:\n",
    "                                    print(\"Invalid trajectory, the initial boundaing box should not go beyond image boundary!!\")\n",
    "                                    exit(1)\n",
    "                                continue\n",
    "                            \n",
    "                            if j == 0:\n",
    "                                #Record feature maps of the first frame\n",
    "                                target_features[point_idx] = feature[0,sx:tx,sy:ty].clone().detach().requires_grad_(False)\n",
    "                            \n",
    "                            #Compute loss\n",
    "                            if j > 0:\n",
    "                                    target = target_features[point_idx].unsqueeze(0) #[1, h, w, feature]\n",
    "                                    target = F.interpolate(target.permute((0,3,1,2)),size=(tx-sx, ty-sy), mode=\"bilinear\") #[1,feature,h,w]\n",
    "                                    target = target.permute((0,2,3,1))[0] #[h, w, feature]\n",
    "                                    target = target[osx:otx, osy:oty] #[h', w', feature]\n",
    "                                    source = feature[j,sx_:tx_,sy_:ty_]\n",
    "                                    \n",
    "                                    #compute pixel-wise difference\n",
    "                                    pixel_wise_loss = F.mse_loss(target, source, reduction=\"none\").mean(dim=-1)\n",
    "                                    \n",
    "                                    #gaussian weight applied\n",
    "                                    mask = self.get_gaussian_heatmap(tx-sx, ty-sy)\n",
    "                                    mask = mask[osx:otx, osy:oty]\n",
    "                                    assert(mask.shape == pixel_wise_loss.shape)\n",
    "\n",
    "                                    #weight loss depending on the weight\n",
    "                                    pixel_wise_loss = pixel_wise_loss\n",
    "                                    \n",
    "                                    #add up to the loss\n",
    "                                    loss = loss + (mask*pixel_wise_loss).sum()\n",
    "                                    loss_cnt += mask.sum()\n",
    "                        \n",
    "                    loss = loss/max(1e-8, loss_cnt)\n",
    "                    \n",
    "                    if optimizer == None:\n",
    "                        #Initialize optimizer\n",
    "                        optimizer = torch.optim.AdamW([latents], lr = self.unet.optimize_latent_lr) \n",
    "                    \n",
    "                    self.unet.zero_grad()\n",
    "                    optimizer.zero_grad()\n",
    "                    if loss_cnt > 0:\n",
    "                        scaler.scale(loss).backward()\n",
    "                        scaler.step(optimizer)\n",
    "                        scaler.update()\n",
    "\n",
    "                    del loss\n",
    "                    del feature\n",
    "                    del self.unet.record_value_\n",
    "                    torch.cuda.empty_cache()\n",
    "\n",
    "                    if loss_cnt==0:\n",
    "                        break #nothing to optimize\n",
    "            \n",
    "            if self.unet.latent_fft_post_merge:\n",
    "                fft_axis = (-2, -1) #H and W\n",
    "                with torch.no_grad():\n",
    "                    #latents: [1, frames = 14, channel = 4, h, w]               \n",
    "                    #create low pass filter\n",
    "                    LPF = butterworth_low_pass_filter(latents, d_s = self.unet.latent_fft_ratio)\n",
    "                    \n",
    "                    #FFT\n",
    "                    latents_freq = torch.fft.fftn(latents, dim=fft_axis)\n",
    "                    latents_freq = torch.fft.fftshift(latents_freq, dim=fft_axis)\n",
    "                    original_latents_freq = torch.fft.fftn(original_latents.to(dtype=torch.float32), dim=fft_axis)\n",
    "                    original_latents_freq = torch.fft.fftshift(original_latents_freq, dim=fft_axis)\n",
    "        \n",
    "                    #frequency mix\n",
    "                    HPF = 1 - LPF\n",
    "                    new_freq = latents_freq*LPF + original_latents_freq*HPF\n",
    "        \n",
    "                    #IFFT\n",
    "                    new_freq = torch.fft.ifftshift(new_freq, dim=fft_axis)\n",
    "                    latents = torch.fft.ifftn(new_freq, dim=fft_axis).real\n",
    "            \n",
    "            self.unet = self.unet.to(dtype=torch.float16)\n",
    "            latents = latents.to(dtype=torch.float16)\n",
    "            image_latents = image_latents.to(dtype=torch.float16)\n",
    "            image_embeddings = image_embeddings.to(dtype=torch.float16)\n",
    "            added_time_ids = added_time_ids.to(dtype=torch.float16)\n",
    "            t = t.to(dtype=torch.float16)\n",
    "            self.unet.train(False)\n",
    "        \n",
    "        latents = latents.detach().requires_grad_(False)\n",
    "        return latents\n",
    "    \n",
    "    def __call__(self, image, trajectory_points, height, width, num_frames, min_guidance_scale = 1.0, max_guidance_scale = 3.0, fps = 7,\n",
    "                 generator = None, motion_bucket_id = 127, noise_aug_strength = 0.02, decode_chunk_size = 8):\n",
    "        #Modified from the original implementaion such that the pipeline incorporates our latent optimization procedure\n",
    "        batch_size = 1\n",
    "        fps = fps - 1\n",
    "        self._guidance_scale = max_guidance_scale\n",
    "        image_embeddings = self._encode_image(image, \"cuda\", 1, self.do_classifier_free_guidance)\n",
    "        try: \n",
    "            image = self.image_processor.preprocess(image, height=height, width=width).to(\"cuda\")\n",
    "        except:\n",
    "            self.image_processor = self.video_processor \n",
    "            image = self.image_processor.preprocess(image, height=height, width=width).to(\"cuda\")\n",
    "        noise = randn_tensor(image.shape, generator=generator, device=image.device, dtype=image.dtype).to(\"cuda\")\n",
    "        image = image + noise_aug_strength * noise\n",
    "        needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast\n",
    "        if needs_upcasting:\n",
    "            self.vae.to(dtype=torch.float32)\n",
    "        image_latents = self._encode_vae_image(\n",
    "            image,\n",
    "            device=\"cuda\",\n",
    "            num_videos_per_prompt=1,\n",
    "            do_classifier_free_guidance=self.do_classifier_free_guidance,\n",
    "        )\n",
    "        image_latents = image_latents.to(image_embeddings.dtype)\n",
    "        if needs_upcasting:\n",
    "            self.vae.to(dtype=torch.float16)\n",
    "        image_latents = image_latents.unsqueeze(1).repeat(1, num_frames, 1, 1, 1)\n",
    "        added_time_ids = self._get_add_time_ids(\n",
    "            fps,\n",
    "            motion_bucket_id,\n",
    "            noise_aug_strength,\n",
    "            image_embeddings.dtype,\n",
    "            batch_size,\n",
    "            1,\n",
    "            self.do_classifier_free_guidance,\n",
    "        )\n",
    "        added_time_ids = added_time_ids.to(\"cuda\")\n",
    "        self.scheduler.set_timesteps(self.unet.num_inference_steps, device=\"cuda\")\n",
    "        timesteps = self.scheduler.timesteps\n",
    "        num_channels_latents = self.unet.config.in_channels\n",
    "        shape = (\n",
    "            batch_size,\n",
    "            num_frames,\n",
    "            num_channels_latents // 2,\n",
    "            height // self.vae_scale_factor,\n",
    "            width // self.vae_scale_factor,\n",
    "        )\n",
    "        latents = randn_tensor(shape, generator=generator, device=image.device, dtype=image_embeddings.dtype).to(\"cuda\")\n",
    "        latents = latents * self.scheduler.init_noise_sigma # scale the initial noise by the standard deviation required by the scheduler\n",
    "        self.unet.latent_shape = latents.shape\n",
    "        guidance_scale = torch.linspace(min_guidance_scale, max_guidance_scale, num_frames).unsqueeze(0)\n",
    "        guidance_scale = guidance_scale.to(\"cuda\", latents.dtype)\n",
    "        guidance_scale = guidance_scale.repeat(batch_size, 1)\n",
    "        guidance_scale = _append_dims(guidance_scale, latents.ndim)\n",
    "        self._guidance_scale = guidance_scale\n",
    "\n",
    "        #Free cuda memory\n",
    "        self.vae = self.vae.to(\"cpu\")\n",
    "        self.image_encoder = self.image_encoder.to(\"cpu\")\n",
    "        torch.cuda.empty_cache()\n",
    "            \n",
    "        #Denoising loop\n",
    "        num_warmup_steps = len(timesteps) - self.unet.num_inference_steps * self.scheduler.order #num_warmup_steps = 0 in our setting\n",
    "        self._num_timesteps = len(timesteps)\n",
    "        with self.progress_bar(total=self.unet.num_inference_steps) as progress_bar:\n",
    "            for i, t in enumerate(timesteps):\n",
    "                self.unet.cur_timestep = len(timesteps) - i\n",
    "                \n",
    "                if (self.unet.cur_timestep in self.unet.optimize_latent_time):\n",
    "                    #update latent through optimization\n",
    "                    latents = self.optimize_latent(latents, trajectory_points, t, image_latents[1:], image_embeddings[1:], added_time_ids[1:])\n",
    "                \n",
    "                latent_model_input = torch.cat([latents] * 2) if self.do_classifier_free_guidance else latents\n",
    "                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\n",
    "                latent_model_input = torch.cat([latent_model_input, image_latents], dim=2)\n",
    "                with torch.no_grad():\n",
    "                    noise_pred = self.unet(\n",
    "                        latent_model_input,\n",
    "                        t,\n",
    "                        encoder_hidden_states=image_embeddings,\n",
    "                        added_time_ids=added_time_ids,\n",
    "                        return_dict=False,\n",
    "                    )[0]\n",
    "                if self.do_classifier_free_guidance:\n",
    "                    noise_pred_uncond, noise_pred_cond = noise_pred.chunk(2)\n",
    "                    noise_pred = noise_pred_uncond + self.guidance_scale * (noise_pred_cond - noise_pred_uncond)\n",
    "                latents = self.scheduler.step(noise_pred, t, latents,  s_churn = 0.0).prev_sample\n",
    "                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):\n",
    "                    progress_bar.update()\n",
    "        self.vae = self.vae.to(\"cuda\")\n",
    "        self.image_encoder = self.image_encoder.to(\"cuda\")\n",
    "        if needs_upcasting:\n",
    "            self.vae.to(dtype=torch.float16)\n",
    "        frames = self.decode_latents(latents, num_frames, decode_chunk_size)\n",
    "        frames = tensor2vid(frames, self.image_processor, output_type=\"np\")\n",
    "        self.maybe_free_model_hooks()\n",
    "        return StableVideoDiffusionPipelineOutput(frames=frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57f14507-1a96-42bb-8af2-57cd55384553",
   "metadata": {},
   "source": [
    "# Set up config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f820ab7d-6cfe-430b-ab28-fd9a212774c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Config:\n",
    "    \"\"\"\n",
    "    Hyperparameters\n",
    "    \"\"\"\n",
    "    seed = 817\n",
    "    height, width = 576, 1024 #resolution of generated video\n",
    "    num_frames = 14\n",
    "    num_inference_steps = 50 #total number of inference steps\n",
    "    optimize_latent_time = list(range(30,46)) #set of timesteps to perform optimization\n",
    "    optimize_latent_iter = 5 #number of optimization iterations to perform for each timestep\n",
    "    optimize_latent_lr = 0.21 #learning rate for optimization\n",
    "    record_layer_sublayer = [(2, 1), (2, 2)] #extract feature maps from 1st and 2nd self-attention (note: 0-indexed base) located at 2nd resolution-level of upsampling layer\n",
    "    heatmap_sigma = 0.4 #standard deviation of gaussian heatmap\n",
    "    fft_ratio = 0.5 #fft mix ratio\n",
    "    latent_fft_post_merge = True #fft-based post-processing is enabled iff True\n",
    "\n",
    "config = Config()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "704c0f62-a1ac-4097-bdd1-579fd994017a",
   "metadata": {},
   "source": [
    "# Load pre-trained image-to-video diffusion models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c9ae6aac-7568-4459-bab7-2f07edd97a0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load and set up the pipeline\n",
    "svd_dir = \"stabilityai/stable-video-diffusion-img2vid\"\n",
    "cache_dir = \"./../\"\n",
    "    \n",
    "feature_extractor = CLIPImageProcessor.from_pretrained(svd_dir, subfolder=\"feature_extractor\", cache_dir=cache_dir, torch_dtype=torch.float16, variant=\"fp16\")\n",
    "vae = AutoencoderKLTemporalDecoder.from_pretrained(svd_dir, subfolder=\"vae\", cache_dir=cache_dir, torch_dtype=torch.float16, variant=\"fp16\").to(\"cuda\")\n",
    "requires_grad(vae, False)\n",
    "image_encoder = CLIPVisionModelWithProjection.from_pretrained(svd_dir, subfolder=\"image_encoder\", cache_dir = cache_dir, torch_dtype=torch.float16, variant=\"fp16\").to(\"cuda\")\n",
    "requires_grad(image_encoder, False)\n",
    "unet = MyUNet.from_pretrained(svd_dir, subfolder=\"unet\", cache_dir=cache_dir, torch_dtype=torch.float16, variant=\"fp16\").to(\"cuda\")\n",
    "requires_grad(unet, False)\n",
    "scheduler = EulerDiscreteScheduler.from_pretrained(svd_dir, subfolder=\"scheduler\", cache_dir=cache_dir, torch_dtype=torch.float16, variant=\"fp16\")\n",
    "        \n",
    "unet.inject() #inject module\n",
    "    \n",
    "#Set up pipeline\n",
    "pipe = SGI2VPipe(vae,image_encoder,unet,scheduler,feature_extractor).to(device=\"cuda\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a905ab8-6393-4d0d-8337-2257c20e4f06",
   "metadata": {},
   "source": [
    "# Prepare input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3d094d59-9ddd-4094-9883-1451a0957ce5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Input example 1\n",
    "\"\"\"\n",
    "bounding_box : N x (w_1, h_1, w_2, h_2), specifying corner coordinates of bounding boxes on the first frame\n",
    "center_traj: N x F x 2, specifying center coordinates (w, h) of bounding boxes at each frame (at the scale of config.width and config.height)\n",
    "\"\"\"\n",
    "image_url = \"./examples/111/img.png\"\n",
    "bounding_box = [[404., 305., 773., 500.], [290.,   4., 541.,  74.]] \n",
    "center_traj = [\n",
    "       [[588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ],\n",
    "        [588.        , 402.        ]],\n",
    "\n",
    "       [[415.        ,  39.        ],\n",
    "        [453.5430132 ,  34.66408739],\n",
    "        [486.12517069,  31.64997724],\n",
    "        [512.56076468,  29.71734183],\n",
    "        [532.66408739,  28.62585344],\n",
    "        [546.24943104,  28.13518434],\n",
    "        [553.13108785,  28.00500683],\n",
    "        [553.32453345,  28.2553482 ],\n",
    "        [547.85116067,  30.20801092],\n",
    "        [536.72644515,  33.8830223 ],\n",
    "        [519.76467911,  39.04005462],\n",
    "        [496.78015476,  45.43878015],\n",
    "        [467.58716431,  52.83887119],\n",
    "        [432.        ,  61.        ]]]\n",
    "assert(len(bounding_box)==len(center_traj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4e2684a1-05c4-46c8-a91b-98fd24021569",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#load image\n",
    "image = Image.open(image_url).convert('RGB')\n",
    "image = image.resize((config.width, config.height))\n",
    "\n",
    "#preprocess trajectory\n",
    "bounding_box = np.array(bounding_box).astype(np.float32)\n",
    "center_traj = np.array(center_traj).astype(np.float32)\n",
    "trajectory_points = [] # N x frames x 4\n",
    "for j, trajectory in enumerate(center_traj):\n",
    "        #For normal use\n",
    "        box_traj = [] # frames x 4\n",
    "        for i in range(config.num_frames):\n",
    "            d = center_traj[j][i] - center_traj[j][0]\n",
    "            dx, dy = d[0], d[1]\n",
    "            box_traj.append(np.array([bounding_box[j][1] + dy, bounding_box[j][0] + dx, bounding_box[j][3] + dy, bounding_box[j][2] + dx], dtype=np.float32))\n",
    "        trajectory_points.append(box_traj)\n",
    "\n",
    "#visualize\n",
    "visualize_control(image, trajectory_points=trajectory_points)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2dd599d4-711c-415d-b2b6-2d25e669f2b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#To save traj.npy under ./tmp, run the following\n",
    "\"\"\"\n",
    "traj = np.concatenate([bounding_box.reshape((-1,2,2)), center_traj], axis=1).astype(np.float32) #N x (2+F) x 2\n",
    "os.makedirs(\"./tmp\", exist_ok = True) \n",
    "np.save(\"./tmp/traj.npy\", traj)\n",
    "image.save(\"./tmp/img.png\")\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf0de081-9a3e-4a82-adac-dd1f55fd5b7d",
   "metadata": {},
   "source": [
    "# Generate video "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7ae102d4-2a65-4516-bfa1-83eecf6ca9cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/scratch/ondemand28/namekata/conda_env/ex5/lib/python3.12/site-packages/torch/nn/modules/conv.py:456: UserWarning: Applied workaround for CuDNN issue, install nvrtc.so (Triggered internally at /opt/conda/conda-bld/pytorch_1716905969118/work/aten/src/ATen/native/cudnn/Conv_v8.cpp:84.)\n",
      "  return F.conv2d(input, weight, bias, self.stride,\n",
      "100%|███████████████████████████| 50/50 [04:19<00:00,  5.19s/it]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<img src=\"./result.gif\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Approx. 4 minutes on A6000 with default config\n",
    "def run(config, image, trajectory_points, save_path):\n",
    "    \"\"\"\n",
    "    Set up hyperparameters\n",
    "    \"\"\"\n",
    "    pipe.unet.num_inference_steps = config.num_inference_steps\n",
    "    pipe.unet.optimize_zero_initialize_param = True\n",
    "    height, width = config.height, config.width\n",
    "    motion_bucket_id = 127\n",
    "    fps = 7\n",
    "    num_frames = config.num_frames\n",
    "    seed = config.seed\n",
    "    pipe.unet.heatmap_sigma = config.heatmap_sigma\n",
    "    pipe.unet.latent_fft_post_merge = config.latent_fft_post_merge\n",
    "    pipe.unet.latent_fft_ratio = config.fft_ratio #range : 0.0 - 1.0\n",
    "    pipe.unet.optimize_latent_iter = config.optimize_latent_iter\n",
    "    pipe.unet.optimize_latent_lr = config.optimize_latent_lr\n",
    "    pipe.unet.optimize_latent_time = config.optimize_latent_time\n",
    "    pipe.unet.record_layer_sublayer =  config.record_layer_sublayer\n",
    "    generator = torch.manual_seed(seed)\n",
    "    frames = pipe(image, trajectory_points, height=height, width=width, num_frames = num_frames, decode_chunk_size=8, generator=generator, fps=fps, motion_bucket_id=motion_bucket_id, noise_aug_strength=0.02).frames[0]\n",
    "    #save video\n",
    "    export_to_gif(frames, save_path)\n",
    "\n",
    "#generate video\n",
    "run(config, image, trajectory_points, save_path=\"./result.gif\")\n",
    "HTML(\"<img src=\\\"\" + \"./result.gif\" + \"\\\">\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0d58ea9-5a95-475b-8276-87bcf5f7c4d4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7717d5e4-f746-4ffc-8ab5-d52aa3c3e5bc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be3daee5-0a9b-4e9e-a371-29a520cc4cc1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff65dec1-3153-4510-80e4-3be9b3765b92",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ex5",
   "language": "python",
   "name": "ex5"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}