LOO-DualLOO-Group-Mislabel-Nonconvex-11.12-final-mnist-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 a\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:3\" 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",
    "            \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",
    "\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='mnist', 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='mnist', 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('mnist')\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_44057/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_44057/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": [
    "# 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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x_test_tensor = torch.tensor(test_img_np.reshape(-1, 1, 28, 28), dtype=torch.float32).to(device)\n",
    "# y_test_tensor = torch.tensor(test_lb_np.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",
    "# test_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from torch.utils.data import TensorDataset, DataLoader\n",
    "# # Create a TensorDataset for test data\n",
    "# test_dataset = TensorDataset(x_test_tensor, y_test_tensor)\n",
    "\n",
    "# # Create a DataLoader for test data\n",
    "# test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# correct = 0\n",
    "# total = 0\n",
    "\n",
    "# with torch.no_grad():\n",
    "#     for inputs, labels in test_loader:  # Assuming test_loader is defined similar to train_loader\n",
    "#         inputs, labels = inputs.to(device), labels.to(device)\n",
    "#         outputs = model(inputs)\n",
    "#         _, predicted = torch.max(outputs.data, 1)\n",
    "#         total += labels.size(0)\n",
    "#         correct += (predicted == labels).sum().item()\n",
    "\n",
    "# test_accuracy = 100 * correct / total\n",
    "# print(f'Accuracy of the model on the test images: {test_accuracy}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "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": 12,
     "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": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LOO vs Dual\n",
    "repeat = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine the number of samples for clean and mislabeled data\n",
    "num_clean = int(0.7 * 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": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "315"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mislabel_img_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "group_size = len(mislabel_img_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9 1 9 7 5]\n"
     ]
    }
   ],
   "source": [
    "print(train_lb_D[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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": 20,
   "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": 21,
   "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 315 \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 315 \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 315 \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 315 \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 315 \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 315 \n",
      " current portion of mislabeled data samples is 0.8620689655172413 \n",
      " time elapsed : 71.04174280166626\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": 22,
   "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": 23,
   "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 315 \n",
      " current idx is 5 \n",
      " current shape of test set is (500, 784), the length of the group is 315 \n",
      " current idx is 10 \n",
      " current shape of test set is (500, 784), the length of the group is 315 \n",
      " current idx is 15 \n",
      " current shape of test set is (500, 784), the length of the group is 315 \n",
      " current idx is 20 \n",
      " current shape of test set is (500, 784), the length of the group is 315 \n",
      " current idx is 25 \n",
      " current shape of test set is (500, 784), the length of the group is 315 \n",
      " time elapsed : 131.53228449821472\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": 24,
   "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": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAsjklEQVR4nO3dd3xUVfrH8c+TTgqBJCSURBIg9E5oAgKCCqyCLE1UBLvY27rgKmvdtYErCCr+KDYEFVQQbKAs0gkSCDV0CC0QJCGBEJKc3x8zuhGSMEAmd8rzfr3yIjP3zJ3nBMh37j33niPGGJRSSnkvH6sLUEopZS0NAqWU8nIaBEop5eU0CJRSystpECillJfzs7qAixUVFWXi4+OtLkMppdzK2rVrjxljqpW0ze2CID4+nuTkZKvLUEoptyIie0vbpqeGlFLKy2kQKKWUl9MgUEopL+d2YwRKKe9w9uxZ0tPTycvLs7oUtxIUFERsbCz+/v4Ov0aDQCnlktLT0wkLCyM+Ph4Rsboct2CMITMzk/T0dBISEhx+nZ4aUkq5pLy8PCIjIzUELoKIEBkZedFHURoESimXpSFw8S7lZ+Y1QZBxMo+XvtlMxkk936iUUsV5TRCs3HWcacv3cNVrP/Py/M0cyzljdUlKKeUSvCYI+raoyaLHu9KnWQ2mLN1Nl1d/5t/fbuF4br7VpSmlXFRoaKjVJVQIrwkCgPioEMYNbsmPj3fluiYxTF6yi86v/sRr323lNw0EpZQLKCwsrPD39MrLR+tWC+U/N7Xiwavr8daiHbzz3518uGIvt3eK567OdQgPdvz6W6WU8z0/bxObD2aX6z4b16zMP29o4lBbYwxPPfUU3377LSLCM888w5AhQ0p9viSLFy9mzJgxhIWFsWPHDrp3786kSZPw8fEhNDSUe++9l4ULFzJx4kT27NnD+PHjyc/Pp3379kyaNAlfX9/y7P6feNURwbnqRYcxYWgrvn/0KrrWr8aEn3bQ+dWfGPdjGtl5Z60uTynlIubMmUNKSgrr169n4cKF/O1vf+PQoUOlPl+a1atXM2HCBDZv3szOnTuZM2cOALm5ubRv357169cTGRnJrFmzWLZsGSkpKfj6+vLJJ584tX9eeURwrvoxYUy8pTUPHc7mrYXbGb9oO/M3HGTG3R2IqRxkdXlKeT1HP7k7y9KlSxk6dCi+vr7ExMTQtWtX1qxZU+rzffv2LXE/7dq1o06dOgAMHTqUpUuXMnDgQHx9fRkwYAAAixYtYu3atbRt2xaA06dPEx0d7dT+aRAU07B6Zd65tQ0rdmZy1wdrGPLeCmbc3YGaVSpZXZpSygOce43/74+DgoL+OPVjjGH48OH8+9//rrC6vPrUUGk61o3kwzvbk5mTz+D3VrD/+CmrS1JKWahLly7MmjWLwsJCjh49ypIlS2jXrl2pz5dm9erV7N69m6KiImbNmkXnzp3Pa9OjRw+++OILMjIyADh+/Dh795a6lEC50CAoRZvaVfnk7vaczCtgyHsr2HMs1+qSlFIW6d+/P82bN6dFixZcffXVvPbaa1SvXr3U50vTtm1bHnzwQRo1akRCQgL9+/c/r03jxo156aWXuPbaa2nevDnXXHNNmeMO5UGMMU59g/KWlJRkKnKFsk0Hsxg2ZTV+PsKMuztQL9o7ritWympbtmyhUaNGVpdRbhYvXswbb7zBN9984/T3KulnJyJrjTFJJbXXI4ILaFIznE/v7kCRgZsmr2Db4ZNWl6SUUuVKB4sd0KB6GDPv6cDN76/kpskr+Piu9jSpGW51WUopF5SamsqwYcP+9FxgYCCrVq2iW7du1hR1ARoEDqoXHcpn93bk5vdXcvP7q/joznY0j61idVlKKRfTrFkzUlJSrC7jouipoYsQHxXCrHs7Ehbkxy3vr2Lt3t+sLkkppS6bBsFFiosI5rN7OxIZGsBtU1axalem1SUppdRlcVoQiMhUEckQkY2lbL9FRDaISKqILBeRFs6qpbzVrFKJWfd2pHp4ECOmrSHtiA4gK6XclzOPCKYDvcrYvhvoaoxpBrwITHZiLeUupnIQn97dgUoBvjzx2XrOFhZZXZJSSl0SpwWBMWYJcLyM7cuNMb+fZF8JxDqrFmeJrhzEv/o3JfVAFpN+3ml1OUqpclae6xHs2bOHGTNmXLBdSkoKCxYsuGC7xYsXc/3115dHaS4zRnAn8G1pG0XkHhFJFpHko0ePVmBZF9araQ1ubFmTCT9tZ+OBLKvLUUq5qPIOgvJk+eWjItIdWxCcP+mGnTFmMvZTR0lJSS53K/TzfZuyYlcmj3+WwtwHOxPk77x5w5XySt+OgsOp5bvP6s2g9ysONS2P9QhGjRrFli1baNmyJcOHD2fkyJGMHDmS5ORk/Pz8GDduHJ06dWLMmDGcPn2apUuXMnr0aBISEnjkkUfIy8ujUqVKTJs2jQYNGpTnT8LaIBCR5sD/Ab2NMW57+U14sD+vDmjOiGlreHNhGqN7e85t8UqpP69HcOzYMdq2bctVV13F8uXLS3y+Ro0a5+3jlVde+dMUE2PHjkVESE1NZevWrVx77bWkpaXxwgsvkJyczNtvvw1AdnY2v/zyC35+fixcuJCnn36a2bNnl2v/LAsCEbkCmAMMM8akWVVHeenWIJqh7a5g8pJdXNs4hja1I6wuSSnP4eAnd2cpr/UIzt3nQw89BEDDhg2pXbs2aWnn/yrMyspi+PDhbN++HRHh7NnyXzTLmZePfgqsABqISLqI3Cki94nIffYmY4BIYJKIpIhIxc0k5yT/+EsjalWpxBOfredUfoHV5SilPMCzzz5L9+7d2bhxI/PmzSMvL6/c38OZVw0NNcbUMMb4G2NijTFTjDHvGmPetW+/yxhT1RjT0v5V4qx47iQ00I83BrVgT+YpXv12q9XlKKXKSXmsRxAWFsbJkyf/tM/fl6BMS0tj3759NGjQ4Lx2WVlZ1KpVC4Dp06c7pX+uctWQx+hQJ5I7OiXwwYq9LNtxzOpylFLloDzWI2jevDm+vr60aNGCN998k/vvv5+ioiKaNWvGkCFDmD59OoGBgXTv3p3NmzfTsmVLZs2axVNPPcXo0aNp1aoVBQXOOdOg6xE4Qd7ZQvqM/4W8/EK+e+wqKgf5W12SUm7H09YjqEi6HoELCPL3ZeygFhzOzuPFeZutLkcppcpk+X0EnqrVFVUZ2a0uE3/eyXVNqtOzcYzVJSmlKkBZ6xG4Kg0CJ3qkR30Wbclg1JxUfqxdlaohAVaXpJRbMcYgIlaXcVGsXo/gUk7366khJwrw82Hc4JZknc7n2a9LnIRVKVWKoKAgMjMzL+kXm7cyxpCZmUlQUNBFvU6PCJyscc3KPNqzPq9/v42qwRupWy2EyNBAIkMDiAyx/Vk1OABfH/f61KOUs8XGxpKeno6rzS/m6oKCgoiNvbg5PDUIKsC9V9Vh7d7f+GTVXopK+HAjAhHBAUSGBhAREkC96FBG925ESKD+9Sjv5e/vT0JCgtVleAX9TVMB/Hx9mDqiLYVFhhOn8snMzSczJ5/M3DO2P3POcCw3n+M5+RzLOcMnq/ZhDLzcv5nVpSulvIAGQQXy9RH7aaFAKOMiopfnb+b9X3ZzTeMYujWIrrgClVJeSQeLXdAT1zYgMTqUv8/eQNap8p9gSimlitMgcEFB/r68OaQlmTn5jJmrVxsppZxLg8BFNa0VzkNXJ/J1ykHmbzhkdTlKKQ+mQeDC7u9elxax4TzzVSoZJ8t/6lmllAINApfm7+vD2MEtOZVfyOjZqXpjjVLKKTQIXFy96FD+3qshi7Zm8FnyfqvLUUp5IA0CNzDiyng61onkhXmb2X/8lNXlKKU8jAaBG/DxEV4f1BwR4cnP11NU0u3JSil1iTQI3ERs1WDG3NCYVbuPM3XZbqvLUUp5EA0CNzKoTSw9G0Xz2vfb2JFx8sIvUEopB2gQuBER4d9/bU5ooB+Pf7aes4VFVpeklPIAGgRuplpYIC/f2JQN6VlM+nmn1eUopTyABoEb6t2sBv1b1WLCT9tZv/+E1eUopdycBoGbeq5vE6qFBTL0/ZV8unqf3mymlLpkGgRuKrySP7NHXkmrK6owek4qd0xfQ0a2TkOhlLp4GgRurGaVSnx0R3ueu6Exy3dmcu1/lugEdUqpi6ZB4OZ8fIQRnRKY/3AXakcE88CMX3l05jpdx0Ap5TANAg9RLzqU2SOv5LGe9Zm34RDX/WcJv2zXRb+VUhemQeBB/Hx9eKRnIl/efyUhgb4Mm7KaMV9v5HR+odWlKaVcmAaBB2oeW4X5D3fhjk4JfLhiL38Z/wvr9v1mdVlKKRelQeChgvx9GXNDY2bc3Z4zBUUMencFGw9kWV2WUsoFaRB4uCvrRvHNQ52pEhzAM19t1JlLlVLn0SDwAlVDAni6T0NS9p9gVjktbnMqv4D/ph3VG9mU8gAaBF6if6tatEuI4NXvtnI8N/+y9mWM4cnP1zN86mq+SjlQThUqpazitCAQkakikiEiG0vZLiIyXkR2iMgGEWntrFqUbebSF/s15WReAa99t/Wy9vV5cjoLUg8TFujHy/O3knVa71lQyp0584hgOtCrjO29gUT71z3AO06sRQENqodxR6d4Zq7Zz6+XeBXRzqM5/HPuJjrWieTju9qTmXuGN39MK+dKlVIVyWlBYIxZAhwvo0k/4ENjsxKoIiI1nFWPsnmkZ31iKgfy7FcbKbzIgeP8giIenZlCoL8P44a0oEVcFW5pfwUfrtjDpoN6RZJS7srKMYJaQPGRy3T7c+cRkXtEJFlEko8e1btlL0dooB/PXt+YTQez+Xjl3ot67dgft5F6IItX/tqcGuGVAPjbtQ2pGhzAs3pFklJuyy0Gi40xk40xScaYpGrVqlldjtv7S7MadK4XxRs/bCPjpGMzli7dfoz3/ruLoe2uoFfT6n88Hx7sz6jeDfl13wm+WJvurJKVUk5kZRAcAOKKPY61P6ecTER4oV8Tzpwt4t8LLjxwfDw3n8c/S6FutRCevb7RedsHtI4lqXZVXvluKydOXd4VSUqpimdlEMwFbrNfPdQByDLG6BzKFaROtVDuuaoOX647wMpdmaW2M8bw99kbOHHqLG/d1IrgAL/z2vj4CC/e2JSs02d5/fttzixbKeUEzrx89FNgBdBARNJF5E4RuU9E7rM3WQDsAnYA7wP3O6sWVbIHutejVpVKjPl6I2cLi0ps88mqffy4+QhP9WpA01rhpe6rUY3K3NaxNjNW79PlM5VyM868amioMaaGMcbfGBNrjJlijHnXGPOufbsxxjxgjKlrjGlmjEl2Vi2qZJUCfHmubxPSjuQwbdnu87ZvP3KSF7/ZTJfEKO7olHDB/T12TX2iQgN59uuLvyJJKWUdtxgsVs5zTeMYejSM5j8Lt3Mo6/Qfz+edLeThmSmEBvoxdnALfHzkgvuqHOTPM39pxIb0LD5dvc+ZZSulypEGgeK5vk0oLDK89M2WP5577bttbDmUzWsDmxMdFuTwvvq2qEnHOpG8/v02MnPOOKNcpVQ50yBQxEUE80D3esxPPcSStKMs3pbB1GW7Gd6xNj0axVzUvn6/Iin3TAGvXuZUFkqpiqFBoAC456o6xEcGM+brjTz5+QYaxIQxus/5l4o6IjEmjDs7J/BZcjpr95Z1c7lSyhVoECjAtpDN8/2asifzFNl5Zxk/tBVB/r6XvL+HeyRSIzyIZ77aREEpVyQppVyDBoH6Q9f61fh7r4aMv6kVDaqHXda+QuxTWWw5lM1HFzmVhVKqYmkQqD8Z2a3un6aQuBy9m1anS2IU435IIyPbsakslFIVT9xthamkpCSTnKy3HLiL3cdyue7NJQDUjgwmPiqEhKgQ4iNtfyZEhRBTORCRC1+eqpS6dCKy1hiTVNK28+cLUKocJUSF8OGd7fh5awa7j+Wy+1gu/007Sn7B/8YNKvn7UjsymDrVQqgfE8aA1rHERQRbWLVS3kWPCFSFKywyHMo6ze5juew5lsvuY6fYfSyHPZmn2JuZC9hudLu9UwLtEyL0aEGpcqBHBMql+PoIsVWDia0aTJfEP08rfvDEaT5auZdPV+/j+01HaFSjMrdfGU/fljUv6yompVTp9IhAuaS8s4V8te4A05btYduRk0SEBDC0XRzDOsRTPdzxO52VUjZlHRFoECiXZoxhxa5Mpi/bw49bjuArQq+m1bm9UwKtr6iip42UcpCeGlJuS0S4sm4UV9aNYv/xU3y4Yg8z1+znmw2H6NOsOuMGt9RTRkpdJr2PQLmNuIhg/vGXxqwc3YMnrqnPgtTD3DZlNVmnzlpdmlJuTYNAuZ2QQD8e6pHI+KGtWLf/Nwa9t/xPU2grpS6OBoFyW31b1OSD29tx8EQef520nLQjJ60uSSm3pEGg3NqV9aKYdW8HCooMA99Zzpo9OtupUhdLg0C5vSY1w5kz8kqiQgO59f9W8f2mw1aXpJRb0SBQHiEuIpgvRl5JoxqVGfnxWj7WGU+VcpgGgfIYESEBzLi7PV3rV+OZrzYy7sc03O0+GaWsoEGgPEpwgB+Tb0tiUJtYxi/azug5qbowjlIXoDeUKY/j7+vDawObE1M5iLd/3sGxnDNMvKU1gX5645lSJdEjAuWRRIQnr2vAC/2asHBLBqNmp+ppIqVKoUcEyqPd1jGeE6fOMu7HNOIignn8mvpWl6SUy9EgUB7voavrse/4KcYv2s4VEcEMbBNrdUlKuRSHTg2JyCMiUllspojIryJyrbOLU6o8iAj/6t+MTvUiGTV7A8t2HLO6JKVciqNjBHcYY7KBa4GqwDDgFadVpVQ5C/DzYdItbahTLYT7Pl6r01EoVYyjQfD7pO99gI+MMZuKPaeUWwiv5M/UEW0J8vfl9mlryDiZZ3VJSrkER4NgrYj8gC0IvheRMEAvzlZuJ7ZqMFOHt+V4bj53Tk/mVH6B1SUpZTlHg+BOYBTQ1hhzCvAHbndaVUo5UbPYcCYMbcWmg1k8/Ok6Cov0slLl3RwNgo7ANmPMCRG5FXgGyHJeWUo5V8/GMTzX13aPwQvzNuk9BsqrORoE7wCnRKQF8ASwE/jQaVUpVQFu6xjPXZ0T+GDFXqYu22N1OUpZxtEgKDC2j0z9gLeNMROBMOeVpVTFeLpPI65rEsNL8zfr9NXKazkaBCdFZDS2y0bni4gPtnGCMolILxHZJiI7RGRUCduvEJGfRWSdiGwQkT4XV75Sl8fHR/jPkFY0j63CIzPXkbL/hNUlKVXhHA2CIcAZbPcTHAZigdfLeoGI+AITgd5AY2CoiDQ+p9kzwGfGmFbATcCki6hdqXJRKcCXKcOTiAoNZOTHazmem291SUpVKIeCwP7L/xMgXESuB/KMMRcaI2gH7DDG7DLG5AMzsZ1a+tOugcr278OBgw5XrlQ5igoN5J1b2pCZk8/jn6VQpFcSKS/i6BQTg4HVwCBgMLBKRAZe4GW1gP3FHqfbnyvuOeBWEUkHFgAPOVKPUs7QLDacZ69vxOJtR3l3yU6ry1Gqwjh6augf2O4hGG6MuQ3bp/1ny+H9hwLTjTGx2O9ato8//ImI3CMiySKSfPTo0XJ4W6VKdmuH2lzfvAZjf0hj9e7jVpejVIVwdPZRH2NMRrHHmVw4RA4AccUex9qfK+5OoBeAMWaFiAQBUUDx98IYMxmYDJCUlHRpx+zfjoLDqZf0UuU9BPhPURF3BWVT+KHhbK1w/H112Q7lIqo3g97lP82bo//CvxOR70VkhIiMAOZjO5VTljVAoogkiEgAtsHguee02Qf0ABCRRkAQoB/5laX8fHxIjAmloKiIHUdzMOh4gfJsDh0RGGP+JiIDgE72pyYbY768wGsKRORB4HvAF5hqjNkkIi8AycaYudhuTntfRB7DNnA8wjjrFk8npKjyXCHAzlX7ePrLVJ5oV5+HeiRaXZJSTiPudmt9UlKSSU5OtroM5QWMMTw6K4V56w/y8V3tubJulNUlKXXJRGStMSappG1lnhoSkZMikl3C10kRyXZOuUq5ht8XtImPCuHhT1N02mrlscoMAmNMmDGmcglfYcaYymW9VilPEBLox6RbWpNz5iyPfJqiM5Uqj6SXQyh1AQ2rV+aFfk1ZsSuTtxZtt7ocpcqdBoFSDhicFMeA1rFM+Gk7v2zXC9uUZ9EgUMpBL97YhHrVQnl0ZgpHssseLzDGkHe2kN9y83W6CuXyHL2hTCmvFxxgGy/o+/YyRkxbQ9OalcnNL+BkXgG5ZwrIPVNIzpkCcvMLyMkroMAeAI1qVOalG5vQpnaExT1QqmR6+ahSF+mbDQd5ft5m/HyEkEA/QgL9CAv0IyTQl5BAP0LtXyGBfvj6CB8s38OhrDyGJMXx994NiQgJsLoLyguVdfmoBoFSTpZ7poDxP21nyi+7CQ3yY1SvhgxOisPHR6wuTXmRS76PQCl1+UIC/RjduxELHulC/ZgwRs1JZcC7y9l0UJf9Vq5Bg0CpClI/JoxZ93Rg3OAW7D9+ihsmLOX5eZs4mXfW6tKUl9MgUKoCiQh/bR3Lose7cUv72kxfvoerx/6Xr1MO4G6naZXn0CBQygLhwf68eGNTvn6gEzXCg3hkZgrDpqzmWM4Zq0tTXkiDQCkLNY+twpf3d+LFfk1I3nuc/pOWsSMjx+qylJfRIFDKYr4+wrCO8cy8pyOn8wsZ8M5yVu7KtLos5UU0CJRyES3jbEcHUaEBDJuyii/XpVtdkvISGgRKuZC4iGDmjOxEm9pVeWzWet5auF0HkZXTaRAo5WLCg/358I72/LV1Ld5cmMaTn28gv6DI6rKUB9O5hpRyQQF+Powd1ILaESG8uTCNgydO8+6wNoRX8nd4H8dyznA8N5/6MWFOrFR5Ag0CpVyUiPBIz0TiIirx99kbGPDOcqaNaEtcRHCJ7Y/lnGH17uOs2JnJyl2ZbLdfffTxne3pnKjLbKrS6VxDSrmBFTszufejZAL8fPi/4W1pGVeFzJwzrNp9nJW7bL/4047YfvEHB/iSFB9BhzoRzF6bTu6ZQr5/9CrCgx0/mlCeRyedU8oD7MjI4fbpqzl68gxXRASX+Iu/Q51ImtUKx9/XNvyXmp5F/0nL6N2sBhOGtrKyfGWxsoJATw0p5SbqRYfy5f2d+MeXqZzKL+TGVrXO+8V/rmax4TzaM5E3fkijZ6No+rWsVcFVK3egQaCUG4kKDeS9YSV+qCvVfV3r8tPWDJ75aiNt4yOoWaWSk6pT7kovH1XKw/n5+vDmkJYUFhme/Hy9Lp2pzqNBoJQXqB0ZwpjrG7N8ZyZTl+22uhzlYjQIlPISQ9rG0bNRDK99v41th09aXY5yIRoESnkJEeGVAc2oHOTHo7NSOFNQaHVJykVoECjlRaJCA3nlr83ZciibN3/cbnU5ykVoECjlZXo2jmFouzjeW7KTVTrdtUKDQCmv9MxfGnNFRDCPf7Ze10xWGgRKeaOQQD/GDW7JoazTPDd3s9XlKItpECjlpdrUrsqD3esx+9d0vk09ZHU5ykIaBEp5sYd6JNI8Npynv0wlIzvP6nKURTQIlPJi/va7jk+fLeTWKavYf/yU1SUpC2gQKOXl6lYLZerwthzOyqPfxGWs2XPc6pJUBXNqEIhILxHZJiI7RGRUKW0Gi8hmEdkkIjOcWY9SqmRX1oviqwc6EV7Jn1veX8UXa9OtLklVIKcFgYj4AhOB3kBjYKiIND6nTSIwGuhkjGkCPOqsepRSZatTLZSv7u9EUnxVnvx8Pa98u1UnqPMSzjwiaAfsMMbsMsbkAzOBfue0uRuYaIz5DcAYk+HEepRSFxAe7M8Hd7Tj5vZX8O5/d3Lvx2vJPVNgdVnKyZwZBLWA/cUep9ufK64+UF9ElonIShHpVdKOROQeEUkWkeSjR486qVylFNgGkF++sSnP3dCYRVuOMPDdFRw4cdrqspQTWT1Y7AckAt2AocD7IlLl3EbGmMnGmCRjTFK1atUqtkKlvJCIMKJTAlNHtCX9+Cn6vb2MX/f95vDrjTEcyc7jbGGRE6tU5cWZK5QdAOKKPY61P1dcOrDKGHMW2C0iadiCYY0T61JKOahbg2jm3H8ld36QzE2TV/L6wOZ/Wu6yqMhw4MRptmecZPuRHNKO5LAj4yQ7MnLIzS8kLqIST13XkOub10BELOyJKovTFq8XET8gDeiBLQDWADcbYzYVa9MLGGqMGS4iUcA6oKUxptSZsHTxeqUq3vHcfO77eC2rdx9nUJtYCosM2zNy2JGRw+mz/5vOOqZyIInRYdSLDiUuIpgv1qaz5VA2LWLDebpPI9rXibSwF96trMXrnRYE9jfuA/wH8AWmGmNeFpEXgGRjzFyxfUQYC/QCCoGXjTEzy9qnBoFS1sgvKGLM1xuZlbyf6pWDqBcdSv2YMBKjQ0mMCaVedBjhlfz/9JrCIsOX6w4w9odtHMrKo2ejGEb1bki96FCLeuG9LAsCZ9AgUMpaZwuL8Pe9uOHFvLOFTFm6m3cW7+T02UJuahvHoz3rUy0s0ElVqnNpECilXMKxnDOMX7SdGav2Eejnw31d63JXlzpUCvC1ujSPp0GglHIpu47m8Np32/hu02FiKgfyQPd6tEuIoG610Is+2lCO0SBQSrmk5D3HeXnBFtbtOwFAgK8PiTGhNKpR2f4VRuMalakSHGBtoR5Ag0Ap5bKMsV2BtOVQNpsPZrP5UDZbDp3kWM6ZP9rUDA/6Ixz+2roWdarpYPPF0iBQSrmdjJN5bDl0ki2Hsv8IiV3Hcgn08+Hl/k3p3yrW6hLdSllB4MwbypRS6pJFhwURHRZE1/r/m03gcFYeD3+6jsdmrWf17uP884YmBPnrQPPl0lEZpZTbqB4exIy723N/t7p8uno/N05cxq6jOVaX5fY0CJRSbsXP14enejVk2u1tOZKdxw0TljJ3/UGry3JrGgRKKbfUvUE08x/uQsMalXn403X848tU8opNd6Ecp0GglHJbNatUYuY9Hbj3qjp8smofA95Zzp5juVaX5XY0CJRSbs3f14fRfRoxZXgS6b+d5voJS5m/4ZDVZbkVDQKllEfo0SiGBY90ITEmlAdm/MpzczfpUpsO0iBQSnmMWlUqMeuejtzRKYHpy/fw/LxNuNu9UlbQ+wiUUh4lwM+HMTc0xtcH3v9lN1GhgTzUI9HqslyaBoFSyiON7t2IzJx8xv6YRlRYIEPbXWF1SS5Lg0Ap5ZF8fIRXBzbnt1P5/OPLVKoGB9CraXWry3JJOkaglPJY/r4+TLylNS3iqvDwzHWs3FXqKrheTYNAKeXRggP8mDq8LVdEBHP3B8lsPphtdUkuR4NAKeXxqoYE8OEd7QgN8mP4tNXsyzxldUkuRYNAKeUValapxId3tONsYRG3TV31p/UOvJ0GgVLKayTGhDFleFsOZ+cxYtpqTuadtbokl6BBoJTyKm1qV2XSLa3Zcugk9360ljMFJU9UZ4wh/bdT/Lw1g8lLdvLk5+t5/LMUDmflVXDFzqeXjyqlvM7VDWN4bUBznvh8PY/PWs+o3g3ZcTSH7UdOknbE9ueOjBxy8/8XEtXCAsnJK2DxtqOMG9yCbg2iLexB+dIgUEp5pQFtYsnMPcO/Fmxlfur/JqmrFhZI/ZhQBiXFkRgTSv2YMBKjQ6kSHMDOozk88MmvjJi2hge61+WxnvXx83X/Eyu6ZrFSyqvN33CIE6fzSYwOo36M7Rd+WU7nF/L8vE3MXLOfdgkRTBjaipjKQRVU7aXTxeuVUqqcfbkunafnbCQ4wJc3h7TkqmJrK7uisoLA/Y9plFLKAv1bxTLvoU5EhgYwfNpqxv6wjUI3nfZag0AppS5Rvegwvn6gMwNbxzLhpx3c8n8rych2v6uKNAiUUuoyVArw5fVBLXhjUAtS9p+gz/hfWLr9mNVlXRQNAqWUKgcD28Qy98HOVAkOYNjUVXy6ep/VJTlMg0AppcpJ/Zgw5j7YiS6J1fjn15tITc+yuiSHaBAopVQ5Cg7w460hLYkKDeCBGb+S7QbTWGgQKKVUOasaEsCEm1tx4MRpRs3e4PLrJmsQKKWUE7SpHcFT1zVgQephPlq51+pyyuTUIBCRXiKyTUR2iMioMtoNEBEjIiXe7KCUUu7o7i51uLphNC99s4WNB1x3vMBpQSAivsBEoDfQGBgqIo1LaBcGPAKsclYtSillBR8fYeygFkS6+HiBM48I2gE7jDG7jDH5wEygXwntXgReBdzvLgyllLqAqiEBvH1zK9J/O83o2amXPF5gjKHISXcuOzMIagH7iz1Otz/3BxFpDcQZY+aXtSMRuUdEkkUk+ejRo+VfqVJKOVGb2hH87boGzE89xMeXMF6Qsv8EA99dwcw1+y/c+BJYNlgsIj7AOOCJC7U1xkw2xiQZY5KqVXPtiZ2UUqok93SpQ/cG1XjxIsYLDmfl8fisFG6cuIy9macIDXLOygHODIIDQFyxx7H2534XBjQFFovIHqADMFcHjJVSnsjHRxg7uOUf4wVlLZN5Or+QtxZup/sbi/km9RAju9Xl5ye70rdFTefU5pS92qwBEkUkQUQCgJuAub9vNMZkGWOijDHxxph4YCXQ1xijc0wrpTxSREgAE4baxgtGzTl/vMAYw9cpB7h67GLeXJjG1Q2jWfR4V/7eqyFhQf5Oq8tpK5QZYwpE5EHge8AXmGqM2SQiLwDJxpi5Ze9BKaU8T1J8BE9e24BXv9tKhzqRDOtQG4Bf9/3Gi99sZt2+EzStVZm3bmpFu4SICqnJqUtVGmMWAAvOeW5MKW27ObMWpZRyFfdeVYdVuzN5cd5maoYHMW/9Qb5KOUh0WCCvD2zOgNax+PhIhdWjK5QppZQFjufm0+etXzicnUegnw/3XFWH+7rWJSTQOZ/Py1qhTBevV0opC0SEBPD+bUnMWZfOnZ0TiK0abFktGgRKKWWRZrHhNIsNt7oMnXROKaW8nQaBUkp5OQ0CpZTychoESinl5TQIlFLKy2kQKKWUl9MgUEopL6dBoJRSXs7tppgQkaPApa4EHQUcK8dy3IH22Tton73D5fS5tjGmxAVd3C4ILoeIJJc214an0j57B+2zd3BWn/XUkFJKeTkNAqWU8nLeFgSTrS7AAtpn76B99g5O6bNXjREopZQ6n7cdESillDqHBoFSSnk5jwwCEeklIttEZIeIjCphe6CIzLJvXyUi8RaUWa4c6PPjIrJZRDaIyCIRqW1FneXpQn0u1m6AiBgRcftLDR3ps4gMtv9dbxKRGRVdY3lz4N/2FSLys4iss//77mNFneVFRKaKSIaIbCxlu4jIePvPY4OItL7sNzXGeNQX4AvsBOoAAcB6oPE5be4H3rV/fxMwy+q6K6DP3YFg+/cjvaHP9nZhwBJgJZBkdd0V8PecCKwDqtofR1tddwX0eTIw0v59Y2CP1XVfZp+vAloDG0vZ3gf4FhCgA7Dqct/TE48I2gE7jDG7jDH5wEyg3zlt+gEf2L//AughIlKBNZa3C/bZGPOzMeaU/eFKILaCayxvjvw9A7wIvArkVWRxTuJIn+8GJhpjfgMwxmRUcI3lzZE+G6Cy/ftw4GAF1lfujDFLgONlNOkHfGhsVgJVRKTG5bynJwZBLWB/scfp9udKbGOMKQCygMgKqc45HOlzcXdi+0Thzi7YZ/shc5wxZn5FFuZEjvw91wfqi8gyEVkpIr0qrDrncKTPzwG3ikg6sAB4qGJKs8zF/n+/IF283suIyK1AEtDV6lqcSUR8gHHACItLqWh+2E4PdcN21LdERJoZY05YWZSTDQWmG2PGikhH4CMRaWqMKbK6MHfhiUcEB4C4Yo9j7c+V2EZE/LAdTmZWSHXO4UifEZGewD+AvsaYMxVUm7NcqM9hQFNgsYjswXYuda6bDxg78vecDsw1xpw1xuwG0rAFg7typM93Ap8BGGNWAEHYJmfzVA79f78YnhgEa4BEEUkQkQBsg8Fzz2kzFxhu/34g8JOxj8K4qQv2WURaAe9hCwF3P28MF+izMSbLGBNljIk3xsRjGxfpa4xJtqbccuHIv+2vsB0NICJR2E4V7arAGsubI33eB/QAEJFG2ILgaIVWWbHmArfZrx7qAGQZYw5dzg497tSQMaZARB4Evsd2xcFUY8wmEXkBSDbGzAWmYDt83IFtUOYm6yq+fA72+XUgFPjcPi6+zxjT17KiL5ODffYoDvb5e+BaEdkMFAJ/M8a47dGug31+AnhfRB7DNnA8wp0/2InIp9jCPMo+7vFPwB/AGPMutnGQPsAO4BRw+2W/pxv/vJRSSpUDTzw1pJRS6iJoECillJfTIFBKKS+nQaCUUl5Og0AppbycBoHyOCLS9wKzkXYTkW8usI8RIvL2Rb7vHvu1+462v+j3OOf18SJyc7HHSSIy/lL3p7yXx91HoJT92nKPuI9ARPzs82GVJB64GZgBYL9Zzp1vmFMW0SMC5Tbsn4C3ish0EUkTkU9EpKd9grXtItLO3u6PT9oiMkhENorIehFZUsI+24nICvtc9stFpEGxzXEisti+738We82tIrJaRFJE5D0R8S1hvyW2EZHb7bWvBjqV0s/nROQjEVmG7cbHeBH5RUR+tX9daW/6CtDF/h6PFT/SEZEIEfnKPl/9ShFpfkk/dOUVNAiUu6kHjAUa2r9uBjoDTwJPl9B+DHCdMaYFUNKd1FuBLsaYVva2/yq2rR0wAGgODLKfemkEDAE6GWNaYrt795biOyytjX2q4OexBUBnbHPnl6Yx0NMYMxTIAK4xxrS27/f30z+jgF+MMS2NMW+e8/rngXXGmOb2n8uHZbyX8nJ6aki5m93GmFQAEdkELDLGGBFJxXaq5FzLgOki8hkwp4Tt4cAHIpKIbXoC/2Lbfvx9egYRmYPtl3cB0AZYY5+qoxK2X9TF9SilTXtgsTHmqH2fs7DNBVSSucaY0/bv/YG3RaQltlAp7TXFdcYWYhhjfhKRSBGpbIzJduC1ystoECh3U3zW1KJij4so4d+zMeY+EWkP/AVYKyJtzmnyIvCzMaa/2JYsXVz85efuDtuqUB8YY0aXUWOJbUTkxjJec67cYt8/BhwBWmA7iveERXaUC9FTQ8qjiUhdY8wqY8wYbDNSxp3TJJz/TeE74pxt19jPtVcCbsR2dLEIGCgi0fb9R8j56z+X1mYV0NX+6dwfGORgN8KBQ/b59Ydhm3wN4CS26bZL8gv2U1Yi0g04pkcDqjQaBMrTvS4iqWJbCHw5tjVvi3sN+LeIrOP8I4rVwGxgAzDbGJNsjNkMPAP8ICIbgB+BPy0TWFob+1TBzwErsIXKFgf7MAkYLiLrsY2L/H60sAEotA+EP3bOa54D2tjf/xX+N+26UufR2UeVUsrL6RGBUkp5OQ0CpZTychoESinl5TQIlFLKy2kQKKWUl9MgUEopL6dBoJRSXu7/AXR2x2Lxuz2/AAAAAElFTkSuQmCC\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": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation Coefficient: 0.9864175880210674\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "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": 28,
   "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": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearson Correlation Coefficient: 0.9864\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
}