Upload folder using huggingface_hub

DiffusionXray-FewShot-LandmarkDetection/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 MaLGa Vision 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

DiffusionXray-FewShot-LandmarkDetection/README.md

@@ -0,0 +1,92 @@
+# Self-supervised pre-training with diffusion model for few-shot landmark detection in x-ray images
+Official PyTorch implementation of the paper -> https://openaccess.thecvf.com/content/WACV2025/papers/Di_Via_Self-Supervised_Pre-Training_with_Diffusion_Model_for_Few-Shot_Landmark_Detection_in_WACV_2025_paper.pdf
+
+# Abstract
+Deep neural networks have been extensively applied in the medical domain for various tasks, including image classification, segmentation, and landmark detection. However, their application is often hindered by data scarcity, both in terms of available annotations and images. This study introduces a novel application of denoising diffusion probabilistic models (DDPMs) to the landmark detection task, specifically addressing the challenge of limited annotated data in x-ray imaging. Our key innovation lies in leveraging DDPMs for self-supervised pre-training in landmark detection, a previously unexplored approach in this domain. This method enables accurate landmark detection with minimal annotated training data (as few as 50 images), surpassing both ImageNet supervised pre-training and traditional self-supervised techniques across three popular x-ray benchmark datasets. To our knowledge, this work represents the first application of diffusion models for self-supervised learning in landmark detection, which may offer a valuable pre-training approach in few-shot regimes, for mitigating data scarcity.
+
+
+![ddpm_pipeline](https://github.com/user-attachments/assets/d58daec4-ed81-4b4e-aca0-4257e9149b5b)
+
+
+# Getting Started
+## Installation
+Install python packages
+```
+pip install -r requirements.txt
+```
+
+## Preparing Datasets
+Download the cephalometric ([link1](https://figshare.com/s/37ec464af8e81ae6ebbf), [link2](https://www.kaggle.com/datasets/c34a0ef0cd3cfd5c5afbdb30f8541e887171f19f196b1ad63790ca5b28c0ec93?select=cepha400)), hand [link](https://ipilab.usc.edu/research/baaweb/) and the chest [link](https://www.kaggle.com/datasets/nikhilpandey360/chest-xray-masks-and-labels) datasets.
+
+Prepare datasets in the following directory structure.
+
+- datasets
+    - cephalo
+        -  400_junior
+            - *.txt
+        -  400_senior
+            - *.txt
+        - jpg
+            - *.jpg
+    - hand
+        - labels
+            - all.csv # [download here](https://github.com/christianpayer/MedicalDataAugmentationTool-HeatmapRegression/blob/master/hand_xray/hand_xray_dataset/setup/all.csv)
+        - jpg
+            - *.jpg
+    - chest
+        - pngs
+            - CHNCXR_*.png
+        - labels
+            - CHNCXR_*.txt # unzip [chest_labels.zip](https://github.com/MIRACLE-Center/YOLO_Universal_Anatomical_Landmark_Detection/blob/main/data/chest_labels.zip)
+         
+
+## Running Experiments
+To run the experiments, follow these steps:
+- Open a terminal.
+- Navigate to the root directory of the repository.
+- Make the launch_experiments.sh script executable using the following command:
+  ```
+  chmod +x launch_experiments.sh
+  ```
+- Run the launch_experiments.sh script. The script automates the process of setting up and running the desired experiments.
+  ```
+  ./launch_experiments.sh
+  ```
+
+# Download Pre-Trained models
+
+All the pre-trained models used in the study are available at the following link:
+
+[https://huggingface.co/Roberto98/X-rays_Self-Supervised_Landmark_Detection](https://huggingface.co/Roberto98/X-rays_Self-Supervised_Landmark_Detection)
+
+
+In particular, it is possible to download: 
+- Our DDPM pre-trained model at 6k, 8k, and 8k iterations respectively for the Chest, Cephalometric, and Hand dataset
+- MocoV3 densenet161 model at 10k iterations for the Chest, Cephalometric, and Hand dataset
+- SimClrV2 densenet161 model at 10k iterations for the Chest, Cephalometric, and Hand dataset
+- Dino densenet161 model at 10k iterations for the Chest, Cephalometric, and Hand dataset
+
+
+# Citation
+
+Accepted at WACV (Winter Conference on Applications of Computer Vision) 2025.
+
+If you use this code or findings in your research, please cite:
+
+### Bibtex
+```
+@InProceedings{Di_Via_2025_WACV,
+    author    = {Di Via, Roberto and Odone, Francesca and Pastore, Vito Paolo},
+    title     = {Self-Supervised Pre-Training with Diffusion Model for Few-Shot Landmark Detection in X-Ray Images},
+    booktitle = {Proceedings of the Winter Conference on Applications of Computer Vision (WACV)},
+    month     = {February},
+    year      = {2025},
+    pages     = {3886-3896}
+}
+```
+
+### APA
+
+```
+Di Via, R., Odone, F., & Pastore, V. P. (2025). Self-supervised pre-training with diffusion model for few-shot landmark detection in x-ray images. IEEE/CVF Winter Conference on Applications of Computer Vision (WACV) 2025. https://openaccess.thecvf.com/content/WACV2025/papers/Di_Via_Self-Supervised_Pre-Training_with_Diffusion_Model_for_Few-Shot_Landmark_Detection_in_WACV_2025_paper.pdf
+```

DiffusionXray-FewShot-LandmarkDetection/datasets/cephalo/400_junior/001.txt

@@ -0,0 +1,27 @@
+829,991
+1465,1035
+1300,1275
+588,1178
+1365,1631
+1342,2093
+1325,2224
+1209,2253
+1282,2270
+695,1822
+1457,1868
+1448,1864
+1586,1751
+1571,2015
+1501,1600
+1441,2210
+935,1514
+1368,1552
+664,1332
+3
+3
+2
+3
+3
+1
+2
+3

DiffusionXray-FewShot-LandmarkDetection/datasets/cephalo/400_senior/001.txt

@@ -0,0 +1,27 @@
+835,996
+1473,1029
+1289,1279
+604,1228
+1375,1654
+1386,2019
+1333,2200
+1263,2272
+1305,2252
+694,1805
+1460,1870
+1450,1864
+1588,1753
+1569,2013
+1514,1620
+1382,2310
+944,1506
+1436,1569
+664,1340
+3
+3
+2
+3
+3
+1
+2
+3

DiffusionXray-FewShot-LandmarkDetection/datasets/chest/labels/CHNCXR_0001_0.txt

@@ -0,0 +1,7 @@
+6
+0.41625 0.14375
+0.148125 0.798125
+0.4075 0.59875
+0.63 0.12875
+0.891875 0.7825
+0.7625 0.685

DiffusionXray-FewShot-LandmarkDetection/datasets/hand/labels/all.csv

@@ -0,0 +1 @@
+3142,297,1913,324

DiffusionXray-FewShot-LandmarkDetection/ddpm_pretraining/config/aariz_fastddpm.json

@@ -0,0 +1,46 @@
+{
+    "gpu": 0,
+    "experiment_path": "ddpm_pretraining/ddpm_pretraining_experiments",
+    "model_for_inference": "",
+    "model": {
+        "unet": {
+            "channel_mults": [1, 2, 2, 4],
+            "attn_res": 32,
+            "num_head_channels": 4,
+            "res_blocks": 4,
+            "self_condition": true
+        },
+        "beta_schedule": {
+            "train": {
+                "schedule": "linear",
+                "n_timestep": 500,
+                "linear_start": 1e-4,
+                "linear_end": 0.02
+            },
+            "test": {
+                "schedule": "linear",
+                "n_timestep": 500,
+                "linear_start": 1e-4,
+                "linear_end": 0.02
+            }
+        },
+        "lr": 0.00005,
+        "optimizer": "adamw",
+        "loss_type": "l2",
+        "use_ema": true,
+        "iterations": 5000,
+        "freq_metrics": 500,
+        "freq_checkpoint": 500,
+        "continue_training": false
+    },
+    "dataset": {
+        "name": "Aariz/Aariz",
+        "path": "/teamspace/studios/this_studio",
+        "image_size": 512,
+        "image_channels": 3,
+        "batch_size": 6,
+        "grad_accumulation": 1,
+        "num_workers": 4,
+        "pin_memory": true
+    }
+}

DiffusionXray-FewShot-LandmarkDetection/ddpm_pretraining/config/config.json

@@ -0,0 +1,46 @@
+{
+    "gpu": 0,
+    "experiment_path": "ddpm_pretraining/ddpm_pretraining_experiments",
+    "model_for_inference": "",
+    "model": {
+        "unet": {
+            "channel_mults": [1,2,4,8],
+            "attn_res": 32,
+            "num_head_channels": 4,
+            "res_blocks": 4,
+            "self_condition": true
+        },
+        "beta_schedule": {
+            "train": {
+                "schedule": "linear",
+                "n_timestep":500,
+                "linear_start": 1e-4,
+                "linear_end": 0.02
+            },
+            "test": {
+                "schedule": "linear",
+                "n_timestep": 500,
+                "linear_start": 1e-4,
+                "linear_end": 0.02
+            }
+        },
+        "lr":1e-4,
+        "optimizer": "adamw",
+        "loss_type": "l2",
+        "use_ema": true,   
+        "iterations": 30000,
+        "freq_metrics":2000,
+        "freq_checkpoint":2000,
+        "continue_training": false
+    },
+    "dataset":{
+        "name": "cephalo",
+        "path": "datasets/",
+        "image_size": 256,
+        "image_channels": 1,
+        "batch_size": 4,
+        "grad_accumulation": 8,
+        "num_workers": null,
+        "pin_memory": true
+    }
+}

DiffusionXray-FewShot-LandmarkDetection/ddpm_pretraining/ddpm_datasets.py

@@ -0,0 +1,259 @@
+
+
+
+# ------------------------------------------------------------------------
+#                               Libraries
+# ------------------------------------------------------------------------
+
+import os
+import numpy as np
+from PIL import Image
+from torch.utils.data import Dataset
+import albumentations as A
+import albumentations.pytorch
+
+import torch
+import utils
+from skimage.transform import resize
+
+# ------------------------------------------------------------------------
+#                               Chest Dataset
+# ------------------------------------------------------------------------
+
+# Load the dataset from the train and test folders in the root directory
+class ChestDiffusionDataset(Dataset):
+    def __init__(self, root_dir, channels=1, transform=None, phase='train'):
+
+        self.root_dir = root_dir
+        self.transform = transform
+        self.channels = channels
+       
+        self.pth_Image = os.path.join(root_dir, 'pngs')
+            
+        # file index
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))]
+
+        exclude_list = ['CHNCXR_0059_0', 'CHNCXR_0178_0', 'CHNCXR_0228_0', 'CHNCXR_0267_0', 'CHNCXR_0295_0', 'CHNCXR_0310_0', 'CHNCXR_0285_0', 'CHNCXR_0276_0', 'CHNCXR_0303_0']
+        if exclude_list is not None:
+            st = set(exclude_list)
+            files = [f for f in files if f not in st]
+
+        n = len(files)
+        train_num = 195 
+        val_num = 34  
+        test_num = n - train_num - val_num
+        if phase == 'train':
+            self.image_files = files[:train_num+val_num]
+        elif phase == 'test':
+            self.image_files = files[-test_num:]
+        elif phase == 'all':
+            self.image_files = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+        
+
+    def __len__(self):
+        return len(self.image_files)
+    
+    def __getitem__(self, idx):
+        image_name = self.image_files[idx]
+
+        image = self.read_image(os.path.join(self.pth_Image, image_name + '.png'))
+
+        data_dict = {'name': image_name, 'image': image}   
+
+        return data_dict
+
+    def read_image(self, image_path):
+
+        if self.channels == 3:
+            image = Image.open(image_path).convert('RGB')
+            image_np = np.array(image).astype(np.float32)
+
+        elif self.channels == 1:
+            image = Image.open(image_path).convert('L')
+            image_np = np.array(image).astype(np.float32)
+            image_np = np.expand_dims(image_np, axis=2) # add channel dimension
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+        
+        if self.transform:
+            image = self.transform(image=image_np)['image']
+        
+        return image
+        
+    
+# ------------------------------------------------------------------------
+#                               HAND Dataset
+# ------------------------------------------------------------------------
+
+# Load the dataset from the train and test folders in the root directory
+class HandDiffusionDataset(Dataset):
+    def __init__(self, root_dir, channels=1, transform=None, phase='train'):
+
+        self.root_dir = root_dir
+        self.transform = transform
+        self.channels = channels
+       
+        self.pth_Image = os.path.join(root_dir, 'jpg')
+            
+        # file index
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))]
+
+        n = len(files)
+        train_num = 550
+        val_num = 59
+        test_num = n - train_num - val_num
+        if phase == 'train':
+            self.image_files = files[:train_num+val_num]
+        elif phase == 'test':
+            self.image_files = files[-test_num:]
+        elif phase == 'all':
+            self.image_files = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+        
+
+    def __len__(self):
+        return len(self.image_files)
+    
+    def __getitem__(self, idx):
+        image_name = self.image_files[idx]
+
+        image = self.read_image(os.path.join(self.pth_Image, image_name + '.jpg'))
+
+        data_dict = {'name': image_name, 'image': image}   
+
+        return data_dict
+
+    def read_image(self, image_path):
+
+        if self.channels == 3:
+            image = Image.open(image_path).convert('RGB')
+            image_np = np.array(image).astype(np.float32)
+
+        elif self.channels == 1:
+            image = Image.open(image_path).convert('L')
+            image_np = np.array(image).astype(np.float32)
+            image_np = np.expand_dims(image_np, axis=2)
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+        
+        if self.transform:
+            image = self.transform(image=image_np)['image']
+            
+        return image
+
+
+# ------------------------------------------------------------------------
+#                               CEPH Dataset
+# ------------------------------------------------------------------------
+
+class CephaloDiffusionDataset(Dataset):
+    def __init__(self, root_dir, channels=1, transform=None, phase='train'):
+        self.root_dir = root_dir
+        self.transform = transform
+        self.channels = channels
+       
+        self.pth_Image = os.path.join(root_dir, 'jpg')
+            
+        # file index
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))]
+
+        n = len(files)
+        train_num = 130
+        val_num = 20
+        test_num = n - train_num - val_num
+        
+        if phase == 'train':
+            self.image_files = files[:train_num+val_num]
+        elif phase == 'test':
+            self.image_files = files[-test_num:]
+        elif phase == 'all':
+            self.image_files = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+
+    def __len__(self):
+        return len(self.image_files)
+    
+    def __getitem__(self, idx):
+        image_name = self.image_files[idx]
+
+        image = self.read_image(os.path.join(self.pth_Image, image_name + '.jpg'))
+
+        data_dict = {'name': image_name, 'image': image}   
+
+        return data_dict
+    
+    def read_image(self, image_path):
+            
+        if self.channels == 3:
+            image = Image.open(image_path).convert('RGB')
+            image_np = np.array(image).astype(np.float32)
+
+        elif self.channels == 1:
+            image = Image.open(image_path).convert('L')
+            image_np = np.array(image).astype(np.float32)
+            image_np = np.expand_dims(image_np, axis=2)
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+        
+        if self.transform:
+            image = self.transform(image=image_np)['image']
+            
+        return image
+
+
+# ------------------------------------------------------------------------
+#                               AARIZ Dataset
+# ------------------------------------------------------------------------
+
+class AarizDiffusionDataset(Dataset):
+    def __init__(self, root_dir, channels=3, transform=None, phase='train'):
+        """
+        Lightweight wrapper around the Aariz dataset. Uses the provided split
+        directories (`train`, `valid`, `test`) and consumes images from the
+        `Cephalograms` subfolder.
+        """
+        self.root_dir = root_dir
+        self.transform = transform
+        self.channels = channels
+
+        split_dir = 'train' if phase == 'train' else ('valid' if os.path.isdir(os.path.join(root_dir, 'valid')) else 'test')
+        self.images_dir = os.path.join(root_dir, split_dir, 'Cephalograms')
+
+        if not os.path.isdir(self.images_dir):
+            raise RuntimeError(f'Expected images under {self.images_dir}')
+
+        files = [i for i in sorted(os.listdir(self.images_dir)) if i.lower().endswith(('.png', '.jpg', '.jpeg'))]
+        if len(files) == 0:
+            raise RuntimeError(f'No images found in {self.images_dir}')
+
+        self.image_files = files
+
+    def __len__(self):
+        return len(self.image_files)
+
+    def __getitem__(self, idx):
+        image_name = self.image_files[idx]
+        image = self.read_image(os.path.join(self.images_dir, image_name))
+        return {'name': os.path.splitext(image_name)[0], 'image': image}
+
+    def read_image(self, image_path):
+        if self.channels == 3:
+            image = Image.open(image_path).convert('RGB')
+            image_np = np.array(image).astype(np.float32)
+        elif self.channels == 1:
+            image = Image.open(image_path).convert('L')
+            image_np = np.array(image).astype(np.float32)
+            image_np = np.expand_dims(image_np, axis=2)
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+
+        if self.transform:
+            image = self.transform(image=image_np)['image']
+
+        return image
+    
+        

DiffusionXray-FewShot-LandmarkDetection/ddpm_pretraining/main.py

@@ -0,0 +1,109 @@
+
+# ------------------------------------------------------------------------
+#                               Libraries 
+# ------------------------------------------------------------------------
+
+# General libraries
+import os
+import argparse
+import json
+import sys
+import time
+import logging
+
+import numpy as np
+
+# Deep learning libraries
+import torch
+#import tensorflow as tf
+#import tensorboard as tb
+from tqdm import tqdm
+
+# Custom libraries
+from utils import *
+from model.training_functions import *
+
+# Set random seed
+np.random.seed(42)
+torch.manual_seed(42) 
+torch.cuda.manual_seed(42)
+
+# ------------------------------------------------------------------------
+#                               MAIN
+# ------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    # Parse arguments from command line
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=str,
+        default="./ddpm_pretraining/config/config.json",
+        help="Path to the JSON config file."
+    )
+
+    args = parser.parse_args()
+    config = json.load(open(args.config))
+
+    # Print system info
+    print("----------------------------------------- SYSTEM INFO -----------------------------------------") 
+    print("Python version: {}".format(sys.version))
+    print("Pytorch version: {}".format(torch.__version__))
+    
+    if "CUDA_VISIBLE_DEVICES" in os.environ:
+        GPU = os.environ["CUDA_VISIBLE_DEVICES"]
+    else:
+        GPU = config["gpu"]
+        os.environ["CUDA_VISIBLE_DEVICES"] = f"{GPU}"
+        
+    device = f"cuda" if torch.cuda.is_available() else "cpu"
+    print(f"Torch GPU Name: {torch.cuda.get_device_name(0)}... Using GPU {GPU}" if device == "cuda" else "Torch GPU not available... Using CPU")
+        
+    print("------------------------------------------------------------------------------------------------")
+
+    # Config params for training and testing the model
+    root_path = config["experiment_path"]
+    DATASET_NAME = config["dataset"]["name"]
+    DATASET_PATH = os.path.join(config["dataset"]["path"], DATASET_NAME)
+    batch_size = config["dataset"]["batch_size"]
+    image_size = config["dataset"]["image_size"]
+    image_channels = config["dataset"]["image_channels"]
+    pin_memory = config["dataset"]["pin_memory"]
+    num_workers = 2 if config["dataset"]["num_workers"] == None else config["dataset"]["num_workers"]
+
+    # Create train and test dataloaders
+    train_dataloader, test_dataloader = load_data(DATASET_PATH, image_size, image_channels, batch_size, pin_memory=pin_memory, num_workers=num_workers)
+
+    # Save model path and tensorboard writer and path for the experiment
+    PREFIX_PATH = f"{root_path}/{DATASET_NAME}/{config['model']['beta_schedule']['train']['schedule']}_{config['model']['beta_schedule']['train']['n_timestep']}/size{image_size}_ch{image_channels}"
+    
+    # Create log file for the experiment
+    if not os.path.exists(f'{PREFIX_PATH}/log_file.txt'):
+        os.makedirs(PREFIX_PATH, exist_ok=True)
+
+        with open(f'{PREFIX_PATH}/log_file.txt', 'w') as f:
+            pass     
+               
+    logging.basicConfig(format="%(message)s", level=logging.INFO, filename=f'{PREFIX_PATH}/log_file.txt', filemode='a') # %(asctime)s 
+
+    # Save the original model checkpoint and the ema model checkpoint
+    save_model_path = generate_path(f"{PREFIX_PATH}/models/")
+
+    # Print config params
+    print("----------------------------------------- CONFIG PARAMS -----------------------------------------")
+    print(f"Dataset path: {DATASET_PATH}")
+    print(f"Dataset size: {len(train_dataloader.dataset)}")
+    print(f"Batch size: {batch_size} | Accumulation steps: {config['dataset']['grad_accumulation']}")
+    print(f"Number of batches: {len(train_dataloader)}")
+    print(f"Image shape: ({image_size}, {image_size}, {image_channels})")
+    print(f"Save model path: {save_model_path}")
+    print("------------------------------------------------------------------------------------------------")
+    
+    # Train diffusion model
+    print("----------------------------------------- START TRAINING -----------------------------------------")
+    print(f"Total epochs: {int(config['model']['iterations'] / (len(train_dataloader) / config['dataset']['grad_accumulation']))} | Total iterations: {config['model']['iterations']} | Iterations per epoch: {len(train_dataloader)/config['dataset']['grad_accumulation']}")
+    train_diffusion_model(config, train_dataloader, save_model_path, PREFIX_PATH, device, continue_training=config["model"]["continue_training"])
+
+    print("----------------------------------------- END TRAINING -----------------------------------------")
+    

DiffusionXray-FewShot-LandmarkDetection/ddpm_pretraining/model/ddpm_model.py

@@ -0,0 +1,213 @@
+""" 
+Diffusion model architecture modified from the original code  
+https://github.com/dome272/Diffusion-Models-pytorch/tree/main 
+and
+https://huggingface.co/blog/annotated-diffusion
+"""
+
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+import logging
+from model.nn_blocks import *
+from torch.optim import Adam, AdamW, SGD
+from torchmetrics.image import StructuralSimilarityIndexMeasure
+from torchmetrics import MeanSquaredError
+from torchvision.utils import make_grid
+import matplotlib.pyplot as plt
+import numpy as np
+import copy
+
+class DDPM:
+    def __init__(
+        self,
+        image_size: int = 256,
+        channels: int = 3,
+        device = "cuda",
+        lr: float = 1e-4,
+        optimizer: str = "adam",
+        timesteps: int = 1000,
+        beta_schedule: str = "linear",
+        beta_start: float = 1e-4,
+        beta_end: float = 0.02,
+        unet_channels: list = [1, 2, 4, 8],
+        unet_self_condition: bool = True,
+        unet_att_res: int = 32,
+        unet_att_heads: int = 4,
+        unet_res_blocks: int = 4,
+        use_ema: bool = False,
+    ):
+
+        self.timesteps = timesteps
+        self.device = device
+        self.image_size = image_size
+        self.channels = channels
+        self.lr = lr
+
+        self.beta_start = beta_start
+        self.beta_end = beta_end
+
+        # define beta schedule
+        self.beta = self.prepare_noise_schedule(beta_schedule=beta_schedule).to(device)
+        
+        # define alphas
+        self.alpha = 1.0 - self.beta
+        self.alpha_hat = torch.cumprod(self.alpha, dim=0)
+
+        # define model
+        self.model = Unet(
+            dim=image_size,
+            channels=channels,
+            dim_mults=unet_channels,
+            self_condition=unet_self_condition,
+            resnet_block_groups=unet_res_blocks,
+            att_heads=unet_att_heads,
+            att_res=unet_att_res,
+        )
+        self.model.to(self.device)
+
+        # define optimizer
+        self.optimizer = self.prepare_optimizer(optimizer)
+    
+        # Initialize EMA
+        if use_ema:
+            self.ema = EMA(0.995)
+            self.ema_model = copy.deepcopy(self.model).eval().requires_grad_(False).to(self.device)
+        else:
+            self.ema = None
+            self.ema_model = None
+
+    def update_ema(self):
+        # Update the EMA model parameters
+        self.ema.update_model_average(self.ema_model, self.model)
+        
+    def prepare_optimizer(self, optimizer):
+        if optimizer == "adam":
+            return Adam(self.model.parameters(), lr=self.lr)
+        elif optimizer == "adamw":
+            return AdamW(self.model.parameters(), lr=self.lr)
+        elif optimizer == "sgd":
+            return SGD(self.model.parameters(), lr=self.lr)
+        else:
+            raise NotImplementedError()
+        
+    def prepare_noise_schedule(self, beta_schedule):
+        if beta_schedule == "linear":
+            return linear_beta_schedule(
+                timesteps=self.timesteps, beta_start=self.beta_start, beta_end=self.beta_end
+            )
+        elif beta_schedule == "cosine":
+            return cosine_beta_schedule(timesteps=self.timesteps)
+        elif beta_schedule == "quadratic":
+            return quadratic_beta_schedule(
+                timesteps=self.timesteps, beta_start=self.beta_start, beta_end=self.beta_end
+            )
+        elif beta_schedule == "sigmoid":
+            return sigmoid_beta_schedule(
+                timesteps=self.timesteps, beta_start=self.beta_start, beta_end=self.beta_end
+            )
+        else:
+            raise NotImplementedError
+
+
+    def noise_images(self, x, t):
+        sqrt_alpha_hat = torch.sqrt(self.alpha_hat[t])[:, None, None, None]
+        sqrt_one_minus_alpha_hat = torch.sqrt(1 - self.alpha_hat[t])[:, None, None, None]
+        Ɛ = torch.randn_like(x)
+        return sqrt_alpha_hat * x + sqrt_one_minus_alpha_hat * Ɛ, Ɛ
+    
+    def noise_images_conditioned(self, x, t):
+        sqrt_alpha_hat = torch.sqrt(self.alpha_hat[t])
+        sqrt_one_minus_alpha_hat = torch.sqrt(1 - self.alpha_hat[t])
+        Ɛ = torch.randn_like(x)
+        return sqrt_alpha_hat * x + sqrt_one_minus_alpha_hat * Ɛ, Ɛ
+
+    def sample_timesteps(self, n):
+        return torch.randint(low=1, high=self.timesteps, size=(n,)).to(self.device)
+
+    def p_losses(self, x, t, loss_type="l1"):
+        
+        x_t, noise = self.noise_images(x, t)
+        predicted_noise = self.model(x_t, t)
+
+        if loss_type == "l1":
+            #loss = nn.L1Loss()(noise, predicted_noise)
+            loss = F.l1_loss(noise, predicted_noise)
+        elif loss_type == "l2":
+            #loss = nn.MSELoss()(noise, predicted_noise)
+            loss = F.mse_loss(noise, predicted_noise)
+        elif loss_type == "huber":
+            #loss = nn.SmoothL1Loss()(noise, predicted_noise)
+            loss = F.smooth_l1_loss(noise, predicted_noise)
+        else:
+            raise NotImplementedError()
+
+        return loss
+
+
+    def sample(self, model, batch_size, timesteps=None, x_cond=None):
+        with torch.no_grad():
+            if timesteps is None:
+                timesteps = self.timesteps
+
+            if x_cond is None:
+                x = torch.randn((batch_size, self.channels, self.image_size, self.image_size)).to(self.device)
+            else:
+                x,_ = self.noise_images_conditioned(x_cond, timesteps-1)
+
+            for i in tqdm(reversed(range(1, timesteps)), position=0):
+                t = (torch.ones(batch_size) * i).long().to(self.device)
+                predicted_noise = model(x, t)
+                alpha = self.alpha[t][:, None, None, None]
+                alpha_hat = self.alpha_hat[t][:, None, None, None]
+
+                beta = self.beta[t][:, None, None, None]
+                if i > 1:
+                    noise = torch.randn_like(x)
+                else:
+                    noise = torch.zeros_like(x)
+                x = 1 / torch.sqrt(alpha) * (x - ((1 - alpha) / (torch.sqrt(1 - alpha_hat))) * predicted_noise) + torch.sqrt(beta) * noise
+
+        return x
+    
+    @torch.no_grad()
+    def save_noising_process_image(self, x_start, filename):
+
+        images = [x_start[0:1]] # Select the first image from the batch
+        timesteps_to_visualize = [i for i in range(0, self.timesteps, self.timesteps // 10)]
+        
+        for t in timesteps_to_visualize:
+            t_tensor = torch.tensor([t], device=self.device)
+            noised_image, _ = self.noise_images(x_start, t_tensor)
+            images.append(noised_image[0:1]) # Select the first image from the batch
+
+        # Create a grid of images
+        image_grid = make_grid(torch.cat(images), nrow=len(timesteps_to_visualize) + 1, normalize=False)
+        image_grid = image_grid.clamp(0, 1)
+
+        # Convert to numpy array and transpose axes to HWC format for plotting
+        np_image_grid = image_grid.cpu().numpy().transpose((1, 2, 0))
+
+        # Plot and save the image
+        plt.figure(figsize=(len(images) * 2, 2))
+        plt.imshow(np_image_grid)
+        plt.axis('off')
+        plt.savefig(filename, bbox_inches='tight')
+        plt.close()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

DiffusionXray-FewShot-LandmarkDetection/ddpm_pretraining/model/nn_blocks.py

@@ -0,0 +1,450 @@
+
+# https://github.com/abarankab/DDPM/blob/main/ddpm/unet.py
+
+
+# ------------------------------------------------------------------------
+#                               Libraries
+# ------------------------------------------------------------------------
+
+import math
+from inspect import isfunction
+from functools import partial
+
+# from tqdm.auto import tqdm
+from einops import rearrange, reduce
+from einops.layers.torch import Rearrange
+
+import torch
+from torch import nn, einsum
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+
+# ------------------------------------------------------------------------
+#                               Utilities and Blocks
+# ------------------------------------------------------------------------
+
+def exists(x):
+    return x is not None
+
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if isfunction(d) else d
+
+
+def num_to_groups(num, divisor):
+    groups = num // divisor
+    remainder = num % divisor
+    arr = [divisor] * groups
+    if remainder > 0:
+        arr.append(remainder)
+    return arr
+
+
+class Residual(nn.Module):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+
+    def forward(self, x, *args, **kwargs):
+        return self.fn(x, *args, **kwargs) + x
+
+
+def Upsample(dim, dim_out=None):
+    return nn.Sequential(
+        nn.Upsample(scale_factor=2, mode="nearest"),
+        nn.Conv2d(dim, default(dim_out, dim), 3, padding=1),
+    )
+
+
+def Downsample(dim, dim_out=None):
+    # No More Strided Convolutions or Pooling
+    return nn.Sequential(
+        Rearrange("b c (h p1) (w p2) -> b (c p1 p2) h w", p1=2, p2=2),
+        nn.Conv2d(dim * 4, default(dim_out, dim), 1),
+    )
+
+
+class SinusoidalPositionEmbeddings(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, time):
+        device = time.device
+        half_dim = self.dim // 2
+        embeddings = math.log(10000) / (half_dim - 1)
+        embeddings = torch.exp(torch.arange(half_dim, device=device) * -embeddings)
+        embeddings = time[:, None] * embeddings[None, :]
+        embeddings = torch.cat((embeddings.sin(), embeddings.cos()), dim=-1)
+        return embeddings
+
+
+class WeightStandardizedConv2d(nn.Conv2d):
+    """
+    https://arxiv.org/abs/1903.10520
+    weight standardization purportedly works synergistically with group normalization
+    """
+
+    def forward(self, x):
+        eps = 1e-5 if x.dtype == torch.float32 else 1e-3
+
+        weight = self.weight
+        mean = reduce(weight, "o ... -> o 1 1 1", "mean")
+        var = reduce(weight, "o ... -> o 1 1 1", partial(torch.var, unbiased=False))
+        normalized_weight = (weight - mean) * (var + eps).rsqrt()
+
+        return F.conv2d(
+            x,
+            normalized_weight,
+            self.bias,
+            self.stride,
+            self.padding,
+            self.dilation,
+            self.groups,
+        )
+
+
+class Block(nn.Module):
+    def __init__(self, dim, dim_out, groups=8):
+        super().__init__()
+        self.proj = WeightStandardizedConv2d(dim, dim_out, 3, padding=1)
+        self.norm = nn.GroupNorm(groups, dim_out)
+        self.act = nn.SiLU()
+
+    def forward(self, x, scale_shift=None):
+        x = self.proj(x)
+        x = self.norm(x)
+
+        if exists(scale_shift):
+            scale, shift = scale_shift
+            x = x * (scale + 1) + shift
+
+        x = self.act(x)
+        return x
+
+
+class ResnetBlock(nn.Module):
+    """https://arxiv.org/abs/1512.03385"""
+
+    def __init__(self, dim, dim_out, *, time_emb_dim=None, groups=8):
+        super().__init__()
+        self.mlp = (
+            nn.Sequential(nn.SiLU(), nn.Linear(time_emb_dim, dim_out * 2))
+            if exists(time_emb_dim)
+            else None
+        )
+
+        self.block1 = Block(dim, dim_out, groups=groups)
+        self.block2 = Block(dim_out, dim_out, groups=groups)
+        self.res_conv = nn.Conv2d(dim, dim_out, 1) if dim != dim_out else nn.Identity()
+
+    def forward(self, x, time_emb=None):
+        scale_shift = None
+        if exists(self.mlp) and exists(time_emb):
+            time_emb = self.mlp(time_emb)
+            time_emb = rearrange(time_emb, "b c -> b c 1 1")
+            scale_shift = time_emb.chunk(2, dim=1)
+
+        h = self.block1(x, scale_shift=scale_shift)
+        h = self.block2(h)
+        return h + self.res_conv(x)
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads=4, dim_head=32):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        hidden_dim = dim_head * heads
+        self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False)
+        self.to_out = nn.Conv2d(hidden_dim, dim, 1)
+
+    def forward(self, x):
+        b, c, h, w = x.shape
+        qkv = self.to_qkv(x).chunk(3, dim=1)
+        q, k, v = map(
+            lambda t: rearrange(t, "b (h c) x y -> b h c (x y)", h=self.heads), qkv
+        )
+        q = q * self.scale
+
+        sim = einsum("b h d i, b h d j -> b h i j", q, k)
+        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
+        attn = sim.softmax(dim=-1)
+
+        out = einsum("b h i j, b h d j -> b h i d", attn, v)
+        out = rearrange(out, "b h (x y) d -> b (h d) x y", x=h, y=w)
+        return self.to_out(out)
+
+
+class LinearAttention(nn.Module):
+    def __init__(self, dim, heads=4, dim_head=32):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        hidden_dim = dim_head * heads
+        self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False)
+
+        self.to_out = nn.Sequential(nn.Conv2d(hidden_dim, dim, 1), nn.GroupNorm(1, dim))
+
+    def forward(self, x):
+        b, c, h, w = x.shape
+        qkv = self.to_qkv(x).chunk(3, dim=1)
+        q, k, v = map(
+            lambda t: rearrange(t, "b (h c) x y -> b h c (x y)", h=self.heads), qkv
+        )
+
+        q = q.softmax(dim=-2)
+        k = k.softmax(dim=-1)
+
+        q = q * self.scale
+        context = torch.einsum("b h d n, b h e n -> b h d e", k, v)
+
+        out = torch.einsum("b h d e, b h d n -> b h e n", context, q)
+        out = rearrange(out, "b h c (x y) -> b (h c) x y", h=self.heads, x=h, y=w)
+        return self.to_out(out)
+
+
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.fn = fn
+        self.norm = nn.GroupNorm(1, dim)
+
+    def forward(self, x):
+        x = self.norm(x)
+        return self.fn(x)
+    
+    
+# ------------------------------------------------------------------------
+#                               Unet Model with Time Embeddings
+# ------------------------------------------------------------------------
+
+class Unet(nn.Module):
+    def __init__(
+        self,
+        dim,
+        init_dim=None,
+        out_dim=None,
+        dim_mults=(1, 2, 4, 8),
+        channels=3,
+        self_condition=False,
+        resnet_block_groups=4,
+        att_res=32,
+        att_heads=4,
+    ):
+        super().__init__()
+
+        # determine dimensions
+        self.channels = channels
+        self.self_condition = self_condition
+        # input_channels = channels * (2 if self_condition else 1)
+        input_channels = channels if not self_condition else channels + 1
+
+        init_dim = default(init_dim, dim)
+        self.init_conv = nn.Conv2d(
+            input_channels, init_dim, 1, padding=0
+        )  # changed to 1 and 0 from 7,3
+
+        dims = [init_dim, *map(lambda m: dim * m, dim_mults)]
+        in_out = list(zip(dims[:-1], dims[1:]))
+
+        block_klass = partial(ResnetBlock, groups=resnet_block_groups)
+
+        # time embeddings
+        time_dim = dim * 4
+
+        self.time_mlp = nn.Sequential(
+            SinusoidalPositionEmbeddings(dim),
+            nn.Linear(dim, time_dim),
+            nn.GELU(),
+            nn.Linear(time_dim, time_dim),
+        )
+
+        # layers
+        self.downs = nn.ModuleList([])
+        self.ups = nn.ModuleList([])
+        num_resolutions = len(in_out)
+
+        for ind, (dim_in, dim_out) in enumerate(in_out):
+            is_last = ind >= (num_resolutions - 1)
+
+            self.downs.append(
+                nn.ModuleList(
+                    [
+                        block_klass(dim_in, dim_in, time_emb_dim=time_dim),
+                        block_klass(dim_in, dim_in, time_emb_dim=time_dim),
+                        Residual(
+                            PreNorm(dim_in, LinearAttention(dim_in, att_heads, att_res))
+                        ),
+                        Downsample(dim_in, dim_out)
+                        if not is_last
+                        else nn.Conv2d(dim_in, dim_out, 3, padding=1),
+                    ]
+                )
+            )
+
+        mid_dim = dims[-1]
+        self.mid_block1 = block_klass(mid_dim, mid_dim, time_emb_dim=time_dim)
+        self.mid_attn = Residual(
+            PreNorm(mid_dim, Attention(mid_dim, att_heads, att_res))
+        )
+        self.mid_block2 = block_klass(mid_dim, mid_dim, time_emb_dim=time_dim)
+
+        for ind, (dim_in, dim_out) in enumerate(reversed(in_out)):
+            is_last = ind == (len(in_out) - 1)
+
+            self.ups.append(
+                nn.ModuleList(
+                    [
+                        block_klass(dim_out + dim_in, dim_out, time_emb_dim=time_dim),
+                        block_klass(dim_out + dim_in, dim_out, time_emb_dim=time_dim),
+                        Residual(
+                            PreNorm(
+                                dim_out, LinearAttention(dim_out, att_heads, att_res)
+                            )
+                        ),
+                        Upsample(dim_out, dim_in)
+                        if not is_last
+                        else nn.Conv2d(dim_out, dim_in, 3, padding=1),
+                    ]
+                )
+            )
+
+        self.out_dim = default(out_dim, channels)
+
+        self.final_res_block = block_klass(dim * 2, dim, time_emb_dim=time_dim)
+        self.final_conv = nn.Conv2d(dim, self.out_dim, 1)
+
+
+    def forward(self, x, time=None, x_self_cond=None, checkpointing=True):
+        if self.self_condition:
+            x_self_cond = default(x_self_cond, lambda: torch.zeros_like(x))
+            x = torch.cat((x_self_cond, x), dim=1)
+
+        x = self.init_conv(x)
+        r = x.clone()
+
+        # Only compute time embedding if time is provided
+        if time is not None:  
+            t = self.time_mlp(time)
+        else:
+            t = None
+
+        h = []
+
+        # If checkpointing is enabled, run the model in a memory efficient way
+        if checkpointing:
+            for block1, block2, attn, downsample in self.downs:
+                x = checkpoint(block1, x, t, use_reentrant=False)
+                h.append(x)
+
+                x = checkpoint(block2, x, t, use_reentrant=False)
+                x = checkpoint(attn, x, use_reentrant=False)
+                h.append(x)
+
+                x = checkpoint(downsample, x, use_reentrant=False)
+
+            x = checkpoint(self.mid_block1, x, t, use_reentrant=False)
+            x = checkpoint(self.mid_attn, x, use_reentrant=False)
+            x = checkpoint(self.mid_block2, x, t, use_reentrant=False)
+
+            for block1, block2, attn, upsample in self.ups:
+                x = torch.cat((x, h.pop()), dim=1)
+                x = checkpoint(block1, x, t, use_reentrant=False)
+
+                x = torch.cat((x, h.pop()), dim=1)
+                x = checkpoint(block2, x, t, use_reentrant=False)
+                x = checkpoint(attn, x, use_reentrant=False)
+
+                x = checkpoint(upsample, x, use_reentrant=False)
+                
+        # If checkpointing is not enabled, run the model normally
+        else:
+            for block1, block2, attn, downsample in self.downs:
+                x = block1(x, t)
+                h.append(x)
+
+                x = block2(x, t)
+                x = attn(x)
+                h.append(x)
+
+                x = downsample(x)
+
+            x = self.mid_block1(x, t)
+            x = self.mid_attn(x)
+            x = self.mid_block2(x, t)
+
+            for block1, block2, attn, upsample in self.ups:
+                x = torch.cat((x, h.pop()), dim=1)
+                x = block1(x, t)
+
+                x = torch.cat((x, h.pop()), dim=1)
+                x = block2(x, t)
+                x = attn(x)
+
+                x = upsample(x)
+
+        x = torch.cat((x, r), dim=1)
+
+        x = self.final_res_block(x, t)
+        return self.final_conv(x)
+
+# ------------------------------------------------------------------------
+#                               Noise Schedule
+# ------------------------------------------------------------------------
+
+def cosine_beta_schedule(timesteps, s=0.008):
+    """
+    cosine schedule as proposed in https://arxiv.org/abs/2102.09672
+    """
+    steps = timesteps + 1
+    x = torch.linspace(0, timesteps, steps)
+    alphas_cumprod = torch.cos(((x / timesteps) + s) / (1 + s) * torch.pi * 0.5) ** 2
+    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
+    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
+    return torch.clamp(betas, 0.0001, 0.9999)
+
+def linear_beta_schedule(timesteps, beta_start=0.0001, beta_end=0.02):
+    return torch.linspace(beta_start, beta_end, timesteps)
+
+
+def quadratic_beta_schedule(timesteps, beta_start=0.0001, beta_end=0.02):
+    return torch.linspace(beta_start**0.5, beta_end**0.5, timesteps) ** 2
+
+
+def sigmoid_beta_schedule(timesteps, beta_start=0.0001, beta_end=0.02):
+    betas = torch.linspace(-6, 6, timesteps)
+    return torch.sigmoid(betas) * (beta_end - beta_start) + beta_start
+
+# ------------------------------------------------------------------------
+#                               EMA (Exponential Moving Average)
+# ------------------------------------------------------------------------
+
+class EMA:
+    def __init__(self, beta):
+        super().__init__()
+        self.beta = beta
+        self.step = 0
+
+    def update_model_average(self, ma_model, current_model):
+        for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()):
+            old_weight, up_weight = ma_params.data, current_params.data
+            ma_params.data = self.update_average(old_weight, up_weight)
+
+    def update_average(self, old, new):
+        if old is None:
+            return new
+        return old * self.beta + (1 - self.beta) * new
+
+    def step_ema(self, ema_model, model, step_start_ema=2000):
+        if self.step < step_start_ema:
+            self.reset_parameters(ema_model, model)
+            self.step += 1
+            return
+        self.update_model_average(ema_model, model)
+        self.step += 1
+
+    def reset_parameters(self, ema_model, model):
+        ema_model.load_state_dict(model.state_dict())

DiffusionXray-FewShot-LandmarkDetection/ddpm_pretraining/model/training_functions.py

@@ -0,0 +1,327 @@
+
+
+# ------------------------------------------------------------------------
+#                               Libraries
+# ------------------------------------------------------------------------
+
+# General libraries
+import numpy as np
+import logging
+from typing import Dict, Any
+import time
+import os
+
+# Deep learning libraries
+#import tensorflow as tf
+import torch
+import torch.nn as nn
+
+from tqdm import tqdm
+from torchmetrics import MeanSquaredError
+from torchmetrics.image import StructuralSimilarityIndexMeasure
+from torchmetrics.image.fid import FrechetInceptionDistance
+
+# Custom libraries
+from utils import *
+from model.nn_blocks import *
+
+from model.ddpm_model import DDPM
+
+
+
+def initialize_ddpm(config: Dict[str, Any], phase: str, device: torch.device) -> DDPM:
+    
+    if phase == "train":
+        ddpm = DDPM(
+            image_size=config["dataset"]["image_size"],
+            channels=config["dataset"]["image_channels"],
+            device=device,
+            lr=config["model"]["lr"],
+            optimizer=config["model"]["optimizer"],
+            timesteps=config["model"]["beta_schedule"]["train"]["n_timestep"],
+            beta_schedule=config["model"]["beta_schedule"]["train"]["schedule"],
+            beta_start=config["model"]["beta_schedule"]["train"]["linear_start"],
+            beta_end=config["model"]["beta_schedule"]["train"]["linear_end"],
+            unet_self_condition=config["model"]["unet"]["self_condition"],
+            unet_channels=config["model"]["unet"]["channel_mults"],
+            unet_res_blocks=config["model"]["unet"]["res_blocks"],
+            unet_att_heads=config["model"]["unet"]["num_head_channels"],
+            unet_att_res=config["model"]["unet"]["attn_res"],
+            use_ema=config["model"]["use_ema"],
+        )
+        
+    elif phase == "test":
+        ddpm = DDPM(
+            image_size=config["dataset"]["image_size"],
+            channels=config["dataset"]["image_channels"],
+            device=device,
+            lr=config["model"]["lr"],
+            optimizer=config["model"]["optimizer"],
+            timesteps=config["model"]["beta_schedule"]["test"]["n_timestep"],
+            beta_schedule=config["model"]["beta_schedule"]["test"]["schedule"],
+            beta_start=config["model"]["beta_schedule"]["test"]["linear_start"],
+            beta_end=config["model"]["beta_schedule"]["test"]["linear_end"],
+            unet_self_condition=config["model"]["unet"]["self_condition"],
+            unet_channels=config["model"]["unet"]["channel_mults"],
+            unet_res_blocks=config["model"]["unet"]["res_blocks"],
+            unet_att_heads=config["model"]["unet"]["num_head_channels"],
+            unet_att_res=config["model"]["unet"]["attn_res"],
+        )
+    else:
+        raise ValueError(f"Phase {phase} is not valid. Must be either 'train' or 'test'")
+
+    return ddpm
+
+def save_model(model, optimizer, epoch, n_iter, loss, save_path, name="last_model"):
+    torch.save({
+        "epoch": epoch,
+        "n_iter": n_iter,
+        "model_state_dict": model.state_dict(),
+        "optimizer_state_dict": optimizer.state_dict(),
+        "loss": loss,
+    }, f"{save_path}/{name}.pt")
+
+def save_ema_model(ema_model, epoch, n_iter, save_path, name="last_ema_model"):
+    torch.save({
+        "epoch": epoch,
+        "n_iter": n_iter,
+        "model_state_dict": ema_model.state_dict(),
+    }, f"{save_path}/{name}.pt")
+
+
+def load_model(save_model_path, device, ddpm):
+    assert os.path.exists(f"{save_model_path}"), f"Model {save_model_path} does not exist"
+    checkpoint = torch.load(f"{save_model_path}", map_location=device)
+    ddpm.model.load_state_dict(checkpoint["model_state_dict"])
+    ddpm.optimizer.load_state_dict(checkpoint["optimizer_state_dict"]) if "optimizer_state_dict" in checkpoint else None
+    epoch = checkpoint.get('epoch', 'undefined')
+    n_iter = checkpoint.get('n_iter', 'undefined')
+    loss = checkpoint.get('loss', np.inf)
+    del checkpoint
+    print(f"Model loaded for epoch: {epoch} and iteration: {n_iter} with loss: {loss}")
+    return epoch, n_iter, loss
+
+def load_ema_model(save_model_path, device, ddpm):
+    assert os.path.exists(f"{save_model_path}"), f"Model {save_model_path} does not exist"
+    ema_checkpoint = torch.load(f"{save_model_path}", map_location=device)
+    ddpm.ema_model.load_state_dict(ema_checkpoint["model_state_dict"])
+    ema_epoch = ema_checkpoint.get('epoch', 0)
+    ema_n_iter = ema_checkpoint.get('n_iter', 0)
+    del ema_checkpoint
+    print(f"EMA Model loaded for epoch: {ema_epoch} and iteration: {ema_n_iter}")
+    return ema_epoch, ema_n_iter
+
+
+# ------------------------------------------------------------------------
+#                               TRAINING DIFFUSION MODEL
+# ------------------------------------------------------------------------
+
+
+def train_diffusion_model(config, train_dataloader, save_model_path, root_path, device, continue_training=False):
+    # config params
+    image_size = config["dataset"]["image_size"]
+    channels = config["dataset"]["image_channels"]
+    batch_size = config["dataset"]["batch_size"]
+    grad_accumulation = config["dataset"]["grad_accumulation"]
+    iterations = config["model"]["iterations"]
+    # Compute number of epochs based on the number of iterations and the number of batches and gradient accumulation
+    # Total epochs = iterations / iterations per epoch (batches per epoch / grad_accumulation)
+    epochs = int(iterations / (len(train_dataloader) / grad_accumulation)) + 1
+    
+    loss_type = config["model"]["loss_type"]
+    timesteps=config["model"]["beta_schedule"]["train"]["n_timestep"]
+    freq_metrics = config["model"]["freq_metrics"]
+    freq_checkpoint = config["model"]["freq_checkpoint"]
+    use_ema = config["model"]["use_ema"]
+
+    # instanciate the diffusion model
+    ddpm = initialize_ddpm(config, phase="train", device=device)
+
+    # Print model count trainable parameters
+    table, total_params = count_parameters(ddpm.model)
+    logging.info(f"Total Trainable Params: {total_params}")
+    
+    # If continue_training is True, load the model
+    if continue_training:
+        model_path = os.path.join(save_model_path, "last_model.pt")
+        start_epoch, n_iter, best_loss = load_model(model_path, device, ddpm)
+        
+        if use_ema:
+            ema_model_path = os.path.join(save_model_path, "last_ema_model.pt")
+            ema_epoch, ema_n_iter = load_ema_model(ema_model_path, device, ddpm)
+        
+    else:
+        start_epoch, n_iter = 0, 0
+        best_loss = np.inf
+        
+    # instanciate metrics
+    ssim = StructuralSimilarityIndexMeasure(data_range=None, reduction="elementwise_mean")
+    mse = MeanSquaredError()
+    fid = FrechetInceptionDistance(normalize=True)
+    
+    # Start training
+    start_time = time.time()
+
+    try:    
+        # Train diffusion model
+        for epoch in tqdm(range(start_epoch, epochs), initial=start_epoch, total=epochs, desc="Epoch"):
+            epoch_loss = 0.0
+            torch.cuda.empty_cache()
+            
+            for batch_idx, data in enumerate(tqdm(train_dataloader, desc="Batch", leave=False)):
+
+                # Load data
+                x = data['image'].to(device)
+                x_names = data['name']
+                batch_size = x.shape[0]
+                
+                # Save noising process image
+                if batch_idx == 0 and epoch == 0:
+                    ddpm.save_noising_process_image(x, f'{root_path}/noising_process.png')
+
+                # Forward pass
+                t = ddpm.sample_timesteps(batch_size)
+                loss = ddpm.p_losses(x=x, t=t, loss_type=loss_type)
+
+                # Backward pass 
+                loss.backward()
+                loss = loss / grad_accumulation  # Normalize loss to account for batch accumulation
+                epoch_loss += loss.item()
+                
+                # Update weights
+                if ((batch_idx + 1) % grad_accumulation == 0) or (batch_idx + 1 == len(train_dataloader)):
+                
+                    # Clip to solve the gradient exploding problem
+                    nn.utils.clip_grad_value_(ddpm.model.parameters(), clip_value=1.0)
+
+                    ddpm.optimizer.step()
+                    ddpm.optimizer.zero_grad()
+                
+                    # Update EMA parameters after each training step
+                    if use_ema: ddpm.update_ema()
+                    
+                    # Update number of steps                
+                    n_iter += 1    
+
+                    # Save model checkpoint after each training step
+                    save_model(ddpm.model, ddpm.optimizer, epoch, n_iter, loss, save_model_path, name="last_model")
+                    if use_ema: save_ema_model(ddpm.ema_model, epoch, n_iter, save_model_path, name="last_ema_model")
+        
+                # Compute Metrics
+                if n_iter % freq_metrics == 0 and batch_idx % grad_accumulation == 0 and n_iter != 0:
+                    # Set model to eval mode
+                    ddpm.model.eval()
+                                            
+                    # Generate images conditioned on the input images x
+                    x_hat = ddpm.sample(model=ddpm.model, x_cond=x, batch_size=batch_size, timesteps=timesteps)
+                    if use_ema: ema_x_hat = ddpm.sample(model=ddpm.ema_model, x_cond=x, batch_size=batch_size, timesteps=timesteps)
+                
+                    # Detach tensors from GPU
+                    x = x.detach().cpu()
+                    x_hat = x_hat.detach().cpu()
+                    
+                    # Check pixel range of generated images
+                    x_hat_min, x_hat_max = check_pixels_range_of_image(x_hat)
+                    
+                    # Compute metrics
+                    ssim_metric = ssim(x_hat, x)
+                    mse_metric = mse(x_hat, x)
+                    
+                    # Compute FID
+                    real_images = x if channels == 3 else x.repeat(1, 3, 1, 1)
+                    fake_images = x_hat if channels == 3 else x_hat.repeat(1, 3, 1, 1)
+
+                    fid.update(real_images, real=True)
+                    fid.update(fake_images.clamp(0, 1), real=False)
+                    fid_score = fid.compute()
+                    
+                    # Compute differece images
+                    diff = compute_diff(real_images, fake_images)
+                    
+                    # Save batch original images in the first row, generated images in the second row, and diff images in the third row
+                    train_imgs_path = generate_path(f"{root_path}/images/train")
+                    image_titles = [f"{x_names[i]}" for i in range(batch_size)]
+                    save_images([real_images, fake_images, diff], f"{train_imgs_path}/train_epoch{epoch}_iteration{n_iter}_batch{batch_idx}.jpg", f"Epoch {epoch} - Iteration {n_iter} - Batch {batch_idx} - Timesteps {timesteps}", image_titles)
+
+                    # Log metrics
+                    logging.info(f"\nEpoch/Iteration {epoch}/{n_iter} \t Batch {batch_idx} \t Loss: {loss.item():.6f}")
+                    logging.info(f"\t\t SSIM: {ssim_metric.item():.4f} \t MSE: {mse_metric.item():.6f} \t FID: {fid_score:.2f} \t Pixel range: [{x_hat_min:.2f}, {x_hat_max:.2f}]")
+
+                    
+                    # Send message
+                    message = (
+                        f"<b>Epoch/Iteration {epoch}/{n_iter}</b> --> [{x_hat_min:.2f}, {x_hat_max:.2f}] \n"
+                        f"  • <b>Loss:</b> {loss.item():.4f} \n"
+                        f"  • <b>SSIM:</b> {ssim_metric.item():.4f} \n"
+                        f"  • <b>MSE:</b> {mse_metric.item():.4f} \n"
+                        f"  • <b>FID:</b> {fid_score:.4f}"
+                    )
+                            
+                    # Compute EMA metrics
+                    if use_ema:
+
+                        ema_x_hat = ema_x_hat.detach().cpu()
+                        
+                        ema_ssim_metric = ssim(ema_x_hat, x)
+                        ema_mse_metric = mse(ema_x_hat, x)
+
+                        ema_x_hat_min, ema_x_hat_max = check_pixels_range_of_image(ema_x_hat)
+                        
+                        ema_fake_images = ema_x_hat if channels == 3 else ema_x_hat.repeat(1, 3, 1, 1)
+                        
+                        fid.update(ema_fake_images.clamp(0, 1), real=False)
+                        ema_fid_score = fid.compute()
+                                
+                        ema_diff = compute_diff(real_images, ema_fake_images)
+
+
+                        # Set image titles for each image 
+                        ema_image_titles = [f"{x_names[i]}" for i in range(batch_size)]
+                        save_images([real_images, ema_fake_images, ema_diff], f"{train_imgs_path}/train_epoch{epoch}_iteration{n_iter}_batch{batch_idx}_ema.jpg",  f"Epoch {epoch} - Iteration {n_iter} - Batch {batch_idx} - Timesteps {timesteps}", ema_image_titles)
+        
+                        logging.info(f"\t\t SSIM: {ema_ssim_metric.item():.4f} \t MSE: {ema_mse_metric.item():.6f} \t FID: {ema_fid_score:.2f}\t Pixel range: [{ema_x_hat_min:.2f}, {ema_x_hat_max:.2f}]")
+
+                        
+                        message += (
+                            f"\n\n<b>EMA Epoch/Iteration {epoch}/{n_iter}</b> --> [{ema_x_hat_min:.2f}, {ema_x_hat_max:.2f}] \n"
+                            f"  • <b>Loss:</b> {loss.item():.4f} \n"
+                            f"  • <b>SSIM:</b> {ema_ssim_metric.item():.4f} \n"
+                            f"  • <b>MSE:</b> {ema_mse_metric.item():.4f} \n"
+                            f"  • <b>FID:</b> {ema_fid_score:.4f}"
+                        )
+                                        
+                    
+                    # Delete tensors from GPU
+                    del x, x_hat, real_images, fake_images, diff, ema_x_hat, ema_fake_images, ema_diff
+                    
+                    # Log and print message
+                    print(message)
+                    logging.info(message)
+                                        
+                    # Set model back to train mode
+                    ddpm.model.train()
+                                    
+                # Save model checkpoint
+                if n_iter % freq_checkpoint == 0 and n_iter!= 0 and batch_idx % grad_accumulation == 0:
+                    print(f"Saving model checkpoint at epoch {epoch} and iteration {n_iter} with loss: {loss.item():.4f}")                
+                    save_model(ddpm.model, ddpm.optimizer, epoch, n_iter, loss, save_model_path, name=f"model_epoch{epoch}_step{n_iter}")
+                    if use_ema: save_ema_model(ddpm.ema_model, epoch, n_iter, save_model_path, name=f"ema_model_epoch{epoch}_step{n_iter}")
+
+                    if n_iter % iterations == 0:
+                        print(f"Reaching {iterations} iterations. Exiting training...")
+                        exit()
+                        
+            epoch_loss /= len(train_dataloader)
+                            
+    except (KeyboardInterrupt, SystemExit, Exception) as e:
+        if isinstance(e, Exception):
+            print(f"Exception: {e}")
+        print("\nTraining interrupted. Saving final state...")
+        save_model(ddpm.model, ddpm.optimizer, epoch, n_iter, loss, save_model_path, name="last_model")
+        if use_ema: save_ema_model(ddpm.ema_model, epoch, n_iter, save_model_path, name="last_ema_model")
+        
+    finally:
+        print(f"Training completed in {time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}")
+        logging.info(f"Training completed in {time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}")
+        del ddpm
+        torch.cuda.empty_cache()

DiffusionXray-FewShot-LandmarkDetection/ddpm_pretraining/utils.py

@@ -0,0 +1,180 @@
+
+# ------------------------------------------------------------------------
+#                               Libraries
+# ------------------------------------------------------------------------
+
+# General libraries
+import os
+import cv2
+from matplotlib import pyplot as plt
+from prettytable import PrettyTable
+
+# Deep learning libraries
+import torch
+import torchvision
+from torch.utils.data import DataLoader
+import albumentations as A
+
+# Custom libraries
+from ddpm_datasets import ChestDiffusionDataset, HandDiffusionDataset, CephaloDiffusionDataset, AarizDiffusionDataset
+
+# ------------------------------------------------------------------------
+#                               Logging and Utilities
+# ------------------------------------------------------------------------
+
+# Generate path if it does not exist
+def generate_path(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+    return path
+
+# Get the current GPU memory usage by tensors in megabytes for a given device
+def gpu_memory_usage(device):
+    allocated = torch.cuda.memory_allocated(device)
+    reserved = torch.cuda.memory_reserved(device)
+    print(f'Allocated memory: {allocated / (1024 ** 2):.2f} MB')
+    print(f'Reserved memory: {reserved / (1024 ** 2):.2f} MB')
+
+# Compute the number of trainable parameters in a model
+def count_parameters(model):
+    table = PrettyTable(["Modules", "Parameters"])
+    total_params = 0
+    for name, parameter in model.named_parameters():
+        if not parameter.requires_grad:
+            continue
+        params = parameter.numel()
+        table.add_row([name, params])
+        total_params += params
+    #print(table)
+    print(f"Total Trainable Params: {total_params}")
+    return table, total_params
+
+# ------------------------------------------------------------------------
+#                               Visualizations
+# ------------------------------------------------------------------------
+   
+def plot_images(images):
+    plt.figure(figsize=(32, 32))
+    plt.imshow(torch.cat([
+        torch.cat([i for i in images.cpu()], dim=-1),
+    ], dim=-2).permute(1, 2, 0).cpu())
+    plt.show()
+
+
+def save_images(images, path, title, image_names, **kwargs):
+    batch_size = images[0].shape[0]
+    fig, axs = plt.subplots(3, batch_size, figsize=(batch_size * 2, 6))
+    
+    for i in range(batch_size):
+        axs[0, i].imshow(images[0][i].permute(1, 2, 0).to('cpu').numpy())
+        axs[0, i].set_title(f"{image_names[i]}")
+        axs[0, i].axis('off')
+        
+        axs[1, i].imshow(images[1][i].permute(1, 2, 0).to('cpu').numpy())
+        axs[1, i].set_title("Reconstructed")
+        axs[1, i].axis('off')
+        
+        axs[2, i].imshow(images[2][i].permute(1, 2, 0).to('cpu').numpy())
+        axs[2, i].set_title("Difference")
+        axs[2, i].axis('off')
+    
+    fig.suptitle(f"{title}")
+    fig.tight_layout()
+    fig.savefig(path, bbox_inches='tight')
+    plt.close(fig)
+
+def check_pixels_range_of_image(tensor):
+    # Ensure the input is a tensor
+    assert torch.is_tensor(tensor), "Input must be a tensor"
+
+    # Flatten the tensor to get all pixel values
+    pixel_values = tensor.view(-1)
+
+    # Compute min and max values
+    min_val = pixel_values.min().item()
+    max_val = pixel_values.max().item()
+
+    #print(f"The range of pixel values is: {min_val} to {max_val}")
+    return min_val, max_val
+
+
+def compute_diff(x, x_hat):
+    # Ensure both tensors are on the same device
+    assert x.device == x_hat.device, "Tensors must be on the same device"
+    
+    # Ensure both tensors have the same shape
+    assert x.shape == x_hat.shape, "Tensors must have the same shape"
+    
+    x_min, x_max = check_pixels_range_of_image(x)
+    x_hat_min, x_hat_max = check_pixels_range_of_image(x_hat)
+
+    # Ensure both tensors are have pixel values in the range [0, 1]
+    #assert x_min >= 0 and x_max <= 1, f"Pixel values of x must be in the range [0, 1]. Actual range: [{x_min}, {x_max}]"
+    #assert x_hat_min >= 0 and x_hat_max <= 1, f"Pixel values of x_hat must be in the range [0, 1]. Actual range: [{x_hat_min}, {x_hat_max}]"
+    #print(f"Pixel values of x are in the range [{x_min}, {x_max}]")
+    #print(f"Pixel values of x_hat are in the range [{x_hat_min}, {x_hat_max}]")
+    # Compute absolute difference
+    diff = torch.abs(x - x_hat)
+    
+    # Normalize to the range [0, 1] and return the difference image
+    diff = (diff - diff.min()) / (diff.max() - diff.min())  
+
+    return diff
+
+
+# ------------------------------------------------------------------------
+#                               Data Loading and Preprocessing
+# ------------------------------------------------------------------------
+
+def get_transforms(image_size, phase='train'):
+    resize_image_size = int(image_size*1.02)
+    if phase == 'train':
+        return A.Compose([
+        A.ShiftScaleRotate(shift_limit=0.02, scale_limit=0, rotate_limit=2, border_mode=cv2.BORDER_REPLICATE, p=0.5),
+        #A.Perspective(scale=(0, 0.02), pad_mode=cv2.BORDER_REPLICATE, p=0.5),
+        A.Resize(image_size, image_size),
+        #A.RandomCrop(height=image_size, width=image_size),
+        #A.HorizontalFlip(p=1),
+        #A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.2, 0.2), p=0.5),
+        A.Normalize(normalization='min_max'),
+        A.pytorch.ToTensorV2()
+    ])
+
+    elif phase == 'test':
+        return A.Compose([
+        A.Resize(image_size, image_size),
+        A.Normalize(normalization='min_max'),
+        A.pytorch.transforms.ToTensorV2()
+        ])
+    else:
+        raise ValueError('phase must be either "train" or "test"')
+
+
+def load_data(dataset_path, image_size, image_channels, batch_size, pin_memory=False, num_workers = os.cpu_count()):    
+    dataset_name = os.path.basename(dataset_path).lower()
+    
+    transforms_train = get_transforms(image_size, phase='train')
+    transforms_test = get_transforms(image_size, phase='test')
+    
+    if dataset_name == 'chest':
+        train_dataset = ChestDiffusionDataset(dataset_path, channels=image_channels, transform=transforms_train, phase='train')
+        test_dataset = ChestDiffusionDataset(dataset_path, channels=image_channels, transform=transforms_test, phase='test')
+    elif dataset_name == 'hand':
+        train_dataset = HandDiffusionDataset(dataset_path, channels=image_channels, transform=transforms_train, phase='train')
+        test_dataset = HandDiffusionDataset(dataset_path, channels=image_channels, transform=transforms_test, phase='test')
+    elif dataset_name == 'cephalo':
+        train_dataset = CephaloDiffusionDataset(dataset_path, channels=image_channels, transform=transforms_train, phase='train')
+        test_dataset = CephaloDiffusionDataset(dataset_path, channels=image_channels, transform=transforms_test, phase='test')
+    elif dataset_name == 'aariz':
+        train_dataset = AarizDiffusionDataset(dataset_path, channels=image_channels, transform=transforms_train, phase='train')
+        test_dataset = AarizDiffusionDataset(dataset_path, channels=image_channels, transform=transforms_test, phase='test')
+    else:
+        raise ValueError('Dataset name must be either "chest" or "hand" or "cephalo" or "aariz"')
+    
+    train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=pin_memory, drop_last=True)
+    test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=pin_memory, drop_last=False)
+    
+    return train_dataloader, test_dataloader
+
+
+

DiffusionXray-FewShot-LandmarkDetection/downstream_task/config/config.json

@@ -0,0 +1,48 @@
+{
+    "gpu": 0,
+    "experiment_path": "downstream_task/landmarks_experiments",
+    "model": {
+        "name": "ddpm",
+        "encoder": "",
+        "lr":1e-5,
+        "optimizer": "AdamW",
+        "scheduler": "ReduceLROnPlateau",
+        "loss_function": "CrossEntropyLoss",
+        "epochs": 200
+    },
+
+    "training_protocol":{
+        "apply": true,
+
+        "scratch": {
+            "apply": false,
+            "resume": false
+        },
+
+        "finetuning": {
+            "apply": true,
+            "resume": false,
+            "path": "",
+            "different_dataset": false
+        }
+    },
+
+    "inference_protocol": {
+        "apply": true,
+        "use_validation_set_for_inference": false
+    },
+
+    "dataset":{
+        "name": "chest",
+        "path": "datasets/",
+        "image_size": [256, 256],
+        "image_channels": 1,
+        "sigma": 5,
+        "batch_size": 2,
+        "grad_accumulation": 8,
+        "num_workers": null,
+        "pin_memory": true,
+        "training_samples": "all"
+    }
+}
+

DiffusionXray-FewShot-LandmarkDetection/downstream_task/imagenet_backbones_comparative_study.py

@@ -0,0 +1,187 @@
+# ------------------------------------------------------------------------
+#                               Libraries
+# ------------------------------------------------------------------------
+
+# General libraries
+import os
+import random
+from datetime import datetime
+
+# Deep learning libraries
+import torch
+from torch import nn 
+from torch.utils.data import DataLoader
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+
+# Custom libraries
+from utilities import *
+from landmarks_datasets import * 
+from model.deep_learning import *
+from model.models import *
+
+# Set random seed
+random.seed(42)
+np.random.seed(42)
+torch.manual_seed(42) 
+torch.cuda.manual_seed(42)
+
+
+import ssl
+
+ssl._DEFAULT_CIPHERS = 'HIGH:!DH:!aNULL'
+
+def ignore_ssl_certificate_verification():
+    try:
+        # Python 3.4+
+        import ssl
+        ssl._create_default_https_context = ssl._create_unverified_context
+    except AttributeError:
+        # Python 2.x
+        import requests
+        from urllib3.exceptions import InsecureRequestWarning
+        requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+
+ignore_ssl_certificate_verification()
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                      DATASETS                                             ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+datasets_list = ["chest", "cephalo", "hand"] 
+backbone_list = ["vgg19", "densenet161", "resnext50_32x4d"] #"efficientnet-b5"] 
+
+EXPERIMENT_PATH = "downstream_task/landmarks_experiments/backbone_selection"
+
+# Create folder for saving models 
+if not os.path.exists(EXPERIMENT_PATH):
+    os.makedirs(EXPERIMENT_PATH)
+
+log_file = f"{EXPERIMENT_PATH}/experiments_results.txt"
+
+NUM_EPOCHS = 200
+K_FOLDS = 5
+BATCH_SIZE = 2
+GRAD_ACC = 8
+
+LR = 1e-5
+SIZE = (256, 256)
+SIGMA = 5
+
+PATIENCE = GRAD_ACC + 5
+EARLY_STOPPING = PATIENCE * 2 + 1
+
+NUM_CHANNELS = 1
+ONLY_INFERENCE = False
+PIN_MEMORY = True
+NUM_WORKERS = 2
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+
+# ---------------------------------------------------------------- CHEST ---------
+CHEST_DATASET_PATH = 'datasets/chest'
+assert os.path.exists(CHEST_DATASET_PATH), f"Chest dataset path does not exist: {CHEST_DATASET_PATH}, current path: {os.getcwd()}"
+CHEST_NUM_LANDMARKS = 6
+
+CHEST_SIZE = SIZE
+CHEST_SIGMA = SIGMA
+
+chest_train_dataset = Chest(prefix=CHEST_DATASET_PATH, phase='train', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+chest_val_dataset = Chest(prefix=CHEST_DATASET_PATH, phase='validate', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+chest_test_dataset = Chest(prefix=CHEST_DATASET_PATH, phase='test', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+
+chest_train_val_dataset = torch.utils.data.ConcatDataset([chest_train_dataset, chest_val_dataset])
+print(f"CHEST: {len(chest_train_dataset)} | {len(chest_val_dataset)} | {len(chest_test_dataset)}")
+
+
+# ---------------------------------------------------------------- CEPHALOMETRIC ---------
+CEPHALOMETRIC_DATASET_PATH = 'datasets/cephalo'
+assert os.path.exists(CEPHALOMETRIC_DATASET_PATH), f"Cephalometric dataset path does not exist: {CEPHALOMETRIC_DATASET_PATH}, current path: {os.getcwd()}"
+CEPHALOMETRIC_NUM_LANDMARKS = 19
+
+CEPHALOMETRIC_SIZE = SIZE
+CEPHALOMETRIC_SIGMA = SIGMA
+
+cephalo_train_dataset = Cephalo(prefix=CEPHALOMETRIC_DATASET_PATH, phase='train', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+cephalo_val_dataset = Cephalo(prefix=CEPHALOMETRIC_DATASET_PATH, phase='validate', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+cephalo_test_dataset = Cephalo(prefix=CEPHALOMETRIC_DATASET_PATH, phase='test', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+
+cephalo_train_val_dataset = torch.utils.data.ConcatDataset([cephalo_train_dataset, cephalo_val_dataset])
+print(f"CEPHALO: {len(cephalo_train_dataset)} | {len(cephalo_val_dataset)} | {len(cephalo_test_dataset)}")
+
+
+# ---------------------------------------------------------------- HAND ---------
+HAND_DATASET_PATH = 'datasets/hand'
+assert os.path.exists(HAND_DATASET_PATH), f"Hand dataset path does not exist: {HAND_DATASET_PATH}, current path: {os.getcwd()}"
+HAND_NUM_LANDMARKS = 37
+
+HAND_SIZE = SIZE
+HAND_SIGMA =  SIGMA
+
+hand_train_dataset = Hand(prefix=HAND_DATASET_PATH, phase='train', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+hand_val_dataset = Hand(prefix=HAND_DATASET_PATH, phase='validate', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+hand_test_dataset = Hand(prefix=HAND_DATASET_PATH, phase='test', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+    
+hand_train_val_dataset = torch.utils.data.ConcatDataset([hand_train_dataset, hand_val_dataset])
+print(f"HAND: {len(hand_train_dataset)} | {len(hand_val_dataset)} | {len(hand_test_dataset)}")
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                       TRAINING                                             ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+
+
+for i in datasets_list:
+    print(f"\n\n\n {datetime.now()} ---------------------- {i.upper()} -------------------------------------------")
+    print(f"SIZE: {SIZE} | BATCH: {BATCH_SIZE} | GRAD ACC: {GRAD_ACC} | SIGMA: {SIGMA} | LR: {LR} | CHANNELS: {NUM_CHANNELS}")
+
+    if i == "chest":
+        NUM_LANDMARKS = CHEST_NUM_LANDMARKS
+        dataset_name = i
+        training_dataset = chest_train_val_dataset
+        
+    elif i == "hand":
+        NUM_LANDMARKS = HAND_NUM_LANDMARKS
+        dataset_name = i
+        training_dataset = hand_train_val_dataset
+    
+    elif i == "cephalo":
+        NUM_LANDMARKS = CEPHALOMETRIC_NUM_LANDMARKS
+        dataset_name = i
+        training_dataset = cephalo_train_val_dataset
+    
+    res_file = open(log_file, 'a')
+    print(f"\n\n ----------------------------------------- {dataset_name.upper()} DATASET  ------------------------", file=res_file)
+    res_file.close()
+
+   
+    # -------------------------------------------- SEGMENTATION MODELS -------------
+    useHEATMAPS = True
+    pretrained = "imagenet"
+
+    for backbone in backbone_list:
+                
+        model = smpUnet(
+            encoder_name=backbone,
+            encoder_weights="imagenet",
+            in_channels=NUM_CHANNELS,
+            classes=NUM_LANDMARKS
+        ).to(device)
+        
+        model_name = model.__class__.__name__
+
+        loss_fn = nn.CrossEntropyLoss()
+        optimizer = torch.optim.AdamW(params=model.parameters(), lr=LR)
+        scheduler = ReduceLROnPlateau(optimizer, patience=PATIENCE, factor=0.5) 
+
+        res_file = open(log_file, 'a')
+        print(f"\n\n --------- Model: {model_name}_{backbone} | Dataset: {dataset_name} | Batch: {BATCH_SIZE} | Sigma: {SIGMA} | Size: {SIZE}", file=res_file)
+        res_file.close()
+
+        save_model_path = generate_save_model_path(EXPERIMENT_PATH, model_name, dataset_name, SIGMA, SIZE, pretrained, backbone)
+
+        k_fold_train_and_validate(model, device, training_dataset, optimizer, scheduler, loss_fn, NUM_EPOCHS, EARLY_STOPPING, BATCH_SIZE, GRAD_ACC, 
+                                NUM_LANDMARKS, SIGMA, save_model_path, log_file, K_FOLDS, onlyInference=ONLY_INFERENCE)
+
+        free_gpu_cache()
+        del model, loss_fn, optimizer, scheduler

DiffusionXray-FewShot-LandmarkDetection/downstream_task/landmarks_datasets.py

@@ -0,0 +1,393 @@
+import numpy as np
+import pandas as pd
+from PIL import Image
+import os
+
+import torch
+import utilities
+from skimage.transform import resize
+
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+import cv2
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                          CHEST DATASET                                           ##
+## -----------------------------------------------------------------------------------------------------------------##
+"""
+LINK: https://www.kaggle.com/datasets/nikhilpandey360/chest-xray-masks-and-labels
+
+X-ray images in this data set have been acquired from the tuberculosis control program of the Department of Health and Human Services of Montgomery County, MD, USA. 
+This set contains 138 posterior-anterior x-rays, of which 80 x-rays are normal and 58 x-rays are abnormal with manifestations of tuberculosis. 
+All images are de-identified and available in DICOM format. The set covers a wide range of abnormalities, including effusions and miliary patterns.
+"""
+class Chest(torch.utils.data.Dataset):
+
+    def __init__(self, prefix, phase, size=(512, 512), num_channels=1, fuse_heatmap=False, sigma=8):
+        self.phase = phase
+        self.new_size = size
+        self.dataset_name = 'Chest'
+
+        self.transforms = self.get_transforms()
+        self.num_channels = num_channels
+        self.fuse_heatmap = fuse_heatmap
+        self.sigma = sigma
+        self.num_landmarks = 6
+        self.pth_Image = os.path.join(prefix, 'pngs')
+        self.pth_Label = os.path.join(prefix, 'labels')
+
+        # file index
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))]
+
+        exclude_list = ['CHNCXR_0059_0', 'CHNCXR_0178_0', 'CHNCXR_0228_0', 'CHNCXR_0267_0', 'CHNCXR_0295_0', 'CHNCXR_0310_0', 'CHNCXR_0285_0', 'CHNCXR_0276_0', 'CHNCXR_0303_0']
+        if exclude_list is not None:
+            st = set(exclude_list)
+            files = [f for f in files if f not in st]
+
+        n = len(files)
+        train_num = 195  
+        val_num = 34 
+        test_num = n - train_num - val_num
+        if self.phase == 'train':
+            self.indexes = files[:train_num]
+        elif self.phase == 'validate':
+            self.indexes = files[train_num:-test_num]
+        elif self.phase == 'test':
+            self.indexes = files[-test_num:]
+        elif self.phase == 'all':
+            self.indexes = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+
+    def __getitem__(self, index):
+        name = self.indexes[index]
+        ret = {'name': name}
+
+        img, img_size= self.readImage(os.path.join(self.pth_Image, name + '.png'))
+        points = self.readLandmark(name)        
+        heatmaps = utilities.points_to_heatmap(points, sigma=self.sigma, img_size=self.new_size, fuse=self.fuse_heatmap)
+
+        transformed = self.transforms(image=img, masks=heatmaps)
+        
+        # img shape: CxHxW | heatmaps is a list of CxHxW: example: [CxHxW, CxHxW, CxHxW, CxHxW, CxHxW, CxHxW]
+        img, heatmaps = transformed['image'], transformed['masks']
+        
+        # Image is a torch tensor [C, H, W]
+        ret['image'] = img
+        ret['landmarks'] = torch.FloatTensor(points)
+        # Convert heatmaps to torch tensor [C, H, W]. Stack to give new dimension and float32 type to avoid error in loss function
+        ret['heatmaps'] = torch.stack([hm.float() for hm in heatmaps])
+        ret['original_size'] = torch.FloatTensor(img_size)
+        ret['resized_size'] = torch.FloatTensor(self.new_size)
+
+        return ret
+
+    def __len__(self):
+        return len(self.indexes)
+
+    def readLandmark(self, name):
+        path = os.path.join(self.pth_Label, name + '.txt')
+        points = []
+        with open(path, 'r') as f:
+            n = int(f.readline())
+            for i in range(n):
+                ratios = [float(i) for i in f.readline().split()]
+                points.append(ratios)
+        return np.array(points)
+    
+    def readImage(self, path):
+
+        if self.num_channels == 3:
+            img = Image.open(path).convert('RGB')
+            arr = np.array(img).astype(np.float32)
+ 
+        elif self.num_channels == 1:
+            img = Image.open(path).convert('L')
+            arr = np.array(img).astype(np.float32)
+            arr = np.expand_dims(arr, 2)
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+
+        # Original size in (width, height)
+        origin_size = img.size
+        resized_image = resize(arr, (self.new_size[0], self.new_size[1], self.num_channels))
+
+        return resized_image, origin_size
+
+    def get_transforms(self):
+        if self.phase == 'train':
+            return A.Compose([
+            A.ShiftScaleRotate(shift_limit=0.02, scale_limit=0, rotate_limit=2, border_mode=cv2.BORDER_REPLICATE, p=0.5),
+            #A.Perspective(scale=(0, 0.02), pad_mode=cv2.BORDER_REPLICATE, p=0.5),
+            #A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.2, 0.2), p=0.5),
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.ToTensorV2()
+        ])
+        elif self.phase == 'validate':
+            return A.Compose([
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.ToTensorV2()
+            ])
+        elif self.phase == 'test':
+            return A.Compose([
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.transforms.ToTensorV2()
+            ])
+        else:
+            raise ValueError('phase must be either "train" or "validate" or "test"')
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                          HAND DATASET                                            ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+"""
+LINK: https://ipilab.usc.edu/research/baaweb/
+ASI: Asian; BLK: African American; CAU: Caucasian; HIS: Hispanic.
+"""
+
+class Hand(torch.utils.data.Dataset):
+
+    def __init__(self, prefix, phase, size=(512, 368), num_channels=1, fuse_heatmap=False, sigma=5):
+
+        self.phase = phase
+        self.new_size = size
+        self.dataset_name = 'Hand'
+        
+        self.transforms = self.get_transforms()
+        self.num_channels = num_channels
+        self.fuse_heatmap = fuse_heatmap
+        self.sigma = sigma
+        self.num_landmarks = 37
+
+        self.pth_Image = os.path.join(prefix, 'jpg')
+        self.labels = pd.read_csv(os.path.join(
+            prefix, 'labels/all.csv'), header=None, index_col=0)
+
+        # file index
+        index_set = set(self.labels.index) # Set of all the labels
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))] # -4 to cut ".jpg" # List of all the images
+        files = [i for i in files if int(i) in index_set] # List of filters that has a label
+
+        n = len(files)
+        train_num = 550
+        val_num = 59
+        test_num = n - train_num - val_num
+
+        if phase == 'train':
+            self.indexes = files[:train_num]
+        elif phase == 'validate':
+            self.indexes = files[train_num:-test_num]
+        elif phase == 'test':
+            self.indexes = files[-test_num:]
+        elif phase == 'all':
+            self.indexes = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+
+    def __getitem__(self, index):
+        name = self.indexes[index]
+        ret = {'name': name}
+
+        img, img_size = self.readImage(
+            os.path.join(self.pth_Image, name + '.jpg'))
+
+        points = self.readLandmark(name, img_size)
+        heatmaps = utilities.points_to_heatmap(points, sigma=self.sigma, img_size=self.new_size, fuse=self.fuse_heatmap)
+
+        transformed = self.transforms(image=img, masks=heatmaps)
+        img, heatmaps = transformed['image'], transformed['masks']
+        
+        ret['image'] = img
+        ret['landmarks'] = torch.FloatTensor(points)
+        ret['heatmaps'] = torch.stack([hm.float() for hm in heatmaps])
+        ret['original_size'] = torch.FloatTensor(img_size)
+        ret['resized_size'] = torch.FloatTensor(self.new_size)
+
+        return ret
+    
+
+    def __len__(self):
+        return len(self.indexes)
+
+    def readLandmark(self, name, origin_size):
+        li = list(self.labels.loc[int(name), :])   
+        points = []
+        for i in range(0, len(li), 2):
+            ratios = (li[i] / origin_size[0], li[i + 1] / origin_size[1])
+            points.append(ratios)
+        return np.array(points)
+
+    def readImage(self, path):
+        
+        if self.num_channels == 3:
+            img = Image.open(path).convert('RGB')
+            arr = np.array(img).astype(np.float32)
+ 
+        elif self.num_channels == 1:
+            img = Image.open(path).convert('L')
+            arr = np.array(img).astype(np.float32)
+            arr = np.expand_dims(arr, 2)
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+            
+        # Original size in (width, height)
+        origin_size = img.size
+        resized_image = resize(arr, (self.new_size[0], self.new_size[1], self.num_channels))
+
+        return resized_image, origin_size
+    
+    def get_transforms(self):
+        if self.phase == 'train':
+            return A.Compose([
+            A.ShiftScaleRotate(shift_limit=0.02, scale_limit=(-0.02, 0.02), rotate_limit=2, border_mode=cv2.BORDER_REPLICATE, p=0.5),
+            #A.Perspective(scale=(0, 0.02), pad_mode=cv2.BORDER_REPLICATE, p=0.5),
+            #A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.2, 0.2), p=0.5),
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.ToTensorV2()
+        ])
+        elif self.phase == 'validate':
+            return A.Compose([
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.ToTensorV2()
+            ])
+        elif self.phase == 'test':
+            return A.Compose([
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.transforms.ToTensorV2()
+            ])
+        else:
+            raise ValueError('phase must be either "train" or "validate" or "test"')
+
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                          CEPHALOMETRIC DATASET                                            ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+"""
+LINK: https://www.kaggle.com/datasets/c34a0ef0cd3cfd5c5afbdb30f8541e887171f19f196b1ad63790ca5b28c0ec93
+https://figshare.com/s/37ec464af8e81ae6ebbf?file=5466581
+"""
+
+
+class Cephalo(torch.utils.data.Dataset):
+
+    def __init__(self, prefix, phase, size=(512, 416), num_channels=1, fuse_heatmap=False, sigma=5):
+        self.phase = phase
+        self.new_size = size
+        self.dataset_name = 'Cephalo'
+        
+        self.transforms = self.get_transforms()
+        self.num_channels = num_channels
+        self.fuse_heatmap = fuse_heatmap
+        self.sigma = sigma
+        
+        self.num_landmarks = 19
+
+
+        self.pth_Image = os.path.join(prefix, 'jpg')
+        self.pth_label_junior = os.path.join(prefix, '400_junior')
+        self.pth_label_senior = os.path.join(prefix, '400_senior')
+
+        # file index
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))]
+        n = len(files)
+        
+        if phase == 'train':
+            self.indexes = files[:130]
+        elif phase == 'validate':
+            self.indexes = files[130:150]
+        elif phase == 'test':
+            self.indexes = files[150:400]
+        elif phase == 'all':
+            self.indexes = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+
+
+    def __getitem__(self, index):
+        name = self.indexes[index]
+        ret = {'name': name}
+
+        img, img_size = self.readImage(os.path.join(self.pth_Image, name+'.jpg'))
+        points = self.readLandmark(name, img_size)
+        heatmaps = utilities.points_to_heatmap(points, sigma=self.sigma, img_size=self.new_size, fuse=self.fuse_heatmap)
+
+        transformed = self.transforms(image=img, masks=heatmaps)        
+        img, heatmaps = transformed['image'], transformed['masks']
+        
+        ret['image'] = img
+        ret['landmarks'] = torch.FloatTensor(points)
+        ret['heatmaps'] = torch.stack([hm.float() for hm in heatmaps])
+        ret['original_size'] = torch.FloatTensor(img_size)
+        ret['resized_size'] = torch.FloatTensor(self.new_size)
+
+        return ret
+
+    def __len__(self):
+        return len(self.indexes)
+
+    def readLandmark(self, name, origin_size):
+        points = []
+        with open(os.path.join(self.pth_label_junior, name + '.txt')) as f1:
+            with open(os.path.join(self.pth_label_senior, name + '.txt')) as f2:
+                for i in range(self.num_landmarks):
+                    landmark1 = f1.readline().rstrip('\n').split(',')
+                    landmark2 = f2.readline().rstrip('\n').split(',')
+                    # Average of junior and senior landmarks
+                    landmark = [(float(i) + float(j)) / 2 for i, j in zip(landmark1, landmark2)]
+                    #landmark = [float(i) for i in landmark1] 
+                    ratios = (landmark[0] / origin_size[0], landmark[1] / origin_size[1])
+                    points.append(ratios)
+        return np.array(points)
+
+    def readImage(self, path):
+
+        if self.num_channels == 3:
+            img = Image.open(path).convert('RGB')
+            arr = np.array(img).astype(np.float32)
+ 
+        elif self.num_channels == 1:
+            img = Image.open(path).convert('L')
+            arr = np.array(img).astype(np.float32)
+            arr = np.expand_dims(arr, 2)
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+
+        # Original size in (width, height)
+        origin_size = img.size
+        resized_image = resize(arr, (self.new_size[0], self.new_size[1], self.num_channels))
+        
+        return resized_image, origin_size
+    
+    def get_transforms(self):
+        if self.phase == 'train':
+            return A.Compose([
+            A.ShiftScaleRotate(shift_limit=0.02, scale_limit=(-0.02, 0.02), rotate_limit=2, border_mode=cv2.BORDER_REPLICATE, p=0.5),
+            #A.Perspective(scale=(0, 0.02), pad_mode=cv2.BORDER_REPLICATE, p=0.5),
+            #A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.2, 0.2), p=0.5),
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.ToTensorV2()
+        ])
+        elif self.phase == 'validate':
+            return A.Compose([
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.ToTensorV2()
+            ])
+        elif self.phase == 'test':
+            return A.Compose([
+            #A.Resize(self.new_size[0], self.new_size[1]),
+            A.Normalize(normalization='min_max'),
+            A.pytorch.transforms.ToTensorV2()
+            ])
+        else:
+            raise ValueError('phase must be either "train" or "validate" or "test"')
+
+

DiffusionXray-FewShot-LandmarkDetection/downstream_task/main.py

@@ -0,0 +1,379 @@
+
+
+# ------------------------------------------------------------------------
+#                               Libraries
+# ------------------------------------------------------------------------
+
+# General libraries
+import os
+import sys
+import random
+from datetime import datetime
+import time
+import argparse
+import json
+
+# Deep learning libraries
+import torch
+from torch import nn 
+from torch.utils.data import DataLoader
+from torch.optim.lr_scheduler import ReduceLROnPlateau
+
+# Custom libraries
+from utilities import *
+from landmarks_datasets import * 
+from model.deep_learning import *
+from model.models import *
+
+# Set random seed
+random.seed(42)
+np.random.seed(42)
+torch.manual_seed(42) 
+torch.cuda.manual_seed(42)
+
+
+# ------------------------------------------------------------------------
+#                               MAIN
+# ------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    # Parse arguments from command line
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=str,
+        default="downstream_task/config/config.json",
+        help="Path to the JSON config file."
+    )
+    parser.add_argument(
+        "-p",
+        "--load_path",
+        type=str,
+        default=None,
+        help="Path to the model to be loaded."
+    )
+
+    args = parser.parse_args()
+    config = json.load(open(args.config))
+
+    # Print system info
+    print("----------------------------------------- SYSTEM INFO -----------------------------------------") 
+    print("Python version: {}".format(sys.version))
+    print("Pytorch version: {}".format(torch.__version__))
+    
+    if "CUDA_VISIBLE_DEVICES" in os.environ:
+        GPU = os.environ["CUDA_VISIBLE_DEVICES"]
+    else:
+        GPU = config["gpu"]
+        os.environ["CUDA_VISIBLE_DEVICES"] = f"{GPU}"
+
+    device = f"cuda" if torch.cuda.is_available() else "cpu"
+    print(f"Torch GPU Name: {torch.cuda.get_device_name(0)}... Using GPU {GPU}" if device == "cuda" else "Torch GPU not available... Using CPU")
+        
+    print("------------------------------------------------------------------------------------------------")
+     
+    # -------------------------------------------- PATHS -------------    
+    PREFIX = generate_path(config["experiment_path"])
+    log_file = f"{PREFIX}/experiments_results.txt"
+    DATASET_NAME = config["dataset"]["name"]
+    DATASET_PATH = os.path.join(config["dataset"]["path"], DATASET_NAME)
+    
+    # -------------------------------------------- PARAMETERS -------------
+    # Dataset parameters
+    SIZE = tuple(config["dataset"]["image_size"])
+    NUM_CHANNELS = config["dataset"]["image_channels"]
+    SIGMA = config["dataset"]["sigma"]
+    TRAINING_SAMPLES = config["dataset"]["training_samples"]
+    PIN_MEMORY = config["dataset"]["pin_memory"]
+    NUM_WORKERS = 2 if config["dataset"]["num_workers"] == None else config["dataset"]["num_workers"]
+    
+    # Model parameters
+    MODEL_NAME = config["model"]["name"]
+    SSL_MODELS = ["moco", "mocov2", "mocov3", "simclr", "simclrv2", "dino", "barlow_twins", "byol"]
+        
+    if MODEL_NAME == "imagenet":
+        MODEL_NAME = "smpUnet"
+    elif MODEL_NAME == "ddpm":
+        pass
+    elif MODEL_NAME in SSL_MODELS:
+        NUM_CHANNELS = 3    
+    else:
+        raise Exception("Model not found... Choose between: ddpm, imagenet, moco, mocov2, mocov3, simclr, simclrv2, dino, barlow_twins, byol")
+    
+    BACKBONE_NAME = config["model"]["encoder"]
+    # Replace "efficientnet_b0" by "efficientnet-b0" and so on to match the model name
+    BACKBONE_NAME = BACKBONE_NAME.replace("_", "-") if "efficientnet" in BACKBONE_NAME else BACKBONE_NAME
+        
+    PRETRAINED = config["training_protocol"]["scratch"]["apply"] == False
+    NUM_EPOCHS = config["model"]["epochs"]
+    BATCH_SIZE = config["dataset"]["batch_size"]
+    GRAD_ACC = config["dataset"]["grad_accumulation"]
+    LR = config["model"]["lr"] if PRETRAINED else config["model"]["lr"] / 0.1
+    OPTIMIZER = config["model"]["optimizer"]
+    SCHEDULER = config["model"]["scheduler"]
+    LOSS_FUNCTION = config["model"]["loss_function"]
+    PATIENCE = GRAD_ACC + 5
+    EARLY_STOPPING = PATIENCE * 2 + 1
+    print(f"Pretrained: {PRETRAINED} -> the actual learning rate is {LR}")
+    
+    # ---------------------------------------------------------------- DATASET ---------
+    if DATASET_NAME == "chest":
+        train_dataset = Chest(prefix=DATASET_PATH, phase='train', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+        val_dataset = Chest(prefix=DATASET_PATH, phase='validate', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+        test_dataset = Chest(prefix=DATASET_PATH, phase='test', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+    
+    elif DATASET_NAME == "hand":
+        train_dataset = Hand(prefix=DATASET_PATH, phase='train', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+        val_dataset = Hand(prefix=DATASET_PATH, phase='validate', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+        test_dataset = Hand(prefix=DATASET_PATH, phase='test', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+    elif DATASET_NAME == "cephalo":
+        train_dataset = Cephalo(prefix=DATASET_PATH, phase='train', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+        val_dataset = Cephalo(prefix=DATASET_PATH, phase='validate', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+        test_dataset = Cephalo(prefix=DATASET_PATH, phase='test', size=SIZE, num_channels=NUM_CHANNELS, sigma=SIGMA)
+    else:
+        raise Exception("Dataset not found")
+
+    NUM_LANDMARKS = train_dataset.num_landmarks
+    
+    # ---------------------------------------------------------------- DATA LOADING ---------
+    # Randomly exclude images to reduce the number of samples in the training dataset
+    #random_indices = np.random.choice(len(train_dataset), TRAINING_SAMPLES, replace=False)
+    #print(random_indices)
+    #train_dataset.indexes = [train_dataset.indexes[i] for i in sorted(random_indices)]
+    
+    if TRAINING_SAMPLES == "all":
+        pass
+    else:
+        assert len(train_dataset) >= int(TRAINING_SAMPLES), "The number of training samples is greater than the number of samples in the dataset"
+        
+        train_dataset.indexes = train_dataset.indexes[:int(TRAINING_SAMPLES)]
+
+    # create dataloaders
+    train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, pin_memory=PIN_MEMORY, num_workers=NUM_WORKERS, drop_last=False)
+    val_dataloader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False,  pin_memory=PIN_MEMORY, num_workers=NUM_WORKERS)
+    test_dataloader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, pin_memory=PIN_MEMORY, num_workers=NUM_WORKERS)
+
+    # ---------------------------------------------------------------- LOG FILE ---------
+    # Print dataset and experiment info in log file
+    res_file = open(log_file, 'a')
+    print(f"\n\n\n {datetime.now()} ---------------------- {DATASET_NAME} -------------------------------------------", file=res_file)
+    print(f"SIZE: {SIZE} | BATCH: {BATCH_SIZE} | GRAD ACC: {GRAD_ACC} | SIGMA: {SIGMA} | LR: {LR} | CHANNELS: {NUM_CHANNELS} | Train Samples {TRAINING_SAMPLES}", file=res_file)
+    print(f"samples -> Train: {len(train_dataset)} | Val: {len(val_dataset)} | Test: {len(test_dataset)}", file=res_file)
+    print(f"dataloaders -> Train: {len(train_dataloader)} | Val: {len(val_dataloader)} | Test: {len(test_dataloader)}", file=res_file)
+    res_file.close()
+
+    print(f"\n\n\n {datetime.now()} ---------------------- {DATASET_NAME} -------------------------------------------")
+    print(f"SIZE: {SIZE} | BATCH: {BATCH_SIZE} | GRAD ACC: {GRAD_ACC} | SIGMA: {SIGMA} | LR: {LR} | CHANNELS: {NUM_CHANNELS} | Train Samples {TRAINING_SAMPLES}")
+    print(f"samples -> Train: {len(train_dataset)} | Val: {len(val_dataset)} | Test: {len(test_dataset)}")
+    print(f"dataloaders -> Train: {len(train_dataloader)} | Val: {len(val_dataloader)} | Test: {len(test_dataloader)}")
+    # ---------------------------------------------------------------- MODEL ---------
+    
+    if MODEL_NAME == "smpUnet" and BACKBONE_NAME is not None:
+        if PRETRAINED == True and config["training_protocol"]["finetuning"]["resume"] == False:
+            model = smpUnet(
+                encoder_name=BACKBONE_NAME,
+                encoder_weights="imagenet",
+                in_channels=NUM_CHANNELS,
+                classes=NUM_LANDMARKS
+            ).to(device)
+            model_name = f"{MODEL_NAME}/{model.encoder_name}/{model.encoder_weights}"
+        else:
+            model = smpUnet(
+                encoder_name=BACKBONE_NAME,
+                encoder_weights=None,
+                in_channels=NUM_CHANNELS,
+                classes=NUM_LANDMARKS
+            ).to(device)
+            model_name = f"{MODEL_NAME}/{model.encoder_name}/random"
+            
+    elif MODEL_NAME in SSL_MODELS and BACKBONE_NAME is not None:
+        model = smpUnet(
+            encoder_name=BACKBONE_NAME,
+            encoder_weights=None,
+            in_channels=NUM_CHANNELS,
+            classes=NUM_LANDMARKS
+        ).to(device)
+        
+        assert os.path.exists(f'{config["training_protocol"]["finetuning"]["path"]}'), f"{BACKBONE_NAME} pretrained model path not found"
+        
+        model.encoder.load_state_dict(torch.load(f'{config["training_protocol"]["finetuning"]["path"]}', map_location=device))
+        model_name = f"{MODEL_NAME}/{model.encoder_name}"
+        
+        
+    elif MODEL_NAME == "ddpm":
+        BACKBONE_NAME = ""
+        model = Unet(
+            dim=SIZE[0],
+            channels=NUM_CHANNELS,
+            dim_mults=[1,2,4,8],
+            self_condition=True,
+            resnet_block_groups=4,
+            att_heads=4,
+            att_res=32
+        ).to(device)
+            
+        if PRETRAINED == True and config["training_protocol"]["finetuning"]["resume"] == False:
+            model_name = f"{MODEL_NAME}/pretrained"            
+            checkpoint = torch.load(config["training_protocol"]["finetuning"]["path"], map_location=device)
+            model.load_state_dict(checkpoint["model_state_dict"])
+            pretrained_epoch = checkpoint.get("epoch", "undefined")
+            #print(f"Loaded model weights from {checkpoint['epoch']} epoch with fid {checkpoint['fid']}")
+            del checkpoint
+            """
+            # freeze downsampling layers
+            for name, param in model.named_parameters():
+                if 'downs' in name:
+                    param.requires_grad = False
+            """
+        else:
+            model_name = f"{MODEL_NAME}/random"
+
+        # change the number of output channels of the final convolutional layer
+        model.final_conv = nn.Conv2d(model.final_conv.in_channels, NUM_LANDMARKS, 1)
+    
+    # ---------------------------------------------------------------- COUNT PARAMS ---------
+    table, total_params = count_parameters(model)
+    res_file = open(log_file, 'a')
+    #print(table, file=res_file)
+    print(f"Total Trainable Params: {total_params}", file=res_file)
+    res_file.close()
+
+    # ---------------------------------------------------------------- LOSS FUNCTION ---------
+    if LOSS_FUNCTION == "CrossEntropyLoss":
+        loss_fn = nn.CrossEntropyLoss()
+    else:
+        raise Exception("Loss function not found... Choose between: CrossEntropyLoss")
+
+    # ---------------------------------------------------------------- OPTIMIZER ---------  
+    if OPTIMIZER == "Adam":
+        optimizer = torch.optim.Adam(params=model.parameters(), lr=LR)
+    elif OPTIMIZER == "AdamW":
+        optimizer = torch.optim.AdamW(params=model.parameters(), lr=LR)
+    else:
+        raise Exception("Optimizer not found... Choose between: Adam, AdamW")
+        
+    # ---------------------------------------------------------------- SCHEDULER ---------
+    if SCHEDULER == "ReduceLROnPlateau":
+        scheduler = ReduceLROnPlateau(optimizer, patience=PATIENCE, factor=0.5, verbose=True)
+    else:
+        raise Exception("Scheduler not found... Choose between: ReduceLROnPlateau")
+
+
+    # ---------------------------------------------------------------- MODEL PATHS ---------
+    save_model_path = f"{PREFIX}/{DATASET_NAME}/size{SIZE[0]}x{SIZE[1]}_ch{NUM_CHANNELS}_samples{TRAINING_SAMPLES}/{model_name}"
+
+    use_validation_set_for_inference = True if config["inference_protocol"]["use_validation_set_for_inference"]=="true" else False
+    
+    if use_validation_set_for_inference==True and PRETRAINED == True and config["model"]["name"] == "ddpm" and config["training_protocol"]["finetuning"]["resume"] == False:
+        save_model_path = f"{save_model_path}/val/epoch{pretrained_epoch}"
+    
+    print(save_model_path)
+    save_model_path = generate_path(save_model_path)
+
+    load_model_path = os.path.join(save_model_path, f"best_checkpoint.pt")
+
+    # ---------------------------------------------------------------- TRAINING ---------
+    start_time = time.time()
+
+    if config["training_protocol"]["apply"] == True:
+
+        # Assert if the model is being trained from scratch or if it is being fine-tuned
+        assert config["training_protocol"]["scratch"]["apply"] != config["training_protocol"]["finetuning"]["apply"], "Choose only one training protocol (scratch or finetuning)"
+        print(f"Training model on the {'validation' if use_validation_set_for_inference==True else 'test'} dataset")
+        
+        # Get the training protocol
+        if config["training_protocol"]["scratch"]["apply"] == True:
+            loss_results = train_and_validate(model, device, train_dataloader, val_dataloader, optimizer, scheduler, loss_fn, NUM_EPOCHS, 
+                                                save_model_path, patience=EARLY_STOPPING, useGradAcc=GRAD_ACC, continue_training=config["training_protocol"]["scratch"]["resume"])
+        elif config["training_protocol"]["finetuning"]["apply"] == True:
+            
+            DIFFERENT_DATASET = True if config["training_protocol"]["finetuning"]["different_dataset"] == "true" else False
+            
+            if DIFFERENT_DATASET == True:
+                load_path = config["training_protocol"]["finetuning"]["path"]
+                assert os.path.exists(load_path), "Pretrained model path not found"
+                loss_results = fine_tune(model, device, train_dataloader, val_dataloader, optimizer, scheduler, loss_fn, NUM_EPOCHS, 
+                                                    load_path, save_model_path, patience=EARLY_STOPPING, useGradAcc=GRAD_ACC)
+            else: 
+                loss_results = train_and_validate(model, device, train_dataloader, val_dataloader, optimizer, scheduler, loss_fn, NUM_EPOCHS, 
+                                                    save_model_path, patience=EARLY_STOPPING, useGradAcc=GRAD_ACC, continue_training=config["training_protocol"]["finetuning"]["resume"])       
+        else:
+            raise Exception("Training protocol not found... Choose between: scratch, finetuning")
+
+    # ---------------------------------------------------------------- TESTING --------
+    end_time = time.time()
+
+    if args.load_path is not None:
+        load_model_path = args.load_path
+        
+    if config["inference_protocol"]["apply"] == True:
+        print(f"Testing model on the {'validation' if use_validation_set_for_inference==True else 'test'} dataset")
+        res_file = open(log_file, 'a')
+        print(f"Testing model on the {'validation' if use_validation_set_for_inference==True else 'test'} dataset", file=res_file)
+        res_file.close()
+        
+        if use_validation_set_for_inference == True:
+            test_loss, results, mre, sdr, mse, mAP_heatmaps, mAP_keypoints, iou, epoch  = evaluate(model, device, val_dataloader, loss_fn, load_model_path, 
+                                            NUM_LANDMARKS, sigma=SIGMA, res_file_path=log_file)
+        else:
+            test_loss, results, mre, sdr, mse, mAP_heatmaps, mAP_keypoints, iou, epoch = evaluate(model, device, test_dataloader, loss_fn, load_model_path, 
+                                            NUM_LANDMARKS, sigma=SIGMA, res_file_path=log_file)
+
+    # ---------------------------------------------------------------- TELEGRAM ---------
+    # Free GPU cache and RAM memory
+    #free_gpu_cache()
+    
+
+    sdr_str = '\n'.join(f'\tThresholds {k}: {v*100:.2f}' for k, v in sorted(sdr.items()))
+
+    message = (
+        f"<b>{DATASET_NAME}</b> | Train Samples: {TRAINING_SAMPLES} \n"
+        f"<b>Model:</b> {model_name} \n"
+        f"<b>Shape:</b>[{SIZE}, {SIZE}, {NUM_CHANNELS}] \n"
+        f"<b>Sigma:</b> {SIGMA} \n"
+        f"<b>Batch:</b> {BATCH_SIZE}x{GRAD_ACC} \n"
+        f"<b>Time:</b> {time.strftime('%H:%M:%S', time.gmtime(end_time - start_time))} \n" 
+        f"<b>MRE:</b> {mre:.2f} \n\n"
+        f"<b>SDR:</b> \n{sdr_str} \n"   
+    )
+    
+    send_telegram_message(message)
+    
+    # Save the results in a file
+    results_dir = f"outputs/{DATASET_NAME}_{MODEL_NAME}"
+    os.makedirs(f'{results_dir}', exist_ok=True)
+    
+    if not os.path.exists(f'{results_dir}/outputs_{DATASET_NAME}_{MODEL_NAME}_{BACKBONE_NAME}_{TRAINING_SAMPLES}.txt'):
+        with open(f'{results_dir}/outputs_{DATASET_NAME}_{MODEL_NAME}_{BACKBONE_NAME}_{TRAINING_SAMPLES}.txt', 'w') as f:
+            print(f"\n\n{DATASET_NAME} | {MODEL_NAME} | {BACKBONE_NAME} | {TRAINING_SAMPLES}", file=f)
+            print(f"Shape: [{SIZE}, {SIZE}, {NUM_CHANNELS}] | Sigma: {SIGMA} | Batch: {BATCH_SIZE}x{GRAD_ACC}", file=f)
+            print(f"Time: {time.strftime('%H:%M:%S', time.gmtime(end_time - start_time))}", file=f)
+            print(f"MRE: {mre:.2f}", file=f)
+            print(f"SDR: \n{sdr_str}", file=f)
+            print(f"MSE: {mse:.2f}", file=f)
+            print(f"IOU: {iou:.2f}", file=f)
+            print(f"mAP Heatmaps: {mAP_heatmaps:.2f}", file=f)
+            print(f"mAP Keypoints: {mAP_keypoints:.2f}", file=f)
+            print(f"Epoch: {epoch}", file=f)
+            print(f"Test Loss: {test_loss:.2f}", file=f)
+            print(f"Total Trainable Params: {total_params}", file=f)
+            print(f"Model Path: {save_model_path}", file=f)
+    else:
+        with open(f'{results_dir}/outputs_{DATASET_NAME}_{MODEL_NAME}_{BACKBONE_NAME}_{TRAINING_SAMPLES}.txt', 'a') as f:
+            print(f"\n\n{DATASET_NAME} | {MODEL_NAME} | {BACKBONE_NAME} | {TRAINING_SAMPLES}", file=f)
+            print(f"Shape: [{SIZE}, {SIZE}, {NUM_CHANNELS}] | Sigma: {SIGMA} | Batch: {BATCH_SIZE}x{GRAD_ACC}", file=f)
+            print(f"Time: {time.strftime('%H:%M:%S', time.gmtime(end_time - start_time))}", file=f)
+            print(f"MRE: {mre:.2f}", file=f)
+            print(f"SDR: \n{sdr_str}", file=f)
+            print(f"MSE: {mse:.2f}", file=f)
+            print(f"IOU: {iou:.2f}", file=f)
+            print(f"mAP Heatmaps: {mAP_heatmaps:.2f}", file=f)
+            print(f"mAP Keypoints: {mAP_keypoints:.2f}", file=f)
+            print(f"Epoch: {epoch}", file=f)
+            print(f"Test Loss: {test_loss:.2f}", file=f)
+            print(f"Total Trainable Params: {total_params}", file=f)
+            print(f"Model Path: {save_model_path}", file=f)
+        
+        
+    

DiffusionXray-FewShot-LandmarkDetection/downstream_task/metrics.py

@@ -0,0 +1,234 @@
+
+import numpy as np
+import scipy.spatial.distance as dist
+import utilities
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+from PIL import Image
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  Mean Squared Error                                             ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def compute_mse(gt_keypoints, pred_keypoints):
+    assert gt_keypoints.shape == pred_keypoints.shape, "The ground truth list has not the same shape of the predicted list"
+
+    # Compute squared differences
+    squared_diff = np.square(gt_keypoints - pred_keypoints)
+
+    # Compute mean
+    mse = np.mean(squared_diff)
+
+    return mse
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  mAp with OKS for heatmaps                                       ##
+## -----------------------------------------------------------------------------------------------------------------##
+def compute_oks_heatmaps(ground_truth, prediction, sigma):
+    distance = dist.cdist(ground_truth, prediction, 'euclidean')
+    scale = 1 
+    oks = np.exp(-1 * (distance ** 2) / (2 * (sigma**2) * (scale ** 2)))
+    return oks
+
+def compute_map_heatmaps(ground_truth_heatmaps, predicted_heatmaps, sigma=0.1, thresholds=np.arange(0.5, 1.0, 0.05)):
+    aps = []
+
+    assert ground_truth_heatmaps.shape == predicted_heatmaps.shape, "Heatmaps should have the same shape"
+
+    oks = compute_oks_heatmaps(ground_truth_heatmaps, predicted_heatmaps, sigma)
+    for threshold in thresholds:
+        tp = np.sum(oks >= threshold)
+        fp = np.sum(oks < threshold)
+        precision = tp / (tp + fp)
+        aps.append(precision)
+    map_value = np.mean(aps)
+
+    return map_value
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  mAp with OKS for keypoints                                       ##
+## -----------------------------------------------------------------------------------------------------------------##
+def compute_oks_keypoints(ground_truth, prediction, sigma):
+    # Calculate the distance between the ground truth and prediction points
+    distance = np.sqrt(np.sum((ground_truth - prediction)**2, axis=1))
+
+    # Calculate the scale, assuming the points are normalized
+    #scale = np.max(ground_truth) - np.min(ground_truth)
+    scale = 1
+    # Calculate the OKS value
+    oks = np.exp(-1 * (distance ** 2) / (2 * (sigma**2) * (scale ** 2)))
+    return oks
+
+
+def compute_map_keypoints(ground_truth_keypoints, predicted_keypoints, sigma=0.1, thresholds=np.arange(0.5, 1.0, 0.05)):
+    aps = []
+
+    # Calculate OKS value
+    oks = compute_oks_keypoints(ground_truth_keypoints, predicted_keypoints, sigma)
+    for threshold in thresholds:
+        # Calculate precision
+        tp = np.sum(oks >= threshold)
+        fp = np.sum(oks < threshold)
+        precision = tp / (tp + fp)
+        aps.append(precision)
+    # Calculate the mean average precision
+    map_value = np.mean(aps)
+    return map_value
+
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  Intersection Over Union                                       ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def compute_iou_heatmaps(heatmap1, heatmap2):
+
+    assert heatmap1.shape == heatmap2.shape, "Heatmaps should have the same shape"
+
+    overlap = np.logical_and(heatmap1, heatmap2)
+    union = np.logical_or(heatmap1, heatmap2)
+    overlap_area = np.sum(overlap)
+    union_area = np.sum(union)
+    IoU = overlap_area / union_area
+    return IoU
+
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                 Aux functions                                       ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+from collections.abc import Iterable
+
+def radial(pt1, pt2, factor=1):
+    if  not isinstance(factor,Iterable):
+        factor = [factor]*len(pt1)
+    return sum(((i-j)*s)**2 for i, j,s  in zip(pt1, pt2, factor))**0.5
+
+def cal_all_distance(points, gt_points, factor=1):
+    '''
+    points: [(x,y,z...)]
+    gt_points: [(x,y,z...)]
+    return : [d1,d2, ...]
+    '''
+    n1 = len(points)
+    n2 = len(gt_points)
+    if n1 == 0:
+        print("[Warning]: Empty input for calculating mean and std")
+        return 0, 0
+    if n1 != n2:
+        raise Exception("Error: lengthes dismatch, {}<>{}".format(n1, n2))
+    return [radial(p, q, factor) for p, q in zip(points, gt_points)]
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  Mean Radial Error (MRE)                                       ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+"""
+MRE (Mean Radial Error): 
+This measures the average euclidean distance between predicted landmarks and ground truth landmarks. 
+It is calculated by taking the mean of the list of distances (cal_all_distance).
+"""
+
+def compute_mre(distance_list):
+    return np.mean(distance_list)
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  Successful Detection Rate (SDR)                                       ##
+## -----------------------------------------------------------------------------------------------------------------##
+"""
+SDR (Successful Detection Rate): 
+This measures the percentage of predicted landmarks that are within a threshold distance of the ground truth. 
+It is calculated by get_sdr which counts the number of distances below each threshold and divides by the total number of landmarks.
+"""
+
+def compute_sdr(distance_list, threshold=[2, 2.5, 3, 4, 6, 9, 10]):
+    """
+    Compute Successful Detection Rate (SDR) in pixel for a given list of distances and thresholds.
+    The SDR is the proportion of predicted points that fall within a certain distance threshold from the ground truth points.
+    """
+    sdr = {}
+    n = len(distance_list)
+
+    for th in threshold:
+        sdr[th] = sum(d <= th for d in distance_list) / n
+    return sdr
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  COMPUTE BATCH METRICS                                       ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+
+def compute_batch_metrics(gt_batch_keypoints, gt_batch_heatmaps, pred_batch, image_size, num_landmarks, useHeatmaps, sigma):
+
+    batch_size = pred_batch.shape[0]
+    mse_list = []
+    map_list1 = []
+    map_list2 = []
+    iou_list = []
+    distance_list = []  
+
+    #sigma = sigma/10
+    sigma = 5
+        
+    # Loop through the batch
+    for i in range(batch_size):
+        single_gt_keypoints = gt_batch_keypoints[i, :, :].numpy()
+        single_gt_heatmaps = gt_batch_heatmaps[i, :, :].numpy()
+        single_prediction = pred_batch[i, :, :].numpy()
+        single_image_size = tuple(image_size[i].int().tolist())            
+
+        # So when i compare predicted extracted keypoints with original keypoints they all have the same system reference and same origin size
+        single_gt_keypoints = utilities.extract_landmarks(single_gt_heatmaps, num_landmarks)
+
+        # Fuse the original heatmaps
+        single_gt_heatmaps_fused = utilities.points_to_heatmap(single_gt_keypoints, img_size=single_image_size, sigma=sigma, fuse=True)
+        #single_gt_heatmaps_fused = utilities.fuse_heatmaps(single_gt_heatmaps)
+
+        if useHeatmaps:
+            # Extract landmarks from the model's output
+            single_pred_keypoints = utilities.extract_landmarks(single_prediction, num_landmarks)
+
+            # Upscaling the prediction to the original image size to compute metrics
+            single_pred_heatmaps = utilities.points_to_heatmap(single_pred_keypoints, img_size=single_image_size, sigma=sigma, fuse=True)
+        else:
+            single_pred_keypoints = single_prediction
+            single_pred_heatmaps = utilities.points_to_heatmap(single_pred_keypoints, img_size=single_image_size, sigma=sigma, fuse=True)
+
+        gt_scaled_points = np.array(utilities.scale_points(single_gt_keypoints, single_image_size))
+        pred_scaled_points = np.array(utilities.scale_points(single_pred_keypoints, single_image_size))
+
+        # Compute Distance list for MRE and SDR
+        if num_landmarks == 6:
+            physical_factor = 1 # chest
+        elif num_landmarks == 19:
+            physical_factor = np.array([2400/single_image_size[0], 1935/single_image_size[1]]) * 0.1 # head
+            #physical_factor = 0.46875 # ceph
+            #physical_factor = 0.9375
+        elif num_landmarks == 37:
+            physical_factor = 50/radial(gt_scaled_points[0], gt_scaled_points[4]) # hand
+        else:
+            raise Exception("Error: Unknown number of landmarks")
+
+        cur_distance_list = cal_all_distance(pred_scaled_points, gt_scaled_points, physical_factor)
+        distance_list += cur_distance_list
+
+        # Compute MSE
+        mse = compute_mse(gt_scaled_points, pred_scaled_points)
+        mse_list.append(mse)
+
+        # Compute mAP with keypoints
+        map2 = compute_map_keypoints(gt_scaled_points, pred_scaled_points)
+        map_list2.append(map2)
+
+        # Compute mAP with heatmaps
+        map1 = compute_map_heatmaps(single_gt_heatmaps_fused, single_pred_heatmaps)
+        map_list1.append(map1)
+
+        # Compute IoU
+        iou = compute_iou_heatmaps(single_gt_heatmaps_fused, single_pred_heatmaps)
+        iou_list.append(iou)
+        
+    return mse_list, map_list1, map_list2, iou_list, distance_list

DiffusionXray-FewShot-LandmarkDetection/downstream_task/model/deep_learning.py

@@ -0,0 +1,725 @@
+
+import os
+import numpy as np
+from timeit import default_timer as timer
+from tqdm.auto import tqdm 
+import torch
+import metrics
+from torch import nn
+import utilities
+import csv
+import matplotlib.pyplot as plt
+from sklearn.model_selection import KFold
+## -----------------------------------------------------------------------------------------------------------------##
+##                                               TRAINING with GRADIENT ACCUMULATION                                                      ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def train_step(model: torch.nn.Module,
+               device: torch.device,
+               dataloader: torch.utils.data.DataLoader,
+               loss_fn: torch.nn.Module,
+               optimizer: torch.optim.Optimizer,
+               useHeatmaps: bool = False,
+               gradient_accumulation_steps: int = 1):
+    # Put model in train mode
+    model = model.to(device)
+    model.train()
+
+    # Setup train loss value
+    train_loss = 0.0
+
+    # Loop through data loader data batches
+    for batch, data in enumerate(dataloader):
+
+        img_name = data['name']
+        images_tensor = data['image']
+        landmarks_tensor = data['landmarks']
+        heatmaps_tensor = data['heatmaps']
+
+        # Send data to target device
+        X = images_tensor.to(device)
+
+        if useHeatmaps:
+            y = heatmaps_tensor.to(device)
+        else:
+            y = landmarks_tensor.to(device)
+
+        #print(f"Batch {batch} - image tensor:  {X.shape} - GT tensor: {y.shape}")
+
+        # Forward pass
+        y_pred = model(X)
+
+        #print(f"y pred shape: {y_pred.shape} - y shape: {y.shape}")
+        
+        # Calculate  and accumulate loss
+        loss = loss_fn(y_pred, y)
+
+        # normalize loss to account for batch accumulation
+        loss = loss / gradient_accumulation_steps
+        train_loss += loss.item()
+
+        # Loss backward
+        loss.backward()
+        
+        # Check if it is time to update the weights
+        if ((batch + 1) % gradient_accumulation_steps == 0) or (batch + 1 == len(dataloader)):
+            # Optimizer step
+            optimizer.step()
+            # Reset gradients
+            optimizer.zero_grad()
+
+    # Adjust metrics to get average loss and accuracy per batch
+    train_loss /= len(dataloader)
+    
+    return train_loss
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                               VALIDATION PART                                                    ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def validate_step(model: torch.nn.Module,
+                  device: torch.device,
+                  dataloader: torch.utils.data.DataLoader,
+                  loss_fn: torch.nn.Module,
+                  useHeatmaps: bool = False):
+    # Put model in eval mode
+    model = model.to(device)
+    model.eval()
+
+    # Setup validation loss value
+    val_loss = 0.0
+
+    with torch.no_grad():
+        # Loop through DataLoader batches
+        for batch, data in enumerate(dataloader):
+            images_tensor = data['image']
+            landmarks_tensor = data['landmarks']
+            heatmaps_tensor = data['heatmaps']
+
+            # Send data to target device
+            X = images_tensor.to(device)
+
+            if useHeatmaps:
+                y = heatmaps_tensor.to(device)
+            else:
+                y = landmarks_tensor.to(device)
+
+            # Forward pass
+            val_pred_logits = model(X)
+
+            # Calculate and accumulate loss
+            loss = loss_fn(val_pred_logits, y)
+            val_loss += loss.item()
+
+    # Adjust metrics to get average loss per batch
+    val_loss = val_loss / len(dataloader)
+
+    return val_loss
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                               EARLY STOPPING                                                     ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+class EarlyStopping:
+    """Early stops the training if validation loss doesn't improve after a given patience."""
+    def __init__(self, patience=10, delta=0, save_path=not None, counter=0, best_val_loss=None):
+        self.patience = patience
+        self.counter = counter
+        self.best_val_loss = best_val_loss
+        self.early_stop = False
+        self.val_loss_min = np.Inf
+        self.delta = delta
+        self.path = save_path
+
+    def call(self, val_loss, model, optimizer, scheduler, loss_fn, results, epochs_without_improvement, epoch):
+
+        if self.best_val_loss is None:
+            self.best_val_loss = val_loss
+            save_model(self.path, model, optimizer, scheduler, loss_fn, results, epochs_without_improvement, self.best_val_loss, epoch, called_by_early_stopping=True)
+
+        elif val_loss >= self.best_val_loss + self.delta:
+            self.counter += 1
+            print(f'EarlyStopping counter: {self.counter} out of {self.patience}')
+            if self.counter >= self.patience:
+                self.early_stop = True
+        else:
+            self.best_val_loss = val_loss
+            save_model(self.path, model, optimizer, scheduler, loss_fn, results, epochs_without_improvement, self.best_val_loss, epoch, called_by_early_stopping=True)
+            self.counter = 0
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                           SAVE AND LOAD A MODEL                                            ##
+## -----------------------------------------------------------------------------------------------------------------##
+def save_model(save_path, model, optimizer, scheduler, loss_fn, results, epochs_without_improvement, best_val_loss, epoch, called_by_early_stopping=False):
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+
+    if called_by_early_stopping:
+        checkpoint_path = os.path.join(save_path, "best_checkpoint.pt")
+    else:
+        checkpoint_path = os.path.join(save_path, f"checkpoint_epoch{epoch}.pt")
+
+    torch.save({
+        'model_state_dict': model.state_dict(),
+        'optimizer_state_dict': optimizer.state_dict(),
+        'scheduler_state_dict': scheduler.state_dict(),
+        'loss_fn': loss_fn.state_dict(),
+        'results': results,
+        'epochs_without_improvement': epochs_without_improvement,
+        'best_val_loss': best_val_loss,
+        'epoch': epoch
+    }, checkpoint_path)
+    #print(f"Model saved to {checkpoint_path}")
+
+    
+def load_model(load_path, model, optimizer, scheduler, loss_fn, device):
+    checkpoint = torch.load(load_path, map_location=torch.device(device))
+
+    # Load the state_dict into the model only if it exists in the checkpoint
+    if 'model_state_dict' in checkpoint:
+        model.load_state_dict(checkpoint['model_state_dict'])
+    model = model.to(device)  # Move the model to the specified device
+
+    # Load the optimizer state_dict only if it exists in the checkpoint
+    if 'optimizer_state_dict' in checkpoint:
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+
+    # Load the scheduler state_dict only if it exists in the checkpoint
+    if 'scheduler_state_dict' in checkpoint:
+        scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
+
+    # Load the loss_fn state_dict only if it exists in the checkpoint
+    if 'loss_fn' in checkpoint:
+        loss_fn.load_state_dict(checkpoint['loss_fn'])
+
+    # Load other values only if they exist in the checkpoint
+    start_epoch = checkpoint.get('epoch', 0) + 1
+    results = checkpoint.get('results', None)
+    epochs_without_improvement = checkpoint.get('epochs_without_improvement', 0)
+    best_val_loss = checkpoint.get('best_val_loss', None)
+    print(f"Model loaded from {load_path} | Starting from epoch {start_epoch} | Best validation loss: {best_val_loss} | Epochs without improvement: {epochs_without_improvement}")
+    return model, optimizer, scheduler, loss_fn, start_epoch, results, epochs_without_improvement, best_val_loss
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                           TRAINING + VALIDATION PART                                             ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def train_and_validate(model: torch.nn.Module,
+                       device: torch.device,
+                       train_dataloader: torch.utils.data.DataLoader,
+                       val_dataloader: torch.utils.data.DataLoader,
+                       optimizer: torch.optim.Optimizer,
+                       scheduler: torch.optim.lr_scheduler,
+                       loss_fn: torch.nn.Module,
+                       epochs: int = 10,
+                       save_path: str = None,
+                       useHeatmaps: bool = True,
+                       patience: int = 10,
+                       save_all_epochs: bool = False,
+                       useGradAcc: int = 1,
+                       continue_training: bool = False):
+    
+    if continue_training:
+        model_path = os.path.join(save_path, "best_checkpoint.pt")
+        assert model_path is not None, "If you want to continue training, you must provide a path to load the model from."
+
+        # Load the model from the path
+        model, optimizer, scheduler, loss_fn, start_epoch, results, epochs_without_improvement, best_val_loss = load_model(model_path, model, optimizer, scheduler, loss_fn, device)
+    else:
+        # Create empty results dictionary and initialize epoch
+        results = {"train_loss": [], "val_loss": []}
+        start_epoch = 1
+        best_val_loss = float("inf")
+        epochs_without_improvement = 0
+
+    # Start the timer
+    start_time = timer()
+
+    # Create EarlyStopping instance
+    early_stopping = EarlyStopping(patience=patience, save_path=save_path, counter=epochs_without_improvement, best_val_loss=best_val_loss)
+
+    # Loop through training and validating steps for a number of epochs
+    for epoch in tqdm(range(start_epoch, epochs + 1)):
+
+        assert useGradAcc >= 1, "Gradient accumulation steps must be greater than 1"
+
+        train_loss = train_step(model, device, train_dataloader, loss_fn, optimizer, useHeatmaps, gradient_accumulation_steps=useGradAcc)
+
+        val_loss = validate_step(model, device, val_dataloader, loss_fn, useHeatmaps)
+
+        scheduler_type = scheduler.__class__.__name__
+        if scheduler_type == "ReduceLROnPlateau":
+            scheduler.step(val_loss)
+        else:
+            # Update the learning rate using the scheduler
+            scheduler.step()
+
+        # Print out what's happening
+        print(f"Epoch {epoch} | Train Loss: {train_loss:.7f} | Validation Loss: {val_loss:.7f}")
+
+        # Update results dictionary
+        results["train_loss"].append(train_loss)
+        results["val_loss"].append(val_loss)
+
+        # Save the trained model
+        if save_all_epochs is True:
+            save_model(save_path, model, optimizer, scheduler, loss_fn, results, epochs_without_improvement, best_val_loss, epoch)
+
+        # Check for early stopping
+        early_stopping.call(val_loss, model, optimizer, scheduler, loss_fn, results, epochs_without_improvement, epoch)
+        if early_stopping.early_stop:
+            print("Early stopping triggered.")
+            break
+        
+    # End the timer and print out how long it took
+    end_time = timer()
+    print(f"Total training time: {end_time - start_time:.3f} seconds")
+
+    # Return the filled results at the end of the epochs
+    return results
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  FINE-TUNING IN-DOMAIN                                           ##
+## -----------------------------------------------------------------------------------------------------------------##
+def fine_tune(model: torch.nn.Module,
+              device: torch.device,
+              train_dataloader: torch.utils.data.DataLoader,
+              val_dataloader: torch.utils.data.DataLoader,
+              optimizer: torch.optim.Optimizer,
+              scheduler: torch.optim.lr_scheduler,
+              loss_fn: torch.nn.Module,
+              epochs: int = 10,
+              load_path: str = None,
+              save_path: str = None,
+              useHeatmaps: bool = True,
+              patience: int = 10,
+              useGradAcc: int = 1):
+    
+    assert load_path is not None, "You must provide a path to load the model from."
+    
+    # Load the model from the path
+    model.load_state_dict(torch.load(load_path, map_location=torch.device(device)), strict=False) 
+    model = model.to(device)  # Move the model to the specified device
+    
+    # Create empty results dictionary and initialize epoch
+    results = {"train_loss": [], "val_loss": []}
+    start_epoch = 1
+    best_val_loss = float("inf")
+    epochs_without_improvement = 0
+    
+    # Start the timer
+    start_time = timer()
+
+    # Create EarlyStopping instance
+    early_stopping = EarlyStopping(patience=patience, save_path=save_path, counter=epochs_without_improvement, best_val_loss=best_val_loss)
+
+    # Loop through training and validating steps for a number of epochs
+    for epoch in tqdm(range(start_epoch, epochs + 1)):
+
+        assert useGradAcc >= 1, "Gradient accumulation steps must be greater than 1"
+
+        train_loss = train_step(model, device, train_dataloader, loss_fn, optimizer, useHeatmaps, gradient_accumulation_steps=useGradAcc)
+
+        val_loss = validate_step(model, device, val_dataloader, loss_fn, useHeatmaps)
+
+        scheduler_type = scheduler.__class__.__name__
+        if scheduler_type == "ReduceLROnPlateau":
+            scheduler.step(val_loss)
+        else:
+            # Update the learning rate using the scheduler
+            scheduler.step()
+
+        # Print out what's happening
+        print(f"Epoch {epoch} | Train Loss: {train_loss:.7f} | Validation Loss: {val_loss:.7f}")
+
+        # Update results dictionary
+        results["train_loss"].append(train_loss)
+        results["val_loss"].append(val_loss)
+
+        # Check for early stopping
+        early_stopping.call(val_loss, model, optimizer, scheduler, loss_fn, results, epochs_without_improvement, epoch)
+        if early_stopping.early_stop:
+            print("Early stopping triggered.")
+            break
+        
+    # End the timer and print out how long it took
+    end_time = timer()
+    print(f"Total training time: {end_time - start_time:.3f} seconds")
+
+    # Return the filled results at the end of the epochs
+    return results   
+                 
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  EVALUATION PART                                                 ##
+## -----------------------------------------------------------------------------------------------------------------##
+def test_step(model: torch.nn.Module,
+              device: torch.device,
+              dataloader: torch.utils.data.DataLoader,
+              loss_fn: torch.nn.Module,
+              num_landmarks: int,
+              useHeatmaps: bool = False,
+              sigma: int = 1.5,
+              load_path: str = None):
+    
+    # Take the baseline of the path
+    if load_path is not None:
+        model_dir = os.path.dirname(load_path)
+        
+    # Put model in eval mode
+    model = model.to(device)
+    model.eval()
+    model_name = model.__class__.__name__
+    model_encoder = model.encoder.__class__.__name__ if hasattr(model, 'encoder') else ""
+
+    # Setup test loss and test accuracy values
+    test_loss = 0.0
+    results = {}
+    distances = [] 
+
+    with torch.no_grad():
+        # Loop through DataLoader batches
+        for batch, data in enumerate(dataloader):
+            images_name = data['name']
+            images_tensor = data['image']
+            #image_size = images_tensor.numpy().shape[2:]
+            landmarks_tensor = data['landmarks']
+            heatmaps_tensor = data['heatmaps']
+            original_size = data['original_size']
+            resized_size = data['resized_size']
+
+            # Send data to target device
+            X = images_tensor.to(device)
+
+            if useHeatmaps:
+                y = heatmaps_tensor.to(device)
+            else:
+                y = landmarks_tensor.to(device)
+
+            # Forward pass
+            y_pred = model(X)
+
+            # Calculate and accumulate loss
+            loss = loss_fn(y_pred, y)
+            test_loss += loss.item()
+
+            # Move the prediction and the GT to the CPU
+            y_pred = y_pred.cpu()
+
+            # Save the prediction heatmaps as images in the model directory 
+            #os.makedirs(f"{model_dir}/predictions", exist_ok=True)
+            #utilities.save_heatmaps(X, y_pred, images_name, f"{model_dir}/predictions")                
+
+            # Compute the MSE and mAP between the original landmarks and the predicted landmarks
+            mse_list, mAP_list_heatmaps, mAP_list_keypoints, iou_list, distance_list = metrics.compute_batch_metrics(landmarks_tensor, heatmaps_tensor, y_pred, resized_size, num_landmarks, useHeatmaps, sigma)
+            # Append to full list in order to compute the MRE and SDR for all the images
+            distances.extend(distance_list)
+            
+            # Store image names as keys and their corresponding predictions as values.
+            for i, name in enumerate(images_name):  # Since they are in batch I loop them
+                # Storing prediction and metrics values
+                results[name] = { 
+                    'prediction': y_pred[i],
+                    'mse': mse_list[i],
+                    'map1': mAP_list_heatmaps[i],
+                    'map2': mAP_list_keypoints[i],
+                    'iou': iou_list[i]
+                }
+
+            del batch, data, images_name, images_tensor, landmarks_tensor, heatmaps_tensor, original_size, resized_size, X, y, y_pred, loss, mse_list, mAP_list_heatmaps, mAP_list_keypoints, iou_list, distance_list   # Free memory
+                                       
+
+    # Adjust metrics to get average loss and accuracy per batch
+    test_loss = test_loss / len(dataloader)
+
+    # Compute metrics on full list
+    #print("Dist shape:", len(distances))
+    #print("Mean distance:", np.mean(distances))
+    #print("Std distance:", np.std(distances))
+    #print("Distances under 3px:", len([i for i in distances if i < 3]))
+    #print("Distances above 15px:", len([i for i in distances if i > 15]))
+    
+    mre = metrics.compute_mre(distances)
+    sdr = metrics.compute_sdr(distances)
+
+    return test_loss, results, mre, sdr
+
+
+def evaluate(model: torch.nn.Module,
+          device: torch.device,
+          test_dataloader: torch.utils.data.DataLoader,
+          loss_fn: torch.nn.Module,
+          load_path: str,
+          num_landmarks: int = 6,
+          useHeatmaps: bool = True,
+          sigma: int = 1.5,
+          currentKfold: int = 1,
+          res_file_path: str = "results/readable_res.csv"):
+    
+    checkpoint = torch.load(load_path, map_location=torch.device(device))
+    #model.load_state_dict(checkpoint['model'])
+
+    model.load_state_dict(checkpoint['model_state_dict'])
+    print(f"\nModel loaded from {load_path}")
+    epoch = checkpoint.get('epoch', "Undefined")
+
+    # Get the loss and the predictions dictionary
+    test_loss, results, mre, sdr = test_step(model, device, test_dataloader, loss_fn, num_landmarks, useHeatmaps, sigma, load_path)
+
+    total_mse_list = []
+    total_mAP_heatmaps_list = []
+    total_mAP_keypoints_list = []
+    total_iou_list = []
+
+    # Create a list with all metrics of all images
+    for value in results.values():
+        total_mse_list.append(value['mse'])
+        total_mAP_heatmaps_list.append(value['map1'])
+        total_mAP_keypoints_list.append(value['map2'])
+        total_iou_list.append(value['iou'])
+
+    # Compute the mean between all samples
+    total_mse_mean = np.mean(total_mse_list)
+    total_mAP_heatmaps_mean = np.mean(total_mAP_heatmaps_list)
+    total_mAP_keypoints_mean = np.mean(total_mAP_keypoints_list)
+    total_iou_mean = np.mean(total_iou_list)
+
+    # Compute the standard deviation between all samples
+    total_mse_std = np.std(total_mse_list)
+    total_mAP_heatmaps_std = np.std(total_mAP_heatmaps_list)
+    total_mAP_keypoints_std = np.std(total_mAP_keypoints_list)
+    total_iou_std = np.std(total_iou_list)
+
+    # Create a string representation of the sdr dictionary
+    sdr_str = '\n'.join(f'\tThresholds {k}: {v*100:.2f}' for k, v in sorted(sdr.items()))
+
+    # Print and Save results
+    res_file = open(res_file_path, 'a')
+    print(f"\n{load_path}", file=res_file)
+    print(f"Fold {currentKfold} - Epoch: {epoch} | MSE: {total_mse_mean:.2f} ± {total_mse_std:.2f} | mAP heat: {total_mAP_heatmaps_mean:.2f} ± {total_mAP_heatmaps_std:.2f} | mAP key: {total_mAP_keypoints_mean:.2f} ± {total_mAP_keypoints_std:.2f} | IoU: {total_iou_mean:.2f} ± {total_iou_std:.2f} \nMRE: {mre:.2f} \nSDR: \n{sdr_str}", file=res_file)
+    res_file.close()
+
+    print(f"Fold {currentKfold} - Epoch: {epoch} | \nMSE: {total_mse_mean:.2f} ± {total_mse_std:.2f} | \nmAP heat: {total_mAP_heatmaps_mean:.2f} ± {total_mAP_heatmaps_std:.2f} | mAP key: {total_mAP_keypoints_mean:.2f} ± {total_mAP_keypoints_std:.2f} | \nIoU: {total_iou_mean:.2f} ± {total_iou_std:.2f} | \nMRE: {mre:.2f} | \nSDR: \n{sdr_str}")
+    del total_mse_list, total_mAP_heatmaps_list, total_mAP_keypoints_list, total_iou_list
+
+    return test_loss, results, mre, sdr, total_mse_mean, total_mAP_heatmaps_mean, total_mAP_keypoints_mean, total_iou_mean, epoch
+
+
+
+
+# ------------------------------------------------------------------------
+#                               Reinstantiate Model
+# ------------------------------------------------------------------------
+
+def reset_all_weights(model: nn.Module) -> None:
+    """
+    refs:
+        - https://discuss.pytorch.org/t/how-to-re-set-alll-parameters-in-a-network/20819/6
+        - https://stackoverflow.com/questions/63627997/reset-parameters-of-a-neural-network-in-pytorch
+        - https://pytorch.org/docs/stable/generated/torch.nn.Module.html
+    """
+
+    @torch.no_grad()
+    def weight_reset(m: nn.Module):
+        # - check if the current module has reset_parameters & if it's callabed called it on m
+        reset_parameters = getattr(m, "reset_parameters", None)
+        if callable(reset_parameters):
+            m.reset_parameters()
+
+    # Applies fn recursively to every submodule see: https://pytorch.org/docs/stable/generated/torch.nn.Module.html
+    model.apply(fn=weight_reset)
+     
+def reinstantiate_model(model, optimizer, scheduler):
+    model_type = model.__class__.__name__
+    scheduler_type = scheduler.__class__.__name__
+    optimizer_type = optimizer.__class__.__name__
+    #print(scheduler_params)
+    
+    reset_all_weights(model)
+
+    if optimizer_type == 'AdamW':
+        optimizer = torch.optim.AdamW(params=model.parameters(), lr=optimizer.param_groups[0]['lr'])
+    else:    
+        raise ValueError(f"Unsupported optimizer type: {optimizer_type}")
+
+    if scheduler_type == 'ReduceLROnPlateau':
+        scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=scheduler.factor, patience=scheduler.patience, verbose=True, mode=scheduler.mode)
+    else:
+        raise ValueError(f"Unsupported scheduler type: {scheduler_type}")
+    
+    return model, optimizer, scheduler
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                            K-FOLD                                             ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+        
+def k_fold_train_and_validate(model: torch.nn.Module,
+                                device: torch.device,
+                                train_dataset: torch.utils.data.Dataset,
+                                optimizer: torch.optim.Optimizer,
+                                scheduler: torch.optim.lr_scheduler,
+                                loss_fn: torch.nn.Module,
+                                epochs: int,
+                                early_stopping: int,
+                                batch_size: int,
+                                gradient_accumulation_steps: int,
+                                num_landmarks: int,
+                                sigma: int,
+                                save_model_path: str,
+                                log_file: str,
+                                k_folds: int = 5,
+                                onlyInference: bool = True
+                                ):
+    
+    if onlyInference:
+        k_train_losses = [0]
+        k_val_losses = [0]
+    else:
+        k_train_losses = []
+        k_val_losses = []
+
+    k_test_losses = []
+    k_mse = []
+    k_iou = []
+    k_map_heat = []
+    k_map_key = []
+    k_mre = []
+    k_sdr = {}
+
+    results_folds = []
+        
+    # Get the total number of samples
+    total_size = len(train_dataset)
+
+    # Divide by the number of folds to get the size of each fold
+    fold_size = total_size // k_folds
+
+    indices = list(range(total_size))
+  
+
+    for fold in range(k_folds):
+        
+        # Assign the fold as the val set
+        val_ids = indices[fold*fold_size:(fold+1)*fold_size]
+
+        # The remaining data will be used for training 
+        train_ids = indices[:fold*fold_size] + indices[(fold+1)*fold_size:]
+
+        # Create the subsets
+        train_subsampler = torch.utils.data.SubsetRandomSampler(train_ids)
+        val_subsampler = torch.utils.data.SubsetRandomSampler(val_ids)
+
+        # Create the data loaders
+        train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, sampler=train_subsampler, num_workers=4, pin_memory=True, drop_last=True)
+        val_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, sampler=val_subsampler, num_workers=4, pin_memory=True)
+
+        save_fold_path = f"{save_model_path}/fold_{fold}"
+        print(f"Training fold {fold}...")
+        print(f"Path: {save_fold_path}")
+        
+        if not onlyInference:
+            
+            model, optimizer, scheduler = reinstantiate_model(model, optimizer, scheduler)
+            
+            # Train on the current fold
+            fold_train_results = train_and_validate(model, device, train_loader, val_loader, optimizer, scheduler, loss_fn, epochs, 
+                                            save_fold_path, patience=early_stopping, useGradAcc=gradient_accumulation_steps, continue_training=False)
+            
+            last_train_loss = fold_train_results['train_loss'][-1]
+            last_val_loss = fold_train_results['val_loss'][-1]
+
+            k_train_losses.append(last_train_loss)
+            k_val_losses.append(last_val_loss)
+
+            print(f"FOLD {fold} | Train loss: {last_train_loss} | Val loss: {last_val_loss}")
+            del fold_train_results, last_train_loss, last_val_loss, train_loader, train_subsampler, val_subsampler, train_ids, val_ids
+
+
+        # ---------------------- Evaluate performances on val set (the training never has seen the images on the val set, it use only to minimize error) -------------------------------
+        load_fold_path = os.path.join(save_fold_path, f"best_checkpoint.pt")
+        # Get the loss and the predictions dictionary
+        test_loss, results, mre, sdr, mse, mAP_heatmaps, mAP_keypoints, iou, epoch = evaluate(model, device, val_loader, loss_fn, load_fold_path, 
+                                        num_landmarks, sigma, res_file_path=log_file)        
+
+        k_test_losses.append(test_loss)
+        
+        k_mre.append(mre)
+        
+        # Update the sdr dictionary
+        for threshold, value in sdr.items():
+            if threshold not in k_sdr:
+                k_sdr[threshold] = []
+            k_sdr[threshold].append(value)
+
+        # Create a list with all metrics of all images
+        for value in results.values():
+            k_mse.append(value['mse'])
+            k_map_heat.append(value['map1'])
+            k_map_key.append(value['map2'])
+            k_iou.append(value['iou'])    
+
+        del test_loss, results, mre, sdr, load_fold_path, val_loader, 
+        
+    # Compute the mean and SD for each threshold
+    sdr_mean_std = {threshold: (np.mean(values), np.std(values)) for threshold, values in k_sdr.items()}
+
+    # Compute the mean for the losses
+    k_train_loss_mean = np.mean(k_train_losses)
+    k_train_loss_std = np.std(k_train_losses)
+
+    k_val_loss_mean = np.mean(k_val_losses)
+    k_val_loss_std = np.std(k_val_losses)
+
+    k_test_loss_mean = np.mean(k_test_losses)
+    k_test_loss_std = np.std(k_test_losses)
+
+    # Compute the mean between all samples
+    k_mse_mean = np.mean(k_mse)
+    k_map_heat_mean = np.mean(k_map_heat)
+    k_map_key_mean = np.mean(k_map_key)
+    k_iou_mean = np.mean(k_iou)
+
+    # Compute the standard deviation between all samples
+    k_mse_std = np.std(k_mse)
+    k_map_heat_std = np.std(k_map_heat)
+    k_map_key_std = np.std(k_map_key)
+    k_iou_std = np.std(k_iou)
+
+    # Compute the mean MRE and mean SDR
+    k_mre_mean = np.mean(k_mre)
+    k_mre_std = np.std(k_mre)
+
+    res_file = open(log_file, 'a')
+    print(f"----------------------------------------------------------------- GLOBAL RES for {k_folds} Folds \n",
+        f"Train loss ---> Mean: {k_train_loss_mean} | Std: {k_train_loss_std} \n",
+        f"Val loss ---> Mean: {k_val_loss_mean} | Std: {k_val_loss_std} \n",
+        f"Test loss ---> Mean: {k_test_loss_mean} | Std: {k_test_loss_std} \n",
+        f"MSE ---> Mean: {k_mse_mean:.2f} | Std: {k_mse_std:.2f} \n",
+        f"mAp heat ---> Mean: {k_map_heat_mean:.2f} | Std: {k_map_heat_std:.2f} \n",
+        f"mAp key ---> Mean: {k_map_key_mean:.2f} | Std: {k_map_key_std:.2f} \n",
+        f"IOU ---> Mean: {k_iou_mean:.2f} | Std: {k_iou_std:.2f} \n",
+        f"MRE ---> Mean: {k_mre_mean:.2f} | Std: {k_mre_std:.2f} \n",
+        f"SDR:\n",
+        *(f"Threshold {threshold}: Mean: {mean*100:.2f} | Std: {std*100:.2f}\n" for threshold, (mean, std) in sdr_mean_std.items()),
+        file=res_file)
+    res_file.close()
+
+
+    print(f"----------------------------------------------------------------- GLOBAL RES for {k_folds} Folds \n",
+        f"Train loss ---> Mean: {k_train_loss_mean} | Std: {k_train_loss_std} \n",
+        f"Val loss ---> Mean: {k_val_loss_mean} | Std: {k_val_loss_std} \n",
+        f"Test loss ---> Mean: {k_test_loss_mean} | Std: {k_test_loss_std} \n",
+        f"MSE ---> Mean: {k_mse_mean:.2f} | Std: {k_mse_std:.2f} \n",
+        f"mAp heat ---> Mean: {k_map_heat_mean:.2f} | Std: {k_map_heat_std:.2f} \n",
+        f"mAp key ---> Mean: {k_map_key_mean:.2f} | Std: {k_map_key_std:.2f} \n",
+        f"IOU ---> Mean: {k_iou_mean:.2f} | Std: {k_iou_std:.2f} \n",
+        f"MRE ---> Mean: {k_mre_mean:.2f} | Std: {k_mre_std:.2f} \n",
+        f"SDR:\n",
+        *(f"Threshold {threshold}: Mean: {mean*100:.2f} | Std: {std*100:.2f}\n" for threshold, (mean, std) in sdr_mean_std.items()))
+    del k_train_losses, k_val_losses, k_test_losses, k_mse, k_iou, k_map_heat, k_map_key, k_mre, k_sdr, results_folds, train_dataset, total_size, fold_size, indices    

DiffusionXray-FewShot-LandmarkDetection/downstream_task/model/models.py

@@ -0,0 +1,463 @@
+
+
+# https://github.com/abarankab/DDPM/blob/main/ddpm/unet.py
+
+
+import math
+from inspect import isfunction
+from functools import partial
+
+# from tqdm.auto import tqdm
+from einops import rearrange, reduce
+from einops.layers.torch import Rearrange
+
+import torch
+from torch import nn, einsum
+import torch.nn.functional as F
+
+from torch.utils.checkpoint import checkpoint
+
+class EMA:
+    def __init__(self, beta):
+        super().__init__()
+        self.beta = beta
+        self.step = 0
+
+    def update_model_average(self, ma_model, current_model):
+        for current_params, ma_params in zip(current_model.parameters(), ma_model.parameters()):
+            old_weight, up_weight = ma_params.data, current_params.data
+            ma_params.data = self.update_average(old_weight, up_weight)
+
+    def update_average(self, old, new):
+        if old is None:
+            return new
+        return old * self.beta + (1 - self.beta) * new
+
+    def step_ema(self, ema_model, model, step_start_ema=2000):
+        if self.step < step_start_ema:
+            self.reset_parameters(ema_model, model)
+            self.step += 1
+            return
+        self.update_model_average(ema_model, model)
+        self.step += 1
+
+    def reset_parameters(self, ema_model, model):
+        ema_model.load_state_dict(model.state_dict())
+
+
+def exists(x):
+    return x is not None
+
+
+def default(val, d):
+    if exists(val):
+        return val
+    return d() if isfunction(d) else d
+
+
+def num_to_groups(num, divisor):
+    groups = num // divisor
+    remainder = num % divisor
+    arr = [divisor] * groups
+    if remainder > 0:
+        arr.append(remainder)
+    return arr
+
+
+class Residual(nn.Module):
+    def __init__(self, fn):
+        super().__init__()
+        self.fn = fn
+
+    def forward(self, x, *args, **kwargs):
+        return self.fn(x, *args, **kwargs) + x
+
+
+def Upsample(dim, dim_out=None):
+    return nn.Sequential(
+        nn.Upsample(scale_factor=2, mode="nearest"),
+        nn.Conv2d(dim, default(dim_out, dim), 3, padding=1),
+    )
+
+
+def Downsample(dim, dim_out=None):
+    # No More Strided Convolutions or Pooling
+    return nn.Sequential(
+        Rearrange("b c (h p1) (w p2) -> b (c p1 p2) h w", p1=2, p2=2),
+        nn.Conv2d(dim * 4, default(dim_out, dim), 1),
+    )
+
+
+class SinusoidalPositionEmbeddings(nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+
+    def forward(self, time):
+        device = time.device
+        half_dim = self.dim // 2
+        embeddings = math.log(10000) / (half_dim - 1)
+        embeddings = torch.exp(torch.arange(half_dim, device=device) * -embeddings)
+        embeddings = time[:, None] * embeddings[None, :]
+        embeddings = torch.cat((embeddings.sin(), embeddings.cos()), dim=-1)
+        return embeddings
+
+
+class WeightStandardizedConv2d(nn.Conv2d):
+    """
+    https://arxiv.org/abs/1903.10520
+    weight standardization purportedly works synergistically with group normalization
+    """
+
+    def forward(self, x):
+        eps = 1e-5 if x.dtype == torch.float32 else 1e-3
+
+        weight = self.weight
+        mean = reduce(weight, "o ... -> o 1 1 1", "mean")
+        var = reduce(weight, "o ... -> o 1 1 1", partial(torch.var, unbiased=False))
+        normalized_weight = (weight - mean) * (var + eps).rsqrt()
+
+        return F.conv2d(
+            x,
+            normalized_weight,
+            self.bias,
+            self.stride,
+            self.padding,
+            self.dilation,
+            self.groups,
+        )
+
+
+class Block(nn.Module):
+    def __init__(self, dim, dim_out, groups=8):
+        super().__init__()
+        self.proj = WeightStandardizedConv2d(dim, dim_out, 3, padding=1)
+        self.norm = nn.GroupNorm(groups, dim_out)
+        self.act = nn.SiLU()
+
+    def forward(self, x, scale_shift=None):
+        x = self.proj(x)
+        x = self.norm(x)
+
+        if exists(scale_shift):
+            scale, shift = scale_shift
+            x = x * (scale + 1) + shift
+
+        x = self.act(x)
+        return x
+
+
+class ResnetBlock(nn.Module):
+    """https://arxiv.org/abs/1512.03385"""
+
+    def __init__(self, dim, dim_out, *, time_emb_dim=None, groups=8):
+        super().__init__()
+        self.mlp = (
+            nn.Sequential(nn.SiLU(), nn.Linear(time_emb_dim, dim_out * 2))
+            if exists(time_emb_dim)
+            else None
+        )
+
+        self.block1 = Block(dim, dim_out, groups=groups)
+        self.block2 = Block(dim_out, dim_out, groups=groups)
+        self.res_conv = nn.Conv2d(dim, dim_out, 1) if dim != dim_out else nn.Identity()
+
+    def forward(self, x, time_emb=None):
+        scale_shift = None
+        if exists(self.mlp) and exists(time_emb):
+            time_emb = self.mlp(time_emb)
+            time_emb = rearrange(time_emb, "b c -> b c 1 1")
+            scale_shift = time_emb.chunk(2, dim=1)
+
+        h = self.block1(x, scale_shift=scale_shift)
+        h = self.block2(h)
+        return h + self.res_conv(x)
+
+
+class Attention(nn.Module):
+    def __init__(self, dim, heads=4, dim_head=32):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        hidden_dim = dim_head * heads
+        self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False)
+        self.to_out = nn.Conv2d(hidden_dim, dim, 1)
+
+    def forward(self, x):
+        b, c, h, w = x.shape
+        qkv = self.to_qkv(x).chunk(3, dim=1)
+        q, k, v = map(
+            lambda t: rearrange(t, "b (h c) x y -> b h c (x y)", h=self.heads), qkv
+        )
+        q = q * self.scale
+
+        sim = einsum("b h d i, b h d j -> b h i j", q, k)
+        sim = sim - sim.amax(dim=-1, keepdim=True).detach()
+        attn = sim.softmax(dim=-1)
+
+        out = einsum("b h i j, b h d j -> b h i d", attn, v)
+        out = rearrange(out, "b h (x y) d -> b (h d) x y", x=h, y=w)
+        return self.to_out(out)
+
+
+class LinearAttention(nn.Module):
+    def __init__(self, dim, heads=4, dim_head=32):
+        super().__init__()
+        self.scale = dim_head**-0.5
+        self.heads = heads
+        hidden_dim = dim_head * heads
+        self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias=False)
+
+        self.to_out = nn.Sequential(nn.Conv2d(hidden_dim, dim, 1), nn.GroupNorm(1, dim))
+
+    def forward(self, x):
+        b, c, h, w = x.shape
+        qkv = self.to_qkv(x).chunk(3, dim=1)
+        q, k, v = map(
+            lambda t: rearrange(t, "b (h c) x y -> b h c (x y)", h=self.heads), qkv
+        )
+
+        q = q.softmax(dim=-2)
+        k = k.softmax(dim=-1)
+
+        q = q * self.scale
+        context = torch.einsum("b h d n, b h e n -> b h d e", k, v)
+
+        out = torch.einsum("b h d e, b h d n -> b h e n", context, q)
+        out = rearrange(out, "b h c (x y) -> b (h c) x y", h=self.heads, x=h, y=w)
+        return self.to_out(out)
+
+
+class PreNorm(nn.Module):
+    def __init__(self, dim, fn):
+        super().__init__()
+        self.fn = fn
+        self.norm = nn.GroupNorm(1, dim)
+
+    def forward(self, x):
+        x = self.norm(x)
+        return self.fn(x)
+
+
+    
+# ------------------------------------------------------------------------
+#                               Unet Model with Time Embeddings
+# ------------------------------------------------------------------------
+
+class Unet(nn.Module):
+    def __init__(
+        self,
+        dim,
+        init_dim=None,
+        out_dim=None,
+        dim_mults=(1, 2, 4, 8),
+        channels=3,
+        self_condition=False,
+        resnet_block_groups=4,
+        att_res=32,
+        att_heads=4,
+    ):
+        super().__init__()
+
+        # determine dimensions
+        self.channels = channels
+        self.self_condition = self_condition
+        # input_channels = channels * (2 if self_condition else 1)
+        input_channels = channels if not self_condition else channels + 1
+
+        init_dim = default(init_dim, dim)
+        self.init_conv = nn.Conv2d(
+            input_channels, init_dim, 1, padding=0
+        )  # changed to 1 and 0 from 7,3
+
+        dims = [init_dim, *map(lambda m: dim * m, dim_mults)]
+        in_out = list(zip(dims[:-1], dims[1:]))
+
+        block_klass = partial(ResnetBlock, groups=resnet_block_groups)
+
+        # time embeddings
+        time_dim = dim * 4
+
+        self.time_mlp = nn.Sequential(
+            SinusoidalPositionEmbeddings(dim),
+            nn.Linear(dim, time_dim),
+            nn.GELU(),
+            nn.Linear(time_dim, time_dim),
+        )
+
+        # layers
+        self.downs = nn.ModuleList([])
+        self.ups = nn.ModuleList([])
+        num_resolutions = len(in_out)
+
+        for ind, (dim_in, dim_out) in enumerate(in_out):
+            is_last = ind >= (num_resolutions - 1)
+
+            self.downs.append(
+                nn.ModuleList(
+                    [
+                        block_klass(dim_in, dim_in, time_emb_dim=time_dim),
+                        block_klass(dim_in, dim_in, time_emb_dim=time_dim),
+                        Residual(
+                            PreNorm(dim_in, LinearAttention(dim_in, att_heads, att_res))
+                        ),
+                        Downsample(dim_in, dim_out)
+                        if not is_last
+                        else nn.Conv2d(dim_in, dim_out, 3, padding=1),
+                    ]
+                )
+            )
+
+        mid_dim = dims[-1]
+        self.mid_block1 = block_klass(mid_dim, mid_dim, time_emb_dim=time_dim)
+        self.mid_attn = Residual(
+            PreNorm(mid_dim, Attention(mid_dim, att_heads, att_res))
+        )
+        self.mid_block2 = block_klass(mid_dim, mid_dim, time_emb_dim=time_dim)
+
+        for ind, (dim_in, dim_out) in enumerate(reversed(in_out)):
+            is_last = ind == (len(in_out) - 1)
+
+            self.ups.append(
+                nn.ModuleList(
+                    [
+                        block_klass(dim_out + dim_in, dim_out, time_emb_dim=time_dim),
+                        block_klass(dim_out + dim_in, dim_out, time_emb_dim=time_dim),
+                        Residual(
+                            PreNorm(
+                                dim_out, LinearAttention(dim_out, att_heads, att_res)
+                            )
+                        ),
+                        Upsample(dim_out, dim_in)
+                        if not is_last
+                        else nn.Conv2d(dim_out, dim_in, 3, padding=1),
+                    ]
+                )
+            )
+
+        self.out_dim = default(out_dim, channels)
+
+        self.final_res_block = block_klass(dim * 2, dim, time_emb_dim=time_dim)
+        self.final_conv = nn.Conv2d(dim, self.out_dim, 1)
+
+
+    def forward(self, x, time=None, x_self_cond=None, checkpointing=True):
+        if self.self_condition:
+            x_self_cond = default(x_self_cond, lambda: torch.zeros_like(x))
+            x = torch.cat((x_self_cond, x), dim=1)
+
+        x = self.init_conv(x)
+        r = x.clone()
+
+        # Only compute time embedding if time is provided
+        if time is not None:  
+            t = self.time_mlp(time)
+        else:
+            t = None
+
+        h = []
+
+        # If checkpointing is enabled, run the model in a memory efficient way
+        if checkpointing:
+            for block1, block2, attn, downsample in self.downs:
+                x = checkpoint(block1, x, t, use_reentrant=False)
+                h.append(x)
+
+                x = checkpoint(block2, x, t, use_reentrant=False)
+                x = checkpoint(attn, x, use_reentrant=False)
+                h.append(x)
+
+                x = checkpoint(downsample, x, use_reentrant=False)
+
+            x = checkpoint(self.mid_block1, x, t, use_reentrant=False)
+            x = checkpoint(self.mid_attn, x, use_reentrant=False)
+            x = checkpoint(self.mid_block2, x, t, use_reentrant=False)
+
+            for block1, block2, attn, upsample in self.ups:
+                x = torch.cat((x, h.pop()), dim=1)
+                x = checkpoint(block1, x, t, use_reentrant=False)
+
+                x = torch.cat((x, h.pop()), dim=1)
+                x = checkpoint(block2, x, t, use_reentrant=False)
+                x = checkpoint(attn, x, use_reentrant=False)
+
+                x = checkpoint(upsample, x, use_reentrant=False)
+                
+        # If checkpointing is not enabled, run the model normally
+        else:
+            for block1, block2, attn, downsample in self.downs:
+                x = block1(x, t)
+                h.append(x)
+
+                x = block2(x, t)
+                x = attn(x)
+                h.append(x)
+
+                x = downsample(x)
+
+            x = self.mid_block1(x, t)
+            x = self.mid_attn(x)
+            x = self.mid_block2(x, t)
+
+            for block1, block2, attn, upsample in self.ups:
+                x = torch.cat((x, h.pop()), dim=1)
+                x = block1(x, t)
+
+                x = torch.cat((x, h.pop()), dim=1)
+                x = block2(x, t)
+                x = attn(x)
+
+                x = upsample(x)
+
+        x = torch.cat((x, r), dim=1)
+
+        x = self.final_res_block(x, t)
+        return self.final_conv(x)
+
+
+
+
+def cosine_beta_schedule(timesteps, s=0.008):
+    """
+    cosine schedule as proposed in https://arxiv.org/abs/2102.09672
+    """
+    steps = timesteps + 1
+    x = torch.linspace(0, timesteps, steps)
+    alphas_cumprod = torch.cos(((x / timesteps) + s) / (1 + s) * torch.pi * 0.5) ** 2
+    alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
+    betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
+    return torch.clip(betas, 0.0001, 0.9999)
+
+def linear_beta_schedule(timesteps, beta_start=0.0001, beta_end=0.02):
+    return torch.linspace(beta_start, beta_end, timesteps)
+
+
+def quadratic_beta_schedule(timesteps, beta_start=0.0001, beta_end=0.02):
+    return torch.linspace(beta_start**0.5, beta_end**0.5, timesteps) ** 2
+
+
+def sigmoid_beta_schedule(timesteps, beta_start=0.0001, beta_end=0.02):
+    betas = torch.linspace(-6, 6, timesteps)
+    return torch.sigmoid(betas) * (beta_end - beta_start) + beta_start
+
+
+
+
+
+
+# ------------------------------------------------------------------------
+#                               Unet Model pre-trained on ImageNet
+# ------------------------------------------------------------------------
+
+from segmentation_models_pytorch import Unet as smpUnet
+
+class smpUnet(smpUnet):
+    def __init__(self, encoder_name, encoder_weights, in_channels, classes):
+        super().__init__(encoder_name=encoder_name, encoder_weights=encoder_weights, in_channels=in_channels, classes=classes)
+        self.encoder_name = encoder_name
+        self.encoder_weights = encoder_weights
+        self.in_channels = in_channels
+        self.classes = classes
+        
+        
+        

DiffusionXray-FewShot-LandmarkDetection/downstream_task/utilities.py

@@ -0,0 +1,253 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+import os
+import requests
+import torch
+from GPUtil import showUtilization as gpu_usage
+from prettytable import PrettyTable
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                          CLEAN GPU MEMORY USAGE AND DATASETS                                     ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def free_gpu_cache():
+    print("Initial GPU Usage")
+    gpu_usage() 
+    torch.cuda.synchronize()
+    torch.cuda.empty_cache()
+    print("GPU Usage after emptying the cache")
+    gpu_usage()
+
+# Compute the number of trainable parameters in a model
+def count_parameters(model):
+    table = PrettyTable(["Modules", "Parameters"])
+    total_params = 0
+    for name, parameter in model.named_parameters():
+        if not parameter.requires_grad:
+            continue
+        params = parameter.numel()
+        table.add_row([name, params])
+        total_params += params
+    #print(table)
+    print(f"Total Trainable Params: {total_params}")
+    return table, total_params
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                            HEATMAPS GENERATION FROM LANDMARKS POINTS                                             ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def fuse_heatmaps(heatmaps):
+    fused_heatmap = np.sum(heatmaps, axis=0)
+
+    # Threshold the heatmap so that values below a certain threshold are set to 0
+    binary_fused_heatmap = np.where(fused_heatmap < 0.5, 0, 1)
+
+    assert is_binary_image(binary_fused_heatmap), "Image is not binary"
+
+    return binary_fused_heatmap
+
+def fuse_heatmaps(heatmaps):
+    # Use np.maximum.reduce to get the maximum value from each stack of pixels across the heatmaps
+    fused_heatmap = np.maximum.reduce(heatmaps)
+    return fused_heatmap
+
+def scale_points(points: list, img_size: tuple, orig_size: tuple = None, offset=0):    
+    # Scale coordinates according to image size
+    if orig_size:
+        # Points * Ratio -> Downscaling
+        scaled_points = [tuple([round(p*isize/osize)+offset for p, isize, osize in zip(point, img_size, orig_size)]) for point in points]
+    else:
+        # Points * current Size -> Upscaling (when i use "extract_landmarks" function the points are with size (1,1))
+        scaled_points = [tuple([round(r*sz)+offset for sz, r in zip(point, img_size)]) for point in points]
+
+    return scaled_points
+
+
+def points_to_heatmap(points: list, img_size: tuple, orig_size: tuple = None, sigma=2, fuse=False, offset=0):
+
+    # Scale coordinates according to image size
+    if orig_size:
+        scaled_points = scale_points(points, img_size, orig_size, offset=offset)
+    else:
+        scaled_points = scale_points(points, img_size, offset=offset)
+
+    # Generate heatmaps with the scaled points
+    heatmaps = [generate_heatmap_from_points(point, img_size, sigma) for point in scaled_points]
+
+    if fuse:
+        heatmaps = fuse_heatmaps(heatmaps)
+
+    return np.array(heatmaps)
+
+
+def generate_heatmap_from_points(point, img_size, sigma):
+    # Create a meshgrid of x,y coordinates for the image size
+    x, y = np.meshgrid(np.arange(img_size[0]), np.arange(img_size[1]))
+    # Calculate the heatmap using a Gaussian function centered at the input point
+    heatmap = np.exp(-((x - point[0]) ** 2 + (y - point[1]) ** 2) / (2 * sigma ** 2))
+    # Threshold the heatmap so that values below a certain threshold are set to 0
+    binary_heatmap = np.where(heatmap < 0.5*heatmap.max(), 0, 1)
+
+    assert is_binary_image(binary_heatmap), "Image is not binary"
+
+    return binary_heatmap
+
+def is_binary_image(image):
+    binary_check = np.logical_or(image == 0, image == 1)
+    return binary_check.all()
+## -----------------------------------------------------------------------------------------------------------------##
+##                                   LANDMARKS EXTRACTION FROM HEATMAPS                                             ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def extract_landmarks(heatmaps, num_landmarks):
+    landmarks = np.zeros((num_landmarks, 2), dtype=np.float64)
+    heatmap_height, heatmap_width = heatmaps.shape[1], heatmaps.shape[2]
+
+    # Loop all the heatmaps (one for each landmark)
+    for i in range(num_landmarks):
+        heatmap_channel = heatmaps[i]  # get the heatmap number i
+        
+        # binarize the heatmap channel using a threshold
+        binary_img = np.where(heatmap_channel < 0.5 * heatmap_channel.max(), 0, 1)
+        binary_img = binary_img.astype(np.uint8)  # convert the binary image to uint8 datatype
+
+        assert is_binary_image(binary_img), "Image is not binary"
+
+        contours, _ = cv2.findContours(binary_img, cv2.RETR_EXTERNAL,
+                                       cv2.CHAIN_APPROX_SIMPLE)  # find the contours in the binary image
+
+        if contours:
+            max_contour = max(contours, key=cv2.contourArea)  # find the contour with the maximum area
+            M = cv2.moments(max_contour)  # calculate the moments of the maximum contour
+
+            if M['m00'] != 0:  # avoid divide by zero error
+                centroid_x = M['m10'] / M['m00']  # calculate the x-coordinate of centroid
+                centroid_y = M['m01'] / M['m00']  # calculate the y-coordinate of centroid
+                landmarks[i, :] = [centroid_x / heatmap_height,
+                                   centroid_y / heatmap_width]  # normalize the coordinates
+
+    return landmarks
+
+
+## -----------------------------------------------------------------------------------------------------------------##
+##                                                  PLOT LOSS CURVES                                                ##
+## -----------------------------------------------------------------------------------------------------------------##
+
+def plot_loss_curves(results_path: str, save_dir: str = None):
+    # Load the results dictionary
+    results = torch.load(results_path)['results']
+    # Get the loss values of the results dictionary (training and validation)
+    train_loss = results['train_loss']
+    val_loss = results['val_loss']
+
+    # Figure out how many epochs there were
+    epochs = range(1, len(results['train_loss']) + 1)
+
+    # Plot loss
+    plt.figure(figsize=(10, 5))
+    plt.plot(epochs, train_loss, label='train_loss')
+    plt.plot(epochs, val_loss, label='val_loss')
+    plt.title('Loss')
+    plt.xlabel('Epochs')
+    plt.legend()
+
+    if save_dir is not None:
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir)
+        plt.savefig(os.path.join(save_dir, f"loss_epochs{epochs}"))
+
+    plt.show()
+
+# -----------------------------------------------------------------------------------------------------------------##
+# 
+# -----------------------------------------------------------------------------------------------------------------##
+
+# Function to generate the save model path for both custom model and segmentation model.
+def generate_save_model_path(PREFIX, model_name, dataset_name, sigma, size, pretrained=None, backbone=None):
+    if pretrained is not None:
+        pretrained_dir = pretrained
+    else:
+        pretrained_dir = "no_pretrain"
+
+    if backbone is not None:
+        backbone_dir = backbone
+    else:
+        backbone_dir = "no_backbone"
+
+    save_model_path = f'{PREFIX}/results/models/{model_name}/{pretrained_dir}/{backbone_dir}/{dataset_name}/sigma{sigma}_size{str(size).replace(", ", "x")}'
+    return save_model_path
+
+# Generate path if it does not exist
+def generate_path(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+    return path
+
+# Save the: original image with the heatmaps overlayed, single heatmaps and fused heatmap
+def save_heatmaps(batch_images, batch_heatmaps, images_name, save_dir):
+    for i, sample in enumerate(batch_heatmaps):
+        
+        original_image = batch_images[i].permute(1, 2, 0).cpu().numpy()
+        
+        plt.figure(figsize=(10, 10))
+        plt.imshow(original_image)
+        for j, heatmap in enumerate(sample):
+            plt.imshow(heatmap, cmap='viridis', alpha=0.25)
+            
+            # Save the single heatmaps
+            plt.imsave(f"{save_dir}/{images_name[i]}_heatmap_{j}.png", heatmap, cmap='viridis')
+
+        # Save the original image with the heatmaps overlayed
+        plt.savefig(f"{save_dir}/{images_name[i]}_overlayed_heatmaps.png")
+        plt.close()
+        
+        # Save the fused heatmap
+        fused_heatmap = fuse_heatmaps(sample)
+        plt.imsave(f"{save_dir}/{images_name[i]}_fused_heatmap.png", fused_heatmap, cmap='viridis')
+        
+
+
+# -----------------------------------------------------------------------------------------------------------------##
+
+# Load env variables from a .env file
+def load_env_variables(env_file):
+    with open(env_file, 'r') as f:
+        for line in f:
+            key, value = line.strip().split('=')
+            # trim whitespace
+            key = key.strip()
+            value = value.strip()
+            # remove quotes if present
+            if value[0] == value[-1] and value.startswith(("'", '"')):
+                value = value[1:-1]
+
+            os.environ[key] = value
+
+def send_telegram_message(text, env_file='~/.env'):
+    env_file_path = os.path.expanduser(env_file)
+
+    if os.path.exists(env_file_path):
+        load_env_variables(env_file_path)
+    else:
+        print(f"Error: {env_file_path} does not exist")
+        return
+    
+    token = os.getenv('TELEGRAM_TOKEN')
+    chat_id = os.getenv('TELEGRAM_CHAT_ID')
+    
+    url_req = "https://api.telegram.org/bot" + token + "/sendMessage"
+    payload = {
+        'chat_id': chat_id,
+        'text': text,
+        'parse_mode': 'HTML' #or HTML or MarkdownV2
+    }
+    
+    try:
+        response = requests.get(url_req, params=payload)
+    except Exception as e:
+        print(f"Error sending telegram message: {e}")
+
+    return response
+        
+        

DiffusionXray-FewShot-LandmarkDetection/experiments/launch_imagenet_comparative_study.bash

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+# Print the message to the user
+echo "Launching the comparative study of ImageNet backbones for the downstream task..."
+python downstream_task/imagenet_backbones_comparative_study.py

DiffusionXray-FewShot-LandmarkDetection/experiments/launch_landmarks_experiments.bash

@@ -0,0 +1,108 @@
+#!/bin/bash
+
+# Path to the config.json file
+CONFIG_PATH="downstream_task/config/config.json"
+
+# Path to the main.py script
+MAIN_PY_PATH="downstream_task/main.py"
+
+# Temporary file for modified config
+TEMP_CONFIG="temp_config.json"
+
+# Ask for new values for the config file 
+read -p "Insert the dataset name to use for the downstream task ('chest' or 'hand' or 'cephalo'): " DATASET_NAME
+
+# Assert that the dataset name is valid
+if [ "$DATASET_NAME" != "chest" ] && [ "$DATASET_NAME" != "hand" ] && [ "$DATASET_NAME" != "cephalo" ]; then
+    echo "Invalid dataset name. Please choose 'chest' or 'hand' or 'cephalo'."
+    exit 1
+fi
+
+read -p "Insert the name of the model to be used for the downstream task ('ddpm' or 'imagenet' or 'moco' or 'mocov2' or 'mocov3' or 'simclr' or 'simclrv2' or 'dino' or 'barlow_twins' or 'byol'): " MODEL_NAME
+
+# If model_name is "ddpm", then ask for the pretrained model path and if the user is tuning the DDPM pre-training iterations
+if [ "$MODEL_NAME" == "ddpm" ]; then
+    BACKBONE_ENCODER=""
+
+    read -p "Insert the path to the pretrained ddpm model for the downstream task: " PRETRAINED_MODEL_PATH
+
+    # Ask if the user is tuning the DDPM pre-training iterations
+    read -p "Are you tuning the DDPM pre-training iterations? (true or false): " USE_VAL_SET
+
+    # Assert that the value is valid
+    if [ "$USE_VAL_SET" != "true" ] && [ "$USE_VAL_SET" != "false" ]; then
+        echo "Invalid value for tuning DDPM. Please choose 'true' or 'false'."
+        exit 1
+    fi 
+
+    # Ask if the dataset used for the downstream task is different from the one used for pretraining
+    read -p "Is the dataset used for the downstream task different from the one used for pretraining? (true or false): " DIFFERENT_DATASET
+
+    # Assert that the value for different dataset is valid
+    if [ "$DIFFERENT_DATASET" == "true" ]; then
+        DIFFERENT_DATASET=true
+    elif [ "$DIFFERENT_DATASET" == "false" ]; then
+        DIFFERENT_DATASET=false
+    else
+        echo "Invalid value for different dataset. Please choose 'true' or 'false'."
+        exit 1
+    fi
+
+elif [ "$MODEL_NAME" == "imagenet" ]; then
+    PRETRAINED_MODEL_PATH=""
+    USE_VAL_SET=false
+    DIFFERENT_DATASET=false
+
+    # Ask for the backbone encoder to be used for the downstream task
+    read -p "Insert the name of the backbone encoder to be used for the downstream task ('resnet18', 'resnet50', 'resnet101', 'resnet152', 'resnext50_32x4d', 'resnext101_32x8d', 'vgg11', 'vgg13', 'vgg16', 'vgg19', 'densenet121', 'densenet169', 'densenet201', 'densenet161'): " BACKBONE_ENCODER
+
+    # Assert that the backbone encoder is valid
+    if [ "$BACKBONE_ENCODER" != "resnet18" ] && [ "$BACKBONE_ENCODER" != "resnet50" ] && [ "$BACKBONE_ENCODER" != "resnet101" ] && [ "$BACKBONE_ENCODER" != "resnet152" ] && [ "$BACKBONE_ENCODER" != "resnext50_32x4d" ] && [ "$BACKBONE_ENCODER" != "resnext101_32x8d" ] && [ "$BACKBONE_ENCODER" != "vgg11" ] && [ "$BACKBONE_ENCODER" != "vgg13" ] && [ "$BACKBONE_ENCODER" != "vgg16" ] && [ "$BACKBONE_ENCODER" != "vgg19" ] && [ "$BACKBONE_ENCODER" != "densenet121" ] && [ "$BACKBONE_ENCODER" != "densenet169" ] && [ "$BACKBONE_ENCODER" != "densenet201" ] && [ "$BACKBONE_ENCODER" != "densenet161" ]; then
+        echo "Invalid backbone encoder. Please choose 'resnet18', 'resnet50', 'resnet101', 'resnet152', 'resnext50_32x4d', 'resnext101_32x8d', 'vgg11', 'vgg13', 'vgg16', 'vgg19', 'densenet121', 'densenet169', 'densenet201', 'densenet161'."
+        exit 1
+    fi
+
+
+elif [ "$MODEL_NAME" == "moco" ] || [ "$MODEL_NAME" == "mocov2" ] || [ "$MODEL_NAME" == "mocov3" ] || [ "$MODEL_NAME" == "simclr" ] || [ "$MODEL_NAME" == "simclrv2" ] || [ "$MODEL_NAME" == "dino" ] || [ "$MODEL_NAME" == "barlow_twins" ] || [ "$MODEL_NAME" == "byol" ]; then
+    # Ask for the backbone encoder to be used for the downstream task
+    read -p "Insert the name of the backbone encoder to be used for the downstream task ('resnet18', 'resnet50', 'resnet101', 'resnet152', 'resnext50_32x4d', 'resnext101_32x8d', 'vgg11', 'vgg13', 'vgg16', 'vgg19', 'densenet121', 'densenet169', 'densenet201', 'densenet161'): " BACKBONE_ENCODER
+
+    # Assert that the backbone encoder is valid
+    if [ "$BACKBONE_ENCODER" != "resnet18" ] && [ "$BACKBONE_ENCODER" != "resnet50" ] && [ "$BACKBONE_ENCODER" != "resnet101" ] && [ "$BACKBONE_ENCODER" != "resnet152" ] && [ "$BACKBONE_ENCODER" != "resnext50_32x4d" ] && [ "$BACKBONE_ENCODER" != "resnext101_32x8d" ] && [ "$BACKBONE_ENCODER" != "vgg11" ] && [ "$BACKBONE_ENCODER" != "vgg13" ] && [ "$BACKBONE_ENCODER" != "vgg16" ] && [ "$BACKBONE_ENCODER" != "vgg19" ] && [ "$BACKBONE_ENCODER" != "densenet121" ] && [ "$BACKBONE_ENCODER" != "densenet169" ] && [ "$BACKBONE_ENCODER" != "densenet201" ] && [ "$BACKBONE_ENCODER" != "densenet161" ]; then
+        echo "Invalid backbone encoder. Please choose 'resnet18', 'resnet50', 'resnet101', 'resnet152', 'resnext50_32x4d', 'resnext101_32x8d', 'vgg11', 'vgg13', 'vgg16', 'vgg19', 'densenet121', 'densenet169', 'densenet201', 'densenet161'."
+        exit 1
+    fi
+
+    read -p "Insert the path to the $BACKBONE_ENCODER backbone model pre-trained with $MODEL_NAME: " PRETRAINED_MODEL_PATH
+    USE_VAL_SET=false
+    DIFFERENT_DATASET=false
+
+else
+    echo "Invalid model name. Please choose 'ddpm' or 'moco' or 'mocov2' or 'mocov3' or 'simclr' or 'simclrv2' or 'dino' or 'barlow_twins' or 'byol'."
+    exit 1
+fi
+
+# Assert that the path to the pretrained model is valid
+if [ "$PRETRAINED_MODEL_PATH" != "" ] && [ ! -f $PRETRAINED_MODEL_PATH ]; then
+    echo "Invalid path to the pretrained model."
+    exit 1
+fi
+
+
+read -p "Insert the number of training labeled samples to be used for the downstream task ('all' or a number): " TRAINING_SAMPLES
+
+# Assert that the number of training samples is valid
+if [ "$TRAINING_SAMPLES" != "all" ] && ! [[ "$TRAINING_SAMPLES" =~ ^[0-9]+$ ]]; then
+    echo "Invalid number of training samples. Please choose 'all' or a number."
+    exit 1
+fi
+
+# Load the original config
+#jq '.model.name = $MODEL_NAME | .training_protocol.finetuning.path = $PRETRAINED_MODEL_PATH | .training_protocol.finetuning.different_dataset = $DIFFERENT_DATASET | .inference_protocol.use_validation_set_for_inference = $USE_VAL_SET | .dataset.name = $DATASET_NAME | .dataset.training_samples = $TRAINING_SAMPLES' $CONFIG_PATH > $TEMP_CONFIG
+jq --arg BACKBONE_ENCODER "$BACKBONE_ENCODER" --arg MODEL_NAME "$MODEL_NAME" --arg PRETRAINED_MODEL_PATH "$PRETRAINED_MODEL_PATH" --arg DIFFERENT_DATASET "$DIFFERENT_DATASET" --arg USE_VAL_SET "$USE_VAL_SET" --arg DATASET_NAME "$DATASET_NAME" --arg TRAINING_SAMPLES "$TRAINING_SAMPLES" '.model.name = $MODEL_NAME | .model.encoder = $BACKBONE_ENCODER | .training_protocol.finetuning.path = $PRETRAINED_MODEL_PATH | .training_protocol.finetuning.different_dataset = $DIFFERENT_DATASET | .inference_protocol.use_validation_set_for_inference = $USE_VAL_SET | .dataset.name = $DATASET_NAME | .dataset.training_samples = $TRAINING_SAMPLES' $CONFIG_PATH > $TEMP_CONFIG
+
+# Execute the main.py script with the modified config
+python $MAIN_PY_PATH --config $TEMP_CONFIG
+
+# Remove the temporary config file
+rm $TEMP_CONFIG

DiffusionXray-FewShot-LandmarkDetection/experiments/launch_pretraining.bash

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+# Path to the config.json file
+DDPM_CONFIG_PATH="ddpm_pretraining/config/config.json"
+SSL_CONFIG_PATH="ssl_pretraining/config/config.json"
+
+# Path to the main.py script
+DDPM_PY_PATH="ddpm_pretraining/main.py"
+SSL_PY_PATH="ssl_pretraining/main.py"
+
+# Temporary file for modified config
+TEMP_CONFIG="temp_config.json"
+
+# Ask for new values for the config file
+read -p "Insert the dataset name to use for the downstream task ('chest' or 'hand' or 'cephalo'): " DATASET_NAME
+
+# Assert that the dataset name is valid
+if [ "$DATASET_NAME" != "chest" ] && [ "$DATASET_NAME" != "hand" ] && [ "$DATASET_NAME" != "cephalo" ]; then
+    echo "Invalid dataset name. Please choose 'chest' or 'hand' or 'cephalo'."
+    exit 1
+fi
+
+# Ask for the model to be used for the pre-training task
+read -p "Insert the name of the model to be used for the pre-training task ('ddpm' or 'moco' or 'mocov2' or 'mocov3' or 'simclr' or 'simclrv2' or 'dino' or 'barlow_twins' or 'byol'): " MODEL_NAME
+
+# Assert that the model name is valid 
+if [ "$MODEL_NAME" == "ddpm" ]; then
+    # Load the original config
+    jq --arg DATASET_NAME "$DATASET_NAME" '.dataset.name = $DATASET_NAME' $DDPM_CONFIG_PATH > $TEMP_CONFIG
+
+    # Execute the main.py script with the modified config
+    python $DDPM_PY_PATH --config $TEMP_CONFIG
+
+elif [ "$MODEL_NAME" == "moco" ] || [ "$MODEL_NAME" == "mocov2" ] || [ "$MODEL_NAME" == "mocov3" ] || [ "$MODEL_NAME" == "simclr" ] || [ "$MODEL_NAME" == "simclrv2" ] || [ "$MODEL_NAME" == "dino" ] || [ "$MODEL_NAME" == "barlow_twins" ] || [ "$MODEL_NAME" == "byol" ]; then
+
+    # Ask for the backbone encoder to be used for the pre-training task
+    read -p "Insert the name of the backbone encoder to be used for the pre-training task ('resnet18', 'resnet50', 'resnet101', 'resnet152', 'resnext50_32x4d', 'resnext101_32x8d', 'vgg11', 'vgg13', 'vgg16', 'vgg19', 'densenet121', 'densenet169', 'densenet201', 'densenet161'): " BACKBONE_ENCODER
+
+    # Assert that the backbone encoder is valid
+    if [ "$BACKBONE_ENCODER" != "resnet18" ] && [ "$BACKBONE_ENCODER" != "resnet50" ] && [ "$BACKBONE_ENCODER" != "resnet101" ] && [ "$BACKBONE_ENCODER" != "resnet152" ] && [ "$BACKBONE_ENCODER" != "resnext50_32x4d" ] && [ "$BACKBONE_ENCODER" != "resnext101_32x8d" ] && [ "$BACKBONE_ENCODER" != "vgg11" ] && [ "$BACKBONE_ENCODER" != "vgg13" ] && [ "$BACKBONE_ENCODER" != "vgg16" ] && [ "$BACKBONE_ENCODER" != "vgg19" ] && [ "$BACKBONE_ENCODER" != "densenet121" ] && [ "$BACKBONE_ENCODER" != "densenet169" ] && [ "$BACKBONE_ENCODER" != "densenet201" ] && [ "$BACKBONE_ENCODER" != "densenet161" ]; then
+        echo "Invalid backbone encoder. Please choose 'resnet18', 'resnet50', 'resnet101', 'resnet152', 'resnext50_32x4d', 'resnext101_32x8d', 'vgg11', 'vgg13', 'vgg16', 'vgg19', 'densenet121', 'densenet169', 'densenet201', 'densenet161'."
+        exit 1
+    fi
+
+    # Load the original config
+    jq --arg BACKBONE_ENCODER "$BACKBONE_ENCODER" --arg MODEL_NAME "$MODEL_NAME" --arg DATASET_NAME "$DATASET_NAME" '.dataset.name = $DATASET_NAME | .model.encoder = $BACKBONE_ENCODER | .model.name = $MODEL_NAME' $SSL_CONFIG_PATH > $TEMP_CONFIG
+
+    # Execute the main.py script with the modified config
+    python $SSL_PY_PATH --config $TEMP_CONFIG
+
+else
+    echo "Invalid model name. Please choose 'ddpm' or 'moco' or 'mocov2' or 'mocov3' or 'simclr' or 'simclrv2' or 'dino' or 'barlow_twins' or 'byol'."
+    exit 1
+fi
+
+# Remove the temporary config file
+rm $TEMP_CONFIG

DiffusionXray-FewShot-LandmarkDetection/launch_experiments.bash

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Check if more than one gpu is available, if so ask for which one to use
+if [ $(nvidia-smi --query-gpu=count --format=csv,noheader | wc -l) -gt 1 ]; then
+    read -p "Insert the GPU number to use: " GPU
+    export CUDA_VISIBLE_DEVICES=$GPU
+fi
+
+# Ask for which experiment to run
+read -p "Insert the experiment to run (1 for pre-training task, 2 for ImageNet comparative study, 3 for downstream task experiments): " EXPERIMENT
+
+# Execute the corresponding experiment
+case $EXPERIMENT in 
+    1)
+        bash experiments/launch_pretraining.bash
+        ;;
+    2)
+        bash experiments/launch_imagenet_comparative_study.bash
+        ;;
+    3)
+        bash experiments/launch_landmarks_experiments.bash
+        ;;
+    *)
+
+        echo "Invalid experiment number" 
+        ;;
+esac
+
+
+

DiffusionXray-FewShot-LandmarkDetection/requirements.txt

@@ -0,0 +1,21 @@
+albumentations==1.4.4
+einops==0.8.0
+GPUtil==1.4.0
+matplotlib==3.8.2
+numpy==1.23.5
+opencv_python==4.9.0.80
+opencv_python_headless==4.9.0.80
+pandas==2.2.3
+Pillow==9.3.0
+Pillow==11.0.0
+prettytable==3.12.0
+Requests==2.32.3
+scikit_learn==1.3.2
+scipy==1.14.1
+segmentation_models_pytorch==0.3.3
+skimage==0.0
+torch==2.1.0+cu118
+torchmetrics==1.3.0
+torchvision==0.16.0+cu118
+tqdm==4.66.1
+urllib3==1.26.13

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/__init__.py

@@ -0,0 +1,31 @@
+"""
+
+Self-supervised Implementation taken from https://github.com/giakoumoglou/pyssl
+
+"""
+from .barlow_twins import BarlowTwins 
+from .byol import BYOL
+from .dino import DINO
+from .moco import MoCo
+from .mocov2 import MoCoV2
+from .mocov3 import MoCoV3
+from .simclr import SimCLR
+from .simsiam import SimSiam
+from .simclrv2 import SimCLRv2
+from .supcon import SupCon
+from .swav import SwAV
+
+
+__all__ = [
+        'BarlowTwins',
+        'BYOL',
+        'DINO',
+        'MoCo',
+        'MoCoV2',
+        'MoCoV3',
+        'SimCLR',
+        'SimCLRv2',
+        'SimSiam',
+        'SupCon',
+        'SwAV',
+        ]

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/barlow_twins.py

@@ -0,0 +1,105 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torchvision.transforms as T
+from PIL import Image
+
+
+__all__ = ['BarlowTwins']
+
+
+class BarlowTwins(nn.Module):
+    """ 
+    Barlow Twins
+    Link: https://arxiv.org/abs/2104.02057
+    Implementation: https://arxiv.org/abs/2103.03230
+    """
+    def __init__(self, backbone, feature_size, projection_dim=8192, hidden_dim=8192, lamda=0.005,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.lamda = lamda
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.backbone = backbone
+        self.projector = Projector(feature_size, hidden_dim, projection_dim)
+        self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.bn = nn.BatchNorm1d(projection_dim, affine=False)
+        self.augment = T.Compose([
+                T.RandomResizedCrop(image_size, interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.RandomSolarize(threshold=0.5, p=0.0),
+                T.Normalize(mean=mean, std=std),
+                ])
+        self.augment_prime = T.Compose([
+                T.RandomResizedCrop(image_size, interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.RandomSolarize(threshold=0.5, p=0.2),
+                T.Normalize(mean=mean, std=std),
+                ])
+        
+    def forward(self, x):
+        x1, x2 = self.augment(x), self.augment_prime(x)
+        z1, z2 = self.encoder(x1), self.encoder(x2)
+        bz = z1.shape[0]
+        c = self.bn(z1).T @ self.bn(z2)
+        c.div_(bz)
+        on_diag = torch.diagonal(c).add_(-1).pow_(2).sum()
+        off_diag = off_diagonal(c).pow_(2).sum()
+        loss = on_diag + self.lamda * off_diag
+        return loss
+    
+    
+class Projector(nn.Module):
+    """ Projector for Barlow Twins """
+    def __init__(self, in_dim, hidden_dim=2048, out_dim=128):
+        super().__init__()
+        
+        self.layer1 = nn.Sequential(
+                    nn.Linear(in_dim, hidden_dim, bias=False),
+                    nn.BatchNorm1d(hidden_dim, eps=1e-5, affine=True),
+                    nn.ReLU(inplace=True),
+                    )
+        self.layer2 = nn.Sequential(
+                    nn.Linear(hidden_dim, hidden_dim, bias=False),
+                    nn.BatchNorm1d(hidden_dim, eps=1e-5, affine=True),
+                    nn.ReLU(inplace=True),
+                    )
+        self.layer3 = nn.Sequential(
+                    nn.Linear(hidden_dim, out_dim, bias=False),
+                    )
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        return x 
+    
+    
+def off_diagonal(x):
+    n, m = x.shape
+    return x.flatten()[:-1].view(n - 1, n + 1)[:, 1:].flatten()
+    
+
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = BarlowTwins(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/byol.py

@@ -0,0 +1,114 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+import copy
+from PIL import Image
+
+
+__all__ = ['BYOL']
+
+
+class BYOL(nn.Module):
+    """ 
+    BYOL: Bootstrap your own latent: A new approach to self-supervised Learning
+    Link: https://arxiv.org/abs/2006.07733
+    Implementation: https://github.com/deepmind/deepmind-research/tree/master/byol
+    """
+    def __init__(self, backbone, feature_size, projection_dim=256, hidden_dim=4096, tau=0.996,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.tau = tau # EMA update
+        self.backbone = backbone
+        self.projector = MLP(feature_size, hidden_dim=hidden_dim, out_dim=projection_dim)
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.online_encoder =  self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.online_predictor = MLP(in_dim=projection_dim, hidden_dim=hidden_dim, out_dim=projection_dim)
+        self.target_encoder = copy.deepcopy(self.online_encoder) # target must be a deepcopy of online, since we will use the backbone trained by online
+        self._init_target_encoder()
+        self.augment1 = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.08, 1.0), ratio=(3.0/4.0,4.0/3.0), interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.2, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.Normalize(mean=mean, std=std)
+                ])
+        self.augment2 = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.08, 1.0), ratio=(3.0/4.0,4.0/3.0), interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.2, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.RandomSolarize(threshold=0.5, p=0.2),
+                T.Normalize(mean=mean, std=std)
+                ])
+    
+    def forward(self, x):
+        x1, x2 = self.augment1(x), self.augment2(x)
+        z1_o, z2_o = self.online_encoder(x1), self.online_encoder(x2)
+        p1_o, p2_o = self.online_predictor(z1_o), self.online_predictor(z2_o)
+        with torch.no_grad():
+            self._momentum_update_target_encoder()
+            z1_t, z2_t = self.target_encoder(x1), self.target_encoder(x2) 
+        loss =  mean_squared_error(p1_o, z2_t) / 2 + mean_squared_error(p2_o, z1_t) / 2     
+        return loss
+    
+    def _init_target_encoder(self):
+        for param_o, param_t in zip(self.online_encoder.parameters(), self.target_encoder.parameters()):
+            param_t.data.copy_(param_o.data)
+            param_t.requires_grad = False
+            
+    @torch.no_grad()
+    def _momentum_update_target_encoder(self):
+        for param_o, param_t in zip(self.online_encoder.parameters(), self.target_encoder.parameters()):
+            param_t.data = self.tau * param_t.data  + (1. - self.tau) * param_o.data
+                  
+
+def mean_squared_error(p, z):
+    p = F.normalize(p, dim=1)
+    z = F.normalize(z, dim=1)
+    return 2 - 2 * (p * z.detach()).sum(dim=-1).mean()
+
+
+class MLP(nn.Module):
+    """ Projection Head and Prediction Head for BYOL """
+    def __init__(self, in_dim, hidden_dim=4096, out_dim=256):
+        super().__init__()
+
+        self.layer1 = nn.Sequential(
+            nn.Linear(in_dim, hidden_dim),
+            nn.BatchNorm1d(hidden_dim),
+            nn.ReLU(inplace=True)
+        )
+        self.layer2 = nn.Sequential(
+            nn.Linear(hidden_dim, out_dim),
+        )
+
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        return x 
+    
+    
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+        
+    model = BYOL(backbone, feature_size, tau=0.996)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/dino.py

@@ -0,0 +1,172 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+from PIL import Image
+import copy
+
+
+__all__ = ['DINO']
+
+
+class DINO(nn.Module):
+    """ 
+    DINO: Emerging Properties in Self-Supervised Vision Transformers
+    Link: https://arxiv.org/abs/2104.14294
+    Implementation: https://github.com/facebookresearch/dino
+    """
+    def __init__(self, backbone, feature_size, projection_dim=256, hidden_dim=2048, bottleneck_dim=256, temp_s=0.1, temp_t=0.5, m=0.5, lamda=0.996, num_crops=6,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.temp_s = temp_s
+        self.temp_t = temp_t
+        self.register_buffer("center", torch.zeros(1, projection_dim))
+        self.m = m
+        self.lamda = lamda # EMA update
+        self.backbone = backbone   
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.head_student = Head(feature_size, hidden_dim=hidden_dim, bottleneck_dim=bottleneck_dim, out_dim=projection_dim)
+        self.student = self.encoder = nn.Sequential(self.backbone, self.head_student)
+        self.head_teacher = Head(feature_size, hidden_dim=hidden_dim, bottleneck_dim=bottleneck_dim, out_dim=projection_dim)
+        self.teacher = nn.Sequential(copy.deepcopy(backbone), self.head_teacher)
+        self._init_teacher()
+        self.num_crops = num_crops
+        self.augment_global1 = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.04, 1.0), interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.2, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.Normalize(mean=mean, std=std),
+                ])
+        self.augment_global2 = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.04, 1.0), interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.2, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.RandomSolarize(threshold=0.5, p=0.2),
+                T.Normalize(mean=mean, std=std),
+                ])
+        self.augment_local = T.Compose([
+                T.RandomResizedCrop(int(image_size*3/7), scale=(0.05, 1.0), interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.2, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.Normalize(mean=mean, std=std),
+                ])
+        
+    def forward(self, x):
+        x1, x2 = self.augment_global1(x), self.augment_global2(x)
+        
+        xc = []
+        if self.num_crops > 0:
+            for _ in range(self.num_crops):
+                xc.append(self.augment_local(x))
+          
+        z1_s, z2_s = self.student(x1), self.student(x2)
+           
+        zc_s = []
+        for x in xc:
+            zc_s.append(self.student(x))
+        
+        with torch.no_grad():
+            self._momentum_update_teacher()
+            z1_t, z2_t = self.teacher(x1), self.teacher(x2)
+            
+        z_s = [z1_s, z2_s] + zc_s
+        z_t = [z1_t, z2_t]  
+        
+        loss, loss_terms = 0, 0
+        for iq, q in enumerate(z_t):
+            for iv, v in enumerate(z_s):
+                if iv==iq:
+                    continue
+                loss += cross_entropy_loss(q, v, self.temp_s, self.temp_t, self.center)
+                loss_terms += 1
+        loss /= loss_terms 
+        
+        self._update_center(z1_t, z2_t)
+        return loss
+    
+    def _init_teacher(self):
+        for param_q, param_k in zip(self.student.parameters(), self.teacher.parameters()):
+            param_k.data.copy_(param_q.data)  # initialize
+            param_k.requires_grad = False     # not update by gradient
+            
+    @torch.no_grad()
+    def _momentum_update_teacher(self):
+        for param_q, param_k in zip(self.student.parameters(), self.teacher.parameters()):
+            param_k.data = self.lamda * param_k.data  + (1. - self.lamda) * param_q.data
+           
+    @torch.no_grad()
+    def _update_center(self, z1_t, z2_t):
+        self.center = self.m*self.center + (1-self.m)*torch.cat([z1_t, z2_t]).mean(dim=0)
+            
+
+def cross_entropy_loss(z_t, z_s, temp_s, temp_t, center):
+    z_t = z_t.detach() # stop gradient
+    z_s = z_s / temp_s
+    z_t = F.softmax((z_t - center) / temp_t, dim=1) # center + sharpen
+    return - (z_t * F.log_softmax(z_s, dim=1)).sum(dim=1).mean()
+    
+
+class Head(nn.Module):
+    """ Projection Head for DINO """
+    def __init__(self, in_dim, hidden_dim=2048, bottleneck_dim=256, out_dim=256, ):
+        super().__init__()
+
+        self.layer1 = nn.Sequential(
+            nn.Linear(in_dim, hidden_dim),
+            nn.GELU(),
+        )
+        self.layer2 = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.GELU(),
+        )
+        self.layer3 = nn.Sequential(
+            nn.Linear(hidden_dim, bottleneck_dim),
+        )
+        self.apply(self._init_weights)
+        
+        self.last_layer = nn.utils.weight_norm(nn.Linear(bottleneck_dim, out_dim, bias=False))
+        self.last_layer.weight_g.data.fill_(1)
+        self.last_layer.weight_g.requires_grad = False
+        
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = nn.functional.normalize(x, dim=-1, p=2)
+        x = self.last_layer(x)
+        return x 
+    
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            torch.nn.init.trunc_normal_(m.weight, std=0.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+                
+                
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = DINO(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/moco.py

@@ -0,0 +1,118 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+import copy
+
+
+__all__ = ['MoCo']
+
+
+class MoCo(nn.Module):
+    """ 
+    MoCo: Momentum Contrast
+    Link: https://arxiv.org/abs/1911.05722
+    Implementation: https://github.com/facebookresearch/moco
+    """
+    def __init__(self, backbone, feature_size, projection_dim=128, K=65536, m=0.999, temperature=0.07,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.K = K
+        self.m = m
+        self.temperature = temperature
+        self.backbone = backbone
+        self.projector = nn.Linear(feature_size, projection_dim)
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.encoder_q  =  self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.encoder_k = copy.deepcopy(self.encoder_q)
+        self._init_encoder_k()
+        self.register_buffer("queue", torch.randn(projection_dim, K))
+        self.queue = nn.functional.normalize(self.queue, dim=0)
+        self.register_buffer("queue_ptr", torch.zeros(1, dtype=torch.long))
+        self.augment = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.2, 1.0)),
+                T.RandomGrayscale(p=0.2),
+                T.ColorJitter(0.4, 0.4, 0.4, 0.4),
+                T.RandomHorizontalFlip(),
+                T.Normalize(mean=mean, std=std)
+                ])
+        
+    def forward(self, x):
+        x_q, x_k = self.augment(x), self.augment(x)
+        q = self.encoder_q(x_q)
+        q = nn.functional.normalize(q, dim=1)
+        with torch.no_grad():
+            self._momentum_update_encoder_k()
+            x_k, idx_unshuffle = self._batch_shuffle_single_gpu(x_k)
+            k = self.encoder_k(x_k) 
+            k = nn.functional.normalize(k, dim=1)
+            k = self._batch_unshuffle_single_gpu(k, idx_unshuffle)
+        loss = infonce_loss(q, k, self.queue, self.temperature)
+        self._dequeue_and_enqueue(k)
+        return loss
+    
+    @torch.no_grad()
+    def _init_encoder_k(self):
+        for param_q, param_k in zip(self.encoder_q.parameters(), self.encoder_k.parameters()):
+            param_k.data.copy_(param_q.data) 
+            param_k.requires_grad = False 
+        
+    @torch.no_grad()
+    def _momentum_update_encoder_k(self):
+        for param_q, param_k in zip(self.encoder_q.parameters(), self.encoder_k.parameters()):
+            param_k.data = param_k.data * self.m + param_q.data * (1.0 - self.m)
+        
+    @torch.no_grad()
+    def _dequeue_and_enqueue(self, keys):
+        bz = keys.shape[0]
+        ptr = int(self.queue_ptr)
+        assert self.K % bz == 0
+        self.queue[:, ptr:(ptr + bz)] = keys.t() 
+        ptr = (ptr + bz) % self.K
+        self.queue_ptr[0] = ptr
+        
+    @torch.no_grad()
+    def _batch_shuffle_single_gpu(self, x):
+        idx_shuffle = torch.randperm(x.shape[0]).cuda()
+        idx_unshuffle = torch.argsort(idx_shuffle)
+        return x[idx_shuffle], idx_unshuffle
+
+    @torch.no_grad()
+    def _batch_unshuffle_single_gpu(self, x, idx_unshuffle):
+        return x[idx_unshuffle]
+
+
+def infonce_loss(q, k, queue, temperature=0.07):
+    """ InfoNCE loss """
+    l_pos = torch.einsum("nc,nc->n", [q, k]).unsqueeze(-1)
+    l_neg = torch.einsum("nc,ck->nk", [q, queue.clone().detach()])
+    logits = torch.cat([l_pos, l_neg], dim=1)
+    logits /= temperature
+    labels = torch.zeros(logits.shape[0], dtype=torch.long).to(q.device)
+    loss = F.cross_entropy(logits, labels)
+    return loss
+
+
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = MoCo(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')
+
+    

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/mocov2.py

@@ -0,0 +1,132 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+import copy
+
+
+__all__ = ['MoCoV2']
+    
+
+class MoCoV2(nn.Module):
+    """ 
+    MoCo v2: Momentum Contrast v2
+    Link: https://arxiv.org/abs/2003.04297
+    Implementation: https://github.com/facebookresearch/moco
+    """
+    def __init__(self, backbone, feature_size, projection_dim=128, K=65536, m=0.999, temperature=0.07,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.K = K
+        self.m = m
+        self.temperature = temperature     
+        self.backbone = backbone
+        self.projector = Projector(feature_size, feature_size, projection_dim)
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.encoder_q  =  self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.encoder_k = copy.deepcopy(self.encoder_q)
+        self._init_encoder_k()        
+        self.register_buffer("queue", torch.randn(projection_dim, K))
+        self.queue = nn.functional.normalize(self.queue, dim=0)
+        self.register_buffer("queue_ptr", torch.zeros(1, dtype=torch.long))
+        self.augment = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.2, 1.0)),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.4, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.RandomHorizontalFlip(),
+                T.Normalize(mean=mean, std=std)
+                ])
+        
+    def forward(self, x):
+        x_q, x_k = self.augment(x), self.augment(x)        
+        q = self.encoder_q(x_q)
+        q = nn.functional.normalize(q, dim=1)
+        with torch.no_grad():
+            self._momentum_update_encoder_k()
+            x_k, idx_unshuffle = self._batch_shuffle_single_gpu(x_k)
+            k = self.encoder_k(x_k) 
+            k = nn.functional.normalize(k, dim=1)
+            k = self._batch_unshuffle_single_gpu(k, idx_unshuffle)
+        loss = infonce_loss(q, k, self.queue, self.temperature)
+        self._dequeue_and_enqueue(k)
+        return loss
+    
+    @torch.no_grad()
+    def _init_encoder_k(self):
+        for param_q, param_k in zip(self.encoder_q.parameters(), self.encoder_k.parameters()):
+            param_k.data.copy_(param_q.data) 
+            param_k.requires_grad = False 
+        
+    @torch.no_grad()
+    def _momentum_update_encoder_k(self):
+        for param_q, param_k in zip(self.encoder_q.parameters(), self.encoder_k.parameters()):
+            param_k.data = param_k.data * self.m + param_q.data * (1.0 - self.m)
+        
+    @torch.no_grad()
+    def _dequeue_and_enqueue(self, keys):
+        bz = keys.shape[0]
+        ptr = int(self.queue_ptr)
+        assert self.K % bz == 0
+        self.queue[:, ptr:(ptr + bz)] = keys.t() 
+        ptr = (ptr + bz) % self.K
+        self.queue_ptr[0] = ptr
+        
+    @torch.no_grad()
+    def _batch_shuffle_single_gpu(self, x):
+        idx_shuffle = torch.randperm(x.shape[0]).cuda()
+        idx_unshuffle = torch.argsort(idx_shuffle)
+        return x[idx_shuffle], idx_unshuffle
+
+    @torch.no_grad()
+    def _batch_unshuffle_single_gpu(self, x, idx_unshuffle):
+        return x[idx_unshuffle]
+            
+
+def infonce_loss(q, k, queue, temperature=0.07):
+    """ InfoNCE loss """
+    l_pos = torch.einsum("nc,nc->n", [q, k]).unsqueeze(-1)
+    l_neg = torch.einsum("nc,ck->nk", [q, queue.clone().detach()])
+    logits = torch.cat([l_pos, l_neg], dim=1)
+    logits /= temperature
+    labels = torch.zeros(logits.shape[0], dtype=torch.long).to(q.device)
+    loss = F.cross_entropy(logits, labels)
+    return loss
+
+
+class Projector(nn.Module):
+    """ Projector for MoCov2: Copy from SimCLR"""
+    def __init__(self, in_dim, hidden_dim=None, out_dim=128):
+        super().__init__()
+        if hidden_dim == None: hidden_dim=in_dim
+        self.layer1 = nn.Sequential(
+                    nn.Linear(in_dim, hidden_dim),
+                    nn.ReLU(inplace=True),
+                    nn.Linear(hidden_dim, out_dim),
+                )
+    def forward(self, x):
+        x = self.layer1(x)
+        return x 
+    
+    
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = MoCoV2(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/mocov3.py

@@ -0,0 +1,148 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+import copy
+from PIL import Image
+
+
+__all__ = ['MoCoV3']
+    
+
+class MoCoV3(nn.Module):
+    """ 
+    MoCo v3: Momentum Contrast v3
+    Link: https://arxiv.org/abs/2104.02057
+    Implementation: https://github.com/facebookresearch/moco-v3
+    """
+    def __init__(self, backbone, feature_size, projection_dim=256, hidden_dim=2048, temperature=0.5, m=0.999,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.temperature = temperature
+        self.m = m
+        self.backbone = backbone
+        self.projector = Projector(feature_size, hidden_dim=hidden_dim, out_dim=projection_dim)
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.encoder_q = self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.predictor = Predictor(in_dim=projection_dim, hidden_dim=hidden_dim, out_dim=projection_dim)
+        self.encoder_k = copy.deepcopy(self.encoder_q)
+        self._init_encoder_k()
+        self.augment1 = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.08, 1.0), ratio=(3.0/4.0,4.0/3.0), interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.2, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.Normalize(mean=mean, std=std)
+                ])
+        self.augment2 = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.08, 1.0), ratio=(3.0/4.0,4.0/3.0), interpolation=Image.BICUBIC),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.2, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.RandomSolarize(threshold=0.5, p=0.2),
+                T.Normalize(mean=mean, std=std)
+                ])
+        
+    def forward(self, x):
+        x1, x2 = self.augment1(x), self.augment2(x)
+        q1 = self.predictor(self.encoder_q(x1))
+        q2 = self.predictor(self.encoder_q(x2))
+        with torch.no_grad():
+            self._update_momentum_encoder()
+            k1 = self.encoder_k(x1)
+            k2 = self.encoder_k(x2)
+        loss = infonce_loss(q1, k2, self.temperature) + infonce_loss(q2, k1, self.temperature)
+        return loss
+        
+    @torch.no_grad()
+    def _update_momentum_encoder(self):
+        for param_b, param_m in zip(self.encoder_q.parameters(), self.encoder_k.parameters()):
+            param_m.data = param_m.data * self.m + param_b.data * (1. - self.m)
+            
+    @torch.no_grad()
+    def _init_encoder_k(self):
+        for param_q, param_k in zip(self.encoder_q.parameters(), self.encoder_k.parameters()):
+            param_k.data.copy_(param_q.data) 
+            param_k.requires_grad = False 
+         
+
+def infonce_loss(q, k, temperature=0.07):
+    """ InfoNCE loss """
+    q = nn.functional.normalize(q, dim=1)
+    k = nn.functional.normalize(k, dim=1)
+    logits = torch.einsum('nc,mc->nm', [q, k])
+    logits /= temperature
+    labels = (torch.arange(logits.shape[0], dtype=torch.long)).to(q.device)
+    loss = F.cross_entropy(logits, labels)
+    return loss
+
+
+class Projector(nn.Module):
+    """ Projector for SimCLR v2, used in MoCo v3 too """
+    def __init__(self, in_dim, hidden_dim=2048, out_dim=256):
+        super().__init__()
+        
+        self.layer1 = nn.Sequential(
+                    nn.Linear(in_dim, hidden_dim),
+                    nn.BatchNorm1d(hidden_dim, eps=1e-5, affine=True),
+                    nn.ReLU(inplace=True),
+                    )
+        self.layer2 = nn.Sequential(
+                    nn.Linear(hidden_dim, hidden_dim),
+                    nn.BatchNorm1d(hidden_dim, eps=1e-5, affine=True),
+                    nn.ReLU(inplace=True),
+                    )
+        self.layer3 = nn.Sequential(
+                    nn.Linear(hidden_dim, out_dim),
+                    nn.BatchNorm1d(out_dim, eps=1e-5, affine=True),
+                    )
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        return x 
+    
+    
+class Predictor(nn.Module):
+    """ Projection Head and Prediction Head for BYOL, used in MoCo v3 too """
+    def __init__(self, in_dim, hidden_dim=4096, out_dim=256):
+        super().__init__()
+
+        self.layer1 = nn.Sequential(
+            nn.Linear(in_dim, hidden_dim),
+            nn.BatchNorm1d(hidden_dim),
+            nn.ReLU(inplace=True)
+        )
+        self.layer2 = nn.Sequential(
+            nn.Linear(hidden_dim, out_dim),
+        )
+
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        return x       
+    
+    
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = MoCoV3(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/simclr.py

@@ -0,0 +1,99 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+
+
+__all__ = ['SimCLR']
+
+
+class SimCLR(nn.Module):
+    """ 
+    SimCLR: A Simple Framework for Contrastive Learning of Visual Representations
+    Link: https://arxiv.org/abs/2002.05709
+    Implementation: https://github.com/google-research/simclr
+    """
+    def __init__(self, backbone, feature_size, projection_dim=128, temperature=0.5, 
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.temperature = temperature
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.backbone = backbone
+        self.projector = Projector(feature_size, hidden_dim=feature_size, out_dim=projection_dim)
+        self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.augment = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.2, 1.0)),
+                T.RandomHorizontalFlip(),
+                T.RandomApply([T.ColorJitter(0.8,0.8,0.8,0.2)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.Normalize(mean=mean, std=std),
+                ])
+        
+    def forward(self, x):
+        x1, x2 = self.augment(x), self.augment(x)
+        z1, z2 = self.encoder(x1), self.encoder(x2)
+        loss = nt_xent_loss(z1, z2, self.temperature)
+        return loss
+
+
+def nt_xent_loss(z1, z2, temperature=0.5):
+    """ NT-Xent loss """
+    z1 = F.normalize(z1, dim=1)
+    z2 = F.normalize(z2, dim=1)
+    N, Z = z1.shape 
+    device = z1.device 
+    representations = torch.cat([z1, z2], dim=0)
+    similarity_matrix = F.cosine_similarity(representations.unsqueeze(1), representations.unsqueeze(0), dim=-1)
+    l_pos = torch.diag(similarity_matrix, N)
+    r_pos = torch.diag(similarity_matrix, -N)
+    positives = torch.cat([l_pos, r_pos]).view(2 * N, 1)
+    diag = torch.eye(2*N, dtype=torch.bool, device=device)
+    diag[N:,:N] = diag[:N,N:] = diag[:N,:N]
+    negatives = similarity_matrix[~diag].view(2*N, -1)
+    logits = torch.cat([positives, negatives], dim=1)
+    logits /= temperature
+    labels = torch.zeros(2*N, device=device, dtype=torch.int64)
+    loss = F.cross_entropy(logits, labels, reduction='sum')
+    return loss / (2 * N)
+    
+    
+class Projector(nn.Module):
+    """ Projector for SimCLR """
+    def __init__(self, in_dim, hidden_dim=None, out_dim=128):
+        super().__init__()
+        
+        if hidden_dim is None:
+            self.layer1 = nn.Linear(in_dim, out_dim)
+        else:
+            self.layer1 = nn.Sequential(
+                    nn.Linear(in_dim, hidden_dim),
+                    nn.ReLU(inplace=True),
+                    nn.Linear(hidden_dim, out_dim),
+                )
+    def forward(self, x):
+        x = self.layer1(x)
+        return x 
+    
+    
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = SimCLR(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/simclrv2.py

@@ -0,0 +1,113 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+
+
+__all__ = ['SimCLRv2']
+
+
+
+class SimCLRv2(nn.Module):
+    """ 
+    SimCLR: A Simple Framework for Contrastive Learning of Visual Representations
+    Link: https://arxiv.org/abs/2002.05709
+    Implementation: https://github.com/google-research/simclr
+    """
+    def __init__(self, backbone, feature_size, projection_dim=128, temperature=0.5,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.temperature = temperature
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.backbone = backbone
+        self.projector = Projector(feature_size, hidden_dim=feature_size, out_dim=projection_dim)
+        self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.augment = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.2, 1.0)),
+                T.RandomHorizontalFlip(),
+                T.RandomApply([T.ColorJitter(0.8,0.8,0.8,0.2)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.Normalize(mean=mean, std=std),
+                ])
+        
+    def forward(self, x):
+        x1, x2 = self.augment(x), self.augment(x)
+        z1, z2 = self.encoder(x1), self.encoder(x2)
+        loss = nt_xent_loss(z1, z2, self.temperature)
+        return loss
+    
+    @torch.no_grad()
+    def eval(self):
+        super().eval()
+        self.backbone = nn.Sequential(self.backbone, self.projector.layer1)
+
+
+def nt_xent_loss(z1, z2, temperature=0.5):
+    """ NT-Xent loss """
+    z1 = F.normalize(z1, dim=1)
+    z2 = F.normalize(z2, dim=1)
+    N, Z = z1.shape 
+    device = z1.device 
+    representations = torch.cat([z1, z2], dim=0)
+    similarity_matrix = F.cosine_similarity(representations.unsqueeze(1), representations.unsqueeze(0), dim=-1)
+    l_pos = torch.diag(similarity_matrix, N)
+    r_pos = torch.diag(similarity_matrix, -N)
+    positives = torch.cat([l_pos, r_pos]).view(2 * N, 1)
+    diag = torch.eye(2*N, dtype=torch.bool, device=device)
+    diag[N:,:N] = diag[:N,N:] = diag[:N,:N]
+    negatives = similarity_matrix[~diag].view(2*N, -1)
+    logits = torch.cat([positives, negatives], dim=1)
+    logits /= temperature
+    labels = torch.zeros(2*N, device=device, dtype=torch.int64)
+    loss = F.cross_entropy(logits, labels, reduction='sum')
+    return loss / (2 * N)
+    
+    
+class Projector(nn.Module):
+    """ Projector for SimCLR v2 """
+    def __init__(self, in_dim, hidden_dim=2048, out_dim=128):
+        super().__init__()
+        
+        self.layer1 = nn.Sequential(
+                    nn.Linear(in_dim, hidden_dim),
+                    nn.BatchNorm1d(hidden_dim, eps=1e-5, affine=True),
+                    nn.ReLU(inplace=True),
+                    )
+        self.layer2 = nn.Sequential(
+                    nn.Linear(hidden_dim, hidden_dim),
+                    nn.BatchNorm1d(hidden_dim, eps=1e-5, affine=True),
+                    nn.ReLU(inplace=True),
+                    )
+        self.layer3 = nn.Sequential(
+                    nn.Linear(hidden_dim, out_dim),
+                    nn.BatchNorm1d(out_dim, eps=1e-5, affine=True),
+                    )
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        return x 
+
+
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = SimCLRv2(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/simsiam.py

@@ -0,0 +1,114 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+
+
+__all__ = ['SimSiam']
+
+
+class SimSiam(nn.Module):
+    """ 
+    SimSiam: Exploring Simple Siamese Representation Learning
+    Link: https://arxiv.org/abs/2011.10566
+    Implementation: https://github.com/facebookresearch/simsiam
+    """
+    def __init__(self, backbone, feature_size, projection_dim=2048, hidden_dim_proj=2048, hidden_dim_pred=512,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.backbone = backbone
+        self.projector = Projector(feature_size, hidden_dim=hidden_dim_proj, out_dim=projection_dim)
+        self.predictor = Predictor(in_dim=projection_dim, hidden_dim=hidden_dim_pred, out_dim=projection_dim)
+        self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.augment = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.2, 1.0)),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.4, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.RandomHorizontalFlip(),
+                T.Normalize(mean=mean, std=std)
+                ])
+        
+    def forward(self, x):
+        x1, x2 = self.augment(x), self.augment(x)
+        z1, z2 = self.encoder(x1), self.encoder(x2) 
+        p1, p2 = self.predictor(z1), self.predictor(z2)
+        loss = negative_cosine_similarity(p1, z2) / 2 + negative_cosine_similarity(p2, z1) / 2
+        return loss
+
+
+def negative_cosine_similarity(p, z):
+    """ Negative Cosine Similarity """
+    z = z.detach()
+    p = F.normalize(p, dim=1)
+    z = F.normalize(z, dim=1)
+    return -(p*z).sum(dim=1).mean()
+    
+
+class Projector(nn.Module):
+    """ Projection Head for SimSiam """
+    def __init__(self, in_dim, hidden_dim=2048, out_dim=2048):
+        super().__init__()
+
+        self.layer1 = nn.Sequential(
+            nn.Linear(in_dim, hidden_dim),
+            nn.BatchNorm1d(hidden_dim),
+            nn.ReLU(inplace=True)
+        )
+        self.layer2 = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.BatchNorm1d(hidden_dim),
+            nn.ReLU(inplace=True)
+        )
+        self.layer3 = nn.Sequential(
+            nn.Linear(hidden_dim, out_dim),
+            nn.BatchNorm1d(hidden_dim)
+        )
+
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        return x 
+    
+    
+class Predictor(nn.Module):
+    """ Predictor for SimSiam """
+    def __init__(self, in_dim=2048, hidden_dim=512, out_dim=2048):
+        super().__init__()
+        
+        self.layer1 = nn.Sequential(
+            nn.Linear(in_dim, hidden_dim),
+            nn.BatchNorm1d(hidden_dim),
+            nn.ReLU(inplace=True)
+        )
+        self.layer2 = nn.Linear(hidden_dim, out_dim)
+
+    def forward(self, x):
+        x = self.layer1(x)
+        x = self.layer2(x)
+        return x 
+    
+    
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = SimSiam(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/supcon.py

@@ -0,0 +1,124 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torchvision.transforms as T
+
+
+__all__ = ['SupCon']
+
+
+class SupCon(nn.Module):
+    """
+    SupCon: Supervised Contrastive Learning
+    Link: https://arxiv.org/abs/2004.11362
+    Implementation: https://github.com/HobbitLong/SupContrast
+    """
+    def __init__(self, backbone, feature_size, projection_dim=128, temperature=0.07,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.temperature = temperature
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.backbone = backbone
+        self.projector = Projector(feature_size, hidden_dim=feature_size, out_dim=projection_dim)
+        self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.augment = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.2, 1.)),
+                T.RandomHorizontalFlip(),
+                T.RandomApply([T.ColorJitter(0.4, 0.4, 0.4, 0.1)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.Normalize(mean=mean, std=std)
+                ])
+        
+    def forward(self, x, y):
+        x1, x2 = self.augment(x), self.augment(x)
+        z1, z2 = self.encoder(x1), self.encoder(x2)
+        z = torch.cat([z1.unsqueeze(1), z2.unsqueeze(1)], dim=1)
+        loss = sup_con_loss(z, y, temperature=self.temperature)
+        return loss
+
+
+def sup_con_loss(features, labels=None, mask=None, temperature=0.07, contrast_mode='all', base_temperature=0.07):
+    """ 
+    Supervised Contrastive Loss. It also supports the unsupervised contrastive loss in SimCLR 
+    If both labels and mask are None, it degenerates to SimCLR unsupervised loss
+    """
+    device = features.device 
+    if len(features.shape) < 3:
+        raise ValueError('features needs to be [bsz, n_views, ...], at least 3 dimensions are required')
+    if len(features.shape) > 3:
+        features = features.view(features.shape[0], features.shape[1], -1)
+    if contrast_mode not in ['all', 'one']:
+        raise ValueError('Unknown mode: {}'.format(contrast_mode))
+    bz = features.shape[0]
+    if labels is not None and mask is not None:
+        raise ValueError('Cannot define both labels and mask')
+    elif labels is None and mask is None:
+        mask = torch.eye(bz, dtype=torch.float32).to(device)
+    elif labels is not None:
+        labels = labels.contiguous().view(-1, 1)
+        if labels.shape[0] != bz:
+            raise ValueError('Num of labels does not match num of features')
+        mask = torch.eq(labels, labels.T).float().to(device)
+    else:
+        mask = mask.float().to(device)
+    contrast_count = features.shape[1]
+    contrast_feature = torch.cat(torch.unbind(features, dim=1), dim=0)
+    if contrast_mode == 'one':
+        anchor_feature = features[:, 0]
+        anchor_count = 1
+    elif contrast_mode == 'all':
+        anchor_feature = contrast_feature
+        anchor_count = contrast_count
+    anchor_dot_contrast = torch.div(torch.matmul(anchor_feature, contrast_feature.T), temperature)
+    logits_max, _ = torch.max(anchor_dot_contrast, dim=1, keepdim=True)
+    logits = anchor_dot_contrast - logits_max.detach()
+    mask = mask.repeat(anchor_count, contrast_count)
+    logits_mask = torch.scatter(torch.ones_like(mask), 1, torch.arange(bz * anchor_count).view(-1, 1).to(device), 0)
+    mask = mask * logits_mask
+    exp_logits = torch.exp(logits) * logits_mask
+    log_prob = logits - torch.log(exp_logits.sum(1, keepdim=True))
+    mean_log_prob_pos = (mask * log_prob).sum(1) / mask.sum(1)
+    loss = - (temperature / base_temperature) * mean_log_prob_pos
+    loss = loss.view(anchor_count, bz)
+    return loss.mean()
+
+
+class Projector(nn.Module):
+    """ Projector for SupCon """
+    def __init__(self, in_dim, hidden_dim=None, out_dim=128):
+        super().__init__()
+        
+        if hidden_dim is None:
+            self.layer1 = nn.Linear(in_dim, out_dim)
+        else:
+            self.layer1 = nn.Sequential(
+                    nn.Linear(in_dim, hidden_dim),
+                    nn.ReLU(inplace=True),
+                    nn.Linear(hidden_dim, out_dim),
+                )
+    def forward(self, x):
+        x = self.layer1(x)
+        return x 
+    
+    
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = SupCon(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    y = torch.rand(4)
+    with torch.no_grad():
+        loss = model.forward(x, y)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/builders/swav.py

@@ -0,0 +1,179 @@
+# Copyright (C) 2023. All rights reserved.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from torch import nn
+import torch.nn.functional as F 
+import torchvision.transforms as T
+
+
+__all__ = ['SwAV']
+
+
+class SwAV(nn.Module):
+    """ 
+    SwAV: Unsupervised Learning of Visual Features by Contrasting Cluster Assignments
+    Link: https://arxiv.org/abs/2006.09882
+    Implementation: https://github.com/facebookresearch/swav
+    """
+    
+    def __init__(self, backbone, feature_size, projection_dim=128, hidden_dim=2048, temperature=0.1, epsilon=0.05, 
+                 sinkhorn_iterations=3, num_prototypes=3000, queue_length=64, use_the_queue=True, num_crops=6,
+                 image_size=224, mean=(0.5,), std=(0.229, 0.224, 0.225)):
+        super().__init__()
+        self.projection_dim = projection_dim
+        self.temperature = temperature
+        self.epsilon = epsilon
+        self.sinkhorn_iterations = sinkhorn_iterations
+        self.num_prototypes = num_prototypes
+        self.queue_length = queue_length
+        self.use_the_queue = use_the_queue
+        self.image_size = image_size
+        self.mean = mean
+        self.std = std
+        self.register_buffer("queue", torch.zeros(2, self.queue_length, self.projection_dim))
+        self.backbone = backbone
+        self.projector = Projector(feature_size, hidden_dim, projection_dim)
+        self.encoder = nn.Sequential(self.backbone, self.projector)
+        self.prototypes = nn.Linear(self.projection_dim, self.num_prototypes, bias=False)   
+        self._init_weights()
+        self.num_crops = num_crops
+        self.augment_global = T.Compose([
+                T.RandomResizedCrop(image_size, scale=(0.14, 1.0)),
+                T.RandomApply([T.ColorJitter(0.8, 0.8, 0.8, 0.2)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomHorizontalFlip(p=0.5),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.Normalize(mean=mean, std=std),
+                ])
+        self.augment_local = T.Compose([
+                T.RandomResizedCrop(int(image_size*3/7), scale=(0.05, 0.14)),
+                T.RandomHorizontalFlip(),
+                T.RandomApply([T.ColorJitter(0.8,0.8,0.8,0.2)], p=0.8),
+                T.RandomGrayscale(p=0.2),
+                T.RandomApply([T.GaussianBlur(kernel_size=image_size//20*2+1, sigma=(0.1, 2.0))], p=0.5),
+                T.Normalize(mean=mean, std=std),
+                ])
+        
+    def forward(self, x):
+        x1, x2 = self.augment_global(x), self.augment_global(x)
+        if self.num_crops >0:
+            xc = []
+            for _ in range(self.num_crops):
+                xc.append(self.augment_local(x))
+        bz = x1.shape[0]
+        with torch.no_grad(): # normalize prototypes
+            w = self.prototypes.weight.data.clone()
+            w = nn.functional.normalize(w, dim=1, p=2)
+            self.prototypes.weight.copy_(w)
+        z1, z2 = self.encoder(x1), self.encoder(x2)
+        z1, z2 = nn.functional.normalize(z1, dim=1, p=2), nn.functional.normalize(z2, dim=1, p=2)
+        z1, z2 = z1.detach(), z2.detach()
+        c1, c2 = self.prototypes(z1), self.prototypes(z2)    
+        _c1, _c2 = c1.detach(), c2.detach()
+        with torch.no_grad():
+            if self.queue is not None:
+                if self.use_the_queue:
+                    _c1 = torch.cat((torch.mm(self.queue[0], self.prototypes.weight.t()), _c1))
+                    _c2 = torch.cat((torch.mm(self.queue[1], self.prototypes.weight.t()), _c2))
+                    self.queue[0, bz:] = self.queue[0, :-bz].clone()
+                    self.queue[0, :bz] = z1
+                    self.queue[1, bz:] = self.queue[1, :-bz].clone()
+                    self.queue[1, :bz] = z2
+            q1, q2 = self.sinkhorn(_c1)[:bz, :], self.sinkhorn(_c2)[:bz, :]     
+        z_c, c_c = [], []
+        for x in xc:
+            z = self.encoder(x)
+            z = nn.functional.normalize(z, dim=1, p=2)
+            z = z.detach()
+            z_c.append(z)
+            c_c.append(self.prototypes(z))   
+        loss = swav_loss(c1, c2, c_c, q1, q2, self.temperature, 2+len(xc))
+        return loss 
+    
+    @torch.no_grad()
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+         
+    @torch.no_grad()
+    def freeze_prototypes(self):
+        for name, p in self.prototypes.named_parameters():
+            if "prototypes" in name:
+                p.grad = None
+                    
+    @torch.no_grad()
+    def sinkhorn(self, Q):
+        with torch.no_grad():
+            Q = torch.exp(Q / self.epsilon).t()
+            B = Q.shape[1]
+            K = Q.shape[0]
+            sum_Q = torch.sum(Q)
+            Q /= sum_Q
+            for _ in range(self.sinkhorn_iterations):
+                sum_of_rows = torch.sum(Q, dim=1, keepdim=True)
+                Q /= sum_of_rows
+                Q /= K
+                Q /= torch.sum(Q, dim=0, keepdim=True)
+                Q /= B
+            Q *= B
+            return Q.t()
+
+
+def cross_entropy_loss(q, p):
+    return torch.mean(torch.sum(q * F.log_softmax(p, dim=1), dim=1))
+
+
+def swav_loss(c1, c2, c_c, q1, q2, temperature, num_crops):
+    loss = 0
+    
+    p1, p2 = c1/temperature, c2/temperature
+    loss += cross_entropy_loss(q1, p2) / (num_crops - 1)
+    loss += cross_entropy_loss(q2, p1) / (num_crops - 1)
+    
+    for c in range(len(c_c)):
+        p = c_c[c] / temperature
+        loss += cross_entropy_loss(q1, p) / (num_crops - 1)
+        loss += cross_entropy_loss(q2, p) / (num_crops - 1)
+    
+    return loss/2 
+
+
+class Projector(nn.Module):
+    """ Projector for SwAV """
+    def __init__(self, in_dim, hidden_dim=2048, out_dim=128):
+        super().__init__()
+        
+        if hidden_dim is None:
+            self.layer1 = nn.Linear(in_dim, out_dim)
+        else:
+            self.layer1 = nn.Sequential(
+                    nn.Linear(in_dim, hidden_dim),
+                    nn.BatchNorm1d(hidden_dim),
+                    nn.ReLU(inplace=True),
+                    nn.Linear(hidden_dim, out_dim),
+                )
+    def forward(self, x):
+        x = self.layer1(x)
+        return x 
+    
+    
+if __name__ == '__main__':
+    import torchvision
+    backbone = torchvision.models.resnet50(pretrained=False)
+    feature_size = backbone.fc.in_features
+    backbone.fc = torch.nn.Identity()
+    
+    model = SwAV(backbone, feature_size)
+    
+    x = torch.rand(4, 3, 224, 224)
+    with torch.no_grad():
+        loss = model.forward(x)
+        print(f'loss = {loss}')

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/config/config.json

@@ -0,0 +1,22 @@
+{
+    "gpu": 0,
+    "experiment_path": "ssl_pretraining/ssl_pretraining_experiments",
+    "model": {
+        "name": "moco_v2",
+        "encoder": "resnet18",
+        "lr":1e-4,
+        "optimizer": "adamw",
+        "epochs": 20000
+    },
+    "dataset":{
+        "name": "hand",
+        "path": "datasets/",
+        "image_size": 256,
+        "image_channels": 3,
+        "batch_size": 4,
+        "grad_accumulation": 8,
+        "num_workers": null,
+        "pin_memory": true
+    }
+}
+

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/main.py

@@ -0,0 +1,350 @@
+import torch
+import numpy as np
+import torchvision
+from builders.moco import MoCo
+from builders.mocov2 import MoCoV2
+from builders.mocov3 import MoCoV3
+from builders.simclr import SimCLR
+from builders.simclrv2 import SimCLRv2
+from builders.dino import DINO
+from builders.byol import BYOL
+from builders.barlow_twins import BarlowTwins
+from segmentation_models_pytorch import Unet as smpUnet
+from utils import *
+from ssl_datasets import *
+import logging
+import os
+import sys
+from tqdm import tqdm
+import time
+import argparse
+import json
+import signal
+import sys
+import tempfile
+
+# Set random seed
+np.random.seed(42)
+torch.manual_seed(42) 
+torch.cuda.manual_seed(42)
+
+
+
+def safe_save(state, filename):
+    """
+    Safely save a model state to a file using atomic operations.
+    
+    Args:
+    state (dict): The state to be saved (usually containing model and optimizer states)
+    filename (str): The name of the file to save the state to
+    """
+    # Create a temporary file
+    temp_filename = None
+    try:
+        # Create a temporary file in the same directory as the target file
+        directory = os.path.dirname(filename)
+        with tempfile.NamedTemporaryFile(delete=False, dir=directory) as tmp_file:
+            temp_filename = tmp_file.name
+            # Save the state to the temporary file
+            torch.save(state, temp_filename)
+        
+        # If the save was successful, rename the temporary file to the target filename
+        # This operation is atomic on most Unix-like systems
+        os.replace(temp_filename, filename)
+        #print(f"Model safely saved to {filename}")
+    except Exception as e:
+        print(f"Error during safe save: {e}")
+        # If there was an error, remove the temporary file if it was created
+        if temp_filename and os.path.exists(temp_filename):
+            os.remove(temp_filename)
+
+# ------------------------------------------------------------------------
+#                               MAIN
+# ------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    # Parse arguments from command line
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c",
+        "--config",
+        type=str,
+        default="config/config.json",
+        help="Path to the JSON config file."
+    )
+
+    args = parser.parse_args()
+    config = json.load(open(args.config))
+
+    # Config params for training and testing the model
+    ROOT_PATH = config["experiment_path"]
+    DATASET_NAME = config["dataset"]["name"]
+    DATASET_PATH = os.path.join(config["dataset"]["path"], DATASET_NAME)
+    IMAGE_SIZE = config["dataset"]["image_size"]
+    IMAGE_CHANNELS = config["dataset"]["image_channels"]
+    BATCH_SIZE = config["dataset"]["batch_size"]
+    GRAD_ACCUMULATION = config["dataset"]["grad_accumulation"]
+    PIN_MEMORY = config["dataset"]["pin_memory"]
+    NUM_WORKERS = os.cpu_count() if config["dataset"]["num_workers"] == None else config["dataset"]["num_workers"]
+    
+    # SSL training params
+    LR = config["model"]["lr"]
+    EPOCHS = config["model"]["epochs"]
+    SSL_METHOD = config["model"]["name"]
+    BACKBONE_NAME = config["model"]["encoder"]
+    OPTIMIZER = config["model"]["optimizer"]
+    
+    # Load the dataset
+    train_dataloader, test_dataloader = load_data(DATASET_PATH, IMAGE_SIZE, IMAGE_CHANNELS, BATCH_SIZE, pin_memory=PIN_MEMORY, num_workers=NUM_WORKERS)
+
+    # Save model path and tensorboard writer and path for the experiment
+    PREFIX_PATH = f"{ROOT_PATH}/{DATASET_NAME}/size{IMAGE_SIZE}_ch{IMAGE_CHANNELS}"
+
+    # Create log file for the experiment
+    if not os.path.exists(f'{PREFIX_PATH}/models/{SSL_METHOD}/{BACKBONE_NAME}/log_file.txt'):
+        os.makedirs(f"{PREFIX_PATH}/models/{SSL_METHOD}/{BACKBONE_NAME}/", exist_ok=True)
+
+        with open(f'{PREFIX_PATH}/models/{SSL_METHOD}/{BACKBONE_NAME}/log_file.txt', 'w') as f:
+            pass     
+
+    save_model_path = generate_path(f"{PREFIX_PATH}/models/{SSL_METHOD}/{BACKBONE_NAME}")
+    logging.basicConfig(format="%(message)s", level=logging.INFO, filename=f'{PREFIX_PATH}/models/{SSL_METHOD}/{BACKBONE_NAME}/log_file.txt', filemode='a') # %(asctime)s 
+
+
+    print("----------------------------------------- SYSTEM INFO -----------------------------------------")
+    print("Python version: {}".format(sys.version))
+    print("Pytorch version: {}".format(torch.__version__))
+    
+    if "CUDA_VISIBLE_DEVICES" in os.environ:
+        GPU = os.environ["CUDA_VISIBLE_DEVICES"]
+    else:
+        GPU = config["gpu"]
+        os.environ["CUDA_VISIBLE_DEVICES"] = f"{GPU}"
+        
+    device = f"cuda" if torch.cuda.is_available() else "cpu"
+    print(f"Torch GPU Name: {torch.cuda.get_device_name(0)}... Using GPU {GPU}" if device == "cuda" else "Torch GPU not available... Using CPU")
+            
+    print("------------------------------------------------------------------------------------------------")
+
+    print("----------------------------------------- CONFIG INFO -----------------------------------------")
+    print(f"Dataset Name: {DATASET_NAME}")
+    print(f"Dataset Path: {DATASET_PATH}")
+    print(f"Image Size: ({IMAGE_SIZE}, {IMAGE_SIZE}, {IMAGE_CHANNELS})")
+    print(f"Batch Size: {BATCH_SIZE} with cumulation of {GRAD_ACCUMULATION}")
+    print(f"SSL Method: {SSL_METHOD}")
+    print(f"Epochs: {EPOCHS}")
+    print(f"Starting Learning Rate: {LR}")
+    print(f"Save Model Path: {save_model_path}")
+    print("------------------------------------------------------------------------------------------------")
+
+    print("----------------------------------------- START TRAINING -----------------------------------------")
+
+    # Initialize backbones for self-supervised learning method
+    if BACKBONE_NAME == "resnet18":
+        backbone = torchvision.models.resnet18(weights=None)
+        # Change the last layer of the backbone to Identity       
+        feature_size = backbone.fc.in_features
+        backbone.fc = torch.nn.Identity()
+    
+    elif BACKBONE_NAME == "resnet34":
+        backbone = torchvision.models.resnet34(weights=None)
+        feature_size = backbone.fc.in_features
+        backbone.fc = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "resnet50":
+        backbone = torchvision.models.resnet50(weights=None)
+        feature_size = backbone.fc.in_features
+        backbone.fc = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "resnet101":
+        backbone = torchvision.models.resnet101(weights=None)
+        feature_size = backbone.fc.in_features
+        backbone.fc = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "resnet152":
+        backbone = torchvision.models.resnet152(weights=None)
+        feature_size = backbone.fc.in_features
+        backbone.fc = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "resnext50_32x4d":
+        backbone = torchvision.models.resnext50_32x4d(weights=None)
+        feature_size = backbone.fc.in_features
+        backbone.fc = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "resnext101_32x8d":
+        backbone = torchvision.models.resnext101_32x8d(weights=None)
+        feature_size = backbone.fc.in_features
+        backbone.fc = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "vgg11":
+        backbone = torchvision.models.vgg11(weights=None)
+        feature_size = backbone.classifier[6].in_features
+        backbone.classifier[6] = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "vgg13":
+        backbone = torchvision.models.vgg13(weights=None)
+        feature_size = backbone.classifier[6].in_features
+        backbone.classifier[6] = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "vgg16":
+        backbone = torchvision.models.vgg16(weights=None)
+        feature_size = backbone.classifier[6].in_features
+        backbone.classifier[6] = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "vgg19":
+        backbone = torchvision.models.vgg19(weights=None)
+        feature_size = backbone.classifier[6].in_features
+        backbone.classifier[6] = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "densenet121":
+        backbone = torchvision.models.densenet121(weights=None)
+        feature_size = backbone.classifier.in_features
+        backbone.classifier = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "densenet169":
+        backbone = torchvision.models.densenet169(weights=None)
+        feature_size = backbone.classifier.in_features
+        backbone.classifier = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "densenet201":
+        backbone = torchvision.models.densenet201(weights=None)
+        feature_size = backbone.classifier.in_features
+        backbone.classifier = torch.nn.Identity()
+        
+    elif BACKBONE_NAME == "densenet161":
+        backbone = torchvision.models.densenet161(weights=None)
+        feature_size = backbone.classifier.in_features
+        backbone.classifier = torch.nn.Identity()
+    else:
+        raise ValueError(f"Unknown backbone: {BACKBONE_NAME}")
+
+
+    # Initialize ssl method model and optimizer
+    if SSL_METHOD == "moco":
+        model = MoCo(backbone, feature_size, projection_dim=128, K=65536, m=0.999, temperature=0.07, image_size=IMAGE_SIZE)
+    elif SSL_METHOD == "mocov2":
+        model = MoCoV2(backbone, feature_size, projection_dim=128, K=65536, m=0.999, temperature=0.07, image_size=IMAGE_SIZE)
+    elif SSL_METHOD == "mocov3":
+        model = MoCoV3(backbone, feature_size, projection_dim=256, hidden_dim=2048, temperature=0.5, m=0.999, image_size=IMAGE_SIZE)  
+              
+    elif SSL_METHOD == "simclr":
+        model = SimCLR(backbone, feature_size, projection_dim=128, temperature=0.5, image_size=IMAGE_SIZE)
+    elif SSL_METHOD == "simclrv2":
+        model = SimCLRv2(backbone, feature_size, projection_dim=128, temperature=0.5, image_size=IMAGE_SIZE)
+        
+    elif SSL_METHOD == "dino":
+        model = DINO(backbone, feature_size, projection_dim=256, hidden_dim=2048, bottleneck_dim=256, temp_s=0.1, temp_t=0.5, m=0.5, lamda=0.996, num_crops=6) # image_size=IMAGE_SIZE)
+    
+    elif SSL_METHOD == "byol":
+        model = BYOL(backbone, feature_size, projection_dim=256, hidden_dim=4096, tau=0.996, image_size=IMAGE_SIZE)
+        
+    elif SSL_METHOD == "barlow_twins":
+        model = BarlowTwins(backbone, feature_size, projection_dim=8192, hidden_dim=8192, lamda=0.005, image_size=IMAGE_SIZE)
+        
+    else:
+        raise ValueError(f"Unknown SSL method: {SSL_METHOD}")
+
+
+    model = model.to(device)
+    
+    if OPTIMIZER == "adam":
+        optimizer = torch.optim.Adam(model.parameters(), lr=LR)
+    elif OPTIMIZER == "adamw":
+        optimizer = torch.optim.AdamW(model.parameters(), lr=LR)
+    else:
+        raise ValueError(f"Unknown optimizer: {OPTIMIZER} - Choose either 'adam' or 'adamw'")
+    
+    
+    # Check if there are any saved models in the save_model_path
+    if os.path.exists(f'{save_model_path}/last_model.pth'):
+        
+        # Get the latest model weights
+        model_path = f'{save_model_path}/last_model.pth'
+        checkpoint = torch.load(model_path, map_location=device)    
+
+        # Load the model weights and optimizer state
+        model.load_state_dict(checkpoint['model_state_dict'])
+        optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+        starting_epoch = checkpoint['epoch']
+        n_iter = checkpoint['iteration']
+        print(f"Loading model weights from epoch {starting_epoch} and iteration {n_iter}") 
+        del checkpoint
+    else:
+        starting_epoch = 0
+        n_iter = 0
+        
+    # switch to train mode
+    model.train()
+
+    # train model
+    best_loss = float('inf')
+    early_stopping = 0
+    loss_margin = 0
+    epochs_losses = []
+    
+    start_time = time.time()
+    
+    try:
+        for epoch in tqdm(range(starting_epoch, EPOCHS), initial=starting_epoch, total=EPOCHS, desc="Epoch"):
+            epoch_loss = 0
+            
+            for batch_idx, data in enumerate(train_dataloader):
+                images = data['image'].to(device)
+                        
+                loss = model(images)
+                
+                loss.backward()
+                
+                if ((batch_idx + 1) % GRAD_ACCUMULATION == 0) or (batch_idx + 1 == len(train_dataloader)):
+                    optimizer.step()
+                    optimizer.zero_grad()
+                    n_iter += 1
+                    
+                    # Safely save the last model weights and optimizer state
+                    state = {
+                        'model_state_dict': model.state_dict(),
+                        'optimizer_state_dict': optimizer.state_dict(),
+                        'epoch': epoch,
+                        'iteration': n_iter
+                    }
+                    safe_save(state, f'{save_model_path}/last_model.pth')
+                    del state            
+
+                # Update iteration
+                loss = loss / GRAD_ACCUMULATION  # Normalize loss to account for batch accumulation
+                epoch_loss += loss.item()
+            
+                # Save resnet backbone model every 2k iterations
+                if n_iter % 2000 == 0 and n_iter!= 0 and batch_idx % GRAD_ACCUMULATION == 0:
+                    print(f"Saving model weights at epoch {epoch} and iteration {n_iter}")
+                    logging.info(f"\t\tEPOCH: {epoch} | ITER: {n_iter} | LOSS: {loss.item():.4f}")
+                    # Save the model weights and optimizer state
+                    torch.save(model.backbone.state_dict(), f'{save_model_path}/model_epoch{epoch}_iter{n_iter}.pth')
+                                    
+                    if n_iter % 20000 == 0:
+                        print(f"Reaching 20k iterations... exiting training of model {SSL_METHOD} with backbone {BACKBONE_NAME}")
+                        torch.save(model.backbone.state_dict(), f'{save_model_path}/model_epoch{epoch}_iter{n_iter}.pth')
+                        raise StopIteration
+            
+            # Average loss for the epoch
+            avg_loss = epoch_loss / len(train_dataloader)
+            epochs_losses.append(avg_loss)
+            
+            # Update tqdm description every 10 epochs
+            if epoch % 10 == 0:
+                tqdm.write(f"Epoch {epoch}, Iteration: {n_iter}, Loss: {avg_loss:.4f}")
+
+    # Catch keyboard interrupt, the StopIteration when reaching 20k iterations, and if the process is killed, and if there is any other exception
+    except (KeyboardInterrupt, StopIteration, SystemExit, Exception) as e:
+        print("\nTraining interrupted. Saving final state...")
+        state = {
+            'model_state_dict': model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'epoch': epoch,
+            'iteration': n_iter
+        }
+        safe_save(state, f'{save_model_path}/last_model.pth')
+        print(f"Final state saved in {save_model_path}/last_model.pth - Exiting...")
+
+    finally:
+        print(f"Training completed in {time.strftime('%H:%M:%S', time.gmtime(time.time() - start_time))}")

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/ssl_datasets.py

@@ -0,0 +1,205 @@
+
+
+
+# ------------------------------------------------------------------------
+#                               Libraries
+# ------------------------------------------------------------------------
+
+import os
+import numpy as np
+from PIL import Image
+from torch.utils.data import Dataset
+import albumentations as A
+import albumentations.pytorch
+
+
+
+# ------------------------------------------------------------------------
+#                               Chest Dataset
+# ------------------------------------------------------------------------
+
+# Load the dataset from the train and test folders in the root directory
+class ChestDataset(Dataset):
+    def __init__(self, root_dir, channels=1, transform=None, phase='train'):
+
+        self.root_dir = root_dir
+        self.transform = transform
+        self.channels = channels
+       
+        self.pth_Image = os.path.join(root_dir, 'pngs')
+            
+        # file index
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))]
+
+        exclude_list = ['CHNCXR_0059_0', 'CHNCXR_0178_0', 'CHNCXR_0228_0', 'CHNCXR_0267_0', 'CHNCXR_0295_0', 'CHNCXR_0310_0', 'CHNCXR_0285_0', 'CHNCXR_0276_0', 'CHNCXR_0303_0']
+        if exclude_list is not None:
+            st = set(exclude_list)
+            files = [f for f in files if f not in st]
+
+        n = len(files)
+        train_num = 195 
+        val_num = 34  
+        test_num = n - train_num - val_num
+        if phase == 'train':
+            self.image_files = files[:train_num+val_num]
+        elif phase == 'test':
+            self.image_files = files[-test_num:]
+        elif phase == 'all':
+            self.image_files = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+        
+
+    def __len__(self):
+        return len(self.image_files)
+    
+    def __getitem__(self, idx):
+        image_name = self.image_files[idx]
+
+        image = self.read_image(os.path.join(self.pth_Image, image_name + '.png'))
+
+        data_dict = {'name': image_name, 'image': image}   
+
+        return data_dict
+
+    def read_image(self, image_path):
+
+        if self.channels == 3:
+            image = Image.open(image_path).convert('RGB')
+            image_np = np.array(image).astype(np.float32)
+
+        elif self.channels == 1:
+            image = Image.open(image_path).convert('L')
+            image_np = np.array(image).astype(np.float32)
+            image_np = np.expand_dims(image_np, axis=2) # add channel dimension
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+        
+        if self.transform:
+            image = self.transform(image=image_np)['image']
+
+        return image
+        
+    
+# ------------------------------------------------------------------------
+#                               HAND Dataset
+# ------------------------------------------------------------------------
+
+# Load the dataset from the train and test folders in the root directory
+class HandDataset(Dataset):
+    def __init__(self, root_dir, channels=1, transform=None, phase='train'):
+
+        self.root_dir = root_dir
+        self.transform = transform
+        self.channels = channels
+       
+        self.pth_Image = os.path.join(root_dir, 'jpg')
+            
+        # file index
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))]
+
+        n = len(files)
+        train_num = 550
+        val_num = 59
+        test_num = n - train_num - val_num
+        if phase == 'train':
+            self.image_files = files[:train_num+val_num]
+        elif phase == 'test':
+            self.image_files = files[-test_num:]
+        elif phase == 'all':
+            self.image_files = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+        
+
+    def __len__(self):
+        return len(self.image_files)
+    
+    def __getitem__(self, idx):
+        image_name = self.image_files[idx]
+
+        image = self.read_image(os.path.join(self.pth_Image, image_name + '.jpg'))
+
+        data_dict = {'name': image_name, 'image': image}   
+
+        return data_dict
+
+    def read_image(self, image_path):
+
+        if self.channels == 3:
+            image = Image.open(image_path).convert('RGB')
+            image_np = np.array(image).astype(np.float32)
+
+        elif self.channels == 1:
+            image = Image.open(image_path).convert('L')
+            image_np = np.array(image).astype(np.float32)
+            image_np = np.expand_dims(image_np, axis=2)
+        else:
+            raise ValueError('Channels must be either 1 or 3')
+        
+        if self.transform:
+            image = self.transform(image=image_np)['image']
+            
+        return image
+
+
+# ------------------------------------------------------------------------
+#                               CEPH Dataset
+# ------------------------------------------------------------------------
+
+class CephaloDataset(Dataset):
+    def __init__(self, root_dir, channels=1, transform=None, phase='train'):
+        self.root_dir = root_dir
+        self.transform = transform
+        self.channels = channels
+       
+        self.pth_Image = os.path.join(root_dir, 'jpg')
+            
+        # file index
+        files = [i[:-4] for i in sorted(os.listdir(self.pth_Image))]
+
+        n = len(files)
+        train_num = 130
+        val_num = 20
+        test_num = n - train_num - val_num
+        
+        if phase == 'train':
+            self.image_files = files[:train_num+val_num]
+        elif phase == 'test':
+            self.image_files = files[-test_num:]
+        elif phase == 'all':
+            self.image_files = files
+        else:
+            raise Exception("Unknown phase: {phase}".format(phase=phase))
+
+    def __len__(self):
+        return len(self.image_files)
+    
+    def __getitem__(self, idx):
+        image_name = self.image_files[idx]
+
+        image = self.read_image(os.path.join(self.pth_Image, image_name + '.jpg'))
+
+        data_dict = {'name': image_name, 'image': image}   
+
+        return data_dict
+    
+    def read_image(self, image_path):
+            
+            if self.channels == 3:
+                image = Image.open(image_path).convert('RGB')
+                image_np = np.array(image).astype(np.float32)
+    
+            elif self.channels == 1:
+                image = Image.open(image_path).convert('L')
+                image_np = np.array(image).astype(np.float32)
+                image_np = np.expand_dims(image_np, axis=2)
+            else:
+                raise ValueError('Channels must be either 1 or 3')
+            
+            if self.transform:
+                image = self.transform(image=image_np)['image']
+                
+            return image
+        
+        

DiffusionXray-FewShot-LandmarkDetection/ssl_pretraining/utils.py

@@ -0,0 +1,174 @@
+
+# ------------------------------------------------------------------------
+#                               Libraries
+# ------------------------------------------------------------------------
+
+# General libraries
+import os
+import cv2
+from matplotlib import pyplot as plt
+from prettytable import PrettyTable
+
+# Deep learning libraries
+import torch
+import torchvision
+from torch.utils.data import DataLoader
+import albumentations as A
+
+# Custom libraries
+from ssl_datasets import ChestDataset, HandDataset, CephaloDataset
+
+# ------------------------------------------------------------------------
+#                               Logging and Utilities
+# ------------------------------------------------------------------------
+
+# Generate path if it does not exist
+def generate_path(path):
+    if not os.path.exists(path):
+        os.makedirs(path)
+    return path
+
+# Get the current GPU memory usage by tensors in megabytes for a given device
+def gpu_memory_usage(device):
+    allocated = torch.cuda.memory_allocated(device)
+    reserved = torch.cuda.memory_reserved(device)
+    print(f'Allocated memory: {allocated / (1024 ** 2):.2f} MB')
+    print(f'Reserved memory: {reserved / (1024 ** 2):.2f} MB')
+
+# Compute the number of trainable parameters in a model
+def count_parameters(model):
+    table = PrettyTable(["Modules", "Parameters"])
+    total_params = 0
+    for name, parameter in model.named_parameters():
+        if not parameter.requires_grad:
+            continue
+        params = parameter.numel()
+        table.add_row([name, params])
+        total_params += params
+    #print(table)
+    print(f"Total Trainable Params: {total_params}")
+    return table, total_params
+
+# ------------------------------------------------------------------------
+#                               Visualizations
+# ------------------------------------------------------------------------
+   
+def plot_images(images):
+    plt.figure(figsize=(32, 32))
+    plt.imshow(torch.cat([
+        torch.cat([i for i in images.cpu()], dim=-1),
+    ], dim=-2).permute(1, 2, 0).cpu())
+    plt.show()
+
+
+def save_images(images, path, **kwargs):
+
+    x_grid = torchvision.utils.make_grid(images[0], **kwargs)
+    x_hat_grid = torchvision.utils.make_grid(images[1], **kwargs)
+    diff_grid = torchvision.utils.make_grid(images[2], **kwargs)
+
+    # Apply 'viridis' colormap to the difference image
+    #diff_grid = cm.viridis(diff_grid.detach().cpu().numpy())
+
+    grid = torch.cat((x_grid, x_hat_grid, diff_grid), dim=1)
+    ndarr = grid.permute(1, 2, 0).to('cpu').numpy()
+    
+    plt.figure(figsize=(10, 10))
+    plt.imshow(ndarr)
+    plt.axis('off')
+    plt.savefig(path, bbox_inches='tight')
+    plt.close()
+
+def check_pixels_range_of_image(tensor):
+    # Ensure the input is a tensor
+    assert torch.is_tensor(tensor), "Input must be a tensor"
+
+    # Flatten the tensor to get all pixel values
+    pixel_values = tensor.view(-1)
+
+    # Compute min and max values
+    min_val = pixel_values.min().item()
+    max_val = pixel_values.max().item()
+
+    #print(f"The range of pixel values is: {min_val} to {max_val}")
+    return min_val, max_val
+
+
+def compute_diff(x, x_hat):
+    # Ensure both tensors are on the same device
+    assert x.device == x_hat.device, "Tensors must be on the same device"
+    
+    # Ensure both tensors have the same shape
+    assert x.shape == x_hat.shape, "Tensors must have the same shape"
+    
+    x_min, x_max = check_pixels_range_of_image(x)
+    x_hat_min, x_hat_max = check_pixels_range_of_image(x_hat)
+
+    # Ensure both tensors are have pixel values in the range [0, 1]
+    #assert x_min >= 0 and x_max <= 1, f"Pixel values of x must be in the range [0, 1]. Actual range: [{x_min}, {x_max}]"
+    #assert x_hat_min >= 0 and x_hat_max <= 1, f"Pixel values of x_hat must be in the range [0, 1]. Actual range: [{x_hat_min}, {x_hat_max}]"
+    #print(f"Pixel values of x are in the range [{x_min}, {x_max}]")
+    #print(f"Pixel values of x_hat are in the range [{x_hat_min}, {x_hat_max}]")
+    # Compute absolute difference
+    diff = torch.abs(x - x_hat)
+    
+    # Normalize to the range [0, 1] and return the difference image
+    diff = (diff - diff.min()) / (diff.max() - diff.min())  
+
+    return diff
+
+
+# ------------------------------------------------------------------------
+#                               Data Loading and Preprocessing
+# ------------------------------------------------------------------------
+
+def get_transforms(image_size, phase='train'):
+    resize_image_size = int(image_size*1.02)
+    if phase == 'train':
+        return A.Compose([
+        #A.ShiftScaleRotate(shift_limit=0.02, scale_limit=0, rotate_limit=2, border_mode=cv2.BORDER_REPLICATE, p=0.5),
+        #A.Perspective(scale=(0, 0.02), pad_mode=cv2.BORDER_REPLICATE, p=0.5),
+        A.Resize(image_size, image_size),
+        #A.RandomCrop(height=image_size, width=image_size),
+        #A.HorizontalFlip(p=1),
+        #A.RandomBrightnessContrast(brightness_limit=(-0.1, 0.1), contrast_limit=(-0.2, 0.2), p=0.5),
+        A.Normalize(normalization='min_max'),
+        A.pytorch.ToTensorV2()
+    ])
+
+    elif phase == 'test':
+        return A.Compose([
+        A.Resize(image_size, image_size),
+        A.Normalize(normalization='min_max'),
+        A.pytorch.transforms.ToTensorV2()
+        ])
+    else:
+        raise ValueError('phase must be either "train" or "test"')
+
+
+def load_data(dataset_path, image_size, image_channels, batch_size, pin_memory=False, num_workers = os.cpu_count()):    
+    dataset_name = os.path.basename(dataset_path)
+    
+    transforms_train = get_transforms(image_size, phase='train')
+    transforms_test = get_transforms(image_size, phase='test')
+    
+    if dataset_name == 'chest':
+        train_dataset = ChestDataset(dataset_path, channels=image_channels, transform=transforms_train, phase='train')
+        test_dataset = ChestDataset(dataset_path, channels=image_channels, transform=transforms_test, phase='test')
+    elif dataset_name == 'hand':
+        train_dataset = HandDataset(dataset_path, channels=image_channels, transform=transforms_train, phase='train')
+        test_dataset = HandDataset(dataset_path, channels=image_channels, transform=transforms_test, phase='test')
+    elif dataset_name == 'cephalo':
+        train_dataset = CephaloDataset(dataset_path, channels=image_channels, transform=transforms_train, phase='train')
+        test_dataset = CephaloDataset(dataset_path, channels=image_channels, transform=transforms_test, phase='test')
+    else:
+        raise ValueError('Dataset name must be either "chest" or "hand" or "cephalo"')
+    
+    train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=pin_memory, drop_last=True)
+    test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=pin_memory, drop_last=False)
+    
+    return train_dataloader, test_dataloader
+
+
+
+