From 29136f47f6ca643a97d16ffa734ab178f93c15ee Mon Sep 17 00:00:00 2001
From: divyat09 <divyatmahajan@gmail.com>
Date: Wed, 29 Sep 2021 17:06:27 +0000
Subject: [PATCH] reproducibility details addition; updates to MatchDG based on
 slab dataset issues, noise in invariant mechanism

---
 algorithms/algo.py                            |  31 +-
 algorithms/erm_match.py                       |  19 +-
 algorithms/match_dg.py                        |   6 +
 data/data_gen_mnist.py                        | 231 ++++++
 data_gen_syn.py                               |   4 +-
 docs/notebooks/ChestXRay_Translate.ipynb      |  26 +-
 docs/notebooks/Preprocess.ipynb               |  12 +-
 docs/notebooks/beta_reproduce_results.ipynb   | 658 ++++++++++++++++++
 .../reproducing_results_matchdg_paper.ipynb   |   2 +-
 docs/notebooks/usenix_results.ipynb           | 570 ++++++++++-----
 reproduce_scripts/cxray_run.py                |   6 +-
 reproduce_scripts/mnist_mdg_ctr_run.py        |  28 +-
 reproduce_scripts/mnist_plot.py               |  13 +-
 reproduce_scripts/mnist_run.py                |  17 +-
 .../reproduce_rmnist_domainbed.py             |  59 +-
 reproduce_scripts/reproduce_rmnist_lenet.py   |  68 +-
 reproduce_scripts/reproduce_slab.py           |   8 +-
 reproduce_scripts/slab-plot.py                |  30 +-
 reproduce_scripts/slab-run.py                 |  65 +-
 test.py                                       |   3 +
 test_slab.py                                  |   5 +-
 train.py                                      |   3 +
 utils/__init__.py                             |   0
 utils/helper.py                               |   9 +-
 utils/match_function.py                       |   5 +-
 utils/scripts/__init__.py                     |   0
 26 files changed, 1527 insertions(+), 351 deletions(-)
 create mode 100644 data/data_gen_mnist.py
 create mode 100644 docs/notebooks/beta_reproduce_results.ipynb
 create mode 100644 utils/__init__.py
 create mode 100644 utils/scripts/__init__.py

diff --git a/algorithms/algo.py b/algorithms/algo.py
index be6c718..23eee9d 100644
--- a/algorithms/algo.py
+++ b/algorithms/algo.py
@@ -77,12 +77,6 @@ def get_noise_multiplier(
 class BaseAlgo():
     def __init__(self, args, train_dataset, val_dataset, test_dataset, base_res_dir, run, cuda):
         
-#         from evaluation.base_eval import BaseEval
-#         self.test_method= BaseEval(
-#                               args, train_dataset, val_dataset,
-#                               test_dataset, base_res_dir,
-#                               run, cuda
-#                              )
         
         self.args= args
         self.train_dataset= train_dataset['data_loader']
@@ -111,7 +105,7 @@ class BaseAlgo():
         self.val_acc=[]
         self.train_acc=[]
         
-#         if self.args.method_name == 'dp_erm':
+        # Differentially Private Noise
         if self.args.dp_noise:
             self.privacy_engine= self.get_dp_noise()
     
@@ -297,28 +291,16 @@ class BaseAlgo():
         MAX_GRAD_NORM = 5.0
         DELTA = 1.0/(self.total_domains*self.domain_size)
         BATCH_SIZE = self.args.batch_size * self.total_domains
-        VIRTUAL_BATCH_SIZE = 10*BATCH_SIZE
-        assert VIRTUAL_BATCH_SIZE % BATCH_SIZE == 0 # VIRTUAL_BATCH_SIZE should be divisible by BATCH_SIZE
-        N_ACCUMULATION_STEPS = int(VIRTUAL_BATCH_SIZE / BATCH_SIZE)        
         SAMPLE_RATE = BATCH_SIZE /(self.total_domains*self.domain_size)
         DEFAULT_ALPHAS = [1 + x / 10.0 for x in range(1, 100)] + list(range(12, 64))
-        
-        
+                
         NOISE_MULTIPLIER = get_noise_multiplier(self.args.dp_epsilon, DELTA, SAMPLE_RATE, self.args.epochs, DEFAULT_ALPHAS)
         
         print("Target Epsilon: ", self.args.dp_epsilon)
         print(f"Using sigma={NOISE_MULTIPLIER} and C={MAX_GRAD_NORM}")
         
-#         sys.exit(-1)
                 
         from opacus import PrivacyEngine        
-#         privacy_engine = PrivacyEngine(
-#             self.phi,
-#             sample_rate=SAMPLE_RATE * N_ACCUMULATION_STEPS,
-#             alphas=[1 + x / 10.0 for x in range(1, 100)] + list(range(12, 64)),
-#             noise_multiplier=NOISE_MULTIPLIER,
-#             max_grad_norm=MAX_GRAD_NORM,
-#         )
         privacy_engine = PrivacyEngine(
             self.phi,
             batch_size= BATCH_SIZE,
@@ -326,6 +308,11 @@ class BaseAlgo():
             noise_multiplier=NOISE_MULTIPLIER,
             max_grad_norm=MAX_GRAD_NORM,
         )
-    
-        privacy_engine.attach(self.opt)
+        
+        if self.args.dp_attach_opt:
+            print('Standard DP Training with finite epsilon')
+            privacy_engine.attach(self.opt)
+        else:
+            print('DP Training with infinite epsilon')
+            
         return privacy_engine
\ No newline at end of file
diff --git a/algorithms/erm_match.py b/algorithms/erm_match.py
index 7fe6039..552e01b 100644
--- a/algorithms/erm_match.py
+++ b/algorithms/erm_match.py
@@ -110,15 +110,16 @@ class ErmMatch(BaseAlgo):
 
                         
                 loss_e.backward(retain_graph=False)
-                 
-                if batch_idx % 10 == 9:
+                
+                if self.args.dp_noise and self.args.dp_attach_opt:
+                    if batch_idx % 10 == 9:
+                        self.opt.step()
+                        self.opt.zero_grad()
+                    else:
+                        self.opt.virtual_step()                        
+                else:                    
                     self.opt.step()
                     self.opt.zero_grad()
-                else:
-                    self.opt.virtual_step()
-
-#                 self.opt.step()
-#                 self.opt.zero_grad()
                     
                 #Gradient Norm Computation
 #                 batch_grad_norm=0.0
@@ -156,10 +157,6 @@ class ErmMatch(BaseAlgo):
                 self.max_epoch= epoch
                 self.save_model()
                 
-                # Sanity check on the test accuracy
-#                 self.test_method.get_model()        
-#                 self.test_method.get_metric_eval()
-#                 print( ' Sanity Check Test Accuracy: ', self.test_method.metric_score )                                    
             print('Current Best Epoch: ', self.max_epoch, ' with Test Accuracy: ', self.final_acc[self.max_epoch])
             
             if epoch > 0 and self.args.model_name in ['domain_bed_mnist', 'lenet']:
diff --git a/algorithms/match_dg.py b/algorithms/match_dg.py
index 9dcdf86..0ea30a8 100644
--- a/algorithms/match_dg.py
+++ b/algorithms/match_dg.py
@@ -178,6 +178,9 @@ class MatchDG(BaseAlgo):
 #                             print('Weird! Positive Matches are more than the negative matches?', pos_feat_match.shape[0], neg_feat_match.shape[0])
 
                         # If no instances of label y_c in the current batch then continue
+                        
+                        print(pos_feat_match.shape[0], neg_feat_match.shape[0], y_c)
+        
                         if pos_feat_match.shape[0] ==0 or neg_feat_match.shape[0] == 0:
                             continue
 
@@ -229,6 +232,9 @@ class MatchDG(BaseAlgo):
                 
                     loss_e += ( ( epoch- self.args.penalty_s )/(self.args.epochs -self.args.penalty_s) )*diff_hinge_loss
                         
+                if not loss_e.requires_grad:
+                    continue
+                    
                 loss_e.backward(retain_graph=False)
                 self.opt.step()
                 
diff --git a/data/data_gen_mnist.py b/data/data_gen_mnist.py
new file mode 100644
index 0000000..19291b9
--- /dev/null
+++ b/data/data_gen_mnist.py
@@ -0,0 +1,231 @@
+#Common imports
+import numpy as np
+import sys
+import os
+import argparse
+import random
+import copy
+import os 
+
+#Sklearn
+from scipy.stats import bernoulli
+
+#Pillow
+from PIL import Image, ImageColor, ImageOps 
+
+#Pytorch
+import torch
+import torch.utils.data as data_utils
+from torchvision import datasets, transforms
+
+def generate_rotated_domain_data(imgs, labels, data_case, dataset, indices, domain, save_dir, img_w, img_h):    
+
+    # Get total number of labeled examples
+    mnist_labels = labels[indices]
+    mnist_imgs = imgs[indices]
+    mnist_size = mnist_labels.shape[0] 
+
+    to_pil=  transforms.Compose([
+            transforms.ToPILImage(),
+            transforms.Resize((img_w, img_h))
+        ])
+
+    to_augment= transforms.Compose([
+            transforms.RandomResizedCrop(img_w, scale=(0.7,1.0)),
+            transforms.RandomHorizontalFlip()
+        ])
+
+    to_tensor=  transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize((0.1307,), (0.3081,))
+        ])
+    
+    if dataset == 'rot_mnist_spur':
+        color_list=['red', 'blue', 'green', 'orange', 'yellow', 'brown', 'pink', 'magenta', 'olive', 'cyan']    
+        # Adding color with 70 percent probability
+        rand_var= bernoulli.rvs(0.7, size=mnist_size)
+    
+    # Run transforms
+    if dataset == 'rot_mnist_spur':
+        mnist_img_rot= torch.zeros((mnist_size, 3, img_w, img_h))        
+        mnist_img_rot_org= torch.zeros((mnist_size, 3, img_w, img_h))        
+    else:
+        mnist_img_rot= torch.zeros((mnist_size, img_w, img_h))
+        mnist_img_rot_org= torch.zeros((mnist_size, img_w, img_h))
+        
+    mnist_idx=[]
+
+    for i in range(len(mnist_imgs)):
+        
+        curr_image= to_pil(mnist_imgs[i])         
+        
+        #Color the image
+        if dataset == 'rot_mnist_spur':
+            if rand_var[i]:
+                # Change colors per label for test domains relative to the train domains
+                if data_case == 'test':
+                    curr_image = ImageOps.colorize(curr_image, black ="black", white =color_list[mnist_labels[i].item()])    
+                    # Choose this for test domain with permuted colors
+#                     curr_image = ImageOps.colorize(curr_image, black ="black", white =color_list[(mnist_labels[i].item()+1)%10]  )
+                else:
+                    curr_image = ImageOps.colorize(curr_image, black ="black", white =color_list[mnist_labels[i].item()])    
+            else:
+                curr_image = ImageOps.colorize(curr_image, black ="black", white ="white")               
+        
+        #Rotation
+        if domain == '0':
+            img_rotated= curr_image
+        else:
+            img_rotated= transforms.functional.rotate( curr_image, int(domain) )
+
+        mnist_img_rot_org[i]= to_tensor(img_rotated)        
+        #Augmentation
+        mnist_img_rot[i]= to_tensor(to_augment(img_rotated))        
+
+    if data_case == 'train' or data_case == 'val':
+        torch.save(mnist_img_rot, save_dir + '_data.pt')    
+        
+    torch.save(mnist_img_rot_org, save_dir + '_org_data.pt')        
+    torch.save(mnist_labels, save_dir + '_label.pt')    
+    
+    if dataset == 'rot_mnist_spur':
+        np.save(save_dir + '_spur.npy', rand_var)
+    
+    print('Data Case: ', data_case, ' Source Domain: ', domain, ' Shape: ', mnist_img_rot.shape, mnist_img_rot_org.shape, mnist_labels.shape)        
+    
+    return
+
+# Main Function
+
+# Input Parsing
+parser = argparse.ArgumentParser()
+parser.add_argument('--dataset', type=str, default='rot_mnist', 
+                    help='Datasets: rot_mnist; fashion_mnist; rot_mnist_spur')
+parser.add_argument('--model', type=str, default='resnet18', 
+                    help='Base Models: resnet18; lenet')
+parser.add_argument('--data_size', type=int, default=60000)
+parser.add_argument('--subset_size', type=int, default=2000)
+parser.add_argument('--img_w', type=int, default=224)
+parser.add_argument('--img_h', type=int, default=224)
+
+args = parser.parse_args()
+
+dataset= args.dataset
+model= args.model
+img_w= args.img_w
+img_h= args.img_h
+data_size= args.data_size
+subset_size= args.subset_size
+val_size= int(args.subset_size/5)
+
+#Generate Dataset for Rotated / Fashion MNIST
+#TODO: Manage OS Env from args
+os_env=0
+if os_env:
+    base_dir= os.getenv('PT_DATA_DIR') + '/mnist/'
+else:
+    base_dir= 'data/datasets/mnist/'
+    
+if not os.path.exists(base_dir):
+    os.makedirs(base_dir)
+        
+        
+data_dir= base_dir + dataset + '_' + model + '/'
+if not os.path.exists(data_dir):
+    os.makedirs(data_dir)
+    
+    
+if dataset =='rot_mnist' or dataset == 'rot_mnist_spur':
+    data_obj_train= datasets.MNIST(base_dir,
+                                train=True,
+                                download=True,
+                                transform=transforms.ToTensor()
+                            )
+
+    data_obj_test= datasets.MNIST(base_dir,
+                                train=False,
+                                download=True,
+                                transform=transforms.ToTensor()
+                            )
+    mnist_imgs= torch.cat((data_obj_train.data, data_obj_test.data))
+    mnist_labels= torch.cat((data_obj_train.targets, data_obj_test.targets))
+
+elif dataset == 'fashion_mnist':
+    data_obj_train= datasets.FashionMNIST(base_dir,
+                                        train=True,
+                                        download=True,
+                                        transform=transforms.ToTensor()
+                                    )
+
+    data_obj_test= datasets.FashionMNIST(base_dir,
+                                train=False,
+                                download=True,
+                                transform=transforms.ToTensor()
+                            )
+    mnist_imgs= torch.cat((data_obj_train.data, data_obj_test.data))
+    mnist_labels= torch.cat((data_obj_train.targets, data_obj_test.targets))
+    
+
+# For testing over different base objects; seed 9
+# Seed 9 only for test data, See 0:3 for train data
+seed_list= [0, 1, 2, 9]    
+domains= [0, 15, 30, 45, 60, 75, 90]
+
+for seed in seed_list:
+    
+    # Random Seed
+    random.seed(seed*10)
+    np.random.seed(seed*10)     
+    torch.manual_seed(seed*10)    
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed*10)
+        
+    # Indices
+    res=np.random.choice(data_size, subset_size+val_size)
+    print('Seed: ', seed)
+    for domain in domains:        
+                
+        #Train
+        data_case= 'train'
+        if not os.path.exists(data_dir + data_case +  '/'):
+            os.makedirs(data_dir + data_case + '/')
+
+        save_dir= data_dir + data_case + '/' + 'seed_' + str(seed) + '_domain_' + str(domain)
+        indices= res[:subset_size]      
+
+        if model == 'resnet18':
+            if seed in [0, 1, 2] and domain in [15, 30, 45, 60, 75]:
+                generate_rotated_domain_data(mnist_imgs, mnist_labels, data_case, dataset, indices, domain, save_dir, img_w, img_h)                   
+        elif model in ['lenet']:
+            if seed in [0, 1, 2] and domain in [0, 15, 30, 45, 60, 75]:
+                generate_rotated_domain_data(mnist_imgs, mnist_labels, data_case, dataset, indices, domain, save_dir, img_w, img_h)                   
+                    
+        #Val 
+        data_case= 'val'
+        if not os.path.exists(data_dir +  data_case +  '/'):
+            os.makedirs(data_dir + data_case + '/')
+        
+        save_dir= data_dir + data_case +  '/' + 'seed_' + str(seed) + '_domain_' + str(domain)
+        indices= res[subset_size:]
+        
+        if model == 'resnet18':
+            if seed in [0, 1, 2] and domain in [15, 30, 45, 60, 75]:
+                generate_rotated_domain_data(mnist_imgs, mnist_labels, data_case, dataset, indices, domain, save_dir, img_w, img_h)                
+        elif model in ['lenet']:
+            if seed in [0, 1, 2] and domain in [0, 15, 30, 45, 60, 75]:
+                generate_rotated_domain_data(mnist_imgs, mnist_labels, data_case, dataset, indices, domain, save_dir, img_w, img_h)                
+            
+        #Test
+        data_case= 'test'
+        if not os.path.exists(data_dir +  data_case  +  '/'):
+            os.makedirs(data_dir + data_case + '/')
+            
+        save_dir= data_dir + data_case + '/' + 'seed_' + str(seed) + '_domain_' + str(domain)
+        indices= res[:subset_size]
+        
+        if model == 'resnet18':
+            if seed in [0, 1, 2, 9] and domain in [0, 90]:
+                generate_rotated_domain_data(mnist_imgs, mnist_labels, data_case, dataset, indices, domain, save_dir, img_w, img_h)             
+        elif model in ['lenet', 'lenet_mdg']:
+            if seed in [0, 1, 2] and domain in [0, 15, 30, 45, 60, 75]:
+                generate_rotated_domain_data(mnist_imgs, mnist_labels, data_case, dataset, indices, domain, save_dir, img_w, img_h)                     
diff --git a/data_gen_syn.py b/data_gen_syn.py
index 4064897..dce0dd9 100644
--- a/data_gen_syn.py
+++ b/data_gen_syn.py
@@ -38,8 +38,8 @@ if not os.path.exists(base_dir):
 
 num_samples= 10000
 total_slabs= 7
-slab_noise_list= [0.0, 0.10, 0.20]
-spur_corr_list= [0.0, 0.05, 0.10, 0.15, 0.30, 0.50, 0.70, 0.90, 1.0]
+slab_noise_list= [0.0, 0.10]
+spur_corr_list= [0.0, 0.10, 0.20, 0.90]
 
 for seed in range(10):
     np.random.seed(seed*10)                     
diff --git a/docs/notebooks/ChestXRay_Translate.ipynb b/docs/notebooks/ChestXRay_Translate.ipynb
index 2c0998a..3e4b25a 100644
--- a/docs/notebooks/ChestXRay_Translate.ipynb
+++ b/docs/notebooks/ChestXRay_Translate.ipynb
@@ -187,7 +187,7 @@
       "Fracture doesn't exist. Adding nans instead.\n",
       "Lung Opacity doesn't exist. Adding nans instead.\n",
       "Enlarged Cardiomediastinum doesn't exist. Adding nans instead.\n",
-      "{'Support Devices', 'Pleural Other'} will be dropped\n",
+      "{'Pleural Other', 'Support Devices'} will be dropped\n",
       "Infiltration doesn't exist. Adding nans instead.\n",
       "Emphysema doesn't exist. Adding nans instead.\n",
       "Fibrosis doesn't exist. Adding nans instead.\n",
@@ -565,9 +565,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(112120,)\n",
+      "Error:\n",
+      "torch.Size([800, 3, 224, 224]) torch.Size([800, 3, 224, 224]) torch.Size([800]) 400 400\n",
+      "torch.Size([200, 3, 224, 224]) torch.Size([200, 3, 224, 224]) torch.Size([200]) 100 100\n",
+      "torch.Size([400, 3, 224, 224]) torch.Size([400, 3, 224, 224]) torch.Size([400]) 200 200\n",
+      "(191010,)\n",
+      "torch.Size([800, 3, 224, 224]) torch.Size([800, 3, 224, 224]) torch.Size([800]) 400 400\n",
+      "torch.Size([200, 3, 224, 224]) torch.Size([200, 3, 224, 224]) torch.Size([200]) 100 100\n",
+      "torch.Size([400, 3, 224, 224]) torch.Size([400, 3, 224, 224]) torch.Size([400]) 200 200\n",
+      "(26684,)\n",
+      "torch.Size([800, 3, 224, 224]) torch.Size([800, 3, 224, 224]) torch.Size([800]) 400 400\n",
+      "torch.Size([200, 3, 224, 224]) torch.Size([200, 3, 224, 224]) torch.Size([200]) 100 100\n",
+      "torch.Size([400, 3, 224, 224]) torch.Size([400, 3, 224, 224]) torch.Size([400]) 200 200\n"
+     ]
+    }
+   ],
    "source": [
     "base_dir=root_dir + '/data/datasets/chestxray/'\n",
     "        \n",
diff --git a/docs/notebooks/Preprocess.ipynb b/docs/notebooks/Preprocess.ipynb
index 5bdd349..3112761 100644
--- a/docs/notebooks/Preprocess.ipynb
+++ b/docs/notebooks/Preprocess.ipynb
@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -37,7 +37,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -51,7 +51,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -77,7 +77,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -86,7 +86,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -107,7 +107,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/docs/notebooks/beta_reproduce_results.ipynb b/docs/notebooks/beta_reproduce_results.ipynb
new file mode 100644
index 0000000..33d9ccb
--- /dev/null
+++ b/docs/notebooks/beta_reproduce_results.ipynb
@@ -0,0 +1,658 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Reproducing results\n",
+    "\n",
+    "\n",
+    "The following code reproduces results for Slab dataset, Rotated MNIST and Fashion-MNIST dataset, and PACS dataset corresponding to Tables 1, 2, 3, 4, 5, 6 in the main paper.\n",
+    "\n",
+    "## Note regarding hardware requirements\n",
+    "\n",
+    "The code requires a GPU device, also the batch size for MatchDG Phase 1 training might need to be adjusted according to the memory limits of the GPU device. In case of CUDA of out of memory issues, try with a smaller batch size."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Installing Libraries\n",
+    "\n",
+    "List of all the required packages are mentioned in the file 'requirements.txt'\n",
+    "\n",
+    "You may install them as follows: `pip install -r requirements.txt`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 1: Slab Dataset\n",
+    "\n",
+    "## Prepare Slab Dataset\n",
+    "\n",
+    "Run the following command:\n",
+    "\n",
+    "`python3 data_gen_syn.py`\n",
+    "\n",
+    "## Table 1\n",
+    "\n",
+    "Run the following command:\n",
+    "\n",
+    "`python3 reproduce_scripts/reproduce_slab.py train`\n",
+    "\n",
+    "The results would be stored in the `results/slab/logs/` directory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 2, 3: RotMNIST & Fashion MNIST\n",
+    "\n",
+    "## Prepare Data for Rot MNIST & Fashion MNIST\n",
+    "\n",
+    "Run the following command"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`python data/data_gen_mnist.py --dataset rot_mnist --model resnet18 --img_h 224 --img_w 224 --subset_size 2000` \n",
+    "\n",
+    "`python data/data_gen_mnist.py --dataset fashion_mnist --model resnet18 --img_h 224 --img_w 224 --subset_size 10000`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Table 2\n",
+    "\n",
+    "Rotated MNIST dataset with training domains set to [15, 30, 45, 60, 75] and the test domains set to [0, 90]. \n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_all --metric train`\n",
+    "\n",
+    "The results would be present in the `results/rot_mnist/train_logs/` directory\n",
+    "\n",
+    "To obtain results for the FashionMNIST dataset, change the dataset parameter `--dataset` from `rot_mnist` to `fashion_mnist`.\n",
+    "\n",
+    "To obtain results for the different set of training domains in the paper, change the input to the parameter `--train_case` to `train_abl_3` for training with domains [30, 45, 60], and `train_abl_2` for training with domains [30, 45] "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Table 3\n",
+    "\n",
+    "Run the following commands:\n",
+    "\n",
+    "`python test.py --dataset rot_mnist --method_name erm_match --match_case 0.0 --penalty_ws 0.0 --test_metric match_score`\n",
+    "\n",
+    "`python test.py --dataset rot_mnist --method_name matchdg_ctr --match_case 0.0 --match_flag 1 --pos_metric cos --test_metric match_score`\n",
+    "\n",
+    "For MDG Perf, run the folllowing command to first train the model:\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_mdg_ctr_run.py --dataset rot_mnist --perf_init 1`\n",
+    "\n",
+    "Then run the following commands to evalute match function metrics:\n",
+    "\n",
+    "`python test.py --dataset rot_mnist --method_name matchdg_ctr --match_case 1.0 --match_flag 1 --pos_metric cos --test_metric match_score`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 4, 5: PACS\n",
+    "\n",
+    "## Prepare Data for PACS\n",
+    "\n",
+    "Download the PACS dataset (https://drive.google.com/drive/folders/0B6x7gtvErXgfUU1WcGY5SzdwZVk) and place it in the directory '/data/datasets/pacs/' "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Table 4\n",
+    "\n",
+    "* RandMatch: "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`python3 reproduce_scripts/pacs_run.py --method rand --model resnet18`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* MatchDG:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For contrastive phase, we train with the resnet50 model despite the model architecture in Phase 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`python3 reproduce_scripts/pacs_run.py --method matchdg_ctr --model resnet50`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`python3 reproduce_scripts/pacs_run.py --method matchdg_erm --model resnet18`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* MDGHybrid:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "No need to train the contrastive phase again if already done while training MatchDG"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`python3 reproduce_scripts/pacs_run.py --method hybrid --model resnet18`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Table 5\n",
+    "\n",
+    "Repeat the above commands and replace the argument to flag --model with resnet50 with resnet18 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 6: Chest X-Ray"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prepare Data for Chest X-Ray\n",
+    "\n",
+    "    -Follow the steps in the Preprocess.ipynb notebook to donwload and process the Chest X-Ray datasets\n",
+    "    -Then follow the steps in the ChestXRay_Translate.ipynb notebook to perform image translations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* NIH: "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`python3 reproduce_scripts/cxray_run.py --test_domain nih --metric train`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* Chexpert: "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`python3 reproduce_scripts/cxray_run.py --test_domain chex --metric train`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "* RSNA: "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`python3 reproduce_scripts/cxray_run.py --test_domain kaggle --metric train`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The results would be stored in the `results/cxray/train_logs` directory"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 11\n",
+    "\n",
+    "Run the following command for data generation:\n",
+    "\n",
+    "`python data/data_gen_mnist.py --dataset rot_mnist --model lenet --img_h 32 --img_w 32 --subset_size 1000`\n",
+    "\n",
+    "Run the following commands for training models:\n",
+    "\n",
+    "`python3 reproduce_rmnist_lenet.py`\n",
+    "\n",
+    "The results will be stored in the directory: `results/rmnist_lenet/`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 12\n",
+    "\n",
+    "Run the following command for data generation:\n",
+    "\n",
+    "    \n",
+    "Run the following command for training models:\n",
+    "\n",
+    "`python3 reproduce_rmnist_domainbed.py`\n",
+    "\n",
+    "The results will be stored in the directory: `results/rmnist_domain_bed/`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 13\n",
+    "\n",
+    "To obtain results for the FashionMNIST dataset, change the dataset parameter `--dataset` from `rot_mnist` to `fashion_mnist`.\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_all --metric train --methods approx_25 approx_50 approx_75`\n",
+    "\n",
+    "The results will be stored in the directory: `results/rot_mnist/train_logs/`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 14\n",
+    "\n",
+    "To obtain results for the FashionMNIST dataset, change the dataset parameter `--dataset` from `rot_mnist` to `fashion_mnist`.\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_all --metric match_score --data_case train --methods rand perf matchdg`\n",
+    "\n",
+    "The results would be stored in the directory: `results/rot_mnist/match_score_train/`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 15\n",
+    "\n",
+    "Generate data again for the Fashion MNIST 2k sample case by running the following command:\n",
+    "\n",
+    "`python data/data_gen_mnist.py --dataset fashion_mnist --model resnet18 --img_h 224 --img_w 224 --subset_size 2000`\n",
+    "\n",
+    "Then follow the same commands as mentioned in the Table 2 section"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 16\n",
+    "\n",
+    "To obtain results for the FashionMNIST dataset, change the dataset parameter `--dataset` from `rot_mnist` to `fashion_mnist`.\n",
+    "\n",
+    "MatchDG Iterative corresponds to the default MatchDG algorithm, with the same results as in Table 3\n",
+    "\n",
+    "For MatchDG Non Iterative, run the folllowing command to first the model\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_mdg_ctr_run.py --dataset rot_mnist --iterative 0`\n",
+    "\n",
+    "Then run the following command to evaluate match function metrics:\n",
+    "\n",
+    "`python test.py --dataset rot_mnist --method_name matchdg_ctr --match_case 0.0 --match_flag 0 --pos_metric cos --test_metric match_score`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Table 18\n",
+    "\n",
+    "Repeat the commands mentioned for PACS ResNet-18 (Table 4) and replace the argument to flag --model with alexnet with resnet18 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Privacy & OOD: ICLR\n",
+    "\n",
+    "# Slab Dataset\n",
+    "\n",
+    "### Preparing Data\n",
+    "\n",
+    "`python3 data_gen_syn.py`\n",
+    "\n",
+    "### Training Models\n",
+    "\n",
+    "Run the following command to train models with no noise in the prediction mechanism based on slab features\n",
+    "\n",
+    "`python3 reproduce_scripts/slab-run.py --slab_noise 0.0`\n",
+    "\n",
+    "Run the following command to train models with noise in the prediction mechanism based on slab features\n",
+    "\n",
+    "`python3 reproduce_scripts/slab-run.py --slab_noise 0.10`\n",
+    "\n",
+    "\n",
+    "### Evaluating OOD Accuracy, Randomised-AUC, & Privacy Loss Attack\n",
+    "\n",
+    "Run the following command for the case of no noise in the prediction mechanism based on slab features\n",
+    "\n",
+    "`python3 reproduce_scripts/slab-run.py --slab_noise 0.0 --case test`\n",
+    "\n",
+    "Run the following command for the case of noise in the prediction mechanism based on slab features\n",
+    "\n",
+    "`python3 reproduce_scripts/slab-run.py --slab_noise 0.10 --case test`\n",
+    "\n",
+    "### Plotting Results\n",
+    "\n",
+    "`python3 reproduce_scripts/slab-plot.py 0.0`\n",
+    "\n",
+    "`python3 reproduce_scripts/slab-plot.py 0.1`\n",
+    "\n",
+    "The plots would be stored in the directory: `results/slab/plots/`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Rotated & Fashion MNIST \n",
+    "\n",
+    "For convenience we provide the commands for the Rotated MNIST dataset. To obtain results for the FashionMNIST dataset, change the dataset parameter `--dataset` from `rot_mnist` to `fashion_mnist`.\n",
+    "\n",
+    "### Preparing Data\n",
+    "\n",
+    "`python data/data_gen_mnist.py --dataset rot_mnist --model resnet18 --img_h 224 --img_w 224 --subset_size 2000` \n",
+    "\n",
+    "\n",
+    "### Training Models\n",
+    "\n",
+    "Training Domains: [15, 30, 45, 60, 75]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_all --metric train --data_aug 0`\n",
+    "\n",
+    "Training Domains: [30, 45, 60]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_3 --metric train --data_aug 0`\n",
+    "\n",
+    "Training Domains: [30, 45]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_2 --metric train --data_aug 0`\n",
+    "\n",
+    "The results would be present in the results/rot_mnist/train_logs/ directory\n",
+    "\n",
+    "\n",
+    "### Evaluating OOD Accuracy\n",
+    "\n",
+    "Training Domains: [15, 30, 45, 60, 75]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_all --metric acc --data_case train --data_aug 0 `\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_all --metric acc --data_case test --data_aug 0 `\n",
+    "\n",
+    "Training Domains: [30, 45, 60]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_3 --metric acc --data_case train --data_aug 0`\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_3 --metric acc --data_case test --data_aug 0`\n",
+    "\n",
+    "Training Domains: [30, 45]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_2 --metric acc --data_case train --data_aug 0`\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_2 --metric acc --data_case test --data_aug 0`\n",
+    "\n",
+    "\n",
+    "\n",
+    "### Evaluating MI Attack Accuracy\n",
+    "\n",
+    "Training Domains: [15, 30, 45, 60, 75]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_all --metric privacy_loss_attack --data_aug 0 `\n",
+    "\n",
+    "Training Domains: [30, 45, 60]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_3 --metric privacy_loss_attack --data_aug 0`\n",
+    "\n",
+    "Training Domains: [30, 45]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_2 --metric privacy_loss_attack --data_aug 0`\n",
+    "\n",
+    "\n",
+    "### Evaluating Mean Rank\n",
+    "\n",
+    "Training Domains: [15, 30, 45, 60, 75]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_all --metric match_score --data_case test --data_aug 0 `\n",
+    "\n",
+    "Training Domains: [30, 45, 60]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_3 --metric match_score --data_case test --data_aug 0`\n",
+    "\n",
+    "Training Domains: [30, 45]\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --train_case train_abl_2 --metric match_score --data_case test --data_aug 0`\n",
+    "\n",
+    "### Plotting Results\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_plot.py rot_mnist`\n",
+    "\n",
+    "The plots would be stored in the directory: `results/rot_mnist/plots/`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Differentially Private Noise\n",
+    "\n",
+    "For convenience we provide the commands for the Rotated MNIST dataset. To obtain results for the FashionMNIST dataset, change the dataset parameter `--dataset` from `rot_mnist` to `fashion_mnist`.\n",
+    "\n",
+    "The command below produces results for the case of epsilon 1.0; repeat the same command by changing the input to the paramter `--dp_epsilon` to the other values from the list: [1, 2, 5, 10]. \n",
+    "\n",
+    "\n",
+    "### Training Models\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --dp_noise 1 --dp_epsilon 1.0 --data_aug 0 --methods erm perf`\n",
+    "\n",
+    "### Evaluating OOD Accuracy\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --dp_noise 1 --dp_epsilon 1.0 --data_aug 0 --methods erm perf --metric acc --data_case test `\n",
+    "\n",
+    "\n",
+    "### Evaluating MI Attack Accuracy\n",
+    "\n",
+    "`python3 reproduce_scripts/mnist_run.py --dataset rot_mnist --dp_noise 1 --dp_epsilon 1.0 --data_aug 0 --methods erm perf --metric privacy_loss_attack`\n",
+    "\n",
+    "### Infinite Epsilon Case\n",
+    "\n",
+    "Append this extra parameter ` --dp_attach_opt 0 ` to all the commands above. This does not attach the differential privacy engine with the optimizer. Also, change the epsilon value to the parameter ` --dp_epsilon ` to any random value as it does not matter since the privacy engine is not attached to the optimizer\n",
+    "\n",
+    "### Plotting Results\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ChestXRay Dataset\n",
+    "\n",
+    "### Prepare Data for Chest X-Ray\n",
+    "\n",
+    "    -Follow the steps in the Preprocess.ipynb notebook to donwload and process the Chest X-Ray datasets\n",
+    "    -Then follow the steps in the ChestXRay_Translate.ipynb notebook to perform image translations\n",
+    "\n",
+    "### Training Models\n",
+    "\n",
+    "Test Domain NIH\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain nih --metric train`\n",
+    "\n",
+    "Test Domain Chexpert\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain chex --metric train`\n",
+    "\n",
+    "Test Domain RSNA\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain kaggle --metric train`\n",
+    "\n",
+    "### Evaluating OOD Accuracy\n",
+    "\n",
+    "Test Domain NIH\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain nih --metric acc --data_case train`\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain nih --metric acc --data_case test`\n",
+    "\n",
+    "Test Domain Chexpert\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain chex --metric acc --data_case train`\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain chex --metric acc --data_case test`\n",
+    "\n",
+    "Test Domain RSNA\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain kaggle --metric acc --data_case train`\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain kaggle --metric acc --data_case test`\n",
+    "\n",
+    "\n",
+    "### Evaluating MI Attack Accuracy\n",
+    "\n",
+    "Test Domain NIH\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain nih --metric privacy_loss_attack`\n",
+    "\n",
+    "Test Domain Chexpert\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain chex --metric privacy_loss_attack`\n",
+    "\n",
+    "Test Domain RSNA\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_run.py --test_domain kaggle --metric privacy_loss_attack`\n",
+    "\n",
+    "\n",
+    "### Plotting Results\n",
+    "\n",
+    "`python3 reproduce_scripts/cxray_plot.py`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Attribute Attack\n",
+    "\n",
+    "python data/data_gen_mnist.py --dataset rot_mnist_spur --model resnet18 --img_h 224 --img_w 224 --subset_size 2000"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/notebooks/reproducing_results_matchdg_paper.ipynb b/docs/notebooks/reproducing_results_matchdg_paper.ipynb
index db367d3..7f3d17e 100644
--- a/docs/notebooks/reproducing_results_matchdg_paper.ipynb
+++ b/docs/notebooks/reproducing_results_matchdg_paper.ipynb
@@ -351,7 +351,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.7"
+   "version": "3.7.9"
   }
  },
  "nbformat": 4,
diff --git a/docs/notebooks/usenix_results.ipynb b/docs/notebooks/usenix_results.ipynb
index 455d16a..d4eec39 100644
--- a/docs/notebooks/usenix_results.ipynb
+++ b/docs/notebooks/usenix_results.ipynb
@@ -32,7 +32,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -59,58 +59,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n",
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n",
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "for idx in range(3):\n",
     "    \n",
@@ -153,7 +104,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -180,58 +131,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n",
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n",
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "for idx in range(3):\n",
     "    \n",
@@ -274,7 +176,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -301,58 +203,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n",
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n",
-      "/home/t-dimaha/FairDG/robust_learning/envs/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
-      "  \n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x576 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "for idx in range(3):\n",
     "    \n",
@@ -533,13 +386,414 @@
     "att=[]\n",
     "att_err=[]"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DP ERM: Rotated MNIST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=['2', '5', '10', '50', '100', '500']\n",
+    "dp_erm= [26.9, 33.5, 45.6, 59.6, 63.8, 73.4]\n",
+    "dp_erm_std= [1.30, 3.81, 1.15, 2.22, 3.49, 0.29]\n",
+    "dp_perf= [22.7, 32.2, 39.5, 58.7, 66.5, 81.4]\n",
+    "dp_perf_std= [2.55, 2.89, 2.15, 2.28, 1.86, 1.17]\n",
+    "\n",
+    "plt.xlabel('Epsilon')\n",
+    "plt.ylabel('OOD Accuracy')\n",
+    "plt.title('Training with differentially noise')\n",
+    "plt.errorbar(x, dp_erm, yerr=dp_erm_std, label='DP-ERM')\n",
+    "plt.errorbar(x, dp_perf, yerr=dp_perf_std, label='DP-Perf')\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## DP Analysis: ERM vs Perf 50th Epoch Acc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "f1= '../../erm_dp.txt'\n",
+    "f2= '../../perf_dp.txt'\n",
+    "\n",
+    "f= open(f1)\n",
+    "erm_data= f.readlines()\n",
+    "\n",
+    "f= open(f2)\n",
+    "perf_data= f.readlines()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "flag=0\n",
+    "for line in erm_data:\n",
+    "    \n",
+    "    if flag==2:\n",
+    "        print(line)\n",
+    "        flag=0\n",
+    "        \n",
+    "    if flag==1:\n",
+    "        print(line)\n",
+    "        flag+= 1        \n",
+    "    \n",
+    "    if 'Done Training for epoch:  45' in line:\n",
+    "        print(line)\n",
+    "        flag+=1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "flag=0\n",
+    "for line in perf_data:\n",
+    "    \n",
+    "    if flag==2:\n",
+    "        print(line)\n",
+    "        flag=0\n",
+    "        \n",
+    "    if flag==1:\n",
+    "        print(line)\n",
+    "        flag+= 1        \n",
+    "    \n",
+    "    if 'Done Training for epoch:  45' in line:\n",
+    "        print(line)\n",
+    "        flag+=1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Attribute Attack"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=['ERM', 'Rand', 'MatchDG', 'CSD', 'IRM', 'Perf']\n",
+    "matplotlib.rcParams.update({'errorbar.capsize': 2})\n",
+    "fig, ax = plt.subplots(1, 1, figsize=(12, 8))\n",
+    "fontsize=33\n",
+    "fontsize_lgd= fontsize/1.2\n",
+    "marker_list = ['o', '^']\n",
+    "\n",
+    "ax.tick_params(labelsize=fontsize)\n",
+    "ax.set_xticklabels(x, rotation=25)\n",
+    "ax.set_title('Attribute Attack on Colored Rotated MNIST', fontsize= fontsize)\n",
+    "ax.set_ylabel('Metric Score', fontsize=fontsize)\n",
+    "\n",
+    "mi= [97.7 , 83.0, 95.3, 92.4, 97.9, 69.9]\n",
+    "mi_err= [0.41, 3.09, 3.80, 1.30, 0.30, 0.03]\n",
+    "acc_p= [25.3, 28.9, 25.5, 42.9, 25.4, 93.4]\n",
+    "acc_p_err= [0.17, 1.81, 0.28, 2.30, 0.21, 0.35]\n",
+    "\n",
+    "ax.errorbar(x, mi, yerr=mi_err, marker= marker_list[0], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='AI Attack')\n",
+    "ax.errorbar(x, acc_p, yerr=acc_p_err, marker= marker_list[1], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='Test Acc Permute')\n",
+    "ax.legend(fontsize= fontsize_lgd)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('../../results/ai_attack_cmnist.pdf', dpi=600)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DP Analysis Rotated MNIST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:10: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
+      "  # Remove the CWD from sys.path while we load stuff.\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:19: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"o--\" (-> marker='o'). The keyword argument will take precedence.\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:20: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"o--\" (-> marker='o'). The keyword argument will take precedence.\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:24: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:33: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"o--\" (-> marker='o'). The keyword argument will take precedence.\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:34: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"o--\" (-> marker='o'). The keyword argument will take precedence.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1728x576 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "x=['1.0', '2.0', '5.0', '10.0', 'Inf']\n",
+    "matplotlib.rcParams.update({'errorbar.capsize': 2})\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(24, 8))\n",
+    "fontsize=40\n",
+    "fontsize_lgd= fontsize/1.2\n",
+    "marker_list = ['o', '^']\n",
+    "\n",
+    "#OOD Accuracy\n",
+    "ax[0].tick_params(labelsize=fontsize)\n",
+    "ax[0].set_xticklabels(x, rotation=25)\n",
+    "ax[0].set_ylabel('OOD Accuracy', fontsize=fontsize)\n",
+    "ax[0].set_xlabel('DP-Epsilon', fontsize=fontsize)\n",
+    "\n",
+    "erm_acc= [33.7, 38.4, 40.3, 41.2, 90.9]\n",
+    "erm_std= [1.15, 2.45, 2.38, 2.73, 0.24]\n",
+    "perf_acc= [36.6, 44.1, 48.7, 50.4, 95.5]\n",
+    "perf_std= [0.69, 1.236, 3.75, 2.78, 0.26]\n",
+    "\n",
+    "ax[0].errorbar(x, erm_acc, yerr=erm_std, marker= marker_list[0], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='ERM')\n",
+    "ax[0].errorbar(x, perf_acc, yerr=perf_std, marker= marker_list[1], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='Perf Match')\n",
+    "\n",
+    "#MI Attack\n",
+    "ax[1].tick_params(labelsize=fontsize)\n",
+    "ax[1].set_xticklabels(x, rotation=25)\n",
+    "ax[1].set_ylabel('MI Attack Accuracy', fontsize=fontsize)\n",
+    "ax[1].set_xlabel('DP-Epsilon', fontsize=fontsize)\n",
+    "\n",
+    "erm_acc=  [60.5, 65.4, 66.2, 67.1, 71.9]\n",
+    "erm_std=  [0.92, 1.03, 0.81, 0.41, 0.29]\n",
+    "perf_acc= [60.2, 63.8, 65.3, 65.4, 64.9]\n",
+    "perf_std= [1.07, 0.42, 0.38, 0.50, 0.72]\n",
+    "\n",
+    "ax[1].errorbar(x, erm_acc, yerr=erm_std, marker= marker_list[0], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='ERM')\n",
+    "ax[1].errorbar(x, perf_acc, yerr=perf_std, marker= marker_list[1], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='Perf Match')\n",
+    "\n",
+    "\n",
+    "lines, labels = fig.axes[-1].get_legend_handles_labels()    \n",
+    "lgd= fig.legend(lines, labels, loc=\"lower center\", bbox_to_anchor=(0.5, -0.15), fontsize=fontsize, ncol=3)\n",
+    "    \n",
+    "plt.tight_layout()\n",
+    "plt.savefig('../../results/dp_rmnist.pdf', bbox_extra_artists=(lgd,), bbox_inches='tight',  dpi=600)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DP Analysis Fashion MNIST"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:10: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
+      "  # Remove the CWD from sys.path while we load stuff.\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:19: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"o--\" (-> marker='o'). The keyword argument will take precedence.\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:20: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"o--\" (-> marker='o'). The keyword argument will take precedence.\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:24: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:33: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"o--\" (-> marker='o'). The keyword argument will take precedence.\n",
+      "/home/t-dimaha/RobustDG/robustdg/matchdg-env/lib/python3.7/site-packages/ipykernel_launcher.py:34: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"o--\" (-> marker='o'). The keyword argument will take precedence.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1728x576 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "x=['1.0', '2.0', '5.0', '10.0', 'Inf']\n",
+    "matplotlib.rcParams.update({'errorbar.capsize': 2})\n",
+    "fig, ax = plt.subplots(1, 2, figsize=(24, 8))\n",
+    "fontsize=40\n",
+    "fontsize_lgd= fontsize/1.2\n",
+    "marker_list = ['o', '^']\n",
+    "\n",
+    "#OOD Accuracy\n",
+    "ax[0].tick_params(labelsize=fontsize)\n",
+    "ax[0].set_xticklabels(x, rotation=25)\n",
+    "ax[0].set_ylabel('OOD Accuracy', fontsize=fontsize)\n",
+    "ax[0].set_xlabel('DP-Epsilon', fontsize=fontsize)\n",
+    "\n",
+    "erm_acc= [46.6, 46.7, 46.3, 45.6, 57.6]\n",
+    "erm_std= [1.70, 2.03, 1.99, 2.19, 1.53]\n",
+    "perf_acc= [48.9, 50.9, 53.5, 54.1, 67.6]\n",
+    "perf_std= [1.19, 1.01, 0.95, 0.89, 1.63]\n",
+    "\n",
+    "ax[0].errorbar(x, erm_acc, yerr=erm_std, marker= marker_list[0], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='ERM')\n",
+    "ax[0].errorbar(x, perf_acc, yerr=perf_std, marker= marker_list[1], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='Perf Match')\n",
+    "\n",
+    "#MI Attack\n",
+    "ax[1].tick_params(labelsize=fontsize)\n",
+    "ax[1].set_xticklabels(x, rotation=25)\n",
+    "ax[1].set_ylabel('MI Attack Accuracy', fontsize=fontsize)\n",
+    "ax[1].set_xlabel('DP-Epsilon', fontsize=fontsize)\n",
+    "\n",
+    "erm_acc=  [62.9, 63.9, 65.6, 64.9, 80.5]\n",
+    "erm_std=  [0.75, 0.68, 0.44, 0.51, 0.31]\n",
+    "perf_acc= [60.7, 62.7, 62.6, 62.6, 71.0]\n",
+    "perf_std= [0.13, 0.25, 0.18, 0.31, 0.60]\n",
+    "\n",
+    "ax[1].errorbar(x, erm_acc, yerr=erm_std, marker= marker_list[0], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='ERM')\n",
+    "ax[1].errorbar(x, perf_acc, yerr=perf_std, marker= marker_list[1], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='Perf Match')\n",
+    "\n",
+    "\n",
+    "lines, labels = fig.axes[-1].get_legend_handles_labels()    \n",
+    "lgd= fig.legend(lines, labels, loc=\"lower center\", bbox_to_anchor=(0.5, -0.15), fontsize=fontsize, ncol=3)\n",
+    "    \n",
+    "plt.tight_layout()\n",
+    "plt.savefig('../../results/dp_fmnist.pdf', bbox_extra_artists=(lgd,), bbox_inches='tight',  dpi=600)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "locs = [ [1], [2] ]\n",
+    "for loc in locs:\n",
+    "    loc= loc*2\n",
+    "\n",
+    "print(locs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x= torch.rand(2,2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x.unsqueeze(1).expand(-1,4,-1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x.unsqueeze(1).repeat(1,4,2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "drwils_env",
+   "display_name": "matchdg-env",
    "language": "python",
-   "name": "drwils_env"
+   "name": "matchdg-env"
   },
   "language_info": {
    "codemirror_mode": {
diff --git a/reproduce_scripts/cxray_run.py b/reproduce_scripts/cxray_run.py
index 8fb7373..bc58c3b 100644
--- a/reproduce_scripts/cxray_run.py
+++ b/reproduce_scripts/cxray_run.py
@@ -16,7 +16,11 @@ metric= args.metric
 test_domain= args.test_domain
 data_case= args.data_case
 
-methods=['erm', 'irm', 'csd', 'rand', 'matchdg_ctr', 'matchdg_erm', 'hybrid']
+if metric == 'train':
+    methods=['erm', 'irm', 'csd', 'rand', 'matchdg_ctr', 'matchdg_erm', 'hybrid']
+else:
+    methods=['erm', 'irm', 'csd', 'rand', 'matchdg_erm', 'hybrid']
+
 domains= ['nih', 'chex', 'kaggle']
 dataset= 'chestxray'
 
diff --git a/reproduce_scripts/mnist_mdg_ctr_run.py b/reproduce_scripts/mnist_mdg_ctr_run.py
index 0532ed3..d216cb1 100644
--- a/reproduce_scripts/mnist_mdg_ctr_run.py
+++ b/reproduce_scripts/mnist_mdg_ctr_run.py
@@ -1,17 +1,23 @@
 import os
-#rot_mnist, fashion_mnist
-dataset=sys.argv[1]
+import argparse
 
-#TODO 
-#1) Add another argparse arugment for deciding between perfect and non-iterative
-#2) Script for evaluating the match function metrics
+# Input Parsing
+parser = argparse.ArgumentParser()
+parser.add_argument('--dataset', type=str, default='rot_mnist', 
+                    help='Datasets: rot_mnist; fashion_mnist')
+parser.add_argument('--iterative', type=int, default=1, 
+                    help='Iterative updates to positive matches')
+parser.add_argument('--perf_init', type=int, default=0, 
+                    help='Positive matches Initialization to perfect matches')
+
+args = parser.parse_args()
+dataset= args.dataset
+iterative= args.iterative
+perf_init= args.perf_init
 
 base_script= 'python train.py --epochs 50 --batch_size 64 --dataset ' + str(dataset)
-
-#Perf MDG
-script= base_script + '  --method_name matchdg_ctr --match_case 1.0 --match_flag 1  --pos_metric cos '
+script= base_script + '  --method_name matchdg_ctr --pos_metric cos --match_case ' +  str(perf_init) + ' --match_flag ' + str(iterative)
 os.system(script)
 
-#Non Iterative MDG
-script= base_script + '  --method_name matchdg_ctr --match_case 0.0 --match_flag 0  --pos_metric cos '
-os.system(script)
\ No newline at end of file
+
+#2) Script for evaluating the match function metrics
diff --git a/reproduce_scripts/mnist_plot.py b/reproduce_scripts/mnist_plot.py
index d80b46e..f9f3592 100644
--- a/reproduce_scripts/mnist_plot.py
+++ b/reproduce_scripts/mnist_plot.py
@@ -61,7 +61,7 @@ dataset=sys.argv[1]
 test_case=['test_diff']
 
 matplotlib.rcParams.update({'errorbar.capsize': 2})
-fig, ax = plt.subplots(1, 3, figsize=(33, 8))
+fig, ax = plt.subplots(1, 4, figsize=(33, 8))
 fontsize=35
 fontsize_lgd= fontsize/1.2
 x=['ERM', 'Rand', 'MatchDG', 'CSD', 'IRM', 'Perf']
@@ -70,7 +70,7 @@ methods=['erm', 'rand', 'matchdg', 'csd', 'irm', 'perf']
 
 metrics= ['acc:train', 'acc:test', 'privacy_loss_attack', 'match_score:test']
 
-for idx in range(3):
+for idx in range(4):
     
     marker_list = ['o', '^', '*']
     legend_count = 0
@@ -154,7 +154,8 @@ for idx in range(3):
     
         if idx == 0:
             ax[idx].errorbar(x, acc_test, yerr=acc_test_err, label=legend_label, marker= marker_list[legend_count], markersize= fontsize_lgd, linewidth=4, fmt='o--')
-            ax[idx].set_ylabel('OOD Accuracy', fontsize=fontsize)
+            ax[idx].set_ylabel('OOD Accuracy', fontsize=fontsize)            
+            
             
         if idx == 1:
             ax[idx].errorbar(x, loss, yerr=loss_err, label=legend_label, marker= marker_list[legend_count], markersize= fontsize_lgd, linewidth=4, fmt='o--')
@@ -165,10 +166,8 @@ for idx in range(3):
             ax[idx].set_ylabel('Mean Rank', fontsize=fontsize)
 
         if idx == 3:
-            ax[idx].errorbar(x, np.array(acc_train) - np.array(acc_test), yerr=acc_train_err, label=legend_label, fmt='o--')
-    #         ax.set_xlabel('Models', fontsize=fontsize)
-            ax[idx].set_ylabel('Train-Test Accuracy Gap of ML Model', fontsize=fontsize)
-#             ax[idx].legend(fontsize=fontsize_lgd)
+            ax[idx].errorbar(x, np.array(acc_train) - np.array(acc_test), yerr=acc_train_err, marker= 's', markersize= fontsize_lgd, linewidth=4, fmt='o--')
+            ax[idx].set_ylabel('Generalization Gap', fontsize=fontsize)
         
         legend_count+= 1 
     
diff --git a/reproduce_scripts/mnist_run.py b/reproduce_scripts/mnist_run.py
index 3cad473..a4a9355 100644
--- a/reproduce_scripts/mnist_run.py
+++ b/reproduce_scripts/mnist_run.py
@@ -14,10 +14,17 @@ parser.add_argument('--data_case', type=str, default='test',
                    help='train: Evaluate the acc/match_score metrics on the train dataset; test: Evaluate the acc/match_score metrics on the test dataset')
 parser.add_argument('--data_aug', type=int, default=1, 
                    help='0: No data augmentation for fashion mnist; 1: Data augmentation for fashion mnist')
+
+parser.add_argument('--methods', nargs='+', type=str, default=['erm', 'irm', 'csd', 'rand', 'perf', 'matchdg'], 
+                    help='List of methods: erm, irm, csd, rand, approx_25, approx_50, approx_75, perf, matchdg')
+
+
 parser.add_argument('--dp_noise', type=int, default=0, 
                     help='0: No DP noise; 1: Add DP noise')
-parser.add_argument('--dp_epsilon', type=float, default=1.0, 
+parser.add_argument('--dp_epsilon', type=float, default=100.0, 
                     help='Epsilon value for Differential Privacy')
+parser.add_argument('--dp_attach_opt', type=int, default=1, 
+                    help='0: Infinite Epsilon; 1: Finite Epsilion')
 
 args = parser.parse_args()
 
@@ -27,14 +34,13 @@ train_case= args.train_case
 metric= args.metric
 data_case= args.data_case
 data_aug= args.data_aug
+methods= args.methods
 
 # test_diff, test_common
 test_case=['test_diff']
     
 # List of methods to train/evaluate
-# methods=['erm', 'irm', 'csd', 'rand', 'approx_25', 'approx_50', 'approx_75', 'perf', 'matchdg']
-# methods=['erm', 'irm', 'csd', 'rand', 'perf', 'matchdg']
-methods=['erm', 'perf']
+# methods=[]
 
 if metric == 'train':
     if dataset in ['rot_mnist', 'rot_mnist_spur']:
@@ -46,7 +52,6 @@ if metric == 'train':
 elif metric == 'mia':
     if dataset in ['rot_mnist', 'rot_mnist_spur']:
         base_script= 'python  test.py --test_metric mia --mia_logit 1 --mia_sample_size 2000 --batch_size 64 ' + ' --dataset ' + str(dataset)
-    elif dataset in ['fashion_mnist']:
         base_script= 'python  test.py --test_metric mia --mia_logit 1 --mia_sample_size 2000 --batch_size 64 ' + ' --dataset ' + str(dataset)
 
     res_dir= 'results/'+str(dataset)+'/privacy_clf/'
@@ -107,7 +112,7 @@ if test_case  == 'test_common':
     
 #Differential Privacy
 if args.dp_noise:
-    base_script += ' --dp_noise ' + str(args.dp_noise) + ' --dp_epsilon ' + str(args.dp_epsilon) + ' '
+    base_script += ' --dp_noise ' + str(args.dp_noise) + ' --dp_epsilon ' + str(args.dp_epsilon) + ' --dp_attach_opt ' + str(args.dp_attach_opt) + ' ' 
     res_dir= res_dir[:-1] + '_epsilon_' + str(args.dp_epsilon) + '/'
     
 if not os.path.exists(res_dir):
diff --git a/reproduce_scripts/reproduce_rmnist_domainbed.py b/reproduce_scripts/reproduce_rmnist_domainbed.py
index b033dbb..c1c43fa 100644
--- a/reproduce_scripts/reproduce_rmnist_domainbed.py
+++ b/reproduce_scripts/reproduce_rmnist_domainbed.py
@@ -1,33 +1,40 @@
 import os
-import sys
+import argparse
 
-# method: rand, matchdg, perf
-method= sys.argv[1]
+# Input Parsing
+parser = argparse.ArgumentParser()
+parser.add_argument('--methods', nargs='+', type=str, default=['rand', 'matchdg_ctr', 'matchdg_erm'], 
+                    help='List of methods')
+
+args = parser.parse_args()
+methods= args.methods                    
 domains= [0, 15, 30, 45, 60, 75]
 
-if method == 'rand':
-	base_script= 'python train.py --dataset rot_mnist --mnist_case domain_bed --method_name erm_match --perfect_match 0 --match_case 0.0 --penalty_ws 1.0 --epochs 25 --batch_size 128 --model_name domain_bed_mnist --img_h 28 --img_w 28 --total_matches_per_point 1000 '
-
-elif method == 'matchdg_ctr':
-    base_script= 'python train.py --dataset rot_mnist --mnist_case domain_bed --method_name matchdg_ctr --perfect_match 0 --match_case 0.0 --match_flag 1 --epochs 50 --batch_size 512 --pos_metric cos --model_name domain_bed_mnist --img_h 28 --img_w 28 --match_func_aug_case 1 '
+for method in methods:
     
-elif method == 'matchdg_erm':
-    base_script= 'python train.py --dataset rot_mnist --mnist_case domain_bed --method_name matchdg_erm --perfect_match 0 --match_case -1 --penalty_ws 1.0 --epochs 25 --batch_size 128 --ctr_match_case 0.0 --ctr_match_flag 1 --ctr_match_interrupt 5 --ctr_model_name domain_bed_mnist  --model_name domain_bed_mnist --img_h 28 --img_w 28 --total_matches_per_point 1000 '
+    if method == 'rand':
+        base_script= 'python train.py --dataset rot_mnist --mnist_case domain_bed --method_name erm_match --perfect_match 0 --match_case 0.0 --penalty_ws 1.0 --epochs 25 --batch_size 128 --model_name domain_bed_mnist --img_h 28 --img_w 28 --total_matches_per_point 1000 '
 
-for test_domain in domains:
-    
-    train_domains=''
-    for d in domains:
-        if d != test_domain:
-            train_domains+= str(d) + ' '
-    print(train_domains)
+    elif method == 'matchdg_ctr':
+        base_script= 'python train.py --dataset rot_mnist --mnist_case domain_bed --method_name matchdg_ctr --perfect_match 0 --match_case 0.0 --match_flag 1 --epochs 50 --batch_size 512 --pos_metric cos --model_name domain_bed_mnist --img_h 28 --img_w 28 --match_func_aug_case 1 '
 
-    res_dir= 'results/rmnist_domain_bed/'
-    if not os.path.exists(res_dir):
-        os.makedirs(res_dir)
-        
-    script= base_script + ' --train_domains ' + str(train_domains) + ' --test_domains ' + str(test_domain) 
-    script= script + ' > ' + res_dir + method + '_' + str(test_domain) + '.txt'
-    
-    print('Method: ', method, ' Test Domain: ', test_domain)
-    os.system(script)
\ No newline at end of file
+    elif method == 'matchdg_erm':
+        base_script= 'python train.py --dataset rot_mnist --mnist_case domain_bed --method_name matchdg_erm --perfect_match 0 --match_case -1 --penalty_ws 1.0 --epochs 25 --batch_size 128 --ctr_match_case 0.0 --ctr_match_flag 1 --ctr_match_interrupt 5 --ctr_model_name domain_bed_mnist  --model_name domain_bed_mnist --img_h 28 --img_w 28 --total_matches_per_point 1000 '
+
+    for test_domain in domains:
+
+        train_domains=''
+        for d in domains:
+            if d != test_domain:
+                train_domains+= str(d) + ' '
+        print(train_domains)
+
+        res_dir= 'results/rmnist_domain_bed/'
+        if not os.path.exists(res_dir):
+            os.makedirs(res_dir)
+
+        script= base_script + ' --train_domains ' + str(train_domains) + ' --test_domains ' + str(test_domain) 
+        script= script + ' > ' + res_dir + method + '_' + str(test_domain) + '.txt'
+
+        print('Method: ', method, ' Test Domain: ', test_domain)
+        os.system(script)
\ No newline at end of file
diff --git a/reproduce_scripts/reproduce_rmnist_lenet.py b/reproduce_scripts/reproduce_rmnist_lenet.py
index bf3a7f8..2932ae6 100644
--- a/reproduce_scripts/reproduce_rmnist_lenet.py
+++ b/reproduce_scripts/reproduce_rmnist_lenet.py
@@ -1,40 +1,46 @@
 import os
-import sys
+import argparse
 
-# method: rand, matchdg, perf
-method= sys.argv[1]
+# Input Parsing
+parser = argparse.ArgumentParser()
+parser.add_argument('--methods', nargs='+', type=str, default=['erm', 'rand', 'matchdg_ctr', 'matchdg_erm', 'perf'], 
+                    help='List of methods')
+
+args = parser.parse_args()
+methods= args.methods                    
 domains= [0, 15, 30, 45, 60, 75]
 
+for method in methods:
+                    
+    if method == 'perf':
+        base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name erm_match --match_case 1.0 --penalty_ws 1.0 --epochs 100 --model_name lenet --img_h 32 --img_w 32 '
 
-if method == 'perf':
-	base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name erm_match --match_case 1.0 --penalty_ws 1.0 --epochs 100 --model_name lenet --img_h 32 --img_w 32 '
+    elif method == 'erm':
+        base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name erm_match --match_case 0.0 --penalty_ws 0.0 --epochs 100 --model_name lenet --img_h 32 --img_w 32 '
 
-elif method == 'erm':
-	base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name erm_match --match_case 0.0 --penalty_ws 0.0 --epochs 100 --model_name lenet --img_h 32 --img_w 32 '
-    
-elif method == 'rand':
-	base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name erm_match --match_case 0.0 --penalty_ws 1.0 --epochs 100 --model_name lenet --img_h 32 --img_w 32 --total_matches_per_point 100 '
+    elif method == 'rand':
+        base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name erm_match --match_case 0.0 --penalty_ws 1.0 --epochs 100 --model_name lenet --img_h 32 --img_w 32 --total_matches_per_point 100 '
 
-elif method == 'matchdg_ctr':
-    base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name matchdg_ctr --match_case 0.0 --match_flag 1 --epochs 50 --batch_size 512 --pos_metric cos --model_name lenet --img_h 32 --img_w 32 --match_func_aug_case 1 '
-    
-elif method == 'matchdg_erm':
-    base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name matchdg_erm --match_case -1 --penalty_ws 1.0 --epochs 100 --ctr_match_case 0.0 --ctr_match_flag 1 --ctr_match_interrupt 5 --ctr_model_name lenet  --model_name lenet --img_h 32 --img_w 32 --total_matches_per_point 100 '
+    elif method == 'matchdg_ctr':
+        base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name matchdg_ctr --match_case 0.0 --match_flag 1 --epochs 50 --batch_size 512 --pos_metric cos --model_name lenet --img_h 32 --img_w 32 --match_func_aug_case 1 '
 
-for test_domain in domains:
-    
-    train_domains=''
-    for d in domains:
-        if d != test_domain:
-            train_domains+= str(d) + ' '
-    print(train_domains)
+    elif method == 'matchdg_erm':
+        base_script= 'python train.py --dataset rot_mnist --mnist_case lenet --method_name matchdg_erm --match_case -1 --penalty_ws 1.0 --epochs 100 --ctr_match_case 0.0 --ctr_match_flag 1 --ctr_match_interrupt 5 --ctr_model_name lenet  --model_name lenet --img_h 32 --img_w 32 --total_matches_per_point 100 '
 
-    res_dir= 'results/rmnist_lenet/'
-    if not os.path.exists(res_dir):
-        os.makedirs(res_dir)
-        
-    script= base_script + ' --train_domains ' + str(train_domains) + ' --test_domains ' + str(test_domain) 
-    script= script + ' > ' + res_dir + method + '_' + str(test_domain) + '.txt'
-    
-    print('Method: ', method, ' Test Domain: ', test_domain)
-    os.system(script)
\ No newline at end of file
+    for test_domain in domains:
+
+        train_domains=''
+        for d in domains:
+            if d != test_domain:
+                train_domains+= str(d) + ' '
+        print(train_domains)
+
+        res_dir= 'results/rmnist_lenet/'
+        if not os.path.exists(res_dir):
+            os.makedirs(res_dir)
+
+        script= base_script + ' --train_domains ' + str(train_domains) + ' --test_domains ' + str(test_domain) 
+        script= script + ' > ' + res_dir + method + '_' + str(test_domain) + '.txt'
+
+        print('Method: ', method, ' Test Domain: ', test_domain)
+        os.system(script)
\ No newline at end of file
diff --git a/reproduce_scripts/reproduce_slab.py b/reproduce_scripts/reproduce_slab.py
index 1bb8a0e..4a62271 100644
--- a/reproduce_scripts/reproduce_slab.py
+++ b/reproduce_scripts/reproduce_slab.py
@@ -2,13 +2,9 @@ import os
 import sys
 
 '''
-argv1: Allowed Values (train, test)
+argv1: Allowed Values (train, evaluate)
 '''
 
-## TODO
-# Choose a better name for train, test as in the test stage we do not really evalute the test accuracy 
-# Maybe make the train set accuracy also as part of the logs in the train.py phase (Check once if it changes any results from the main paper)
-
 case= sys.argv[1]
 methods=['erm', 'mmd', 'coral', 'dann', 'c-mmd', 'c-coral', 'c-dann', 'rand', 'perf']
 total_seed= 10
@@ -16,7 +12,7 @@ total_seed= 10
 if case == 'train':
     base_script= 'python train.py --dataset slab --model_name slab --batch_size 128 --lr 0.1 --epochs 100 --out_classes 2 --train_domains 0.0 0.10 --test_domains 1.0 --slab_data_dim 2 --slab_noise 0.1 ' + ' --n_runs ' + str(total_seed)
 
-elif case == 'test':
+elif case == 'evaluate':
     base_script= 'python test.py --test_metric per_domain_acc --acc_data_case train --dataset slab --model_name slab --batch_size 128 --lr 0.1 --epochs 100 --out_classes 2 --train_domains 0.0 0.10 --test_domains 1.0 --slab_data_dim 2 --slab_noise 0.1 ' + ' --n_runs ' + str(total_seed)
 
     
diff --git a/reproduce_scripts/slab-plot.py b/reproduce_scripts/slab-plot.py
index f8085ab..466b664 100644
--- a/reproduce_scripts/slab-plot.py
+++ b/reproduce_scripts/slab-plot.py
@@ -1,14 +1,15 @@
 import matplotlib
 import matplotlib.pyplot as plt
 import sys
+import os
+import numpy as np
 
 slab_noise= float(sys.argv[1])
-base_dir= 'slab_res/slab_noise_' + str(slab_noise) + '/'
-# methods=['erm', 'irm', 'csd', 'rand', 'matchdg', 'perf', 'mask_linear']
+base_dir= 'results/slab/slab_noise_' + str(slab_noise) + '/'
 methods=['erm', 'irm', 'csd', 'rand', 'perf', 'mask_linear']
 
 # x=['ERM', 'IRM', 'CSD', 'Rand', 'MatchDG', 'Perf', 'Mask']
-x=['ERM', 'IRM', 'CSD', 'Rand', 'Perf', 'Mask']
+x=['ERM', 'IRM', 'CSD', 'Rand', 'Perf', 'Oracle']
 matplotlib.rcParams.update({'errorbar.capsize': 2})
 fig, ax = plt.subplots(1, 2, figsize=(24, 8))
 fontsize=40
@@ -16,10 +17,12 @@ fontsize_lgd= fontsize/1.2
 marker_list = ['o', '^', '*']
 count= 0
 
-for test_domain in [0.3, 0.9]:
+for test_domain in [0.2, 0.9]:
         
     acc=[]
     acc_err=[]
+    train_acc =[]
+    train_acc_err =[]
     auc=[]
     auc_err=[]
     s_auc=[]
@@ -40,6 +43,11 @@ for test_domain in [0.3, 0.9]:
         sc_auc.append( float(data[-1].replace('\n', '').split(' ')[-2] ))
         sc_auc_err.append( float( data[-1].replace('\n', '').split(' ')[-1] ) )
 
+        f= open(base_dir + method + '-train-auc-' + str(test_domain) + '.txt')
+        data= f.readlines()
+        train_acc.append( float( data[-4].replace('\n', '').split(' ')[-2] ))
+        train_acc_err.append( float( data[-4].replace('\n', '').split(' ')[-1] ))
+        
         
     #Privacy Metrics
     mia=[]
@@ -81,6 +89,10 @@ for test_domain in [0.3, 0.9]:
     ax[count].errorbar(x, acc, yerr=acc_err, marker= marker_list[0], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='OOD Acc')
     ax[count].errorbar(x, s_auc, yerr=s_auc_err, marker= marker_list[1], markersize= fontsize_lgd, linewidth=4, fmt='o--', label='Linear-RAUC')
     ax[count].errorbar(x, loss, yerr=loss_err, marker= marker_list[2], markersize= fontsize_lgd, linewidth=4, label='Loss Attack', fmt='o--')
+    
+    gen_gap= np.array(train_acc) - np.array(acc)
+    ax[count].errorbar(x, gen_gap, yerr=0*gen_gap, marker= 's', markersize= fontsize_lgd, linewidth=4, fmt='o--', label='Gen Gap')
+    
     ax[count].set_ylabel('Metric Score', fontsize=fontsize)
     ax[count].set_title('Test Domain: ' + str(test_domain), fontsize=fontsize)
     
@@ -88,7 +100,11 @@ for test_domain in [0.3, 0.9]:
     
 lines, labels = fig.axes[-1].get_legend_handles_labels()    
 lgd= fig.legend(lines, labels, loc="lower center", bbox_to_anchor=(0.5, -0.15), fontsize=fontsize, ncol=3)
-    
-plt.tight_layout()
-plt.savefig('results/privacy_slab_' + str(slab_noise) + '.pdf', bbox_extra_artists=(lgd,), bbox_inches='tight',  dpi=600)
+
+save_dir= 'results/slab/plots/'
+if not os.path.exists(save_dir):
+    os.makedirs(save_dir)
+
+plt.tight_layout()
+plt.savefig( save_dir + 'privacy_slab_' + str(slab_noise) + '.pdf', bbox_extra_artists=(lgd,), bbox_inches='tight',  dpi=600)
 
diff --git a/reproduce_scripts/slab-run.py b/reproduce_scripts/slab-run.py
index 0053b35..b445ec7 100644
--- a/reproduce_scripts/slab-run.py
+++ b/reproduce_scripts/slab-run.py
@@ -1,21 +1,25 @@
 import os
 import sys
+import argparse
 
-'''
-argv1: Case (train, test)
+# Input Parsing
+parser = argparse.ArgumentParser()
+parser.add_argument('--case', type=str, default='train', 
+                    help='Case: train; test')
+parser.add_argument('--slab_noise', type=float, default=0.0, 
+                    help='Probability of corrupting slab features')
+parser.add_argument('--methods', nargs='+', type=str, default=['erm', 'irm', 'csd', 'rand', 'matchdg', 'perf', 'mask_linear'],
+                    help='List of methods')
 
-argv2: Noise in the slab feature (Flip probability)
-'''
+args = parser.parse_args()
 
-case= sys.argv[1]
-slab_noise= float(sys.argv[2])
+case= args.case
+slab_noise= args.slab_noise
+methods= args.methods
+
+metrics= ['train-auc', 'auc', 'loss']
 total_seed= 3
 
-methods=['erm', 'irm', 'csd', 'rand', 'perf', 'mask_linear']
-# methods=['matchdg']
-# metrics= ['auc', 'mi', 'entropy', 'loss']
-metrics= ['auc', 'loss']
-
 if case == 'train':
     
     base_script= 'python train.py --dataset slab --model_name slab --batch_size 128 --lr 0.1 --epochs 100 --out_classes 2 --train_domains 0.0 0.10 --test_domains 0.90 --slab_data_dim 2 '
@@ -40,6 +44,7 @@ if case == 'train':
             #CTR Phase
             script = base_script + ' --method_name matchdg_ctr --batch_size 512 --match_case 0.0 --match_flag 1 --match_interrupt 5 --pos_metric cos '
             os.system(script)
+            
             #ERM Phase
             script = base_script + ' --method_name matchdg_erm --match_case -1 --penalty_ws 1.0 --ctr_match_case 0.0 --ctr_match_flag 1 --ctr_match_interrupt 5 --ctr_model_name slab '            
             
@@ -51,7 +56,9 @@ elif case == 'test':
 
         if metric == 'auc':
             base_script= 'python test_slab.py --train_domains 0.0 0.10 '
-            
+
+        if metric == 'train-auc':
+            base_script= 'python test_slab.py --train_domains 0.0 0.10 --acc_data_case train '            
         elif metric == 'mi':
             base_script= 'python  test.py --test_metric mia --mia_logit 1 --mia_sample_size 400 --dataset slab --model_name slab --out_classes 2 --train_domains 0.0 0.10 '
         elif metric == 'entropy':
@@ -62,7 +69,7 @@ elif case == 'test':
             base_script= 'python  test.py --test_metric attribute_attack --mia_logit 1 --attribute_domain 0 --dataset slab --model_name slab --out_classes 2 --train_domains 0.0 0.10 '           
 
         base_script= base_script + ' --slab_noise ' + str(slab_noise) + ' --n_runs ' + str(total_seed)
-        res_dir= 'slab_res/slab_noise_' + str(slab_noise) + '/'
+        res_dir= 'results/slab/slab_noise_' + str(slab_noise) + '/'
 
         if not os.path.exists(res_dir):
             os.makedirs(res_dir)
@@ -85,36 +92,6 @@ elif case == 'test':
             elif method == 'matchdg':
                 upd_script = base_script + ' --method_name matchdg_erm --match_case -1 --penalty_ws 1.0 --ctr_match_case 0.0 --ctr_match_flag 1 --ctr_match_interrupt 5 --ctr_model_name slab '                
                 
-#             for test_domain in [0.05, 0.15, 0.3, 0.5, 0.7, 0.9]:
-            for test_domain in [0.3, 0.9]:
+            for test_domain in [0.2, 0.9]:
                 script= upd_script + ' --test_domains ' + str(test_domain) + ' > ' + res_dir + str(method) + '-' + str(metric) + '-' + str(test_domain) + '.txt'
                 os.system(script)
-
-                
-# elif case == 'train_plot':    
-
-#     for metric in metrics:
-
-#         if metric == 'auc':
-#             base_script= 'python logit_plot_slab.py --train_domains 0.0 0.10 '
-
-#         for method in methods:
-
-#             if method == 'erm':
-#                 upd_script= base_script + ' --method_name perf_match --penalty_ws 0.0 '
-#             elif method == 'irm':
-#                 upd_script= base_script + ' --method_name irm_slab --penalty_irm 10.0 --penalty_s 2 '
-#             elif method == 'csd':
-#                 upd_script= base_script + ' --method_name csd_slab --penalty_ws 0.0 --rep_dim 100 '
-#             elif method == 'rand':
-#                 upd_script= base_script + ' --method_name rand_match --penalty_ws 1.0  '
-#             elif method == 'perf':
-#                 upd_script= base_script + ' --method_name perf_match --penalty_ws 1.0 '        
-#             elif method == 'mask_linear':
-#                 upd_script= base_script + ' --method_name mask_linear --penalty_ws 0.0 '        
-
-
-#             for test_domain in [0.05, 0.15, 0.3, 0.5, 0.7, 0.9]:
-#                 script= upd_script + ' --test_domains ' + str(test_domain) + ' > slab_temp/' + str(method) + '-' + str(metric) + '-' + str(test_domain) + '.txt'
-#                 os.system(script)                
-
diff --git a/test.py b/test.py
index 7400f81..0c88a39 100644
--- a/test.py
+++ b/test.py
@@ -119,6 +119,9 @@ parser.add_argument('--dp_noise', type=int, default=0,
                     help='0: No DP noise; 1: Add DP noise')
 parser.add_argument('--dp_epsilon', type=float, default=1.0, 
                     help='Epsilon value for Differential Privacy')
+parser.add_argument('--dp_attach_opt', type=int, default=1, 
+                    help='0: Infinite Epsilon; 1: Finite Epsilion')
+
 
 
 #MMD, DANN
diff --git a/test_slab.py b/test_slab.py
index a34c4f9..093aa6b 100644
--- a/test_slab.py
+++ b/test_slab.py
@@ -276,7 +276,10 @@ for run in range(args.n_runs):
     model= test_method.phi
     
     test_method.get_metric_eval()
-    std_acc= test_method.metric_score['test accuracy']
+    if args.acc_data_case == 'train':        
+        std_acc= test_method.metric_score['train accuracy']
+    elif args.acc_data_case == 'test':
+        std_acc= test_method.metric_score['test accuracy']
     print('Test Accuracy: ', std_acc)
 
     spur_prob= float(test_domains[0])
diff --git a/train.py b/train.py
index 8186962..8172f2f 100644
--- a/train.py
+++ b/train.py
@@ -119,6 +119,9 @@ parser.add_argument('--dp_noise', type=int, default=0,
                     help='0: No DP noise; 1: Add DP noise')
 parser.add_argument('--dp_epsilon', type=float, default=1.0, 
                     help='Epsilon value for Differential Privacy')
+# Special case when you want to check results with the dp setting for the infinite epsilon case
+parser.add_argument('--dp_attach_opt', type=int, default=1, 
+                    help='0: Infinite Epsilon; 1: Finite Epsilion')
 
 
 #MMD, DANN
diff --git a/utils/__init__.py b/utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/utils/helper.py b/utils/helper.py
index c2b04b0..73f1334 100644
--- a/utils/helper.py
+++ b/utils/helper.py
@@ -286,18 +286,13 @@ def get_dataloader(args, run, domains, data_case, eval_case, kwargs):
         data_obj= ChestXRay(args, domains, '/chestxray_spur/', data_case=data_case, match_func=match_func)
         
     elif args.dataset_name in ['rot_mnist', 'fashion_mnist', 'rot_mnist_spur']:       
-        if data_case == 'test' and args.mnist_case not in ['lenet', 'lenet_mdg']:
+        if data_case == 'test' and args.mnist_case not in ['lenet']:
             #TODO: Infer this based on the total number of seed values for the mnist case
             # Actually by default the seeds 0, 1, 2 are for training and seed 9 is for test; mention that properly in comments
             mnist_subset= 9
         else:
             mnist_subset= run            
-        
-        #TODO: Only Temporary, in order to see if it changes results on MNIST
-#         if eval_case:
-#             if args.test_metric in ['mia', 'privacy_entropy', 'privacy_loss_attack']:
-#                 mnist_subset=run
-        
+                
         print('MNIST Subset: ', mnist_subset)
         data_obj=  MnistRotated(args, domains, mnist_subset, '/mnist/', data_case=data_case, match_func=match_func)
         
diff --git a/utils/match_function.py b/utils/match_function.py
index 4c9378f..79d99be 100644
--- a/utils/match_function.py
+++ b/utils/match_function.py
@@ -229,7 +229,9 @@ def get_matched_pairs(args, cuda, train_dataset, domain_size, total_domains, tra
                     if perfect_match == 1:
                         ## Find all instances among the curr_domain with same object as obj_base[idx]
                         ## .nonzero() converts True matche to match indexes; [0, 0] takes into the first match of same base object in the curr domain
-                        perfect_match_rank.append( (obj_curr[sort_idx] == obj_base[idx]).nonzero()[0,0].item() )                    
+                        
+                        if obj_base[idx] in obj_curr[sort_idx]:                        
+                            perfect_match_rank.append( (obj_curr[sort_idx] == obj_base[idx]).nonzero()[0,0].item() )                    
 #                 print('Time Taken in CTR Loop: ', time.time()-start_time)
 
             elif inferred_match == 0 and perfect_match == 1:
@@ -242,6 +244,7 @@ def get_matched_pairs(args, cuda, train_dataset, domain_size, total_domains, tra
                     
                     # Select random matches with perm_prob probability
                     if rand_vars[idx]:
+                        
                         rand_indices = np.arange(ordered_curr_indices.size()[0])
                         np.random.shuffle(rand_indices)           
                         curr_indices= ordered_curr_indices[rand_indices][:total_matches_per_point]
diff --git a/utils/scripts/__init__.py b/utils/scripts/__init__.py
new file mode 100644
index 0000000..e69de29