Upload code/model_vis_tools/vis_sd_feats.py with huggingface_hub

code/model_vis_tools/vis_sd_feats.py

@@ -0,0 +1,144 @@
+import os
+import torch
+import os
+import numpy as np
+from PIL import Image,ImageDraw
+import torch.nn.functional as F
+from extractor_sd import load_model, load_sd_backbone, get_mask
+from open_clip.transform import ResizeMaxSize,_convert_to_rgb
+from torchvision.transforms import ToTensor
+from third_party.utils.utils_correspondence import co_pca, pca, resize
+import matplotlib.pyplot as plt
+from extractor_dino import ViTExtractor
+from torchvision import transforms
+
+def draw_point_on_image(image, x, y, color=(255, 0, 0), radius=8):
+    draw = ImageDraw.Draw(image)
+    left_up = (x - radius, y - radius)
+    right_down = (x + radius, y + radius)
+    draw.ellipse([left_up, right_down], fill=color, outline=(0,0,0), width=2)
+    return image
+
+def overlay_heatmap_on_image(image, heatmap, alpha=0.5, colormap='jet'):
+    """
+    image: PIL.Image (RGB)
+    heatmap: torch.Tensor [1,1,H,W] or numpy array [H,W]
+    alpha: float, blending factor
+    colormap: matplotlib colormap name
+    """
+    if isinstance(heatmap, torch.Tensor):
+        heatmap = heatmap.squeeze().cpu().numpy()  # [H, W]
+    # Normalize heatmap to [0, 1]
+    heatmap = (heatmap - np.min(heatmap)) / (np.max(heatmap) - np.min(heatmap) + 1e-8)
+    # Get colormap
+    cmap = plt.get_cmap(colormap)
+    heatmap_color = cmap(heatmap)[:, :, :3]  # ignore alpha, [H, W, 3]
+    heatmap_color = (heatmap_color * 255).astype(np.uint8)
+    heatmap_img = Image.fromarray(heatmap_color).convert("RGBA")
+    image = image.convert("RGBA")
+    # Blend heatmap to image
+    blended = Image.blend(image, heatmap_img, alpha=alpha)
+    return blended
+
+
+def preprocess_pil(pil_image):
+    prep = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
+    ])
+    prep_img = prep(pil_image)[None, ...]
+    return prep_img
+
+MASK = True
+VER = "v1-5"
+PCA = False
+CO_PCA = True
+PCA_DIMS = [256, 256, 256]
+SIZE =960
+EDGE_PAD = False
+
+FUSE_DINO = 1
+ONLY_DINO = 0
+MODEL_SIZE = 'base'
+DRAW=1
+TEXT_INPUT = False
+SEED = 42
+TIMESTEP = 100
+
+DIST = 'l2' if FUSE_DINO and not ONLY_DINO else 'cos'
+if ONLY_DINO:
+    FUSE_DINO = True
+
+np.random.seed(SEED)
+torch.manual_seed(SEED)
+torch.cuda.manual_seed(SEED)
+torch.backends.cudnn.benchmark = True
+
+sd_transform=transforms.Compose([
+                ResizeMaxSize(960, fill=0),
+                _convert_to_rgb,
+                ToTensor(),
+    ])
+img_path = "demo_images/dog.jpg"
+model = load_sd_backbone(diffusion_ver=VER, image_size=SIZE, num_timesteps=TIMESTEP, decoder_only=False)
+img_size = 840
+stride = 14 
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+extractor = ViTExtractor('dinov2_vitb14', 14, device=device)
+patch_size = 14
+num_patches = int(patch_size / stride * (img_size // patch_size - 1) + 1)
+# Load image 1
+img1 = Image.open(img_path)
+sd_input1=sd_transform(img1).to(device).unsqueeze(0)
+img1 = resize(img1, img_size, resize=True, to_pil=True, edge=EDGE_PAD)
+result = []
+target_size=560
+with torch.no_grad():
+    sd_features=model(sd_input1, raw=True)
+    sd_features = pca(sd_features)# torch.Size([bs, c_1, h, w])
+    img1_batch = preprocess_pil(img1).to(device)
+    dino_feats = extractor.extract_descriptors(img1_batch, 11, 'token') # torch.Size([bs, 1, h*w, c_2])
+    # sd_features: [bs, c1, h1, w1] -> [bs, h1*w1, c1]
+    bs, c1, h1, w1 = sd_features.shape
+    sd_tokens = sd_features.permute(0, 2, 3, 1).reshape(bs, -1, c1)  # [bs, n_sd, c1]
+
+    # dino_feats: [bs, 1, h2*w2, c2] -> [bs, h2*w2, c2]
+    bs2, _, n_dino, c2 = dino_feats.shape
+    dino_tokens = dino_feats.squeeze(1)  # [bs, n_dino, c2]
+    sd_tokens_norm = F.normalize(sd_tokens, dim=-1)
+    dino_tokens_norm = F.normalize(dino_tokens, dim=-1)
+    # 图像内自相关性
+    sim_sd = torch.einsum('bic,bjc->bij', sd_tokens_norm, sd_tokens_norm)        # [bs, n_sd, n_sd]
+    sim_dino = torch.einsum('bic,bjc->bij', dino_tokens_norm, dino_tokens_norm)  # [bs, n_dino, n_dino]
+
+
+    output_dir = "vis"
+    vis_img = Image.open(img_path).convert('RGB')
+    target_size = (960,960)
+    vis_img = resize(vis_img, target_size[0], resize=True, to_pil=True, edge=EDGE_PAD)
+    low_res_size = (60, 60)
+    low_res_token_choosen = (30, 30)
+    token_chosen = int(
+        low_res_token_choosen[0] * low_res_size[1] + low_res_token_choosen[1]
+    )
+    token_x_low_res = token_chosen % low_res_size[0]
+    token_y_low_res = token_chosen // low_res_size[1]
+    token_x_img = int((token_x_low_res / low_res_size[0]) * target_size[0])
+    token_y_img = int((token_y_low_res / low_res_size[1]) * target_size[1])
+    if not os.path.exists(output_dir):
+        os.mkdir(output_dir)
+    sim_sd=sim_sd[:, token_chosen, :] # 1, h*w
+    sim_dino=sim_dino[:, token_chosen, :] # 1, h*w
+    sim_sd_map = sim_sd.view(1, 1, low_res_size[0], low_res_size[1])
+    sim_dino_map = sim_dino.view(1, 1, low_res_size[0], low_res_size[1])
+    sim_sd_up = F.interpolate(sim_sd_map, size=target_size, mode="bilinear", align_corners=False)
+    sim_dino_up = F.interpolate(sim_dino_map, size=target_size, mode="bilinear", align_corners=False)
+    img_sd = overlay_heatmap_on_image(vis_img, sim_sd_up, alpha=0.5, colormap='jet')
+    img_sd = draw_point_on_image(img_sd, token_x_img, token_y_img, color=(255,0,0), radius=8)
+    img_sd = img_sd.convert('RGB') 
+    img_sd.save(os.path.join(output_dir,"sd_sim.jpg"))
+
+    img_dino = overlay_heatmap_on_image(vis_img, sim_dino_up, alpha=0.5, colormap='jet')
+    img_dino = draw_point_on_image(img_dino, token_x_img, token_y_img, color=(255,0,0), radius=8)
+    img_dino = img_dino.convert('RGB')
+    img_dino.save(os.path.join(output_dir,"dino_sim.jpg"))