Upload folder using huggingface_hub

AAAI2025-FC/.gitignore

@@ -0,0 +1,14 @@
+data
+__pycache__
+.vscode
+*.model
+wandb/
+output/
+pretrained_weights/
+*.pkl
+*.pyc
+playground/
+*.pth
+pre_calculated_logits/
+output/
+paper-figure

AAAI2025-FC/README.md

@@ -0,0 +1,30 @@
+# Feature Clipping
+### Pretrained models
+
+All logits and features and extracted from the following models:
+
+- CIFAR10 (from [focal loss calibration](https://github.com/torrvision/focal_calibration?tab=readme-ov-file))
+  - [Resnet-50](https://www.robots.ox.ac.uk/~viveka/focal_calibration/CIFAR10/resnet50_cross_entropy_350.model)
+  - [Resnet-110](https://www.robots.ox.ac.uk/~viveka/focal_calibration/CIFAR10/resnet110_cross_entropy_350.model)
+  - [DenseNet-121](https://www.robots.ox.ac.uk/~viveka/focal_calibration/CIFAR10/densenet121_cross_entropy_350.model)
+- CIFAR100 (from [focal loss calibration](https://github.com/torrvision/focal_calibration?tab=readme-ov-file))
+  - [Resnet-50](https://www.robots.ox.ac.uk/~viveka/focal_calibration/CIFAR100/resnet50_cross_entropy_350.model)
+  - [Resnet-110](https://www.robots.ox.ac.uk/~viveka/focal_calibration/CIFAR100/resnet110_cross_entropy_350.model)
+  - [DenseNet-121](https://www.robots.ox.ac.uk/~viveka/focal_calibration/CIFAR100/densenet121_cross_entropy_350.model)
+- IMAGENET (from [pytorch's torchvision.models](https://pytorch.org/vision/main/models.html))
+  - Resnet-50: torchvision.models.resnet50(weights=torchvision.models.ResNet50_Weights.IMAGENET1K_V1)
+  - DenseNet-121: torchvision.models.densenet121(weights=torchvision.models.DenseNet121_Weights.IMAGENET1K_V1)
+  - Wide-Resnet-50: torchvision.models.wide_resnet50_2(weights=torchvision.models.Wide_ResNet50_2_Weights.IMAGENET1K_V1)
+  - MobileNet-V2: torchvision.models.mobilenet_v2(weights=torchvision.models.MobileNet_V2_Weights.IMAGENET1K_V1)
+  - ViT-L-16: torchvision.models.vit_l_16(weights=torchvision.models.ViT_L_16_Weights.IMAGENET1K_V1)
+
+### Dependencies
+`conda create -n feature-clipping python=3.10`
+
+`python -m pip install -r requirements.txt`
+
+### Evalutation
+
+run `bash evaluate_scripts_post_hoc.sh` to evaluate post hoc methods
+
+run `bash evaluate_scripts_train-time.sh` to evaluate train time methods

AAAI2025-FC/calibration/__init__.py

@@ -0,0 +1 @@
+from . import *

AAAI2025-FC/calibration/feature_clipping.py

@@ -0,0 +1,66 @@
+'''
+Code to perform feature clipping. Adapted from https://github.com/gpleiss/temperature_scaling
+'''
+import torch
+import numpy as np
+from torch import nn, optim
+from torch.nn import functional as F
+
+from metrics.metrics import ECELoss
+    
+# implemented as a post hoc calibrator
+class FeatureClippingCalibrator(nn.Module):
+    def __init__(self, model, cross_validate='ece'):
+        super(FeatureClippingCalibrator, self).__init__()
+        self.cross_validate = cross_validate
+        self.feature_clip = float("inf")
+        self.ece_criterion = ECELoss().cuda()
+        self.nll_criterion = nn.CrossEntropyLoss().cuda()
+        self.model = model
+        self.classifier = self.model.classifier
+
+    def get_feature_clip(self):
+        return self.feature_clip
+    
+    def set_feature_clip(self, features_val, logits_val, labels_val):
+        nll_val_opt = float("inf")
+        ece_val_opt = float("inf")
+        C_opt_nll = float("inf")
+        C_opt_ece = float("inf")
+        self.feature_clip = float("inf")
+        
+        before_clipping_acc = (F.softmax(logits_val, dim=1).argmax(dim=1) == labels_val).float().mean().item()
+        
+        C = 0.01
+        for _ in range(2000):
+            logits_after_clipping = self.classifier(self.feature_clipping(features_val, C))
+            after_clipping_nll = self.nll_criterion(logits_after_clipping, labels_val).item()
+            after_clipping_ece = self.ece_criterion(logits_after_clipping, labels_val).item()
+            after_clipping_acc = (F.softmax(logits_after_clipping, dim=1).argmax(dim=1) == labels_val).float().mean().item()
+            if (after_clipping_nll < nll_val_opt) and (after_clipping_acc > before_clipping_acc*0.99):
+                C_opt_nll = C
+                nll_val_opt = after_clipping_nll
+
+            if (after_clipping_ece < ece_val_opt) and (after_clipping_acc > before_clipping_acc*0.99):
+                C_opt_ece = C
+                ece_val_opt = after_clipping_ece
+
+            C += 0.01
+
+        if self.cross_validate == 'ece':
+            self.feature_clip = C_opt_ece
+        elif self.cross_validate == 'nll':
+            self.feature_clip = C_opt_nll
+
+        return self.feature_clip
+    
+    def feature_clipping(self, features, c=None):
+        """
+        Perform feature clipping on logits
+        """
+
+        return torch.clamp(features, min=-c, max=c)
+    
+
+    def forward(self, features, c=None):
+        return self.classifier(self.feature_clipping(features, c))

AAAI2025-FC/calibration/group_calibration/conf/main.yaml

@@ -0,0 +1,3 @@
+data: ???
+method: ???
+seeds: [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99]

AAAI2025-FC/calibration/group_calibration/conf/method/ets.yaml

@@ -0,0 +1,2 @@
+name: ets
+train_set: test_train

AAAI2025-FC/calibration/group_calibration/conf/method/group_calibration_combine_ets.yaml

@@ -0,0 +1,16 @@
+name: group_calibration_combine_ets
+num_groups: 2
+num_partitions: 20
+train_set: test_train
+
+w_net:
+  model: linear
+  weight_decay: 1e-1
+
+optimizer:
+  name: lbfgs
+  lr: 1e-3
+  steps: 100
+
+base_calibrator:
+  name: ets

AAAI2025-FC/calibration/group_calibration/conf/method/group_calibration_combine_ts.yaml

@@ -0,0 +1,16 @@
+name: group_calibration_combine_ts
+num_groups: 2
+num_partitions: 20
+train_set: test_train
+
+w_net:
+  model: linear
+  weight_decay: 1e-1
+
+optimizer:
+  name: lbfgs
+  lr: 1e-3
+  steps: 100
+
+base_calibrator:
+  name: temp_scaling

AAAI2025-FC/calibration/group_calibration/conf/method/histogram_binning.yaml

@@ -0,0 +1,2 @@
+name: histogram_binning
+train_set: test_train

AAAI2025-FC/calibration/group_calibration/conf/method/isotonic_regression.yaml

@@ -0,0 +1,2 @@
+name: isotonic_regression
+train_set: test_train

AAAI2025-FC/calibration/group_calibration/conf/method/none.yaml

@@ -0,0 +1 @@
+name: none

AAAI2025-FC/calibration/group_calibration/conf/method/temp_scaling.yaml

@@ -0,0 +1,2 @@
+name: temp_scaling
+train_set: test_train

AAAI2025-FC/calibration/group_calibration/data.py

@@ -0,0 +1,34 @@
+import torch
+import pickle
+import logging
+
+from utils import RandomSplitter
+
+def load_data(data_config,
+              test_splits=(0.1, 0.9),
+              seed=None):
+    with open(data_config.val_path, "rb") as f:
+        val_data = pickle.load(f)
+
+    with open(data_config.test_path, "rb") as f:
+        test_data = pickle.load(f)
+
+    val_acc = (torch.argmax(val_data["logits"], dim=1)
+               == val_data["labels"]).float().mean().item()
+    test_acc = (torch.argmax(test_data["logits"], dim=1)
+                == test_data["labels"]).float().mean().item()
+    logging.info("Dataset: val_acc: {:.4f}, test_acc: {:.4f}".format(val_acc, test_acc))
+
+    test_splitter = RandomSplitter(splits=test_splits,
+                                   num=test_data["logits"].shape[0],
+                                   seed=seed)
+    test_train_data, test_test_data = {}, {}
+    test_train_data["logits"], test_test_data["logits"] = test_splitter.split(
+        test_data["logits"])
+    test_train_data["labels"], test_test_data["labels"] = test_splitter.split(
+        test_data["labels"]
+    )
+    test_train_data["features"], test_test_data["features"] = test_splitter.split(
+        test_data["features"]
+    )
+    return val_data, test_train_data, test_test_data

AAAI2025-FC/calibration/group_calibration/evaluate.py

@@ -0,0 +1,28 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+import torchmetrics.functional as tmF
+
+def evaluate(y, num_classes, n_bins=15, pred_prob=None, pred_logits=None):
+    if pred_logits is not None:
+        pred_logits = pred_logits.contiguous()
+    if pred_prob is None:
+        pred_prob = torch.softmax(pred_logits, dim=1)
+    ece_multiclass = tmF.calibration_error(pred_prob,
+                                           y,
+                                           task="multiclass",
+                                           n_bins=n_bins,
+                                           num_classes=num_classes)
+    if pred_logits is not None:
+        nll = F.cross_entropy(pred_logits, y).item()
+    else:
+        nll = -torch.mean(torch.sum(torch.log(pred_prob + 1e-10)
+                                    * F.one_hot(y, num_classes=num_classes), dim=1)).item()
+    pred_labels = torch.argmax(pred_prob, dim=1)
+    acc = (pred_labels == y).float().mean().item()
+    results = {
+        "ece_m": ece_multiclass.item(),
+        "nll": nll,
+        "acc": acc,
+    }
+    return results

AAAI2025-FC/calibration/group_calibration/main.py

@@ -0,0 +1,52 @@
+import hydra
+from omegaconf import DictConfig, OmegaConf
+import logging
+import time
+
+from data import load_data
+from utils import set_seed, gather_metrics
+from methods import calibrate
+from evaluate import evaluate
+
+def _main(cfg):
+    logging.info("config: {}\n===========\n".format(OmegaConf.to_yaml(cfg)))
+    seeds = cfg.seeds
+
+    start_time = time.time()
+    metrics = []
+    for seed in seeds:
+        logging.info("Running seed: {}".format(seed))
+        
+                
+        val_data, test_train_data, test_test_data = load_data(data_config=cfg.data,
+                                                            seed=seed)
+        set_seed(seed)
+        
+        calibrated_test_test = calibrate(method_config=cfg.method,
+                                        val_data=val_data,
+                                        test_train_data=test_train_data,
+                                        test_test_data=test_test_data,
+                                        seed=seed,
+                                        cfg=cfg)
+        
+        _metrics = evaluate(y=test_test_data["labels"],
+                            num_classes=test_test_data["logits"].shape[1],
+                            n_bins=15,
+                            pred_logits=calibrated_test_test.get(
+            "logits", None),
+            pred_prob=calibrated_test_test.get("prob", None)
+        )
+        logging.info("Metrics: {}".format(_metrics))
+        _results = (seed, _metrics)
+            
+        metrics.append(_results)
+    metric_stats, metrics = gather_metrics(metrics)
+    logging.info("Metrics stats: {}".format(metric_stats))
+
+
+@hydra.main(version_base=None, config_path="conf", config_name="main")
+def main(cfg: DictConfig) -> None:
+    _main(cfg)
+
+if __name__ == "__main__":
+    main()

AAAI2025-FC/calibration/group_calibration/methods/__init__.py

@@ -0,0 +1,68 @@
+import functools
+
+import torch
+import calibration.group_calibration.methods.temp_scaling as temp_scaling
+import calibration.group_calibration.methods.group_calibration as group_calibration
+import calibration.group_calibration.methods.nn_calibration as nn_calibration
+import calibration.group_calibration.methods.mix_calibration as mix_calibration
+
+
+def get_calibrate_fn(method_config):
+    if method_config.name in ["temp_scaling"]:
+        return temp_scaling.calibrate
+    elif method_config.name in ["histogram_binning",
+                                "isotonic_regression"]:
+        return nn_calibration.calibrate
+    elif method_config.name in ["ets"]:
+        return mix_calibration.calibrate
+    else:
+        raise ValueError("config_name {} not found".format(method_config.name))
+
+
+def calibrate(method_config,
+              val_data,
+              test_train_data,
+              test_test_data,
+              seed,
+              cfg):
+    if method_config.name == "none":
+        return {
+            "logits": test_test_data["logits"]
+        }
+
+    train_set = method_config.get("train_set", "test_train")
+    if train_set == "val":
+        train_logits = val_data["logits"]
+        train_labels = val_data["labels"]
+    elif train_set == "test_train":
+        train_logits = test_train_data["logits"]
+        train_labels = test_train_data["labels"]
+    else:
+        assert train_set == "val+test_train"
+        train_logits = torch.cat(
+            [val_data["logits"], test_train_data["logits"]], dim=0)
+        train_labels = torch.cat(
+            [val_data["labels"], test_train_data["labels"]], dim=0)
+
+    test_test_logits = test_test_data["logits"]
+
+    if "group_calibration_combine" in method_config.name:
+        return group_calibration.calibrate_combine(val_features=val_data["features"],
+                                                           val_logits=val_data["logits"],
+                                                           val_labels=val_data["labels"],
+                                                           test_train_features=test_train_data["features"],
+                                                           test_train_logits=test_train_data["logits"],
+                                                           test_train_labels=test_train_data["labels"],
+                                                           test_test_features=test_test_data["features"],
+                                                           test_test_logits=test_test_data["logits"],
+                                                           base_calibrate_fn=get_calibrate_fn(
+                                                               method_config=method_config.base_calibrator),
+                                                           method_config=method_config,
+                                                           seed=seed,
+                                                           cfg=cfg)
+    else:
+        calibrate_fn = get_calibrate_fn(method_config=method_config)
+        return calibrate_fn(method_name=method_config.name,
+                            train_logits=train_logits,
+                            train_labels=train_labels,
+                            test_logits=test_test_logits)

AAAI2025-FC/calibration/group_calibration/methods/group_calibration.py

@@ -0,0 +1,212 @@
+import torch
+import torch.nn.functional as F
+
+from tqdm import tqdm
+
+class WNet(torch.nn.Module):
+
+    def __init__(self, feature_dim, num_groups):
+        super().__init__()
+        self.feature_dim = feature_dim
+        self.num_groups = num_groups
+
+        self.model = torch.nn.Sequential(
+            torch.nn.Linear(feature_dim, num_groups, bias=False),
+        ).cuda()
+
+    def forward(self, x):
+        x = self.model(x)
+        return x
+
+
+def calibrate_with_tau_and_w_logits(logits,
+                                    features,
+                                    tau,
+                                    hard,
+                                    w_net=None,
+                                    w_logits=None):
+    assert (w_logits is not None) != (w_net is not None)
+    
+ 
+    N, num_classes = logits.shape
+    if hard:
+        num_groups = w_net.num_groups
+        group_log_softmax = torch.log_softmax(
+            w_net(features), dim=1)
+        group_argmax = torch.argmax(group_log_softmax, dim=1)
+        group_hard_prob = F.one_hot(
+            group_argmax, num_classes=num_groups).view((N, num_groups, 1))
+        group_hard_prob = group_hard_prob.expand((N, num_groups, num_classes))
+
+        temp_logits = logits.view((N, 1, num_classes)) / \
+            tau.view((1, num_groups, 1))
+        temp_log_softmax = torch.log_softmax(temp_logits, dim=2)
+        calibrated_logits = torch.sum(
+            temp_log_softmax * group_hard_prob, dim=1)
+        return calibrated_logits
+    else:
+
+        if w_logits is not None:
+            num_groups = w_logits.shape[1]
+            group_log_softmax = torch.log_softmax(
+                w_logits, dim=1).view((N, num_groups, 1))
+        else:
+            num_groups = w_net.num_groups
+            group_log_softmax = torch.log_softmax(
+                w_net(features), dim=1).view((N, num_groups, 1))
+
+        group_log_softmax = group_log_softmax.expand(
+            (N, num_groups, num_classes))
+        temp_logits = logits.view((N, 1, num_classes)) / \
+            tau.view((1, num_groups, 1))
+        temp_log_softmax = torch.log_softmax(temp_logits, dim=2)
+        calibrated_logits = torch.logsumexp(group_log_softmax +
+                                            temp_log_softmax, dim=1)
+        return calibrated_logits
+
+
+def optimize_group_fn(
+        features,
+        logits,
+        labels,
+        w_net,
+        hard_group,
+        method_config):
+
+    if isinstance(w_net, str):
+        train_w = True
+        assert isinstance(method_config.num_groups, int)
+        w_net = WNet(feature_dim=features.shape[1],
+                     num_groups=method_config.num_groups)
+    else:
+        train_w = False
+        assert isinstance(w_net, torch.nn.Module)
+
+    tau = torch.nn.Parameter(torch.tensor(
+        [1.5] * method_config.num_groups, 
+        requires_grad=True, device=features.device))
+
+    if train_w:
+        params = [tau] + list(w_net.parameters())
+    else:
+        params = [tau]
+
+    if method_config.optimizer.name == "lbfgs" or not train_w:
+        optimizer = torch.optim.LBFGS(params,
+                                      line_search_fn="strong_wolfe",
+                                      max_iter=method_config.optimizer.steps)
+    else:
+        raise ValueError(method_config.optimizer)
+
+    W_gpu = w_net.to(features.device)
+
+    def closure():
+        optimizer.zero_grad()
+        
+        # Calculate weight decay loss
+        reg_weight_decay = 0
+        for name, param in W_gpu.named_parameters():
+            if "weight" in name:
+                reg_weight_decay += torch.mean((param)**2)
+        reg_weight_decay_loss = reg_weight_decay * method_config.w_net.weight_decay
+
+        # Calculate NLL loss
+        calibrated_logits = calibrate_with_tau_and_w_logits(
+            logits=logits,
+            features=features,
+            tau=tau,
+            w_net=W_gpu,
+            hard=hard_group
+        )
+
+        main_loss = F.cross_entropy(calibrated_logits, labels)
+
+        # Gather all loss
+        _loss = main_loss + reg_weight_decay_loss
+
+        _loss.backward()
+        return _loss
+
+    optimizer.step(closure=closure)
+            
+    return tau.detach().cpu(), w_net.cpu()
+
+
+def train_partitions(features,
+                     logits,
+                     labels,
+                     w_net,
+                     method_config):
+    w_net_list = []
+    # print("Generating partitions...")
+    for partition_i in range(method_config.num_partitions):
+        trained_tau, trained_w_net = optimize_group_fn(features.to("cuda:0"),
+                                                       logits.to("cuda:0"),
+                                                       labels.to("cuda:0"),
+                                                       hard_group=False,
+                                                       w_net=w_net,
+                                                       method_config=method_config)
+        w_net_list.append(trained_w_net)
+    return w_net_list
+
+
+def calibrate_combine(val_features,
+                      val_logits,
+                      val_labels,
+                      test_train_features,
+                      test_train_logits,
+                      test_train_labels,
+                      test_test_features,
+                      test_test_logits,
+                      method_config,
+                      base_calibrate_fn,
+                      seed,
+                      cfg,
+                      *args, **kwargs):
+    
+    w_net_list = train_partitions(val_features,
+                                val_logits,
+                                val_labels,
+                                w_net=method_config.w_net.model,
+                                method_config=method_config)
+    
+    calibrated_probs = []
+    # print("Calibrating with partitions...")
+    for trained_w_net in w_net_list:
+
+        train_group_logits = trained_w_net(test_train_features)
+        test_group_logits = trained_w_net(test_test_features)
+        # Hard group
+        train_groups_id = torch.argmax(
+            train_group_logits, dim=1)
+        test_groups_id = torch.argmax(
+            test_group_logits, dim=1)
+
+        _calibrated_probs = torch.zeros_like(test_test_logits)
+        for _g in range(method_config.num_groups):
+            train_group_mask = train_groups_id == _g
+            test_group_mask = test_groups_id == _g
+            group_train_logits = test_train_logits[train_group_mask]
+            group_train_labels = test_train_labels[train_group_mask]
+
+            group_test_logits = test_test_logits[test_group_mask]
+
+            _group_calibrated_results = base_calibrate_fn(
+                method_name=method_config.base_calibrator.name,
+                train_logits=group_train_logits,
+                train_labels=group_train_labels,
+                test_logits=group_test_logits
+            )
+            if "prob" in _group_calibrated_results:
+                _group_calibrated_prob = _group_calibrated_results["prob"]
+            else:
+                _group_calibrated_prob = torch.softmax(_group_calibrated_results["logits"],
+                                                        dim=1)
+            _calibrated_probs[test_group_mask] = _group_calibrated_prob
+
+        calibrated_probs.append(_calibrated_probs.detach())
+    calibrated_probs = torch.stack(calibrated_probs, dim=0).mean(0)
+
+    return {
+        "prob": calibrated_probs
+    }

AAAI2025-FC/calibration/group_calibration/methods/mix_calibration.py

@@ -0,0 +1,190 @@
+import numpy as np
+import torch
+from scipy import optimize
+from sklearn.isotonic import IsotonicRegression
+from scipy.special import softmax
+
+"""
+auxiliary functions for optimizing the temperature (scaling approaches) and weights of ensembles
+*args include logits and labels from the calibration dataset:
+"""
+# Adapted from https://github.com/zhang64-llnl/Mix-n-Match-Calibration/blob/master/util_calibration.py
+
+
+def mse_t(t, *args):
+    # find optimal temperature with MSE loss function
+
+    logit, label = args
+    logit = logit/t
+
+    n = np.sum(np.exp(logit), 1)
+    p = np.exp(logit)/n[:, None]
+    mse = np.mean((p-label)**2)
+    return mse
+
+
+def ll_t(t, *args):
+    # find optimal temperature with Cross-Entropy loss function
+
+    logit, label = args
+    logit = logit/t
+    n = np.sum(np.exp(logit), 1)
+    p = np.clip(np.exp(logit)/n[:, None], 1e-20, 1-1e-20)
+    N = p.shape[0]
+    ce = -np.sum(label*np.log(p))/N
+    return ce
+
+
+def mse_w(w, *args):
+    # find optimal weight coefficients with MSE loss function
+
+    p0, p1, p2, label = args
+    p = w[0]*p0+w[1]*p1+w[2]*p2
+    p = p/np.sum(p, 1)[:, None]
+    mse = np.mean((p-label)**2)
+    return mse
+
+
+def ll_w(w, *args):
+    # find optimal weight coefficients with Cros-Entropy loss function
+
+    p0, p1, p2, label = args
+    p = (w[0]*p0+w[1]*p1+w[2]*p2)
+    N = p.shape[0]
+    ce = -np.sum(label*np.log(p))/N
+    return ce
+
+
+# Ftting Temperature Scaling
+def temperature_scaling(logit, label, loss):
+    bnds = ((0.05, 5.0),)
+    if loss == 'ce':
+        t = optimize.minimize(ll_t, 1.0, args=(
+            logit, label), method='L-BFGS-B', bounds=bnds, tol=1e-12,
+                              options={"disp": False})
+    if loss == 'mse':
+        t = optimize.minimize(mse_t, 1.0, args=(
+            logit, label), method='L-BFGS-B', bounds=bnds, tol=1e-12,
+                              options={"disp": False}
+                              )
+    t = t.x
+    return t
+
+
+# Ftting Enseble Temperature Scaling
+def ensemble_scaling(logit, label, loss, t, n_class):
+
+    p1 = np.exp(logit)/np.sum(np.exp(logit), 1)[:, None]
+    logit = logit/t
+    p0 = np.exp(logit)/np.sum(np.exp(logit), 1)[:, None]
+    p2 = np.ones_like(p0)/n_class
+
+    bnds_w = ((0.0, 1.0), (0.0, 1.0), (0.0, 1.0),)
+    def my_constraint_fun(x): return np.sum(x)-1
+    constraints = {"type": "eq", "fun": my_constraint_fun, }
+    if loss == 'ce':
+        w = optimize.minimize(ll_w, (1.0, 0.0, 0.0), args=(p0, p1, p2, label), method='SLSQP',
+                              constraints=constraints, bounds=bnds_w, tol=1e-12, options={'disp': False})
+    if loss == 'mse':
+        w = optimize.minimize(mse_w, (1.0, 0.0, 0.0), args=(p0, p1, p2, label), method='SLSQP',
+                              constraints=constraints, bounds=bnds_w, tol=1e-12, options={'disp': False})
+    w = w.x
+    return w
+
+
+"""
+Calibration: 
+Input: uncalibrated logits, temperature (and weight)
+Output: calibrated prediction probabilities
+"""
+
+# Calibration: Temperature Scaling with MSE
+
+
+def ts_calibrate(logit, label, logit_eval, loss):
+    t = temperature_scaling(logit, label, loss)
+    # print("temperature = " +str(t))
+    logit_eval = logit_eval/t
+    p = np.exp(logit_eval)/np.sum(np.exp(logit_eval), 1)[:, None]
+    return p
+
+
+# Calibration: Ensemble Temperature Scaling
+def ets_calibrate(logit, label, logit_eval, n_class, loss="mse"):
+    t = temperature_scaling(logit, label, loss=loss)  # loss can change to 'ce'
+    w = ensemble_scaling(logit, label, 'mse', t, n_class)
+
+    p1 = np.exp(logit_eval)/np.sum(np.exp(logit_eval), 1)[:, None]
+    logit_eval = logit_eval/t
+    p0 = np.exp(logit_eval)/np.sum(np.exp(logit_eval), 1)[:, None]
+    p2 = np.ones_like(p0)/n_class
+    p = w[0]*p0 + w[1]*p1 + w[2]*p2
+    return p
+
+
+# Calibration: Isotonic Regression (Multi-class)
+def mir_calibrate(logit, label, logit_eval, eps):
+    
+    original_pred = np.argmax(logit_eval, axis=1)
+    
+    p = softmax(logit, axis=1)
+    p_eval = softmax(logit_eval, axis=1)
+    ir = IsotonicRegression(out_of_bounds="clip")
+    
+    y_ = ir.fit_transform(p.flatten(), (label.flatten()))
+    yt_ = ir.predict(p_eval.flatten())
+    
+
+    p = yt_.reshape(logit_eval.shape) + eps*p_eval
+    p = p / np.sum(p, axis=1, keepdims=True)
+    
+    after_pred = np.argmax(p, axis=1)
+    noe_mask = after_pred != original_pred
+    
+    diff = np.sum(np.abs(original_pred - after_pred))
+    print("diff ", diff)
+    return p
+
+def irova_calibrate(logit, label, logit_eval):
+    p = np.exp(logit)/np.sum(np.exp(logit), 1)[:, None]
+    p_eval = np.exp(logit_eval)/np.sum(np.exp(logit_eval), 1)[:, None]
+
+    for ii in range(p_eval.shape[1]):
+        ir = IsotonicRegression(out_of_bounds='clip')
+        y_ = ir.fit_transform(p[:, ii], label[:, ii])
+        p_eval[:, ii] = ir.predict(p_eval[:, ii])+1e-9*p_eval[:, ii]
+    return p_eval
+
+
+def calibrate(
+        method_name,
+        train_logits,
+        train_labels,
+        test_logits,
+        *args, **kwargs):
+    n_class = train_logits.shape[1]
+    train_labels = torch.nn.functional.one_hot(train_labels,
+                                               num_classes=n_class)
+    train_logits = train_logits.detach().numpy()
+    train_labels = train_labels.numpy()
+    test_logits = test_logits.detach().numpy()
+
+    if "ets" in method_name:
+        calibrated_prob = ets_calibrate(logit=train_logits,
+                                        label=train_labels,
+                                        logit_eval=test_logits,
+                                        n_class=n_class)
+    elif "irm" in method_name:
+        calibrated_prob = mir_calibrate(logit=train_logits,
+                                        label=train_labels,
+                                        logit_eval=test_logits,
+                                        eps=kwargs["eps"])
+    elif method_name == "irova":
+        calibrated_prob = irova_calibrate(logit=train_logits,
+                                        label=train_labels,
+                                        logit_eval=test_logits)
+    else:
+        raise ValueError(method_name)
+    return {
+        "prob": torch.from_numpy(calibrated_prob).float()
+    }

AAAI2025-FC/calibration/group_calibration/methods/nn_calibration.py

@@ -0,0 +1,435 @@
+import numpy as np
+import torch
+from scipy.optimize import minimize 
+from sklearn.metrics import log_loss
+import time
+from sklearn.metrics import log_loss, brier_score_loss
+from os.path import join
+from betacal import BetaCalibration
+import sklearn.metrics as metrics
+from sklearn.isotonic import IsotonicRegression
+
+# Adapted from open-source code
+# https://github.com/markus93/NN_calibration/blob/master/scripts/calibration/cal_methods.py
+# https://github.com/dirichletcal/experiments_dnn/blob/master/scripts/calibration/cal_methods.py
+
+def softmax(x):
+    """
+    Compute softmax values for each sets of scores in x.
+    
+    Parameters:
+        x (numpy.ndarray): array containing m samples with n-dimensions (m,n)
+    Returns:
+        x_softmax (numpy.ndarray) softmaxed values for initial (m,n) array
+    """
+    e_x = np.exp(x - np.max(x))
+    return e_x / e_x.sum(axis=1, keepdims=1)
+    
+
+class HistogramBinning():
+    """
+    Histogram Binning as a calibration method. The bins are divided into equal lengths.
+    
+    The class contains two methods:
+        - fit(probs, true), that should be used with validation data to train the calibration model.
+        - predict(probs), this method is used to calibrate the confidences.
+    """
+    
+    def __init__(self, M=15):
+        """
+        M (int): the number of equal-length bins used
+        """
+        self.bin_size = 1./M  # Calculate bin size
+        self.conf = []  # Initiate confidence list
+        self.upper_bounds = np.arange(self.bin_size, 1+self.bin_size, self.bin_size)  # Set bin bounds for intervals
+
+    
+    def _get_conf(self, conf_thresh_lower, conf_thresh_upper, probs, true):
+        """
+        Inner method to calculate optimal confidence for certain probability range
+        
+        Params:
+            - conf_thresh_lower (float): start of the interval (not included)
+            - conf_thresh_upper (float): end of the interval (included)
+            - probs : list of probabilities.
+            - true : list with true labels, where 1 is positive class and 0 is negative).
+        """
+
+        # Filter labels within probability range
+        filtered = [x[0] for x in zip(true, probs) if x[1] > conf_thresh_lower and x[1] <= conf_thresh_upper]
+        nr_elems = len(filtered)  # Number of elements in the list.
+
+        if nr_elems < 1:
+            return 0
+        else:
+            # In essence the confidence equals to the average accuracy of a bin
+            conf = sum(filtered)/nr_elems  # Sums positive classes
+            return conf
+    
+
+    def fit(self, probs, true):
+        """
+        Fit the calibration model, finding optimal confidences for all the bins.
+        
+        Params:
+            probs: probabilities of data
+            true: true labels of data
+        """
+
+        conf = []
+
+        # Got through intervals and add confidence to list
+        for conf_thresh in self.upper_bounds:
+            temp_conf = self._get_conf((conf_thresh - self.bin_size), conf_thresh, probs = probs, true = true)
+            conf.append(temp_conf)
+
+        self.conf = conf
+
+
+    # Fit based on predicted confidence
+    def predict(self, probs):
+        """
+        Calibrate the confidences
+        
+        Param:
+            probs: probabilities of the data (shape [samples, classes])
+            
+        Returns:
+            Calibrated probabilities (shape [samples, classes])
+        """
+
+        # Go through all the probs and check what confidence is suitable for it.
+        for i, prob in enumerate(probs):
+            idx = np.searchsorted(self.upper_bounds, prob)
+            probs[i] = self.conf[idx]
+
+        return probs
+        
+        
+class TemperatureScaling():
+    
+    def __init__(self, temp = 1, maxiter = 50, solver = "BFGS"):
+        """
+        Initialize class
+        
+        Params:
+            temp (float): starting temperature, default 1
+            maxiter (int): maximum iterations done by optimizer, however 8 iterations have been maximum.
+        """
+        self.temp = temp
+        self.maxiter = maxiter
+        self.solver = solver
+    
+    def _loss_fun(self, x, probs, true):
+        # Calculates the loss using log-loss (cross-entropy loss)
+        scaled_probs = self.predict(probs, x)    
+        loss = log_loss(y_true=true, y_pred=scaled_probs)
+        return loss
+    
+    # Find the temperature
+    def fit(self, logits, true):
+        """
+        Trains the model and finds optimal temperature
+        
+        Params:
+            logits: the output from neural network for each class (shape [samples, classes])
+            true: one-hot-encoding of true labels.
+            
+        Returns:
+            the results of optimizer after minimizing is finished.
+        """
+        
+        true = true.flatten() # Flatten y_val
+        opt = minimize(self._loss_fun, x0 = 1, args=(logits, true), options={'maxiter':self.maxiter}, method = self.solver)
+        self.temp = opt.x[0]
+        
+        return opt
+        
+    def predict(self, logits, temp = None):
+        """
+        Scales logits based on the temperature and returns calibrated probabilities
+        
+        Params:
+            logits: logits values of data (output from neural network) for each class (shape [samples, classes])
+            temp: if not set use temperatures find by model or previously set.
+            
+        Returns:
+            calibrated probabilities (nd.array with shape [samples, classes])
+        """
+        
+        if not temp:
+            return softmax(logits/self.temp)
+        else:
+            return softmax(logits/temp)
+            
+def compute_acc_bin(conf_thresh_lower, conf_thresh_upper, conf, pred, true):
+    """
+    # Computes accuracy and average confidence for bin
+    
+    Args:
+        conf_thresh_lower (float): Lower Threshold of confidence interval
+        conf_thresh_upper (float): Upper Threshold of confidence interval
+        conf (numpy.ndarray): list of confidences
+        pred (numpy.ndarray): list of predictions
+        true (numpy.ndarray): list of true labels
+    
+    Returns:
+        (accuracy, avg_conf, len_bin): accuracy of bin, confidence of bin and number of elements in bin.
+    """
+    filtered_tuples = [x for x in zip(pred, true, conf) if x[2] > conf_thresh_lower and x[2] <= conf_thresh_upper]
+    if len(filtered_tuples) < 1:
+        return 0,0,0
+    else:
+        correct = len([x for x in filtered_tuples if x[0] == x[1]])  # How many correct labels
+        len_bin = len(filtered_tuples)  # How many elements falls into given bin
+        avg_conf = sum([x[2] for x in filtered_tuples]) / len_bin  # Avg confidence of BIN
+        accuracy = float(correct)/len_bin  # accuracy of BIN
+        return accuracy, avg_conf, len_bin
+  
+
+def ECE(conf, pred, true, bin_size = 0.1):
+
+    """
+    Expected Calibration Error
+    
+    Args:
+        conf (numpy.ndarray): list of confidences
+        pred (numpy.ndarray): list of predictions
+        true (numpy.ndarray): list of true labels
+        bin_size: (float): size of one bin (0,1)  # TODO should convert to number of bins?
+        
+    Returns:
+        ece: expected calibration error
+    """
+    
+    upper_bounds = np.arange(bin_size, 1+bin_size, bin_size)  # Get bounds of bins
+    
+    n = len(conf)
+    ece = 0  # Starting error
+    
+    for conf_thresh in upper_bounds:  # Go through bounds and find accuracies and confidences
+        acc, avg_conf, len_bin = compute_acc_bin(conf_thresh-bin_size, conf_thresh, conf, pred, true)        
+        ece += np.abs(acc-avg_conf)*len_bin/n  # Add weigthed difference to ECE
+        
+    return ece
+        
+      
+def MCE(conf, pred, true, bin_size = 0.1):
+
+    """
+    Maximal Calibration Error
+    
+    Args:
+        conf (numpy.ndarray): list of confidences
+        pred (numpy.ndarray): list of predictions
+        true (numpy.ndarray): list of true labels
+        bin_size: (float): size of one bin (0,1)  # TODO should convert to number of bins?
+        
+    Returns:
+        mce: maximum calibration error
+    """
+    
+    upper_bounds = np.arange(bin_size, 1+bin_size, bin_size)
+    
+    cal_errors = []
+    
+    for conf_thresh in upper_bounds:
+        acc, avg_conf, _ = compute_acc_bin(conf_thresh-bin_size, conf_thresh, conf, pred, true)
+        cal_errors.append(np.abs(acc-avg_conf))
+        
+    return max(cal_errors)
+    
+
+def get_bin_info(conf, pred, true, bin_size = 0.1):
+
+    """
+    Get accuracy, confidence and elements in bin information for all the bins.
+    
+    Args:
+        conf (numpy.ndarray): list of confidences
+        pred (numpy.ndarray): list of predictions
+        true (numpy.ndarray): list of true labels
+        bin_size: (float): size of one bin (0,1)  # TODO should convert to number of bins?
+        
+    Returns:
+        (acc, conf, len_bins): tuple containing all the necessary info for reliability diagrams.
+    """
+    
+    upper_bounds = np.arange(bin_size, 1+bin_size, bin_size)
+    
+    accuracies = []
+    confidences = []
+    bin_lengths = []
+    
+    for conf_thresh in upper_bounds:
+        acc, avg_conf, len_bin = compute_acc_bin(conf_thresh-bin_size, conf_thresh, conf, pred, true)
+        accuracies.append(acc)
+        confidences.append(avg_conf)
+        bin_lengths.append(len_bin)
+        
+        
+    return accuracies, confidences, bin_lengths
+
+def evaluate(probs, y_true, verbose = False, normalize = False, bins = 15):
+    """
+    Evaluate model using various scoring measures: Error Rate, ECE, MCE, NLL, Brier Score
+    
+    Params:
+        probs: a list containing probabilities for all the classes with a shape of (samples, classes)
+        y_true: a list containing the actual class labels
+        verbose: (bool) are the scores printed out. (default = False)
+        normalize: (bool) in case of 1-vs-K calibration, the probabilities need to be normalized.
+        bins: (int) - into how many bins are probabilities divided (default = 15)
+        
+    Returns:
+        (error, ece, mce, loss, brier), returns various scoring measures
+    """
+    
+    preds = np.argmax(probs, axis=1)  # Take maximum confidence as prediction
+    
+    if normalize:
+        confs = np.max(probs, axis=1)/np.sum(probs, axis=1)
+        # Check if everything below or equal to 1?
+    else:
+        confs = np.max(probs, axis=1)  # Take only maximum confidence
+    
+    accuracy = metrics.accuracy_score(y_true, preds) * 100
+    error = 100 - accuracy
+    
+        # Calculate ECE
+    ece = ECE(confs, preds, y_true, bin_size = 1/bins)
+    # Calculate MCE
+    mce = MCE(confs, preds, y_true, bin_size = 1/bins)
+    
+    loss = log_loss(y_true=y_true, y_pred=probs)
+    
+    y_prob_true = np.array([probs[i, idx] for i, idx in enumerate(y_true)])  # Probability of positive class
+    brier = brier_score_loss(y_true=y_true, y_prob=y_prob_true)  # Brier Score (MSE)
+    
+    if verbose:
+        print("Accuracy:", accuracy)
+        print("Error:", error)
+        print("ECE:", ece)
+        print("MCE:", mce)
+        print("Loss:", loss)
+        print("brier:", brier)
+    
+    return (error, ece, mce, loss, brier)
+    
+ 
+def cal_results(fn, 
+                train_logits,
+                train_labels,
+                test_logits,
+                m_kwargs={}, 
+                approach="1-vs-k"):
+    
+    """
+    Calibrate models scores, using output from logits files and given function (fn). 
+    There are implemented to different approaches "all" and "1-vs-K" for calibration,
+    the approach of calibration should match with function used for calibration.
+    
+    TODO: split calibration of single and all into separate functions for more use cases.
+    
+    Params:
+        fn (class): class of the calibration method used. It must contain methods "fit" and "predict", 
+                    where first fits the models and second outputs calibrated probabilities.
+        path (string): path to the folder with logits files
+        files (list of strings): pickled logits files ((logits_val, y_val), (logits_test, y_test))
+        m_kwargs (dictionary): keyword arguments for the calibration class initialization
+        approach (string): "all" for multiclass calibration and "1-vs-K" for 1-vs-K approach.
+        
+    Returns:
+        df (pandas.DataFrame): dataframe with calibrated and uncalibrated results for all the input files.
+    
+    """
+    y_val = train_labels
+    logits_val = train_logits
+    logits_test = test_logits
+    
+    if approach == "all":            
+
+        y_val = y_val.flatten()
+
+        model = fn(**m_kwargs)
+
+        model.fit(logits_val, y_val)
+
+        probs_val = model.predict(logits_val) 
+        probs_test = model.predict(logits_test)
+        return probs_test
+        
+    else:  # 1-vs-k models
+        probs_val = softmax(logits_val)  # Softmax logits
+        probs_test = softmax(logits_test)
+        K = probs_test.shape[1]
+        
+        # Go through all the classes
+        for k in range(K):
+            # Prep class labels (1 fixed true class, 0 other classes)
+            y_cal = np.array(y_val == k, dtype="int")
+            
+            # print("sum y_cal ", np.sum(y_cal))
+            if np.sum(y_cal) < 1:
+                probs_test[:, k] = 0
+                continue
+
+            # Train model
+            model = fn(**m_kwargs)
+            model.fit(probs_val[:, k], y_cal) # Get only one column with probs for given class "k"
+
+            probs_val[:, k] = model.predict(probs_val[:, k])  # Predict new values based on the fitting
+            probs_test[:, k] = model.predict(probs_test[:, k])
+
+            # Replace NaN with 0, as it should be close to zero  # TODO is it needed?
+            idx_nan = np.where(np.isnan(probs_test))
+            probs_test[idx_nan] = 0
+
+            idx_nan = np.where(np.isnan(probs_val))
+            probs_val[idx_nan] = 0
+
+    probs_test += 1e-10 # avoid 1.0 and 0.0
+    probs_test = probs_test / np.sum(probs_test, axis=1, keepdims=True)
+    return probs_test
+    
+
+def calibrate(
+    method_name,
+    train_logits,
+    train_labels,
+    test_logits,
+    *args, **kwargs):
+    train_logits = train_logits.numpy()
+    train_labels = train_labels.numpy()
+    test_logits = test_logits.numpy()
+    if method_name == "temp_scaling_ref":
+        calibrated_prob = cal_results(fn=TemperatureScaling,
+                                    train_logits=train_logits,
+                                    train_labels=train_labels,
+                                    test_logits=test_logits,
+                                    approach="all")
+    elif method_name == "histogram_binning":
+        calibrated_prob = cal_results(fn=HistogramBinning,
+                                    train_logits=train_logits,
+                                    train_labels=train_labels,
+                                    test_logits=test_logits,
+                                    approach="1-vs-k")
+    elif method_name == "beta_calibration":
+        calibrated_prob = cal_results(fn=BetaCalibration, 
+                                      train_logits=train_logits,
+                                      train_labels=train_labels,
+                                      test_logits=test_logits, 
+                                      m_kwargs={'parameters':"abm"}, 
+                                      approach="1-vs-k")
+    elif method_name == "isotonic_regression":
+        calibrated_prob = cal_results(fn=IsotonicRegression, 
+                                      train_logits=train_logits,
+                                      train_labels=train_labels,
+                                      test_logits=test_logits, 
+                                      m_kwargs={'y_min':0, 'y_max':1}, 
+                                      approach="1-vs-k")
+    else:
+        raise ValueError(method_name)
+    return {
+        "prob": torch.from_numpy(calibrated_prob)
+    }

AAAI2025-FC/calibration/group_calibration/methods/temp_scaling.py

@@ -0,0 +1,36 @@
+import logging
+import torch
+import torch.nn.functional as F
+import numpy as np
+
+
+def calibrate(train_logits,
+              train_labels,
+              test_logits,
+              *args, **kwargs):
+    train_logits = train_logits.cuda()
+    train_labels = train_labels.cuda()
+
+    tau = torch.nn.Parameter(torch.tensor(1.0))
+    optimizer = torch.optim.LBFGS([tau],
+                                  line_search_fn="strong_wolfe",
+                                  max_iter=50)
+
+    def closure():
+        optimizer.zero_grad()
+        loss = F.cross_entropy(train_logits / tau, train_labels)
+        loss.backward()
+        return loss
+    optimizer.step(closure=closure)
+    final_loss = closure()
+
+    if torch.isnan(tau):
+        tau = 1
+    else:
+        tau = tau.item()
+
+    return {
+        "tau": tau,
+        "logits": test_logits / tau,
+        "loss": final_loss.item()
+    }

AAAI2025-FC/calibration/group_calibration/utils.py

@@ -0,0 +1,95 @@
+import logging
+import torch
+import numpy as np
+
+
+def gather_metrics(metrics):
+    _metrics = sorted(metrics, key=lambda x: x[0])
+    metrics = [x[1] for x in _metrics]
+    assert isinstance(metrics, list)
+    res = {k: [] for k in metrics[0].keys()}
+    
+    for m in metrics:
+        to_del = []
+        for k in res:
+            if k not in m:
+                to_del.append(k)
+        for k in to_del:
+            del res[k]
+    
+    for m in metrics:
+        for k in res.keys():
+            res[k].append(m[k])
+            
+    res_stats = {}
+    for k, v in res.items():
+        res_stats[k] = {"mean": np.mean(v), "std": np.std(v)}
+    logging.info("Raw metrics: {}".format(res))
+    return res_stats, metrics
+
+
+def set_seed(seed, get_state=False, set_torch=True, set_numpy=True):
+    if get_state:
+        if set_torch:
+            torch_state = torch.get_rng_state()
+        else:
+            torch_state = None
+        if set_numpy:
+            numpy_state = np.random.get_state()
+        else:
+            numpy_state = None
+    else:
+        torch_state, numpy_state = None, None
+    if set_torch:
+        torch.manual_seed(seed)
+    if set_numpy:
+        np.random.seed(seed)
+    if get_state:
+        return (torch_state, numpy_state)
+
+
+def restore_state(states, set_torch=True, set_numpy=True):
+    if set_torch:
+        torch.set_rng_state(states[0])
+    if set_numpy:
+        np.random.set_state(states[1])
+
+
+class seed_scope:
+
+    def __init__(self, seed, set_torch=True, set_numpy=True):
+        self.seed = seed
+        self.set_torch = set_torch
+        self.set_numpy = set_numpy
+
+    def __enter__(self):
+        self.prev_state = set_seed(self.seed, get_state=True,
+                                   set_numpy=self.set_numpy,
+                                   set_torch=self.set_torch)
+
+    def __exit__(self, type, value, traceback):
+        restore_state(self.prev_state,
+                      set_torch=self.set_torch,
+                      set_numpy=self.set_numpy)
+
+
+class RandomSplitter:
+    def __init__(self, splits, num, seed=None):
+        assert np.isclose(np.sum(splits), 1)
+        self.num = num
+        idx = list(range(num))
+        with seed_scope(seed=seed, set_torch=False):
+            np.random.shuffle(idx)
+        cnt = 0
+        self.idx_splits = []
+        for s in splits[:-1]:
+            length = int(s * num)
+            self.idx_splits.append(idx[cnt: cnt+length])
+            cnt += length
+        self.idx_splits.append(idx[cnt:])
+
+    def split(self, x, split_id=None):
+        if split_id is not None:
+            return x[self.idx_splits[split_id]]
+        else:
+            return [x[_idx] for _idx in self.idx_splits]

AAAI2025-FC/calibration/pts_cts_ets/__init__.py

@@ -0,0 +1,74 @@
+import torch
+from torch import nn
+from . import lossfunction, scaler, optimizer
+from .option import opt
+from .utils import dataset_mapping, dataloader, expected_caibration_error, calibrator_mapping, loss_mapping
+
+# Dataset params
+dataset_num_classes = {
+    'cifar10': 10,
+    'cifar100': 100,
+    'tiny_imagenet': 200,
+    'imagenet': 1000
+}
+
+class calibrator(nn.Module):
+    def __init__(self, args):
+        super(calibrator, self).__init__()
+        torch.manual_seed(1)
+        self.data = args.dataset
+        self.n_class = dataset_num_classes[args.dataset]
+        # Call the function to measure accuracy and expected calibration error.
+        self.evaluator = expected_caibration_error()
+
+        # Call the scaler for selected temperature based approach.
+        self.scaler = getattr(scaler, calibrator_mapping(args.cal))(args)
+        
+        # Call the loss for learn.
+        self.loss = getattr(lossfunction, loss_mapping('CE'))(args)
+
+        # Call the optimizer for corresponding combination of scaler and loss.
+        self.optim = args.optim
+        self.optimizer = [getattr(optimizer, self.optim)(self.scaler, args)] if args.cal != 'ETS' else [
+            getattr(optimizer, self.optim)(self.scaler.t, args), getattr(optimizer, self.optim)(self.scaler.w, args)
+        ]
+    
+    def evaluate(self, x, y):
+        # Evaluate the uncalibrated logits.
+        uncalibrated_ece, uncalibrated_acc = self.evaluator(x, y)
+
+        # Calibrate the logits.
+        q = self.forward(x)
+
+        # Evaluate the calibrated logits.
+        calibrated_ece, calibrated_acc = self.evaluator(q, y)
+
+    
+    def forward(self, x):
+        return self.scaler(x)
+    
+    def train(self, x, y):
+        # Training for Parameterized Temperature Scaling
+        if 'adam' in self.optim:
+            for optimizers in self.optimizer:
+                for optimizer, epochs in optimizers:
+                    for _ in range(epochs):
+                        optimizer.zero_grad()
+                        q = self.forward(x)
+                        loss = self.loss(q, y)
+                        loss.backward()
+                        optimizer.step()
+
+        # Traninig for Temperature Scaling and Class-based Temperature Scaling
+        else:
+            for optimizers in self.optimizer:
+                for optimizer in optimizers:
+                    def trainer():
+                        optimizer.zero_grad()
+                        q = self.forward(x)
+                        loss = self.loss(q, y)
+                        loss.backward()
+
+                        return loss
+
+                    optimizer.step(trainer)

AAAI2025-FC/calibration/pts_cts_ets/dataloader.py

@@ -0,0 +1,19 @@
+import pickle
+import torch
+
+def dataloader(file, args):
+    with open(file, 'rb') as f:
+        (y_probs_val, y_val), (y_probs_test, y_test) = pickle.load(f)
+        
+    if args.logger != 'None':
+        args.logger.info("{}".format(file.split('/')[-1].split('.p')[0]))
+        args.logger.info("y_probs_val : {} | y_val : {} | y_probs_test : {} | y_true_test : {}".format(y_probs_val.shape,y_val.shape,y_probs_test.shape,y_test.shape))
+
+    n_class = y_probs_val.shape[1]
+
+    valid_logits = torch.tensor(y_probs_val).cuda()
+    valid_labels = torch.tensor(y_val).long().view(-1).cuda()
+    test_logits = torch.tensor(y_probs_test).cuda()
+    test_labels = torch.tensor(y_test).long().view(-1).cuda()
+        
+    return ((valid_logits, valid_labels), (test_logits, test_labels), n_class)

AAAI2025-FC/calibration/pts_cts_ets/lossfunction.py

@@ -0,0 +1,112 @@
+import torch
+import numpy as np
+from scipy import optimize
+from torch import nn
+from torch.autograd import Variable
+from torch.nn import functional as F
+
+# Baseline Loss
+class cross_entropy_loss(nn.Module):
+    def __init__(self, args):
+        super(cross_entropy_loss, self).__init__()
+        self.loss = nn.CrossEntropyLoss()
+
+    def forward(self, input, target):
+        return self.loss(input, target)
+    
+class label_smoothing_loss(nn.Module):
+    def __init__(self, args):
+        super(label_smoothing_loss, self).__init__()
+        args.optim += '_schedule'
+        self.loss = nn.CrossEntropyLoss(label_smoothing=0.05).cuda()
+
+    def forward(self, input, target):
+        return self.loss(input, target)
+
+class focal_loss(nn.Module):
+    def __init__(self, args, gamma=3, alpha=None, size_average=True):
+        super(focal_loss, self).__init__()
+        args.optim += '_schedule'
+        self.gamma = gamma
+        self.alpha = alpha
+        if isinstance(alpha,(float,int)): self.alpha = torch.Tensor([alpha,1-alpha])
+        if isinstance(alpha,list): self.alpha = torch.Tensor(alpha)
+        self.size_average = size_average
+
+    def forward(self, input, target):
+        if input.dim()>2:
+            input = input.view(input.size(0),input.size(1),-1)  # N,C,H,W => N,C,H*W
+            input = input.transpose(1,2)    # N,C,H*W => N,H*W,C
+            input = input.contiguous().view(-1,input.size(2))   # N,H*W,C => N*H*W,C
+        target = target.view(-1,1)
+
+        logpt = F.log_softmax(input, dim=1)
+        logpt = logpt.gather(1,target)
+        logpt = logpt.view(-1)
+        pt = Variable(logpt.data.exp())
+
+        if self.alpha is not None:
+            if self.alpha.type()!=input.data.type():
+                self.alpha = self.alpha.type_as(input.data)
+            at = self.alpha.gather(0,target.data.view(-1))
+            logpt = logpt * Variable(at)
+
+        loss = -1 * (1-pt)**self.gamma * logpt
+
+        if self.size_average: 
+            return loss.mean()
+        else: 
+            return loss.sum()
+    
+class scaling_classwise_training_loss(nn.Module):
+    def __init__(self, args):
+        super(scaling_classwise_training_loss, self).__init__()
+        self.loss = nn.CrossEntropyLoss()
+        self.n_class = args.n_class
+        self.norm = args.norm
+        self.step = 0
+        self.alpha = 1
+        self.beta = 1.5
+
+    def forward(self, input, target):
+        losses = torch.zeros(self.n_class)
+        for i in range(self.n_class):
+            indice = target.eq(i)
+            tx = input[indice]
+            ty = target[indice]
+            losses[i] = self.loss(tx, ty)
+
+        loss = losses.clone().detach()
+
+        if self.norm == 'ND':
+            norm = (loss-loss.mean())/loss.std() 
+        elif self.norm == 'MM': 
+            norm = (loss-loss.min())/(loss.max()-loss.min())
+        elif self.norm == 'CM':
+            norm = (loss-loss.mean())/(loss.max()-loss.min())
+
+        if self.step == 0:
+            self.first = loss.tolist()
+
+        # Optimize alpha and beta
+        elif self.step == 1:
+            self.optim = False
+            self.optimize_scailing_estimator(norm.tolist(), loss.tolist())
+
+        self.step += 1
+                
+        # scale loss
+        losses *= self.scailing_estimator(norm)
+        return losses.sum()
+    
+    def scailing_estimator(self, x):
+        return self.beta/(1+np.exp(-x/self.alpha)) - self.beta/2 + 1
+    
+    def optimize_scailing_estimator(self, norm, loss):
+        def func(x, *args):
+            return np.sqrt(((np.array(args[2]) - (x[1]/(1+np.exp(-np.array(args[0])/x[0])) -x[1]/2) * (np.array(args[1])-np.array(args[2])) - np.array(args[1]).mean()) ** 2).sum())
+        
+        opt = optimize.minimize(func, (self.alpha, self.beta), args=(norm, loss, self.first, self.n_class), method='SLSQP', 
+                                bounds=((0.1, np.log(self.n_class)/2),(1.5, 2.0)), options={'disp':False})
+
+        self.alpha, self.beta = opt.x

AAAI2025-FC/calibration/pts_cts_ets/optimizer.py

@@ -0,0 +1,25 @@
+from torch import optim
+
+# Optimizer for Temperature Scalinig, Ensemble Temperature Scaling, and Class-based Temperature Scaling
+def lbfgs(cal, args):
+    args.lr=0.02
+    args.n_iter=1000
+    return [optim.LBFGS(cal.parameters(), lr=args.lr, max_iter=args.n_iter)]
+
+# Optimizer for Temperature Scalinig, Ensemble Temperature Scaling, and Class-based Temperature Scaling, by using Focal Loss or Label Smoothing
+def lbfgs_schedule(cal, _):
+    return [optim.LBFGS(cal.parameters(), lr=0.005, max_iter=200), 
+            optim.LBFGS(cal.parameters(), lr=0.003, max_iter=400), 
+            optim.LBFGS(cal.parameters(), lr=0.001, max_iter=400)]
+
+# Optimizer for Parameterized Temperature Scalinig
+def adam(cal, args):
+    args.lr=0.02
+    args.n_iter=1000
+    return [[optim.Adam(cal.parameters(), lr=args.lr),args.n_iter]]
+
+# Optimizer for Parameterized Temperature Scalinig, by using Focal Loss or Label Smoothing
+def adam_schedule(cal, _):
+    return [[optim.Adam(cal.parameters(), lr=0.005), 200],
+            [optim.Adam(cal.parameters(), lr=0.003), 400], 
+            [optim.Adam(cal.parameters(), lr=0.001), 400]]

AAAI2025-FC/calibration/pts_cts_ets/option.py

@@ -0,0 +1,32 @@
+import argparse
+
+def opt():
+    parser = argparse.ArgumentParser(description='SCTL')
+    # Datasets
+    parser.add_argument('--dataset', type=str, required=True, 
+                        help='Select the datasets')
+    
+    # Calibrator and Training Loss
+    parser.add_argument('--cal', type=str, default='TS', 
+                        help='TS : Temperature Scaling, ETS : Ensemble Temperature Scaling, CTS : Class-based Temeprature Scailing, PTS : Parameterized Temerature Scailng')
+    parser.add_argument('--loss', type=str, default='CE', 
+                        help='CE : Cross Entropy, LS : Label Smoothing loss, FL : Focal Loss, CL : scaling Class-wise Loss')
+    
+    # Hyper-parameter
+    parser.add_argument('--n_iter', type=int, default=1000, 
+                        help='Limit the max iter for optimizer')
+    parser.add_argument('--lr', type=float, default=0.02, 
+                        help='Learning rate')
+    parser.add_argument('--wd', type=float, default=0.02, 
+                        help='weight_decay')
+    parser.add_argument('--norm', type=str, default='ND',
+                        help='ND : Normal Distribution(standardization), CM : Centerized Min-max normalization ,MM : Min-Max Normalization')
+    
+    # Log
+    parser.add_argument('--name', type=str, default='text.log',
+                        help='Name of log')
+    parser.add_argument('--trainlog', action='store_true',
+                        help='Logging loss and measures during training')
+    
+
+    return parser.parse_args()

AAAI2025-FC/calibration/pts_cts_ets/scaler.py

@@ -0,0 +1,61 @@
+import torch
+from torch import nn
+
+class temperature_scaler(nn.Module):
+    def __init__(self, args):
+        super(temperature_scaler, self).__init__()
+        args.optim = 'lbfgs'
+        # Call a Tmeperature Scaling parameter.
+        self.t = nn.Parameter(torch.ones(1))
+
+    def forward(self, x):
+        return x / self.t
+    
+class ensemble_scaler(nn.Module):
+    def __init__(self, args):
+        super(ensemble_scaler, self).__init__()
+        # Call a Tmeperature Scaling parameter.
+        self.w = nn.Parameter(torch.tensor((1.0, 0.0, 0.0)))
+
+    def forward(self, x1, x2, x3):
+        return x1*self.w[0] + x2*self.w[1] + x3*self.w[2]
+    
+class ensemble_temperature_scaler(nn.Module):
+    def __init__(self, args):
+        super(ensemble_temperature_scaler, self).__init__()
+        self.n_class = args.n_class
+
+        self.t = temperature_scaler(args)
+        self.w = ensemble_scaler(args)
+
+    def forward(self, x):
+        return self.w(self.t(x), x, 1/self.n_class)
+    
+    
+class parameterized_temperature_scaler(nn.Module):
+    def __init__(self, args):
+        super(parameterized_temperature_scaler, self).__init__()
+        args.optim = 'adam'
+        
+        for i in range(4):
+            if i == 0:
+                model = [nn.Sequential(nn.Linear(10,2),nn.ReLU())]
+            else:
+                model += [nn.Sequential(nn.Linear(2,2),nn.ReLU())]
+        model += [nn.Linear(2,1)]
+        self.models = nn.Sequential(*model)
+
+    def forward(self, x):
+        t,_ = x.clone().detach().sort(descending=True)
+        t = t[:,:10]
+        t = self.models(t)
+        return x/t
+    
+class class_based_temperature_scaler(nn.Module):
+    def __init__(self, args):
+        super(class_based_temperature_scaler, self).__init__()
+        args.optim = 'lbfgs'
+        self.T = nn.Parameter(torch.ones(args.n_class))
+
+    def forward(self, x):
+        return x / self.T

AAAI2025-FC/calibration/pts_cts_ets/utils.py

@@ -0,0 +1,150 @@
+import torch
+import pickle
+from torch import nn
+from torch.nn import functional as F
+
+DATASETS = {
+            'cifar10_densenet40'      : ['datasets/probs_densenet40_c10_logits.p',],
+            'cifar10_wideresnet32'    : ['datasets/probs_resnet_wide32_c10_logits.p',],
+            'cifar10_resnet110'       : ['datasets/probs_resnet110_c10_logits.p',],
+            'cifar10_resnet110sd'     : ['datasets/probs_resnet110_SD_c10_logits.p',],
+            'cifar100_densenet40'     : ['datasets/probs_densenet40_c100_logits.p',],
+            'cifar100_wideresnet32'   : ['datasets/probs_resnet_wide32_c100_logits.p',],
+            'cifar100_resnet110'      : ['datasets/probs_resnet110_c100_logits.p',],
+            'cifar100_resnet110sd'    : ['datasets/probs_resnet110_SD_c100_logits.p',],
+            'imagenet_resnet152'      : ['datasets/probs_resnet152_imgnet_logits.p',],
+            'imagenet_densenet161'    : ['datasets/probs_densenet161_imgnet_logits.p',],
+
+            'LT_cifar10_densenet40'   : ['datasets/probs_densenet40_c10_LT_logits.p',],
+            'LT_cifar10_wideresnet28' : ['datasets/probs_resnet_wide28_c10_LT_logits.p',],
+            'LT_cifar10_resnet110'    : ['datasets/probs_resnet110_c10_LT_logits.p',],
+            'LT_cifar10_resnet110sd'  : ['datasets/probs_resnet110_SD_c10_LT_logits.p',],
+            'LT_cifar100_densenet40'  : ['datasets/probs_densenet40_c100_LT_logits.p',],
+            'LT_cifar100_wideresnet28': ['datasets/probs_resnet_wide28_c100_LT_logits.p',],
+            'LT_cifar100_resnet110'   : ['datasets/probs_resnet110_c100_LT_logits.p',],
+            'LT_cifar100_resnet110sd' : ['datasets/probs_resnet110_SD_c100_LT_logits.p',],
+
+            'cifar10'                 : ['datasets/probs_densenet40_c10_logits.p',
+                                         'datasets/probs_resnet_wide32_c10_logits.p',
+                                         'datasets/probs_resnet110_c10_logits.p',
+                                         'datasets/probs_resnet110_SD_c10_logits.p',],
+            'cifar100'                : ['datasets/probs_densenet40_c100_logits.p',
+                                         'datasets/probs_resnet_wide32_c100_logits.p',
+                                         'datasets/probs_resnet110_c100_logits.p',
+                                         'datasets/probs_resnet110_SD_c100_logits.p',],
+            'imagenet'                : ['datasets/probs_resnet152_imgnet_logits.p',
+                                         'datasets/probs_densenet161_imgnet_logits.p',],
+                                      
+            'LT_cifar10'              : ['datasets/probs_densenet40_c10_LT_logits.p',
+                                         'datasets/probs_resnet_wide28_c10_LT_logits.p',
+                                         'datasets/probs_resnet110_c10_LT_logits.p',
+                                         'datasets/probs_resnet110_SD_c10_LT_logits.p',],
+            'LT_cifar100'             : ['datasets/probs_densenet40_c100_LT_logits.p',
+                                         'datasets/probs_resnet_wide28_c100_LT_logits.p',
+                                         'datasets/probs_resnet110_c100_LT_logits.p',
+                                         'datasets/probs_resnet110_SD_c100_LT_logits.p',],
+
+            'all'                     : ['datasets/probs_densenet40_c10_logits.p',
+                                         'datasets/probs_resnet_wide32_c10_logits.p',
+                                         'datasets/probs_resnet110_c10_logits.p',
+                                         'datasets/probs_resnet110_SD_c10_logits.p',
+                                         'datasets/probs_densenet40_c100_logits.p',
+                                         'datasets/probs_resnet_wide32_c100_logits.p',
+                                         'datasets/probs_resnet110_c100_logits.p',
+                                         'datasets/probs_resnet110_SD_c100_logits.p',
+                                         'datasets/probs_resnet152_imgnet_logits.p',
+                                         'datasets/probs_densenet161_imgnet_logits.p',],
+
+            'LT'                      : ['datasets/probs_densenet40_c10_LT_logits.p',
+                                         'datasets/probs_resnet_wide28_c10_LT_logits.p',
+                                         'datasets/probs_resnet110_c10_LT_logits.p',
+                                         'datasets/probs_resnet110_SD_c10_LT_logits.p',
+                                         'datasets/probs_densenet40_c100_LT_logits.p',
+                                         'datasets/probs_resnet_wide28_c100_LT_logits.p',
+                                         'datasets/probs_resnet110_c100_LT_logits.p',
+                                         'datasets/probs_resnet110_SD_c100_LT_logits.p',],
+
+            'ALL'                     : ['datasets/probs_densenet40_c10_logits.p',
+                                         'datasets/probs_resnet_wide32_c10_logits.p',
+                                         'datasets/probs_resnet110_c10_logits.p',
+                                         'datasets/probs_resnet110_SD_c10_logits.p',
+                                         'datasets/probs_densenet40_c100_logits.p',
+                                         'datasets/probs_resnet_wide32_c100_logits.p',
+                                         'datasets/probs_resnet110_c100_logits.p',
+                                         'datasets/probs_resnet110_SD_c100_logits.p',
+                                         'datasets/probs_resnet152_imgnet_logits.p',
+                                         'datasets/probs_densenet161_imgnet_logits.p',
+                                         'datasets/probs_densenet40_c10_LT_logits.p',
+                                         'datasets/probs_resnet_wide28_c10_LT_logits.p',
+                                         'datasets/probs_resnet110_c10_LT_logits.p',
+                                         'datasets/probs_resnet110_SD_c10_LT_logits.p',
+                                         'datasets/probs_densenet40_c100_LT_logits.p',
+                                         'datasets/probs_resnet_wide28_c100_LT_logits.p',
+                                         'datasets/probs_resnet110_c100_LT_logits.p',
+                                         'datasets/probs_resnet110_SD_c100_LT_logits.p',],
+            }
+
+CALIBRATOR = {
+    'TS' : 'temperature_scaler',
+    'ETS': 'ensemble_temperature_scaler',
+    'CTS': 'class_based_temperature_scaler',
+    'PTS': 'parameterized_temperature_scaler',
+}
+
+LOSS = {
+    'CE' : 'cross_entropy_loss',
+    'LS' : 'label_smoothing_loss',
+    'FL' : 'focal_loss',
+    'CL' : 'scaling_classwise_training_loss'
+}
+
+class expected_caibration_error(nn.Module):
+    def __init__(self, n_bins=15):
+        super(expected_caibration_error, self).__init__()
+        bin_boundaries = torch.linspace(0, 1, n_bins + 1)
+        self.bin_lowers = bin_boundaries[:-1]
+        self.bin_uppers = bin_boundaries[1:]
+
+    def forward(self, logits, labels):
+        softmaxes = F.softmax(logits, dim=1)
+        confidences, predictions = torch.max(softmaxes, 1)
+        accuracies = predictions.eq(labels)
+        
+        ece = torch.zeros(1, device=logits.device)
+        acc = torch.zeros(1, device=logits.device)
+        for bin_lower, bin_upper in zip(self.bin_lowers, self.bin_uppers):
+            # Calculated |confidence - accuracy| in each bin
+            in_bin = confidences.gt(bin_lower.item()) * confidences.le(bin_upper.item())
+            prop_in_bin = in_bin.float().mean()
+            if prop_in_bin.item() > 0:
+                accuracy_in_bin = accuracies[in_bin].float().mean()
+                avg_confidence_in_bin = confidences[in_bin].mean()
+                
+                ece += torch.abs(avg_confidence_in_bin - accuracy_in_bin) * prop_in_bin
+                acc += accuracies[in_bin].float().mean() * prop_in_bin
+        return ece * 100, acc * 100
+    
+def dataloader(args):
+    with open(args.data, 'rb') as f:
+        (y_probs_val, y_val), (y_probs_test, y_test) = pickle.load(f)
+        
+    #     print("{}".format(file.split('/')[-1].split('.p')[0]))
+    #     print("y_probs_val : {} | y_val : {} | y_probs_test : {} | y_true_test : {}".format(y_probs_val.shape,y_val.shape,y_probs_test.shape,y_test.shape))
+
+    args.n_class = y_probs_val.shape[1] # using for class_based_temperature_scalining
+
+    valid_logits = torch.tensor(y_probs_val).cuda()
+    valid_labels = torch.tensor(y_val).long().view(-1).cuda()
+    test_logits = torch.tensor(y_probs_test).cuda()
+    test_labels = torch.tensor(y_test).long().view(-1).cuda()
+        
+    return (valid_logits, valid_labels), (test_logits, test_labels)
+
+def dataset_mapping(data):
+    return DATASETS[data]
+    
+def calibrator_mapping(cal):
+    return CALIBRATOR[cal]
+    
+def loss_mapping(loss):
+    return LOSS[loss]

AAAI2025-FC/calibration/temperature_scaling.py

@@ -0,0 +1,112 @@
+'''
+Code to perform temperature scaling. Adapted from https://github.com/gpleiss/temperature_scaling
+'''
+import torch
+import numpy as np
+from torch import nn, optim
+from torch.nn import functional as F
+
+from metrics.metrics import ECELoss
+
+
+class ModelWithTemperature(nn.Module):
+    """
+    A thin decorator, which wraps a model with temperature scaling
+    model (nn.Module):
+        A classification neural network
+        NB: Output of the neural network should be the classification logits,
+            NOT the softmax (or log softmax)!
+    """
+    def __init__(self, model, log=True):
+        super(ModelWithTemperature, self).__init__()
+        self.model = model
+        self.temperature = 1.0
+        self.log = log
+
+
+    def forward(self, input, return_feature=None):
+        if return_feature == None:
+            logits = self.model(input)
+            return self.temperature_scale(logits)
+        else:
+            logits, features = self.model(input, return_feature=True)
+            return self.temperature_scale(logits), features
+
+
+    def temperature_scale(self, logits):
+        """
+        Perform temperature scaling on logits
+        """
+        # Expand temperature to match the size of logits
+        return logits / self.temperature
+
+
+    def set_temperature(self,
+                        valid_loader,
+                        cross_validate='ece'):
+        """
+        Tune the tempearature of the model (using the validation set) with cross-validation on ECE or NLL
+        """
+        self.cuda()
+        self.model.eval()
+        nll_criterion = nn.CrossEntropyLoss().cuda()
+        ece_criterion = ECELoss().cuda()
+
+        # First: collect all the logits and labels for the validation set
+        logits_list = []
+        labels_list = []
+        with torch.no_grad():
+            for input, label in valid_loader:
+                input = input.cuda()
+                logits = self.model(input)
+                logits_list.append(logits)
+                labels_list.append(label)
+            logits = torch.cat(logits_list).cuda()
+            labels = torch.cat(labels_list).cuda()
+
+        # Calculate NLL and ECE before temperature scaling
+        before_temperature_nll = nll_criterion(logits, labels).item()
+        before_temperature_ece = ece_criterion(logits, labels).item()
+        if self.log:
+            print('Before temperature - NLL: %.3f, ECE: %.3f' % (before_temperature_nll, before_temperature_ece))
+
+        nll_val = 10 ** 7
+        ece_val = 10 ** 7
+        T_opt_nll = 1.0
+        T_opt_ece = 1.0
+        T = 0.1
+        for i in range(100):
+            self.temperature = T
+            self.cuda()
+            after_temperature_nll = nll_criterion(self.temperature_scale(logits), labels).item()
+            after_temperature_ece = ece_criterion(self.temperature_scale(logits), labels).item()
+            if nll_val > after_temperature_nll:
+                T_opt_nll = T
+                nll_val = after_temperature_nll
+
+            if ece_val > after_temperature_ece:
+                T_opt_ece = T
+                ece_val = after_temperature_ece
+            T += 0.1
+
+        if cross_validate == 'ece':
+            self.temperature = T_opt_ece
+        else:
+            self.temperature = T_opt_nll
+        self.cuda()
+
+        # Calculate NLL and ECE after temperature scaling
+        after_temperature_nll = nll_criterion(self.temperature_scale(logits), labels).item()
+        after_temperature_ece = ece_criterion(self.temperature_scale(logits), labels).item()
+        if self.log:
+            print('Optimal temperature: %.3f' % self.temperature)
+            print('After temperature - NLL: %.3f, ECE: %.3f' % (after_temperature_nll, after_temperature_ece))
+
+        return self
+
+
+    def get_temperature(self):
+        return self.temperature
+    
+    def classifier(self, features):
+        return self.model.classifier(features)

AAAI2025-FC/dataset/cifar10.py

@@ -0,0 +1,165 @@
+"""
+Create train, valid, test iterators for CIFAR-10.
+Train set size: 45000
+Val set size: 5000
+Test set size: 10000
+"""
+
+import torch
+import numpy as np
+
+from torchvision import datasets
+from torchvision import transforms
+from torch.utils.data.sampler import SubsetRandomSampler
+
+
+def get_train_valid_loader(batch_size,
+                           augment,
+                           random_seed,
+                        data_dir='/share/datasets/',
+                           valid_size=0.1,
+                           shuffle=True,
+                           num_workers=4,
+                           pin_memory=False,
+                           get_val_temp=0):
+    """
+    Utility function for loading and returning train and valid
+    multi-process iterators over the CIFAR-10 dataset. 
+    Params:
+    ------
+    - batch_size: how many samples per batch to load.
+    - augment: whether to apply the data augmentation scheme
+      mentioned in the paper. Only applied on the train split.
+    - random_seed: fix seed for reproducibility.
+    - valid_size: percentage split of the training set used for
+      the validation set. Should be a float in the range [0, 1].
+    - shuffle: whether to shuffle the train/validation indices.
+    - num_workers: number of subprocesses to use when loading the dataset.
+    - pin_memory: whether to copy tensors into CUDA pinned memory. Set it to
+      True if using GPU.
+    - get_val_temp: set to 1 if temperature is to be set on a separate
+                    val set other than normal val set.
+    Returns
+    -------
+    - train_loader: training set iterator.
+    - valid_loader: validation set iterator.
+    """
+    error_msg = "[!] valid_size should be in the range [0, 1]."
+    assert ((valid_size >= 0) and (valid_size <= 1)), error_msg
+
+    normalize = transforms.Normalize(
+        mean=[0.4914, 0.4822, 0.4465],
+        std=[0.2023, 0.1994, 0.2010],
+    )
+
+    # define transforms
+    valid_transform = transforms.Compose([
+            transforms.ToTensor(),
+            normalize,
+    ])
+    if augment:
+        train_transform = transforms.Compose([
+            transforms.RandomCrop(32, padding=4),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            normalize,
+        ])
+    else:
+        train_transform = transforms.Compose([
+            transforms.ToTensor(),
+            normalize,
+        ])
+
+    # load the dataset
+    train_dataset = datasets.CIFAR10(
+        root=data_dir, train=True,
+        download=True, transform=train_transform,
+    )
+
+    valid_dataset = datasets.CIFAR10(
+        root=data_dir, train=True,
+        download=True, transform=valid_transform,
+    )
+
+    num_train = len(train_dataset)
+    indices = list(range(num_train))
+    split = int(np.floor(valid_size * num_train))
+
+    if shuffle:
+        np.random.seed(random_seed)
+        np.random.shuffle(indices)
+
+    train_idx, valid_idx = indices[split:], indices[:split]
+    if get_val_temp > 0:
+        valid_temp_dataset = datasets.CIFAR10(
+            root=data_dir, train=True,
+            download=True, transform=valid_transform,
+        )
+        split = int(np.floor(get_val_temp * split))
+        valid_idx, valid_temp_idx = valid_idx[split:], valid_idx[:split]
+        valid_temp_sampler = SubsetRandomSampler(valid_temp_idx)
+        valid_temp_loader = torch.utils.data.DataLoader(
+            valid_temp_dataset, batch_size=batch_size, sampler=valid_temp_sampler,
+            num_workers=num_workers, pin_memory=pin_memory,
+        )
+
+    train_sampler = SubsetRandomSampler(train_idx)
+    valid_sampler = SubsetRandomSampler(valid_idx)
+
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset, batch_size=batch_size, sampler=train_sampler,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+    valid_loader = torch.utils.data.DataLoader(
+        valid_dataset, batch_size=batch_size, sampler=valid_sampler,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+    if get_val_temp > 0:
+        return (train_loader, valid_loader, valid_temp_loader)
+    else:
+        return (train_loader, valid_loader)
+
+
+def get_test_loader(batch_size,
+                    data_dir='/share/datasets/',
+                    shuffle=False,
+                    num_workers=4,
+                    pin_memory=False,
+                    drop_index=None):
+    """
+    Utility function for loading and returning a multi-process
+    test iterator over the CIFAR-10 dataset.
+    If using CUDA, num_workers should be set to 1 and pin_memory to True.
+    Params
+    ------
+    - batch_size: how many samples per batch to load.
+    - shuffle: whether to shuffle the dataset after every epoch.
+    - num_workers: number of subprocesses to use when loading the dataset.
+    - pin_memory: whether to copy tensors into CUDA pinned memory. Set it to
+      True if using GPU.
+    Returns
+    -------
+    - data_loader: test set iterator.
+    """
+    normalize = transforms.Normalize(
+        mean=[0.4914, 0.4822, 0.4465],
+        std=[0.2023, 0.1994, 0.2010],
+    )
+
+    # define transform
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        normalize,
+    ])
+
+    dataset = datasets.CIFAR10(
+        root=data_dir, train=False,
+        download=True, transform=transform,
+    )
+
+    data_loader = torch.utils.data.DataLoader(
+        dataset, batch_size=batch_size, shuffle=shuffle,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+
+    return data_loader

AAAI2025-FC/dataset/cifar100.py

@@ -0,0 +1,165 @@
+"""
+Create train, valid, test iterators for CIFAR-100.
+Train set size: 45000
+Val set size: 5000
+Test set size: 10000
+"""
+
+import torch
+import numpy as np
+
+from torchvision import datasets
+from torchvision import transforms
+from torch.utils.data.sampler import SubsetRandomSampler
+
+
+def get_train_valid_loader(batch_size,
+                           augment,
+                           random_seed,
+                           data_dir='/share/datasets/',
+                           valid_size=0.1,
+                           shuffle=True,
+                           num_workers=4,
+                           pin_memory=False,
+                           get_val_temp=0):
+    """
+    Utility function for loading and returning train and valid
+    multi-process iterators over the CIFAR-100 dataset. 
+    Params:
+    ------
+    - batch_size: how many samples per batch to load.
+    - augment: whether to apply the data augmentation scheme
+      mentioned in the paper. Only applied on the train split.
+    - random_seed: fix seed for reproducibility.
+    - valid_size: percentage split of the training set used for
+      the validation set. Should be a float in the range [0, 1].
+    - shuffle: whether to shuffle the train/validation indices.
+    - num_workers: number of subprocesses to use when loading the dataset.
+    - pin_memory: whether to copy tensors into CUDA pinned memory. Set it to
+      True if using GPU.
+    - get_val_temp: set to 1 if temperature is to be set on a separate
+                    val set other than normal val set.
+    Returns
+    -------
+    - train_loader: training set iterator.
+    - valid_loader: validation set iterator.
+    """
+    error_msg = "[!] valid_size should be in the range [0, 1]."
+    assert ((valid_size >= 0) and (valid_size <= 1)), error_msg
+
+    normalize = transforms.Normalize(
+        mean=[0.4914, 0.4822, 0.4465],
+        std=[0.2023, 0.1994, 0.2010],
+    )
+
+    # define transforms
+    valid_transform = transforms.Compose([
+            transforms.ToTensor(),
+            normalize,
+    ])
+    if augment:
+        train_transform = transforms.Compose([
+            transforms.RandomCrop(32, padding=4),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            normalize,
+        ])
+    else:
+        train_transform = transforms.Compose([
+            transforms.ToTensor(),
+            normalize,
+        ])
+
+    # load the dataset
+    train_dataset = datasets.CIFAR100(
+        root=data_dir, train=True,
+        download=True, transform=train_transform,
+    )
+
+    valid_dataset = datasets.CIFAR100(
+        root=data_dir, train=True,
+        download=True, transform=valid_transform,
+    )
+
+    num_train = len(train_dataset)
+    indices = list(range(num_train))
+    split = int(np.floor(valid_size * num_train))
+
+    if shuffle:
+        np.random.seed(random_seed)
+        np.random.shuffle(indices)
+
+    train_idx, valid_idx = indices[split:], indices[:split]
+    if get_val_temp > 0:
+        valid_temp_dataset = datasets.CIFAR100(
+            root=data_dir, train=True,
+            download=True, transform=valid_transform,
+        )
+        split = int(np.floor(get_val_temp * split))
+        valid_idx, valid_temp_idx = valid_idx[split:], valid_idx[:split]
+        valid_temp_sampler = SubsetRandomSampler(valid_temp_idx)
+        valid_temp_loader = torch.utils.data.DataLoader(
+            valid_temp_dataset, batch_size=batch_size, sampler=valid_temp_sampler,
+            num_workers=num_workers, pin_memory=pin_memory,
+        )
+
+    train_sampler = SubsetRandomSampler(train_idx)
+    valid_sampler = SubsetRandomSampler(valid_idx)
+
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset, batch_size=batch_size, sampler=train_sampler,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+    valid_loader = torch.utils.data.DataLoader(
+        valid_dataset, batch_size=batch_size, sampler=valid_sampler,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+    if get_val_temp > 0:
+        return (train_loader, valid_loader, valid_temp_loader)
+    else:
+        return (train_loader, valid_loader)
+
+
+def get_test_loader(batch_size,
+                    data_dir='/share/datasets/',
+                    shuffle=True,
+                    num_workers=4,
+                    pin_memory=False):
+    """
+    Utility function for loading and returning a multi-process
+    test iterator over the CIFAR-100 dataset.
+    If using CUDA, num_workers should be set to 1 and pin_memory to True.
+    Params
+    ------
+    - data_dir: path directory to the dataset.
+    - batch_size: how many samples per batch to load.
+    - shuffle: whether to shuffle the dataset after every epoch.
+    - num_workers: number of subprocesses to use when loading the dataset.
+    - pin_memory: whether to copy tensors into CUDA pinned memory. Set it to
+      True if using GPU.
+    Returns
+    -------
+    - data_loader: test set iterator.
+    """
+    normalize = transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225],
+    )
+
+    # define transform
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        normalize,
+    ])
+
+    dataset = datasets.CIFAR100(
+        root=data_dir, train=False,
+        download=True, transform=transform,
+    )
+
+    data_loader = torch.utils.data.DataLoader(
+        dataset, batch_size=batch_size, shuffle=shuffle,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+
+    return data_loader

AAAI2025-FC/dataset/svhn.py

@@ -0,0 +1,142 @@
+
+import os
+import torch
+import numpy as np
+
+from torchvision import datasets
+from torchvision import transforms
+from torch.utils.data import DataLoader
+from torch.utils.data.sampler import SubsetRandomSampler
+
+
+def get_train_valid_loader(batch_size,
+                           augment,
+                           random_seed,
+                           valid_size=0.1,
+                           shuffle=True,
+                           num_workers=4,
+                           pin_memory=False):
+    """
+    Utility function for loading and returning train and valid
+    multi-process iterators over the SVHN dataset. 
+    Params:
+    ------
+    - batch_size: how many samples per batch to load.
+    - augment: whether to apply the data augmentation scheme
+      mentioned in the paper. Only applied on the train split.
+    - random_seed: fix seed for reproducibility.
+    - valid_size: percentage split of the training set used for
+      the validation set. Should be a float in the range [0, 1].
+    - shuffle: whether to shuffle the train/validation indices.
+    - num_workers: number of subprocesses to use when loading the dataset.
+    - pin_memory: whether to copy tensors into CUDA pinned memory. Set it to
+      True if using GPU.
+    Returns
+    -------
+    - train_loader: training set iterator.
+    - valid_loader: validation set iterator.
+    """
+    error_msg = "[!] valid_size should be in the range [0, 1]."
+    assert ((valid_size >= 0) and (valid_size <= 1)), error_msg
+
+    normalize = transforms.Normalize(
+        mean=[0.4914, 0.4822, 0.4465],
+        std=[0.2023, 0.1994, 0.2010],
+    )
+
+    # define transforms
+    valid_transform = transforms.Compose([
+        transforms.ToTensor(),
+        normalize,
+    ])
+    #if augment:
+    #    train_transform = transforms.Compose([
+    #        transforms.RandomCrop(32, padding=4),
+    #        transforms.RandomHorizontalFlip(),
+    #        transforms.ToTensor(),
+    #        normalize,
+    #    ])
+    #else:
+    #    train_transform = transforms.Compose([
+    #        transforms.ToTensor(),
+    #        normalize,
+    #    ])
+
+    # load the dataset
+    data_dir = '/share/datasets'
+    train_dataset = datasets.SVHN(
+        root=data_dir, split='train',
+        download=True, transform=valid_transform,
+    )
+
+    valid_dataset = datasets.SVHN(
+        root=data_dir, split='train',
+        download=True, transform=valid_transform,
+    )
+
+    num_train = len(train_dataset)
+    indices = list(range(num_train))
+    split = int(np.floor(valid_size * num_train))
+
+    if shuffle:
+        np.random.seed(random_seed)
+        np.random.shuffle(indices)
+
+    train_idx, valid_idx = indices[split:], indices[:split]
+    train_sampler = SubsetRandomSampler(train_idx)
+    valid_sampler = SubsetRandomSampler(valid_idx)
+
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset, batch_size=batch_size, sampler=train_sampler,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+    valid_loader = torch.utils.data.DataLoader(
+        valid_dataset, batch_size=batch_size, sampler=valid_sampler,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+
+    return (train_loader, valid_loader)
+
+
+def get_test_loader(batch_size,
+                    shuffle=True,
+                    num_workers=4,
+                    pin_memory=False):
+    """
+    Utility function for loading and returning a multi-process
+    test iterator over the SVHN dataset.
+    If using CUDA, num_workers should be set to 1 and pin_memory to True.
+    Params
+    ------
+    - batch_size: how many samples per batch to load.
+    - shuffle: whether to shuffle the dataset after every epoch.
+    - num_workers: number of subprocesses to use when loading the dataset.
+    - pin_memory: whether to copy tensors into CUDA pinned memory. Set it to
+      True if using GPU.
+    Returns
+    -------
+    - data_loader: test set iterator.
+    """
+    normalize = transforms.Normalize(
+        mean=[0.4914, 0.4822, 0.4465],
+        std=[0.2023, 0.1994, 0.2010],
+    )
+
+    # define transform
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        normalize,
+    ])
+
+    data_dir = '/share/datasets'
+    dataset = datasets.SVHN(
+        root=data_dir, split='test',
+        download=True, transform=transform,
+    )
+
+    data_loader = torch.utils.data.DataLoader(
+        dataset, batch_size=batch_size, shuffle=shuffle,
+        num_workers=num_workers, pin_memory=pin_memory,
+    )
+
+    return data_loader

AAAI2025-FC/environment.yml

@@ -0,0 +1,514 @@
+name: feature-calibration
+channels:
+  - defaults
+dependencies:
+  - _anaconda_depends=2024.06=py312_mkl_2
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - abseil-cpp=20211102.0=hd4dd3e8_0
+  - aiobotocore=2.12.3=py312h06a4308_0
+  - aiohttp=3.9.5=py312h5eee18b_0
+  - aioitertools=0.7.1=pyhd3eb1b0_0
+  - aiosignal=1.2.0=pyhd3eb1b0_0
+  - alabaster=0.7.16=py312h06a4308_0
+  - altair=5.0.1=py312h06a4308_0
+  - anaconda-anon-usage=0.4.4=py312hfc0e8ea_100
+  - anaconda-catalogs=0.2.0=py312h06a4308_1
+  - anaconda-client=1.12.3=py312h06a4308_0
+  - anaconda-cloud-auth=0.5.1=py312h06a4308_0
+  - anaconda-navigator=2.6.0=py312h06a4308_0
+  - anaconda-project=0.11.1=py312h06a4308_0
+  - annotated-types=0.6.0=py312h06a4308_0
+  - anyio=4.2.0=py312h06a4308_0
+  - aom=3.6.0=h6a678d5_0
+  - appdirs=1.4.4=pyhd3eb1b0_0
+  - archspec=0.2.3=pyhd3eb1b0_0
+  - argon2-cffi=21.3.0=pyhd3eb1b0_0
+  - argon2-cffi-bindings=21.2.0=py312h5eee18b_0
+  - arrow=1.2.3=py312h06a4308_1
+  - arrow-cpp=14.0.2=h374c478_1
+  - astroid=2.14.2=py312h06a4308_0
+  - astropy=6.1.0=py312ha883a20_0
+  - astropy-iers-data=0.2024.6.3.0.31.14=py312h06a4308_0
+  - asttokens=2.0.5=pyhd3eb1b0_0
+  - async-lru=2.0.4=py312h06a4308_0
+  - atomicwrites=1.4.0=py_0
+  - attrs=23.1.0=py312h06a4308_0
+  - automat=20.2.0=py_0
+  - autopep8=2.0.4=pyhd3eb1b0_0
+  - aws-c-auth=0.6.19=h5eee18b_0
+  - aws-c-cal=0.5.20=hdbd6064_0
+  - aws-c-common=0.8.5=h5eee18b_0
+  - aws-c-compression=0.2.16=h5eee18b_0
+  - aws-c-event-stream=0.2.15=h6a678d5_0
+  - aws-c-http=0.6.25=h5eee18b_0
+  - aws-c-io=0.13.10=h5eee18b_0
+  - aws-c-mqtt=0.7.13=h5eee18b_0
+  - aws-c-s3=0.1.51=hdbd6064_0
+  - aws-c-sdkutils=0.1.6=h5eee18b_0
+  - aws-checksums=0.1.13=h5eee18b_0
+  - aws-crt-cpp=0.18.16=h6a678d5_0
+  - aws-sdk-cpp=1.10.55=h721c034_0
+  - babel=2.11.0=py312h06a4308_0
+  - bcrypt=3.2.0=py312h5eee18b_1
+  - beautifulsoup4=4.12.3=py312h06a4308_0
+  - binaryornot=0.4.4=pyhd3eb1b0_1
+  - black=24.4.2=py312h06a4308_0
+  - blas=1.0=mkl
+  - bleach=4.1.0=pyhd3eb1b0_0
+  - blinker=1.6.2=py312h06a4308_0
+  - blosc=1.21.3=h6a678d5_0
+  - bokeh=3.4.1=py312he106c6f_0
+  - boltons=23.0.0=py312h06a4308_0
+  - boost-cpp=1.82.0=hdb19cb5_2
+  - botocore=1.34.69=py312h06a4308_0
+  - bottleneck=1.3.7=py312ha883a20_0
+  - brotli=1.0.9=h5eee18b_8
+  - brotli-bin=1.0.9=h5eee18b_8
+  - brotli-python=1.0.9=py312h6a678d5_8
+  - brunsli=0.1=h2531618_0
+  - bzip2=1.0.8=h5eee18b_6
+  - c-ares=1.19.1=h5eee18b_0
+  - c-blosc2=2.12.0=h80c7b02_0
+  - ca-certificates=2024.3.11=h06a4308_0
+  - cachetools=5.3.3=py312h06a4308_0
+  - certifi=2024.6.2=py312h06a4308_0
+  - cffi=1.16.0=py312h5eee18b_1
+  - cfitsio=3.470=h5893167_7
+  - chardet=4.0.0=py312h06a4308_1003
+  - charls=2.2.0=h2531618_0
+  - charset-normalizer=2.0.4=pyhd3eb1b0_0
+  - click=8.1.7=py312h06a4308_0
+  - cloudpickle=2.2.1=py312h06a4308_0
+  - colorama=0.4.6=py312h06a4308_0
+  - colorcet=3.1.0=py312h06a4308_0
+  - comm=0.2.1=py312h06a4308_0
+  - conda=24.5.0=py312h06a4308_0
+  - conda-build=24.5.1=py312h06a4308_0
+  - conda-content-trust=0.2.0=py312h06a4308_1
+  - conda-index=0.5.0=py312h06a4308_0
+  - conda-libmamba-solver=24.1.0=pyhd3eb1b0_0
+  - conda-pack=0.7.1=py312h06a4308_0
+  - conda-package-handling=2.3.0=py312h06a4308_0
+  - conda-package-streaming=0.10.0=py312h06a4308_0
+  - conda-repo-cli=1.0.88=py312h06a4308_0
+  - conda-token=0.5.0=pyhd3eb1b0_0
+  - constantly=23.10.4=py312h06a4308_0
+  - contourpy=1.2.0=py312hdb19cb5_0
+  - cookiecutter=2.6.0=py312h06a4308_0
+  - cryptography=42.0.5=py312hdda0065_1
+  - cssselect=1.2.0=py312h06a4308_0
+  - curl=8.7.1=hdbd6064_0
+  - cycler=0.11.0=pyhd3eb1b0_0
+  - cyrus-sasl=2.1.28=h52b45da_1
+  - cytoolz=0.12.2=py312h5eee18b_0
+  - dask=2024.5.0=py312h06a4308_0
+  - dask-core=2024.5.0=py312h06a4308_0
+  - dask-expr=1.1.0=py312h06a4308_0
+  - datashader=0.16.2=py312h06a4308_0
+  - dav1d=1.2.1=h5eee18b_0
+  - dbus=1.13.18=hb2f20db_0
+  - debugpy=1.6.7=py312h6a678d5_0
+  - decorator=5.1.1=pyhd3eb1b0_0
+  - defusedxml=0.7.1=pyhd3eb1b0_0
+  - diff-match-patch=20200713=pyhd3eb1b0_0
+  - dill=0.3.8=py312h06a4308_0
+  - distributed=2024.5.0=py312h06a4308_0
+  - distro=1.9.0=py312h06a4308_0
+  - docstring-to-markdown=0.11=py312h06a4308_0
+  - docutils=0.18.1=py312h06a4308_3
+  - entrypoints=0.4=py312h06a4308_0
+  - et_xmlfile=1.1.0=py312h06a4308_1
+  - executing=0.8.3=pyhd3eb1b0_0
+  - expat=2.6.2=h6a678d5_0
+  - filelock=3.13.1=py312h06a4308_0
+  - flake8=7.0.0=py312h06a4308_0
+  - flask=3.0.3=py312h06a4308_0
+  - fmt=9.1.0=hdb19cb5_1
+  - fontconfig=2.14.1=h4c34cd2_2
+  - fonttools=4.51.0=py312h5eee18b_0
+  - freetype=2.12.1=h4a9f257_0
+  - frozendict=2.4.2=py312h06a4308_0
+  - frozenlist=1.4.0=py312h5eee18b_0
+  - fsspec=2024.3.1=py312h06a4308_0
+  - gensim=4.3.2=py312h526ad5a_0
+  - gflags=2.2.2=h6a678d5_1
+  - giflib=5.2.1=h5eee18b_3
+  - gitdb=4.0.7=pyhd3eb1b0_0
+  - gitpython=3.1.37=py312h06a4308_0
+  - glib=2.78.4=h6a678d5_0
+  - glib-tools=2.78.4=h6a678d5_0
+  - glog=0.5.0=h6a678d5_1
+  - greenlet=3.0.1=py312h6a678d5_0
+  - grpc-cpp=1.48.2=he1ff14a_1
+  - gst-plugins-base=1.14.1=h6a678d5_1
+  - gstreamer=1.14.1=h5eee18b_1
+  - h5py=3.11.0=py312h34c39bb_0
+  - hdf5=1.12.1=h2b7332f_3
+  - heapdict=1.0.1=pyhd3eb1b0_0
+  - holoviews=1.19.0=py312h06a4308_0
+  - hvplot=0.10.0=py312h06a4308_0
+  - hyperlink=21.0.0=pyhd3eb1b0_0
+  - icu=73.1=h6a678d5_0
+  - idna=3.7=py312h06a4308_0
+  - imagecodecs=2023.1.23=py312h81b8100_1
+  - imageio=2.33.1=py312h06a4308_0
+  - imagesize=1.4.1=py312h06a4308_0
+  - imbalanced-learn=0.12.3=py312h06a4308_1
+  - importlib-metadata=7.0.1=py312h06a4308_0
+  - incremental=22.10.0=pyhd3eb1b0_0
+  - inflection=0.5.1=py312h06a4308_1
+  - iniconfig=1.1.1=pyhd3eb1b0_0
+  - intake=0.7.0=py312h06a4308_0
+  - intel-openmp=2023.1.0=hdb19cb5_46306
+  - intervaltree=3.1.0=pyhd3eb1b0_0
+  - ipykernel=6.28.0=py312h06a4308_0
+  - ipython=8.25.0=py312h06a4308_0
+  - ipython_genutils=0.2.0=pyhd3eb1b0_1
+  - ipywidgets=7.8.1=py312h06a4308_0
+  - isort=5.13.2=py312h06a4308_0
+  - itemadapter=0.3.0=pyhd3eb1b0_0
+  - itemloaders=1.1.0=py312h06a4308_0
+  - itsdangerous=2.2.0=py312h06a4308_0
+  - jaraco.classes=3.2.1=pyhd3eb1b0_0
+  - jedi=0.18.1=py312h06a4308_1
+  - jeepney=0.7.1=pyhd3eb1b0_0
+  - jellyfish=1.0.1=py312hb02cf49_0
+  - jinja2=3.1.4=py312h06a4308_0
+  - jmespath=1.0.1=py312h06a4308_0
+  - joblib=1.4.2=py312h06a4308_0
+  - jpeg=9e=h5eee18b_1
+  - jq=1.6=h27cfd23_1000
+  - json5=0.9.6=pyhd3eb1b0_0
+  - jsonpatch=1.33=py312h06a4308_1
+  - jsonpointer=2.1=pyhd3eb1b0_0
+  - jsonschema=4.19.2=py312h06a4308_0
+  - jsonschema-specifications=2023.7.1=py312h06a4308_0
+  - jupyter=1.0.0=py312h06a4308_9
+  - jupyter-lsp=2.2.0=py312h06a4308_0
+  - jupyter_client=8.6.0=py312h06a4308_0
+  - jupyter_console=6.6.3=py312h06a4308_1
+  - jupyter_core=5.7.2=py312h06a4308_0
+  - jupyter_events=0.10.0=py312h06a4308_0
+  - jupyter_server=2.14.1=py312h06a4308_0
+  - jupyter_server_terminals=0.4.4=py312h06a4308_1
+  - jupyterlab=4.0.11=py312h06a4308_0
+  - jupyterlab-variableinspector=3.1.0=py312h06a4308_0
+  - jupyterlab_pygments=0.1.2=py_0
+  - jupyterlab_server=2.25.1=py312h06a4308_0
+  - jupyterlab_widgets=1.0.0=pyhd3eb1b0_1
+  - jxrlib=1.1=h7b6447c_2
+  - keyring=24.3.1=py312h06a4308_0
+  - kiwisolver=1.4.4=py312h6a678d5_0
+  - krb5=1.20.1=h143b758_1
+  - lazy-object-proxy=1.10.0=py312h5eee18b_0
+  - lazy_loader=0.4=py312h06a4308_0
+  - lcms2=2.12=h3be6417_0
+  - ld_impl_linux-64=2.38=h1181459_1
+  - lerc=3.0=h295c915_0
+  - libaec=1.0.4=he6710b0_1
+  - libarchive=3.6.2=h6ac8c49_3
+  - libavif=0.11.1=h5eee18b_0
+  - libboost=1.82.0=h109eef0_2
+  - libbrotlicommon=1.0.9=h5eee18b_8
+  - libbrotlidec=1.0.9=h5eee18b_8
+  - libbrotlienc=1.0.9=h5eee18b_8
+  - libclang=14.0.6=default_hc6dbbc7_1
+  - libclang13=14.0.6=default_he11475f_1
+  - libcups=2.4.2=h2d74bed_1
+  - libcurl=8.7.1=h251f7ec_0
+  - libdeflate=1.17=h5eee18b_1
+  - libedit=3.1.20230828=h5eee18b_0
+  - libev=4.33=h7f8727e_1
+  - libevent=2.1.12=hdbd6064_1
+  - libffi=3.4.4=h6a678d5_1
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgfortran-ng=11.2.0=h00389a5_1
+  - libgfortran5=11.2.0=h1234567_1
+  - libglib=2.78.4=hdc74915_0
+  - libgomp=11.2.0=h1234567_1
+  - libiconv=1.16=h5eee18b_3
+  - liblief=0.12.3=h6a678d5_0
+  - libllvm14=14.0.6=hdb19cb5_3
+  - libmamba=1.5.8=hfe524e5_2
+  - libmambapy=1.5.8=py312h2dafd23_2
+  - libnghttp2=1.57.0=h2d74bed_0
+  - libpng=1.6.39=h5eee18b_0
+  - libpq=12.17=hdbd6064_0
+  - libprotobuf=3.20.3=he621ea3_0
+  - libsodium=1.0.18=h7b6447c_0
+  - libsolv=0.7.24=he621ea3_1
+  - libspatialindex=1.9.3=h2531618_0
+  - libssh2=1.11.0=h251f7ec_0
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libthrift=0.15.0=h1795dd8_2
+  - libtiff=4.5.1=h6a678d5_0
+  - libuuid=1.41.5=h5eee18b_0
+  - libwebp-base=1.3.2=h5eee18b_0
+  - libxcb=1.15=h7f8727e_0
+  - libxkbcommon=1.0.1=h5eee18b_1
+  - libxml2=2.10.4=hfdd30dd_2
+  - libxslt=1.1.37=h5eee18b_1
+  - libzopfli=1.0.3=he6710b0_0
+  - linkify-it-py=2.0.0=py312h06a4308_0
+  - llvmlite=0.42.0=py312h6a678d5_0
+  - locket=1.0.0=py312h06a4308_0
+  - lxml=5.2.1=py312hdbbb534_0
+  - lz4=4.3.2=py312h5eee18b_0
+  - lz4-c=1.9.4=h6a678d5_1
+  - lzo=2.10=h7b6447c_2
+  - markdown=3.4.1=py312h06a4308_0
+  - markdown-it-py=2.2.0=py312h06a4308_1
+  - markupsafe=2.1.3=py312h5eee18b_0
+  - matplotlib=3.8.4=py312h06a4308_0
+  - matplotlib-base=3.8.4=py312h526ad5a_0
+  - matplotlib-inline=0.1.6=py312h06a4308_0
+  - mccabe=0.7.0=pyhd3eb1b0_0
+  - mdit-py-plugins=0.3.0=py312h06a4308_0
+  - mdurl=0.1.0=py312h06a4308_0
+  - menuinst=2.1.1=py312h06a4308_0
+  - mistune=2.0.4=py312h06a4308_0
+  - mkl=2023.1.0=h213fc3f_46344
+  - mkl-service=2.4.0=py312h5eee18b_1
+  - mkl_fft=1.3.8=py312h5eee18b_0
+  - mkl_random=1.2.4=py312hdb19cb5_0
+  - more-itertools=10.1.0=py312h06a4308_0
+  - mpmath=1.3.0=py312h06a4308_0
+  - msgpack-python=1.0.3=py312hdb19cb5_0
+  - multidict=6.0.4=py312h5eee18b_0
+  - multipledispatch=0.6.0=py312h06a4308_0
+  - mypy=1.10.0=py312h5eee18b_0
+  - mypy_extensions=1.0.0=py312h06a4308_0
+  - mysql=5.7.24=h721c034_2
+  - navigator-updater=0.5.1=py312h06a4308_0
+  - nbclient=0.8.0=py312h06a4308_0
+  - nbconvert=7.10.0=py312h06a4308_0
+  - nbformat=5.9.2=py312h06a4308_0
+  - ncurses=6.4=h6a678d5_0
+  - nest-asyncio=1.6.0=py312h06a4308_0
+  - networkx=3.2.1=py312h06a4308_0
+  - nltk=3.8.1=py312h06a4308_0
+  - notebook=7.0.8=py312h06a4308_0
+  - notebook-shim=0.2.3=py312h06a4308_0
+  - nspr=4.35=h6a678d5_0
+  - nss=3.89.1=h6a678d5_0
+  - numba=0.59.1=py312h526ad5a_0
+  - numexpr=2.8.7=py312hf827012_0
+  - numpy=1.26.4=py312hc5e2394_0
+  - numpy-base=1.26.4=py312h0da6c21_0
+  - numpydoc=1.7.0=py312h06a4308_0
+  - oniguruma=6.9.7.1=h27cfd23_0
+  - openjpeg=2.4.0=h3ad879b_0
+  - openpyxl=3.1.2=py312h5eee18b_0
+  - openssl=3.0.14=h5eee18b_0
+  - orc=1.7.4=hb3bc3d3_1
+  - overrides=7.4.0=py312h06a4308_0
+  - packaging=23.2=py312h06a4308_0
+  - pandas=2.2.2=py312h526ad5a_0
+  - pandocfilters=1.5.0=pyhd3eb1b0_0
+  - panel=1.4.4=py312h06a4308_0
+  - param=2.1.0=py312h06a4308_0
+  - parsel=1.8.1=py312h06a4308_0
+  - parso=0.8.3=pyhd3eb1b0_0
+  - partd=1.4.1=py312h06a4308_0
+  - patch=2.7.6=h7b6447c_1001
+  - patchelf=0.17.2=h6a678d5_0
+  - pathspec=0.10.3=py312h06a4308_0
+  - patsy=0.5.6=py312h06a4308_0
+  - pcre2=10.42=hebb0a14_1
+  - pexpect=4.8.0=pyhd3eb1b0_3
+  - pickleshare=0.7.5=pyhd3eb1b0_1003
+  - pillow=10.3.0=py312h5eee18b_0
+  - pip=24.0=py312h06a4308_0
+  - pkce=1.0.3=py312h06a4308_0
+  - pkginfo=1.10.0=py312h06a4308_0
+  - platformdirs=3.10.0=py312h06a4308_0
+  - plotly=5.22.0=py312he106c6f_0
+  - pluggy=1.0.0=py312h06a4308_1
+  - ply=3.11=py312h06a4308_1
+  - prometheus_client=0.14.1=py312h06a4308_0
+  - prompt-toolkit=3.0.43=py312h06a4308_0
+  - prompt_toolkit=3.0.43=hd3eb1b0_0
+  - protego=0.1.16=py_0
+  - protobuf=3.20.3=py312h6a678d5_0
+  - psutil=5.9.0=py312h5eee18b_0
+  - ptyprocess=0.7.0=pyhd3eb1b0_2
+  - pure_eval=0.2.2=pyhd3eb1b0_0
+  - py-cpuinfo=9.0.0=py312h06a4308_0
+  - py-lief=0.12.3=py312h6a678d5_0
+  - pyarrow=14.0.2=py312hb107042_0
+  - pyasn1=0.4.8=pyhd3eb1b0_0
+  - pyasn1-modules=0.2.8=py_0
+  - pybind11-abi=5=hd3eb1b0_0
+  - pycodestyle=2.11.1=py312h06a4308_0
+  - pycosat=0.6.6=py312h5eee18b_1
+  - pycparser=2.21=pyhd3eb1b0_0
+  - pyct=0.5.0=py312h06a4308_0
+  - pycurl=7.45.2=py312hdbd6064_1
+  - pydantic=2.5.3=py312h06a4308_0
+  - pydantic-core=2.14.6=py312hb02cf49_0
+  - pydeck=0.8.0=py312h06a4308_2
+  - pydispatcher=2.0.5=py312h06a4308_3
+  - pydocstyle=6.3.0=py312h06a4308_0
+  - pyerfa=2.0.1.4=py312ha883a20_0
+  - pyflakes=3.2.0=py312h06a4308_0
+  - pygments=2.15.1=py312h06a4308_1
+  - pyjwt=2.8.0=py312h06a4308_0
+  - pylint=2.16.2=py312h06a4308_0
+  - pylint-venv=3.0.3=py312h06a4308_0
+  - pyls-spyder=0.4.0=pyhd3eb1b0_0
+  - pyodbc=5.0.1=py312h6a678d5_0
+  - pyopenssl=24.0.0=py312h06a4308_0
+  - pyparsing=3.0.9=py312h06a4308_0
+  - pyqt=5.15.10=py312h6a678d5_0
+  - pyqt5-sip=12.13.0=py312h5eee18b_0
+  - pyqtwebengine=5.15.10=py312h6a678d5_0
+  - pysocks=1.7.1=py312h06a4308_0
+  - pytables=3.9.2=py312h387d6ec_0
+  - pytest=7.4.4=py312h06a4308_0
+  - python=3.12.4=h5148396_1
+  - python-dateutil=2.9.0post0=py312h06a4308_2
+  - python-dotenv=0.21.0=py312h06a4308_0
+  - python-fastjsonschema=2.16.2=py312h06a4308_0
+  - python-json-logger=2.0.7=py312h06a4308_0
+  - python-libarchive-c=2.9=pyhd3eb1b0_1
+  - python-lmdb=1.4.1=py312h6a678d5_0
+  - python-lsp-black=2.0.0=py312h06a4308_0
+  - python-lsp-jsonrpc=1.1.2=pyhd3eb1b0_0
+  - python-lsp-server=1.10.0=py312h06a4308_0
+  - python-slugify=5.0.2=pyhd3eb1b0_0
+  - python-snappy=0.6.1=py312h6a678d5_0
+  - python-tzdata=2023.3=pyhd3eb1b0_0
+  - pytoolconfig=1.2.6=py312h06a4308_0
+  - pytz=2024.1=py312h06a4308_0
+  - pyviz_comms=3.0.2=py312h06a4308_0
+  - pywavelets=1.5.0=py312ha883a20_0
+  - pyxdg=0.27=pyhd3eb1b0_0
+  - pyyaml=6.0.1=py312h5eee18b_0
+  - pyzmq=25.1.2=py312h6a678d5_0
+  - qdarkstyle=3.2.3=pyhd3eb1b0_0
+  - qstylizer=0.2.2=py312h06a4308_0
+  - qt-main=5.15.2=h53bd1ea_10
+  - qt-webengine=5.15.9=h9ab4d14_7
+  - qtawesome=1.2.2=py312h06a4308_0
+  - qtconsole=5.5.1=py312h06a4308_0
+  - qtpy=2.4.1=py312h06a4308_0
+  - queuelib=1.6.2=py312h06a4308_0
+  - re2=2022.04.01=h295c915_0
+  - readline=8.2=h5eee18b_0
+  - referencing=0.30.2=py312h06a4308_0
+  - regex=2023.10.3=py312h5eee18b_0
+  - reproc=14.2.4=h6a678d5_2
+  - reproc-cpp=14.2.4=h6a678d5_2
+  - requests=2.32.2=py312h06a4308_0
+  - requests-file=1.5.1=pyhd3eb1b0_0
+  - requests-toolbelt=1.0.0=py312h06a4308_0
+  - rfc3339-validator=0.1.4=py312h06a4308_0
+  - rfc3986-validator=0.1.1=py312h06a4308_0
+  - rich=13.3.5=py312h06a4308_1
+  - rope=1.12.0=py312h06a4308_0
+  - rpds-py=0.10.6=py312hb02cf49_0
+  - rtree=1.0.1=py312h06a4308_0
+  - ruamel.yaml=0.17.21=py312h5eee18b_0
+  - ruamel_yaml=0.17.21=py312h5eee18b_0
+  - s2n=1.3.27=hdbd6064_0
+  - s3fs=2024.3.1=py312h06a4308_0
+  - scikit-image=0.23.2=py312h526ad5a_0
+  - scikit-learn=1.4.2=py312h526ad5a_1
+  - scipy=1.13.1=py312hc5e2394_0
+  - scrapy=2.11.1=py312h06a4308_0
+  - seaborn=0.13.2=py312h06a4308_0
+  - secretstorage=3.3.1=py312h06a4308_1
+  - semver=3.0.2=py312h06a4308_0
+  - send2trash=1.8.2=py312h06a4308_0
+  - service_identity=18.1.0=pyhd3eb1b0_1
+  - setuptools=69.5.1=py312h06a4308_0
+  - sip=6.7.12=py312h6a678d5_0
+  - six=1.16.0=pyhd3eb1b0_1
+  - smart_open=5.2.1=py312h06a4308_0
+  - smmap=4.0.0=pyhd3eb1b0_0
+  - snappy=1.1.10=h6a678d5_1
+  - sniffio=1.3.0=py312h06a4308_0
+  - snowballstemmer=2.2.0=pyhd3eb1b0_0
+  - sortedcontainers=2.4.0=pyhd3eb1b0_0
+  - soupsieve=2.5=py312h06a4308_0
+  - sphinx=7.3.7=py312h5eee18b_0
+  - sphinxcontrib-applehelp=1.0.2=pyhd3eb1b0_0
+  - sphinxcontrib-devhelp=1.0.2=pyhd3eb1b0_0
+  - sphinxcontrib-htmlhelp=2.0.0=pyhd3eb1b0_0
+  - sphinxcontrib-jsmath=1.0.1=pyhd3eb1b0_0
+  - sphinxcontrib-qthelp=1.0.3=pyhd3eb1b0_0
+  - sphinxcontrib-serializinghtml=1.1.10=py312h06a4308_0
+  - spyder=5.5.1=py312h06a4308_0
+  - spyder-kernels=2.5.0=py312h06a4308_0
+  - sqlalchemy=2.0.30=py312h5eee18b_0
+  - sqlite=3.45.3=h5eee18b_0
+  - stack_data=0.2.0=pyhd3eb1b0_0
+  - statsmodels=0.14.2=py312ha883a20_0
+  - streamlit=1.32.0=py312h06a4308_0
+  - sympy=1.12=py312h06a4308_0
+  - tabulate=0.9.0=py312h06a4308_0
+  - tbb=2021.8.0=hdb19cb5_0
+  - tblib=1.7.0=pyhd3eb1b0_0
+  - tenacity=8.2.2=py312h06a4308_1
+  - terminado=0.17.1=py312h06a4308_0
+  - text-unidecode=1.3=pyhd3eb1b0_0
+  - textdistance=4.2.1=pyhd3eb1b0_0
+  - threadpoolctl=2.2.0=pyh0d69192_0
+  - three-merge=0.1.1=pyhd3eb1b0_0
+  - tifffile=2023.4.12=py312h06a4308_0
+  - tinycss2=1.2.1=py312h06a4308_0
+  - tk=8.6.14=h39e8969_0
+  - tldextract=3.2.0=pyhd3eb1b0_0
+  - toml=0.10.2=pyhd3eb1b0_0
+  - tomli=2.0.1=py312h06a4308_1
+  - tomlkit=0.11.1=py312h06a4308_0
+  - toolz=0.12.0=py312h06a4308_0
+  - tornado=6.4.1=py312h5eee18b_0
+  - tqdm=4.66.4=py312he106c6f_0
+  - traitlets=5.14.3=py312h06a4308_0
+  - truststore=0.8.0=py312h06a4308_0
+  - twisted=23.10.0=py312h06a4308_0
+  - typing-extensions=4.11.0=py312h06a4308_0
+  - typing_extensions=4.11.0=py312h06a4308_0
+  - tzdata=2024a=h04d1e81_0
+  - uc-micro-py=1.0.1=py312h06a4308_0
+  - ujson=5.10.0=py312h6a678d5_0
+  - unicodedata2=15.1.0=py312h5eee18b_0
+  - unidecode=1.2.0=pyhd3eb1b0_0
+  - unixodbc=2.3.11=h5eee18b_0
+  - urllib3=2.2.2=py312h06a4308_0
+  - utf8proc=2.6.1=h5eee18b_1
+  - w3lib=1.21.0=pyhd3eb1b0_0
+  - watchdog=4.0.1=py312h06a4308_0
+  - wcwidth=0.2.5=pyhd3eb1b0_0
+  - webencodings=0.5.1=py312h06a4308_2
+  - websocket-client=1.8.0=py312h06a4308_0
+  - werkzeug=3.0.3=py312h06a4308_0
+  - whatthepatch=1.0.2=py312h06a4308_0
+  - wheel=0.43.0=py312h06a4308_0
+  - widgetsnbextension=3.6.6=py312h06a4308_0
+  - wrapt=1.14.1=py312h5eee18b_0
+  - wurlitzer=3.0.2=py312h06a4308_0
+  - xarray=2023.6.0=py312h06a4308_0
+  - xyzservices=2022.9.0=py312h06a4308_1
+  - xz=5.4.6=h5eee18b_1
+  - yaml=0.2.5=h7b6447c_0
+  - yaml-cpp=0.8.0=h6a678d5_1
+  - yapf=0.40.2=py312h06a4308_0
+  - yarl=1.9.3=py312h5eee18b_0
+  - zeromq=4.3.5=h6a678d5_0
+  - zfp=1.0.0=h6a678d5_0
+  - zict=3.0.0=py312h06a4308_0
+  - zipp=3.17.0=py312h06a4308_0
+  - zlib=1.2.13=h5eee18b_1
+  - zlib-ng=2.0.7=h5eee18b_0
+  - zope=1.0=py312h06a4308_1
+  - zope.interface=5.4.0=py312h5eee18b_0
+  - zstandard=0.22.0=py312h2c38b39_0
+  - zstd=1.5.5=hc292b87_2
+  - pip:
+      - nvidia-ml-py==12.535.161
+      - nvitop==1.3.2
+      - termcolor==2.4.0
+prefix: /home/lwtao/anaconda3

AAAI2025-FC/evaluate.py

@@ -0,0 +1,622 @@
+import torch
+import argparse
+from torch import nn
+import torch.nn.functional as F
+import torch.backends.cudnn as cudnn
+import pandas as pd
+import numpy as np
+from omegaconf import OmegaConf # yaml config for group calibration
+import torchvision
+from torchvision import transforms
+from torch.utils.data import DataLoader, random_split
+import random
+import os
+
+# Import dataloaders
+import dataset.cifar10 as cifar10
+import dataset.cifar100 as cifar100
+
+# Import network architectures
+from models.resnet import resnet50, resnet110
+from models.densenet import densenet121
+from models.resnet_imagenet import ResNet_ImageNet
+from models.densenet_imagenet import DenseNet121_ImageNet
+from models.wide_resnet_imagenet import Wide_ResNet_ImageNet
+from models.mobilenet_v2_imagenet import MobileNet_V2_ImageNet
+
+# Import metrics to compute
+from metrics.metrics import test_classification_net_logits
+from metrics.metrics import ECELoss, AdaptiveECELoss, ClasswiseECELoss
+
+# Import post hoc calibration methods
+from calibration.feature_clipping import FeatureClippingCalibrator
+from calibration.pts_cts_ets import calibrator, calibrator_mapping, dataloader, dataset_mapping, loss_mapping, opt
+from calibration.group_calibration.methods import calibrate
+from calibrator import LogitClippingCalibrator
+
+
+# Dataset params
+dataset_num_classes = {
+    'cifar10': 10,
+    'cifar100': 100,
+    'imagenet': 1000
+}
+
+dataset_loader = {
+    'cifar10': cifar10,
+    'cifar100': cifar100,
+}
+
+# Mapping model name to model function
+cifar_models = {
+    'resnet50': resnet50,
+    'resnet110': resnet110,
+    'densenet121': densenet121
+}
+imagenet_models = {
+    'resnet50': ResNet_ImageNet(weights=torchvision.models.ResNet50_Weights.IMAGENET1K_V1),
+    'densenet121': DenseNet121_ImageNet(weights=torchvision.models.DenseNet121_Weights.IMAGENET1K_V1),
+    'wide_resnet': Wide_ResNet_ImageNet(weights=torchvision.models.Wide_ResNet50_2_Weights.IMAGENET1K_V2),
+    'mobilenet_v2': MobileNet_V2_ImageNet(weights=torchvision.models.MobileNet_V2_Weights.IMAGENET1K_V2),
+    'vit_l_16':torchvision.models.vit_l_16(weights=torchvision.models.ViT_L_16_Weights.IMAGENET1K_V1),
+}
+
+def parseArgs():
+    default_dataset = 'cifar10'
+    dataset_root = '/share/datasets'
+    num_bins = 15
+    model_name = None
+    train_batch_size = 128
+    test_batch_size = 512
+    cross_validation_error = 'ece'
+
+    parser = argparse.ArgumentParser(
+        description="Evaluating a single model on calibration metrics.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument("--dataset", type=str, default=default_dataset,
+                        dest="dataset", help='dataset to test on')
+    parser.add_argument("--dataset-root", type=str, default=dataset_root,
+                        dest="dataset_root", help='root path of the dataset')
+    parser.add_argument("--model-name", type=str, default=model_name,
+                        dest="model_name", help='name of the model')
+    parser.add_argument("--num-bins", type=int, default=num_bins, dest="num_bins",
+                        help='Number of bins')
+    parser.add_argument("-g", action="store_true", dest="gpu",
+                        help="Use GPU")
+    parser.set_defaults(gpu=True)
+    parser.add_argument("-da", action="store_true", dest="data_aug",
+                        help="Using data augmentation")
+    parser.set_defaults(data_aug=True)
+    parser.add_argument("-b", type=int, default=train_batch_size,
+                        dest="train_batch_size", help="Batch size")
+    parser.add_argument("-tb", type=int, default=test_batch_size,
+                        dest="test_batch_size", help="Test Batch size")
+    parser.add_argument("--feature_clamp", type=float, default=0.3)
+    parser.add_argument("--cverror", type=str, default=cross_validation_error,
+                        dest="cross_validation_error", help='Error function to do temp scaling')
+    parser.add_argument("--debug", action="store_true", dest="debug",
+                        help="whether to debug the code")
+    parser.add_argument("--loss", type=str, default='cross_entropy')
+    parser.add_argument("--weights_dir", type=str, default='/share/pretrained_weights')
+    parser.add_argument("--fc_type", type=str, default='fc')
+    
+    
+    return parser.parse_args()
+
+
+def get_logits_labels(data_loader, net, return_feature=False):
+    logits_list = []
+    labels_list = []
+    features_list = []
+    net.eval()
+    if return_feature:
+        with torch.no_grad():
+            for data, label in data_loader:
+                data = data.cuda()
+                logits, features = net(data, return_feature=return_feature)
+                logits_list.append(logits)
+                labels_list.append(label)
+                features_detach = features.detach().cpu()
+                features_list.append(features_detach)
+            logits = torch.cat(logits_list).cuda()
+            labels = torch.cat(labels_list).cuda()
+            features = torch.cat(features_list).cuda()
+        return logits, labels, features
+    else:
+        with torch.no_grad():
+            for data, label in data_loader:
+                data = data.cuda()
+                logits = net(data)
+                logits_list.append(logits)
+                labels_list.append(label)
+            logits = torch.cat(logits_list).cuda()
+            labels = torch.cat(labels_list).cuda()
+        return logits, labels
+
+
+if __name__ == "__main__":
+
+    # Checking if GPU is available
+    cuda = False
+    if (torch.cuda.is_available()):
+        cuda = True
+
+    # Setting additional parameters
+    torch.manual_seed(1)
+    device = torch.device("cuda" if cuda else "cpu")
+
+    args = parseArgs()
+
+    dataset = args.dataset
+    dataset_root = args.dataset_root
+    args.n_class = dataset_num_classes[dataset]
+    model_name = args.model_name
+    num_bins = args.num_bins
+    cross_validation_error = args.cross_validation_error
+    
+    # define the calibration criterion
+    nll_criterion = nn.CrossEntropyLoss().cuda()
+    ece_criterion = ECELoss().cuda()
+    adaece_criterion = AdaptiveECELoss().cuda()
+    cece_criterion = ClasswiseECELoss().cuda()
+
+    # load the datasets
+    num_classes = dataset_num_classes[dataset]
+    if (args.dataset == 'tiny_imagenet'):
+        val_loader = dataset_loader[args.dataset].get_data_loader(
+            root=args.dataset_root,
+            split='val',
+            batch_size=args.test_batch_size,
+            pin_memory=args.gpu)
+
+        test_loader = dataset_loader[args.dataset].get_data_loader(
+            root=args.dataset_root,
+            split='val',
+            batch_size=args.test_batch_size,
+            pin_memory=args.gpu)
+    elif (args.dataset == 'cifar10' or args.dataset == 'cifar100'):
+        _, val_loader = dataset_loader[args.dataset].get_train_valid_loader(
+            batch_size=args.train_batch_size,
+            augment=args.data_aug,
+            random_seed=1,
+            pin_memory=args.gpu
+        )
+        test_loader = dataset_loader[args.dataset].get_test_loader(
+            batch_size=args.test_batch_size,
+            pin_memory=args.gpu,
+        )
+    elif (args.dataset == 'imagenet'):
+        # split 20% of the val set as validation set and the rest 80% as the test set
+        # Define the transformation
+        transform = transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                     std=[0.229, 0.224, 0.225]),
+        ])
+
+        # Load the entire validation dataset
+        full_val_set = torchvision.datasets.ImageFolder(
+            root=args.dataset_root + '/imagenet/val',
+            transform=transform,
+        )
+
+        # Calculate lengths for validation and test sets
+        val_size = int(0.2 * len(full_val_set))
+        test_size = len(full_val_set) - val_size
+
+        # Split the dataset
+        seed = 42
+        torch.manual_seed(seed)
+        random.seed(seed)
+        np.random.seed(seed)
+        val_set, test_set = random_split(full_val_set, [val_size, test_size])
+
+        # Create DataLoaders
+        val_loader = DataLoader(val_set, batch_size=args.test_batch_size, shuffle=True)
+        test_loader = DataLoader(test_set, batch_size=args.test_batch_size, shuffle=True)
+
+
+    # Load the model
+    if (args.dataset == 'cifar10' or args.dataset == 'cifar100'):
+        model = cifar_models[model_name]
+        net = model(num_classes=num_classes).cuda()
+        weight = torch.load(f"{args.weights_dir}/{args.dataset}_{args.model_name}_{args.loss}.model", weights_only=True)
+        # modify the key name, remove the 'module.'
+        new_weight = {k.replace('module.', ''): v for k, v in weight.items()}
+        net.load_state_dict(new_weight)
+        net.classifier = net.classifier
+    elif (args.dataset == 'imagenet'):
+        model = imagenet_models[model_name]
+        net = model.cuda()
+
+
+    # if file not exist, calculated logits, feature and labels
+    logit_path = f'pre_calculated_logits/{args.dataset}/{args.model_name}_{args.loss}.pt'
+    if not os.path.exists(logit_path):
+        os.makedirs(os.path.dirname(logit_path), exist_ok=True)
+        logits_val, labels_val, features_val = get_logits_labels(val_loader, net, return_feature=True)
+        logits_test, labels_test, features_test = get_logits_labels(test_loader, net, return_feature=True)
+
+        torch.save({
+            'logits_val': logits_val,
+            'labels_val': labels_val,
+            'features_val': features_val,
+            'logits_test': logits_test,
+            'labels_test': labels_test,
+            'features_test': features_test,
+        }, logit_path)    
+
+    # load logits, feature and labels
+    data = torch.load(logit_path, weights_only=False)
+    logits_val = data['logits_val']
+    labels_val = data['labels_val']
+    features_val = data['features_val']
+    logits_test = data['logits_test']
+    labels_test = data['labels_test']
+    features_test = data['features_test']
+
+    '''
+    practice the feature clipping calibration
+    '''
+    fc_cal = FeatureClippingCalibrator(net, cross_validate=cross_validation_error)
+    C_opt_fc = fc_cal.set_feature_clip(features_val, logits_val, labels_val)
+
+    logits_val_fc, labels_val_fc, features_val_fc = fc_cal(features_val, C_opt_fc), labels_val, fc_cal.feature_clipping(features_val, C_opt_fc)
+    logits_test_fc, labels_test_fc, features_test_fc = fc_cal(features_test, C_opt_fc), labels_test, fc_cal.feature_clipping(features_test, C_opt_fc)
+    data['logits_val_fc'], data['labels_val_fc'], data['features_val_fc'] = logits_val_fc.detach(), labels_val_fc.detach(), features_val_fc.detach()
+    data['logits_test_fc'], data['labels_test_fc'], data['features_test_fc'] = logits_test_fc.detach(), labels_test_fc.detach(), features_test_fc.detach()
+    logits_val_fc = data['logits_val_fc']
+    labels_val_fc = data['labels_val_fc']
+    features_val_fc = data['features_val_fc']
+    logits_test_fc = data['logits_test_fc']
+    labels_test_fc = data['labels_test_fc']
+    features_test_fc = data['features_test_fc']
+
+    '''
+    practice the logit clipping calibration
+    '''
+    lc_cal = LogitClippingCalibrator()
+    C_opt_lc = lc_cal.fit(logits_val, labels_val)
+    logits_val_lc = lc_cal.calibrate(logits_val, return_logits=True)
+    logits_test_lc = lc_cal.calibrate(logits_test, return_logits=True)
+    labels_val_lc = data['labels_val']
+    labels_test_lc = data['labels_test']
+    data['logits_val_lc'], data['labels_val_lc'] = logits_val_lc.detach(), labels_val_lc.detach()
+    data['logits_test_lc'], data['labels_test_lc'] = logits_test_lc.detach(), labels_test_lc.detach()
+
+    fc_logit_path = f'pre_calculated_logits/{args.dataset}/{args.model_name}_{args.loss}_fc.pt'
+    torch.save(data, fc_logit_path)
+
+    
+
+    
+    print("=="*20)
+    print(args.model_name, args.dataset, args.loss)
+    print("=="*20)
+
+    # evalution results
+    results = {
+        "cal": [],
+        "ece":[],
+        "adaece":[],
+        "cece":[],
+        "nll":[],
+        "accuracy":[]
+    }
+    run_methods = ['Vanilla', 'TS', 'FC', 'FC_TS']
+    # run_methods = ['Vanilla', 'LC', 'FC', 'LC_TS', 'FC_TS', 'ETS', 'FC_ETS', 'PTS', 'FC_PTS', 'CTS', 'FC_CTS', 'GC', 'FC_GC']
+    # vanilla
+    if "Vanilla" in run_methods:
+        ece = ece_criterion(logits_test, labels_test).item()
+        adaece = adaece_criterion(logits_test, labels_test).item()
+        cece = cece_criterion(logits_test, labels_test).item()
+        nll = nll_criterion(logits_test, labels_test).item()
+        accuracy = logits_test.argmax(dim=1).eq(labels_test).float().mean().item()
+        print(f"Vanilla: ECE={round(ece*100, 2)}, Accuracy={round(accuracy*100, 2)}")
+        results['cal'].append('Vanilla')
+        results['ece'].append(ece)
+        results['adaece'].append(adaece)
+        results['cece'].append(cece)
+        results['nll'].append(nll)
+        results['accuracy'].append(accuracy)
+
+    # LC
+    if "LC" in run_methods:
+        accuracy_lc = logits_test_lc.argmax(dim=1).eq(labels_test_lc).float().mean().item()
+        ece_lc = ece_criterion(logits_test_lc, labels_test_lc).item()
+        adaece_lc = adaece_criterion(logits_test_lc, labels_test_lc).item()
+        cece_lc = cece_criterion(logits_test_lc, labels_test_lc).item()
+        nll_lc = nll_criterion(logits_test_lc, labels_test_lc).item()
+        print(f"LC(C={round(C_opt_lc,2)}): ECE={round(ece_lc*100, 2)}, Accuracy={round(accuracy_lc*100, 2)}")
+        results['cal'].append(f'LC(C={round(C_opt_lc,2)})')
+        results['ece'].append(ece_lc)
+        results['adaece'].append(adaece_lc)
+        results['cece'].append(cece_lc)
+        results['nll'].append(nll_lc)
+        results['accuracy'].append(accuracy_lc)
+
+    # FC
+    if "FC" in run_methods:
+        accuracy_fc = logits_test_fc.argmax(dim=1).eq(labels_test_fc).float().mean().item()
+        ece_fc = ece_criterion(logits_test_fc, labels_test_fc).item()
+        adaece_fc = adaece_criterion(logits_test_fc, labels_test_fc).item()
+        cece_fc = cece_criterion(logits_test_fc, labels_test_fc).item()
+        nll_fc = nll_criterion(logits_test_fc, labels_test_fc).item()
+        print(f"FC(C={round(C_opt_fc,2)}): ECE={round(ece_fc*100, 2)}, Accuracy={round(accuracy_fc*100, 2)}")
+        results['cal'].append(f'FC(C={round(C_opt_fc,2)})')
+        results['ece'].append(ece_fc)
+        results['adaece'].append(adaece_fc)
+        results['cece'].append(cece_fc)
+        results['nll'].append(nll_fc)
+        results['accuracy'].append(accuracy_fc)
+
+    # TS
+    if "TS" in run_methods:
+        args.cal = 'TS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val, labels_val)
+        logits_ts = cbt(logits_test)
+        ece_ts = ece_criterion(logits_ts, labels_test).item()
+        adaece_ts = adaece_criterion(logits_ts, labels_test).item()
+        cece_ts = cece_criterion(logits_ts, labels_test).item()
+        nll_ts = nll_criterion(logits_ts, labels_test).item()
+        accuracy_ts = logits_ts.argmax(dim=1).eq(labels_test).float().mean().item()
+        print(f"TS: ECE={round(ece_ts*100, 2)}, Accuracy={round(accuracy_ts*100, 2)}")
+        results['cal'].append('TS')
+        results['ece'].append(ece_ts)
+        results['adaece'].append(adaece_ts)
+        results['cece'].append(cece_ts)
+        results['nll'].append(nll_ts)
+        results['accuracy'].append(accuracy_ts)
+
+    # LC then TS
+    if "LC_TS" in run_methods:
+        args.cal = 'TS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val_lc, labels_val_lc)
+        logits_lc_ts = cbt(logits_test_lc)
+        ece_lc_ts = ece_criterion(logits_lc_ts, labels_test_lc).item()
+        adaece_lc_ts = adaece_criterion(logits_lc_ts, labels_test_lc).item()
+        cece_lc_ts = cece_criterion(logits_lc_ts, labels_test_lc).item()
+        nll_lc_ts = nll_criterion(logits_lc_ts, labels_test_lc).item()
+        accuracy_lc_ts = logits_lc_ts.argmax(dim=1).eq(labels_test_lc).float().mean().item()
+        print(f"LC_TS: ECE={round(ece_lc_ts*100, 2)}, Accuracy={round(accuracy_lc_ts*100, 2)}")
+        results['cal'].append('LC_TS')
+        results['ece'].append(ece_lc_ts)
+        results['adaece'].append(adaece_lc_ts)
+        results['cece'].append(cece_lc_ts)
+        results['nll'].append(nll_lc_ts)
+        results['accuracy'].append(accuracy_lc_ts)
+
+    # FC then TS
+    if "FC_TS" in run_methods:
+        args.cal = 'TS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val_fc, labels_val_fc)
+        logits_fc_ts = cbt(logits_test_fc)
+        ece_fc_ts = ece_criterion(logits_fc_ts, labels_test_fc).item()
+        adaece_fc_ts = adaece_criterion(logits_fc_ts, labels_test_fc).item()
+        cece_fc_ts = cece_criterion(logits_fc_ts, labels_test_fc).item()
+        nll_fc_ts = nll_criterion(logits_fc_ts, labels_test_fc).item()
+        accuracy_fc_ts = logits_fc_ts.argmax(dim=1).eq(labels_test_fc).float().mean().item()
+        print(f"FC_TS: ECE={round(ece_fc_ts*100, 2)}, Accuracy={round(accuracy_fc_ts*100, 2)}")
+        results['cal'].append('FC_TS')
+        results['ece'].append(ece_fc_ts)
+        results['adaece'].append(adaece_fc_ts)
+        results['cece'].append(cece_fc_ts)
+        results['nll'].append(nll_fc_ts)
+        results['accuracy'].append(accuracy_fc_ts)
+
+
+    # ETS
+    if "ETS" in run_methods:
+        args.cal = 'ETS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val, labels_val)
+        logits_ets = cbt(logits_test)
+        ece_ets = ece_criterion(logits_ets, labels_test).item()
+        adaece_ets = adaece_criterion(logits_ets, labels_test).item()
+        cece_ets = cece_criterion(logits_ets, labels_test).item()
+        nll_ets = nll_criterion(logits_ets, labels_test).item()
+        accuracy_ets = logits_ets.argmax(dim=1).eq(labels_test).float().mean().item()
+        print(f"ETS: ECE={round(ece_ets*100, 2)}, Accuracy={round(accuracy_ets*100, 2)}")
+        results['cal'].append('ETS')
+        results['ece'].append(ece_ets)
+        results['adaece'].append(adaece_ets)
+        results['cece'].append(cece_ets)
+        results['nll'].append(nll_ets)
+        results['accuracy'].append(accuracy_ets)
+
+    # FC then ETS
+    if "FC_ETS" in run_methods:
+        args.cal = 'ETS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val_fc, labels_val_fc)
+        logits_fc_ets = cbt(logits_test_fc)
+        ece_fc_ets = ece_criterion(logits_fc_ets, labels_test_fc).item()
+        adaece_fc_ets = adaece_criterion(logits_fc_ets, labels_test_fc).item()
+        cece_fc_ets = cece_criterion(logits_fc_ets, labels_test_fc).item()
+        nll_fc_ets = nll_criterion(logits_fc_ets, labels_test_fc).item()
+        accuracy_fc_ets = logits_fc_ets.argmax(dim=1).eq(labels_test_fc).float().mean().item()
+        print(f"FC_ETS: ECE={round(ece_fc_ets*100, 2)}, Accuracy={round(accuracy_fc_ets*100, 2)}")
+        results['cal'].append('FC_ETS')
+        results['ece'].append(ece_fc_ets)
+        results['adaece'].append(adaece_fc_ets)
+        results['cece'].append(cece_fc_ets)
+        results['nll'].append(nll_fc_ets)
+        results['accuracy'].append(accuracy_fc_ets)
+
+
+    # PTS
+    if "PTS" in run_methods:
+        args.cal = 'PTS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val, labels_val)
+        logits_pts = cbt(logits_test)
+        ece_pts = ece_criterion(logits_pts, labels_test).item()
+        adaece_pts = adaece_criterion(logits_pts, labels_test).item()
+        cece_pts = cece_criterion(logits_pts, labels_test).item()
+        nll_pts = nll_criterion(logits_pts, labels_test).item()
+        accuracy_pts = logits_pts.argmax(dim=1).eq(labels_test).float().mean().item()
+        print(f"PTS: ECE={round(ece_pts*100, 2)}, Accuracy={round(accuracy_pts*100, 2)}")
+        results['cal'].append('PTS')
+        results['ece'].append(ece_pts)
+        results['adaece'].append(adaece_pts)
+        results['cece'].append(cece_pts)
+        results['nll'].append(nll_pts)
+        results['accuracy'].append(accuracy_pts)
+    
+    # FC then PTS
+    if "FC_PTS" in run_methods:
+        args.cal = 'PTS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val_fc, labels_val_fc)
+        logits_fc_pts = cbt(logits_test_fc)
+        ece_fc_pts = ece_criterion(logits_fc_pts, labels_test_fc).item()
+        adaece_fc_pts = adaece_criterion(logits_fc_pts, labels_test_fc).item()
+        cece_fc_pts = cece_criterion(logits_fc_pts, labels_test_fc).item()
+        nll_fc_pts = nll_criterion(logits_fc_pts, labels_test_fc).item()
+        accuracy_fc_pts = logits_fc_pts.argmax(dim=1).eq(labels_test_fc).float().mean().item()
+        print(f"FC_PTS: ECE={round(ece_fc_pts*100, 2)}, Accuracy={round(accuracy_fc_pts*100, 2)}")
+        results['cal'].append('FC_PTS')
+        results['ece'].append(ece_fc_pts)
+        results['adaece'].append(adaece_fc_pts)
+        results['cece'].append(cece_fc_pts)
+        results['nll'].append(nll_fc_pts)
+        results['accuracy'].append(accuracy_fc_pts)
+
+
+    # CTS
+    if "CTS" in run_methods:
+        args.cal = 'CTS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val, labels_val)
+        logits_cts = cbt(logits_test)
+        ece_cts = ece_criterion(logits_cts, labels_test).item()
+        adaece_cts = adaece_criterion(logits_cts, labels_test).item()
+        cece_cts = cece_criterion(logits_cts, labels_test).item()
+        nll_cts = nll_criterion(logits_cts, labels_test).item()
+        accuracy_cts = logits_cts.argmax(dim=1).eq(labels_test).float().mean().item()
+        print(f"CTS: ECE={round(ece_cts*100, 2)}, Accuracy={round(accuracy_cts*100, 2)}")
+        results['cal'].append('CTS')
+        results['ece'].append(ece_cts)
+        results['adaece'].append(adaece_cts)
+        results['cece'].append(cece_cts)
+        results['nll'].append(nll_cts)
+        results['accuracy'].append(accuracy_cts)
+    
+    if "FC_CTS" in run_methods:
+        # FC then CTS
+        args.cal = 'PTS'
+        cbt = calibrator(args).cuda()
+        cbt.train(logits_val_fc, labels_val_fc)
+        logits_fc_cts = cbt(logits_test_fc)
+        ece_fc_cts = ece_criterion(logits_fc_cts, labels_test_fc).item()
+        adaece_fc_cts = adaece_criterion(logits_fc_cts, labels_test_fc).item()
+        cece_fc_cts = cece_criterion(logits_fc_cts, labels_test_fc).item()
+        nll_fc_cts = nll_criterion(logits_fc_cts, labels_test_fc).item()
+        accuracy_fc_cts = logits_fc_cts.argmax(dim=1).eq(labels_test_fc).float().mean().item()
+        print(f"FC_CTS: ECE={round(ece_fc_cts*100, 2)}, Accuracy={round(accuracy_fc_cts*100, 2)}")
+        results['cal'].append('FC_CTS')
+        results['ece'].append(ece_fc_cts)
+        results['adaece'].append(adaece_fc_cts)
+        results['cece'].append(cece_fc_cts)
+        results['nll'].append(nll_fc_cts)
+        results['accuracy'].append(accuracy_fc_cts)
+
+
+    if "GC" in run_methods:
+        # Group Calibration 
+        conf = OmegaConf.load("calibration/group_calibration/conf/method/group_calibration_combine_ets.yaml")
+        logits_val, labels_val, features_val = logits_val.cpu(), labels_val.cpu(), features_val.cpu()
+        logits_test, labels_test, features_test = logits_test.cpu(), labels_test.cpu(), features_test.cpu()
+        calibrated_test_test = calibrate(method_config=conf,
+                                            val_data={"logits": logits_val, "labels": labels_val, "features": features_val},
+                                            test_train_data={"logits": logits_val, "labels": labels_val, "features": features_val},
+                                            test_test_data={"logits": logits_test, "labels": labels_test, "features": features_test},
+                                            seed=1,
+                                            cfg=None)
+        probs_gc = calibrated_test_test.get("prob", None)
+        ece_gc = ece_criterion(logits=None, labels=labels_test, probs=probs_gc).item()
+        adaece_gc = adaece_criterion(logits=None, labels=labels_test, probs=probs_gc).item()
+        cece_gc = cece_criterion(logits=None, labels=labels_test, probs=probs_gc).item()
+        nll_gc = torch.mean(-torch.log(probs_gc[range(len(labels_test)), labels_test])).item()
+        accuracy_gc = torch.mean(torch.argmax(probs_gc, dim=1).eq(labels_test).float()).item()
+        print(f"GC: ECE={round(ece_gc*100, 2)}, Accuracy={round(accuracy_gc*100, 2)}")
+        results['cal'].append('GC')
+        results['ece'].append(ece_gc)
+        results['adaece'].append(adaece_gc)
+        results['cece'].append(cece_gc)
+        results['nll'].append(nll_gc)
+        results['accuracy'].append(accuracy_gc)
+
+    if "FC_GC" in run_methods:
+        # FC then Group Calibration 
+        conf = OmegaConf.load("calibration/group_calibration/conf/method/group_calibration_combine_ets.yaml")
+        logits_test_fc, labels_test_fc, features_test_fc = logits_test_fc.cpu(), labels_test_fc.cpu(), features_test_fc.cpu()
+        logits_test_fc, labels_test_fc, features_test_fc = logits_test_fc.cpu(), labels_test_fc.cpu(), features_test_fc.cpu()
+        calibrated_test_test = calibrate(method_config=conf,
+                                            val_data={"logits": logits_test_fc, "labels": labels_test_fc, "features": features_test_fc},
+                                            test_train_data={"logits": logits_test_fc, "labels": labels_test_fc, "features": features_test_fc},
+                                            test_test_data={"logits": logits_test_fc, "labels": labels_test_fc, "features": features_test_fc},
+                                            seed=1,
+                                            cfg=None)
+        probs_fc_gc = calibrated_test_test.get("prob", None)
+        ece_fc_gc = ece_criterion(logits=None, labels=labels_test_fc, probs=probs_fc_gc).item()
+        adaece_fc_gc = adaece_criterion(logits=None, labels=labels_test_fc, probs=probs_fc_gc).item()
+        cece_fc_gc = cece_criterion(logits=None, labels=labels_test_fc, probs=probs_fc_gc).item()
+        nll_fc_gc = torch.mean(-torch.log(probs_fc_gc[range(len(labels_test_fc)), labels_test_fc])).item()
+        accuracy_fc_gc = torch.mean(torch.argmax(probs_fc_gc, dim=1).eq(labels_test_fc).float()).item()
+        print(f"FC_GC: ECE={round(ece_fc_gc*100, 2)}({round(C_opt_fc,2)}), Accuracy={round(accuracy_fc_gc*100, 2)},")
+        results['cal'].append('FC_GC')
+        results['ece'].append(ece_fc_gc)
+        results['adaece'].append(adaece_fc_gc)
+        results['cece'].append(cece_fc_gc)
+        results['nll'].append(nll_fc_gc)
+        results['accuracy'].append(accuracy_fc_gc)
+
+
+    # print out a result table, drop the row index, decimal to 2
+    results_table = pd.DataFrame({
+        'Model': args.model_name,
+        'Dataset': args.dataset,
+        'ECE': [round(i*100, 2) for i in results['ece']],
+        'AdaECE': [round(i*100, 2) for i in results['adaece']],
+        'CECE': [round(i*100, 2) for i in results['cece']],
+        'NLL': [round(i*100, 2) for i in results['nll']],
+        'Accuracy': [round(i*100, 2) for i in results['accuracy']]
+    }, index=results['cal'])
+    print("\n",results_table,"\n")
+
+    # # print latex scripts
+    # result_str = f"ECE Latex scipts: " \
+    # + f"{round(ece*100, 2):.2f}&\cellgray{round(ece_fc*100, 2):.2f}({round(C_opt_fc,2)}){' greendown' if ece_fc<ece else ' redup'}" \
+    # + f"&{round(ece_ts*100, 2):.2f}&\cellgray{round(ece_fc_ts*100, 2):.2f}{' greendown' if ece_fc_ts<ece_ts else ' redup'}" \
+    # + f"&{round(ece_ets*100, 2):.2f}&\cellgray{round(ece_fc_ets*100, 2):.2f}{' greendown' if ece_fc_ets<ece_ets else ' redup'}" \
+    # + f"&{round(ece_pts*100, 2):.2f}&\cellgray{round(ece_fc_pts*100, 2):.2f}{' greendown' if ece_fc_pts<ece_pts else ' redup'}" \
+    # + f"&{round(ece_cts*100, 2):.2f}&\cellgray{round(ece_fc_cts*100, 2):.2f}{' greendown' if ece_fc_cts<ece_cts else ' redup'}" \
+    # + f"&{round(ece_gc*100, 2):.2f}&\cellgray{round(ece_fc_gc*100, 2):.2f}{' greendown' if ece_fc_gc<ece_gc else ' redup'}" \
+    # + f"\\\\"
+    # # replace textcolor with \textcolor; replace blacktriangle with \blacktriangle
+    # result_str = result_str.replace('greendown', '\\greendown').replace('redup', '\\redup')
+    # # highlight the lowest results
+    # lowest_results = "{:.2f}".format(round(min(results['ece'])*100,2))
+    # result_str = result_str.replace(lowest_results, '\\textbf{'+lowest_results+'}')
+    # print(result_str)
+
+    # result_str = f"AdaECE Latex scipts: " \
+    # + f"{round(adaece*100, 2):.2f}&\cellgray{round(adaece_fc*100, 2):.2f}({round(C_opt_fc,2)}){' greendown' if adaece_fc<adaece else ' redup'}" \
+    # + f"&{round(adaece_ts*100, 2):.2f}&\cellgray{round(adaece_fc_ts*100, 2):.2f}{' greendown' if adaece_fc_ts<adaece_ts else ' redup'}" \
+    # + f"&{round(adaece_ets*100, 2):.2f}&\cellgray{round(adaece_fc_ets*100, 2):.2f}{' greendown' if adaece_fc_ets<adaece_ets else ' redup'}" \
+    # + f"&{round(adaece_pts*100, 2):.2f}&\cellgray{round(adaece_fc_pts*100, 2):.2f}{' greendown' if adaece_fc_pts<adaece_pts else ' redup'}" \
+    # + f"&{round(adaece_cts*100, 2):.2f}&\cellgray{round(adaece_fc_cts*100, 2):.2f}{' greendown' if adaece_fc_cts<adaece_cts else ' redup'}" \
+    # + f"&{round(adaece_gc*100, 2):.2f}&\cellgray{round(adaece_fc_gc*100, 2):.2f}{' greendown' if adaece_fc_gc<adaece_gc else ' redup'}" \
+    # + f"\\\\"
+    # # replace textcolor with \textcolor; replace blacktriangle with \blacktriangle
+    # result_str = result_str.replace('greendown', '\\greendown').replace('redup', '\\redup')
+    # # highlight the lowest results
+    # lowest_results = "{:.2f}".format(round(min(results['ece'])*100,2))
+    # result_str = result_str.replace(lowest_results, '\\textbf{'+lowest_results+'}')
+    # print(result_str)

AAAI2025-FC/evaluate_scripts_post_hoc.sh

@@ -0,0 +1,18 @@
+conda activate feature-clipping
+
+# cifar10
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet50
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet110
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name densenet121
+
+# cifar100
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet50
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet110
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name densenet121
+
+# imagenet
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset imagenet --model-name resnet50
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset imagenet --model-name densenet121
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset imagenet --model-name wide_resnet
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset imagenet --model-name mobilenet_v2
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset imagenet --model-name vit_l_16

AAAI2025-FC/evaluate_scripts_train_time.sh

@@ -0,0 +1,63 @@
+conda activate feature-clipping
+
+# cifar10
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet50 --loss cross_entropy
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet50 --loss brier_score
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet50 --loss mmce
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet50 --loss label_smoothing 
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet50 --loss focal_loss
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet50 --loss focal_loss_53
+
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet110 --loss cross_entropy
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet110 --loss brier_score
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet110 --loss mmce
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet110 --loss label_smoothing 
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet110 --loss focal_loss
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name resnet110 --loss focal_loss_53
+
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name densenet121 --loss cross_entropy
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name densenet121 --loss brier_score
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name densenet121 --loss mmce
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name densenet121 --loss label_smoothing 
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name densenet121 --loss focal_loss
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name densenet121 --loss focal_loss_53
+
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name wide_resnet --loss cross_entropy
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name wide_resnet --loss brier_score
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name wide_resnet --loss mmce
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name wide_resnet --loss label_smoothing 
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name wide_resnet --loss focal_loss
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar10 --model-name wide_resnet --loss focal_loss_53
+
+
+
+
+
+# # cifar100
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet50 --loss cross_entropy
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet50 --loss brier_score
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet50 --loss mmce
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet50 --loss label_smoothing 
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet50 --loss focal_loss
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet50 --loss focal_loss_53
+
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet110 --loss cross_entropy
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet110 --loss brier_score
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet110 --loss mmce
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet110 --loss label_smoothing 
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet110 --loss focal_loss
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name resnet110 --loss focal_loss_53
+
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name densenet121 --loss cross_entropy
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name densenet121 --loss brier_score
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name densenet121 --loss mmce
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name densenet121 --loss label_smoothing 
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name densenet121 --loss focal_loss
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name densenet121 --loss focal_loss_53
+
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name wide_resnet --loss cross_entropy
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name wide_resnet --loss brier_score
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name wide_resnet --loss mmce
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name wide_resnet --loss label_smoothing 
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name wide_resnet --loss focal_loss
+CUDA_VISIBLE_DEVICES=0 python evaluate.py --cverror nll --dataset cifar100 --model-name wide_resnet --loss focal_loss_53

AAAI2025-FC/losses/brier_score.py

@@ -0,0 +1,27 @@
+'''
+Implementation of Brier Score.
+'''
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+class BrierScore(nn.Module):
+    def __init__(self):
+        super(BrierScore, self).__init__()
+
+    def forward(self, input, target):
+        if input.dim()>2:
+            input = input.view(input.size(0),input.size(1),-1)  # N,C,H,W => N,C,H*W
+            input = input.transpose(1,2)    # N,C,H*W => N,H*W,C
+            input = input.contiguous().view(-1,input.size(2))   # N,H*W,C => N*H*W,C
+        target = target.view(-1,1)
+        target_one_hot = torch.FloatTensor(input.shape).to(target.get_device())
+        target_one_hot.zero_()
+        target_one_hot.scatter_(1, target, 1)
+
+        pt = F.softmax(input)
+        squared_diff = (target_one_hot - pt) ** 2
+
+        loss = torch.sum(squared_diff) / float(input.shape[0])
+        return loss

AAAI2025-FC/losses/focal_loss.py

@@ -0,0 +1,32 @@
+'''
+Implementation of Focal Loss.
+Reference:
+[1]  T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollar, Focal loss for dense object detection.
+     arXiv preprint arXiv:1708.02002, 2017.
+'''
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+class FocalLoss(nn.Module):
+    def __init__(self, gamma=0, size_average=False):
+        super(FocalLoss, self).__init__()
+        self.gamma = gamma
+        self.size_average = size_average
+
+    def forward(self, input, target):
+        if input.dim()>2:
+            input = input.view(input.size(0),input.size(1),-1)  # N,C,H,W => N,C,H*W
+            input = input.transpose(1,2)    # N,C,H*W => N,H*W,C
+            input = input.contiguous().view(-1,input.size(2))   # N,H*W,C => N*H*W,C
+        target = target.view(-1,1)
+
+        logpt = F.log_softmax(input)
+        logpt = logpt.gather(1,target)
+        logpt = logpt.view(-1)
+        pt = logpt.exp()
+
+        loss = -1 * (1-pt)**self.gamma * logpt
+        if self.size_average: return loss.mean()
+        else: return loss.sum()

AAAI2025-FC/losses/focal_loss_adaptive_gamma.py

@@ -0,0 +1,68 @@
+'''
+Implementation of Focal Loss with adaptive gamma.
+Reference:
+[1]  T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollar, Focal loss for dense object detection.
+     arXiv preprint arXiv:1708.02002, 2017.
+'''
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+from scipy.special import lambertw
+import numpy as np
+
+
+def get_gamma(p=0.2):
+    '''
+    Get the gamma for a given pt where the function g(p, gamma) = 1
+    '''
+    y = ((1-p)**(1-(1-p)/(p*np.log(p)))/(p*np.log(p)))*np.log(1-p)
+    gamma_complex = (1-p)/(p*np.log(p)) + lambertw(-y + 1e-12, k=-1)/np.log(1-p)
+    gamma = np.real(gamma_complex) #gamma for which p_t > p results in g(p_t,gamma)<1
+    return gamma
+
+ps = [0.2, 0.5]
+gammas = [5.0, 3.0]
+i = 0
+gamma_dic = {}
+for p in ps:
+    gamma_dic[p] = gammas[i]
+    i += 1
+
+class FocalLossAdaptive(nn.Module):
+    def __init__(self, gamma=0, size_average=False, device=None):
+        super(FocalLossAdaptive, self).__init__()
+        self.size_average = size_average
+        self.gamma = gamma
+        self.device = device
+
+    def get_gamma_list(self, pt):
+        gamma_list = []
+        batch_size = pt.shape[0]
+        for i in range(batch_size):
+            pt_sample = pt[i].item()
+            if (pt_sample >= 0.5):
+                gamma_list.append(self.gamma)
+                continue
+            # Choosing the gamma for the sample
+            for key in sorted(gamma_dic.keys()):
+                if pt_sample < key:
+                    gamma_list.append(gamma_dic[key])
+                    break
+        return torch.tensor(gamma_list).to(self.device)
+
+    def forward(self, input, target):
+        if input.dim()>2:
+            input = input.view(input.size(0),input.size(1),-1)  # N,C,H,W => N,C,H*W
+            input = input.transpose(1,2)    # N,C,H*W => N,H*W,C
+            input = input.contiguous().view(-1,input.size(2))   # N,H*W,C => N*H*W,C
+        target = target.view(-1,1)
+        logpt = F.log_softmax(input, dim=1)
+        logpt = logpt.gather(1,target)
+        logpt = logpt.view(-1)
+        pt = logpt.exp()
+        gamma = self.get_gamma_list(pt)
+        loss = -1 * (1-pt)**gamma * logpt
+        if self.size_average: return loss.mean()
+        else: return loss.sum()

AAAI2025-FC/losses/loss.py

@@ -0,0 +1,43 @@
+'''
+Implementation of the following loss functions:
+1. Cross Entropy
+2. Focal Loss
+3. Cross Entropy + MMCE_weighted
+4. Cross Entropy + MMCE
+5. Brier Score
+'''
+
+from torch.nn import functional as F
+from losses.focal_loss import FocalLoss
+from losses.focal_loss_adaptive_gamma import FocalLossAdaptive
+from losses.mmce import MMCE, MMCE_weighted
+from losses.brier_score import BrierScore
+
+
+def cross_entropy(logits, targets, **kwargs):
+    return F.cross_entropy(logits, targets, reduction='sum')
+
+
+def focal_loss(logits, targets, **kwargs):
+    return FocalLoss(gamma=kwargs['gamma'])(logits, targets)
+
+
+def focal_loss_adaptive(logits, targets, **kwargs):
+    return FocalLossAdaptive(gamma=kwargs['gamma'],
+                             device=kwargs['device'])(logits, targets)
+
+
+def mmce(logits, targets, **kwargs):
+    ce = F.cross_entropy(logits, targets)
+    mmce = MMCE(kwargs['device'])(logits, targets)
+    return ce + (kwargs['lamda'] * mmce)
+
+
+def mmce_weighted(logits, targets, **kwargs):
+    ce = F.cross_entropy(logits, targets)
+    mmce = MMCE_weighted(kwargs['device'])(logits, targets)
+    return ce + (kwargs['lamda'] * mmce)
+
+
+def brier_score(logits, targets, **kwargs):
+    return BrierScore()(logits, targets)

AAAI2025-FC/losses/mmce.py

@@ -0,0 +1,140 @@
+'''
+Implementation of the MMCE (MMCE_m) and MMCE_weighted (MMCE_w).
+Reference:
+[1]  A. Kumar, S. Sarawagi, U. Jain, Trainable Calibration Measures for Neural Networks from Kernel Mean Embeddings.
+     ICML, 2018.
+'''
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+class MMCE(nn.Module):
+    """
+    Computes MMCE_m loss.
+    """
+    def __init__(self, device):
+        super(MMCE, self).__init__()
+        self.device = device
+
+    def torch_kernel(self, matrix):
+        return torch.exp(-1.0*torch.abs(matrix[:, :, 0] - matrix[:, :, 1])/(0.4))
+
+    def forward(self, input, target):
+        if input.dim()>2:
+            input = input.view(input.size(0),input.size(1),-1)  # N,C,H,W => N,C,H*W
+            input = input.transpose(1,2)    # N,C,H*W => N,H*W,C
+            input = input.contiguous().view(-1,input.size(2))   # N,H*W,C => N*H*W,C
+
+        target = target.view(-1) #For CIFAR-10 and CIFAR-100, target.shape is [N] to begin with
+
+        predicted_probs = F.softmax(input, dim=1)
+        predicted_probs, pred_labels = torch.max(predicted_probs, 1)
+        correct_mask = torch.where(torch.eq(pred_labels, target),
+                          torch.ones(pred_labels.shape).to(self.device),
+                          torch.zeros(pred_labels.shape).to(self.device))
+
+        c_minus_r = correct_mask - predicted_probs
+
+        dot_product = torch.mm(c_minus_r.unsqueeze(1),
+                        c_minus_r.unsqueeze(0))
+
+        prob_tiled = predicted_probs.unsqueeze(1).repeat(1, predicted_probs.shape[0]).unsqueeze(2)
+        prob_pairs = torch.cat([prob_tiled, prob_tiled.permute(1, 0, 2)],
+                                    dim=2)
+
+        kernel_prob_pairs = self.torch_kernel(prob_pairs)
+
+        numerator = dot_product*kernel_prob_pairs
+        #return torch.sum(numerator)/correct_mask.shape[0]**2
+        return torch.sum(numerator)/torch.pow(torch.tensor(correct_mask.shape[0]).type(torch.FloatTensor),2)
+
+
+
+class MMCE_weighted(nn.Module):
+    """
+    Computes MMCE_w loss.
+    """
+    def __init__(self, device):
+        super(MMCE_weighted, self).__init__()
+        self.device = device
+
+    def torch_kernel(self, matrix):
+        return torch.exp(-1.0*torch.abs(matrix[:, :, 0] - matrix[:, :, 1])/(0.4))
+
+    def get_pairs(self, tensor1, tensor2):
+        correct_prob_tiled = tensor1.unsqueeze(1).repeat(1, tensor1.shape[0]).unsqueeze(2)
+        incorrect_prob_tiled = tensor2.unsqueeze(1).repeat(1, tensor2.shape[0]).unsqueeze(2)
+
+        correct_prob_pairs = torch.cat([correct_prob_tiled, correct_prob_tiled.permute(1, 0, 2)],
+                                    dim=2)
+        incorrect_prob_pairs = torch.cat([incorrect_prob_tiled, incorrect_prob_tiled.permute(1, 0, 2)],
+                                    dim=2)
+
+        correct_prob_tiled_1 = tensor1.unsqueeze(1).repeat(1, tensor2.shape[0]).unsqueeze(2)
+        incorrect_prob_tiled_1 = tensor2.unsqueeze(1).repeat(1, tensor1.shape[0]).unsqueeze(2)
+
+        correct_incorrect_pairs = torch.cat([correct_prob_tiled_1, incorrect_prob_tiled_1.permute(1, 0, 2)],
+                                    dim=2)
+        return correct_prob_pairs, incorrect_prob_pairs, correct_incorrect_pairs
+
+    def get_out_tensor(self, tensor1, tensor2):
+        return torch.mean(tensor1*tensor2)
+
+    def forward(self, input, target):
+        if input.dim()>2:
+            input = input.view(input.size(0),input.size(1),-1)  # N,C,H,W => N,C,H*W
+            input = input.transpose(1,2)    # N,C,H*W => N,H*W,C
+            input = input.contiguous().view(-1,input.size(2))   # N,H*W,C => N*H*W,C
+
+        target = target.view(-1)  #For CIFAR-10 and CIFAR-100, target.shape is [N] to begin with
+
+        predicted_probs = F.softmax(input, dim=1)
+        predicted_probs, predicted_labels = torch.max(predicted_probs, 1)
+
+        correct_mask = torch.where(torch.eq(predicted_labels, target),
+                                    torch.ones(predicted_labels.shape).to(self.device),
+                                    torch.zeros(predicted_labels.shape).to(self.device))
+
+        k = torch.sum(correct_mask).type(torch.int64)
+        k_p = torch.sum(1.0 - correct_mask).type(torch.int64)
+        cond_k = torch.where(torch.eq(k,0),torch.tensor(0).to(self.device),torch.tensor(1).to(self.device))
+        cond_k_p = torch.where(torch.eq(k_p,0),torch.tensor(0).to(self.device),torch.tensor(1).to(self.device))
+        k = torch.max(k, torch.tensor(1).to(self.device))*cond_k*cond_k_p + (1 - cond_k*cond_k_p)*2 
+        k_p = torch.max(k_p, torch.tensor(1).to(self.device))*cond_k_p*cond_k + ((1 - cond_k_p*cond_k)*
+                                            (correct_mask.shape[0] - 2))
+
+
+        correct_prob, _ = torch.topk(predicted_probs*correct_mask, k)
+        incorrect_prob, _ = torch.topk(predicted_probs*(1 - correct_mask), k_p)
+
+        correct_prob_pairs, incorrect_prob_pairs,\
+               correct_incorrect_pairs = self.get_pairs(correct_prob, incorrect_prob)
+
+        correct_kernel = self.torch_kernel(correct_prob_pairs)
+        incorrect_kernel = self.torch_kernel(incorrect_prob_pairs)
+        correct_incorrect_kernel = self.torch_kernel(correct_incorrect_pairs)  
+
+        sampling_weights_correct = torch.mm((1.0 - correct_prob).unsqueeze(1), (1.0 - correct_prob).unsqueeze(0))
+
+        correct_correct_vals = self.get_out_tensor(correct_kernel,
+                                                          sampling_weights_correct)
+        sampling_weights_incorrect = torch.mm(incorrect_prob.unsqueeze(1), incorrect_prob.unsqueeze(0))
+
+        incorrect_incorrect_vals = self.get_out_tensor(incorrect_kernel,
+                                                          sampling_weights_incorrect)
+        sampling_correct_incorrect = torch.mm((1.0 - correct_prob).unsqueeze(1), incorrect_prob.unsqueeze(0))
+
+        correct_incorrect_vals = self.get_out_tensor(correct_incorrect_kernel,
+                                                          sampling_correct_incorrect)
+
+        correct_denom = torch.sum(1.0 - correct_prob)
+        incorrect_denom = torch.sum(incorrect_prob)
+
+        m = torch.sum(correct_mask)
+        n = torch.sum(1.0 - correct_mask)
+        mmd_error = 1.0/(m*m + 1e-5) * torch.sum(correct_correct_vals) 
+        mmd_error += 1.0/(n*n + 1e-5) * torch.sum(incorrect_incorrect_vals)
+        mmd_error -= 2.0/(m*n + 1e-5) * torch.sum(correct_incorrect_vals)
+        return torch.max((cond_k*cond_k_p).type(torch.FloatTensor).to(self.device).detach()*torch.sqrt(mmd_error + 1e-10), torch.tensor(0.0).to(self.device))

AAAI2025-FC/metrics/.gitignore

@@ -0,0 +1 @@
+__pycache__

AAAI2025-FC/metrics/metrics.py

@@ -0,0 +1,291 @@
+'''
+Metrics to measure calibration of a trained deep neural network.
+
+References:
+[1] C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger. On calibration of modern neural networks.
+    arXiv preprint arXiv:1706.04599, 2017.
+'''
+
+import math
+import torch
+import numpy as np
+from torch import nn
+from torch.nn import functional as F
+
+
+from sklearn.metrics import accuracy_score
+from sklearn.metrics import confusion_matrix
+
+
+# Some keys used for the following dictionaries
+COUNT = 'count'
+CONF = 'conf'
+ACC = 'acc'
+BIN_ACC = 'bin_acc'
+BIN_CONF = 'bin_conf'
+
+
+def _bin_initializer(bin_dict, num_bins=10):
+    for i in range(num_bins):
+        bin_dict[i][COUNT] = 0
+        bin_dict[i][CONF] = 0
+        bin_dict[i][ACC] = 0
+        bin_dict[i][BIN_ACC] = 0
+        bin_dict[i][BIN_CONF] = 0
+
+
+def _populate_bins(confs, preds, labels, num_bins=10):
+    bin_dict = {}
+    for i in range(num_bins):
+        bin_dict[i] = {}
+    _bin_initializer(bin_dict, num_bins)
+    num_test_samples = len(confs)
+
+    for i in range(0, num_test_samples):
+        confidence = confs[i]
+        prediction = preds[i]
+        label = labels[i]
+        binn = int(math.ceil(((num_bins * confidence) - 1)))
+        bin_dict[binn][COUNT] = bin_dict[binn][COUNT] + 1
+        bin_dict[binn][CONF] = bin_dict[binn][CONF] + confidence
+        bin_dict[binn][ACC] = bin_dict[binn][ACC] + \
+            (1 if (label == prediction) else 0)
+
+    for binn in range(0, num_bins):
+        if (bin_dict[binn][COUNT] == 0):
+            bin_dict[binn][BIN_ACC] = 0
+            bin_dict[binn][BIN_CONF] = 0
+        else:
+            bin_dict[binn][BIN_ACC] = float(
+                bin_dict[binn][ACC]) / bin_dict[binn][COUNT]
+            bin_dict[binn][BIN_CONF] = bin_dict[binn][CONF] / \
+                float(bin_dict[binn][COUNT])
+    return bin_dict
+
+
+def expected_calibration_error(confs, preds, labels, num_bins=10):
+    bin_dict = _populate_bins(confs, preds, labels, num_bins)
+    num_samples = len(labels)
+    ece = 0
+    for i in range(num_bins):
+        bin_accuracy = bin_dict[i][BIN_ACC]
+        bin_confidence = bin_dict[i][BIN_CONF]
+        bin_count = bin_dict[i][COUNT]
+        ece += (float(bin_count) / num_samples) * \
+            abs(bin_accuracy - bin_confidence)
+    return ece
+
+
+def maximum_calibration_error(confs, preds, labels, num_bins=10):
+    bin_dict = _populate_bins(confs, preds, labels, num_bins)
+    ce = []
+    for i in range(num_bins):
+        bin_accuracy = bin_dict[i][BIN_ACC]
+        bin_confidence = bin_dict[i][BIN_CONF]
+        ce.append(abs(bin_accuracy - bin_confidence))
+    return max(ce)
+
+
+def average_calibration_error(confs, preds, labels, num_bins=10):
+    bin_dict = _populate_bins(confs, preds, labels, num_bins)
+    non_empty_bins = 0
+    ace = 0
+    for i in range(num_bins):
+        bin_accuracy = bin_dict[i][BIN_ACC]
+        bin_confidence = bin_dict[i][BIN_CONF]
+        bin_count = bin_dict[i][COUNT]
+        if bin_count > 0:
+            non_empty_bins += 1
+        ace += abs(bin_accuracy - bin_confidence)
+    return ace / float(non_empty_bins)
+
+
+def l2_error(confs, preds, labels, num_bins=15):
+    bin_dict = _populate_bins(confs, preds, labels, num_bins)
+    num_samples = len(labels)
+    l2_sum = 0
+    for i in range(num_bins):
+        bin_accuracy = bin_dict[i][BIN_ACC]
+        bin_confidence = bin_dict[i][BIN_CONF]
+        bin_count = bin_dict[i][COUNT]
+        l2_sum += (float(bin_count) / num_samples) * \
+               (bin_accuracy - bin_confidence)**2
+        l2_error = math.sqrt(l2_sum)
+    return l2_error
+
+
+def test_classification_net_logits(logits, labels, probs=None):
+    '''
+    This function reports classification accuracy and confusion matrix given logits and labels
+    from a model.
+    '''
+    labels_list = []
+    predictions_list = []
+    confidence_vals_list = []
+
+    if logits is not None:
+        softmax = F.softmax(logits, dim=1)
+    else:
+        softmax = probs
+    confidence_vals, predictions = torch.max(softmax, dim=1)
+    labels_list.extend(labels.cpu().numpy().tolist())
+    predictions_list.extend(predictions.cpu().numpy().tolist())
+    confidence_vals_list.extend(confidence_vals.cpu().detach().numpy().tolist())
+    accuracy = accuracy_score(labels_list, predictions_list)
+    return confusion_matrix(labels_list, predictions_list), accuracy, labels_list,\
+        predictions_list, confidence_vals_list
+
+
+def test_classification_net(model, data_loader, device):
+    '''
+    This function reports classification accuracy and confusion matrix over a dataset.
+    '''
+    model.eval()
+    labels_list = []
+    predictions_list = []
+    confidence_vals_list = []
+    with torch.no_grad():
+        for i, (data, label) in enumerate(data_loader):
+            data = data.to(device)
+            label = label.to(device)
+
+            logits = model(data)
+            softmax = F.softmax(logits, dim=1)
+            confidence_vals, predictions = torch.max(softmax, dim=1)
+
+            labels_list.extend(label.cpu().numpy().tolist())
+            predictions_list.extend(predictions.cpu().numpy().tolist())
+            confidence_vals_list.extend(confidence_vals.cpu().numpy().tolist())
+    accuracy = accuracy_score(labels_list, predictions_list)
+
+    return confusion_matrix(labels_list, predictions_list), accuracy, labels_list,\
+        predictions_list, confidence_vals_list
+
+
+# Calibration error scores in the form of loss metrics
+class ECELoss(nn.Module):
+    '''
+    Compute ECE (Expected Calibration Error)
+    '''
+    def __init__(self, n_bins=15):
+        super(ECELoss, self).__init__()
+        bin_boundaries = torch.linspace(0, 1, n_bins + 1)
+        self.bin_lowers = bin_boundaries[:-1]
+        self.bin_uppers = bin_boundaries[1:]
+
+    def forward(self, logits, labels, features=None, probs=None):
+        if logits is not None:
+            softmaxes = F.softmax(logits, dim=1)
+        else:
+            softmaxes = probs
+        confidences, predictions = torch.max(softmaxes, 1)
+        accuracies = predictions.eq(labels)
+        ce_per_sample = torch.zeros_like(confidences)
+
+        ece = torch.zeros(1, device=labels.device)
+        for bin_lower, bin_upper in zip(self.bin_lowers, self.bin_uppers):
+            # Calculated |confidence - accuracy| in each bin
+            in_bin = confidences.gt(bin_lower.item()) * confidences.le(bin_upper.item())
+            prop_in_bin = in_bin.float().mean()
+            if prop_in_bin.item() > 0:
+                accuracy_in_bin = accuracies[in_bin].float().mean()
+                avg_confidence_in_bin = confidences[in_bin].mean()
+
+                ### TODO
+                if bin_upper == 1:
+                    # get all the index of in_bin data
+                    indexs = torch.nonzero(in_bin).squeeze()
+                    # # get the confidence values of in_bin data
+                    # conf_in_bin = confidences[indexs]
+                    # # get the index with high calibration error samples
+                    # high_ce_indexs = torch.argsort(torch.abs(conf_in_bin - accuracy_in_bin), descending=True)
+                    # # check the norm of the high calibration error samples
+                    # norm_high_ce = torch.norm(conf_in_bin[high_ce_indexs], p=2)
+                    # # get the indexs of wrongly classified samples
+                    # wrong_indexs = torch.nonzero(accuracies.eq(0)).squeeze()
+                    # # save to playground
+                    # torch.save(in_bin, 'playground/in_bin.pth')
+                    # torch.save(high_ce_indexs, 'playground/high_ce_indexs.pth')
+                    # torch.save(wrong_indexs, 'playground/wrong_indexs.pth')
+                    # torch.save(indexs, 'playground/indexs.pth')
+                    # torch.save(features, 'playground/features.pth')
+                    # torch.save(confidences, 'playground/confidences.pth')
+                ce_per_sample[in_bin]=torch.abs(confidences[in_bin] - accuracy_in_bin)
+                ece += torch.abs(avg_confidence_in_bin - accuracy_in_bin) * prop_in_bin
+        return ece
+
+
+class AdaptiveECELoss(nn.Module):
+    '''
+    Compute Adaptive ECE
+    '''
+    def __init__(self, n_bins=15):
+        super(AdaptiveECELoss, self).__init__()
+        self.nbins = n_bins
+
+    def histedges_equalN(self, x):
+        npt = len(x)
+        return np.interp(np.linspace(0, npt, self.nbins + 1),
+                     np.arange(npt),
+                     np.sort(x))
+    def forward(self, logits, labels, probs=None):
+        if logits is not None:
+            softmaxes = F.softmax(logits, dim=1)
+        else:
+            softmaxes = probs
+        confidences, predictions = torch.max(softmaxes, 1)
+        accuracies = predictions.eq(labels)
+        n, bin_boundaries = np.histogram(confidences.cpu().detach(), self.histedges_equalN(confidences.cpu().detach()))
+        #print(n,confidences,bin_boundaries)
+        self.bin_lowers = bin_boundaries[:-1]
+        self.bin_uppers = bin_boundaries[1:]
+        ece = torch.zeros(1, device=labels.device)
+        for bin_lower, bin_upper in zip(self.bin_lowers, self.bin_uppers):
+            # Calculated |confidence - accuracy| in each bin
+            in_bin = confidences.gt(bin_lower.item()) * confidences.le(bin_upper.item())
+            prop_in_bin = in_bin.float().mean()
+            if prop_in_bin.item() > 0:
+                accuracy_in_bin = accuracies[in_bin].float().mean()
+                avg_confidence_in_bin = confidences[in_bin].mean()
+                ece += torch.abs(avg_confidence_in_bin - accuracy_in_bin) * prop_in_bin
+        return ece
+
+
+class ClasswiseECELoss(nn.Module):
+    '''
+    Compute Classwise ECE
+    '''
+    def __init__(self, n_bins=15):
+        super(ClasswiseECELoss, self).__init__()
+        bin_boundaries = torch.linspace(0, 1, n_bins + 1)
+        self.bin_lowers = bin_boundaries[:-1]
+        self.bin_uppers = bin_boundaries[1:]
+
+    def forward(self, logits, labels, probs=None):
+        num_classes = int((torch.max(labels) + 1).item())
+        if logits is not None:
+            softmaxes = F.softmax(logits, dim=1)
+        else:
+            softmaxes = probs
+        per_class_sce = None
+
+        for i in range(num_classes):
+            class_confidences = softmaxes[:, i]
+            class_sce = torch.zeros(1, device=labels.device)
+            labels_in_class = labels.eq(i) # one-hot vector of all positions where the label belongs to the class i
+
+            for bin_lower, bin_upper in zip(self.bin_lowers, self.bin_uppers):
+                in_bin = class_confidences.gt(bin_lower.item()) * class_confidences.le(bin_upper.item())
+                prop_in_bin = in_bin.float().mean()
+                if prop_in_bin.item() > 0:
+                    accuracy_in_bin = labels_in_class[in_bin].float().mean()
+                    avg_confidence_in_bin = class_confidences[in_bin].mean()
+                    class_sce += torch.abs(avg_confidence_in_bin - accuracy_in_bin) * prop_in_bin
+
+            if (i == 0):
+                per_class_sce = class_sce
+            else:
+                per_class_sce = torch.cat((per_class_sce, class_sce), dim=0)
+
+        sce = torch.mean(per_class_sce)
+        return sce

AAAI2025-FC/metrics/ood_test_utils.py

@@ -0,0 +1,76 @@
+# Utility functions to get OOD detection ROC curves and AUROC scores
+# Ideally should be agnostic of model architectures
+
+import torch
+import torch.nn.functional as F
+from sklearn import metrics
+
+
+def entropy(net_output):
+    p = F.softmax(net_output, dim=1)
+    logp = F.log_softmax(net_output, dim=1)
+    plogp = p * logp
+    entropy = - torch.sum(plogp, dim=1)
+    return entropy
+
+def confidence(net_output):
+    p = F.softmax(net_output, dim=1)
+    confidence, _ = torch.max(p, dim=1)
+    return confidence
+
+
+def get_roc_auc(net, test_loader, ood_test_loader, device):
+    bin_labels_entropies = None
+    bin_labels_confidences = None
+    entropies = None
+    confidences = None
+
+    net.eval()
+    with torch.no_grad():
+        # Getting entropies for in-distribution data
+        for i, (data, label) in enumerate(test_loader):
+            data = data.to(device)
+            label = label.to(device)
+
+            bin_label_entropy = torch.zeros(label.shape).to(device)
+            bin_label_confidence = torch.ones(label.shape).to(device)
+
+            net_output = net(data)
+
+            entrop = entropy(net_output)
+            conf = confidence(net_output)
+
+            if (i == 0):
+                bin_labels_entropies = bin_label_entropy
+                bin_labels_confidences = bin_label_confidence
+                entropies = entrop
+                confidences = conf
+            else:
+                bin_labels_entropies = torch.cat((bin_labels_entropies, bin_label_entropy))
+                bin_labels_confidences = torch.cat((bin_labels_confidences, bin_label_confidence))
+                entropies = torch.cat((entropies, entrop))
+                confidences = torch.cat((confidences, conf))
+
+        # Getting entropies for OOD data
+        for i, (data, label) in enumerate(ood_test_loader):
+            data = data.to(device)
+            label = label.to(device)
+
+            bin_label_entropy = torch.ones(label.shape).to(device)
+            bin_label_confidence = torch.zeros(label.shape).to(device)
+
+            net_output = net(data)
+            entrop = entropy(net_output)
+            conf = confidence(net_output)
+
+            bin_labels_entropies = torch.cat((bin_labels_entropies, bin_label_entropy))
+            bin_labels_confidences = torch.cat((bin_labels_confidences, bin_label_confidence))
+            entropies = torch.cat((entropies, entrop))
+            confidences = torch.cat((confidences, conf))
+
+    fpr_entropy, tpr_entropy, thresholds_entropy = metrics.roc_curve(bin_labels_entropies.cpu().numpy(), entropies.cpu().numpy())
+    fpr_confidence, tpr_confidence, thresholds_confidence = metrics.roc_curve(bin_labels_confidences.cpu().numpy(), confidences.cpu().numpy())
+    auc_entropy = metrics.roc_auc_score(bin_labels_entropies.cpu().numpy(), entropies.cpu().numpy())
+    auc_confidence = metrics.roc_auc_score(bin_labels_confidences.cpu().numpy(), confidences.cpu().numpy())
+
+    return (fpr_entropy, tpr_entropy, thresholds_entropy), (fpr_confidence, tpr_confidence, thresholds_confidence), auc_entropy, auc_confidence

AAAI2025-FC/metrics/plots.py

@@ -0,0 +1,94 @@
+'''
+This file contains method for generating calibration related plots, eg. reliability plots.
+
+References:
+[1] C. Guo, G. Pleiss, Y. Sun, and K. Q. Weinberger. On calibration of modern neural networks.
+    arXiv preprint arXiv:1706.04599, 2017.
+'''
+
+import math
+import matplotlib.pyplot as plt
+plt.rcParams.update({'font.size': 20})
+
+# Some keys used for the following dictionaries
+COUNT = 'count'
+CONF = 'conf'
+ACC = 'acc'
+BIN_ACC = 'bin_acc'
+BIN_CONF = 'bin_conf'
+
+
+def _bin_initializer(bin_dict, num_bins=10):
+    for i in range(num_bins):
+        bin_dict[i][COUNT] = 0
+        bin_dict[i][CONF] = 0
+        bin_dict[i][ACC] = 0
+        bin_dict[i][BIN_ACC] = 0
+        bin_dict[i][BIN_CONF] = 0
+
+
+def _populate_bins(confs, preds, labels, num_bins=10):
+    bin_dict = {}
+    for i in range(num_bins):
+        bin_dict[i] = {}
+    _bin_initializer(bin_dict, num_bins)
+    num_test_samples = len(confs)
+
+    for i in range(0, num_test_samples):
+        confidence = confs[i]
+        prediction = preds[i]
+        label = labels[i]
+        binn = int(math.ceil(((num_bins * confidence) - 1)))
+        bin_dict[binn][COUNT] = bin_dict[binn][COUNT] + 1
+        bin_dict[binn][CONF] = bin_dict[binn][CONF] + confidence
+        bin_dict[binn][ACC] = bin_dict[binn][ACC] + \
+            (1 if (label == prediction) else 0)
+
+    for binn in range(0, num_bins):
+        if (bin_dict[binn][COUNT] == 0):
+            bin_dict[binn][BIN_ACC] = 0
+            bin_dict[binn][BIN_CONF] = 0
+        else:
+            bin_dict[binn][BIN_ACC] = float(
+                bin_dict[binn][ACC]) / bin_dict[binn][COUNT]
+            bin_dict[binn][BIN_CONF] = bin_dict[binn][CONF] / \
+                float(bin_dict[binn][COUNT])
+    return bin_dict
+
+
+def reliability_plot(confs, preds, labels, num_bins=15):
+    '''
+    Method to draw a reliability plot from a model's predictions and confidences.
+    '''
+    bin_dict = _populate_bins(confs, preds, labels, num_bins)
+    bns = [(i / float(num_bins)) for i in range(num_bins)]
+    y = []
+    for i in range(num_bins):
+        y.append(bin_dict[i][BIN_ACC])
+    plt.figure(figsize=(10, 8))  # width:20, height:3
+    plt.bar(bns, bns, align='edge', width=0.05, color='pink', label='Expected')
+    plt.bar(bns, y, align='edge', width=0.05,
+            color='blue', alpha=0.5, label='Actual')
+    plt.ylabel('Accuracy')
+    plt.xlabel('Confidence')
+    plt.legend()
+    plt.show()
+
+
+def bin_strength_plot(confs, preds, labels, num_bins=15):
+    '''
+    Method to draw a plot for the number of samples in each confidence bin.
+    '''
+    bin_dict = _populate_bins(confs, preds, labels, num_bins)
+    bns = [(i / float(num_bins)) for i in range(num_bins)]
+    num_samples = len(labels)
+    y = []
+    for i in range(num_bins):
+        n = (bin_dict[i][COUNT] / float(num_samples)) * 100
+        y.append(n)
+    plt.figure(figsize=(10, 8))  # width:20, height:3
+    plt.bar(bns, y, align='edge', width=0.05,
+            color='blue', alpha=0.5, label='Percentage samples')
+    plt.ylabel('Percentage of samples')
+    plt.xlabel('Confidence')
+    plt.show()

AAAI2025-FC/models/densenet.py

@@ -0,0 +1,117 @@
+'''
+Pytorch impplementation of DenseNet.
+
+Reference:
+[1] Gao Huang, Zhuang Liu, and Kilian Q. Weinberger. Densely connected convolutional networks.
+    arXiv preprint arXiv:1608.06993, 2016a.
+'''
+
+import math
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Bottleneck(nn.Module):
+    def __init__(self, in_planes, growth_rate):
+        super(Bottleneck, self).__init__()
+        self.bn1 = nn.BatchNorm2d(in_planes)
+        self.conv1 = nn.Conv2d(in_planes, 4*growth_rate, kernel_size=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(4*growth_rate)
+        self.conv2 = nn.Conv2d(4*growth_rate, growth_rate, kernel_size=3, padding=1, bias=False)
+
+    def forward(self, x):
+        out = self.conv1(F.relu(self.bn1(x)))
+        out = self.conv2(F.relu(self.bn2(out)))
+        out = torch.cat([out,x], 1)
+        return out
+
+
+class Transition(nn.Module):
+    def __init__(self, in_planes, out_planes):
+        super(Transition, self).__init__()
+        self.bn = nn.BatchNorm2d(in_planes)
+        self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=1, bias=False)
+
+    def forward(self, x):
+        out = self.conv(F.relu(self.bn(x)))
+        out = F.avg_pool2d(out, 2)
+        return out
+
+
+class DenseNet(nn.Module):
+    def __init__(self, block, nblocks, growth_rate=12, reduction=0.5, num_classes=10, temp=1.0, feature_clamp=1e6):
+        super(DenseNet, self).__init__()
+        self.growth_rate = growth_rate
+        self.temp = temp
+
+        num_planes = 2*growth_rate
+        self.conv1 = nn.Conv2d(3, num_planes, kernel_size=3, padding=1, bias=False)
+
+        self.dense1 = self._make_dense_layers(block, num_planes, nblocks[0])
+        num_planes += nblocks[0]*growth_rate
+        out_planes = int(math.floor(num_planes*reduction))
+        self.trans1 = Transition(num_planes, out_planes)
+        num_planes = out_planes
+
+        self.dense2 = self._make_dense_layers(block, num_planes, nblocks[1])
+        num_planes += nblocks[1]*growth_rate
+        out_planes = int(math.floor(num_planes*reduction))
+        self.trans2 = Transition(num_planes, out_planes)
+        num_planes = out_planes
+
+        self.dense3 = self._make_dense_layers(block, num_planes, nblocks[2])
+        num_planes += nblocks[2]*growth_rate
+        out_planes = int(math.floor(num_planes*reduction))
+        self.trans3 = Transition(num_planes, out_planes)
+        num_planes = out_planes
+
+        self.dense4 = self._make_dense_layers(block, num_planes, nblocks[3])
+        num_planes += nblocks[3]*growth_rate
+
+        self.bn = nn.BatchNorm2d(num_planes)
+        self.linear = nn.Linear(num_planes, num_classes)
+        self.feature_clamp = feature_clamp 
+
+    def _make_dense_layers(self, block, in_planes, nblock):
+        layers = []
+        for i in range(nblock):
+            layers.append(block(in_planes, self.growth_rate))
+            in_planes += self.growth_rate
+        return nn.Sequential(*layers)
+
+    def forward(self, x, return_feature=False):
+        out = self.conv1(x)
+        out = self.trans1(self.dense1(out))
+        out = self.trans2(self.dense2(out))
+        out = self.trans3(self.dense3(out))
+        out = self.dense4(out)
+        out = F.avg_pool2d(F.relu(self.bn(out)), 4)
+        feature = out.view(out.size(0), -1)
+        out = self.linear(feature) / self.temp
+        if return_feature:
+            return out, feature
+        else:
+            return out
+    
+
+    def classifier(self, x):
+        return self.linear(x)
+
+
+
+def densenet121(temp=1.0, **kwargs):
+    return DenseNet(Bottleneck, [6,12,24,16], growth_rate=32, temp=temp, **kwargs)
+
+
+def densenet169(temp=1.0, **kwargs):
+    return DenseNet(Bottleneck, [6,12,32,32], growth_rate=32, temp=temp, **kwargs)
+
+
+def densenet201(temp=1.0, **kwargs):
+    return DenseNet(Bottleneck, [6,12,48,32], growth_rate=32, temp=temp, **kwargs)
+
+
+def densenet161(temp=1.0, **kwargs):
+    return DenseNet(Bottleneck, [6,12,36,24], growth_rate=48, temp=temp, **kwargs)