LOO-DualLOO-Group-Mislabel-Nonconvex-11.12-final-fmnist-Copy2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/myeongseob/anaconda3/envs/msPro-trex/lib/python3.8/site-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.23.5\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import copy\n",
    "import pickle\n",
    "import pandas as pd \n",
    "import time\n",
    "import os\n",
    "import random\n",
    "import argparse\n",
    "from scipy.stats import pearsonr\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "    \n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "from torchvision import datasets\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "from sklearn.datasets import fetch_openml\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler, LabelEncoder\n",
    "from sklearn.linear_model import LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_seed(seed):\n",
    "    # Set a seed for reproducibility\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    random.seed(seed) \n",
    "    # If you are using CUDA:\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "device = torch.device(\"cuda:4\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "def fetch_dataset(dataset_name, seed):\n",
    "    if dataset_name == 'cifar10':\n",
    "        dataset = fetch_openml('CIFAR_10', version=1)\n",
    "        dataset.data = dataset.data.astype(np.float32) / 255.0\n",
    "        train_size = 0.015 # 0.07\n",
    "    elif dataset_name == 'fmnist':\n",
    "        dataset = fetch_openml('Fashion-MNIST', version=1)\n",
    "        dataset.data = dataset.data.astype(np.float32) / 255.0\n",
    "        train_size = 0.015 # 0.07\n",
    "    else:  # Default to MNIST\n",
    "        dataset = fetch_openml('mnist_784', version=1)\n",
    "        dataset.data = dataset.data.astype(np.float32) / 255.0\n",
    "        train_size = 0.015 # 0.07\n",
    "    validation_size = 5000\n",
    "    return train_test_split(dataset.data, dataset.target, train_size=train_size, test_size=validation_size, random_state=seed)\n",
    "\n",
    "class CNNModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CNNModel, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 32, kernel_size=5)\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=5)\n",
    "        self.fc1 = nn.Linear(64*4*4, 128)\n",
    "        self.fc2 = nn.Linear(128, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = F.max_pool2d(x, 2)\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = F.max_pool2d(x, 2)\n",
    "        x = x.view(-1, 64*4*4)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "        return x\n",
    "    \n",
    "def train_model(args, train_img_np, train_lb_np):\n",
    "    train_dataset = TensorDataset(torch.tensor(train_img_np.reshape(-1, 1, 28, 28)), torch.tensor(train_lb_np).long())\n",
    "    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)\n",
    "\n",
    "    model = CNNModel().to(device) # whenever we train the model, we start from here\n",
    "    \n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, weight_decay=args.weight_decay, momentum=args.momentum)\n",
    "\n",
    "    model.train()\n",
    "    for epoch in range(args.epochs):\n",
    "        model.train()\n",
    "        running_loss = 0.0\n",
    "        for i, (inputs, labels) in enumerate(train_loader):\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, labels)    \n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            running_loss += loss.item()\n",
    "    return model    \n",
    "\n",
    "def finetune_train_model(args, train_img_np, train_lb_np, epochs):\n",
    "    train_dataset = TensorDataset(torch.tensor(train_img_np.reshape(-1, 1, 28, 28)), torch.tensor(train_lb_np).long())\n",
    "    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)\n",
    "\n",
    "    model = CNNModel().to(device) # whenever we train the model, we start from here\n",
    "    model_path = f'./saved_models/optimal_weight_mislabeled/{args.dataset}_{args.remove}'\n",
    "    model_filename = f'{model_path}/CNN_model_{args.seed}.pth'\n",
    "    model.load_state_dict(torch.load(model_filename))  \n",
    "    \n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, weight_decay=args.weight_decay, momentum=args.momentum)\n",
    "\n",
    "    model.train()\n",
    "    for epoch in range(epochs):\n",
    "        model.train()\n",
    "        running_loss = 0.0\n",
    "        for i, (inputs, labels) in enumerate(train_loader):\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(inputs)\n",
    "            loss = criterion(outputs, labels)    \n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            running_loss += loss.item()\n",
    "            \n",
    "    return model    \n",
    "\n",
    "def multiple_utility_fcn(args, x_train, y_train, x_test, y_test, indicator, idx, iter_, repeat, sampled_seeds):\n",
    "    loss_lst = []\n",
    "    \n",
    "    for seed_i in sampled_seeds:\n",
    "        loss = utility_fcn(args, x_train, y_train, x_test, y_test, indicator, idx, iter_, repeat, seed_i)\n",
    "        loss_lst.append(loss)\n",
    "        \n",
    "    return np.mean(np.array(loss_lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def utility_fcn(args, x_train, y_train, x_test, y_test, indicator, idx, iter_, repeat, seed):\n",
    "    indicator_origin = indicator\n",
    "    #--------------------------------------------------------------------------------------------# filename    \n",
    "    model_path = f'./saved_models/GroupIF/mislabeled/Grouptrain_Grouptest_02_10/{args.dataset}_{args.remove}'\n",
    "    if indicator == 'dual_loo_pre_': # [ DualLOO first term == LOO second term , also, it does not depend on the new test point ]\n",
    "        indicator = 'loo_total_'\n",
    "    model_filename = f'{model_path}/CNN_model_{indicator}_{seed}_{idx}_{iter_}.pth'\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    criterion_ind = nn.CrossEntropyLoss(reduction='none')    \n",
    "    \n",
    "    #--------------------------------------------------------------------------------------------# train, this time we need to save it over different seeds\n",
    "    if repeat == 0:\n",
    "        if indicator_origin == 'dual_loo_pre_': \n",
    "            model = CNNModel().to(device)\n",
    "            try:\n",
    "                model.load_state_dict(torch.load(model_filename))\n",
    "            except EOFError as e:\n",
    "                print(f\"Cannot load the model from {model_filename}. File may be corrupted or incomplete.\")\n",
    "        else: # train the model otherwise, [ with the new test point, DualLOO second term will be different, so no need to save it ]\n",
    "            model = train_model(args, x_train, y_train)\n",
    "            if indicator in ['loo_total_', 'loo_pre_']: # [ LOO terms do not depend on the new test point, so we need to save it ]\n",
    "                torch.save(model.state_dict(), model_filename)\n",
    "    #--------------------------------------------------------------------------------------------# val  \n",
    "    x_test_tensor = torch.tensor(x_test.reshape(-1, 1, 28, 28), dtype=torch.float32).to(device)\n",
    "    y_test_tensor = torch.tensor(y_test.reshape(-1), dtype=torch.long).to(device)  \n",
    "    model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "    with torch.no_grad():\n",
    "        output = model(x_test_tensor)\n",
    "        test_loss = criterion(output, y_test_tensor)\n",
    "    \n",
    "    return test_loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(batch_size=64, dataset='fmnist', epochs=10, lr=0.01, momentum=0.9, remove='removeone', seed=42, target_class=1, topk=30, weight_decay=0.001)\n"
     ]
    }
   ],
   "source": [
    "import argparse\n",
    "import sys\n",
    "\n",
    "# Define the arguments\n",
    "parser = argparse.ArgumentParser(description=\"Script to run logistic regression with different datasets.\")\n",
    "parser.add_argument('--dataset', type=str, default='fmnist', choices=['mnist', 'cifar10', 'fmnist'], help='Dataset to use; mnist, cifar10, or fmnist')\n",
    "parser.add_argument('--seed', type=int, default=42, help='Random seed for reproducibility')\n",
    "parser.add_argument('--batch_size', type=int, default=64, help='Batch size for training')\n",
    "parser.add_argument('--weight_decay', type=float, default=0.001, help='Weight decay for regularization')\n",
    "parser.add_argument('--lr', type=float, default=0.01, help='Learning rate for optimizer')\n",
    "parser.add_argument('--momentum', type=float, default=0.9, help='Momentum for optimizer')\n",
    "parser.add_argument('--epochs', type=int, default=10, help='Number of epochs for training')    \n",
    "parser.add_argument('--topk', type=int, default=30, help='Number of top-k groups to form')  \n",
    "parser.add_argument('--target_class', type=int, default=1, help='Target class')\n",
    "parser.add_argument('--remove', type=str, default='addone', choices=['addone', 'removeone'], help='Method to remove data points')\n",
    "\n",
    "# Simulate command line arguments in Jupyter\n",
    "# Clear any previous arguments first\n",
    "sys.argv = ['']\n",
    "# Now add your arguments; these are just examples\n",
    "sys.argv.append('--dataset')\n",
    "sys.argv.append('fmnist')\n",
    "sys.argv.append('--seed')\n",
    "sys.argv.append('42')\n",
    "sys.argv.append('--batch_size')\n",
    "sys.argv.append('64')\n",
    "sys.argv.append('--weight_decay')\n",
    "sys.argv.append('0.001')\n",
    "sys.argv.append('--lr')\n",
    "sys.argv.append('0.01')\n",
    "sys.argv.append('--momentum')\n",
    "sys.argv.append('0.9')\n",
    "sys.argv.append('--epoch')\n",
    "sys.argv.append('10')\n",
    "sys.argv.append('--topk')\n",
    "sys.argv.append('30')\n",
    "sys.argv.append('--remove')\n",
    "sys.argv.append('removeone')\n",
    "sys.argv.append('--target_class')\n",
    "sys.argv.append('1')\n",
    "\n",
    "# Parse the arguments\n",
    "args = parser.parse_args()\n",
    "print(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[57, 12, 140, 125, 114]\n"
     ]
    }
   ],
   "source": [
    "set_seed(args.seed)\n",
    "#-------------------------------------------------# Preparation \n",
    "# Define the range for 32-bit integers\n",
    "MIN_SEED = 0\n",
    "MAX_SEED = 2**8 - 1\n",
    "\n",
    "# Sample 15 seeds\n",
    "sampled_seeds = random.sample(range(MIN_SEED, MAX_SEED + 1), 5)\n",
    "print(sampled_seeds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/myeongseob/anaconda3/envs/msPro-trex/lib/python3.8/site-packages/sklearn/datasets/_openml.py:968: FutureWarning: The default value of `parser` will change from `'liac-arff'` to `'auto'` in 1.4. You can set `parser='auto'` to silence this warning. Therefore, an `ImportError` will be raised from 1.4 if the dataset is dense and pandas is not installed. Note that the pandas parser may return different data types. See the Notes Section in fetch_openml's API doc for details.\n",
      "  warn(\n",
      "/tmp/ipykernel_44068/1071582773.py:7: DeprecationWarning: `np.long` is a deprecated alias for `np.compat.long`. To silence this warning, use `np.compat.long` by itself. In the likely event your code does not need to work on Python 2 you can use the builtin `int` for which `np.compat.long` is itself an alias. Doing this will not modify any behaviour and is safe. When replacing `np.long`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  train_lb_np = train_labels.to_numpy().astype(np.long)\n",
      "/tmp/ipykernel_44068/1071582773.py:8: DeprecationWarning: `np.long` is a deprecated alias for `np.compat.long`. To silence this warning, use `np.compat.long` by itself. In the likely event your code does not need to work on Python 2 you can use the builtin `int` for which `np.compat.long` is itself an alias. Doing this will not modify any behaviour and is safe. When replacing `np.long`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  test_lb_np = validation_labels.to_numpy().astype(np.long)\n"
     ]
    }
   ],
   "source": [
    "#-------------------------------------------------#\n",
    "train_images, validation_images, train_labels, validation_labels = fetch_dataset(args.dataset, args.seed)\n",
    "\n",
    "# Convert pandas dataframes to numpy arrays\n",
    "train_img_np = train_images.to_numpy().astype(np.float32)\n",
    "test_img_np = validation_images.to_numpy().astype(np.float32)\n",
    "train_lb_np = train_labels.to_numpy().astype(np.long)\n",
    "test_lb_np = validation_labels.to_numpy().astype(np.long)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "criterion_ind = nn.CrossEntropyLoss(reduction='none')   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_balanced_test_set(test_img_np, test_lb_np, num_samples_per_class):\n",
    "    unique_classes = np.unique(test_lb_np)\n",
    "    balanced_indices = []\n",
    "\n",
    "    for cls in unique_classes:\n",
    "        indices_of_class = np.where(test_lb_np == cls)[0]\n",
    "        sampled_indices = np.random.choice(indices_of_class, num_samples_per_class, replace=False)\n",
    "        balanced_indices.extend(sampled_indices)\n",
    "\n",
    "    balanced_test_img_np = test_img_np[balanced_indices]\n",
    "    balanced_test_lb_np = test_lb_np[balanced_indices]\n",
    "\n",
    "    return balanced_test_img_np, balanced_test_lb_np, balanced_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.03448276, 0.06896552, 0.10344828, 0.13793103,\n",
       "       0.17241379, 0.20689655, 0.24137931, 0.27586207, 0.31034483,\n",
       "       0.34482759, 0.37931034, 0.4137931 , 0.44827586, 0.48275862,\n",
       "       0.51724138, 0.55172414, 0.5862069 , 0.62068966, 0.65517241,\n",
       "       0.68965517, 0.72413793, 0.75862069, 0.79310345, 0.82758621,\n",
       "       0.86206897, 0.89655172, 0.93103448, 0.96551724, 1.        ])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratios = np.linspace(0, 1, args.topk)\n",
    "ratios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LOO vs DualLOO | One test group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LOO vs Dual\n",
    "repeat = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine the number of samples for clean and mislabeled data\n",
    "num_clean = int(0.5 * len(train_img_np))\n",
    "num_mislabel = len(train_img_np) - num_clean\n",
    "\n",
    "# Create an array of indices and shuffle it\n",
    "indices = np.arange(len(train_img_np))\n",
    "np.random.shuffle(indices)\n",
    "\n",
    "# Split the indices for the clean and mislabeled data\n",
    "clean_indices = indices[:num_clean]\n",
    "mislabel_indices = indices[num_clean:]\n",
    "\n",
    "# Use the indices to create the clean and mislabeled datasets\n",
    "clean_img_np = train_img_np[clean_indices]\n",
    "clean_lb_np = train_lb_np[clean_indices]\n",
    "mislabel_img_np = train_img_np[mislabel_indices]\n",
    "mislabel_lb_np = train_lb_np[mislabel_indices]\n",
    "###################################################### 50% mis. 50% clean \n",
    "\n",
    "unique_labels = np.unique(train_lb_np)  # Get unique labels from the dataset\n",
    "for i in range(len(mislabel_lb_np)):\n",
    "    original_label = mislabel_lb_np[i]\n",
    "    # Choose a new label different from the original\n",
    "    possible_labels = [l for l in unique_labels if l != original_label]\n",
    "    mislabel_lb_np[i] = np.random.choice(possible_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "group_size = len(mislabel_img_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# new dataset D with mislabel and clean label\n",
    "train_img_D = np.concatenate([clean_img_np, mislabel_img_np]) # 0-525, 525-1050 \n",
    "train_lb_D = np.concatenate([clean_lb_np, mislabel_lb_np])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "clean_indices_new = np.arange(len(clean_img_np))\n",
    "mislabel_indices_new = np.arange(len(clean_img_np), len(train_img_D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n"
     ]
    }
   ],
   "source": [
    "# Use this function to create a balanced test set\n",
    "num_samples_per_class = 50 # Adjust this number based on your requirement\n",
    "test_img_V, test_lb_V, balanced_indices = create_balanced_test_set(test_img_np, test_lb_np, num_samples_per_class)\n",
    "num_test = len(test_img_V)\n",
    "print(num_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " current idx is 0 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current portion of mislabeled data samples is 0.0 \n",
      " current idx is 5 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current portion of mislabeled data samples is 0.1724137931034483 \n",
      " current idx is 10 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current portion of mislabeled data samples is 0.3448275862068966 \n",
      " current idx is 15 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current portion of mislabeled data samples is 0.5172413793103449 \n",
      " current idx is 20 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current portion of mislabeled data samples is 0.6896551724137931 \n",
      " current idx is 25 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current portion of mislabeled data samples is 0.8620689655172413 \n",
      " time elapsed : 55.160136699676514\n"
     ]
    }
   ],
   "source": [
    "### LOO\n",
    "loo_score = []\n",
    "pre_loss_lst = []\n",
    "total_loss_lst = []           \n",
    "combined_indices_lst = []\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "# L(A(D) on V) \n",
    "total_loss = multiple_utility_fcn(args, train_img_D, train_lb_D, test_img_V, test_lb_V, 'loo_total_', len(train_img_D), 333, repeat, sampled_seeds)       \n",
    "all_indices = np.arange(len(train_img_D)) ## based on new dataset \n",
    "\n",
    "for i, ratio in enumerate(ratios):\n",
    "    num_mislabel_samples = int(group_size * ratio)\n",
    "    num_clean_samples = group_size - num_mislabel_samples\n",
    "\n",
    "    # Draw samples from clean and mislabel sets G\n",
    "    sampled_clean_indices = np.random.choice(clean_indices_new, num_clean_samples, replace=False)\n",
    "    sampled_mislabel_indices = np.random.choice(mislabel_indices_new, num_mislabel_samples, replace=False)\n",
    "\n",
    "    # These are the actual indices in the original dataset D\n",
    "    combined_indices = np.concatenate([sampled_clean_indices, sampled_mislabel_indices]) # G\n",
    "    exclude_indices = np.setdiff1d(all_indices, combined_indices, assume_unique=True) # D-G \n",
    "    combined_indices_lst.append(combined_indices)\n",
    "\n",
    "    ## Step 3: L(A(D / G) on V) \n",
    "    train_img_np_excluded = train_img_D[exclude_indices]\n",
    "    train_lb_np_excluded = train_lb_D[exclude_indices]\n",
    "\n",
    "    ## Step 4:  \n",
    "    pre_loss = multiple_utility_fcn(args, train_img_np_excluded, train_lb_np_excluded, test_img_V, test_lb_V, 'loo_pre_', len(train_img_np_excluded), i, repeat, sampled_seeds)    \n",
    "\n",
    "    loo_score.append(total_loss-pre_loss) ## D+G - D [ if G is mislabeled, D will be higher]  \n",
    "    total_loss_lst.append(total_loss)\n",
    "    pre_loss_lst.append(pre_loss)\n",
    "\n",
    "    if i%5 == 0:\n",
    "        print(f\" current idx is {i} \")\n",
    "        print(f\" current shape of test set is {test_img_V.shape}, the length of the group is {group_size} \")\n",
    "        print(f\" current portion of mislabeled data samples is {ratio} \")\n",
    "\n",
    "print(f\" time elapsed : {time.time() - start_time}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_ = f'./saved_models/GroupIF/mislabeled/Grouptrain_Grouptest_02_10/{args.dataset}_{args.remove}'\n",
    "path_filename = f'{path_}/combined_indices_lst.npy'\n",
    "np.save(path_filename,combined_indices_lst )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " current idx is 0 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current idx is 5 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current idx is 10 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current idx is 15 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current idx is 20 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " current idx is 25 \n",
      " current shape of test set is (500, 784), the length of the group is 525 \n",
      " time elapsed : 129.21440839767456\n"
     ]
    }
   ],
   "source": [
    "###################################################\n",
    "### Dual LOO\n",
    "dual_loo_score = []\n",
    "pre_train_loss_lst = []\n",
    "total_train_loss_lst = []            \n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "for i in range(len(combined_indices_lst)): ## Iterate over different group sizes\n",
    "    combined_indices = combined_indices_lst[i] # G\n",
    "    \n",
    "    ## Step 1: eval n G\n",
    "    test_img_np_G = train_img_D[combined_indices]\n",
    "    test_lb_np_G = train_lb_D[combined_indices]\n",
    "    \n",
    "    ## Step 2: L(A((D + V) on G) \n",
    "    train_img_np_V = np.concatenate([train_img_D, test_img_V])\n",
    "    train_lb_np_V = np.concatenate([train_lb_D, test_lb_V])\n",
    "\n",
    "    ## Step 4:  \n",
    "    total_train_loss = multiple_utility_fcn(args, train_img_np_V, train_lb_np_V, test_img_np_G, test_lb_np_G, 'dual_loo_total_', len(train_img_np_V), i, repeat, sampled_seeds)    \n",
    "    pre_train_loss = multiple_utility_fcn(args, train_img_D, train_lb_D, test_img_np_G, test_lb_np_G, 'dual_loo_pre_', len(train_img_D), 333, repeat, sampled_seeds)\n",
    "\n",
    "    dual_loo_score.append(total_train_loss-pre_train_loss) ## D U V - D   \n",
    "    total_train_loss_lst.append(total_train_loss)            \n",
    "    pre_train_loss_lst.append(pre_train_loss)            \n",
    "\n",
    "    if i%5 == 0:\n",
    "        print(f\" current idx is {i} \")\n",
    "        print(f\" current shape of test set is {test_img_V.shape}, the length of the group is {group_size} \")\n",
    "        \n",
    "print(f\" time elapsed : {time.time() - start_time}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.03448276, 0.06896552, 0.10344828, 0.13793103,\n",
       "       0.17241379, 0.20689655, 0.24137931, 0.27586207, 0.31034483,\n",
       "       0.34482759, 0.37931034, 0.4137931 , 0.44827586, 0.48275862,\n",
       "       0.51724138, 0.55172414, 0.5862069 , 0.62068966, 0.65517241,\n",
       "       0.68965517, 0.72413793, 0.75862069, 0.79310345, 0.82758621,\n",
       "       0.86206897, 0.89655172, 0.93103448, 0.96551724, 1.        ])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.array(ratios), np.array(pre_train_loss_lst), label='dual_pre')\n",
    "plt.plot(np.array(ratios), np.array(total_train_loss_lst), label='dual_total')\n",
    "plt.xlabel(\"mislabeled ratio\")\n",
    "plt.ylabel(\"loss\")\n",
    "plt.legend()  # This will display the legend\n",
    "plt.show()  # This will show the plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.array(ratios), np.array(pre_loss_lst), label='loo_pre')\n",
    "plt.plot(np.array(ratios), np.array(total_loss_lst), label='loo_total')\n",
    "plt.xlabel(\"mislabeled ratio\")\n",
    "plt.ylabel(\"loss\")\n",
    "plt.legend()  # This will display the legend\n",
    "plt.show()  # This will show the plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "from scipy.stats import pearsonr\n",
    "\n",
    "mpl.rcParams.update({'font.size': 40, 'font.weight': 'bold'})\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "# Plotting\n",
    "plt.figure(figsize=(20, 10))\n",
    "\n",
    "# First subplot\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(np.array(ratios), np.array(pre_train_loss_lst), \n",
    "         label=r'$\\mathrm{L}(\\mathrm{A}(D_{\\mathrm{trn}}),D_i)$', linewidth=3)\n",
    "plt.plot(np.array(ratios), np.array(total_train_loss_lst), \n",
    "         label=r'$\\mathrm{L}(\\mathrm{A}(D_{\\mathrm{trn}} \\cup D_{\\mathrm{tst}}),D_i)$', linewidth=3)\n",
    "plt.xlabel('Mislabeled Ratio in ' + r'$D_{i}$', fontsize=40, fontweight='bold')\n",
    "plt.ylabel('Loss of ' + r'$D_{i}$', fontsize=40, fontweight='bold')\n",
    "plt.xticks(fontsize=40)\n",
    "plt.yticks(fontsize=40)\n",
    "plt.grid(True, which='both', axis='both', color='grey', linestyle='-.', linewidth=1.0)\n",
    "plt.legend(prop={'size': 35})\n",
    "\n",
    "# Second subplot\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(np.array(ratios), np.array(pre_loss_lst), \n",
    "         label=r'$\\mathrm{L}(\\mathrm{A}(D_{\\mathrm{trn}} - D_i),D_{\\mathrm{tst}})$', linewidth=3)\n",
    "plt.plot(np.array(ratios), np.array(total_loss_lst), \n",
    "         label=r'$\\mathrm{L}(\\mathrm{A}(D_{\\mathrm{trn}}),D_{\\mathrm{tst}})$', linewidth=3)\n",
    "plt.xlabel('Mislabeled Ratio in ' + r'$D_{i}$', fontsize=40, fontweight='bold')\n",
    "plt.ylabel('Loss of ' + r'$D_{tst}$', fontsize=40, fontweight='bold')\n",
    "plt.xticks(fontsize=40)\n",
    "plt.yticks(fontsize=40)\n",
    "plt.grid(True, which='both', axis='both', color='grey', linestyle='-.', linewidth=1.0)\n",
    "plt.legend(prop={'size': 35})\n",
    "\n",
    "\n",
    "# Display the combined plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation Coefficient: 0.9752282810833116\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "### Loo scores vs LOO scores\n",
    "array1 = np.array(dual_loo_score)\n",
    "array2 = np.array(loo_score)\n",
    "\n",
    "# Calculate the correlation coefficient\n",
    "correlation_coefficient, p = pearsonr(array1, array2)\n",
    "\n",
    "print(\"Correlation Coefficient:\", correlation_coefficient)\n",
    "\n",
    "# Set the figure size\n",
    "plt.figure(figsize=(12, 6))\n",
    "plt.scatter(array1, array2, c='0.6', marker='o', label='values')\n",
    "\n",
    "# Iterate over the points and annotate each point with its group size\n",
    "for i, txt in enumerate(ratios):\n",
    "    plt.annotate(txt, (array1[i], array2[i]))\n",
    "\n",
    "# Add labels and titles\n",
    "plt.xlabel('Dual LOO')\n",
    "plt.ylabel('LOO')\n",
    "plt.title('LOO vs Dual LOO')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spearman Rank Correlation Coefficient: 0.9915461624026695\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import spearmanr\n",
    "spearman_corr, _ = spearmanr(array1, array2)\n",
    "print(\"Spearman Rank Correlation Coefficient:\", spearman_corr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearson Correlation Coefficient: 0.9752\n",
      "Spearman Correlation Coefficient: 0.9915\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "from scipy.stats import pearsonr, spearmanr\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "\n",
    "# Setting a larger default font size\n",
    "mpl.rcParams.update({'font.size': 40, 'font.weight': 'bold'})\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "# Initialize arrays from loo_score and dual_loo_score\n",
    "array1 = np.array(loo_score)\n",
    "array2 = np.array(dual_loo_score)\n",
    "\n",
    "# Calculate correlation coefficients\n",
    "pearson_corr, _ = pearsonr(array1, array2)\n",
    "spearman_corr, _ = spearmanr(array1, array2)\n",
    "\n",
    "# Print the correlation coefficients\n",
    "print(f\"Pearson Correlation Coefficient: {pearson_corr:.4f}\")\n",
    "print(f\"Spearman Correlation Coefficient: {spearman_corr:.4f}\")\n",
    "\n",
    "# Scatter plot setup\n",
    "plt.figure(figsize=(10, 6))\n",
    "ax = plt.gca()\n",
    "ax.set_facecolor('none')\n",
    "\n",
    "# Spine and grid setup\n",
    "for spine in ax.spines.values():\n",
    "    spine.set_visible(True)\n",
    "    spine.set_color('black')\n",
    "    spine.set_linewidth(1.5)\n",
    "ax.grid(True, which='both', axis='both', color='grey', linestyle='-.', linewidth=1.0)\n",
    "\n",
    "# Scatter plot\n",
    "plt.scatter(array1, array2, c='maroon', marker='o', s=150)\n",
    "\n",
    "# Axis labels\n",
    "plt.xlabel(r'Inf($D_i \\rightarrow D_{tst}$)', fontsize=40, fontweight='bold')\n",
    "plt.ylabel(r'Inf($D_i \\leftarrow D_{tst}$)', fontsize=40, fontweight='bold')\n",
    "\n",
    "ax.xaxis.set_major_formatter(FormatStrFormatter('%.2f'))\n",
    "ax.yaxis.set_major_formatter(FormatStrFormatter('%.2f'))\n",
    "\n",
    "# Display correlation coefficients in a box\n",
    "info_text = f'Pearson: {pearson_corr:.4f}\\nSpearman: {spearman_corr:.4f}'\n",
    "plt.text(0.05, 0.95, info_text, transform=ax.transAxes, fontsize=30,\n",
    "         verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))\n",
    "\n",
    "# Adjusting tick label size\n",
    "plt.xticks(fontsize=20)\n",
    "plt.yticks(fontsize=20)\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:msPro-trex]",
   "language": "python",
   "name": "conda-env-msPro-trex-py"
  },
  "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}