demo_vis_features.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/junyi/miniconda3/envs/sd_dino/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '0'\n",
    "import torch\n",
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "from tqdm import tqdm\n",
    "import torch.nn.functional as F\n",
    "from extractor_sd import load_model, process_features_and_mask, get_mask\n",
    "from utils.utils_correspondence import co_pca, resize, find_nearest_patchs, find_nearest_patchs_replace\n",
    "import matplotlib.pyplot as plt\n",
    "import sys\n",
    "from extractor_dino import ViTExtractor\n",
    "from sklearn.decomposition import PCA as sklearnPCA\n",
    "import math\n",
    "from sklearn.cluster import KMeans\n",
    "from scipy.optimize import linear_sum_assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "MASK = True\n",
    "VER = \"v1-5\"\n",
    "PCA = False\n",
    "CO_PCA = True\n",
    "PCA_DIMS = [256, 256, 256]\n",
    "SIZE =960\n",
    "EDGE_PAD = False\n",
    "\n",
    "FUSE_DINO = 1\n",
    "ONLY_DINO = 0\n",
    "DINOV2 = True\n",
    "MODEL_SIZE = 'base'\n",
    "DRAW_DENSE = 1\n",
    "DRAW_SWAP = 1\n",
    "TEXT_INPUT = False\n",
    "SEED = 42\n",
    "TIMESTEP = 100\n",
    "\n",
    "DIST = 'l2' if FUSE_DINO and not ONLY_DINO else 'cos'\n",
    "if ONLY_DINO:\n",
    "    FUSE_DINO = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LatentDiffusion: Running in eps-prediction mode\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 1280, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 640, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is 768 and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is None and using 8 heads.\n",
      "Setting up MemoryEfficientCrossAttention. Query dim is 320, context_dim is 768 and using 8 heads.\n",
      "DiffusionWrapper has 859.52 M params.\n",
      "making attention of type 'vanilla-xformers' with 512 in_channels\n",
      "building MemoryEfficientAttnBlock with 512 in_channels...\n",
      "Working with z of shape (1, 4, 32, 32) = 4096 dimensions.\n",
      "making attention of type 'vanilla-xformers' with 512 in_channels\n",
      "building MemoryEfficientAttnBlock with 512 in_channels...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "The checkpoint state_dict contains keys that are not used by the model:\n",
      "  model_ema.{decay, num_updates}\n",
      "WARNING:fvcore.common.checkpoint:Keys with prefix are removed from state_dict:\n",
      "backbone.feature_extractor.,category_head.clip.clip.,clip_head.clip.clip.\n",
      "WARNING:fvcore.common.checkpoint:Removed 2483 ignored_state_dict keys from missing_keys\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(SEED)\n",
    "torch.manual_seed(SEED)\n",
    "torch.cuda.manual_seed(SEED)\n",
    "torch.backends.cudnn.benchmark = True\n",
    "\n",
    "model, aug = load_model(diffusion_ver=VER, image_size=SIZE, num_timesteps=TIMESTEP)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_pair_feature(model, aug, save_path, files, category, mask=False, dist='cos', real_size=960):\n",
    "    if type(category) == str:\n",
    "        category = [category]\n",
    "    img_size = 840 if DINOV2 else 244\n",
    "    model_dict={'small':'dinov2_vits14',\n",
    "                'base':'dinov2_vitb14',\n",
    "                'large':'dinov2_vitl14',\n",
    "                'giant':'dinov2_vitg14'}\n",
    "    \n",
    "    model_type = model_dict[MODEL_SIZE] if DINOV2 else 'dino_vits8'\n",
    "    layer = 11 if DINOV2 else 9\n",
    "    if 'l' in model_type:\n",
    "        layer = 23\n",
    "    elif 'g' in model_type:\n",
    "        layer = 39\n",
    "    facet = 'token' if DINOV2 else 'key'\n",
    "    stride = 14 if DINOV2 else 4\n",
    "    device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "    # indiactor = 'v2' if DINOV2 else 'v1'\n",
    "    # model_size = model_type.split('vit')[-1]\n",
    "    extractor = ViTExtractor(model_type, stride, device=device)\n",
    "    patch_size = extractor.model.patch_embed.patch_size[0] if DINOV2 else extractor.model.patch_embed.patch_size\n",
    "    num_patches = int(patch_size / stride * (img_size // patch_size - 1) + 1)\n",
    "    \n",
    "    input_text = \"a photo of \"+category[-1][0] if TEXT_INPUT else None\n",
    "\n",
    "    current_save_results = 0\n",
    "\n",
    "    N = len(files) // 2\n",
    "    pbar = tqdm(total=N)\n",
    "    result = []\n",
    "    if 'Anno' in files[0]:\n",
    "        Anno=True\n",
    "    else:\n",
    "        Anno=False\n",
    "    for pair_idx in range(N):\n",
    "\n",
    "        # Load image 1\n",
    "        img1 = Image.open(files[2*pair_idx]).convert('RGB')\n",
    "        img1_input = resize(img1, real_size, resize=True, to_pil=True, edge=EDGE_PAD)\n",
    "        img1 = resize(img1, img_size, resize=True, to_pil=True, edge=EDGE_PAD)\n",
    "\n",
    "        # Load image 2\n",
    "        img2 = Image.open(files[2*pair_idx+1]).convert('RGB')\n",
    "        img2_input = resize(img2, real_size, resize=True, to_pil=True, edge=EDGE_PAD)\n",
    "        img2 = resize(img2, img_size, resize=True, to_pil=True, edge=EDGE_PAD)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            if not CO_PCA:\n",
    "                if not ONLY_DINO:\n",
    "                    img1_desc = process_features_and_mask(model, aug, img1_input, input_text=input_text, mask=False, pca=PCA).reshape(1,1,-1, num_patches**2).permute(0,1,3,2)\n",
    "                    img2_desc = process_features_and_mask(model, aug, img2_input, category[-1], input_text=input_text,  mask=mask, pca=PCA).reshape(1,1,-1, num_patches**2).permute(0,1,3,2)\n",
    "                if FUSE_DINO:\n",
    "                    img1_batch = extractor.preprocess_pil(img1)\n",
    "                    img1_desc_dino = extractor.extract_descriptors(img1_batch.to(device), layer, facet)\n",
    "                    img2_batch = extractor.preprocess_pil(img2)\n",
    "                    img2_desc_dino = extractor.extract_descriptors(img2_batch.to(device), layer, facet)\n",
    "\n",
    "            else:\n",
    "                if not ONLY_DINO:\n",
    "                    features1 = process_features_and_mask(model, aug, img1_input, input_text=input_text,  mask=False, raw=True)\n",
    "                    features2 = process_features_and_mask(model, aug, img2_input, input_text=input_text,  mask=False, raw=True)\n",
    "                    processed_features1, processed_features2 = co_pca(features1, features2, PCA_DIMS)\n",
    "                    img1_desc = processed_features1.reshape(1, 1, -1, num_patches**2).permute(0,1,3,2)\n",
    "                    img2_desc = processed_features2.reshape(1, 1, -1, num_patches**2).permute(0,1,3,2)\n",
    "                if FUSE_DINO:\n",
    "                    img1_batch = extractor.preprocess_pil(img1)\n",
    "                    img1_desc_dino = extractor.extract_descriptors(img1_batch.to(device), layer, facet)\n",
    "                    img2_batch = extractor.preprocess_pil(img2)\n",
    "                    img2_desc_dino = extractor.extract_descriptors(img2_batch.to(device), layer, facet)\n",
    "                \n",
    "            if dist == 'l1' or dist == 'l2':\n",
    "                # normalize the features\n",
    "                img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)\n",
    "                img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)\n",
    "                if FUSE_DINO:\n",
    "                    img1_desc_dino = img1_desc_dino / img1_desc_dino.norm(dim=-1, keepdim=True)\n",
    "                    img2_desc_dino = img2_desc_dino / img2_desc_dino.norm(dim=-1, keepdim=True)\n",
    "\n",
    "            if FUSE_DINO and not ONLY_DINO:\n",
    "                # cat two features together\n",
    "                img1_desc = torch.cat((img1_desc, img1_desc_dino), dim=-1)\n",
    "                img2_desc = torch.cat((img2_desc, img2_desc_dino), dim=-1)\n",
    "\n",
    "            if ONLY_DINO:\n",
    "                img1_desc = img1_desc_dino\n",
    "                img2_desc = img2_desc_dino\n",
    "\n",
    "            if DRAW_DENSE:\n",
    "                if not Anno:\n",
    "                    mask1 = get_mask(model, aug, img1, category[0])\n",
    "                    mask2 = get_mask(model, aug, img2, category[-1])\n",
    "                if Anno:\n",
    "                    mask1 = torch.Tensor(resize(img1, img_size, resize=True, to_pil=False, edge=EDGE_PAD).mean(-1)>0).to(device)\n",
    "                    mask2 = torch.Tensor(resize(img2, img_size, resize=True, to_pil=False, edge=EDGE_PAD).mean(-1)>0).to(device)\n",
    "                    print(mask1.shape, mask2.shape,mask1.sum(), mask2.sum())\n",
    "                if ONLY_DINO or not FUSE_DINO:\n",
    "                    img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)\n",
    "                    img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)\n",
    "                \n",
    "                img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)\n",
    "                img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)\n",
    "                trg_dense_output, src_color_map = find_nearest_patchs(mask2, mask1, img2, img1, img2_desc_reshaped, img1_desc_reshaped, mask=mask)\n",
    "\n",
    "                if not os.path.exists(f'{save_path}/{category[0]}'):\n",
    "                    os.makedirs(f'{save_path}/{category[0]}')\n",
    "                fig_colormap, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))\n",
    "                ax1.axis('off')\n",
    "                ax2.axis('off')\n",
    "                ax1.imshow(src_color_map)\n",
    "                ax2.imshow(trg_dense_output)\n",
    "                fig_colormap.savefig(f'{save_path}/{category[0]}/{pair_idx}_colormap.png')\n",
    "                plt.close(fig_colormap)\n",
    "            \n",
    "            if DRAW_SWAP:\n",
    "                if not DRAW_DENSE:\n",
    "                    mask1 = get_mask(model, aug, img1, category[0])\n",
    "                    mask2 = get_mask(model, aug, img2, category[-1])\n",
    "\n",
    "                if (ONLY_DINO or not FUSE_DINO) and not DRAW_DENSE:\n",
    "                    img1_desc = img1_desc / img1_desc.norm(dim=-1, keepdim=True)\n",
    "                    img2_desc = img2_desc / img2_desc.norm(dim=-1, keepdim=True)\n",
    "                    \n",
    "                img1_desc_reshaped = img1_desc.permute(0,1,3,2).reshape(-1, img1_desc.shape[-1], num_patches, num_patches)\n",
    "                img2_desc_reshaped = img2_desc.permute(0,1,3,2).reshape(-1, img2_desc.shape[-1], num_patches, num_patches)\n",
    "                trg_dense_output, src_color_map = find_nearest_patchs_replace(mask2, mask1, img2, img1, img2_desc_reshaped, img1_desc_reshaped, mask=mask, resolution=156)\n",
    "                if not os.path.exists(f'{save_path}/{category[0]}'):\n",
    "                    os.makedirs(f'{save_path}/{category[0]}')\n",
    "                fig_colormap, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))\n",
    "                ax1.axis('off')\n",
    "                ax2.axis('off')\n",
    "                ax1.imshow(src_color_map)\n",
    "                ax2.imshow(trg_dense_output)\n",
    "                fig_colormap.savefig(f'{save_path}/{category[0]}/{pair_idx}_swap.png')\n",
    "                plt.close(fig_colormap)\n",
    "            if not DRAW_SWAP and not DRAW_DENSE:\n",
    "                result.append([img1_desc.cpu(), img2_desc.cpu()])\n",
    "            else:\n",
    "                result.append([img1_desc.cpu(), img2_desc.cpu(), mask1.cpu(), mask2.cpu()])\n",
    "\n",
    "    pbar.update(1)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vis_pca_mask(result,save_path):\n",
    "    # PCA visualization mask version\n",
    "    for (feature1,feature2,mask1,mask2) in result:\n",
    "        # feature1 shape (1,1,3600,768*2)\n",
    "        # feature2 shape (1,1,3600,768*2)\n",
    "        num_patches = int(math.sqrt(feature1.shape[-2]))\n",
    "        # pca the concatenated feature to 3 dimensions\n",
    "        feature1 = feature1.squeeze() # shape (3600,768*2)\n",
    "        feature2 = feature2.squeeze() # shape (3600,768*2)\n",
    "        chennel_dim = feature1.shape[-1]\n",
    "        # resize back\n",
    "        src_feature_reshaped = feature1.squeeze().permute(1,0).reshape(-1,num_patches,num_patches).cuda()\n",
    "        tgt_feature_reshaped = feature2.squeeze().permute(1,0).reshape(-1,num_patches,num_patches).cuda()\n",
    "        resized_src_mask = F.interpolate(mask1.unsqueeze(0).unsqueeze(0), size=(num_patches, num_patches), mode='nearest').squeeze().cuda()\n",
    "        resized_tgt_mask = F.interpolate(mask2.unsqueeze(0).unsqueeze(0), size=(num_patches, num_patches), mode='nearest').squeeze().cuda()\n",
    "        src_feature_upsampled = src_feature_reshaped * resized_src_mask.repeat(src_feature_reshaped.shape[0],1,1)\n",
    "        tgt_feature_upsampled = tgt_feature_reshaped * resized_tgt_mask.repeat(src_feature_reshaped.shape[0],1,1)\n",
    "        feature1=src_feature_upsampled.reshape(chennel_dim,-1).permute(1,0)\n",
    "        feature2=tgt_feature_upsampled.reshape(chennel_dim,-1).permute(1,0)\n",
    "\n",
    "        n_components=4 # the first component is to seperate the object from the background\n",
    "        pca = sklearnPCA(n_components=n_components)\n",
    "        feature1_n_feature2 = torch.cat((feature1,feature2),dim=0) # shape (7200,768*2)\n",
    "        feature1_n_feature2 = pca.fit_transform(feature1_n_feature2.cpu().numpy()) # shape (7200,3)\n",
    "        feature1 = feature1_n_feature2[:feature1.shape[0],:] # shape (3600,3)\n",
    "        feature2 = feature1_n_feature2[feature1.shape[0]:,:] # shape (3600,3)\n",
    "        \n",
    "        \n",
    "        fig, axes = plt.subplots(4, 2, figsize=(10, 14))\n",
    "        for show_channel in range(n_components):\n",
    "            if show_channel==0:\n",
    "                continue\n",
    "            # min max normalize the feature map\n",
    "            feature1[:, show_channel] = (feature1[:, show_channel] - feature1[:, show_channel].min()) / (feature1[:, show_channel].max() - feature1[:, show_channel].min())\n",
    "            feature2[:, show_channel] = (feature2[:, show_channel] - feature2[:, show_channel].min()) / (feature2[:, show_channel].max() - feature2[:, show_channel].min())\n",
    "            feature1_first_channel = feature1[:, show_channel].reshape(num_patches,num_patches)\n",
    "            feature2_first_channel = feature2[:, show_channel].reshape(num_patches,num_patches)\n",
    "\n",
    "            axes[show_channel-1, 0].imshow(feature1_first_channel)\n",
    "            axes[show_channel-1, 0].axis('off')\n",
    "            axes[show_channel-1, 1].imshow(feature2_first_channel)\n",
    "            axes[show_channel-1, 1].axis('off')\n",
    "            axes[show_channel-1, 0].set_title('Feature 1 - Channel {}'.format(show_channel ), fontsize=14)\n",
    "            axes[show_channel-1, 1].set_title('Feature 2 - Channel {}'.format(show_channel ), fontsize=14)\n",
    "\n",
    "\n",
    "        feature1_resized = feature1[:, 1:4].reshape(num_patches,num_patches, 3)\n",
    "        feature2_resized = feature2[:, 1:4].reshape(num_patches,num_patches, 3)\n",
    "\n",
    "        axes[3, 0].imshow(feature1_resized)\n",
    "        axes[3, 0].axis('off')\n",
    "        axes[3, 1].imshow(feature2_resized)\n",
    "        axes[3, 1].axis('off')\n",
    "        axes[3, 0].set_title('Feature 1 - All Channels', fontsize=14)\n",
    "        axes[3, 1].set_title('Feature 2 - All Channels', fontsize=14)\n",
    "\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "        fig.savefig(save_path+'/masked_pca.png', dpi=300)\n",
    "\n",
    "def vis_pca(result,save_path,src_img_path,trg_img_path):\n",
    "    # PCA visualization\n",
    "    for (feature1,feature2,mask1,mask2) in result:\n",
    "        # feature1 shape (1,1,3600,768*2)\n",
    "        # feature2 shape (1,1,3600,768*2)\n",
    "        num_patches=int(math.sqrt(feature1.shape[2]))\n",
    "        # pca the concatenated feature to 3 dimensions\n",
    "        feature1 = feature1.squeeze() # shape (3600,768*2)\n",
    "        feature2 = feature2.squeeze() # shape (3600,768*2)\n",
    "        chennel_dim = feature1.shape[-1]\n",
    "        # resize back\n",
    "        h1, w1 = Image.open(src_img_path).size\n",
    "        scale_h1 = h1/num_patches\n",
    "        scale_w1 = w1/num_patches\n",
    "        \n",
    "        if scale_h1 > scale_w1:\n",
    "            scale = scale_h1\n",
    "            scaled_w = int(w1/scale)\n",
    "            feature1 = feature1.reshape(num_patches,num_patches,chennel_dim)\n",
    "            feature1_uncropped=feature1[(num_patches-scaled_w)//2:num_patches-(num_patches-scaled_w)//2,:,:]\n",
    "        else:\n",
    "            scale = scale_w1\n",
    "            scaled_h = int(h1/scale)\n",
    "            feature1 = feature1.reshape(num_patches,num_patches,chennel_dim)\n",
    "            feature1_uncropped=feature1[:,(num_patches-scaled_h)//2:num_patches-(num_patches-scaled_h)//2,:]\n",
    "        \n",
    "        h2, w2 = Image.open(trg_img_path).size\n",
    "        scale_h2 = h2/num_patches\n",
    "        scale_w2 = w2/num_patches\n",
    "        if scale_h2 > scale_w2:\n",
    "            scale = scale_h2\n",
    "            scaled_w = int(w2/scale)\n",
    "            feature2 = feature2.reshape(num_patches,num_patches,chennel_dim)\n",
    "            feature2_uncropped=feature2[(num_patches-scaled_w)//2:num_patches-(num_patches-scaled_w)//2,:,:]\n",
    "        else:\n",
    "            scale = scale_w2\n",
    "            scaled_h = int(h2/scale)\n",
    "            feature2 = feature2.reshape(num_patches,num_patches,chennel_dim)\n",
    "            feature2_uncropped=feature2[:,(num_patches-scaled_h)//2:num_patches-(num_patches-scaled_h)//2,:]\n",
    "\n",
    "        f1_shape=feature1_uncropped.shape[:2]\n",
    "        f2_shape=feature2_uncropped.shape[:2]\n",
    "        feature1 = feature1_uncropped.reshape(f1_shape[0]*f1_shape[1],chennel_dim)\n",
    "        feature2 = feature2_uncropped.reshape(f2_shape[0]*f2_shape[1],chennel_dim)\n",
    "        n_components=3\n",
    "        pca = sklearnPCA(n_components=n_components)\n",
    "        feature1_n_feature2 = torch.cat((feature1,feature2),dim=0) # shape (7200,768*2)\n",
    "        feature1_n_feature2 = pca.fit_transform(feature1_n_feature2.cpu().numpy()) # shape (7200,3)\n",
    "        feature1 = feature1_n_feature2[:feature1.shape[0],:] # shape (3600,3)\n",
    "        feature2 = feature1_n_feature2[feature1.shape[0]:,:] # shape (3600,3)\n",
    "        \n",
    "        \n",
    "        fig, axes = plt.subplots(4, 2, figsize=(10, 14))\n",
    "        for show_channel in range(n_components):\n",
    "            # min max normalize the feature map\n",
    "            feature1[:, show_channel] = (feature1[:, show_channel] - feature1[:, show_channel].min()) / (feature1[:, show_channel].max() - feature1[:, show_channel].min())\n",
    "            feature2[:, show_channel] = (feature2[:, show_channel] - feature2[:, show_channel].min()) / (feature2[:, show_channel].max() - feature2[:, show_channel].min())\n",
    "            feature1_first_channel = feature1[:, show_channel].reshape(f1_shape[0], f1_shape[1])\n",
    "            feature2_first_channel = feature2[:, show_channel].reshape(f2_shape[0], f2_shape[1])\n",
    "\n",
    "            axes[show_channel, 0].imshow(feature1_first_channel)\n",
    "            axes[show_channel, 0].axis('off')\n",
    "            axes[show_channel, 1].imshow(feature2_first_channel)\n",
    "            axes[show_channel, 1].axis('off')\n",
    "            axes[show_channel, 0].set_title('Feature 1 - Channel {}'.format(show_channel + 1), fontsize=14)\n",
    "            axes[show_channel, 1].set_title('Feature 2 - Channel {}'.format(show_channel + 1), fontsize=14)\n",
    "\n",
    "\n",
    "        feature1_resized = feature1[:, :3].reshape(f1_shape[0], f1_shape[1], 3)\n",
    "        feature2_resized = feature2[:, :3].reshape(f2_shape[0], f2_shape[1], 3)\n",
    "\n",
    "        axes[3, 0].imshow(feature1_resized)\n",
    "        axes[3, 0].axis('off')\n",
    "        axes[3, 1].imshow(feature2_resized)\n",
    "        axes[3, 1].axis('off')\n",
    "        axes[3, 0].set_title('Feature 1 - All Channels', fontsize=14)\n",
    "        axes[3, 1].set_title('Feature 2 - All Channels', fontsize=14)\n",
    "\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "        fig.savefig(save_path+'/pca.png', dpi=300)\n",
    "\n",
    "\n",
    "def perform_clustering(features, n_clusters=10):\n",
    "    # Normalize features\n",
    "    features = F.normalize(features, p=2, dim=1)\n",
    "    # Convert the features to float32\n",
    "    features = features.cpu().detach().numpy().astype('float32')\n",
    "    # Initialize a k-means clustering index with the desired number of clusters\n",
    "    kmeans = KMeans(n_clusters=n_clusters, random_state=0)\n",
    "    # Train the k-means index with the features\n",
    "    kmeans.fit(features)\n",
    "    # Assign the features to their nearest cluster\n",
    "    labels = kmeans.predict(features)\n",
    "\n",
    "    return labels\n",
    "\n",
    "def cluster_and_match(result, save_path, n_clusters=6):\n",
    "    for (feature1,feature2,mask1,mask2) in result:\n",
    "        # feature1 shape (1,1,3600,768*2)\n",
    "        num_patches = int(math.sqrt(feature1.shape[-2]))\n",
    "        # pca the concatenated feature to 3 dimensions\n",
    "        feature1 = feature1.squeeze() # shape (3600,768*2)\n",
    "        feature2 = feature2.squeeze() # shape (3600,768*2)\n",
    "        chennel_dim = feature1.shape[-1]\n",
    "        # resize back\n",
    "\n",
    "        src_feature_reshaped = feature1.squeeze().permute(1,0).reshape(-1,num_patches,num_patches).cuda()\n",
    "        tgt_feature_reshaped = feature2.squeeze().permute(1,0).reshape(-1,num_patches,num_patches).cuda()\n",
    "        resized_src_mask = F.interpolate(mask1.unsqueeze(0).unsqueeze(0), size=(num_patches, num_patches), mode='nearest').squeeze().cuda()\n",
    "        resized_tgt_mask = F.interpolate(mask2.unsqueeze(0).unsqueeze(0), size=(num_patches, num_patches), mode='nearest').squeeze().cuda()\n",
    "        src_feature_upsampled = src_feature_reshaped * resized_src_mask.repeat(src_feature_reshaped.shape[0],1,1)\n",
    "        tgt_feature_upsampled = tgt_feature_reshaped * resized_tgt_mask.repeat(src_feature_reshaped.shape[0],1,1)\n",
    "\n",
    "        feature1=src_feature_upsampled.unsqueeze(0)\n",
    "        feature2=tgt_feature_upsampled.unsqueeze(0)\n",
    "        \n",
    "        w1, h1 = feature1.shape[2], feature1.shape[3]\n",
    "        w2, h2 = feature2.shape[2], feature2.shape[3]\n",
    "\n",
    "        features1_2d = feature1.reshape(feature1.shape[1], -1).permute(1, 0)\n",
    "        features2_2d = feature2.reshape(feature2.shape[1], -1).permute(1, 0)\n",
    "\n",
    "        labels_img1 = perform_clustering(features1_2d, n_clusters)\n",
    "        labels_img2 = perform_clustering(features2_2d, n_clusters)\n",
    "\n",
    "        cluster_means_img1 = [features1_2d.cpu().detach().numpy()[labels_img1 == i].mean(axis=0) for i in range(n_clusters)]\n",
    "        cluster_means_img2 = [features2_2d.cpu().detach().numpy()[labels_img2 == i].mean(axis=0) for i in range(n_clusters)]\n",
    "\n",
    "        distances = np.linalg.norm(np.expand_dims(cluster_means_img1, axis=1) - np.expand_dims(cluster_means_img2, axis=0), axis=-1)\n",
    "        # Use Hungarian algorithm to find the optimal bijective mapping\n",
    "        row_ind, col_ind = linear_sum_assignment(distances)\n",
    "\n",
    "        relabeled_img2 = np.zeros_like(labels_img2)\n",
    "        for i, match in zip(row_ind, col_ind):\n",
    "            relabeled_img2[labels_img2 == match] = i\n",
    "\n",
    "        labels_img1 = labels_img1.reshape(w1, h1)\n",
    "        relabeled_img2 = relabeled_img2.reshape(w2, h2)\n",
    "        fig, axs = plt.subplots(1, 2, figsize=(10, 5))\n",
    "        # Plot the results\n",
    "        ax_img1 = axs[0]\n",
    "        axs[0].axis('off')\n",
    "        ax_img1.imshow(labels_img1, cmap='tab20')\n",
    "        \n",
    "        ax_img2 = axs[1]\n",
    "        axs[1].axis('off')\n",
    "        ax_img2.imshow(relabeled_img2, cmap='tab20')\n",
    "\n",
    "        plt.tight_layout()\n",
    "        plt.show()\n",
    "        fig.savefig(save_path+'/clustering.png', dpi=300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using cache found in /home/junyi/.cache/torch/hub/facebookresearch_dinov2_main\n",
      "WARNING:dinov2:xFormers not available\n",
      "  0%|          | 0/1 [00:00<?, ?it/s]/home/junyi/miniconda3/envs/sd_dino/lib/python3.9/site-packages/torch/functional.py:504: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /opt/conda/conda-bld/pytorch_1670525551200/work/aten/src/ATen/native/TensorShape.cpp:3190.)\n",
      "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n",
      "100%|██████████| 1/1 [00:13<00:00, 13.99s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1400 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/junyi/miniconda3/envs/sd_dino/lib/python3.9/site-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
      "  warnings.warn(\n",
      "/home/junyi/miniconda3/envs/sd_dino/lib/python3.9/site-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1400 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def process_images(src_img_path,trg_img_path):\n",
    "\n",
    "    categories = [['dog'], ['dog']]\n",
    "    files = [src_img_path, trg_img_path]\n",
    "    save_path = './results_vis' + f'/{trg_img_path.split(\"/\")[-1].split(\".\")[0]}_{src_img_path.split(\"/\")[-1].split(\".\")[0]}'\n",
    "    result = compute_pair_feature(model, aug, save_path, files, mask=MASK, category=categories, dist=DIST)\n",
    "    if MASK:\n",
    "        vis_pca_mask(result, save_path)\n",
    "        cluster_and_match(result, save_path)\n",
    "    if 'Anno' not in src_img_path:\n",
    "        vis_pca(result, save_path,src_img_path,trg_img_path)\n",
    "\n",
    "    return result\n",
    "\n",
    "src_img_path = \"data/images/dog_00.jpg\"\n",
    "trg_img_path = \"data/images/dog_59.jpg\"\n",
    "result = process_images(src_img_path, trg_img_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using cache found in /home/junyi/.cache/torch/hub/facebookresearch_dinov2_main\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([840, 840]) torch.Size([840, 840]) tensor(44741., device='cuda:0') tensor(79175., device='cuda:0')\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1/1 [00:03<00:00,  3.57s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1400 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/junyi/miniconda3/envs/sd_dino/lib/python3.9/site-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
      "  warnings.warn(\n",
      "/home/junyi/miniconda3/envs/sd_dino/lib/python3.9/site-packages/sklearn/cluster/_kmeans.py:870: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "src_img_path = \"data/images/dog_Anno_00.png\"\n",
    "trg_img_path = \"data/images/dog_Anno_59.png\"\n",
    "result = process_images(src_img_path, trg_img_path)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "colossal",
   "language": "python",
   "name": "python3"
  },
  "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.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}