Add files using upload-large-folder tool

Code/Baselines/DiT/models.py

@@ -0,0 +1,370 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# --------------------------------------------------------
+# References:
+# GLIDE: https://github.com/openai/glide-text2im
+# MAE: https://github.com/facebookresearch/mae/blob/main/models_mae.py
+# --------------------------------------------------------
+
+import torch
+import torch.nn as nn
+import numpy as np
+import math
+from timm.models.vision_transformer import PatchEmbed, Attention, Mlp
+
+
+def modulate(x, shift, scale):
+    return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1)
+
+
+#################################################################################
+#               Embedding Layers for Timesteps and Class Labels                 #
+#################################################################################
+
+class TimestepEmbedder(nn.Module):
+    """
+    Embeds scalar timesteps into vector representations.
+    """
+    def __init__(self, hidden_size, frequency_embedding_size=256):
+        super().__init__()
+        self.mlp = nn.Sequential(
+            nn.Linear(frequency_embedding_size, hidden_size, bias=True),
+            nn.SiLU(),
+            nn.Linear(hidden_size, hidden_size, bias=True),
+        )
+        self.frequency_embedding_size = frequency_embedding_size
+
+    @staticmethod
+    def timestep_embedding(t, dim, max_period=10000):
+        """
+        Create sinusoidal timestep embeddings.
+        :param t: a 1-D Tensor of N indices, one per batch element.
+                          These may be fractional.
+        :param dim: the dimension of the output.
+        :param max_period: controls the minimum frequency of the embeddings.
+        :return: an (N, D) Tensor of positional embeddings.
+        """
+        # https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py
+        half = dim // 2
+        freqs = torch.exp(
+            -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
+        ).to(device=t.device)
+        args = t[:, None].float() * freqs[None]
+        embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+        if dim % 2:
+            embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+        return embedding
+
+    def forward(self, t):
+        t_freq = self.timestep_embedding(t, self.frequency_embedding_size)
+        t_emb = self.mlp(t_freq)
+        return t_emb
+
+
+class LabelEmbedder(nn.Module):
+    """
+    Embeds class labels into vector representations. Also handles label dropout for classifier-free guidance.
+    """
+    def __init__(self, num_classes, hidden_size, dropout_prob):
+        super().__init__()
+        use_cfg_embedding = dropout_prob > 0
+        self.embedding_table = nn.Embedding(num_classes + use_cfg_embedding, hidden_size)
+        self.num_classes = num_classes
+        self.dropout_prob = dropout_prob
+
+    def token_drop(self, labels, force_drop_ids=None):
+        """
+        Drops labels to enable classifier-free guidance.
+        """
+        if force_drop_ids is None:
+            drop_ids = torch.rand(labels.shape[0], device=labels.device) < self.dropout_prob
+        else:
+            drop_ids = force_drop_ids == 1
+        labels = torch.where(drop_ids, self.num_classes, labels)
+        return labels
+
+    def forward(self, labels, train, force_drop_ids=None):
+        use_dropout = self.dropout_prob > 0
+        if (train and use_dropout) or (force_drop_ids is not None):
+            labels = self.token_drop(labels, force_drop_ids)
+        embeddings = self.embedding_table(labels)
+        return embeddings
+
+
+#################################################################################
+#                                 Core DiT Model                                #
+#################################################################################
+
+class DiTBlock(nn.Module):
+    """
+    A DiT block with adaptive layer norm zero (adaLN-Zero) conditioning.
+    """
+    def __init__(self, hidden_size, num_heads, mlp_ratio=4.0, **block_kwargs):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.attn = Attention(hidden_size, num_heads=num_heads, qkv_bias=True, **block_kwargs)
+        self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        mlp_hidden_dim = int(hidden_size * mlp_ratio)
+        approx_gelu = lambda: nn.GELU(approximate="tanh")
+        self.mlp = Mlp(in_features=hidden_size, hidden_features=mlp_hidden_dim, act_layer=approx_gelu, drop=0)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 6 * hidden_size, bias=True)
+        )
+
+    def forward(self, x, c):
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.adaLN_modulation(c).chunk(6, dim=1)
+        x = x + gate_msa.unsqueeze(1) * self.attn(modulate(self.norm1(x), shift_msa, scale_msa))
+        x = x + gate_mlp.unsqueeze(1) * self.mlp(modulate(self.norm2(x), shift_mlp, scale_mlp))
+        return x
+
+
+class FinalLayer(nn.Module):
+    """
+    The final layer of DiT.
+    """
+    def __init__(self, hidden_size, patch_size, out_channels):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, patch_size * patch_size * out_channels, bias=True)
+        self.adaLN_modulation = nn.Sequential(
+            nn.SiLU(),
+            nn.Linear(hidden_size, 2 * hidden_size, bias=True)
+        )
+
+    def forward(self, x, c):
+        shift, scale = self.adaLN_modulation(c).chunk(2, dim=1)
+        x = modulate(self.norm_final(x), shift, scale)
+        x = self.linear(x)
+        return x
+
+
+class DiT(nn.Module):
+    """
+    Diffusion model with a Transformer backbone.
+    """
+    def __init__(
+        self,
+        input_size=32,
+        patch_size=2,
+        in_channels=4,
+        hidden_size=1152,
+        depth=28,
+        num_heads=16,
+        mlp_ratio=4.0,
+        class_dropout_prob=0.1,
+        num_classes=1000,
+        learn_sigma=True,
+    ):
+        super().__init__()
+        self.learn_sigma = learn_sigma
+        self.in_channels = in_channels
+        self.out_channels = in_channels * 2 if learn_sigma else in_channels
+        self.patch_size = patch_size
+        self.num_heads = num_heads
+
+        self.x_embedder = PatchEmbed(input_size, patch_size, in_channels, hidden_size, bias=True)
+        self.t_embedder = TimestepEmbedder(hidden_size)
+        self.y_embedder = LabelEmbedder(num_classes, hidden_size, class_dropout_prob)
+        num_patches = self.x_embedder.num_patches
+        # Will use fixed sin-cos embedding:
+        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches, hidden_size), requires_grad=False)
+
+        self.blocks = nn.ModuleList([
+            DiTBlock(hidden_size, num_heads, mlp_ratio=mlp_ratio) for _ in range(depth)
+        ])
+        self.final_layer = FinalLayer(hidden_size, patch_size, self.out_channels)
+        self.initialize_weights()
+
+    def initialize_weights(self):
+        # Initialize transformer layers:
+        def _basic_init(module):
+            if isinstance(module, nn.Linear):
+                torch.nn.init.xavier_uniform_(module.weight)
+                if module.bias is not None:
+                    nn.init.constant_(module.bias, 0)
+        self.apply(_basic_init)
+
+        # Initialize (and freeze) pos_embed by sin-cos embedding:
+        pos_embed = get_2d_sincos_pos_embed(self.pos_embed.shape[-1], int(self.x_embedder.num_patches ** 0.5))
+        self.pos_embed.data.copy_(torch.from_numpy(pos_embed).float().unsqueeze(0))
+
+        # Initialize patch_embed like nn.Linear (instead of nn.Conv2d):
+        w = self.x_embedder.proj.weight.data
+        nn.init.xavier_uniform_(w.view([w.shape[0], -1]))
+        nn.init.constant_(self.x_embedder.proj.bias, 0)
+
+        # Initialize label embedding table:
+        nn.init.normal_(self.y_embedder.embedding_table.weight, std=0.02)
+
+        # Initialize timestep embedding MLP:
+        nn.init.normal_(self.t_embedder.mlp[0].weight, std=0.02)
+        nn.init.normal_(self.t_embedder.mlp[2].weight, std=0.02)
+
+        # Zero-out adaLN modulation layers in DiT blocks:
+        for block in self.blocks:
+            nn.init.constant_(block.adaLN_modulation[-1].weight, 0)
+            nn.init.constant_(block.adaLN_modulation[-1].bias, 0)
+
+        # Zero-out output layers:
+        nn.init.constant_(self.final_layer.adaLN_modulation[-1].weight, 0)
+        nn.init.constant_(self.final_layer.adaLN_modulation[-1].bias, 0)
+        nn.init.constant_(self.final_layer.linear.weight, 0)
+        nn.init.constant_(self.final_layer.linear.bias, 0)
+
+    def unpatchify(self, x):
+        """
+        x: (N, T, patch_size**2 * C)
+        imgs: (N, H, W, C)
+        """
+        c = self.out_channels
+        p = self.x_embedder.patch_size[0]
+        h = w = int(x.shape[1] ** 0.5)
+        assert h * w == x.shape[1]
+
+        x = x.reshape(shape=(x.shape[0], h, w, p, p, c))
+        x = torch.einsum('nhwpqc->nchpwq', x)
+        imgs = x.reshape(shape=(x.shape[0], c, h * p, h * p))
+        return imgs
+
+    def forward(self, x, t, y):
+        """
+        Forward pass of DiT.
+        x: (N, C, H, W) tensor of spatial inputs (images or latent representations of images)
+        t: (N,) tensor of diffusion timesteps
+        y: (N,) tensor of class labels
+        """
+        x = self.x_embedder(x) + self.pos_embed  # (N, T, D), where T = H * W / patch_size ** 2
+        t = self.t_embedder(t)                   # (N, D)
+        y = self.y_embedder(y, self.training)    # (N, D)
+        c = t + y                                # (N, D)
+        for block in self.blocks:
+            x = block(x, c)                      # (N, T, D)
+        x = self.final_layer(x, c)                # (N, T, patch_size ** 2 * out_channels)
+        x = self.unpatchify(x)                   # (N, out_channels, H, W)
+        return x
+
+    def forward_with_cfg(self, x, t, y, cfg_scale):
+        """
+        Forward pass of DiT, but also batches the unconditional forward pass for classifier-free guidance.
+        """
+        # https://github.com/openai/glide-text2im/blob/main/notebooks/text2im.ipynb
+        half = x[: len(x) // 2]
+        combined = torch.cat([half, half], dim=0)
+        model_out = self.forward(combined, t, y)
+        # For exact reproducibility reasons, we apply classifier-free guidance on only
+        # three channels by default. The standard approach to cfg applies it to all channels.
+        # This can be done by uncommenting the following line and commenting-out the line following that.
+        # eps, rest = model_out[:, :self.in_channels], model_out[:, self.in_channels:]
+        eps, rest = model_out[:, :3], model_out[:, 3:]
+        cond_eps, uncond_eps = torch.split(eps, len(eps) // 2, dim=0)
+        half_eps = uncond_eps + cfg_scale * (cond_eps - uncond_eps)
+        eps = torch.cat([half_eps, half_eps], dim=0)
+        return torch.cat([eps, rest], dim=1)
+
+
+#################################################################################
+#                   Sine/Cosine Positional Embedding Functions                  #
+#################################################################################
+# https://github.com/facebookresearch/mae/blob/main/util/pos_embed.py
+
+def get_2d_sincos_pos_embed(embed_dim, grid_size, cls_token=False, extra_tokens=0):
+    """
+    grid_size: int of the grid height and width
+    return:
+    pos_embed: [grid_size*grid_size, embed_dim] or [1+grid_size*grid_size, embed_dim] (w/ or w/o cls_token)
+    """
+    grid_h = np.arange(grid_size, dtype=np.float32)
+    grid_w = np.arange(grid_size, dtype=np.float32)
+    grid = np.meshgrid(grid_w, grid_h)  # here w goes first
+    grid = np.stack(grid, axis=0)
+
+    grid = grid.reshape([2, 1, grid_size, grid_size])
+    pos_embed = get_2d_sincos_pos_embed_from_grid(embed_dim, grid)
+    if cls_token and extra_tokens > 0:
+        pos_embed = np.concatenate([np.zeros([extra_tokens, embed_dim]), pos_embed], axis=0)
+    return pos_embed
+
+
+def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
+    assert embed_dim % 2 == 0
+
+    # use half of dimensions to encode grid_h
+    emb_h = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[0])  # (H*W, D/2)
+    emb_w = get_1d_sincos_pos_embed_from_grid(embed_dim // 2, grid[1])  # (H*W, D/2)
+
+    emb = np.concatenate([emb_h, emb_w], axis=1) # (H*W, D)
+    return emb
+
+
+def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
+    """
+    embed_dim: output dimension for each position
+    pos: a list of positions to be encoded: size (M,)
+    out: (M, D)
+    """
+    assert embed_dim % 2 == 0
+    omega = np.arange(embed_dim // 2, dtype=np.float64)
+    omega /= embed_dim / 2.
+    omega = 1. / 10000**omega  # (D/2,)
+
+    pos = pos.reshape(-1)  # (M,)
+    out = np.einsum('m,d->md', pos, omega)  # (M, D/2), outer product
+
+    emb_sin = np.sin(out) # (M, D/2)
+    emb_cos = np.cos(out) # (M, D/2)
+
+    emb = np.concatenate([emb_sin, emb_cos], axis=1)  # (M, D)
+    return emb
+
+
+#################################################################################
+#                                   DiT Configs                                  #
+#################################################################################
+
+def DiT_XL_2(**kwargs):
+    return DiT(depth=28, hidden_size=1152, patch_size=2, num_heads=16, **kwargs)
+
+def DiT_XL_4(**kwargs):
+    return DiT(depth=28, hidden_size=1152, patch_size=4, num_heads=16, **kwargs)
+
+def DiT_XL_8(**kwargs):
+    return DiT(depth=28, hidden_size=1152, patch_size=8, num_heads=16, **kwargs)
+
+def DiT_L_2(**kwargs):
+    return DiT(depth=24, hidden_size=1024, patch_size=2, num_heads=16, **kwargs)
+
+def DiT_L_4(**kwargs):
+    return DiT(depth=24, hidden_size=1024, patch_size=4, num_heads=16, **kwargs)
+
+def DiT_L_8(**kwargs):
+    return DiT(depth=24, hidden_size=1024, patch_size=8, num_heads=16, **kwargs)
+
+def DiT_B_2(**kwargs):
+    return DiT(depth=12, hidden_size=768, patch_size=2, num_heads=12, **kwargs)
+
+def DiT_B_4(**kwargs):
+    return DiT(depth=12, hidden_size=768, patch_size=4, num_heads=12, **kwargs)
+
+def DiT_B_8(**kwargs):
+    return DiT(depth=12, hidden_size=768, patch_size=8, num_heads=12, **kwargs)
+
+def DiT_S_2(**kwargs):
+    return DiT(depth=12, hidden_size=384, patch_size=2, num_heads=6, **kwargs)
+
+def DiT_S_4(**kwargs):
+    return DiT(depth=12, hidden_size=384, patch_size=4, num_heads=6, **kwargs)
+
+def DiT_S_8(**kwargs):
+    return DiT(depth=12, hidden_size=384, patch_size=8, num_heads=6, **kwargs)
+
+
+DiT_models = {
+    'DiT-XL/2': DiT_XL_2,  'DiT-XL/4': DiT_XL_4,  'DiT-XL/8': DiT_XL_8,
+    'DiT-L/2':  DiT_L_2,   'DiT-L/4':  DiT_L_4,   'DiT-L/8':  DiT_L_8,
+    'DiT-B/2':  DiT_B_2,   'DiT-B/4':  DiT_B_4,   'DiT-B/8':  DiT_B_8,
+    'DiT-S/2':  DiT_S_2,   'DiT-S/4':  DiT_S_4,   'DiT-S/8':  DiT_S_8,
+}

Code/Baselines/DiT/train.py

@@ -0,0 +1,269 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+A minimal training script for DiT using PyTorch DDP.
+"""
+import torch
+# the first flag below was False when we tested this script but True makes A100 training a lot faster:
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+from torchvision.datasets import ImageFolder
+from torchvision import transforms
+import numpy as np
+from collections import OrderedDict
+from PIL import Image
+from copy import deepcopy
+from glob import glob
+from time import time
+import argparse
+import logging
+import os
+
+from models import DiT_models
+from diffusion import create_diffusion
+from diffusers.models import AutoencoderKL
+
+
+#################################################################################
+#                             Training Helper Functions                         #
+#################################################################################
+
+@torch.no_grad()
+def update_ema(ema_model, model, decay=0.9999):
+    """
+    Step the EMA model towards the current model.
+    """
+    ema_params = OrderedDict(ema_model.named_parameters())
+    model_params = OrderedDict(model.named_parameters())
+
+    for name, param in model_params.items():
+        # TODO: Consider applying only to params that require_grad to avoid small numerical changes of pos_embed
+        ema_params[name].mul_(decay).add_(param.data, alpha=1 - decay)
+
+
+def requires_grad(model, flag=True):
+    """
+    Set requires_grad flag for all parameters in a model.
+    """
+    for p in model.parameters():
+        p.requires_grad = flag
+
+
+def cleanup():
+    """
+    End DDP training.
+    """
+    dist.destroy_process_group()
+
+
+def create_logger(logging_dir):
+    """
+    Create a logger that writes to a log file and stdout.
+    """
+    if dist.get_rank() == 0:  # real logger
+        logging.basicConfig(
+            level=logging.INFO,
+            format='[\033[34m%(asctime)s\033[0m] %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S',
+            handlers=[logging.StreamHandler(), logging.FileHandler(f"{logging_dir}/log.txt")]
+        )
+        logger = logging.getLogger(__name__)
+    else:  # dummy logger (does nothing)
+        logger = logging.getLogger(__name__)
+        logger.addHandler(logging.NullHandler())
+    return logger
+
+
+def center_crop_arr(pil_image, image_size):
+    """
+    Center cropping implementation from ADM.
+    https://github.com/openai/guided-diffusion/blob/8fb3ad9197f16bbc40620447b2742e13458d2831/guided_diffusion/image_datasets.py#L126
+    """
+    while min(*pil_image.size) >= 2 * image_size:
+        pil_image = pil_image.resize(
+            tuple(x // 2 for x in pil_image.size), resample=Image.BOX
+        )
+
+    scale = image_size / min(*pil_image.size)
+    pil_image = pil_image.resize(
+        tuple(round(x * scale) for x in pil_image.size), resample=Image.BICUBIC
+    )
+
+    arr = np.array(pil_image)
+    crop_y = (arr.shape[0] - image_size) // 2
+    crop_x = (arr.shape[1] - image_size) // 2
+    return Image.fromarray(arr[crop_y: crop_y + image_size, crop_x: crop_x + image_size])
+
+
+#################################################################################
+#                                  Training Loop                                #
+#################################################################################
+
+def main(args):
+    """
+    Trains a new DiT model.
+    """
+    assert torch.cuda.is_available(), "Training currently requires at least one GPU."
+
+    # Setup DDP:
+    dist.init_process_group("nccl")
+    assert args.global_batch_size % dist.get_world_size() == 0, f"Batch size must be divisible by world size."
+    rank = dist.get_rank()
+    device = rank % torch.cuda.device_count()
+    seed = args.global_seed * dist.get_world_size() + rank
+    torch.manual_seed(seed)
+    torch.cuda.set_device(device)
+    print(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.")
+
+    # Setup an experiment folder:
+    if rank == 0:
+        os.makedirs(args.results_dir, exist_ok=True)  # Make results folder (holds all experiment subfolders)
+        experiment_index = len(glob(f"{args.results_dir}/*"))
+        model_string_name = args.model.replace("/", "-")  # e.g., DiT-XL/2 --> DiT-XL-2 (for naming folders)
+        experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}"  # Create an experiment folder
+        checkpoint_dir = f"{experiment_dir}/checkpoints"  # Stores saved model checkpoints
+        os.makedirs(checkpoint_dir, exist_ok=True)
+        logger = create_logger(experiment_dir)
+        logger.info(f"Experiment directory created at {experiment_dir}")
+    else:
+        logger = create_logger(None)
+
+    # Create model:
+    assert args.image_size % 8 == 0, "Image size must be divisible by 8 (for the VAE encoder)."
+    latent_size = args.image_size // 8
+    model = DiT_models[args.model](
+        input_size=latent_size,
+        num_classes=args.num_classes
+    )
+    # Note that parameter initialization is done within the DiT constructor
+    ema = deepcopy(model).to(device)  # Create an EMA of the model for use after training
+    requires_grad(ema, False)
+    model = DDP(model.to(device), device_ids=[rank])
+    diffusion = create_diffusion(timestep_respacing="")  # default: 1000 steps, linear noise schedule
+    vae = AutoencoderKL.from_pretrained(f"stabilityai/sd-vae-ft-{args.vae}").to(device)
+    logger.info(f"DiT Parameters: {sum(p.numel() for p in model.parameters()):,}")
+
+    # Setup optimizer (we used default Adam betas=(0.9, 0.999) and a constant learning rate of 1e-4 in our paper):
+    opt = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=0)
+
+    # Setup data:
+    transform = transforms.Compose([
+        transforms.Lambda(lambda pil_image: center_crop_arr(pil_image, args.image_size)),
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True)
+    ])
+    dataset = ImageFolder(args.data_path, transform=transform)
+    sampler = DistributedSampler(
+        dataset,
+        num_replicas=dist.get_world_size(),
+        rank=rank,
+        shuffle=True,
+        seed=args.global_seed
+    )
+    loader = DataLoader(
+        dataset,
+        batch_size=int(args.global_batch_size // dist.get_world_size()),
+        shuffle=False,
+        sampler=sampler,
+        num_workers=args.num_workers,
+        pin_memory=True,
+        drop_last=True
+    )
+    logger.info(f"Dataset contains {len(dataset):,} images ({args.data_path})")
+
+    # Prepare models for training:
+    update_ema(ema, model.module, decay=0)  # Ensure EMA is initialized with synced weights
+    model.train()  # important! This enables embedding dropout for classifier-free guidance
+    ema.eval()  # EMA model should always be in eval mode
+
+    # Variables for monitoring/logging purposes:
+    train_steps = 0
+    log_steps = 0
+    running_loss = 0
+    start_time = time()
+
+    logger.info(f"Training for {args.epochs} epochs...")
+    for epoch in range(args.epochs):
+        sampler.set_epoch(epoch)
+        logger.info(f"Beginning epoch {epoch}...")
+        for x, y in loader:
+            x = x.to(device)
+            y = y.to(device)
+            with torch.no_grad():
+                # Map input images to latent space + normalize latents:
+                x = vae.encode(x).latent_dist.sample().mul_(0.18215)
+            t = torch.randint(0, diffusion.num_timesteps, (x.shape[0],), device=device)
+            model_kwargs = dict(y=y)
+            loss_dict = diffusion.training_losses(model, x, t, model_kwargs)
+            loss = loss_dict["loss"].mean()
+            opt.zero_grad()
+            loss.backward()
+            opt.step()
+            update_ema(ema, model.module)
+
+            # Log loss values:
+            running_loss += loss.item()
+            log_steps += 1
+            train_steps += 1
+            if train_steps % args.log_every == 0:
+                # Measure training speed:
+                torch.cuda.synchronize()
+                end_time = time()
+                steps_per_sec = log_steps / (end_time - start_time)
+                # Reduce loss history over all processes:
+                avg_loss = torch.tensor(running_loss / log_steps, device=device)
+                dist.all_reduce(avg_loss, op=dist.ReduceOp.SUM)
+                avg_loss = avg_loss.item() / dist.get_world_size()
+                logger.info(f"(step={train_steps:07d}) Train Loss: {avg_loss:.4f}, Train Steps/Sec: {steps_per_sec:.2f}")
+                # Reset monitoring variables:
+                running_loss = 0
+                log_steps = 0
+                start_time = time()
+
+            # Save DiT checkpoint:
+            if train_steps % args.ckpt_every == 0 and train_steps > 0:
+                if rank == 0:
+                    checkpoint = {
+                        "model": model.module.state_dict(),
+                        "ema": ema.state_dict(),
+                        "opt": opt.state_dict(),
+                        "args": args
+                    }
+                    checkpoint_path = f"{checkpoint_dir}/{train_steps:07d}.pt"
+                    torch.save(checkpoint, checkpoint_path)
+                    logger.info(f"Saved checkpoint to {checkpoint_path}")
+                dist.barrier()
+
+    model.eval()  # important! This disables randomized embedding dropout
+    # do any sampling/FID calculation/etc. with ema (or model) in eval mode ...
+
+    logger.info("Done!")
+    cleanup()
+
+
+if __name__ == "__main__":
+    # Default args here will train DiT-XL/2 with the hyperparameters we used in our paper (except training iters).
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--data-path", type=str, required=True)
+    parser.add_argument("--results-dir", type=str, default="results")
+    parser.add_argument("--model", type=str, choices=list(DiT_models.keys()), default="DiT-XL/2")
+    parser.add_argument("--image-size", type=int, choices=[256, 512], default=256)
+    parser.add_argument("--num-classes", type=int, default=1000)
+    parser.add_argument("--epochs", type=int, default=1400)
+    parser.add_argument("--global-batch-size", type=int, default=256)
+    parser.add_argument("--global-seed", type=int, default=0)
+    parser.add_argument("--vae", type=str, choices=["ema", "mse"], default="ema")  # Choice doesn't affect training
+    parser.add_argument("--num-workers", type=int, default=4)
+    parser.add_argument("--log-every", type=int, default=100)
+    parser.add_argument("--ckpt-every", type=int, default=50_000)
+    args = parser.parse_args()
+    main(args)

Code/Baselines/GeoAware-SC/pck_train.py

@@ -0,0 +1,521 @@
+import os
+import argparse
+
+# First parse GPU_ID early
+early_parser = argparse.ArgumentParser()
+early_parser.add_argument('--GPU_ID', type=str, default='0')
+args_early, unknown = early_parser.parse_known_args()
+
+# Set CUDA device BEFORE importing torch
+os.environ["CUDA_VISIBLE_DEVICES"] = args_early.GPU_ID
+
+import torch
+import pickle
+import wandb
+
+from PIL import Image
+from tqdm import tqdm
+from loguru import logger
+from itertools import chain
+torch.set_num_threads(16)
+import torch.nn.functional as F
+from torch.optim.lr_scheduler import OneCycleLR, CosineAnnealingLR
+from preprocess_map import set_seed
+from model_utils.projection_network import AggregationNetwork, DummyAggregationNetwork
+from model_utils.corr_map_model import Correlation2Displacement
+import utils.utils_losses as utils_losses
+import utils.utils_visualization as utils_visualization
+from utils.logger import get_logger, log_geo_stats, update_stats, update_geo_stats, log_weighted_pcks, load_config
+from utils.utils_geoware import AP10K_GEO_AWARE, AP10K_FLIP, SPAIR_GEO_AWARE, SPAIR_FLIP, SPAIR_FLIP_TRN, permute_indices, renumber_indices, flip_keypoints, renumber_used_points, optimized_kps_1_to_2
+from utils.utils_correspondence import kpts_to_patch_idx, load_img_and_kps, convert_to_binary_mask, calculate_keypoint_transformation, get_distance, get_distance_mutual_nn
+from utils.utils_dataset import load_eval_data, load_and_prepare_data, get_dataset_info
+
+# device  = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+def normalize_feats(args, feats, epsilon=1e-10):
+    if args.DUMMY_NET: # seperate norm
+        feat_sd = feats[..., :640+1280+1280] #sd feature
+        feat_dino = feats[..., 640+1280+1280:] #dino feature
+        norms_sd = torch.linalg.norm(feat_sd, dim=-1)[:, :, None]
+        norm_feats_sd = feat_sd / (norms_sd + epsilon)
+        norms_dino = torch.linalg.norm(feat_dino, dim=-1)[:, :, None]
+        norm_feats_dino = feat_dino / (norms_dino + epsilon)
+        feats = torch.cat([norm_feats_sd, norm_feats_dino], dim=-1)
+    # (b, w*h, c)
+    norms = torch.linalg.norm(feats, dim=-1)[:, :, None]
+    norm_feats = feats / (norms + epsilon)
+    # norm_feats = feats / norms
+    
+    return norm_feats
+
+def prepare_feature_paths_and_load(aggre_net, img_path, flip, ensemble, num_patches, device):
+    # Construct feature paths
+    feature_base = img_path.replace('JPEGImages', 'features').replace('.jpg', '')
+    suffix_flip = '_flip' if flip else ''
+    ensemble_folder = f'features_ensemble{ensemble}' if ensemble > 1 else 'features'
+    mask_path = f"{feature_base}_mask{suffix_flip}.png"
+    sd_path = f"{feature_base}_sd{suffix_flip}.pt".replace('features', ensemble_folder)
+    dino_path = f"{feature_base}_dino{suffix_flip}.pt".replace('features', ensemble_folder)
+    # Load SD and DINO features
+    # features_sd = torch.load(sd_path)
+    features_sd = torch.load(sd_path, map_location=device)
+    for k in features_sd:
+        features_sd[k] = features_sd[k].to(device)
+    # desc_dino = torch.load(dino_path).to(device)
+    desc_dino = torch.load(dino_path, map_location=device).to(device)
+    # Prepare descriptors
+    desc_gathered = torch.cat([
+        features_sd['s3'],
+        F.interpolate(features_sd['s4'], size=(num_patches, num_patches), mode='bilinear', align_corners=False),
+        F.interpolate(features_sd['s5'], size=(num_patches, num_patches), mode='bilinear', align_corners=False),
+        desc_dino
+    ], dim=1)
+    desc = aggre_net(desc_gathered).reshape(1, 1, -1, num_patches**2).permute(0, 1, 3, 2)
+    # Load mask if it exists
+    mask = None
+    if os.path.exists(mask_path):
+        mask = convert_to_binary_mask(mask_path)
+    return desc, mask
+
+def get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, flip=False, flip2=False, img1=None, img2=None, device='cuda'):
+    img_path_1 = files[pair_idx * 2]
+    img_path_2 = files[pair_idx * 2 + 1]
+    # save the imgs for cases if the feature doesn't exist
+    img1_desc, mask1 = prepare_feature_paths_and_load(aggre_net, img_path_1, flip, args.ENSEMBLE, num_patches, device)
+    img2_desc, mask2 = prepare_feature_paths_and_load(aggre_net, img_path_2, flip2, args.ENSEMBLE, num_patches, device)
+    # normalize the desc
+    img1_desc = normalize_feats(args, img1_desc[0])
+    img2_desc = normalize_feats(args, img2_desc[0])
+    return img1_desc, img2_desc, mask1, mask2
+
+def compute_pck(args, save_path, aggre_net, files, kps, category=None, used_points=None, thresholds=None, device=None):
+    print('this is my input thresholds:', thresholds)
+    out_results = []
+    num_patches = args.NUM_PATCHES
+    current_save_results = 0
+    gt_correspondences, pred_correspondences, img_acc_001, img_acc_005, img_acc_01, len_kpts = ([] for _ in range(6))
+    if thresholds is not None:
+        thresholds = torch.tensor(thresholds).to(device)
+        bbox_size=[]
+    N = len(files) // 2
+    pbar = tqdm(total=N)
+
+    if args.COMPUTE_GEOAWARE_METRICS:   # get the geo-aware idx list
+        geo_aware_count = geo_aware_total_count = 0
+        geo_idx_all, influ_list_geo_filtered = [], []
+        if args.EVAL_DATASET == 'ap10k':
+            influ_list_geo = AP10K_GEO_AWARE
+        else:
+            influ_list_geo = SPAIR_GEO_AWARE[category] if category in SPAIR_GEO_AWARE else None
+        for item in influ_list_geo:
+            item = [item] if isinstance(item, int) else item
+            temp_list = [idx for idx in item if idx in used_points]
+            if len(temp_list) >= 1:
+                influ_list_geo_filtered.append(temp_list)
+        raw_geo_aware = renumber_indices(influ_list_geo_filtered, counter=[0])
+    
+    if args.ADAPT_FLIP: # get the permute list for flipping
+        FLIP_ANNO = AP10K_FLIP if args.EVAL_DATASET == 'ap10k' else SPAIR_FLIP[category]
+        if sum(len(i) if isinstance(i, list) else 1 for i in FLIP_ANNO) == kps[0].shape[0]:
+            permute_list = FLIP_ANNO
+        else:
+            influ_list_filtered = []
+            influ_list = FLIP_ANNO
+            for item in influ_list:
+                item = [item] if isinstance(item, int) else item
+                temp_list = [idx for idx in item if idx in used_points]
+                if len(temp_list) >= 1:
+                    influ_list_filtered.append(temp_list)
+            permute_list = renumber_indices(influ_list_filtered, counter=[0])
+
+    for pair_idx in range(N):
+        # Load images and keypoints
+        img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE, edge=False)
+        img2, img2_kps = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE, edge=False)
+        # Get mutual visibility
+        # vis = img1_kps[:, 2] * img2_kps[:, 2] > 0
+        if args.VISIBILITY == 'mutual':
+            vis = img1_kps[:, 2] * img2_kps[:, 2] > 0
+        elif args.VISIBILITY == 'single':
+            vis = img1_kps[:, 2] > 0
+        vis2 = img2_kps[:, 2]
+        # Get patch descriptors
+        with torch.no_grad():
+            img1_desc, img2_desc, mask1, mask2 = get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, img1=img1, img2=img2)
+        # Get patch index for the keypoints
+        img1_patch_idx = kpts_to_patch_idx(args, img1_kps, num_patches)
+        # Get similarity matr
+        kps_1_to_2 = calculate_keypoint_transformation(args, img1_desc, img2_desc, img1_patch_idx, num_patches)
+
+        if args.ADAPT_FLIP:
+            img1_flip = img1.transpose(Image.FLIP_LEFT_RIGHT)
+            img1_desc_flip, _, mask1_flip, _ = get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, flip=True, img1=img1.transpose(Image.FLIP_LEFT_RIGHT), img2=img2)
+            img1_kps_flip = flip_keypoints(img1_kps, args.ANNO_SIZE, permute_indices(permute_list, vis))
+            img1_patch_idx_flip = kpts_to_patch_idx(args, img1_kps_flip, num_patches)
+            kps_1_to_2_flip = calculate_keypoint_transformation(args, img1_desc_flip, img2_desc, img1_patch_idx_flip, num_patches)
+            
+            # get the distance for the flip and original img
+            if args.MUTUAL_NN:
+                original_dist = get_distance_mutual_nn(img1_desc, img2_desc)
+                flip_dist = get_distance_mutual_nn(img1_desc_flip, img2_desc)
+            else:
+                original_dist = get_distance(img1_desc, img2_desc, mask1, mask2)
+                flip_dist = get_distance(img1_desc_flip, img2_desc, mask1_flip, mask2)
+
+            kps_1_to_2 = optimized_kps_1_to_2(args, kps_1_to_2, kps_1_to_2_flip, img1_kps, img2_kps, flip_dist, original_dist, vis, permute_list)
+
+        # collect the result for more complicated eval
+        single_result = {
+            "src_fn": files[2*pair_idx],  # must
+            "trg_fn": files[2*pair_idx+1],  # must
+            # "category": category,
+            # "used_points": used_points.cpu().numpy(),
+            # "src_kpts": renumber_used_points(img1_kps, used_points).cpu().numpy(),
+            # "trg_kpts": renumber_used_points(img2_kps, used_points).cpu().numpy(),
+            "src_kpts_pred": renumber_used_points(kps_1_to_2.cpu(), used_points).cpu().detach().numpy(),  # must
+            # "threshold": thresholds[pair_idx].item() if thresholds is not None else 0,
+            "resize_resolution": args.ANNO_SIZE,  # must
+        }
+        out_results.append(single_result)
+
+        gt_kps = img2_kps[vis][:, [1,0]]
+        prd_kps = kps_1_to_2[vis][:, [1,0]]
+        gt_correspondences.append(gt_kps)
+        pred_correspondences.append(prd_kps)
+        len_kpts.append(vis.sum().item())
+
+        # compute per image acc
+        if not args.KPT_RESULT: # per img result
+            single_gt_correspondences = img2_kps[vis][:, [1,0]]
+            single_pred_correspondences = kps_1_to_2[vis][:, [1,0]]
+            alpha = torch.tensor([0.1, 0.05, 0.01]) if args.EVAL_DATASET != 'pascal' else torch.tensor([0.1, 0.05, 0.15])
+            correct = torch.zeros(3)
+            err = (single_gt_correspondences - single_pred_correspondences.cpu()).norm(dim=-1)
+            err = err.unsqueeze(0).repeat(3, 1)
+            if thresholds is not None:
+                # print('i am using thresholds')
+                single_bbox_size = thresholds[pair_idx].repeat(vis.sum()).cpu()
+                # print('single_bbox_size:', single_bbox_size)
+                correct += (err < alpha.unsqueeze(-1) * single_bbox_size.unsqueeze(0)).float().mean(dim=-1)
+            else:
+                correct += (err < alpha.unsqueeze(-1) * args.ANNO_SIZE).float().mean(dim=-1)
+            img_acc_01.append(correct[0].item())
+            img_acc_005.append(correct[1].item())
+            img_acc_001.append(correct[2].item())
+
+        if thresholds is not None:
+            pckthres = thresholds[pair_idx].repeat(vis.sum())
+            bbox_size.append(pckthres)
+
+        if args.COMPUTE_GEOAWARE_METRICS:
+            geo_aware_list, geo_aware_full_list = ([] for _ in range(2))
+            for item in raw_geo_aware:
+                # convert to list
+                item = [item] if isinstance(item, int) else item
+                # check if all items are visible
+                temp_list = [idx for idx in item if vis[idx]]
+                temp_list2 = [idx for idx in item if vis2[idx]]
+                # if more than 2 items are visible, add to geo_aware_list
+                if len(temp_list2) >= 2 and len(temp_list) >= 1:
+                    for temp_idx in temp_list:
+                        geo_aware_list.append([temp_idx])
+                    geo_aware_full_list.append(temp_list)
+            
+            geo_aware_idx = [item for sublist in geo_aware_list for item in sublist]
+            geo_idx_mask = torch.zeros(len(vis)).bool()
+            geo_idx_mask[geo_aware_idx] = True
+            geo_idx_mask = geo_idx_mask[vis]
+            geo_idx_all.append(torch.tensor(geo_idx_mask))
+            
+            # count the number of geo-aware pairs
+            if len(geo_aware_full_list) > 0: 
+                geo_aware_total_count += len(geo_aware_idx)     # per keypoint
+                geo_aware_count += 1                            # per img
+            
+        if current_save_results!=args.TOTAL_SAVE_RESULT:
+            if args.ADAPT_FLIP and (flip_dist < original_dist): # save the flip result
+                utils_visualization.save_visualization(thresholds, pair_idx, vis, save_path, category, 
+                       img1_kps_flip, img1_flip, img2, kps_1_to_2, img2_kps, args.ANNO_SIZE, args.ADAPT_FLIP)
+            else:
+                utils_visualization.save_visualization(thresholds, pair_idx, vis, save_path, category, 
+                       img1_kps, img1, img2, kps_1_to_2, img2_kps, args.ANNO_SIZE, args.ADAPT_FLIP)
+            current_save_results += 1
+
+        pbar.update(1)
+    if not args.KPT_RESULT:
+        img_correct = torch.tensor([img_acc_01, img_acc_005, img_acc_001])
+        img_correct = img_correct.mean(dim=-1).tolist()
+        img_correct.append(N)
+    else:
+        img_correct = None
+    gt_correspondences = torch.cat(gt_correspondences, dim=0).cpu()
+    pred_correspondences = torch.cat(pred_correspondences, dim=0).cpu()
+    alpha = torch.tensor([0.1, 0.05, 0.01]) if args.EVAL_DATASET != 'pascal' else torch.tensor([0.1, 0.05, 0.15])
+    correct = torch.zeros(len(alpha))
+    err = (pred_correspondences - gt_correspondences).norm(dim=-1)
+    err = err.unsqueeze(0).repeat(len(alpha), 1)
+    if thresholds is not None:
+        bbox_size = torch.cat(bbox_size, dim=0).cpu()
+        threshold = alpha.unsqueeze(-1) * bbox_size.unsqueeze(0)
+        correct_all = err < threshold
+    else:
+        threshold = alpha * args.ANNO_SIZE
+        correct_all = err < threshold.unsqueeze(-1)
+
+    correct = correct_all.sum(dim=-1) / len(gt_correspondences)
+    correct = correct.tolist()
+    correct.append(len(gt_correspondences))
+    alpha2pck = zip(alpha.tolist(), correct[:3]) if args.KPT_RESULT else zip(alpha.tolist(), img_correct[:3])
+    logger.info(f'{category}...'+' | '.join([f'PCK-Transfer@{alpha:.2f}: {pck_alpha * 100:.2f}%'
+        for alpha, pck_alpha in alpha2pck]))
+    
+    geo_score = []
+    if args.COMPUTE_GEOAWARE_METRICS:
+        geo_idx_all = torch.cat(geo_idx_all, dim=0).cpu()
+        correct_geo = correct_all[:,geo_idx_all].sum(dim=-1) / geo_idx_all.sum().item()
+        correct_geo = correct_geo.tolist()
+        geo_score.append(geo_aware_count / N)
+        geo_score.append(geo_aware_total_count / len(gt_correspondences))
+        geo_score.extend(correct_geo)
+        geo_score.append(geo_idx_all.sum().item())
+        alpha2pck_geo = zip(alpha.tolist(), correct_geo[:3])
+        logger.info(' | '.join([f'PCK-Transfer_geo-aware@{alpha:.2f}: {pck_alpha * 100:.2f}%'
+                        for alpha, pck_alpha in alpha2pck_geo]))
+        logger.info(f'Geo-aware occurance count: {geo_aware_count}, with ratio {geo_aware_count / N * 100:.2f}%; total count ratio {geo_aware_total_count / len(gt_correspondences) * 100:.2f}%')
+
+    return correct, geo_score, out_results, img_correct
+
+def train(args, aggre_net, corr_map_net, optimizer, scheduler, logger, save_path, device):
+    # gather training data
+    files, kps, _, _, all_thresholds = load_and_prepare_data(args)
+    # train
+    num_patches = args.NUM_PATCHES
+    N = len(files) // 2
+    pbar = tqdm(total=N)
+    max_pck_010 = max_pck_005 = max_pck_001 = max_iter = loss_count = count = 0
+    for epoch in range(args.EPOCH):
+        pbar.reset()
+        for j in range(0, N, args.BZ):
+            optimizer.zero_grad()
+            batch_loss = 0  # collect the loss for each batch
+            for pair_idx in range(j, min(j+args.BZ, N)):
+                # Load images and keypoints
+                img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, edge=False)
+                img2, img2_kps = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, edge=False)
+                # Get patch descriptors/feature maps
+                img1_desc, img2_desc, mask1, mask2 = get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, img1=img1, img2=img2, device=device)
+                if args.ADAPT_FLIP > 0 or args.AUGMENT_SELF_FLIP > 0 or args.AUGMENT_DOUBLE_FLIP > 0:  # augment with flip
+                    img1_desc_flip, img2_desc_flip, _, _ = get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, flip=True, flip2=True, img1=img1.transpose(Image.FLIP_LEFT_RIGHT), img2=img2.transpose(Image.FLIP_LEFT_RIGHT), device=device)
+                    raw_permute_list = AP10K_FLIP if args.TRAIN_DATASET == 'ap10k' else SPAIR_FLIP_TRN[files[pair_idx * 2].split('/')[-2]]
+                else:
+                    img1_desc_flip = img2_desc_flip = raw_permute_list = None
+                # Get the threshold for each patch
+                scale_factor = num_patches / args.ANNO_SIZE
+                if args.BBOX_THRE:
+                    img1_threshold = all_thresholds[2*pair_idx] * scale_factor
+                    img2_threshold = all_thresholds[2*pair_idx+1] * scale_factor
+                else: # image threshold
+                    img1_threshold = img2_threshold = args.ANNO_SIZE
+
+                # Compute loss
+                loss = utils_losses.calculate_loss(args, aggre_net, img1_kps, img2_kps, img1_desc, img2_desc, img1_threshold, img2_threshold, mask1, mask2, 
+                                                   num_patches, device, raw_permute_list, img1_desc_flip, img2_desc_flip, corr_map_net)
+
+                # Accumulate loss over iterations
+                loss_count += loss.item()
+                count += 1
+                batch_loss += loss
+                pbar.update(1)
+
+                with torch.no_grad():
+                    # Log loss periodically or at the end of the dataset
+                    if (pair_idx % 100 == 0 and pair_idx > 0) or pair_idx == N-1: # Log every 100 iterations and at the end of the dataset
+                        logger.info(f'Step {pair_idx + epoch * N} | Loss: {loss_count / count:.4f}')
+                        wandb_dict = {'loss': loss_count / count}
+                        loss_count = count = 0 # reset loss count
+                        if not args.NOT_WANDB: wandb.log(wandb_dict, step=pair_idx + epoch * N)
+                    # Evaluate model periodically, at the end of the dataset, or under specific conditions
+                    if (pair_idx % args.EVAL_EPOCH == 0 and pair_idx > 0) or pair_idx == N-1:  # Evaluate every args.EVAL_EPOCH iterations and at the end of the dataset
+                    # if True: # Evaluate every iteration for debugging
+                        pck_010, pck_005, pck_001, total_result = eval(args, aggre_net, save_path, device=device)  # Perform evaluation
+                        wandb_dict = {'pck_010': pck_010, 'pck_005': pck_005, 'pck_001': pck_001}
+                        # Update best model based on PCK scores and dataset type
+                        if (pck_010 > max_pck_010 and args.EVAL_DATASET != 'pascal') or (pck_005 > max_pck_005 and args.EVAL_DATASET == 'pascal'): # different criteria for PASCAL_EVAL
+                            max_pck_010, max_pck_005, max_pck_001 = pck_010, pck_005, pck_001
+                            max_iter = pair_idx + epoch * N
+                            torch.save(aggre_net.state_dict(), f'{save_path}/best.pth') # Save the best model
+                        else:
+                            torch.save(aggre_net.state_dict(), f'{save_path}/last.pth') # Save the last model if it's not the best
+                        # Log the best PCK scores
+                        logger.info(f'Best PCK0.10: {max_pck_010 * 100:.2f}% at step {max_iter}, with PCK0.05: {max_pck_005 * 100:.2f}%, PCK0.01: {max_pck_001 * 100:.2f}%')
+                        if not args.NOT_WANDB: wandb.log(wandb_dict, step=pair_idx + epoch * N)
+            
+            # if args.OPTIMIZER == 'LBFGS':
+            #     def closure():
+            #         optimizer.zero_grad()
+            #         loss = batch_loss / args.BZ
+            #         loss.backward()
+            #         return loss
+            #     optimizer.step(closure)
+            # else:
+            batch_loss /= args.BZ
+            batch_loss.backward()
+            optimizer.step()
+            if scheduler is not None:
+                scheduler.step()
+
+def eval(args, aggre_net, save_path, split='val', device=None):
+    aggre_net.eval()  # Set the network to evaluation mode
+    # Configure data directory and categories based on the dataset type
+    data_dir, categories, split = get_dataset_info(args, split)
+
+    print('data_dir:', data_dir)
+
+    # Initialize lists for results and statistics
+    total_out_results, pcks, pcks_05, pcks_01, weights, kpt_weights = ([] for _ in range(6))
+    if args.COMPUTE_GEOAWARE_METRICS: geo_aware, geo_aware_count, pcks_geo, pcks_geo_05, pcks_geo_01, weights_geo = ([] for _ in range(6))
+
+    # Process each category
+    for cat in categories:
+        # Load data based on the dataset
+        files, kps, thresholds, used_points = load_eval_data(args, data_dir, cat, split)
+        # print('len files:', len(files))
+        # print('thresholds len:', len(thresholds))
+        # print('thresholds:', thresholds)
+        # Compute PCK with or without bbox threshold
+        compute_args = (save_path, aggre_net, files, kps, cat, used_points)
+        # if device is not None:
+        pck, correct_geo, out_results, img_correct = compute_pck(args, *compute_args, thresholds=thresholds, device=device) if args.BBOX_THRE else compute_pck(args, *compute_args, device=device)
+        print(f'PCK for {cat}: {pck}')
+
+        # break
+        total_out_results.extend(out_results)
+        update_stats(args, pcks, pcks_05, pcks_01, weights, kpt_weights, pck, img_correct)
+        if args.COMPUTE_GEOAWARE_METRICS: update_geo_stats(geo_aware, geo_aware_count, pcks_geo, pcks_geo_05, pcks_geo_01, weights_geo, correct_geo)
+
+    # Calculate and log weighted PCKs
+    # print('weights', weights)
+    pck_010, pck_005, pck_001 = log_weighted_pcks(args, logger, pcks, pcks_05, pcks_01, weights)
+    if args.COMPUTE_GEOAWARE_METRICS: log_geo_stats(args, geo_aware, geo_aware_count, pcks_geo, pcks_geo_05, pcks_geo_01, weights_geo, kpt_weights, total_out_results)
+
+    aggre_net.train()  # Set the network back to training mode
+    return pck_010, pck_005, pck_001, total_out_results
+
+def main(args):
+    set_seed(args.SEED)
+    args.NUM_PATCHES = 60
+    args.BBOX_THRE = not (args.IMG_THRESHOLD or args.EVAL_DATASET == 'pascal')
+    args.AUGMENT_FLIP, args.AUGMENT_DOUBLE_FLIP, args.AUGMENT_SELF_FLIP = (1.0, 1.0, 0.25) if args.PAIR_AUGMENT else (0, 0, 0) # set different weight for different augmentation
+    if args.SAMPLE == 0: args.SAMPLE = None # use all the data
+    feature_dims = [640,1280,1280,768] # dimensions for three layers of SD and one layer of DINOv2 features
+
+    # choose the corresponding GPU
+    # device = torch.device('cuda:{}'.format(str(args.GPU_ID))) if args.GPU_ID >= 0 else 'cpu'
+    # print(device)
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.GPU_ID)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Determine the evaluation type and project name based on args
+    save_path = f'./results_{args.EVAL_DATASET}/pck_train_{args.NOTE}_sample_{args.EPOCH}_{args.SAMPLE}_lr_{args.LR}'
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+    if not args.NOT_WANDB:
+        wandb.init(project=args.EVAL_DATASET, name=f'{args.NOTE}_sample_{args.EPOCH}_{args.SAMPLE}_lr_{args.LR}', config=args)
+    
+    logger = get_logger(save_path+'/result.log')
+    logger.info(args)
+    if args.DUMMY_NET:
+        aggre_net = DummyAggregationNetwork()
+    else:
+        aggre_net = AggregationNetwork(feature_dims=feature_dims, projection_dim=args.PROJ_DIM, device=device, feat_map_dropout=args.FEAT_MAP_DROPOUT)
+    if args.LOAD is not None:
+        pretrained_dict = torch.load(args.LOAD)
+        aggre_net.load_pretrained_weights(pretrained_dict)
+        logger.info(f'Load model from {args.LOAD}')
+    aggre_net.to(device)
+    total_args = aggre_net.parameters()
+    if args.DENSE_OBJ>0:
+        corr_map_net = Correlation2Displacement(setting=args.DENSE_OBJ, window_size=args.SOFT_TRAIN_WINDOW).to(device)
+        total_args = chain(total_args, corr_map_net.parameters())
+    else:
+        corr_map_net = None
+
+    optimizer = torch.optim.AdamW(total_args, lr=args.LR, weight_decay=args.WD)
+    if args.SCHEDULER is not None:
+        if args.SCHEDULER == 'cosine':
+            scheduler = CosineAnnealingLR(optimizer, T_max=53339//args.BZ, eta_min=1e-6) #53339 is the number of training pairs for SPair-71k
+        if args.SCHEDULER == 'one_cycle':
+            scheduler = OneCycleLR(optimizer, max_lr=args.LR, steps_per_epoch=53339//args.BZ, epochs=args.EPOCH, pct_start=args.SCHEDULER_P1)
+    else:
+        scheduler = None
+  
+    if args.DO_EVAL: # eval on test set
+        with torch.no_grad():
+            _,_,_,result = eval(args, aggre_net, save_path, split='test')
+            with open(save_path+'/result.pkl', 'wb') as f:
+                pickle.dump(result, f)
+    else: 
+        # print('corr_map_net', corr_map_net.device)
+        train(args, aggre_net, corr_map_net, optimizer, scheduler, logger, save_path, device)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+
+    # load config
+    parser.add_argument('--config', type=str, default=None)                         # path to the config file
+
+    # basic training setting
+    parser.add_argument('--SEED', type=int, default=42)                             # random seed
+    parser.add_argument('--NOTE', type=str, default='')                             # note for the experiment
+    parser.add_argument('--SAMPLE', type=int, default=0)                            # sample 100 pairs for each category for training, set to 0 to use all pairs
+    parser.add_argument('--TEST_SAMPLE', type=int, default=20)                      # sample 20 pairs for each category for testing, set to 0 to use all pairs
+    parser.add_argument('--TOTAL_SAVE_RESULT', type=int, default=0)                 # save the qualitative results for the first 5 pairs
+    parser.add_argument('--IMG_THRESHOLD', action='store_true', default=False)      # set the pck threshold to the image size rather than the bbox size
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)                       # image size for the annotation input
+    parser.add_argument('--LR', type=float, default=1.25e-3)                        # learning rate
+    parser.add_argument('--WD', type=float, default=1e-3)                           # weight decay
+    parser.add_argument('--BZ', type=int, default=1)                                # batch size
+    parser.add_argument('--SCHEDULER', type=str, default=None)                      # set to use lr scheduler, one_cycle, cosine, plateau
+    parser.add_argument('--SCHEDULER_P1', type=float, default=0.3)                  # set the first parameter for the scheduler
+    parser.add_argument('--EPOCH', type=int, default=1)                             # number of epochs
+    parser.add_argument('--EVAL_EPOCH', type=int, default=5000)                     # number of steps for evaluation
+    parser.add_argument('--NOT_WANDB', action='store_true', default=False)          # set true to not use wandb
+    parser.add_argument('--TRAIN_DATASET', type=str, default='spair')               # set the training dataset, 'spair' for SPair-71k, 'pascal' for PF-Pascal, 'ap10k' for AP10k
+
+    # training model setup
+    parser.add_argument('--LOAD', type=str, default=None)                           # path to load the pretrained model
+    parser.add_argument('--DENSE_OBJ', type=int, default=1)                         # set true to use the dense training objective, 1: enable; 0: disable
+    parser.add_argument('--GAUSSIAN_AUGMENT', type=float, default=0.1)              # set float to use the gaussian augment, float for std
+    parser.add_argument('--FEAT_MAP_DROPOUT', type=float, default=0.2)              # set true to use the dropout for the feat map
+    parser.add_argument('--ENSEMBLE', type=int, default=1)                          # set true to use the ensembles of sd feature maps
+    parser.add_argument('--PROJ_DIM', type=int, default=768)                        # projection dimension of the post-processor
+    parser.add_argument('--PAIR_AUGMENT', action='store_true', default=False)       # set true to enable pose-aware pair augmentation
+    parser.add_argument('--SELF_CONTRAST_WEIGHT', type=float, default=0)            # set true to use the self supervised loss
+    parser.add_argument('--SOFT_TRAIN_WINDOW', type=int, default=0)                 # set true to use the window soft argmax during training, default is using standard soft argmax
+    
+    # evaluation setup
+    parser.add_argument('--DO_EVAL', action='store_true', default=False)            # set true to do the evaluation on test set
+    parser.add_argument('--DUMMY_NET', action='store_true', default=False)          # set true to use the dummy net, used for zero-shot setting
+    parser.add_argument('--EVAL_DATASET', type=str, default='spair')                # set the evaluation dataset, 'spair' for SPair-71k, 'pascal' for PF-Pascal, 'ap10k' for AP10k
+    parser.add_argument('--AP10K_EVAL_SUBSET', type=str, default='intra-species')          # set the test setting for ap10k dataset, `intra-species`, `cross-species`, `cross-family`
+    parser.add_argument('--COMPUTE_GEOAWARE_METRICS', action='store_true', default=False)   # set true to use the geo-aware count
+    parser.add_argument('--KPT_RESULT', action='store_true', default=False)         # set true to evaluate per kpt result, in the paper, this is used for comparing unsupervised methods, following ASIC
+    parser.add_argument('--ADAPT_FLIP', action='store_true', default=False)         # set true to use the flipped images, adaptive flip
+    parser.add_argument('--MUTUAL_NN', action='store_true', default=False)          # set true to use the flipped images, adaptive flip, mutual nn as metric
+    parser.add_argument('--SOFT_EVAL', action='store_true', default=False)          # set true to use the soft argmax eval
+    parser.add_argument('--SOFT_EVAL_WINDOW', type=int, default=7)                  # set true to use the window soft argmax eval, window size is 2*SOFT_EVAL_WINDOW+1, 0 to be standard soft argmax
+
+    # add customized arguments
+    parser.add_argument('--GPU_ID', type=str, default='0')                             # set the gpu id to use
+    # parser.add_argument('--OPTIMIZER', type=str, default='adamw')                     # set the optimizer to use
+    parser.add_argument('--VISIBILITY', type=str, default='mutual')                # set the visibility to use, 'mutual' for mutual visibility, 'single' for single visibility (only source)
+
+    args = parser.parse_args()
+    if args.config is not None: # load config file and update the args
+        args_dict = vars(args)
+        args_dict.update(load_config(args.config))
+        args = argparse.Namespace(**args_dict)
+    
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.GPU_ID)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    main(args)

Code/Baselines/GeoAware-SC/pck_train_dit.py

@@ -0,0 +1,606 @@
+import os
+import argparse
+
+# First parse GPU_ID early
+early_parser = argparse.ArgumentParser()
+early_parser.add_argument('--GPU_ID', type=str, default='0')
+args_early, unknown = early_parser.parse_known_args()
+
+# Set CUDA device BEFORE importing torch
+os.environ["CUDA_VISIBLE_DEVICES"] = args_early.GPU_ID
+
+import torch
+import pickle
+import wandb
+
+from PIL import Image
+from tqdm import tqdm
+from loguru import logger
+from itertools import chain
+torch.set_num_threads(16)
+import torch.nn.functional as F
+from torch.optim.lr_scheduler import OneCycleLR, CosineAnnealingLR
+from preprocess_map import set_seed
+from model_utils.projection_network import AggregationNetwork, DummyAggregationNetwork
+from model_utils.corr_map_model import Correlation2Displacement
+import utils.utils_losses as utils_losses
+import utils.utils_visualization as utils_visualization
+from utils.logger import get_logger, log_geo_stats, update_stats, update_geo_stats, log_weighted_pcks, load_config
+from utils.utils_geoware import AP10K_GEO_AWARE, AP10K_FLIP, SPAIR_GEO_AWARE, SPAIR_FLIP, SPAIR_FLIP_TRN, permute_indices, renumber_indices, flip_keypoints, renumber_used_points, optimized_kps_1_to_2
+from utils.utils_correspondence import kpts_to_patch_idx, load_img_and_kps, convert_to_binary_mask, calculate_keypoint_transformation, get_distance, get_distance_mutual_nn
+from utils.utils_dataset import load_eval_data, load_and_prepare_data, get_dataset_info
+
+# device  = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+# def normalize_feats(args, feats, epsilon=1e-10):
+#     if args.DUMMY_NET: # seperate norm
+#         feat_sd = feats[..., :640+1280+1280] #sd feature
+#         feat_dino = feats[..., 640+1280+1280:] #dino feature
+#         norms_sd = torch.linalg.norm(feat_sd, dim=-1)[:, :, None]
+#         norm_feats_sd = feat_sd / (norms_sd + epsilon)
+#         norms_dino = torch.linalg.norm(feat_dino, dim=-1)[:, :, None]
+#         norm_feats_dino = feat_dino / (norms_dino + epsilon)
+#         feats = torch.cat([norm_feats_sd, norm_feats_dino], dim=-1)
+#     # (b, w*h, c)
+#     norms = torch.linalg.norm(feats, dim=-1)[:, :, None]
+#     norm_feats = feats / (norms + epsilon)
+#     # norm_feats = feats / norms
+    
+#     return norm_feats
+
+def normalize_feats_dit(args, feats, epsilon=1e-10):
+    n_channel = feats.shape[1]
+    if args.DUMMY_NET: # seperate norm
+        if n_channel == 768 and not args.NO_DINO: # dino only
+            feat_dino = feats[..., n_channel-768:] #dino feature
+            norms_dino = torch.linalg.norm(feat_dino, dim=-1)[:, :, None]
+            norm_feats_dino = feat_dino / (norms_dino + epsilon)
+            norm_feats = norm_feats_dino
+        
+        elif n_channel > 768 and not args.NO_DINO: # sd + dino
+            feat_dino = feats[..., n_channel-768:] #dino feature
+            norms_dino = torch.linalg.norm(feat_dino, dim=-1)[:, :, None]
+            norm_feats_dino = feat_dino / (norms_dino + epsilon)
+
+            feat_sd = feats[..., :n_channel-768] #sd feature
+            norms_sd = torch.linalg.norm(feat_sd, dim=-1)[:, :, None]
+            norm_feats_sd = feat_sd / (norms_sd + epsilon)
+            feats = torch.cat([norm_feats_sd, norm_feats_dino], dim=-1)
+
+            norms = torch.linalg.norm(feats, dim=-1)[:, :, None]
+            norm_feats = feats / (norms + epsilon)
+        
+        elif n_channel > 768 and args.NO_DINO: # sd only
+            feat_sd = feats[..., :n_channel] #sd feature
+            norms_sd = torch.linalg.norm(feat_sd, dim=-1)[:, :, None]
+            norm_feats_sd = feat_sd / (norms_sd + epsilon)
+            norm_feats = norm_feats_sd
+    # (b, w*h, c)
+    
+    # norm_feats = feats / norms
+    
+    return norm_feats
+
+# def prepare_feature_paths_and_load(aggre_net, img_path, flip, ensemble, num_patches, device):
+#     # Construct feature paths
+#     feature_base = img_path.replace('JPEGImages', 'features').replace('.jpg', '')
+#     suffix_flip = '_flip' if flip else ''
+#     ensemble_folder = f'features_ensemble{ensemble}' if ensemble > 1 else 'features'
+#     mask_path = f"{feature_base}_mask{suffix_flip}.png"
+#     sd_path = f"{feature_base}_sd{suffix_flip}.pt".replace('features', ensemble_folder)
+#     dino_path = f"{feature_base}_dino{suffix_flip}.pt".replace('features', ensemble_folder)
+#     # Load SD and DINO features
+#     # features_sd = torch.load(sd_path)
+#     features_sd = torch.load(sd_path, map_location=device)
+#     for k in features_sd:
+#         features_sd[k] = features_sd[k].to(device)
+#     # desc_dino = torch.load(dino_path).to(device)
+#     desc_dino = torch.load(dino_path, map_location=device).to(device)
+#     # Prepare descriptors
+#     desc_gathered = torch.cat([
+#         features_sd['s3'],
+#         F.interpolate(features_sd['s4'], size=(num_patches, num_patches), mode='bilinear', align_corners=False),
+#         F.interpolate(features_sd['s5'], size=(num_patches, num_patches), mode='bilinear', align_corners=False),
+#         desc_dino
+#     ], dim=1)
+#     desc = aggre_net(desc_gathered).reshape(1, 1, -1, num_patches**2).permute(0, 1, 3, 2)
+#     # Load mask if it exists
+#     mask = None
+#     if os.path.exists(mask_path):
+#         mask = convert_to_binary_mask(mask_path)
+#     return desc, mask
+
+
+def prepare_feature_paths_and_load_dit(aggre_net, img_path, flip, ensemble, num_patches, device, sd_feature_keys=None, no_dino=False):
+
+    # Construct feature paths
+    feature_base = img_path.replace('JPEGImages', 'features').replace('.jpg', '')
+    suffix_flip = '_flip' if flip else ''
+    ensemble_folder = f'features_ensemble{ensemble}' if ensemble > 1 else 'features'
+    mask_path = f"{feature_base}_mask{suffix_flip}.png"
+    sd_path = f"{feature_base}_sd35{suffix_flip}.pt".replace('features', ensemble_folder)
+    dino_path = f"{feature_base}_dino{suffix_flip}.pt".replace('features', ensemble_folder)
+    # Load SD and DINO features
+    # features_sd = torch.load(sd_path)
+    features_sd = torch.load(sd_path, map_location=device)
+    for k in features_sd:
+        features_sd[k] = features_sd[k].to(device)
+    # desc_dino = torch.load(dino_path).to(device)
+    
+    # Prepare descriptors
+
+    # print('all keys in features_sd:', features_sd.keys())
+
+    dest_gathered_list = []
+    if sd_feature_keys is not None:
+        for key in sd_feature_keys:
+            if key in features_sd:
+                dest_gathered_list.append(features_sd[key])
+            else:
+                print(f"Key {key} not found in features_sd. Skipping this key.")
+    
+    if not no_dino:
+       desc_dino = torch.load(dino_path, map_location=device).to(device)
+       dest_gathered_list.append(desc_dino)
+    # Concatenate the gathered features
+    desc_gathered = torch.cat(dest_gathered_list, dim=1)
+
+    # desc_gathered = torch.cat([
+    #     features_sd['t_0.5_layer_15'],
+    #     # F.interpolate(features_sd['s4'], size=(num_patches, num_patches), mode='bilinear', align_corners=False),
+    #     # F.interpolate(features_sd['s5'], size=(num_patches, num_patches), mode='bilinear', align_corners=False),
+    #     desc_dino
+    # ], dim=1)
+
+    desc = aggre_net(desc_gathered).reshape(1, 1, -1, num_patches**2).permute(0, 1, 3, 2)
+    # Load mask if it exists
+    mask = None
+    if os.path.exists(mask_path):
+        mask = convert_to_binary_mask(mask_path)
+    return desc, mask
+
+def get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, flip=False, flip2=False, img1=None, img2=None, device='cuda'):
+    img_path_1 = files[pair_idx * 2]
+    img_path_2 = files[pair_idx * 2 + 1]
+    # save the imgs for cases if the feature doesn't exist
+    img1_desc, mask1 = prepare_feature_paths_and_load_dit(aggre_net, img_path_1, flip, args.ENSEMBLE, num_patches, device, args.SD_FEATURE_KEYS, args.NO_DINO)
+    img2_desc, mask2 = prepare_feature_paths_and_load_dit(aggre_net, img_path_2, flip2, args.ENSEMBLE, num_patches, device, args.SD_FEATURE_KEYS, args.NO_DINO)
+    # normalize the desc
+    img1_desc = normalize_feats_dit(args, img1_desc[0])
+    img2_desc = normalize_feats_dit(args, img2_desc[0])
+    return img1_desc, img2_desc, mask1, mask2
+
+def compute_pck(args, save_path, aggre_net, files, kps, category=None, used_points=None, thresholds=None, device=None):
+    out_results = []
+    num_patches = args.NUM_PATCHES
+    current_save_results = 0
+    gt_correspondences, pred_correspondences, img_acc_001, img_acc_005, img_acc_01, len_kpts = ([] for _ in range(6))
+    if thresholds is not None:
+        thresholds = torch.tensor(thresholds).to(device)
+        bbox_size=[]
+    N = len(files) // 2
+    pbar = tqdm(total=N)
+
+    if args.COMPUTE_GEOAWARE_METRICS:   # get the geo-aware idx list
+        geo_aware_count = geo_aware_total_count = 0
+        geo_idx_all, influ_list_geo_filtered = [], []
+        if args.EVAL_DATASET == 'ap10k':
+            influ_list_geo = AP10K_GEO_AWARE
+        else:
+            influ_list_geo = SPAIR_GEO_AWARE[category] if category in SPAIR_GEO_AWARE else None
+        for item in influ_list_geo:
+            item = [item] if isinstance(item, int) else item
+            temp_list = [idx for idx in item if idx in used_points]
+            if len(temp_list) >= 1:
+                influ_list_geo_filtered.append(temp_list)
+        raw_geo_aware = renumber_indices(influ_list_geo_filtered, counter=[0])
+    
+    if args.ADAPT_FLIP: # get the permute list for flipping
+        FLIP_ANNO = AP10K_FLIP if args.EVAL_DATASET == 'ap10k' else SPAIR_FLIP[category]
+        if sum(len(i) if isinstance(i, list) else 1 for i in FLIP_ANNO) == kps[0].shape[0]:
+            permute_list = FLIP_ANNO
+        else:
+            influ_list_filtered = []
+            influ_list = FLIP_ANNO
+            for item in influ_list:
+                item = [item] if isinstance(item, int) else item
+                temp_list = [idx for idx in item if idx in used_points]
+                if len(temp_list) >= 1:
+                    influ_list_filtered.append(temp_list)
+            permute_list = renumber_indices(influ_list_filtered, counter=[0])
+
+    for pair_idx in range(N):
+        # Load images and keypoints
+        img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, img_size=args.ANNO_SIZE, edge=False)
+        img2, img2_kps = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, img_size=args.ANNO_SIZE, edge=False)
+        # Get mutual visibility
+        vis = img1_kps[:, 2] * img2_kps[:, 2] > 0
+        vis2 = img2_kps[:, 2]
+        # Get patch descriptors
+        with torch.no_grad():
+            img1_desc, img2_desc, mask1, mask2 = get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, img1=img1, img2=img2)
+        # Get patch index for the keypoints
+        img1_patch_idx = kpts_to_patch_idx(args, img1_kps, num_patches)
+        # Get similarity matrix
+        kps_1_to_2 = calculate_keypoint_transformation(args, img1_desc, img2_desc, img1_patch_idx, num_patches)
+
+        if args.ADAPT_FLIP:
+            img1_flip = img1.transpose(Image.FLIP_LEFT_RIGHT)
+            img1_desc_flip, _, mask1_flip, _ = get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, flip=True, img1=img1.transpose(Image.FLIP_LEFT_RIGHT), img2=img2)
+            img1_kps_flip = flip_keypoints(img1_kps, args.ANNO_SIZE, permute_indices(permute_list, vis))
+            img1_patch_idx_flip = kpts_to_patch_idx(args, img1_kps_flip, num_patches)
+            kps_1_to_2_flip = calculate_keypoint_transformation(args, img1_desc_flip, img2_desc, img1_patch_idx_flip, num_patches)
+            
+            # get the distance for the flip and original img
+            if args.MUTUAL_NN:
+                original_dist = get_distance_mutual_nn(img1_desc, img2_desc)
+                flip_dist = get_distance_mutual_nn(img1_desc_flip, img2_desc)
+            else:
+                original_dist = get_distance(img1_desc, img2_desc, mask1, mask2)
+                flip_dist = get_distance(img1_desc_flip, img2_desc, mask1_flip, mask2)
+
+            kps_1_to_2 = optimized_kps_1_to_2(args, kps_1_to_2, kps_1_to_2_flip, img1_kps, img2_kps, flip_dist, original_dist, vis, permute_list)
+
+        # collect the result for more complicated eval
+        single_result = {
+            "src_fn": files[2*pair_idx],  # must
+            "trg_fn": files[2*pair_idx+1],  # must
+            # "category": category,
+            # "used_points": used_points.cpu().numpy(),
+            # "src_kpts": renumber_used_points(img1_kps, used_points).cpu().numpy(),
+            # "trg_kpts": renumber_used_points(img2_kps, used_points).cpu().numpy(),
+            "src_kpts_pred": renumber_used_points(kps_1_to_2.cpu(), used_points).cpu().detach().numpy(),  # must
+            # "threshold": thresholds[pair_idx].item() if thresholds is not None else 0,
+            "resize_resolution": args.ANNO_SIZE,  # must
+        }
+        out_results.append(single_result)
+
+        gt_kps = img2_kps[vis][:, [1,0]]
+        prd_kps = kps_1_to_2[vis][:, [1,0]]
+        gt_correspondences.append(gt_kps)
+        pred_correspondences.append(prd_kps)
+        len_kpts.append(vis.sum().item())
+
+        # compute per image acc
+        if not args.KPT_RESULT: # per img result
+            single_gt_correspondences = img2_kps[vis][:, [1,0]]
+            single_pred_correspondences = kps_1_to_2[vis][:, [1,0]]
+            alpha = torch.tensor([0.1, 0.05, 0.01]) if args.EVAL_DATASET != 'pascal' else torch.tensor([0.1, 0.05, 0.15])
+            correct = torch.zeros(3)
+            err = (single_gt_correspondences - single_pred_correspondences.cpu()).norm(dim=-1)
+            err = err.unsqueeze(0).repeat(3, 1)
+            if thresholds is not None:
+                single_bbox_size = thresholds[pair_idx].repeat(vis.sum()).cpu()
+                correct += (err < alpha.unsqueeze(-1) * single_bbox_size.unsqueeze(0)).float().mean(dim=-1)
+            else:
+                correct += (err < alpha.unsqueeze(-1) * args.ANNO_SIZE).float().mean(dim=-1)
+            img_acc_01.append(correct[0].item())
+            img_acc_005.append(correct[1].item())
+            img_acc_001.append(correct[2].item())
+
+        if thresholds is not None:
+            pckthres = thresholds[pair_idx].repeat(vis.sum())
+            bbox_size.append(pckthres)
+
+        if args.COMPUTE_GEOAWARE_METRICS:
+            geo_aware_list, geo_aware_full_list = ([] for _ in range(2))
+            for item in raw_geo_aware:
+                # convert to list
+                item = [item] if isinstance(item, int) else item
+                # check if all items are visible
+                temp_list = [idx for idx in item if vis[idx]]
+                temp_list2 = [idx for idx in item if vis2[idx]]
+                # if more than 2 items are visible, add to geo_aware_list
+                if len(temp_list2) >= 2 and len(temp_list) >= 1:
+                    for temp_idx in temp_list:
+                        geo_aware_list.append([temp_idx])
+                    geo_aware_full_list.append(temp_list)
+            
+            geo_aware_idx = [item for sublist in geo_aware_list for item in sublist]
+            geo_idx_mask = torch.zeros(len(vis)).bool()
+            geo_idx_mask[geo_aware_idx] = True
+            geo_idx_mask = geo_idx_mask[vis]
+            geo_idx_all.append(torch.tensor(geo_idx_mask))
+            
+            # count the number of geo-aware pairs
+            if len(geo_aware_full_list) > 0: 
+                geo_aware_total_count += len(geo_aware_idx)     # per keypoint
+                geo_aware_count += 1                            # per img
+            
+        if current_save_results!=args.TOTAL_SAVE_RESULT:
+            if args.ADAPT_FLIP and (flip_dist < original_dist): # save the flip result
+                utils_visualization.save_visualization(thresholds, pair_idx, vis, save_path, category, 
+                       img1_kps_flip, img1_flip, img2, kps_1_to_2, img2_kps, args.ANNO_SIZE, args.ADAPT_FLIP)
+            else:
+                utils_visualization.save_visualization(thresholds, pair_idx, vis, save_path, category, 
+                       img1_kps, img1, img2, kps_1_to_2, img2_kps, args.ANNO_SIZE, args.ADAPT_FLIP)
+            current_save_results += 1
+
+        pbar.update(1)
+    if not args.KPT_RESULT:
+        img_correct = torch.tensor([img_acc_01, img_acc_005, img_acc_001])
+        img_correct = img_correct.mean(dim=-1).tolist()
+        img_correct.append(N)
+    else:
+        img_correct = None
+    gt_correspondences = torch.cat(gt_correspondences, dim=0).cpu()
+    pred_correspondences = torch.cat(pred_correspondences, dim=0).cpu()
+    alpha = torch.tensor([0.1, 0.05, 0.01]) if args.EVAL_DATASET != 'pascal' else torch.tensor([0.1, 0.05, 0.15])
+    correct = torch.zeros(len(alpha))
+    err = (pred_correspondences - gt_correspondences).norm(dim=-1)
+    err = err.unsqueeze(0).repeat(len(alpha), 1)
+    if thresholds is not None:
+        bbox_size = torch.cat(bbox_size, dim=0).cpu()
+        threshold = alpha.unsqueeze(-1) * bbox_size.unsqueeze(0)
+        correct_all = err < threshold
+    else:
+        threshold = alpha * args.ANNO_SIZE
+        correct_all = err < threshold.unsqueeze(-1)
+
+    correct = correct_all.sum(dim=-1) / len(gt_correspondences)
+    correct = correct.tolist()
+    correct.append(len(gt_correspondences))
+    alpha2pck = zip(alpha.tolist(), correct[:3]) if args.KPT_RESULT else zip(alpha.tolist(), img_correct[:3])
+    logger.info(f'{category}...'+' | '.join([f'PCK-Transfer@{alpha:.2f}: {pck_alpha * 100:.2f}%'
+        for alpha, pck_alpha in alpha2pck]))
+    
+    geo_score = []
+    if args.COMPUTE_GEOAWARE_METRICS:
+        geo_idx_all = torch.cat(geo_idx_all, dim=0).cpu()
+        correct_geo = correct_all[:,geo_idx_all].sum(dim=-1) / geo_idx_all.sum().item()
+        correct_geo = correct_geo.tolist()
+        geo_score.append(geo_aware_count / N)
+        geo_score.append(geo_aware_total_count / len(gt_correspondences))
+        geo_score.extend(correct_geo)
+        geo_score.append(geo_idx_all.sum().item())
+        alpha2pck_geo = zip(alpha.tolist(), correct_geo[:3])
+        logger.info(' | '.join([f'PCK-Transfer_geo-aware@{alpha:.2f}: {pck_alpha * 100:.2f}%'
+                        for alpha, pck_alpha in alpha2pck_geo]))
+        logger.info(f'Geo-aware occurance count: {geo_aware_count}, with ratio {geo_aware_count / N * 100:.2f}%; total count ratio {geo_aware_total_count / len(gt_correspondences) * 100:.2f}%')
+
+    return correct, geo_score, out_results, img_correct
+
+def train(args, aggre_net, corr_map_net, optimizer, scheduler, logger, save_path, device):
+    # gather training data
+    files, kps, _, _, all_thresholds = load_and_prepare_data(args)
+    # train
+    num_patches = args.NUM_PATCHES
+    N = len(files) // 2
+    pbar = tqdm(total=N)
+    max_pck_010 = max_pck_005 = max_pck_001 = max_iter = loss_count = count = 0
+    for epoch in range(args.EPOCH):
+        pbar.reset()
+        for j in range(0, N, args.BZ):
+            optimizer.zero_grad()
+            batch_loss = 0  # collect the loss for each batch
+            for pair_idx in range(j, min(j+args.BZ, N)):
+                # Load images and keypoints
+                img1, img1_kps = load_img_and_kps(idx=2*pair_idx, files=files, kps=kps, edge=False)
+                img2, img2_kps = load_img_and_kps(idx=2*pair_idx+1, files=files, kps=kps, edge=False)
+                # Get patch descriptors/feature maps
+                img1_desc, img2_desc, mask1, mask2 = get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, img1=img1, img2=img2, device=device)
+                if args.ADAPT_FLIP > 0 or args.AUGMENT_SELF_FLIP > 0 or args.AUGMENT_DOUBLE_FLIP > 0:  # augment with flip
+                    img1_desc_flip, img2_desc_flip, _, _ = get_patch_descriptors(args, aggre_net, num_patches, files, pair_idx, flip=True, flip2=True, img1=img1.transpose(Image.FLIP_LEFT_RIGHT), img2=img2.transpose(Image.FLIP_LEFT_RIGHT), device=device)
+                    raw_permute_list = AP10K_FLIP if args.TRAIN_DATASET == 'ap10k' else SPAIR_FLIP_TRN[files[pair_idx * 2].split('/')[-2]]
+                else:
+                    img1_desc_flip = img2_desc_flip = raw_permute_list = None
+                # Get the threshold for each patch
+                scale_factor = num_patches / args.ANNO_SIZE
+                if args.BBOX_THRE:
+                    img1_threshold = all_thresholds[2*pair_idx] * scale_factor
+                    img2_threshold = all_thresholds[2*pair_idx+1] * scale_factor
+                else: # image threshold
+                    img1_threshold = img2_threshold = args.ANNO_SIZE
+
+                # Compute loss
+                loss = utils_losses.calculate_loss(args, aggre_net, img1_kps, img2_kps, img1_desc, img2_desc, img1_threshold, img2_threshold, mask1, mask2, 
+                                                   num_patches, device, raw_permute_list, img1_desc_flip, img2_desc_flip, corr_map_net)
+
+                # Accumulate loss over iterations
+                loss_count += loss.item()
+                count += 1
+                batch_loss += loss
+                pbar.update(1)
+
+                with torch.no_grad():
+                    # Log loss periodically or at the end of the dataset
+                    if (pair_idx % 100 == 0 and pair_idx > 0) or pair_idx == N-1: # Log every 100 iterations and at the end of the dataset
+                        logger.info(f'Step {pair_idx + epoch * N} | Loss: {loss_count / count:.4f}')
+                        wandb_dict = {'loss': loss_count / count}
+                        loss_count = count = 0 # reset loss count
+                        if not args.NOT_WANDB: wandb.log(wandb_dict, step=pair_idx + epoch * N)
+                    # Evaluate model periodically, at the end of the dataset, or under specific conditions
+                    if (pair_idx % args.EVAL_EPOCH == 0 and pair_idx > 0) or pair_idx == N-1:  # Evaluate every args.EVAL_EPOCH iterations and at the end of the dataset
+                    # if True: # Evaluate every iteration for debugging
+                        pck_010, pck_005, pck_001, total_result = eval(args, aggre_net, save_path, device=device)  # Perform evaluation
+                        wandb_dict = {'pck_010': pck_010, 'pck_005': pck_005, 'pck_001': pck_001}
+                        # Update best model based on PCK scores and dataset type
+                        if (pck_010 > max_pck_010 and args.EVAL_DATASET != 'pascal') or (pck_005 > max_pck_005 and args.EVAL_DATASET == 'pascal'): # different criteria for PASCAL_EVAL
+                            max_pck_010, max_pck_005, max_pck_001 = pck_010, pck_005, pck_001
+                            max_iter = pair_idx + epoch * N
+                            torch.save(aggre_net.state_dict(), f'{save_path}/best.pth') # Save the best model
+                        else:
+                            torch.save(aggre_net.state_dict(), f'{save_path}/last.pth') # Save the last model if it's not the best
+                        # Log the best PCK scores
+                        logger.info(f'Best PCK0.10: {max_pck_010 * 100:.2f}% at step {max_iter}, with PCK0.05: {max_pck_005 * 100:.2f}%, PCK0.01: {max_pck_001 * 100:.2f}%')
+                        if not args.NOT_WANDB: wandb.log(wandb_dict, step=pair_idx + epoch * N)
+            
+            # if args.OPTIMIZER == 'LBFGS':
+            #     def closure():
+            #         optimizer.zero_grad()
+            #         loss = batch_loss / args.BZ
+            #         loss.backward()
+            #         return loss
+            #     optimizer.step(closure)
+            # else:
+            batch_loss /= args.BZ
+            batch_loss.backward()
+            optimizer.step()
+            if scheduler is not None:
+                scheduler.step()
+
+def eval(args, aggre_net, save_path, split='val', device=None):
+    aggre_net.eval()  # Set the network to evaluation mode
+    # Configure data directory and categories based on the dataset type
+    data_dir, categories, split = get_dataset_info(args, split)
+
+    # Initialize lists for results and statistics
+    total_out_results, pcks, pcks_05, pcks_01, weights, kpt_weights = ([] for _ in range(6))
+    if args.COMPUTE_GEOAWARE_METRICS: geo_aware, geo_aware_count, pcks_geo, pcks_geo_05, pcks_geo_01, weights_geo = ([] for _ in range(6))
+
+    # Process each category
+    for cat in categories:
+        # Load data based on the dataset
+        files, kps, thresholds, used_points = load_eval_data(args, data_dir, cat, split)
+        # print('thresholds len:', len(thresholds))
+        # print('thresholds:', thresholds)
+        # Compute PCK with or without bbox threshold
+        compute_args = (save_path, aggre_net, files, kps, cat, used_points)
+        # if device is not None:
+        pck, correct_geo, out_results, img_correct = compute_pck(args, *compute_args, thresholds=thresholds, device=device) if args.BBOX_THRE else compute_pck(args, *compute_args, device=device)
+        # print('pck:', pck)
+        # break
+        total_out_results.extend(out_results)
+        update_stats(args, pcks, pcks_05, pcks_01, weights, kpt_weights, pck, img_correct)
+        if args.COMPUTE_GEOAWARE_METRICS: update_geo_stats(geo_aware, geo_aware_count, pcks_geo, pcks_geo_05, pcks_geo_01, weights_geo, correct_geo)
+
+    # Calculate and log weighted PCKs
+    # print('weights', weights)
+    pck_010, pck_005, pck_001 = log_weighted_pcks(args, logger, pcks, pcks_05, pcks_01, weights)
+    if args.COMPUTE_GEOAWARE_METRICS: log_geo_stats(args, geo_aware, geo_aware_count, pcks_geo, pcks_geo_05, pcks_geo_01, weights_geo, kpt_weights, total_out_results)
+
+    aggre_net.train()  # Set the network back to training mode
+    return pck_010, pck_005, pck_001, total_out_results
+
+def main(args):
+    print(f'preparing sd features of sd_feature_keys: {args.SD_FEATURE_KEYS}')
+
+    set_seed(args.SEED)
+    args.NUM_PATCHES = 60
+    args.BBOX_THRE = not (args.IMG_THRESHOLD or args.EVAL_DATASET == 'pascal')
+    args.AUGMENT_FLIP, args.AUGMENT_DOUBLE_FLIP, args.AUGMENT_SELF_FLIP = (1.0, 1.0, 0.25) if args.PAIR_AUGMENT else (0, 0, 0) # set different weight for different augmentation
+    if args.SAMPLE == 0: args.SAMPLE = None # use all the data
+    # feature_dims = [640,1280,1280,768] # dimensions for three layers of SD and one layer of DINOv2 features
+    feature_dims = [1536, 768]
+
+    # choose the corresponding GPU
+    # device = torch.device('cuda:{}'.format(str(args.GPU_ID))) if args.GPU_ID >= 0 else 'cpu'
+    # print(device)
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.GPU_ID)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    # Determine the evaluation type and project name based on args
+    save_path = f'./results_{args.EVAL_DATASET}/pck_train_{args.NOTE}_sample_{args.EPOCH}_{args.SAMPLE}_lr_{args.LR}'
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+    if not args.NOT_WANDB:
+        wandb.init(project=args.EVAL_DATASET, name=f'{args.NOTE}_sample_{args.EPOCH}_{args.SAMPLE}_lr_{args.LR}', config=args)
+    
+    logger = get_logger(save_path+'/result.log')
+    logger.info(args)
+    if args.DUMMY_NET:
+        aggre_net = DummyAggregationNetwork()
+    else:
+        aggre_net = AggregationNetwork(feature_dims=feature_dims, projection_dim=args.PROJ_DIM, device=device, feat_map_dropout=args.FEAT_MAP_DROPOUT)
+    if args.LOAD is not None:
+        pretrained_dict = torch.load(args.LOAD)
+        aggre_net.load_pretrained_weights(pretrained_dict)
+        logger.info(f'Load model from {args.LOAD}')
+    aggre_net.to(device)
+    total_args = aggre_net.parameters()
+    if args.DENSE_OBJ>0:
+        corr_map_net = Correlation2Displacement(setting=args.DENSE_OBJ, window_size=args.SOFT_TRAIN_WINDOW).to(device)
+        total_args = chain(total_args, corr_map_net.parameters())
+    else:
+        corr_map_net = None
+
+    optimizer = torch.optim.AdamW(total_args, lr=args.LR, weight_decay=args.WD)
+    if args.SCHEDULER is not None:
+        if args.SCHEDULER == 'cosine':
+            scheduler = CosineAnnealingLR(optimizer, T_max=53339//args.BZ, eta_min=1e-6) #53339 is the number of training pairs for SPair-71k
+        if args.SCHEDULER == 'one_cycle':
+            scheduler = OneCycleLR(optimizer, max_lr=args.LR, steps_per_epoch=53339//args.BZ, epochs=args.EPOCH, pct_start=args.SCHEDULER_P1)
+    else:
+        scheduler = None
+  
+    if args.DO_EVAL: # eval on test set
+        with torch.no_grad():
+            _,_,_,result = eval(args, aggre_net, save_path, split='test')
+            with open(save_path+'/result.pkl', 'wb') as f:
+                pickle.dump(result, f)
+    else: 
+        # print('corr_map_net', corr_map_net.device)
+        train(args, aggre_net, corr_map_net, optimizer, scheduler, logger, save_path, device)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+
+    # load config
+    parser.add_argument('--config', type=str, default=None)                         # path to the config file
+
+    # basic training setting
+    parser.add_argument('--SEED', type=int, default=42)                             # random seed
+    parser.add_argument('--NOTE', type=str, default='')                             # note for the experiment
+    parser.add_argument('--SAMPLE', type=int, default=0)                            # sample 100 pairs for each category for training, set to 0 to use all pairs
+    parser.add_argument('--TEST_SAMPLE', type=int, default=20)                      # sample 20 pairs for each category for testing, set to 0 to use all pairs
+    parser.add_argument('--TOTAL_SAVE_RESULT', type=int, default=0)                 # save the qualitative results for the first 5 pairs
+    parser.add_argument('--IMG_THRESHOLD', action='store_true', default=False)      # set the pck threshold to the image size rather than the bbox size
+    parser.add_argument('--ANNO_SIZE', type=int, default=840)                       # image size for the annotation input
+    parser.add_argument('--LR', type=float, default=1.25e-3)                        # learning rate
+    parser.add_argument('--WD', type=float, default=1e-3)                           # weight decay
+    parser.add_argument('--BZ', type=int, default=1)                                # batch size
+    parser.add_argument('--SCHEDULER', type=str, default=None)                      # set to use lr scheduler, one_cycle, cosine, plateau
+    parser.add_argument('--SCHEDULER_P1', type=float, default=0.3)                  # set the first parameter for the scheduler
+    parser.add_argument('--EPOCH', type=int, default=1)                             # number of epochs
+    parser.add_argument('--EVAL_EPOCH', type=int, default=5000)                     # number of steps for evaluation
+    parser.add_argument('--NOT_WANDB', action='store_true', default=False)          # set true to not use wandb
+    parser.add_argument('--TRAIN_DATASET', type=str, default='spair')               # set the training dataset, 'spair' for SPair-71k, 'pascal' for PF-Pascal, 'ap10k' for AP10k
+
+    # sd_key_feature_list
+    parser.add_argument(
+        '--SD_FEATURE_KEYS',
+        nargs='+',  # Expect one or more arguments and store them in a list.
+        type=str,
+        # required=True,
+        default=None,  # Default to None if no keys are provided.
+        help='A space-separated list of feature keys to process.'
+    )
+    parser.add_argument('--NO_DINO', action='store_true', default=False)  # set true to not use the DINOv2 features, only use SD features
+
+    # training model setup
+    parser.add_argument('--LOAD', type=str, default=None)                           # path to load the pretrained model
+    parser.add_argument('--DENSE_OBJ', type=int, default=1)                         # set true to use the dense training objective, 1: enable; 0: disable
+    parser.add_argument('--GAUSSIAN_AUGMENT', type=float, default=0.1)              # set float to use the gaussian augment, float for std
+    parser.add_argument('--FEAT_MAP_DROPOUT', type=float, default=0.2)              # set true to use the dropout for the feat map
+    parser.add_argument('--ENSEMBLE', type=int, default=1)                          # set true to use the ensembles of sd feature maps
+    parser.add_argument('--PROJ_DIM', type=int, default=768)                        # projection dimension of the post-processor
+    parser.add_argument('--PAIR_AUGMENT', action='store_true', default=False)       # set true to enable pose-aware pair augmentation
+    parser.add_argument('--SELF_CONTRAST_WEIGHT', type=float, default=0)            # set true to use the self supervised loss
+    parser.add_argument('--SOFT_TRAIN_WINDOW', type=int, default=0)                 # set true to use the window soft argmax during training, default is using standard soft argmax
+    
+    # evaluation setup
+    parser.add_argument('--DO_EVAL', action='store_true', default=False)            # set true to do the evaluation on test set
+    parser.add_argument('--DUMMY_NET', action='store_true', default=False)          # set true to use the dummy net, used for zero-shot setting
+    parser.add_argument('--EVAL_DATASET', type=str, default='spair')                # set the evaluation dataset, 'spair' for SPair-71k, 'pascal' for PF-Pascal, 'ap10k' for AP10k
+    parser.add_argument('--AP10K_EVAL_SUBSET', type=str, default='intra-species')          # set the test setting for ap10k dataset, `intra-species`, `cross-species`, `cross-family`
+    parser.add_argument('--COMPUTE_GEOAWARE_METRICS', action='store_true', default=False)   # set true to use the geo-aware count
+    parser.add_argument('--KPT_RESULT', action='store_true', default=False)         # set true to evaluate per kpt result, in the paper, this is used for comparing unsupervised methods, following ASIC
+    parser.add_argument('--ADAPT_FLIP', action='store_true', default=False)         # set true to use the flipped images, adaptive flip
+    parser.add_argument('--MUTUAL_NN', action='store_true', default=False)          # set true to use the flipped images, adaptive flip, mutual nn as metric
+    parser.add_argument('--SOFT_EVAL', action='store_true', default=False)          # set true to use the soft argmax eval
+    parser.add_argument('--SOFT_EVAL_WINDOW', type=int, default=7)                  # set true to use the window soft argmax eval, window size is 2*SOFT_EVAL_WINDOW+1, 0 to be standard soft argmax
+
+    # add customized arguments
+    parser.add_argument('--GPU_ID', type=str, default='0')                             # set the gpu id to use
+    # parser.add_argument('--OPTIMIZER', type=str, default='adamw')                     # set the optimizer to use
+
+
+    args = parser.parse_args()
+    if args.config is not None: # load config file and update the args
+        args_dict = vars(args)
+        args_dict.update(load_config(args.config))
+        args = argparse.Namespace(**args_dict)
+    
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.GPU_ID)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    main(args)

Code/Baselines/GeoAware-SC/prepare_ap10k.ipynb

@@ -0,0 +1,584 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json\n",
+    "\n",
+    "def load_data(*file_paths):\n",
+    "    \"\"\"Load and merge data from multiple JSON files.\"\"\"\n",
+    "    merged_data = {'annotations': [], 'images': [], 'categories': []}\n",
+    "    for path in file_paths:\n",
+    "        with open(path, 'r') as file:\n",
+    "            data = json.load(file)\n",
+    "            merged_data['annotations'].extend(data['annotations'])\n",
+    "            merged_data['images'].extend(data['images'])\n",
+    "            # Assuming categories are the same across files or only needed from the first file\n",
+    "            if 'categories' in data and not merged_data['categories']:\n",
+    "                merged_data['categories'] = data['categories']\n",
+    "    return merged_data\n",
+    "\n",
+    "def remove_duplicate_annotations(data):\n",
+    "    \"\"\"Remove duplicate annotations from the data based on image_id.\"\"\"\n",
+    "    unique_image_ids = set()\n",
+    "    new_annotations = []\n",
+    "    for annotation in data['annotations']:\n",
+    "        if annotation['image_id'] not in unique_image_ids:\n",
+    "            unique_image_ids.add(annotation['image_id'])\n",
+    "            new_annotations.append(annotation)\n",
+    "    data['annotations'] = new_annotations\n",
+    "    return data\n",
+    "\n",
+    "# Paths to your JSON files\n",
+    "json_path_1 = \"data/ap-10k/annotations/ap10k-train-split1.json\"\n",
+    "json_path_2 = \"data/ap-10k/annotations/ap10k-test-split1.json\"\n",
+    "json_path_3 = \"data/ap-10k/annotations/ap10k-val-split1.json\"\n",
+    "\n",
+    "# Load and merge data\n",
+    "data = load_data(json_path_1, json_path_2, json_path_3)\n",
+    "\n",
+    "# Remove duplicate annotations\n",
+    "data = remove_duplicate_annotations(data)\n",
+    "\n",
+    "print(len(data['annotations']), \"unique annotations after cleanup.\")\n",
+    "\n",
+    "annotations = data[\"annotations\"]\n",
+    "images = data[\"images\"]\n",
+    "categories = data[\"categories\"]\n",
+    "\n",
+    "# Create dictionaries to index images by image_id and categories by category_id\n",
+    "images_dict = {image[\"id\"]: image for image in images}\n",
+    "categories_dict = {cat[\"id\"]: cat for cat in categories}\n",
+    "\n",
+    "# Set the base directory\n",
+    "base_dir = \"data/ap-10k/ImageAnnotation\"\n",
+    "\n",
+    "# Function to pad the file name\n",
+    "def pad_filename(filename):\n",
+    "    return filename.zfill(17)\n",
+    "\n",
+    "new_annotations = []\n",
+    "\n",
+    "# Iterate over annotations to merge data and directly create and rename files\n",
+    "for annotation in annotations:\n",
+    "    image_id = annotation[\"image_id\"]\n",
+    "    category_id = annotation.get(\"category_id\")\n",
+    "\n",
+    "    # Ensure both image_id and category_id exist in their respective dictionaries\n",
+    "    if image_id in images_dict and category_id in categories_dict:\n",
+    "        # Merge data from annotations, images, and categories\n",
+    "        new_annotation = {**annotation, **images_dict[image_id],\n",
+    "                          \"name\": categories_dict[category_id][\"name\"],\n",
+    "                          \"supercategory\": categories_dict[category_id][\"supercategory\"]}\n",
+    "        new_annotations.append(new_annotation)\n",
+    "\n",
+    "        supercategory = new_annotation.get(\"supercategory\")\n",
+    "        name = new_annotation.get(\"name\")\n",
+    "\n",
+    "        # Check if supercategory and name are available\n",
+    "        if supercategory and name:\n",
+    "            # Create the directory path\n",
+    "            directory_path = os.path.join(base_dir, supercategory, name)\n",
+    "\n",
+    "            # Create the directory if it doesn't exist\n",
+    "            if not os.path.exists(directory_path):\n",
+    "                os.makedirs(directory_path)\n",
+    "\n",
+    "            # Set the file name using the annotation id (or \"unknown\" if not available), and pad it\n",
+    "            file_name = pad_filename(str(new_annotation.get(\"id\", \"unknown\")) + \".json\")\n",
+    "            file_path = os.path.join(directory_path, file_name)\n",
+    "\n",
+    "            # Write the merged data to a JSON file\n",
+    "            with open(file_path, 'w') as file:\n",
+    "                json.dump(new_annotation, file, indent=4)\n",
+    "\n",
+    "print(\"All JSON files have been saved and renamed.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# split the images into different folders according to the supercategory and name\n",
+    "\n",
+    "import os\n",
+    "import shutil\n",
+    "\n",
+    "# create a mapping dict to store the {supercategory}/{name} for each image id\n",
+    "id_to_category = {}\n",
+    "for item in new_annotations:\n",
+    "    image_id = int(item.get(\"id\", \"unknown\"))\n",
+    "    supercategory = item.get(\"supercategory\")\n",
+    "    name = item.get(\"name\")\n",
+    "    if supercategory and name:\n",
+    "        id_to_category[image_id] = os.path.join(supercategory, name)\n",
+    "\n",
+    "# image folder path\n",
+    "img_folder = \"data/ap-10k/data\"\n",
+    "\n",
+    "# iterate through the image folder\n",
+    "for img_file in os.listdir(img_folder):\n",
+    "    img_path = os.path.join(img_folder, img_file)\n",
+    "    if os.path.isfile(img_path):\n",
+    "        # extract the image id\n",
+    "        img_id = int(img_file.split(\".\")[0][7:])\n",
+    "        \n",
+    "        # find the corresponding {supercategory}/{name}\n",
+    "        category_path = id_to_category.get(img_id)\n",
+    "        if category_path:\n",
+    "            # create the target directory\n",
+    "            target_directory = os.path.join(\"data/ap-10k/JPEGImages\", category_path)\n",
+    "            if not os.path.exists(target_directory):\n",
+    "                os.makedirs(target_directory)\n",
+    "\n",
+    "            # move the image to the target directory\n",
+    "            target_path = os.path.join(target_directory, img_file)\n",
+    "            shutil.move(img_path, target_path)\n",
+    "\n",
+    "# delete the original folder, data/ap-10k/data\n",
+    "shutil.rmtree(\"data/ap-10k/data\")\n",
+    "\n",
+    "print(\"All images have been organized according to their respective categories.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "JSON file splitting complete.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import json\n",
+    "\n",
+    "base_path = \"data/ap-10k/ImageAnnotation\"\n",
+    "\n",
+    "def load_list_from_file(file_path):\n",
+    "    \"\"\"Load a list of lines from a file.\"\"\"\n",
+    "    with open(file_path, 'r') as file:\n",
+    "        return [line.strip() for line in file]\n",
+    "\n",
+    "def split_json_files(json_files):\n",
+    "    \"\"\"Split JSON files into train, eval, and test sets based on specified criteria.\"\"\"\n",
+    "    length = len(json_files)\n",
+    "    test_size = min(30, length)  # Ensure we don't exceed the total number of files\n",
+    "    eval_size = min(20, max(0, length - test_size))  # Adjust eval_size based on remaining files\n",
+    "    train_size = max(0, length - test_size - eval_size)  # Avoid negative train_size\n",
+    "\n",
+    "    # Split the dataset\n",
+    "    train, eval, test = json_files[:train_size], json_files[train_size:train_size+eval_size], json_files[-test_size:]\n",
+    "    return train, eval, test\n",
+    "\n",
+    "def save_list_to_file(file_path, items):\n",
+    "    \"\"\"Save a list of items to a file.\"\"\"\n",
+    "    with open(file_path, 'w') as file:\n",
+    "        for item in items:\n",
+    "            file.write(f\"{item}\\n\")\n",
+    "\n",
+    "is_crowd_list = load_list_from_file(\"data/ap-10k_is_crowd.txt\")\n",
+    "\n",
+    "for root, _, files in os.walk(base_path):\n",
+    "    if root.count(os.sep) == base_path.count(os.sep) + 2:\n",
+    "        json_list = [os.path.join(root, f) for f in files if f.endswith(\".json\")]\n",
+    "        filtered_json_list = []\n",
+    "\n",
+    "        for json_file in json_list:\n",
+    "            with open(json_file, 'r') as f:\n",
+    "                json_data = json.load(f)\n",
+    "            \n",
+    "            if json_file.split('/')[-1].strip('.json') in is_crowd_list:\n",
+    "                json_data[\"is_crowd\"] = 1\n",
+    "                with open(json_file, 'w') as f:\n",
+    "                    json.dump(json_data, f)\n",
+    "            elif json_data[\"num_keypoints\"] >= 3:\n",
+    "                filtered_json_list.append(json_file)\n",
+    "        \n",
+    "        train_json_list, eval_json_list, test_json_list = split_json_files(filtered_json_list)\n",
+    "        \n",
+    "        # Save the lists to their respective files\n",
+    "        save_list_to_file(os.path.join(root, \"train_filtered.txt\"), train_json_list)\n",
+    "        save_list_to_file(os.path.join(root, \"val_filtered.txt\"), eval_json_list)\n",
+    "        save_list_to_file(os.path.join(root, \"test_filtered.txt\"), test_json_list)\n",
+    "\n",
+    "print(\"JSON file splitting complete.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import random\n",
+    "import json\n",
+    "import numpy as np\n",
+    "import itertools\n",
+    "\n",
+    "# Set the seed for reproducibility\n",
+    "random.seed(42)\n",
+    "\n",
+    "def generate_pairs(base_path, file_name, output_folder, N_multiplier=None): #intra-specicies\n",
+    "    N_total_pairs = 0\n",
+    "    for root, dirs, files in os.walk(base_path):\n",
+    "        # Process only subdirectories that are two levels deep\n",
+    "        if root.count(os.sep) == base_path.count(os.sep) + 2:\n",
+    "            json_list = []\n",
+    "            with open(os.path.join(root, file_name), 'r') as file:\n",
+    "                json_list = [line.strip() for line in file]\n",
+    "\n",
+    "            # For training, set N based on the length of json_list and a multiplier\n",
+    "            if N_multiplier is not None:\n",
+    "                N = 50 * len(json_list)  # Specific to training\n",
+    "            else:\n",
+    "                N = len(list(itertools.combinations(json_list, 2)))\n",
+    "\n",
+    "            random.shuffle(json_list)\n",
+    "            all_possible_pairs = list(itertools.combinations(json_list, 2))\n",
+    "            possible_pairs = []\n",
+    "\n",
+    "            for pair in all_possible_pairs:\n",
+    "                src_json_path, trg_json_path = pair\n",
+    "                with open(src_json_path) as f:\n",
+    "                    src_data = json.load(f)\n",
+    "                with open(trg_json_path) as f:\n",
+    "                    trg_data = json.load(f)\n",
+    "                src_kpt = np.array(src_data[\"keypoints\"]).reshape(-1, 3)\n",
+    "                trg_kpt = np.array(trg_data[\"keypoints\"]).reshape(-1, 3)\n",
+    "                mutual_vis = src_kpt[:, -1] / 2 * trg_kpt[:, -1] / 2\n",
+    "                if mutual_vis.sum() >= 3:\n",
+    "                    possible_pairs.append(pair)\n",
+    "\n",
+    "            # Adjust N based on the number of possible pairs\n",
+    "            N = min(N, len(possible_pairs))\n",
+    "            pairs_sampled = random.sample(possible_pairs, N) if N > 0 else []\n",
+    "\n",
+    "            for pair in pairs_sampled:\n",
+    "                src_json_path, trg_json_path = pair\n",
+    "                src_json_name, trg_json_name = os.path.basename(src_json_path).split(\".\")[0], os.path.basename(trg_json_path).split(\".\")[0]\n",
+    "                category_name = os.path.basename(os.path.dirname(src_json_path))\n",
+    "                new_json_file_name = f\"{src_json_name}-{trg_json_name}:{category_name}.json\"\n",
+    "                \n",
+    "                if not os.path.exists(output_folder):\n",
+    "                    os.makedirs(output_folder)\n",
+    "                new_json_path = os.path.join(output_folder, new_json_file_name)\n",
+    "                \n",
+    "                data = {\"src_json_path\": src_json_path, \"trg_json_path\": trg_json_path}\n",
+    "                with open(new_json_path, 'w') as f:\n",
+    "                    json.dump(data, f, indent=4)\n",
+    "                \n",
+    "                N_total_pairs += 1\n",
+    "\n",
+    "    print(f\"Total {N_total_pairs} pairs generated for {file_name}\")\n",
+    "\n",
+    "base_path = \"data/ap-10k/ImageAnnotation\"\n",
+    "# Generate for training set with a specific multiplier for N\n",
+    "generate_pairs(base_path, \"train_filtered.txt\", 'data/ap-10k/PairAnnotation/trn', N_multiplier=50)\n",
+    "# Generate for test and validation sets without the multiplier for N\n",
+    "generate_pairs(base_path, \"test_filtered.txt\", 'data/ap-10k/PairAnnotation/test')\n",
+    "generate_pairs(base_path, \"val_filtered.txt\", 'data/ap-10k/PairAnnotation/val')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import random\n",
+    "import json\n",
+    "import numpy as np\n",
+    "import itertools\n",
+    "\n",
+    "# Set the seed for reproducibility\n",
+    "random.seed(42)\n",
+    "\n",
+    "def generate_cross_species_pairs(base_path, file_name, output_folder, N_pairs_per_combination):\n",
+    "    N_total_pairs = 0\n",
+    "    subfolder_path = {}\n",
+    "    for root, dirs, files in os.walk(base_path):\n",
+    "        if root.count(os.sep) == base_path.count(os.sep) + 1:\n",
+    "            subfolder_path[root] = []\n",
+    "            for subroot, subdirs, subfiles in os.walk(root):\n",
+    "                if subroot.count(os.sep) == root.count(os.sep) + 1:\n",
+    "                    subfolder_path[root].append(subroot)\n",
+    "\n",
+    "    for key, value in subfolder_path.items():\n",
+    "        if len(value) > 1:  # the family has more than one species\n",
+    "            total_cross_species_pairs = []\n",
+    "            species_combination = list(itertools.combinations(value, 2))\n",
+    "            for species_pair in species_combination:\n",
+    "                with open(os.path.join(species_pair[0], file_name), 'r') as train_file:\n",
+    "                    train_json_list_1 = [line.strip() for line in train_file]\n",
+    "\n",
+    "                with open(os.path.join(species_pair[1], file_name), 'r') as train_file:\n",
+    "                    train_json_list_2 = [line.strip() for line in train_file]\n",
+    "\n",
+    "                cross_species_pairs = list(itertools.product(train_json_list_1, train_json_list_2))\n",
+    "                for pair in cross_species_pairs:\n",
+    "                    if random.random() > 0.5:\n",
+    "                        pair = (pair[1], pair[0])\n",
+    "                total_cross_species_pairs.extend(cross_species_pairs)\n",
+    "\n",
+    "            possible_pairs = []\n",
+    "            for pair in total_cross_species_pairs:\n",
+    "                src_json_path, trg_json_path = pair\n",
+    "                with open(src_json_path) as f:\n",
+    "                    src_data = json.load(f)\n",
+    "                with open(trg_json_path) as f:\n",
+    "                    trg_data = json.load(f)\n",
+    "                src_kpt = np.array(src_data[\"keypoints\"]).reshape(-1, 3)\n",
+    "                trg_kpt = np.array(trg_data[\"keypoints\"]).reshape(-1, 3)\n",
+    "                src_vis = src_kpt[:, -1] / 2\n",
+    "                trg_vis = trg_kpt[:, -1] / 2\n",
+    "                mutual_vis = src_vis * trg_vis\n",
+    "                if mutual_vis.sum() >= 3:\n",
+    "                    possible_pairs.append(pair)\n",
+    "\n",
+    "            N = min(N_pairs_per_combination, len(possible_pairs))\n",
+    "            pairs_sampled = random.sample(possible_pairs, N)\n",
+    "\n",
+    "            for pair in pairs_sampled:\n",
+    "                src_json_path, trg_json_path = pair\n",
+    "                src_json_name = os.path.basename(src_json_path).split(\".\")[0]\n",
+    "                trg_json_name = os.path.basename(trg_json_path).split(\".\")[0]\n",
+    "                category_name = os.path.basename(os.path.dirname(os.path.dirname(src_json_path)))\n",
+    "                new_json_file_name = f\"{src_json_name}-{trg_json_name}:{category_name}.json\"\n",
+    "                new_json_path = os.path.join(output_folder, new_json_file_name)\n",
+    "\n",
+    "                if not os.path.exists(output_folder):\n",
+    "                    os.makedirs(output_folder)\n",
+    "\n",
+    "                data = {\n",
+    "                    \"src_json_path\": src_json_path,\n",
+    "                    \"trg_json_path\": trg_json_path\n",
+    "                }\n",
+    "\n",
+    "                with open(new_json_path, 'w') as f:\n",
+    "                    json.dump(data, f, indent=4)\n",
+    "\n",
+    "            N_total_pairs += N\n",
+    "    \n",
+    "    print(f\"Total {N_total_pairs} pairs for {file_name}\")\n",
+    "\n",
+    "base_path = \"data/ap-10k/ImageAnnotation\"\n",
+    "generate_cross_species_pairs(base_path, \"val_filtered.txt\", 'data/ap-10k/PairAnnotation/val_cross_species', 400)\n",
+    "generate_cross_species_pairs(base_path, \"test_filtered.txt\", 'data/ap-10k/PairAnnotation/test_cross_species', 900)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import random\n",
+    "import json\n",
+    "import numpy as np\n",
+    "import itertools\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "# Set seed for reproducibility\n",
+    "random.seed(42)\n",
+    "\n",
+    "def generate_cross_family_pairs(base_path, file_name, output_folder, N_pairs_per_combination):\n",
+    "    N_total_pairs = 0\n",
+    "    subfolder_path = {}\n",
+    "\n",
+    "    # Collect all JSON file paths within each family\n",
+    "    for root, dirs, files in os.walk(base_path):\n",
+    "        if root.count(os.sep) == base_path.count(os.sep) + 1:\n",
+    "            subfolder_path[root] = []\n",
+    "            for subroot, subdirs, subfiles in os.walk(root):\n",
+    "                if subroot.count(os.sep) == root.count(os.sep) + 1:\n",
+    "                    with open(os.path.join(subroot, file_name), 'r') as train_file:\n",
+    "                        train_json_list = [line.strip() for line in train_file]\n",
+    "                    subfolder_path[root].extend(train_json_list)\n",
+    "\n",
+    "    # Iterate over combinations of families\n",
+    "    families_combination = list(itertools.combinations(subfolder_path.keys(), 2))\n",
+    "\n",
+    "    for family_pair in tqdm(families_combination, desc=\"Generating pairs\"):\n",
+    "        family_1, family_2 = family_pair\n",
+    "        family_1_json_list = subfolder_path[family_1]\n",
+    "        family_2_json_list = subfolder_path[family_2]\n",
+    "\n",
+    "        # Generate all possible pairs between two families\n",
+    "        cross_family_pairs = list(itertools.product(family_1_json_list, family_2_json_list))\n",
+    "\n",
+    "        # Filter out pairs based on visibility criteria\n",
+    "        possible_pairs = []\n",
+    "        for pair in cross_family_pairs:\n",
+    "            src_json_path, trg_json_path = pair\n",
+    "            with open(src_json_path) as f:\n",
+    "                src_data = json.load(f)\n",
+    "            with open(trg_json_path) as f:\n",
+    "                trg_data = json.load(f)\n",
+    "            src_kpt = np.array(src_data[\"keypoints\"]).reshape(-1, 3)\n",
+    "            trg_kpt = np.array(trg_data[\"keypoints\"]).reshape(-1, 3)\n",
+    "            mutual_vis = src_kpt[:, -1] / 2 * trg_kpt[:, -1] / 2\n",
+    "            if mutual_vis.sum() >= 3:\n",
+    "                possible_pairs.append(pair)\n",
+    "\n",
+    "        # Sample pairs if more are available than needed\n",
+    "        N = min(N_pairs_per_combination, len(possible_pairs))\n",
+    "        pairs_sampled = random.sample(possible_pairs, N)\n",
+    "\n",
+    "        # Create annotation files for sampled pairs\n",
+    "        for pair in pairs_sampled:\n",
+    "            src_json_path, trg_json_path = pair\n",
+    "            src_json_name, trg_json_name = os.path.basename(src_json_path).split(\".\")[0], os.path.basename(trg_json_path).split(\".\")[0]\n",
+    "            category_name = os.path.basename(os.path.dirname(os.path.dirname(src_json_path)))\n",
+    "            new_json_file_name = f\"{src_json_name}-{trg_json_name}:all.json\"\n",
+    "            new_json_path = os.path.join(output_folder, new_json_file_name)\n",
+    "\n",
+    "            if not os.path.exists(output_folder):\n",
+    "                os.makedirs(output_folder)\n",
+    "\n",
+    "            data = {\"src_json_path\": src_json_path, \"trg_json_path\": trg_json_path}\n",
+    "            with open(new_json_path, 'w') as f:\n",
+    "                json.dump(data, f, indent=4)\n",
+    "\n",
+    "            N_total_pairs += N\n",
+    "\n",
+    "    print(f\"Total {N_total_pairs} pairs generated for {file_name}\")\n",
+    "\n",
+    "base_path = \"data/ap-10k/ImageAnnotation\"\n",
+    "# Generate for test set\n",
+    "generate_cross_family_pairs(base_path, \"test_filtered.txt\", 'data/ap-10k/PairAnnotation/test_cross_family', 30)\n",
+    "# Generate for val set\n",
+    "generate_cross_family_pairs(base_path, \"val_filtered.txt\", 'data/ap-10k/PairAnnotation/val_cross_family', 20)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# visualize the key points of ap-10k benchmark\n",
+    "\n",
+    "import json\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "from glob import glob\n",
+    "from utils.utils_correspondence import resize\n",
+    "from utils.utils_visualization import draw_correspondences_gathered\n",
+    "from utils.utils_dataset import preprocess_kps_pad\n",
+    "\n",
+    "np.random.seed(42)\n",
+    "\n",
+    "def load_ap10k_data(path=\"data/ap-10k\", size=840, category='all', split='test_cross_family', subsample=20):\n",
+    "    np.random.seed(42)\n",
+    "    pairs = sorted(glob(f'{path}/PairAnnotation/{split}/*:{category}.json'))\n",
+    "    if subsample is not None and subsample > 0:\n",
+    "        pairs = [pairs[ix] for ix in np.random.choice(len(pairs), subsample)]\n",
+    "    # print(f'Number of SPairs for {category} = {len(pairs)}')\n",
+    "    files = []\n",
+    "    # print(f'Number of SPair key points for {category} <= {num_kps}')\n",
+    "    kps = []\n",
+    "    thresholds = []\n",
+    "    for pair in pairs:\n",
+    "        with open(pair) as f:\n",
+    "            data = json.load(f)\n",
+    "        source_json_path = data[\"src_json_path\"]\n",
+    "        target_json_path = data[\"trg_json_path\"]\n",
+    "        src_img_path = source_json_path.replace(\"json\", \"jpg\").replace('ImageAnnotation', 'JPEGImages')\n",
+    "        trg_img_path = target_json_path.replace(\"json\", \"jpg\").replace('ImageAnnotation', 'JPEGImages')\n",
+    "\n",
+    "        with open(source_json_path) as f:\n",
+    "            src_file = json.load(f)\n",
+    "        with open(target_json_path) as f:\n",
+    "            trg_file = json.load(f)\n",
+    "            \n",
+    "        source_bbox = np.asarray(src_file[\"bbox\"])  # l t w h\n",
+    "        target_bbox = np.asarray(trg_file[\"bbox\"])\n",
+    "        \n",
+    "        source_size = np.array([src_file[\"width\"], src_file[\"height\"]])  # (W, H)\n",
+    "        target_size = np.array([trg_file[\"width\"], trg_file[\"height\"]])  # (W, H)\n",
+    "\n",
+    "        # print(source_raw_kps.shape)\n",
+    "        source_kps = torch.tensor(src_file[\"keypoints\"]).view(-1, 3).float()\n",
+    "        source_kps[:,-1] /= 2\n",
+    "        source_kps, src_x, src_y, src_scale = preprocess_kps_pad(source_kps, source_size[0], source_size[1], size)\n",
+    "\n",
+    "        target_kps = torch.tensor(trg_file[\"keypoints\"]).view(-1, 3).float()\n",
+    "        target_kps[:,-1] /= 2\n",
+    "        target_kps, trg_x, trg_y, trg_scale = preprocess_kps_pad(target_kps, target_size[0], target_size[1], size)\n",
+    "        # The source thresholds aren't actually used to evaluate PCK on SPair-71K, but for completeness\n",
+    "        # they are computed as well:\n",
+    "        # thresholds.append(max(source_bbox[3] - source_bbox[1], source_bbox[2] - source_bbox[0]))\n",
+    "        if split == 'test':\n",
+    "            thresholds.append(max(target_bbox[3], target_bbox[2])*trg_scale)\n",
+    "        elif split == 'trn':\n",
+    "            thresholds.append(max(source_bbox[3], source_bbox[2])*src_scale)\n",
+    "            thresholds.append(max(target_bbox[3], target_bbox[2])*trg_scale)\n",
+    "\n",
+    "        kps.append(source_kps)\n",
+    "        kps.append(target_kps)\n",
+    "        files.append(src_img_path)\n",
+    "        files.append(trg_img_path)\n",
+    "\n",
+    "    kps = torch.stack(kps)\n",
+    "    used_kps, = torch.where(kps[:, :, 2].any(dim=0))\n",
+    "    kps = kps[:, used_kps, :]\n",
+    "    # print(f'Final number of used key points: {kps.size(1)}')\n",
+    "    return files, kps, thresholds, used_kps\n",
+    "\n",
+    "\n",
+    "files, kps, thresholds, used_kps = load_ap10k_data(category='all', split='test_cross_family') # one can specify the category and split\n",
+    "\n",
+    "pair_idx = 0\n",
+    "src_img = Image.open(files[2*pair_idx]).convert('RGB')\n",
+    "src_kps = kps[2*pair_idx]\n",
+    "src_img = resize(src_img, 840, resize=True, to_pil=True)\n",
+    "\n",
+    "trg_img = Image.open(files[2*pair_idx+1]).convert('RGB')\n",
+    "trg_kps = kps[2*pair_idx+1]\n",
+    "trg_img = resize(trg_img, 840, resize=True, to_pil=True)\n",
+    "\n",
+    "vis = src_kps[:, 2] * trg_kps[:, 2] > 0 #tensor([ True,  True,  True,  True,  True,  True,  True,  True, False,  True, True, False, False, False, False])\n",
+    "src_kps = src_kps[vis]\n",
+    "trg_kps = trg_kps[vis]\n",
+    "fig = draw_correspondences_gathered(src_kps[:, [1,0]], trg_kps[:, [1,0]], src_img, trg_img)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "sd-dino",
+   "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"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Code/Baselines/GeoAware-SC/process_feats_sd35.py

@@ -0,0 +1,280 @@
+import torch
+import os
+from tqdm import tqdm
+import numpy as np
+from PIL import Image
+from utils.utils_correspondence import resize
+from diffusers import StableDiffusion3Pipeline
+import sys
+from typing import List, Dict, Tuple
+import glob
+
+
+class FeatureExtractor:
+    """
+    A class to register hooks and extract features from specified layers of a model.
+    This version is redesigned to capture both the image and text branches from the
+    JointTransformerBlock.
+    """
+    def __init__(self, model, layers_to_extract: List[int]):
+        self.model = model
+        self.layers_to_extract = layers_to_extract
+        self.features: Dict[int, List[Tuple[torch.Tensor, torch.Tensor]]] = {}
+        self.hooks = []
+
+    def _get_hook(self, layer_idx: int):
+        def hook(model, input, output):
+            # The output of a JointTransformerBlock is a tuple: (hidden_states, encoder_hidden_states)
+            # 0: image branch, 1: text branch
+            image_branch_features = output[1].detach().cpu()
+            text_branch_features = output[0].detach().cpu()
+            
+            if layer_idx not in self.features:
+                self.features[layer_idx] = []
+            self.features[layer_idx].append((image_branch_features, text_branch_features))
+        return hook
+
+    def register_hooks(self):
+        if not hasattr(self.model, 'transformer_blocks'):
+            raise AttributeError("The provided model does not have 'transformer_blocks'. Make sure you pass `pipe.transformer`.")
+
+        for layer_idx in self.layers_to_extract:
+            if layer_idx < 0 or layer_idx >= len(self.model.transformer_blocks):
+                print(f"Warning: Layer index {layer_idx} is out of bounds. Skipping.")
+                continue
+            
+            layer = self.model.transformer_blocks[layer_idx]
+            hook_handle = layer.register_forward_hook(self._get_hook(layer_idx))
+            self.hooks.append(hook_handle)
+
+    def remove_hooks(self):
+        for hook in self.hooks:
+            hook.remove()
+        self.hooks = []
+        self.features = {}
+
+    def __enter__(self):
+        self.register_hooks()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.remove_hooks()
+
+
+def set_seed(seed=42):
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+    np.random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+
+
+
+def extract_feats_sd35(pipe, transformer, img_pil, category, timesteps, layers_to_extract, device):
+    image_tensor = torch.from_numpy(np.array(img_pil)).float() / 127.5 - 1.0
+    image_tensor = image_tensor.permute(2, 0, 1).unsqueeze(0).to(device, dtype=pipe.vae.dtype)
+
+    with torch.no_grad():
+        vae_output = pipe.vae.encode(image_tensor)
+        clean_latent = vae_output.latent_dist.sample() * pipe.vae.config.scaling_factor
+
+    print("Preparing text conditioning embeddings...")
+
+   
+    prompt = "A photo of {}".format(category)
+    print(f"Prompt: {prompt}")
+    prompt_embeds, negative_prompt_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds = pipe.encode_prompt(
+            prompt=prompt, prompt_2=prompt, prompt_3=None,
+            negative_prompt="", negative_prompt_2="", negative_prompt_3=None, device=device
+        )
+    
+    batched_prompt_embeds = torch.cat([prompt_embeds, negative_prompt_embeds], dim=0).to(pipe.transformer.dtype)
+    batched_pooled_embeds = torch.cat([pooled_prompt_embeds, negative_pooled_prompt_embeds], dim=0).to(pipe.transformer.dtype)
+
+    # --- 2. DATA COLLECTION LOOP ---
+    # cond_feats = [[None for _ in LAYERS_TO_EXTRACT] for _ in TIMESTEPS]
+    # name_list = [[None for _ in LAYERS_TO_EXTRACT] for _ in TIMESTEPS]
+    cond_feats = []
+    name_list = []
+    # uncond_figs = [[None for _ in LAYERS_TO_EXTRACT] for _ in TIMESTEPS]
+
+    for i, ts_val in enumerate(timesteps):
+        print(f"\n===== Processing Timestep: {ts_val} =====\n")
+            
+        # Apply noise for the current timestep
+        noise = torch.randn_like(clean_latent)
+        t = torch.tensor([ts_val], device=device, dtype=clean_latent.dtype)
+        t_reshaped = t.reshape(-1, *([1] * (clean_latent.dim() - 1)))
+        noised_latent = (1 - t_reshaped) * clean_latent + t_reshaped * noise
+            
+        # Prepare inputs for the transformer (batch for CFG)
+        noised_latent_for_model = torch.cat([noised_latent] * 2).to(pipe.transformer.dtype)
+        timestep_for_model = torch.cat([t] * 2).to(pipe.transformer.dtype) * 1000
+
+        with FeatureExtractor(transformer, layers_to_extract) as extractor:
+            with torch.no_grad():
+                transformer(
+                        hidden_states=noised_latent_for_model,
+                        timestep=timestep_for_model,
+                        encoder_hidden_states=batched_prompt_embeds,
+                        pooled_projections=batched_pooled_embeds,
+                        return_dict=False
+                    )
+
+            # Process features for each requested layer at this timestep
+            for j, layer_idx in enumerate(layers_to_extract):
+                print(f"--- Analyzing Layer {layer_idx} ---")
+                if layer_idx in extractor.features:
+                    # The hook returns a list with one item (from the single forward pass)
+                    # which is a tuple of (image_batch_features, text_batch_features)
+                    img_features_batch, _ = extractor.features[layer_idx][0]
+                        
+                    # Separate cond and uncond features
+                    cond_img_features = img_features_batch[0]
+
+                    # num_patch = np.sqrt(cond_img_features.shape[0])
+                    # print(f"Number of patches: {num_patch}")
+                    # cond_img_features = cond_img_features.reshape(1, -1, int(num_patch), int(num_patch))  # (B, H, W, C)
+                    # # uncond_img_features = img_features_batch[1]
+
+                    # print(cond_img_features.shape)
+                    # cond_feats[i][j] = cond_img_features
+                    cond_feats.append(cond_img_features)
+
+                    name = "t_{}_layer_{}".format(ts_val, layer_idx)
+                    # name_list[i][j] = name
+                    name_list.append(name)
+
+                    # normalize 
+                    # print(cond_img_features.shape, uncond_img_features.shape)
+                        
+                    # # Run PCA and store the resulting image arrays
+                    # cond_figs[i][j] = get_pca_image(cond_img_features)
+                    # uncond_figs[i][j] = get_pca_image(uncond_img_features)
+                    # print(f"Stored PCA images for Layer {layer_idx}")
+            
+    return cond_feats, name_list
+
+
+def process_and_save_features(file_paths, real_size, pipe, transformer, flip=False, angle=0, device=None, PF_pascal=False):
+    for file_path in tqdm(file_paths, desc="Processing images (Flip: {})".format(flip)):
+        img1 = Image.open(file_path).convert('RGB')
+        if flip:
+            img1 = img1.transpose(Image.FLIP_LEFT_RIGHT)
+        # img1 = edge_pad_rotate_and_crop(img1, angle=angle) # Uncomment this line to enable different rotation
+        img1_input = resize(img1, real_size, resize=True, to_pil=True)
+        # img1 = resize(img1, img_size, resize=True, to_pil=True)
+
+        if PF_pascal:
+
+            base_annotation_path = file_path.replace('JPEGImages', 'Annotations')
+            # base_annotation_path will be 'path/to/your/Datasets/PF-dataset-PASCAL/Annotations/2009_002457.jpg'
+
+            # 2. Extract the directory part of the annotation path
+            #    This will give 'path/to/your/Datasets/PF-dataset-PASCAL/Annotations'
+            directory_part = os.path.dirname(base_annotation_path)
+
+            # 3. Extract the filename part (including .mat extension)
+            #    This will give '2009_002457.mat'
+            filename_part = os.path.basename(file_path).replace('.jpg', '.mat')
+
+            # # 4. Construct the desired path with the wildcard
+            # file_path_annot_wildcard = os.path.join(directory_part, '*', filename_part)
+            # # category = 
+            # # file_path = file_path.replace('JPEGImages', 'Annotations').replace('.jpg', '.mat')
+            # file_name = os.path.basename(file_path)
+
+            # # print(file_path.replace('JPEGImages', 'Annotations').replace('.jpg', '.mat'))
+
+            # parts = file_path.replace('JPEGImages', 'Annotations').replace('.jpg', '.mat')
+            # annotations_idx = parts.index('Annotations')
+            # # Insert '*' after 'Annotations'
+            # parts.insert(annotations_idx + 1, '*')
+            
+            file_path_annot = glob.glob(os.path.join(directory_part, '*', filename_part))  # Assuming annotations are in .mat files
+            
+            # print(file_name)
+            # print(file_path_annot)
+
+            category = file_path_annot[0].split('/')[-2] #if file_path_annot else 'unknown_category'
+            # print(category)
+        else:
+            print(file_path)
+            category = file_path.split('/')[-2]  # Assuming category is the parent directory name
+
+        # break
+
+        accumulated_features = {}
+        for _ in range(NUM_ENSEMBLE): 
+            # print('model device:', model.device)
+            # features1 = process_features_and_mask(model, aug, img1_input, mask=False, raw=True, device=device)
+            features1, name_list = extract_feats_sd35(pipe, transformer, img1_input, category=category)  # Example category
+
+            for name, features in zip(name_list, features1):
+                accumulated_features[name] = accumulated_features.get(name, 0) + features
+
+
+            # del features1['s2']
+            # for k in features1:
+            #     accumulated_features[k] = accumulated_features.get(k, 0) + features1[k]
+
+        for k in accumulated_features:
+            accumulated_features[k] /= NUM_ENSEMBLE
+
+        subdir_name = 'features' if NUM_ENSEMBLE == 1 else f'features_ensemble{NUM_ENSEMBLE}'
+        output_subdir = file_path.replace('JPEGImages', subdir_name).rsplit('/', 1)[0]
+        os.makedirs(output_subdir, exist_ok=True)
+        
+        suffix = '_flip' if flip else ''
+        output_path = os.path.join(output_subdir, os.path.splitext(os.path.basename(file_path))[0] + f'_sd35{suffix}.pt')
+        torch.save(accumulated_features, output_path)
+
+        # clear memory
+        torch.cuda.empty_cache()
+
+        # print(output_path)
+        # break
+
+        # img1_batch = extractor_vit.preprocess_pil(img1)
+        # img1_desc_dino = extractor_vit.extract_descriptors(img1_batch.to(device), layer, facet).permute(0, 1, 3, 2).reshape(1, -1, 60, 60) # img1_batch.cuda()
+        # output_path_dino = os.path.join(output_subdir, os.path.splitext(os.path.basename(file_path))[0] + f'_dino{suffix}.pt')
+        # torch.save(img1_desc_dino, output_path_dino)
+
+
+
+if __name__ == '__main__':
+    set_seed()
+
+    NUM_ENSEMBLE = 1
+    TIMESTEPS = [0.5]
+    LAYERS_TO_EXTRACT = [3, 5, 6, 9, 10, 12, 15, 18, 20, 21]  # Example layer indices to extract features from
+
+    real_size = 960
+
+    MODEL_ID = "stabilityai/stable-diffusion-3-medium-diffusers"
+    # DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+
+    base_dir = sys.argv[1] if len(sys.argv) > 1 else 'data/SPair-71k/JPEGImages'
+    # set the device using the second argument if provided, otherwise use 'cuda'
+    device_str = sys.argv[2] if len(sys.argv) > 2 else 'cuda'
+    PF_pascal = sys.argv[3] if len(sys.argv) > 3 else False
+    print(f"Using device: {device_str}")
+    DEVICE = torch.device(device_str if torch.cuda.is_available() else "cpu")
+
+    print(f"Using device: {DEVICE}")
+    print(f"Loading pipeline: {MODEL_ID}...")
+
+    pipe = StableDiffusion3Pipeline.from_pretrained(MODEL_ID, torch_dtype=torch.float16)
+    pipe = pipe.to(DEVICE)
+    transformer = pipe.transformer
+
+    print("Pipeline loaded successfully.")
+
+    all_files = [os.path.join(subdir, file) for subdir, dirs, files in os.walk(base_dir) for file in files if file.endswith('.jpg')]
+
+    angles = [0] # angles for rotation
+    for angle in angles:
+        # Process and save features
+        process_and_save_features(all_files, real_size, pipe, transformer, flip=False, angle=angle, device=DEVICE, PF_pascal=PF_pascal)
+        process_and_save_features(all_files, real_size, pipe, transformer, flip=True, angle=angle, device=DEVICE, PF_pascal=PF_pascal)

Code/Baselines/Orient-Anything/.gitignore

@@ -0,0 +1,4 @@
+**/__pycache__
+.gradio
+.locks
+models*

Code/Baselines/Orient-Anything/LICENSE

@@ -0,0 +1,395 @@
+Attribution 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution 4.0 International Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution 4.0 International Public License ("Public License"). To the
+extent this Public License may be interpreted as a contract, You are
+granted the Licensed Rights in consideration of Your acceptance of
+these terms and conditions, and the Licensor grants You such rights in
+consideration of benefits the Licensor receives from making the
+Licensed Material available under these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  d. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  e. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  f. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  g. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  h. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  i. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  j. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  k. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+       4. If You Share Adapted Material You produce, the Adapter's
+          License You apply must not prevent recipients of the Adapted
+          Material from complying with this Public License.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material; and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

Code/Baselines/Orient-Anything/README.md

@@ -0,0 +1,124 @@
+<div align="center">
+<h2>Orient Anything: Learning Robust Object Orientation Estimation from Rendering 3D Models</h2>
+
+[**Zehan Wang**](https://scholar.google.com/citations?user=euXK0lkAAAAJ&hl=zh-CN)<sup>1*</sup> · [**Ziang Zhang**](https://scholar.google.com/citations?hl=zh-CN&user=DptGMnYAAAAJ)<sup>1*</sup> · [**Tianyu Pang**](https://scholar.google.com/citations?hl=zh-CN&user=wYDbtFsAAAAJ)<sup>2</sup> · [**Du Chao**](https://scholar.google.com/citations?hl=zh-CN&user=QOp7xW0AAAAJ)<sup>2</sup> · [**Hengshuang Zhao**](https://scholar.google.com/citations?user=4uE10I0AAAAJ&hl&oi=ao)<sup>3</sup> · [**Zhou Zhao**](https://scholar.google.com/citations?user=IIoFY90AAAAJ&hl&oi=ao)<sup>1</sup>
+
+<sup>1</sup>Zhejiang University&emsp;&emsp;&emsp;&emsp;<sup>2</sup>SEA AI Lab&emsp;&emsp;&emsp;&emsp;<sup>3</sup>HKU
+
+*Equal Contribution
+
+
+<a href='https://arxiv.org/abs/2412.18605'><img src='https://img.shields.io/badge/arXiv-Orient Anything-red' alt='Paper PDF'></a>
+<a href='https://orient-anything.github.io'><img src='https://img.shields.io/badge/Project_Page-Orient Anything-green' alt='Project Page'></a>
+<a href='https://huggingface.co/spaces/Viglong/Orient-Anything'><img src='https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue'></a>
+<a href='https://huggingface.co/papers/2412.18605'><img src='https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Paper-yellow'></a>
+</div>
+
+**Orient Anything**, a robust image-based object orientation estimation model. By training on 2M rendered labeled images, it achieves strong zero-shot generalization ability for images in the wild.
+
+![teaser](assets/demo.png)
+
+## News
+* **2025-05-01:** Orient Anything is accepted by ICML 2025!
+* **2024-12-24:** [Paper](https://arxiv.org/abs/2412.18605), [Project Page](https://orient-anything.github.io), [Code](https://github.com/SpatialVision/Orient-Anything), Models, and [Demo](https://huggingface.co/spaces/Viglong/Orient-Anything) are released.
+
+
+
+## Pre-trained models
+
+We provide **three models** of varying scales for robust object orientation estimation in images:
+
+| Model | Params | Checkpoint |
+|:-|-:|:-:|
+| Orient-Anything-Small | 23.3 M | [Download](https://huggingface.co/Viglong/OriNet/blob/main/cropsmallEx03/dino_weight.pt) |
+| Orient-Anything-Base | 87.8 M | [Download](https://huggingface.co/Viglong/OriNet/blob/main/cropbaseEx032/dino_weight.pt) |
+| Orient-Anything-Large | 305 M | [Download](https://huggingface.co/Viglong/OriNet/blob/main/croplargeEX2/dino_weight.pt) |
+
+## Usage
+
+### 1 Prepraration
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2 Use our models
+#### 2.1 In Gradio app
+Start gradio by executing the following script:
+
+```bash
+python app.py
+```
+then open GUI page(default is https://127.0.0.1:7860) in web browser.
+
+or, you can try it in our [Huggingface-Space](https://huggingface.co/spaces/Viglong/Orient-Anything)
+
+#### 2.2 In Python Scripts
+```python
+from paths import *
+from vision_tower import DINOv2_MLP
+from transformers import AutoImageProcessor
+import torch
+from PIL import Image
+
+import torch.nn.functional as F
+from utils import *
+from inference import *
+
+from huggingface_hub import hf_hub_download
+ckpt_path = hf_hub_download(repo_id="Viglong/Orient-Anything", filename="croplargeEX2/dino_weight.pt", repo_type="model", cache_dir='./', resume_download=True)
+print(ckpt_path)
+
+save_path = './'
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+dino = DINOv2_MLP(
+                    dino_mode   = 'large',
+                    in_dim      = 1024,
+                    out_dim     = 360+180+180+2,
+                    evaluate    = True,
+                    mask_dino   = False,
+                    frozen_back = False
+                )
+
+dino.eval()
+print('model create')
+dino.load_state_dict(torch.load(ckpt_path, map_location='cpu'))
+dino = dino.to(device)
+print('weight loaded')
+val_preprocess   = AutoImageProcessor.from_pretrained(DINO_LARGE, cache_dir='./')
+
+image_path = '/path/to/image'
+origin_image = Image.open(image_path).convert('RGB')
+angles = get_3angle(origin_image, dino, val_preprocess, device)
+azimuth     = float(angles[0])
+polar       = float(angles[1])
+rotation    = float(angles[2])
+confidence  = float(angles[3])
+
+
+```
+
+
+### Best Practice
+To avoid ambiguity, our model only supports inputs that contain images of a single object. For daily images that usually contain multiple objects, it is a good choice to isolate each object with DINO-grounding and predict the orientation separately.
+```python
+[ToDo]
+```
+### Test-Time Augmentation
+In order to further enhance the robustness of the model，We further propose the test-time ensemble strategy. The input images will be randomly cropped into different variants, and the predicted orientation of different variants will be voted as the final prediction result. We implement this strategy in functions `get_3angle_infer_aug()` and `get_crop_images()`.
+
+## Citation
+
+If you find this project useful, please consider citing:
+
+```bibtex
+@article{orient_anything,
+  title={Orient Anything: Learning Robust Object Orientation Estimation from Rendering 3D Models},
+  author={Wang, Zehan and Zhang, Ziang and Pang, Tianyu and Du, Chao and Zhao, Hengshuang and Zhao, Zhou},
+  journal={arXiv:2412.18605},
+  year={2024}
+}
+```
+
+## Acknowledgement
+Thanks to the open source of the following projects: [Grounded-Segment-Anything](https://github.com/IDEA-Research/Grounded-Segment-Anything), [render-py](https://github.com/tvytlx/render-py)

Code/Baselines/Orient-Anything/app.py

@@ -0,0 +1,72 @@
+import gradio as gr
+from paths import *
+
+from vision_tower import DINOv2_MLP
+from transformers import AutoImageProcessor
+import torch
+from inference import *
+from utils import *
+
+from huggingface_hub import hf_hub_download
+ckpt_path = hf_hub_download(repo_id="Viglong/Orient-Anything", filename="croplargeEX2/dino_weight.pt", repo_type="model", cache_dir='./', resume_download=True)
+print(ckpt_path)
+
+save_path = './'
+device = 'cpu'
+dino = DINOv2_MLP(
+                    dino_mode   = 'large',
+                    in_dim      = 1024,
+                    out_dim     = 360+180+180+2,
+                    evaluate    = True,
+                    mask_dino   = False,
+                    frozen_back = False
+                )
+
+dino.eval()
+print('model create')
+dino.load_state_dict(torch.load(ckpt_path, map_location='cpu'))
+dino = dino.to(device)
+print('weight loaded')
+val_preprocess   = AutoImageProcessor.from_pretrained(DINO_LARGE, cache_dir='./')
+
+def infer_func(img, do_rm_bkg, do_infer_aug):
+    origin_img = Image.fromarray(img)
+    if do_infer_aug:
+        rm_bkg_img = background_preprocess(origin_img, True)
+        angles = get_3angle_infer_aug(origin_img, rm_bkg_img, dino, val_preprocess, device)
+    else:
+        rm_bkg_img = background_preprocess(origin_img, do_rm_bkg)
+        angles = get_3angle(rm_bkg_img, dino, val_preprocess, device)
+    
+    phi   = np.radians(angles[0])
+    theta = np.radians(angles[1])
+    gamma = angles[2]
+    confidence = float(angles[3])
+    if confidence > 0.5:
+        render_axis = render_3D_axis(phi, theta, gamma)
+        res_img = overlay_images_with_scaling(render_axis, rm_bkg_img)
+    else:
+        res_img = img
+    
+    # axis_model = "axis.obj"
+    return [res_img, round(float(angles[0]), 2), round(float(angles[1]), 2), round(float(angles[2]), 2), round(float(angles[3]), 2)]
+
+server = gr.Interface(
+    flagging_mode='never',
+    fn=infer_func, 
+    inputs=[
+        gr.Image(height=512, width=512, label="upload your image"),
+        gr.Checkbox(label="Remove Background", value=True),
+        gr.Checkbox(label="Inference time augmentation", value=False)
+    ], 
+    outputs=[
+        gr.Image(height=512, width=512, label="result image"),
+        # gr.Model3D(clear_color=[0.0, 0.0, 0.0, 0.0],  label="3D Model"),
+        gr.Textbox(lines=1, label='Azimuth(0~360°)'),
+        gr.Textbox(lines=1, label='Polar(-90~90°)'),
+        gr.Textbox(lines=1, label='Rotation(-90~90°)'),
+        gr.Textbox(lines=1, label='Confidence(0~1)')
+    ]
+)
+
+server.launch()

Code/Baselines/Orient-Anything/evaluate_orientation.py

@@ -0,0 +1,119 @@
+import torch
+import argparse
+import wandb
+from transformers import AutoImageProcessor
+import torch
+from PIL import Image, ImageDraw
+import torch.nn.functional as F
+from huggingface_hub import hf_hub_download
+import matplotlib.pyplot as plt
+import os
+from tqdm import tqdm
+import json
+
+# custom imports
+from paths import *
+from vision_tower import DINOv2_MLP
+from utils import *
+from inference import *
+
+
+
+def load_dataset(args):
+    if args.EVAL_DATASET == 'spair':
+        # orient_path = '../../../Datasets/SPair-71k/OrientationAnnotation/'
+        orient_path = '../../../Datasets/SPair-71k/OrientationAnnotation_bgd_rmv'
+        annot_path = '../../../Datasets/SPair-71k/ImageAnnotation/'
+
+        assert len(os.listdir(orient_path)) == len(os.listdir(annot_path)) and len(os.listdir(orient_path)) > 0, "Image and annotation counts do not match."
+
+    return orient_path, annot_path
+
+
+# def group_azimuth(azimuth):
+
+#     if 0 <= azimuth < 45:
+#         bin_id = 0
+#     elif 45 <= azimuth < 90:
+#         bin_id = 1
+#     elif 90 <= azimuth < 135:
+#         bin_id = 2
+#     elif 135 <= azimuth < 180:
+#         bin_id = 3
+#     elif 180 <= azimuth < 225:
+#         bin_id = 4
+#     elif 225 <= azimuth < 270:
+#         bin_id = 5
+#     elif 270 <= azimuth < 315:
+#         bin_id = 6
+#     elif 315 <= azimuth < 360:
+#         bin_id = 7
+        
+#     return bin_id
+
+def compute_azimuth_id(azimuth_pred, degree_each_bin=90):
+    return int(azimuth_pred // degree_each_bin) % (360 // degree_each_bin)
+
+def group_azimuth(azimuth_bin_id, new_bin_size=4):
+    org_bin_size = 8
+    return azimuth_bin_id // int(org_bin_size / new_bin_size)
+
+
+# def compute_accuracy(azimuth_pred, azimuth_gt):
+
+
+
+
+def main(args):
+
+    orient_path, annot_path = load_dataset(args)
+
+    categories = os.listdir(orient_path)
+
+
+    # correct_count = 0
+    total_correct_count = 0
+    total_count = 0
+    for category in tqdm(categories):
+        category_path = os.path.join(orient_path, category)
+        images = os.listdir(category_path)
+        
+        category_correct_count = 0
+        category_total_count = 0
+        for image_name in images:
+            orient_full_path = os.path.join(category_path, image_name)
+            annot_full_path = os.path.join(annot_path, category, image_name)
+
+            with open(orient_full_path, 'r') as f:
+                orient_data = json.load(f)
+            
+            with open(annot_full_path, 'r') as f:
+                annot_data = json.load(f)
+            
+            azimuth = orient_data['azimuth']
+
+            # azimuth_pred = group_azimuth(azimuth)
+            azimuth_pred = compute_azimuth_id(azimuth, degree_each_bin=45)
+            azimuth_gt = group_azimuth(annot_data['azimuth_id'], new_bin_size=8)
+
+            category_total_count += 1
+            total_count += 1
+            if azimuth_pred == azimuth_gt:
+                category_correct_count += 1
+
+        total_correct_count += category_correct_count
+        print(f"Category: {category}, Correct: {category_correct_count}/{category_total_count}, Accuracy: {category_correct_count/category_total_count:.4f}")
+
+    
+    # accuracy = correct_count / len(categories)
+    accuracy = total_correct_count / total_count
+    print(f"Total Correct: {total_correct_count}/{total_count}, Overall Accuracy: {accuracy:.4f}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Orient-Anything Quick Try Demo")
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, help='Path to the evaluation dataset')
+
+    args = parser.parse_args()
+
+    main(args)

Code/Baselines/Orient-Anything/extract_orientation.py

@@ -0,0 +1,290 @@
+import torch
+import argparse
+import wandb
+from transformers import AutoImageProcessor
+import torch
+from PIL import Image, ImageDraw
+import torch.nn.functional as F
+from huggingface_hub import hf_hub_download
+import matplotlib.pyplot as plt
+import os
+from tqdm import tqdm
+import json
+from typing import Dict
+
+# custom imports
+from paths import *
+from vision_tower import DINOv2_MLP
+from utils import *
+from inference import *
+
+
+def load_model(ckpt_path, device):
+    # save_path = './'
+    
+    # dino = DINOv2_MLP(
+    #                     dino_mode   = 'large',
+    #                     in_dim      = 1024,
+    #                     out_dim     = 360+180+180+2,
+    #                     evaluate    = True,
+    #                     mask_dino   = False,
+    #                     frozen_back = False
+    #                 )
+
+    # hugging face demo version
+    dino = DINOv2_MLP(
+                    dino_mode   = 'large',
+                    in_dim      = 1024,
+                    out_dim     = 360+180+360+2,
+                    evaluate    = True,
+                    mask_dino   = False,
+                    frozen_back = False
+                )
+
+    dino.eval()
+    print('model create')
+    dino.load_state_dict(torch.load(ckpt_path, map_location='cpu'))
+    dino = dino.to(device)
+    print('weight loaded')
+    val_preprocess   = AutoImageProcessor.from_pretrained(DINO_LARGE, cache_dir='./')
+
+    return dino, val_preprocess
+
+
+def load_dataset(args):
+    if args.EVAL_DATASET == 'spair':
+        # image_path = '../../../Datasets/SPair-71k/JPEGImages/'
+        image_path = '../../../Datasets/SPair-71k/JPEGImages_bgd_rmv'
+        annot_path = '../../../Datasets/SPair-71k/ImageAnnotation/'
+
+        assert len(os.listdir(image_path)) == len(os.listdir(annot_path)) and len(os.listdir(image_path)) > 0, "Image and annotation counts do not match."
+
+    return image_path, annot_path
+
+
+def convert_rgba_to_rgb(image_pil):
+    # Convert RGBA to RGB if the image has an alpha channel
+    background = Image.new("RGB", image_pil.size, (255, 255, 255))  # White background
+    background.paste(image_pil, mask=image_pil.split()[3])  # Use the alpha channel as a mask
+    return background
+
+
+# def describe_orientation(azimuth, polar, category):
+
+#     if category == 'pottedplant' and category == 'tvmonitor' and category == 'bottle' and category == 'train':
+#         azimuth_desc = "facing the viewer"
+
+#     else:
+#         if 0 <= azimuth <= 22.5 or 292.5 < azimuth <= 360:
+#             azimuth_desc = "facing the viewer"
+        
+#         elif 22.5 < azimuth <= 67.5:
+#             azimuth_desc = "facing the viewer and to the left"
+
+#         elif 67.5 < azimuth <= 112.5:
+#             azimuth_desc = "to the left of the viewer"
+        
+#         elif 112.5 < azimuth <= 157.5:
+#             azimuth_desc = "away from the viewer and to the left"
+        
+#         elif 157.5 < azimuth <= 202.5:
+#             azimuth_desc = "away from the viewer"
+        
+#         elif 202.5 < azimuth <= 247.5:
+#             azimuth_desc = "away from the viewer and to the right"
+        
+#         elif 247.5 < azimuth <= 292.5:
+#             azimuth_desc = "to the right of the viewer"
+        
+#         elif 292.5 < azimuth <= 337.5:
+#             azimuth_desc = "facing the viewer and to the right"
+
+#     if -22.5 < polar <= 22.5:
+#         polar_desc = "side view"
+    
+#     elif 22.5 < polar <= 90:
+#         polar_desc = "top view"
+    
+#     elif -90 < polar <= -22.5:
+#         polar_desc = "bottom view"
+
+#     return {"azimuth_description": azimuth_desc, "polar_description": polar_desc}
+
+def describe_orientation(azimuth: float, polar: float, *, confidence: float | None = None) -> Dict:
+    """
+    azimuth: yaw in degrees, 0 = toward viewer, 90 = facing left, 180 = away, 270 = facing right
+    polar  : elevation in degrees; + up (top view), - down (bottom view); 0 ≈ side
+    returns a structured viewer-centric hint
+    """
+    # az = _bucket_angle(azimuth)
+    assert azimuth >= 0 and azimuth < 360, "Azimuth must be in the range [0, 360)"
+    az = azimuth
+    po = polar
+
+    # ---- Facing & yaw_bias ---------------------------------------------------
+    # Main facing from octants; diagonals become a bias on the nearest cardinal
+    if 337.5 <= az or az <= 22.5:
+        facing, yaw_bias = "toward viewer", "none"
+    elif 22.5 < az <= 67.5:
+        facing, yaw_bias = "toward viewer", "left"
+    elif 67.5 < az <= 112.5:
+        facing, yaw_bias = "facing left", "none"
+    elif 112.5 < az <= 157.5:
+        facing, yaw_bias = "away from viewer", "left"
+    elif 157.5 < az <= 202.5:
+        facing, yaw_bias = "away from viewer", "none"
+    elif 202.5 < az <= 247.5:
+        facing, yaw_bias = "away from viewer", "right"
+    elif 247.5 < az <= 292.5:
+        facing, yaw_bias = "facing right", "none"
+    elif 292.5 < az <= 337.5:
+        facing, yaw_bias = "toward viewer", "right"
+    else:
+        facing, yaw_bias = "unknown", "none"
+
+    # ---- Elevation bucket ----------------------------------------------------
+    if -22.5 < po <= 22.5:
+        elevation = "side"
+    elif 22.5 < po <= 60:
+        elevation = "oblique-top"
+    elif po > 60:
+        elevation = "top-down"
+    elif -60 <= po <= -22.5:
+        elevation = "oblique-bottom"
+    else:  # po < -60
+        elevation = "bottom-up"
+
+    # ---- Near-side in object-centric terms ----------------------------------
+    if facing == "facing left":
+        near_side = "object-left"
+    elif facing == "facing right":
+        near_side = "object-right"
+    elif facing == "toward viewer":
+        near_side = "object-left" if yaw_bias == "left" else ("object-right" if yaw_bias == "right" else "none")
+    elif facing == "away from viewer":
+        # flipped: when looking at the back, the opposite side appears nearer
+        near_side = "object-right" if yaw_bias == "left" else ("object-left" if yaw_bias == "right" else "none")
+    else:
+        near_side = "none"
+
+    return {
+        "facing": facing,                 # enum (camera-relative)
+        "yaw_bias": yaw_bias,             # enum (camera-relative)
+        "elevation": elevation,           # enum (camera-relative) 
+        "near_side": near_side,           # enum (object-centric)
+        "confidence": confidence,
+    }
+
+
+def main(args):
+
+    # ckpt_path = hf_hub_download(repo_id="Viglong/Orient-Anything", filename="croplargeEX2/dino_weight.pt", repo_type="model", cache_dir='./', resume_download=True)
+    ckpt_path = hf_hub_download(repo_id="Viglong/Orient-Anything", filename="ronormsigma1/dino_weight.pt", repo_type="model", cache_dir='./', resume_download=True)
+
+    # device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    
+    dino, val_preprocess = load_model(ckpt_path, args.DEVICE)
+    image_path, annot_path = load_dataset(args)
+
+    categories = os.listdir(image_path)
+
+    # Initialize WandB
+    print("Initializing WandB...")
+    wandb.init(
+        project=args.EVAL_DATASET,
+        entity="amazon_intern2025",
+        name=args.EXP_NOTE,
+        config=vars(args)
+    )
+
+    results_table = wandb.Table(columns=["category", "img_id", "img", "azimuth", "polar", "rotation", "confidence", "description"])
+
+    for category in tqdm(categories):
+        category_path = os.path.join(image_path, category)
+        images = os.listdir(category_path)
+
+        for image_name in images:
+
+            image_full_path = os.path.join(category_path, image_name)
+
+            if '_bgd_rmv' in image_name:
+                img_id = image_name.split('_bgd_rmv')[0]
+                annot_full_path = os.path.join(annot_path, category, img_id+'.json')
+                origin_image = Image.open(image_full_path).convert('RGBA')
+                origin_image = convert_rgba_to_rgb(origin_image)  # Convert RGBA to RGB if needed
+                save_name = img_id + '.json'
+            else:
+                annot_full_path = os.path.join(annot_path, category, image_name.replace('.jpg', '.json'))
+                origin_image = Image.open(image_full_path).convert('RGB')
+                save_name = image_name.replace('.jpg', '.json')
+
+            with open(annot_full_path, 'r') as f:
+                annot = json.load(f)
+              
+            # cropped_image = origin_image.crop(annot['bndbox'])
+
+            # angles = get_3angle(cropped_image, dino, val_preprocess, args.DEVICE)
+            angles = get_3angle(origin_image, dino, val_preprocess, args.DEVICE)
+            azimuth, polar, rotation, confidence = map(float, angles)
+
+            desc_dict = describe_orientation(azimuth, polar, category)
+
+            
+            save_path = os.path.join(args.SAVE_PATH, category)
+            os.makedirs(save_path, exist_ok=True)
+
+            output_json = {
+                "image_name": image_name,
+                "category": category,
+                "azimuth": azimuth,
+                "polar": polar,
+                "rotation": rotation,
+                "confidence": confidence,
+                "azimuth_desc": desc_dict["azimuth_description"],
+                "polar_desc": desc_dict["polar_description"],
+            }
+
+            with open(os.path.join(save_path, save_name), 'w') as f:
+                json.dump(output_json, f, indent=4)
+
+            # draw bounding box on the image and log to WandB
+            img_bbox = origin_image.copy()
+            draw = ImageDraw.Draw(img_bbox)
+            draw.rectangle(annot['bndbox'], outline="red", width=2)
+
+
+            wandb_image = wandb.Image(img_bbox)
+
+            results_table.add_data(
+                category,
+                image_name,
+                wandb_image,
+                azimuth,
+                polar,
+                rotation,
+                confidence,
+                # json.dumps(desc_dict)
+                f"Azimuth: {desc_dict['azimuth_description']}, Polar: {desc_dict['polar_description']}"
+            )
+
+            # print(f"Image: {image_name}, Azimuth: {azimuth}, Polar: {polar}, Rotation: {rotation}, Confidence: {confidence}")
+
+            # # Optionally visualize the image
+            # plt.imshow(origin_image)
+            # plt.title(f"Azimuth: {azimuth}, Polar: {polar}, Rotation: {rotation}")
+            # plt.show()
+
+    wandb.log({"results": results_table})
+    wandb.finish()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Orient-Anything Quick Try Demo")
+    parser.add_argument('--EVAL_DATASET', type=str, required=True, help='Path to the evaluation dataset')
+    parser.add_argument('--SAVE_PATH', type=str, required=True, help='Path to save the results')
+
+    parser.add_argument('--DEVICE', type=str, default='cuda' if torch.cuda.is_available() else 'cpu', help='Device to run the model on')
+    parser.add_argument('--EXP_NOTE', type=str, default='quick_try_demo', help='Experiment note for WandB')
+
+    args = parser.parse_args()
+
+    main(args)

Code/Baselines/Orient-Anything/inference.py

@@ -0,0 +1,103 @@
+# import torch
+# from PIL import Image
+# from utils import *
+# import torch.nn.functional as F
+# import numpy as np
+
+# def get_3angle(image, dino, val_preprocess, device):
+    
+#     # image = Image.open(image_path).convert('RGB')
+#     image_inputs = val_preprocess(images = image)
+#     image_inputs['pixel_values'] = torch.from_numpy(np.array(image_inputs['pixel_values'])).to(device)
+#     with torch.no_grad():
+#         dino_pred = dino(image_inputs)
+
+#     gaus_ax_pred   = torch.argmax(dino_pred[:, 0:360], dim=-1)
+#     gaus_pl_pred   = torch.argmax(dino_pred[:, 360:360+180], dim=-1)
+#     gaus_ro_pred   = torch.argmax(dino_pred[:, 360+180:360+180+180], dim=-1)
+#     confidence     = F.softmax(dino_pred[:, -2:], dim=-1)[0][0]
+#     angles = torch.zeros(4)
+#     angles[0]  = gaus_ax_pred
+#     angles[1]  = gaus_pl_pred - 90
+#     angles[2]  = gaus_ro_pred - 90
+#     angles[3]  = confidence
+#     return angles
+
+# def get_3angle_infer_aug(origin_img, rm_bkg_img, dino, val_preprocess, device):
+    
+#     # image = Image.open(image_path).convert('RGB')
+#     image = get_crop_images(origin_img, num=3) + get_crop_images(rm_bkg_img, num=3)
+#     image_inputs = val_preprocess(images = image)
+#     image_inputs['pixel_values'] = torch.from_numpy(np.array(image_inputs['pixel_values'])).to(device)
+#     with torch.no_grad():
+#         dino_pred = dino(image_inputs)
+
+#     gaus_ax_pred   = torch.argmax(dino_pred[:, 0:360], dim=-1).to(torch.float32)
+#     gaus_pl_pred   = torch.argmax(dino_pred[:, 360:360+180], dim=-1).to(torch.float32)
+#     gaus_ro_pred   = torch.argmax(dino_pred[:, 360+180:360+180+180], dim=-1).to(torch.float32)
+    
+#     gaus_ax_pred   = remove_outliers_and_average_circular(gaus_ax_pred)
+#     gaus_pl_pred   = remove_outliers_and_average(gaus_pl_pred)
+#     gaus_ro_pred   = remove_outliers_and_average(gaus_ro_pred)
+    
+#     confidence     = torch.mean(F.softmax(dino_pred[:, -2:], dim=-1), dim=0)[0]
+#     angles = torch.zeros(4)
+#     angles[0]  = gaus_ax_pred
+#     angles[1]  = gaus_pl_pred - 90
+#     angles[2]  = gaus_ro_pred - 90
+#     angles[3]  = confidence
+#     return angles
+
+#################################
+# huggingface demo code
+#################################
+
+import torch
+from PIL import Image
+from utils import *
+import torch.nn.functional as F
+import numpy as np
+
+def get_3angle(image, dino, val_preprocess, device):
+    
+    # image = Image.open(image_path).convert('RGB')
+    image_inputs = val_preprocess(images = image)
+    image_inputs['pixel_values'] = torch.from_numpy(np.array(image_inputs['pixel_values'])).to(device)
+    with torch.no_grad():
+        dino_pred = dino(image_inputs)
+
+    gaus_ax_pred   = torch.argmax(dino_pred[:, 0:360], dim=-1)
+    gaus_pl_pred   = torch.argmax(dino_pred[:, 360:360+180], dim=-1)
+    gaus_ro_pred   = torch.argmax(dino_pred[:, 360+180:360+180+360], dim=-1)
+    confidence     = F.softmax(dino_pred[:, -2:], dim=-1)[0][0]
+    angles = torch.zeros(4)
+    angles[0]  = gaus_ax_pred
+    angles[1]  = gaus_pl_pred - 90
+    angles[2]  = gaus_ro_pred - 180
+    angles[3]  = confidence
+    return angles
+
+def get_3angle_infer_aug(origin_img, rm_bkg_img, dino, val_preprocess, device):
+    
+    # image = Image.open(image_path).convert('RGB')
+    image = get_crop_images(origin_img, num=3) + get_crop_images(rm_bkg_img, num=3)
+    image_inputs = val_preprocess(images = image)
+    image_inputs['pixel_values'] = torch.from_numpy(np.array(image_inputs['pixel_values'])).to(device)
+    with torch.no_grad():
+        dino_pred = dino(image_inputs)
+
+    gaus_ax_pred   = torch.argmax(dino_pred[:, 0:360], dim=-1).to(torch.float32)
+    gaus_pl_pred   = torch.argmax(dino_pred[:, 360:360+180], dim=-1).to(torch.float32)
+    gaus_ro_pred   = torch.argmax(dino_pred[:, 360+180:360+180+360], dim=-1).to(torch.float32)
+    
+    gaus_ax_pred   = remove_outliers_and_average_circular(gaus_ax_pred)
+    gaus_pl_pred   = remove_outliers_and_average(gaus_pl_pred)
+    gaus_ro_pred   = remove_outliers_and_average(gaus_ro_pred)
+    
+    confidence     = torch.mean(F.softmax(dino_pred[:, -2:], dim=-1), dim=0)[0]
+    angles = torch.zeros(4)
+    angles[0]  = gaus_ax_pred
+    angles[1]  = gaus_pl_pred - 90
+    angles[2]  = gaus_ro_pred - 180
+    angles[3]  = confidence
+    return angles

Code/Baselines/Orient-Anything/paths.py

@@ -0,0 +1,4 @@
+DINO_SMALL  = "facebook/dinov2-small"
+DINO_BASE   = "facebook/dinov2-base"
+DINO_LARGE  = "facebook/dinov2-large"
+DINO_GIANT  = "facebook/dinov2-giant"

Code/Baselines/Orient-Anything/requirements.txt

@@ -0,0 +1,9 @@
+torch==2.2.1
+transformers==4.38
+matplotlib
+pillow==10.2.0
+huggingface-hub==0.26.5
+gradio==5.9.0
+numpy==1.26.4
+onnxruntime
+rembg

Code/Baselines/Orient-Anything/utils.py

@@ -0,0 +1,304 @@
+import rembg
+import random
+import torch
+import numpy as np
+from PIL import Image, ImageOps
+import PIL
+from typing import Any
+import matplotlib.pyplot as plt
+import io
+
+def resize_foreground(
+    image: Image,
+    ratio: float,
+) -> Image:
+    image = np.array(image)
+    assert image.shape[-1] == 4
+    alpha = np.where(image[..., 3] > 0)
+    y1, y2, x1, x2 = (
+        alpha[0].min(),
+        alpha[0].max(),
+        alpha[1].min(),
+        alpha[1].max(),
+    )
+    # crop the foreground
+    fg = image[y1:y2, x1:x2]
+    # pad to square
+    size = max(fg.shape[0], fg.shape[1])
+    ph0, pw0 = (size - fg.shape[0]) // 2, (size - fg.shape[1]) // 2
+    ph1, pw1 = size - fg.shape[0] - ph0, size - fg.shape[1] - pw0
+    new_image = np.pad(
+        fg,
+        ((ph0, ph1), (pw0, pw1), (0, 0)),
+        mode="constant",
+        constant_values=((0, 0), (0, 0), (0, 0)),
+    )
+
+    # compute padding according to the ratio
+    new_size = int(new_image.shape[0] / ratio)
+    # pad to size, double side
+    ph0, pw0 = (new_size - size) // 2, (new_size - size) // 2
+    ph1, pw1 = new_size - size - ph0, new_size - size - pw0
+    new_image = np.pad(
+        new_image,
+        ((ph0, ph1), (pw0, pw1), (0, 0)),
+        mode="constant",
+        constant_values=((0, 0), (0, 0), (0, 0)),
+    )
+    new_image = Image.fromarray(new_image)
+    return new_image
+
+def remove_background(image: Image,
+    rembg_session: Any = None,
+    force: bool = False,
+    **rembg_kwargs,
+) -> Image:
+    do_remove = True
+    if image.mode == "RGBA" and image.getextrema()[3][0] < 255:
+        do_remove = False
+    do_remove = do_remove or force
+    if do_remove:
+        image = rembg.remove(image, session=rembg_session, **rembg_kwargs)
+    return image
+
+def random_crop(image, crop_scale=(0.8, 0.95)):
+    """
+    随机裁切图片
+        image (numpy.ndarray):  (H, W, C)。
+        crop_scale (tuple): (min_scale, max_scale)。
+    """
+    assert isinstance(image, Image.Image), "iput must be PIL.Image.Image"
+    assert len(crop_scale) == 2 and 0 < crop_scale[0] <= crop_scale[1] <= 1
+
+    width, height = image.size
+
+    # 计算裁切的高度和宽度
+    crop_width = random.randint(int(width * crop_scale[0]), int(width * crop_scale[1]))
+    crop_height = random.randint(int(height * crop_scale[0]), int(height * crop_scale[1]))
+
+    # 随机选择裁切的起始点
+    left = random.randint(0, width - crop_width)
+    top = random.randint(0, height - crop_height)
+
+    # 裁切图片
+    cropped_image = image.crop((left, top, left + crop_width, top + crop_height))
+
+    return cropped_image
+
+def get_crop_images(img, num=3):
+    cropped_images = []
+    for i in range(num):
+        cropped_images.append(random_crop(img))
+    return cropped_images
+
+def background_preprocess(input_image, do_remove_background):
+
+    rembg_session = rembg.new_session() if do_remove_background else None
+
+    if do_remove_background:
+        input_image = remove_background(input_image, rembg_session)
+        input_image = resize_foreground(input_image, 0.85)
+
+    return input_image
+
+def remove_outliers_and_average(tensor, threshold=1.5):
+    assert tensor.dim() == 1, "dimension of input Tensor must equal to 1"
+
+    q1 = torch.quantile(tensor, 0.25)
+    q3 = torch.quantile(tensor, 0.75)
+    iqr = q3 - q1
+
+    lower_bound = q1 - threshold * iqr
+    upper_bound = q3 + threshold * iqr
+
+    non_outliers = tensor[(tensor >= lower_bound) & (tensor <= upper_bound)]
+
+    if len(non_outliers) == 0:
+        return tensor.mean().item()
+
+    return non_outliers.mean().item()
+
+
+def remove_outliers_and_average_circular(tensor, threshold=1.5):
+    assert tensor.dim() == 1, "dimension of input Tensor must equal to 1"
+
+    # 将角度转换为二维平面上的点
+    radians = tensor * torch.pi / 180.0
+    x_coords = torch.cos(radians)
+    y_coords = torch.sin(radians)
+
+    # 计算平均向量
+    mean_x = torch.mean(x_coords)
+    mean_y = torch.mean(y_coords)
+
+    differences = torch.sqrt((x_coords - mean_x) * (x_coords - mean_x) + (y_coords - mean_y) * (y_coords - mean_y))
+
+    # 计算四分位数和 IQR
+    q1 = torch.quantile(differences, 0.25)
+    q3 = torch.quantile(differences, 0.75)
+    iqr = q3 - q1
+
+    # 计算上下限
+    lower_bound = q1 - threshold * iqr
+    upper_bound = q3 + threshold * iqr
+
+    # 筛选非离群点
+    non_outliers = tensor[(differences >= lower_bound) & (differences <= upper_bound)]
+
+    if len(non_outliers) == 0:
+        mean_angle = torch.atan2(mean_y, mean_x) * 180.0 / torch.pi
+        mean_angle = (mean_angle + 360) % 360
+        return mean_angle  # 如果没有非离群点，返回 None
+
+    # 对非离群点再次计算平均向量
+    radians = non_outliers * torch.pi / 180.0
+    x_coords = torch.cos(radians)
+    y_coords = torch.sin(radians)
+
+    mean_x = torch.mean(x_coords)
+    mean_y = torch.mean(y_coords)
+
+    mean_angle = torch.atan2(mean_y, mean_x) * 180.0 / torch.pi
+    mean_angle = (mean_angle + 360) % 360
+
+    return mean_angle
+
+def scale(x):
+    # print(x)
+    # if abs(x[0])<0.1 and abs(x[1])<0.1:
+        
+    #     return x*5
+    # else:
+    #     return x
+    return x*3
+
+def get_proj2D_XYZ(phi, theta, gamma):
+    x = np.array([-1*np.sin(phi)*np.cos(gamma) - np.cos(phi)*np.sin(theta)*np.sin(gamma), np.sin(phi)*np.sin(gamma) - np.cos(phi)*np.sin(theta)*np.cos(gamma)])
+    y = np.array([-1*np.cos(phi)*np.cos(gamma) + np.sin(phi)*np.sin(theta)*np.sin(gamma), np.cos(phi)*np.sin(gamma) + np.sin(phi)*np.sin(theta)*np.cos(gamma)])
+    z = np.array([np.cos(theta)*np.sin(gamma), np.cos(theta)*np.cos(gamma)])
+    x = scale(x)
+    y = scale(y)
+    z = scale(z)
+    return x, y, z
+
+# 绘制3D坐标轴
+def draw_axis(ax, origin, vector, color, label=None):
+    ax.quiver(origin[0], origin[1], vector[0], vector[1], angles='xy', scale_units='xy', scale=1, color=color)
+    if label!=None:
+        ax.text(origin[0] + vector[0] * 1.1, origin[1] + vector[1] * 1.1, label, color=color, fontsize=12)
+
+def matplotlib_2D_arrow(angles, rm_bkg_img):
+    fig, ax = plt.subplots(figsize=(8, 8))
+
+    # 设置旋转角度
+    phi   = np.radians(angles[0])
+    theta = np.radians(angles[1])
+    gamma = np.radians(-1*angles[2])
+
+    w, h = rm_bkg_img.size
+    if h>w:
+        extent = [-5*w/h, 5*w/h, -5, 5]
+    else:
+        extent = [-5, 5, -5*h/w, 5*h/w]
+    ax.imshow(rm_bkg_img, extent=extent, zorder=0, aspect ='auto')  # extent 设置图片的显示范围
+
+    origin = np.array([0, 0])
+
+    # 旋转后的向量
+    rot_x, rot_y, rot_z = get_proj2D_XYZ(phi, theta, gamma)
+
+    # draw arrow
+    arrow_attr = [{'point':rot_x, 'color':'r', 'label':'front'}, 
+                  {'point':rot_y, 'color':'g', 'label':'right'}, 
+                  {'point':rot_z, 'color':'b', 'label':'top'}]
+    
+    if phi> 45 and phi<=225:
+        order = [0,1,2]
+    elif phi > 225 and phi < 315:
+        order = [2,0,1]
+    else:
+        order = [2,1,0]
+    
+    for i in range(3):
+        draw_axis(ax, origin, arrow_attr[order[i]]['point'], arrow_attr[order[i]]['color'], arrow_attr[order[i]]['label'])
+        # draw_axis(ax, origin, rot_y, 'g', label='right')
+        # draw_axis(ax, origin, rot_z, 'b', label='top')
+        # draw_axis(ax, origin, rot_x, 'r', label='front')
+
+    # 关闭坐标轴和网格
+    ax.set_axis_off()
+    ax.grid(False)
+
+    # 设置坐标范围
+    ax.set_xlim(-5, 5)
+    ax.set_ylim(-5, 5)
+
+def figure_to_img(fig):
+    with io.BytesIO() as buf:
+        fig.savefig(buf, format='JPG', bbox_inches='tight')
+        buf.seek(0)
+        image = Image.open(buf).copy()
+    return image
+
+from render import render, Model
+import math
+axis_model = Model("./assets/axis.obj", texture_filename="./assets/axis.png")
+def render_3D_axis(phi, theta, gamma):
+    radius = 240
+    # camera_location = [radius * math.cos(phi), radius * math.sin(phi), radius * math.tan(theta)]
+    # print(camera_location)
+    camera_location = [-1*radius * math.cos(phi), -1*radius * math.tan(theta), radius * math.sin(phi)]
+    img = render(
+        # Model("res/jinx.obj", texture_filename="res/jinx.tga"),
+        axis_model,
+        height=512,
+        width=512,
+        filename="tmp_render.png",
+        cam_loc = camera_location
+    )
+    img = img.rotate(gamma)
+    return img
+
+def overlay_images_with_scaling(center_image: Image.Image, background_image, target_size=(512, 512)):
+    """
+    调整前景图像大小为 512x512，将背景图像缩放以适配，并中心对齐叠加
+    :param center_image: 前景图像
+    :param background_image: 背景图像
+    :param target_size: 前景图像的目标大小，默认 (512, 512)
+    :return: 叠加后的图像
+    """
+    # 确保输入图像为 RGBA 模式
+    if center_image.mode != "RGBA":
+        center_image = center_image.convert("RGBA")
+    if background_image.mode != "RGBA":
+        background_image = background_image.convert("RGBA")
+    
+    # 调整前景图像大小
+    center_image = center_image.resize(target_size)
+    
+    # 缩放背景图像，确保其适合前景图像的尺寸
+    bg_width, bg_height = background_image.size
+    
+    # 按宽度或高度等比例缩放背景
+    scale = target_size[0] / max(bg_width, bg_height)
+    new_width = int(bg_width * scale)
+    new_height = int(bg_height * scale)
+    resized_background = background_image.resize((new_width, new_height))
+    # 计算需要的填充量
+    pad_width = target_size[0] - new_width
+    pad_height = target_size[0] - new_height
+
+    # 计算上下左右的 padding
+    left = pad_width // 2
+    right = pad_width - left
+    top = pad_height // 2
+    bottom = pad_height - top
+
+    # 添加 padding
+    resized_background = ImageOps.expand(resized_background, border=(left, top, right, bottom), fill=(255,255,255,255))
+    
+    # 将前景图像叠加到背景图像上
+    result = resized_background.copy()
+    result.paste(center_image, (0, 0), mask=center_image)
+    
+    return result

Code/Baselines/Orient-Anything/vision_tower.py

@@ -0,0 +1,161 @@
+import torch
+from torch import nn
+import torch.nn.init as init
+import torch.nn.functional as F
+
+from paths import *
+
+from typing import Dict, List, Optional, Set, Tuple, Union
+from transformers import AutoImageProcessor, AutoModel, Dinov2Model
+from transformers.models.dinov2.modeling_dinov2 import Dinov2Embeddings
+from transformers.models.dinov2.configuration_dinov2 import Dinov2Config
+import numpy as np
+from contextlib import nullcontext
+
+def get_activation(activation):
+    if activation.lower() == 'gelu':
+        return nn.GELU()
+    elif activation.lower() == 'rrelu':
+        return nn.RReLU(inplace=True)
+    elif activation.lower() == 'selu':
+        return nn.SELU(inplace=True)
+    elif activation.lower() == 'silu':
+        return nn.SiLU(inplace=True)
+    elif activation.lower() == 'hardswish':
+        return nn.Hardswish(inplace=True)
+    elif activation.lower() == 'leakyrelu':
+        return nn.LeakyReLU(inplace=True)
+    elif activation.lower() == 'sigmoid':
+        return nn.Sigmoid()
+    elif activation.lower() == 'tanh':
+        return nn.Tanh()
+    else:
+        return nn.ReLU(inplace=True)
+
+
+
+class MLP_dim(nn.Module):
+    def __init__(
+        self, in_dim=512, out_dim=1024, bias=True, activation='relu'):
+        super().__init__()
+        self.act = get_activation(activation)
+        self.net1 = nn.Sequential(
+            nn.Linear(in_dim, int(out_dim), bias=bias),
+            nn.BatchNorm1d(int(out_dim)),
+            self.act
+        )
+        self.net2 = nn.Sequential(
+            nn.Linear(int(out_dim), out_dim, bias=bias),
+            nn.BatchNorm1d(out_dim)
+        )
+
+    def forward(self, x):
+        return self.net2(self.net1(x))
+
+class FLIP_Dinov2Embeddings(Dinov2Embeddings):
+    """
+    Construct the CLS token, mask token, position and patch embeddings.
+    """
+
+    def __init__(self, config: Dinov2Config) -> None:
+        super().__init__(config)
+
+    def forward(self, pixel_values: torch.Tensor, bool_masked_pos: Optional[torch.Tensor] = None) -> torch.Tensor:
+        batch_size, _, height, width = pixel_values.shape
+        target_dtype = self.patch_embeddings.projection.weight.dtype
+        embeddings = self.patch_embeddings(pixel_values.to(dtype=target_dtype))
+
+        # add the [CLS] token to the embedded patch tokens
+        cls_tokens = self.cls_token.expand(batch_size, -1, -1)
+        embeddings = torch.cat((cls_tokens, embeddings), dim=1)
+
+        # add positional encoding to each token
+        embeddings = embeddings + self.interpolate_pos_encoding(embeddings, height, width)
+
+        if bool_masked_pos is not None:
+            # embeddings = torch.where(
+            #     bool_masked_pos.unsqueeze(-1), self.mask_token.to(embeddings.dtype).unsqueeze(0), embeddings
+            # )
+            B,S,D = embeddings.shape
+            batch_indices = torch.arange(B).unsqueeze(1)
+            embeddings = embeddings[batch_indices, bool_masked_pos]
+
+        embeddings = self.dropout(embeddings)
+
+        return embeddings
+
+class FLIP_DINOv2(Dinov2Model):
+    def __init__(self, config):
+        super().__init__(config)
+        
+        self.embeddings = FLIP_Dinov2Embeddings(config)
+        
+class DINOv2_MLP(nn.Module):
+    def __init__(self, 
+                 dino_mode,
+                 in_dim,
+                 out_dim,
+                 evaluate,
+                 mask_dino,
+                 frozen_back
+                ) -> None:
+        super().__init__()
+        # self.dinov2 = AutoModel.from_pretrained(DINO_BASE)
+        if dino_mode == 'base':
+            self.dinov2 = FLIP_DINOv2.from_pretrained(DINO_BASE, cache_dir='./')
+        elif dino_mode == 'large':
+            self.dinov2 = FLIP_DINOv2.from_pretrained(DINO_LARGE, cache_dir='./')
+        elif dino_mode == 'small':
+            self.dinov2 = FLIP_DINOv2.from_pretrained(DINO_SMALL, cache_dir='./')
+        elif dino_mode == 'giant':
+            self.dinov2 = FLIP_DINOv2.from_pretrained(DINO_GIANT, cache_dir='./')
+        
+        self.down_sampler = MLP_dim(in_dim=in_dim, out_dim=out_dim)
+        self.random_mask  = False
+        if not evaluate:
+            self.init_weights(self.down_sampler)
+            self.random_mask = mask_dino
+        if frozen_back:
+            self.forward_mode = torch.no_grad()
+        else:
+            self.forward_mode = nullcontext()
+        
+    def forward(self, img_inputs):
+        device = self.get_device()
+        # print(img_inputs['pixel_values'].shape)
+        
+        with self.forward_mode:
+            if self.random_mask:
+                B = len(img_inputs['pixel_values'])
+                S = 256
+                indices = []
+                for i in range(B):
+                    tmp = torch.randperm(S)[:S//2]
+                    tmp = tmp.sort().values + 1
+                    indices.append(tmp)
+                indices = torch.stack(indices, dim=0)
+                indices = torch.cat([torch.zeros(B, 1, dtype=torch.long, device='cpu'), indices], dim=1)
+                # print(indices.shape)
+                img_inputs['bool_masked_pos'] = indices.to(device)
+                
+            dino_outputs = self.dinov2(**img_inputs)
+            dino_seq = dino_outputs.last_hidden_state
+            # B,S,_ = dino_seq.shape
+            # dino_seq = dino_seq.view(B*S,-1)
+            dino_seq = dino_seq[:,0,:]
+        
+        down_sample_out = self.down_sampler(dino_seq)
+        # down_sample_out = down_sample_out.view(B,S,-1)
+        # down_sample_out = down_sample_out[:,0,:]
+        
+        return down_sample_out
+    
+    def get_device(self):
+        return next(self.parameters()).device
+    
+    def init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            init.xavier_uniform_(m.weight)
+            if m.bias is not None:
+                init.constant_(m.bias, 0)
+