remove all unused files

README.md

@@ -1,5 +1,5 @@
 ---
-title: Pdiscoformer
+title: PdiscoFormer
 emoji: 😻
 colorFrom: green
 colorTo: pink

app.py

@@ -4,9 +4,9 @@ from PIL import Image
 
 from models import IndividualLandmarkViT
 from utils import VisualizeAttentionMaps
-from utils.data_utils.transform_utils import make_test_transforms
+from utils.transform_utils import make_test_transforms
 
-st.title("Pdiscoformer Part Discovery Visualizer")
+st.title("PdiscoFormer Part Discovery Visualizer")
 model_options = ["ananthu-aniraj/pdiscoformer_cub_k_8", "ananthu-aniraj/pdiscoformer_cub_k_16",
                  "ananthu-aniraj/pdiscoformer_cub_k_4", "ananthu-aniraj/pdiscoformer_part_imagenet_ood_k_8",
                  "ananthu-aniraj/pdiscoformer_part_imagenet_ood_k_25",

utils/__init__.py

@@ -1,6 +1,6 @@
-from .data_utils import *
 from .visualize_att_maps import *
 from .misc_utils import *
 from .get_landmark_coordinates import *
+from .transform_utils import *
 
 

utils/data_utils/__init__.py

@@ -1,5 +0,0 @@
-from .dataset_utils import *
-from .reversible_affine_transform import *
-from .transform_utils import *
-from .class_balanced_distributed_sampler import *
-from .class_balanced_sampler import *

utils/data_utils/class_balanced_distributed_sampler.py

@@ -1,100 +0,0 @@
-import torch
-from torch.utils.data import Dataset
-from typing import Optional
-import math
-import torch.distributed as dist
-
-
-class ClassBalancedDistributedSampler(torch.utils.data.Sampler):
-    """
-    A custom sampler that sub-samples a given dataset based on class labels. Based on the DistributedSampler class
-    Ref: https://github.com/pytorch/pytorch/blob/04c1df651aa58bea50977f4efcf19b09ce27cefd/torch/utils/data/distributed.py#L13
-    """
-
-    def __init__(self, dataset: Dataset, num_replicas: Optional[int] = None, rank: Optional[int] = None,
-                 shuffle: bool = True, seed: int = 0, drop_last: bool = False, num_samples_per_class=100) -> None:
-
-        if not shuffle:
-            raise ValueError("ClassBalancedDatasetSubSampler requires shuffling, otherwise use DistributedSampler")
-
-        # Check if the dataset has a generate_class_balanced_indices method
-        if not hasattr(dataset, 'generate_class_balanced_indices'):
-            raise ValueError("Dataset does not have a generate_class_balanced_indices method")
-
-        self.shuffle = shuffle
-        self.seed = seed
-        if num_replicas is None:
-            if not dist.is_available():
-                raise RuntimeError("Requires distributed package to be available")
-            num_replicas = dist.get_world_size()
-        if rank is None:
-            if not dist.is_available():
-                raise RuntimeError("Requires distributed package to be available")
-            rank = dist.get_rank()
-        if rank >= num_replicas or rank < 0:
-            raise ValueError(
-                f"Invalid rank {rank}, rank should be in the interval [0, {num_replicas - 1}]")
-        self.dataset = dataset
-        self.num_replicas = num_replicas
-        self.rank = rank
-        self.epoch = 0
-        self.drop_last = drop_last
-
-        # Calculate the number of samples
-        g = torch.Generator()
-        g.manual_seed(self.seed + self.epoch)
-        self.num_samples_per_class = num_samples_per_class
-        indices = dataset.generate_class_balanced_indices(torch.Generator(),
-                                                          num_samples_per_class=num_samples_per_class)
-        dataset_size = len(indices)
-
-        # If the dataset length is evenly divisible by # of replicas, then there
-        # is no need to drop any data, since the dataset will be split equally.
-        if self.drop_last and len(self.dataset) % self.num_replicas != 0:  # type: ignore[arg-type]
-            # Split to nearest available length that is evenly divisible.
-            # This is to ensure each rank receives the same amount of data when
-            # using this Sampler.
-            self.num_samples = math.ceil(
-                (dataset_size - self.num_replicas) / self.num_replicas  # type: ignore[arg-type]
-            )
-        else:
-            self.num_samples = math.ceil(dataset_size / self.num_replicas)  # type: ignore[arg-type]
-        self.total_size = self.num_samples * self.num_replicas
-
-    def __iter__(self):
-        # deterministically shuffle based on epoch and seed, here shuffle is assumed to be True
-        g = torch.Generator()
-        g.manual_seed(self.seed + self.epoch)
-        indices = self.dataset.generate_class_balanced_indices(g, num_samples_per_class=self.num_samples_per_class)
-
-        if not self.drop_last:
-            # add extra samples to make it evenly divisible
-            padding_size = self.total_size - len(indices)
-            if padding_size <= len(indices):
-                indices += indices[:padding_size]
-            else:
-                indices += (indices * math.ceil(padding_size / len(indices)))[:padding_size]
-        else:
-            # remove tail of data to make it evenly divisible.
-            indices = indices[:self.total_size]
-
-        # subsample
-        indices = indices[self.rank:self.total_size:self.num_replicas]
-
-        return iter(indices)
-
-    def __len__(self) -> int:
-        return self.num_samples
-
-    def set_epoch(self, epoch: int) -> None:
-        r"""
-        Set the epoch for this sampler.
-
-        When :attr:`shuffle=True`, this ensures all replicas
-        use a different random ordering for each epoch. Otherwise, the next iteration of this
-        sampler will yield the same ordering.
-
-        Args:
-            epoch (int): Epoch number.
-        """
-        self.epoch = epoch

utils/data_utils/class_balanced_sampler.py

@@ -1,31 +0,0 @@
-import torch
-from torch.utils.data import Dataset
-
-
-class ClassBalancedRandomSampler(torch.utils.data.Sampler):
-    """
-    A custom sampler that sub-samples a given dataset based on class labels. Based on the RandomSampler class
-    This is essentially the non-ddp version of ClassBalancedDistributedSampler
-    Ref: https://github.com/pytorch/pytorch/blob/abe3c55a6a01c5b625eeb4fc9aab1421a5965cd2/torch/utils/data/sampler.py#L117
-    """
-
-    def __init__(self, dataset: Dataset, num_samples_per_class=100, seed: int = 0) -> None:
-        self.dataset = dataset
-        self.seed = seed
-        # Calculate the number of samples
-        self.generator = torch.Generator()
-        self.generator.manual_seed(self.seed)
-        self.num_samples_per_class = num_samples_per_class
-        indices = dataset.generate_class_balanced_indices(self.generator,
-                                                          num_samples_per_class=num_samples_per_class)
-        self.num_samples = len(indices)
-
-    def __iter__(self):
-        # Change seed for every function call
-        seed = int(torch.empty((), dtype=torch.int64).random_().item())
-        self.generator.manual_seed(seed)
-        indices = self.dataset.generate_class_balanced_indices(self.generator, num_samples_per_class=self.num_samples_per_class)
-        return iter(indices)
-
-    def __len__(self) -> int:
-        return self.num_samples

utils/data_utils/dataset_utils.py

@@ -1,161 +0,0 @@
-from PIL import Image
-from torch import Tensor
-from typing import List, Optional
-import numpy as np
-import torchvision
-import json
-
-
-def load_json(path: str):
-    """
-    Load json file from path and return the data
-    :param path: Path to the json file
-    :return:
-    data: Data in the json file
-    """
-    with open(path, 'r') as f:
-        data = json.load(f)
-    return data
-
-
-def save_json(data: dict, path: str):
-    """
-    Save data to a json file
-    :param data: Data to be saved
-    :param path: Path to save the data
-    :return:
-    """
-    with open(path, "w") as f:
-        json.dump(data, f)
-
-
-def pil_loader(path):
-    """
-    Load image from path using PIL
-    :param path: Path to the image
-    :return:
-    img: PIL Image
-    """
-    with open(path, 'rb') as f:
-        img = Image.open(f)
-        return img.convert('RGB')
-
-
-def get_dimensions(image: Tensor):
-    """
-    Get the dimensions of the image
-    :param image: Tensor or PIL Image or np.ndarray
-    :return:
-    h: Height of the image
-    w: Width of the image
-    """
-    if isinstance(image, Tensor):
-        _, h, w = image.shape
-    elif isinstance(image, np.ndarray):
-        h, w, _ = image.shape
-    elif isinstance(image, Image.Image):
-        w, h = image.size
-    else:
-        raise ValueError(f"Invalid image type: {type(image)}")
-    return h, w
-
-
-def center_crop_boxes_kps(img: Tensor, output_size: Optional[List[int]] = 448, parts: Optional[Tensor] = None,
-                          boxes: Optional[Tensor] = None, num_keypoints: int = 15):
-    """
-    Calculate the center crop parameters for the bounding boxes and landmarks and update them
-    :param img: Image
-    :param output_size: Output size of the cropped image
-    :param parts: Locations of the landmarks of following format: <part_id> <x> <y> <visible>
-    :param boxes: Bounding boxes of the landmarks of following format: <image_id> <x> <y> <width> <height>
-    :param num_keypoints: Number of keypoints
-    :return:
-    cropped_img: Center cropped image
-    parts: Updated locations of the landmarks
-    boxes: Updated bounding boxes of the landmarks
-    """
-    if isinstance(output_size, int):
-        output_size = (output_size, output_size)
-    elif isinstance(output_size, (tuple, list)) and len(output_size) == 1:
-        output_size = (output_size[0], output_size[0])
-    elif isinstance(output_size, (tuple, list)) and len(output_size) == 2:
-        output_size = output_size
-    else:
-        raise ValueError(f"Invalid output size: {output_size}")
-
-    crop_height, crop_width = output_size
-    image_height, image_width = get_dimensions(img)
-    img = torchvision.transforms.functional.center_crop(img, output_size)
-
-    crop_top, crop_left = _get_center_crop_params_(image_height, image_width, output_size)
-
-    if parts is not None:
-        for j in range(num_keypoints):
-            # Skip if part is invisible
-            if parts[j][-1] == 0:
-                continue
-            parts[j][1] -= crop_left
-            parts[j][2] -= crop_top
-
-            # Skip if part is outside the crop
-            if parts[j][1] > crop_width or parts[j][2] > crop_height:
-                parts[j][-1] = 0
-            if parts[j][1] < 0 or parts[j][2] < 0:
-                parts[j][-1] = 0
-
-            parts[j][1] = min(crop_width, parts[j][1])
-            parts[j][2] = min(crop_height, parts[j][2])
-            parts[j][1] = max(0, parts[j][1])
-            parts[j][2] = max(0, parts[j][2])
-
-    if boxes is not None:
-        boxes[1] -= crop_left
-        boxes[2] -= crop_top
-        boxes[1] = max(0, boxes[1])
-        boxes[2] = max(0, boxes[2])
-        boxes[1] = min(crop_width, boxes[1])
-        boxes[2] = min(crop_height, boxes[2])
-
-    return img, parts, boxes
-
-
-def _get_center_crop_params_(image_height: int, image_width: int, output_size: Optional[List[int]] = 448):
-    """
-    Get the parameters for center cropping the image
-    :param image_height: Height of the image
-    :param image_width: Width of the image
-    :param output_size: Output size of the cropped image
-    :return:
-    crop_top: Top coordinate of the cropped image
-    crop_left: Left coordinate of the cropped image
-    """
-    if isinstance(output_size, int):
-        output_size = (output_size, output_size)
-    elif isinstance(output_size, (tuple, list)) and len(output_size) == 1:
-        output_size = (output_size[0], output_size[0])
-    elif isinstance(output_size, (tuple, list)) and len(output_size) == 2:
-        output_size = output_size
-    else:
-        raise ValueError(f"Invalid output size: {output_size}")
-
-    crop_height, crop_width = output_size
-
-    if crop_width > image_width or crop_height > image_height:
-        padding_ltrb = [
-            (crop_width - image_width) // 2 if crop_width > image_width else 0,
-            (crop_height - image_height) // 2 if crop_height > image_height else 0,
-            (crop_width - image_width + 1) // 2 if crop_width > image_width else 0,
-            (crop_height - image_height + 1) // 2 if crop_height > image_height else 0,
-        ]
-        crop_top, crop_left = padding_ltrb[1], padding_ltrb[0]
-        return crop_top, crop_left
-
-    if crop_width == image_width and crop_height == image_height:
-        crop_top = 0
-        crop_left = 0
-        return crop_top, crop_left
-
-    crop_top = int(round((image_height - crop_height) / 2.0))
-    crop_left = int(round((image_width - crop_width) / 2.0))
-
-    return crop_top, crop_left

utils/data_utils/reversible_affine_transform.py

@@ -1,82 +0,0 @@
-# Description: This file contains the code for the reversible affine transform
-import torchvision.transforms as transforms
-import torch
-from typing import List, Optional, Tuple, Any
-
-
-def generate_affine_trans_params(
-        degrees: List[float],
-        translate: Optional[List[float]],
-        scale_ranges: Optional[List[float]],
-        shears: Optional[List[float]],
-        img_size: List[int],
-) -> Tuple[float, Tuple[int, int], float, Any]:
-    """Get parameters for affine transformation
-
-    Returns:
-        params to be passed to the affine transformation
-    """
-    angle = float(torch.empty(1).uniform_(float(degrees[0]), float(degrees[1])).item())
-    if translate is not None:
-        max_dx = float(translate[0] * img_size[0])
-        max_dy = float(translate[1] * img_size[1])
-        tx = int(round(torch.empty(1).uniform_(-max_dx, max_dx).item()))
-        ty = int(round(torch.empty(1).uniform_(-max_dy, max_dy).item()))
-        translations = (tx, ty)
-    else:
-        translations = (0, 0)
-
-    if scale_ranges is not None:
-        scale = float(torch.empty(1).uniform_(scale_ranges[0], scale_ranges[1]).item())
-    else:
-        scale = 1.0
-
-    shear_x = shear_y = 0.0
-    if shears is not None:
-        shear_x = float(torch.empty(1).uniform_(shears[0], shears[1]).item())
-        if len(shears) == 4:
-            shear_y = float(torch.empty(1).uniform_(shears[2], shears[3]).item())
-
-    shear = (shear_x, shear_y)
-    if shear_x == 0.0 and shear_y == 0.0:
-        shear = 0.0
-
-    return angle, translations, scale, shear
-
-
-def rigid_transform(img, angle, translate, scale, invert=False, shear=0,
-                    interpolation=transforms.InterpolationMode.BILINEAR):
-    """
-    Affine transforms input image
-    Modified from: https://github.com/robertdvdk/part_detection/blob/eec53f2f40602113f74c6c1f60a2034823b0fcaf/lib.py#L54
-    Parameters
-    ----------
-    img: Tensor
-        Input image
-    angle: int
-        Rotation angle between -180 and 180 degrees
-    translate: [int]
-        Sequence of horizontal/vertical translations
-    scale: float
-        How to scale the image
-    invert: bool
-        Whether to invert the transformation
-    shear: float
-        Shear angle in degrees
-    interpolation: InterpolationMode
-        Interpolation mode to calculate output values
-    Returns
-    ----------
-    img: Tensor
-        Transformed image
-
-    """
-    if not invert:
-        img = transforms.functional.affine(img, angle=angle, translate=translate, scale=scale, shear=shear,
-                                           interpolation=interpolation)
-    else:
-        translate = [-t for t in translate]
-        img = transforms.functional.affine(img=img, angle=0, translate=translate, scale=1, shear=shear)
-        img = transforms.functional.affine(img=img, angle=-angle, translate=[0, 0], scale=1 / scale, shear=shear)
-
-    return img

utils/visualize_att_maps.py

@@ -3,7 +3,7 @@ import numpy as np
 import skimage
 import torch
 
-from utils.data_utils.transform_utils import inverse_normalize_w_resize
+from utils.transform_utils import inverse_normalize_w_resize
 
 # Define the colors to use for the attention maps
 colors = cc.glasbey_category10