LOO-DualLOO-Group-Mislabel-Nonconvex-11.12-final-cifar10-Copy3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "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": 21,
   "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:6\" 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",
    "        # Adjusted for 3 input channels\n",
    "        self.conv1 = nn.Conv2d(3, 32, kernel_size=5, padding=2)\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=5, padding=2)\n",
    "        # The feature map size is different for CIFAR-10, adjust the input size of fc1\n",
    "        self.fc1 = nn.Linear(64 * 8 * 8, 128) # Adjusted size for CIFAR-10\n",
    "        self.fc2 = nn.Linear(128, 10) # Output size for 10 classes\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",
    "        # Adjust the view size for CIFAR-10\n",
    "        x = x.view(-1, 64 * 8 * 8) # Adjusted size for CIFAR-10\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, 3, 32, 32)), 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": 22,
   "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/1/{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, 3, 32, 32), 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": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(batch_size=64, dataset='cifar10', epochs=20, 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='cifar10', 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=20, 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('cifar10')\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('20')\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": 24,
   "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": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_44282/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_44282/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": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_dataset = TensorDataset(torch.tensor(train_img_np.reshape(-1, 3, 32, 32)), 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": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# x_test_tensor = torch.tensor(test_img_np.reshape(-1, 3, 32, 32), 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",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": 29,
   "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": 30,
   "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": 31,
   "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": 31,
     "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": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LOO vs Dual\n",
    "repeat = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "group_size = len(mislabel_img_np)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "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": 36,
   "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": 37,
   "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": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " current idx is 0 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current portion of mislabeled data samples is 0.0 \n",
      " current idx is 5 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current portion of mislabeled data samples is 0.1724137931034483 \n",
      " current idx is 10 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current portion of mislabeled data samples is 0.3448275862068966 \n",
      " current idx is 15 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current portion of mislabeled data samples is 0.5172413793103449 \n",
      " current idx is 20 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current portion of mislabeled data samples is 0.6896551724137931 \n",
      " current idx is 25 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current portion of mislabeled data samples is 0.8620689655172413 \n",
      " time elapsed : 89.65013217926025\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": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_ = f'./saved_models/GroupIF/mislabeled/Grouptrain_Grouptest_02_10/1/{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": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " current idx is 0 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current idx is 5 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current idx is 10 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current idx is 15 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current idx is 20 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " current idx is 25 \n",
      " current shape of test set is (500, 3072), the length of the group is 450 \n",
      " time elapsed : 218.82689309120178\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": 41,
   "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": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ratios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAA0yElEQVR4nO3dd3hUZfbA8e9JI6RREnoIAem9BAERuyIWlCZF7K6rru7q6tp+u4rb1LXtKrsqui6oCAoIgoKABQEBMfTeW0JJSEhPSDLz/v64A0YIZJLM5E5mzud58kx7595zJ8k9c9973/OKMQallFKBK8juAJRSStlLE4FSSgU4TQRKKRXgNBEopVSA00SglFIBLsTuACorLi7OJCYm2h2GUkrVKmvWrDlujGlU3mu1LhEkJiaSnJxsdxhKKVWriMiBc72mXUNKKRXgNBEopVSA00SglFIBrtadIyhPSUkJKSkpFBUV2R2K3wgPDyc+Pp7Q0FC7Q1FKeZlfJIKUlBSio6NJTExEROwOp9YzxpCRkUFKSgqtW7e2OxyllJf5RddQUVERsbGxmgQ8RESIjY3VIyylAoRfJAJAk4CH6eepVODwm0SglFJ+bclLcHSTVxbtF+cIlFLKr/04CZb8HUoLoWk3jy9ejwi8ZMKECbzyyiuVft/+/fvp2rWrFyJSStVKu76Gr56EDtfBFX/yyio0EfghYwxOp9PuMJRS1XVsK8y4E5p0geHvQlCwV1bjd11Dz8/bwtbDOR5dZufmMTx3Y5cK2/3tb39jypQpNG7cmJYtW9KnTx8uu+wyXnnlFZKSkjh+/DhJSUns37+f/fv3c9ttt5Gfnw/AxIkTueiiiypcx+TJk5k9ezbZ2dmkpqYyfvx4nnvuOfbv38/gwYPp168fa9asYf78+Xz66ad8+umnnDx5kmHDhvH8889X+7NQStWQvHT4eDSERcLYT6BOlNdW5XeJwC5r1qxh+vTprF+/ntLSUnr37k2fPn3O2b5x48YsXryY8PBwdu3axdixY90uprd69Wo2b95MREQEffv25frrrycuLo5du3YxZcoU+vfvz6JFi9i1axerV6/GGMPQoUNZunQpl1xyiac2WSnlLSVFMH0c5KfDXfOhXguvrs7vEoE739y9YdmyZQwbNoyIiAgAhg4det72JSUlPPTQQ6xfv57g4GB27tzp9rquvvpqYmNjARg+fDjLly/n5ptvplWrVvTv3x+ARYsWsWjRInr16gVAXl4eu3bt0kSglK8zBj7/DaSshls+hBa9vb5Kv0sEviYkJOR0f33ZAVqvv/46TZo0YcOGDTidTsLDw91e5pnX+J96HBkZefo5YwxPP/00v/71r6sTvlKqpn3/EmyeCVc+B53P/4XSU/RksYdccsklzJkzh8LCQnJzc5k3bx5gzZ+wZs0aAGbOnHm6fXZ2Ns2aNSMoKIgPP/wQh8Ph9roWL15MZmYmhYWFzJkzh4EDB57VZvDgwbz//vvk5eUBkJqaSlpaWnU2USnlbZtmwpIXoMc4uPjRGlutJgIP6d27N6NHj6ZHjx4MGTKEvn37AvD444/z1ltv0atXL44fP366/YMPPsiUKVPo0aMH27dv/8W3+YpceOGFjBgxgu7duzNixAiSkpLOanPNNdcwbtw4BgwYQLdu3Rg5ciS5ubnV31CllHcc/BHmPAitBsKN/4IaHN0vxpgaW5knJCUlmTNPqm7bto1OnTrZFFHNmjx5MsnJyUycONHr6wqkz1UpW504AO9eAeExcO83ENHQ46sQkTXGmLO/NaJHBEopZa+ibOsyUWcJjPvUK0mgInqy2EctXLiQJ5988hfPtW7dmtmzZ3PnnXfaE5RSyrMcpTDjLsjYBeM/g7h2toThtUQgIi2BD4AmgAEmGWP+dY62fYGVwBhjzMzy2gSawYMHM3jwYLvDUEp508KnYc83cOMb0OZS28Lw5hFBKfCYMWatiEQDa0RksTFma9lGIhIMvAQs8mIsSinlW1a/C6snwYCHoM8dtobitXMExpgjxpi1rvu5wDagvOFxDwOzAL22USkVGHZ/DQuehPZD4Oo/2x1NzZwsFpFEoBfw4xnPtwCGAW9V8P77RCRZRJLT09O9FqdSSnld2nbrvEDjzjDiPa8VkqsMrycCEYnC+sb/iDHmzGpw/wSeNMact1SmMWaSMSbJGJPUqFEjL0WqlFJeln8cPr4FQsJh7DSvFpKrDK8mAhEJxUoCU40xn5XTJAmYLiL7gZHAf0TkZm/GVFO8NR/B+vXrmT9/foXLWbJkCStWrKiw3eTJk3nooYcqFaNSqgpKT8In4yHvmJUE6re0O6LTvJYIxCqA819gmzHmtfLaGGNaG2MSjTGJwEzgQWPMHG/F5A88nQiUUjXAGJj3Ozi4Em5+C+LLHddlG29eNTQQuA3YJCLrXc89AyQAGGPe9spaFzzl+Xk9m3aDIS9W2Mzb8xEUFxfz7LPPUlhYyPLly3n66ae5+uqrufvuu9m7dy8RERFMmjSJmJgY3n77bYKDg/noo4948803ycrK4q9//SvFxcXExsYydepUmjRp4pGPRylVgeWvw4ZpcPn/QdfhdkdzFq8lAmPMcsDtYhnGmDu9FUtNqIn5CMLCwvjzn//8ixITDz/8ML169WLOnDl8++233H777axfv57777+fqKgoHn/8cQBOnDjBqlWrEBHee+89/vGPf/Dqq6967gNQSpVv61z45nnoNgou+YPd0ZTL/0YWu/HN3Rtqcj6CspYvX86sWbMAuOKKK8jIyCAn5+wZ2lJSUhg9ejRHjhyhuLiY1q1bV2l9SqlKOLwOPrsP4i+EoRNrtJBcZWitIS9zZz6C5ORkiouLvRrHww8/zEMPPcSmTZt45513fhGLUsoLcg7DtLEQ2QjGTIVQ9+ccqWmaCDykpuYjiI6O/kU56UGDBjF16lTAOkEcFxdHTEzMWe2ys7Np0cIazzdlypTqbaxS6vyK82HaGDiZC+OmQ1RjuyM6L00EHlJT8xFcfvnlbN26lZ49e/LJJ58wYcIE1qxZQ/fu3XnqqadO7+RvvPFGZs+eTc+ePVm2bBkTJkxg1KhR9OnTh7i4OM9/AEopi6PU6g46uglGvg9N7Jk+tzJ0PgJ1Tvq5KlVJjlKY/Wtrqskh/4B+vjNVrM5HoJRS3uZ0wJwHrCRw1fM+lQQq4n9XDfmJ881HoJTyMU6HNc3kpk+tSecvfsTuiCrFbxKBMQbx0UuzqsLu+QhqW5ehUrZxOuDzh2DjdLjijzDo93ZHVGl+0TUUHh5ORkaG7rw8xBhDRkYG4eG+e7mbUj7B6YS5v4UNH1ujhn10wFhF/OKIID4+npSUFLREteeEh4cTHx9vdxhK+S6nE+b9FtZ/BJc+BZc+YXdEVeYXiSA0NFRHyiqlao7TCV88Aus+hEuegMuesjuiavGLriGllKoxTid8+XtYOwUGPQaXP+OzpSPcpYlAKaXcZQzMfxzW/A8ufhSu+FOtTwKgiUAppdxjDCx4ApL/CwN/Z10m6gdJAPzkHIFSSnlVUTbMewS2fAYDHrIGjPlJEgBNBEopdX6pa2Dm3ZB1CK58Fi7+fY0lgeyCErYfzWH70Vy2Hcnh4nZx3NC9ucfXo4lAKaXK43TCyonWpDLRzeCuBZDQzyurcjgN+47ns/1oDtuO5LD9SC7bj+aSmlV4uk39iFAS49wrTllZmgiUUupMeelW8bg930CnoTD0Dajb4NzNT5ay/mAWyQcyWXPgBOsPZlFY4iA0OIjQYCEsJIiw4CBCQ4JczwW5nhMKSxzsOpbHyVJr3pLgIOGCRpEkJTZgfNNWdGwWTedmMTSOruO16gmaCJRSqqw931lJoDALrn8Nku7+RVeQMYaUE4WsOXDCtePPYsfRHJzGataxaQxDezanfkQoJQ5DcamTEofz9G2Jw1Bc5nHdsBBu6x9Lp2YxdGwWTdvGUdQJCa7RTdZEoJRSAI4S+O7v1kTzce3httmn5xIwxvDdjjRmJKeQfOAE6bknAYiqE0KvhPpcc0U7khIb0LNlfaLDQ+3ciirRRKCUUicOwKx7IWU19L4Drn0RwiIwxrB013FeW7yTDYeyaBJTh4vbxtG7VQP6JDSgQ9NogoNq/9VDmgiUUrVCalYhry7aQVSdEIb3jqdHfL3q95kX58PWz2HBU4CxZhTrOgKAFbutBJB84AQt6tflxeHdGNEnntBg/xt+pYlAKeXTjDFMW32Iv8/fhsNpcBrDBysPcEGjSIb3jmdYrxY0r1/X/QVmHYSdC2HnV7BvGThOQos+VhJokMjqfZm8tngHq/Zm0jQmnL/e3JVbkloSFuJ/CeAUv5iqUinlnw5lFvD0Z5tYvvs4A9vG8uLw7sTUDWXBpiPMWpvCT/tPIAIXXRDL8F7xXNu1KZF1zvh+63RASrK149+5ENK2WM83bAPth0D7wdBqIGtScnl98U6W7z5Oo+g6/OayCxhzYQLhoTV74tZbzjdVpSYCpZTPcToNH68+yAvztwHwzPWdGHdhwlldQQcy8pm9LpXP1qZyMLOAiLBgru3alJE9GtO/eBVBuxZidi1CCjMxEkxJ/AAKEq8kJ+FKciMTOVnqJLughCkr97NkRzqxkWE8cNkFjO/fym8SwCmaCJRStcahzAKenLWRFXsyuLhtHC+O6EZ8g4jzvscYw5oDJ5i1NoWvN+7nNcdLDAreTJaJ4jtnT75x9GKpszs5lD8gq0FEKL++9AJuH9CKiDD/7DE/XyLwzy1WStU6Tqdh6o8HeGHBdoJEeGF4N8b0benWCWERISmxIUnNwvhb1lPIwa3MS3iCTY2HUicsjI4hQfQMDaZOSBB1XLfhZW67tqhH1JldSgEkcLdcKeUzDmUW8MTMjazcm8GgdnG8OKI7LSpzAhiswnBTRxGUkgwj3uXGbiO50Tvh+h1NBEoprykoLiUzv5gT+SVkFhRzIr/Yelzwy9sNh7IJCRJeGtGNW5LcOwr45Yoy4aPhcHQzjJoMnYd6ZXv8lSYCpZTbTpVXOJ53ksz8YjLyisnILyYz/yQZrseZrp19Rv5Jikqc5S4nSKBBRBgNIsNoGBHGDd2b8ejV7St3Gegp+cfhw5shfQeM/gg6XFu9jQxAmgiUUhXKLSph9rpUPlx5gF1peWe9Hh4aRGxkHRpGhhEbFUa7JlHERobRMLIODSNDaRARRsNIa8cfGxlGTHgoQZ4YkZt7DD64CU7sg7HToe2V1V9mANJEoJSPczgNe9Pz2JCSzYZDWWw+nE3d0GDaN4mmY9NoOjSNpn2T6LOvn/eAHUdz+XDVfmavTSW/2EH3+Hr8+aYuxDeoS8PIOsS6dvy2XGmTcximDIWcVLh1BrS+pOZj8BOaCJTyIcYYUrMK2eja6W9IyWJTSjb5xQ4AIsOC6dKiHvknS/nkp0MUljhOv7dlw7p0aGIlhg5NY+jQJJo2jSIrXRKhxOFk4ZajfLDyAKv3ZRIWEsSN3Ztz+4BW9GhZ35ObW3VZB2HKjZCfAeM/g1YD7I6oVtNEoJQPWLkng/eW7WX9oSwy8osBCAsOolOzaKuuTsv69IivR5tGUaeLnDmdhkMnCthxNNf6OWbdfrcjHYfTGh8UHCQ0jQmnRf26tGhQt9zbUwOnjmYX8fHqg0xffZC03JO0bFiXp4d0ZFRSSxpGhtnzwZQnc691JHAyB27/HOL72B1RraeJQCkbFRSX8tKC7UxZeYBm9cK5vGNjesTXo3t8fTo2iz5vXfqgIKFVbCStYiO5pkvT08+fLHWwNz2fHUdz2Z2WR2pWIaknClm9L5Mj2YU4zxhDGhcVRuPocHYcy8VpDJe1b8SLA1pxafvGvldZ8/guKwmUFsHtc6F5T7sj8gteSwQi0hL4AGgCGGCSMeZfZ7S5FXgSECAXeMAYs8FbMSnlS37cm8EfZm7k0IkC7hqYyBODO1I3rPplDeqEBNOpWQydmsWc9Vqpw8nRnCJSTxSeThCpWdbPPe1ac2u/BFrFemc6xGoxBjbPgvl/gKBguPOL03MFqOrz5hFBKfCYMWatiEQDa0RksTFma5k2+4BLjTEnRGQIMAnwzqSgSlVgzYET5BaV0CYuihYN6nrt23BBcSn/+GoHk1fsJ6FhBNN/1Z9+bWK9sq4zhQQHEd8gosKSDT4l9xh8+XvY/oVVJXTYJIhra3dUfsVricAYcwQ44rqfKyLbgBbA1jJtVpR5yyog3lvxKHUuBzMK+MuXW1m89djp58JCgkiMjaB1XCRtGkXROi6SCxpF0iYuigbV6C9fvS+TP8zcwIGMAu68KJEnru3gt7Vtqs0Y2PgJLHgSSgrh6j9D/99AsH5enlYjn6iIJAK9gB/P0+weYEFNxKMUQGGxg7eW7ObtpXsJCRKevLYjfVo1YG96HvuO57MnPZ9daXl8sy2N0jId6/UjQmnbKIquLerR3dWf3yYu8rzXxRcWO3h54Q7+t2IfLerXZdqv+jPggpo5CqiVcg7DF49apaNb9oOb/g1x7eyOym95PRGISBQwC3jEGJNzjjaXYyWCi8/x+n3AfQAJCQleilQFCmMMC7cc5S9fbCM1q5Cbejbn6SGdaFovHIALWzf8RftSh5NDJwp/mSCO5TL9p4NMXmGNnI2uE/KLxNA9vh7xDeoiIqw5kMnjMzay73g+t/VvxVNDOnrlmn+/YAysnwpfPQOOYhj8AvT7tXVeQHmNV8tQi0go8AWw0Bjz2jnadAdmA0OMMTsrWqaWoVbVsTstlwlzt7J893E6No3m+aFdqtw/X+pwsjs9j40p2WxMyWJjSjbbjuRQ4rD+pxpGhtG2URQ/Hcikeb26vDyyOxe1jfPk5viX7BSY+1vY8w20GghD34TYC+yOym/YMh+BWFWjpgCZxphHztEmAfgWuP2M8wXnpIlAVUVuUQlvfLOL//2wn4iwYB4f3IFxFyYQ4uH5Z0+WOthxNPd0cth6JIfeCQ144tqOAV3m+BecTnCWQOlJcJRYU0XuXAiL/gTGCVdNgL73QpD/Tg1pB7vmIxgI3AZsEpH1rueeARIAjDFvA88CscB/XNUGS88VqFJV4XAa5qxL5cWvtnM87yRj+rbk8Ws6EBtVxyvrqxMS7Ooaqg+08so6aoXcYzD3IUjbbu3oHcVQWmzdOkvKf0/rS6yjgAaJNRqq8u5VQ8uxxgecr829wL3eikHZ79SOuG5YMNd0buLxb+DlcToNyQdO8OXGw8zffJT03JP0bFmf/96R5NpBK686ugk+HgOFmdDpRgipA8F1XLehrvthEBz28/2optbcwZUtP608Qo9VldfsPJbLEzM3sv5QFgAJDSO4d1BrRvVp6ZGBU2U5nYZ1h07wxcYjzN90hGM5J6kTEsQVHRtzU8/mXNO5qWeqXarz27EAZt4D4fXg7q+gWQ+7I1Ju0ESgPK7E4eTtJXt489vdRNYJ5l9jehIeGszb3+/h2c+38Prindw+IJHbB7SqVheNMYb1h7L40rXzP5xdRFhIEJd3aMT13ZtzZcfGenVOTTEGVk60+vmb94Qx0yCmmd1RKTfp5PXKozanZvPEzI1sPZLDDd2bMWFoF+JcO3tjrC6bd77fy9fbjhEeGsSoPi25d1Brt8oaFBY72Hksl+1Hc9h6OIevt6WRmlVIWHAQl7RvxA3dm3Flp8ZEh4d6ezNVWaXF1sjfdR9C55vg5rchrBaNXA4Qtlw15C2aCHxTUYmDN7/dxdvf76VhZBh/vbkrg8sUQjvT7rRc3l26j9nrUil1OhnStRn3XdKGHi3rn54Fa/vRXLYdyWH70Ry2H8llX0Y+p/5cI8KC6de6ITd0b85VnZtQr67u/G1RkAmf3g77l8Elf4DLntGrfXyUJgLlVWsPnuCJmRvZnZbHyD7x/On6ztSLcG/HnJZTxP9W7OejVQfILSqlbeMojmUXkXuyFLDOHbZqGEHHpjF0bBZNx6YxdGoWTcsGEdrnb7fju+HjWyD7kHW1T48xdkekzkMTgXLb7rRcThSUEFUnhOjwEKLrhBIVHlJuAbbCYgevLNrB+z/so1lMOC+M6M6l7RtVab25RSV88tMhvt+ZTuu4yNM7fG/NvKWqae8S60ggKATGfAwJ/e2OSFXArnEEqpbIKijm8/WHmbHmEJtTy60CQkRYMNHhIa4EEUp0eAj7jueTcqKQ8f0TePLajtXqm48OD+XeQW24d1CbKi9DncEYKMqGuvU9u9zk/8H8xyG2LYz7RK/79wOaCAKUw2lYuiudmckpLN56jGKHk87NYnjuxs60bRxFblEpeUWl5BSVkHey9PTj3JMl5BZZj5vVC+flkT20eJovcpTCnAdg6+dw79fQrLtnlpv8P/jiEWh7FYx837pMVNV6mgh8hDGGtQez+PSnQyzdlQ5Y0wyGBAlBrtvgoCDXrZy+jY0KI6FhJK1iI1w/kTSLCT9n//me9DxmJKcwe10Kx3JO0iAilFv7JzCyTzxdmus/tV9wlMLs+6yJXELqWlU871lc/ZO4OUdg8bPQ+lIY+4mWg/Yj+pu0WWZ+MZ+tTeGTnw6xKy2PiLBgLu/YmMiwYEqdBofTWLcO163TicOAw+mkxGHYfiSXxVuPnS50BtZct/EN69KqYYRrKsMIgoOEOetSWXswi+Ag4bL2jXh+aDxXdGxCWIhe5eE3HKXw2b2wZbZVsye6Gcz+NaydDEl3V2/ZXz1l1Qe64XVNAn5Gf5s2cDoNy3cf55OfDrFo61FKHIaeLevz4vBu3NCjeaWLkzmchsNZhRzMLOBARgEHMvM5cLyAA5kFrN6XSX6xA4B2jaN45rqO3NyrBY2jw72xacpOjhKYdS9snQNX/wUG/tY6T7DuI/h6AnS8AaIaV23ZOxdZy738j1oR1A/pVUM1KDWrkBnJh5iRnEJqViH1I0IZ3iue0X1b0qFptFfWaYwhI7+Y3KJSEmMjEK3l4p8cJTDzbtg2F675G1z00M+vpe+Ety6CrsNh+KTKL7u4AP7Tz+pmun+ZVTNI1Tp61ZAHFZVYZYY3pWazOTWbPel5lDoNxlg7XYP1Jcxw6jkwWF05u9LyMAYGtYvj6es6cnXnJtQJ8e6EGyJCXFSd06N7lR8qLYaZd1lz+g5+AQY8+MvXG7WHix+BpS9Dz1uhzaWVW/73L0HWQbhzviYBP6WJ4DyKShxsO5LD5sM5bE7JZlNqNjuP5Z6etrB+RCjtm0QTVcfamQeJIGKVXBUR1y2A9fy1XZsxqk88LRvq8HvlIWWTwLUvQf/7y2836DHYNNMqBfHACvd36Me2WDWEeo2HxIGei1v5FE0EWDv8AxkF7E3PY+/xfPak57HtSC47j+XicO30G0SE0rVFPe7r0IZuLerRtcXPUxEqZYvSYphxB+yYD0Nehn73nbttaF24/hX4aAQs/ydc9mTFy3c6Yd7vrEtEr/6Lx8JWvidgEoExhrTck+xJz2Nver71c9y6n3KigDJzk9Mkpg7tm0RzuWun3y2+Hi3q605f+ZDSk/DpHbBzAVz3Clz4q4rf0/Yq6DIclr0K3UZWfNJ37WRI+ckqIhfR8PxtVa0WMIlg9rpUfv/phtOPw0ODaB0XRbf4etzcqwUXNIqkTVwUrRtF6pSCyreVFFnlHXYthOtfg773uP/ewX+H3V/Dl4/BbbPPPRFM7jFYPAESB2kNoQAQMHu8pFYNeX5oF9o0iqRNo6jzDrpSymeVFMEn42H3Yrjhn5B0V+XeH9MMrvgTLPiDNeCs28jy2y18GkoLrXXokbDfC5hEkBAbwR0XJdodhlJVV1II08fBnu/gxjegzx1VW07fe2DDx7DwGau76MxaRLu/tpLEZU9DXNtqh618nw4pVao2KM63Sj7v+Q5u/k/VkwBAULA1Ojg/Hb796xnrKYAvfm8VlLv40erFrGoNTQRK+bqTeTB1FOxfbg0I6zmu+sts3gsuvA9+eg9S1/z8/NKXIeuA1SWkYwYChiYCpXxZUY51yefBVTDiPeh+i+eWffn/QVQTmPeIVaMobRuseAN6jIPWgzy3HuXzNBEo5auKsuGj4ZCaDKP+B11HeHb54TEw5EU4uhFWv2MlhDoxcM1fK3yr8i8Bc7JYqVql8AR8OAyOboZRU6DTDd5ZT+ebrRPGi/4Ixgk3/RsidX6JQKNHBEr5moJMmDLUKu8w+iPvJQGwLg297hUIDoNWA61aRCrg6BGBUr4k/zh8cBMc3wVjpkG7q7y/zoat4cGVENlYxwwEKE0ESvmKvDTrSODEPhg3HS64oubW3VDnig5kmgiU8gV5aTD5eshOgVtnQOtL7I5IBRC3zhGIyO9EJEYs/xWRtSJyjbeDUypgLHjSqvl/60xNAqrGuXuy+G5jTA5wDdAAuA140WtRKRVI9i2FLZ/Bxb/Xmv/KFu4mglNnkK4DPjTGbCnznFKqqhyl1tFA/QRrjmGlbODuOYI1IrIIaA08LSLRgNN7YSkVIH56D9K2wuip1uQxStnA3URwD9AT2GuMKRCRhkAl698qpX4hLx2++7t1dVDH6+2ORgUwd7uGBgA7jDFZIjIe+COQ7b2wlAoA30yAkgIY8g+9fl/Zyt1E8BZQICI9gMeAPcAHXotKKV9mDBRmVW8ZKWtg3UfQ/wGIa+eRsJSqKncTQakxxgA3ARONMf8Gor0XllI+KmMPfDAUXr4Atsyu2jKcTpj/OEQ1hUuf8Gx8SlWBu4kgV0Sexrps9EsRCQJCz/cGEWkpIt+JyFYR2SIivyunjYjIGyKyW0Q2ikjvym+CUjXAUQrL/wlvXQSH10OjjjDzHtj8WeWXtf4jOLwWrvkL1NHvU8p+7p4sHg2MwxpPcFREEoCXK3hPKfCYMWat6yqjNSKy2BiztUybIUA7108/rC6ofpXaAqW87fB6mPuwVa654w1w3cvWDnzqKJh1L2DcLxFdeAK+fh4SBkC3Ud6MWim3uXVEYIw5CkwF6onIDUCRMea85wiMMUeMMWtd93OBbUCLM5rdBHxgLKuA+iLSrLIboZRXFBfAoj/Bu1dA3jG45UMYMxVimluJ4NaZ0LIfzPoVbJrp3jK/ewEKM/UEsfIp7paYuAVYDYwCbgF+FJGR7q5ERBKBXsCPZ7zUAjhU5nEKZycLROQ+EUkWkeT09HR3V6tU1e1dAm8NsGbs6jUefvMjdB76yzZ1oqy6QAn94TM3ksGxLda4gT53QbPuXgtdqcpyt2vo/4C+xpg0ABFpBHwNVPg1SESigFnAI64yFZVmjJkETAJISkoyVVmGUm4pyLSOAtZ/ZFXkvGPe+Wv/nEoGU2+xkoEx0L2cLh9jYP4TEF4Prvij9+JXqgrcTQRBp5KASwZuHE2ISChWEphqjCnvrFoq0LLM43jXc0rVvB0LYO5voSADLn4ULn3SvdG+YZFw66fw8WiYfR9gzp5bePMsOLAcbngdIhp6JXylqsrdRPCViCwEprkejwbmn+8NIiLAf4FtxpjXztFsLvCQiEzHOkmcbYw54mZMSnlOXhrMuBNi28H4WZXvugmLhHGfwse3wOxfW0cAPUZbr53Ms44ymvWA3nd4PHSlqsutRGCM+YOIjABOlUacZIyp6CLqgViXm24SkfWu554BElzLfBsrmVwH7AYK0LIVyi6r/gOOYrhlCsReULVlhEVYyWDaaCsZYKDHGFj2KuQehlGTISjYk1Er5RFuT0xjjJmF1c3jbvvlVFCh1DVI7TfuLlMpryjKhp/+C51vqnoSOCUsAsZ+AtPHwuz7rTkGVk6EHmMhQa+MVr7pvIlARHKB8k7OCtZ+PMYrUSlVk356D07mWOcFPCEsAsZOh2lj4bu/QVg0XPW8Z5atlBecNxEYY3TYo/JvJYWw6i1oe5XVh+8poXVh7DRrroHWl0B0E88tWykP0zmLVWBb9xHkp1uzg3laaF0Y+obnl6uUh7lba0gp/+MogR/esEYHt7rI7miUso0mAhW4Ns+C7IPW0YCWe1ABTBOBCkxOJyx/HRp3gfaD7Y5GKVtpIlCBaecCSN9uXSmkRwMqwGkiUIHHGFj2GjRIhC7D7I5GKdtpIlCBZ/8ySE2Gi34LwXrhnFKaCFTgWfYaRDWBnrfaHYlSPkETgQosh9fB3u+g/4MQGm53NEr5BE0EKrAse82aEyDpbrsjUcpnaCJQgSN9J2ybB31/BeFaJkupUzQRqMDxw78gJBz6P2B3JEr5FE0EKjBkp8DG6dD7doiMszsapXyKJgIVGFZMtG4vetjeOJTyQZoIVO3kKLXKRLgjPwPWToFut0D9lhW3VyrA6GgaVTsUZsGh1XBwJRz6EVLXQFAINOoITTpbNYOadIbGnc/u+vnxbWvegYsfsSNypXyeJgLle4yB7ENwcJW14z/4I6RtBYy182/Ww7r80+mwnt/2Baz94Of3Rzb+OSk07gSr34GO10OjDrZtklK+TBOB8h3ZKfD1BDiwAnJSrefCoqHlhVZNoIR+0KIPhEX+8n3GQF4apG2BY1shbZt1P/l/UFpotRnkhYlnlPITmgiUbzDGmuw9dQ10GAIJA6wJY5p0gaDg879XxJoKMroJXHDFz887HXBiPxTnQ7PuXg1fqdpME4HyDes/torB3fBPSLrLM8sMCobYCzyzLKX8mF41pOyXlw6L/s86Cuh9h93RKBVwNBEo+y18Gk7mwY3/giD9k1Sqpul/nbLXrq9h0wwY9Jhe1aOUTTQRKPsU58OXj0Jce72qRykb6cliZZ/v/g5ZB+GuBRBSx+5olApYekSg7HF4Paz6D/S5E1pdZHc0SgU0TQSq5jlKYd5vIbIRXPW83dEoFfC0a0jVvB/fgiMbYNQUqFvf7miUCnh6RKB+VlIEcx+2SjN4y4n91rmB9kOg803eW49Sym16RKAsJUUwfRzs+cYa5RufBE27eXYdxsCXj4EEwfWvWKUhlFK20yMCZZVonj4W9nwL1/wV6jaAOQ+Ao8Sz69k8C3Z/DVc+C/XiPbtspVSVaSIIdCWFMG0s7PkOhr5pzeB1w+twdBMsf91z6ynIhAVPWtVD+97rueUqpapNE0EgKy6AaWNg7xK46d/Q+zbr+U43QtcR8P0/4Ohmz6xr0Z+gKAtufKPiaqJKqRqliSBQFRfAtNGw93u4+T/Q69Zfvj7kZeuKns8frH4X0d7vYf1HcNFvoWnX6i1LKeVxXksEIvK+iKSJSLlfKUWknojME5ENIrJFRDxUe1hVqDgfPr4F9i2DYW9Dz3Fnt4mMhetfsy7z/OGfVV9X5j74/DfQoDVc+kTVl6OU8hpvHhFMBq49z+u/AbYaY3oAlwGvikiYF+NR4EoCo+HADzDsHegx5txtOw+FLsNhyUvWzF+Vlb4T/jcEivNg1GQIrVvlsJVS3uO1RGCMWQpknq8JEC0iAkS52pZ6Kx6FVep56ihXEpgEPUZX/J7rXobweq6riCrx6zm6yUoCTgfc+SU071nlsJVS3mXnOYKJQCfgMLAJ+J0xxlleQxG5T0SSRSQ5PT29JmP0H6eSwMGVMPxd6D7KvfdFxsH1r8KR9e53EaUkw+TrrUJydy2wpptUSvksOxPBYGA90BzoCUwUkZjyGhpjJhljkowxSY0aNaq5CP1FUY6VBA79CCPeg24jK/f+Ljdbk8cvebHiLqL9P8AHN1ljEe5aAHFtqxy2Uqpm2JkI7gI+M5bdwD6go43x+KeMPfDeVT8nga4jqrac616B8BjXVUTn6CLa/TV8NAJiWsBdX0GDVlWPWylVY+xMBAeBKwFEpAnQAdhrYzz+Z9dimHQ55KfD7XOg6/CqL+tUF9HhdbDijbNf3/aFNTAtri3cNR9imlV9XUqpGuXNy0enASuBDiKSIiL3iMj9InK/q8lfgItEZBPwDfCkMea4t+IJKMbAstes7qD6CXDfEmh9SfWX22WYVShuyQuQtv3n5zfOgE9vh6bd4Y55VtJQStUaXis6Z4wZW8Hrh4FrvLX+gFWcb123v2W21Q00dCKERXhu+de9CvuXW11Edy+C9VNh3u+g1UAYNx3qRHtuXUqpGqHVR/3Jif0w/VZI2wpX/9kayevpCp9RjazzBTPvgqkjrPIUba+CWz70bMJRStUYTQT+Yu8SmHEnGCfcOsPaOXtLl2HWEce2udDxBhj5vs45rFQtpomgtjPGmvt30R8hrgOMmQqxF3h3nSJWpdKON1jdT8H6Z6RUbab/wbVZSSHMewQ2Trd2ysPerrk++rr13RuZrJTyeZoIfF3pSchOgayDZ/9k7IaC43D5/8GgxyFIi8kqpSpPE4GvyT0G3/wZMnZB1iHIPYJVlslFgq0BW/UToN3V0HUktPPi+QCllN/TROBrlvwdNn4CCf3hgsutHX7Zn+jm2ievlPIo3aP4krw0WD/Nmh9gaDmjd5VSygu0U9mXrH4XHCeteYOVUqqGaCLwFcX58NO70OE6iGtndzRKqQCiicBXrP8YCk9Yo4GVUqoGaSLwBU4HrJwI8X2tk8RKKVWDNBH4gm3zrDpBFz3s+dpASilVAU0EdjPGqu/foLU1OlgppWqYJgK7HVwJqWtgwG8gKNjuaJRSAUgTgd1WvAl1G0LPW+2ORCkVoDQR2Cl9J+yYDxf+Smv5K6Vso4nATisnQkg49P2V3ZEopQKYJgK75KXBhunQY6w165dSStlEE4FdVk8CRzEMeMjuSJRSAU4TgR2K8+Gn96Dj9RDX1u5olFIBThOBHdZN1XISSimfoYmgpp0uJ3EhJPSzOxqllNJEUOO2zYWsAzBQjwaUUr5BE0FNMgZ+eAMatrHKTSullA/QRFCTDqyAw2utK4W0nIRSykdoIqgOR4m1c8/YY/X9V2TFmxARa01FqZRSPkLnLK4qpxM+uw+2fGY9Dq4Dce2hcUdo1BEad7JuGyRa3/7Td8DOBXDZ0xBa19bQlVKqLE0EVbXoj1YSGPSY1eeftg3St8PBVbBpxs/tQsKtBOEsdZWTuNe+mJVSqhyaCKpixZuw6t/Q73644k9nTyZTlAPHd/6cHNK2WY8v+i1ExtkTs1JKnYMmgsraOMM6Guh8Mwx+ofwZxcJjID7J+lFKKR+nJ4srY+8SmPMAtLoYhr0DQfrxKaVqP92TuevIRpg+3urvHzMVQsPtjkgppTxCE4E7TuyHqSMhvB6Mnwl169sdkVJKeYwmgorkZ8BHI6D0JIyfBTHN7Y5IKaU8Sk8Wn09xAUwbDdkpcNsca4yAUkr5Ga8dEYjI+yKSJiKbz9PmMhFZLyJbROR7b8VSJY5SmHkXpK6BEe9BqwF2R6SUUl7hza6hycC153pRROoD/wGGGmO6AKO8GEvlGANfPAI7v4LrXoZON9odkVJKeY3XuoaMMUtFJPE8TcYBnxljDrrap3krlkrJ3Acr3oB1H8Kgx3UksFLK79l5jqA9ECoiS4Bo4F/GmA/Kaygi9wH3ASQkJHg+kvwMq1zExk8hZbX1XN974Yo/en5dSinlY+xMBCFAH+BKoC6wUkRWGWN2ntnQGDMJmASQlJRkPLL24gLYMd+qC7T7a6sWUOPOcNUE6DoS6rf0yGqUUsrX2ZkIUoAMY0w+kC8iS4EewFmJwGOcDtj3vfXNf9s8KM6D6OYw4DfQ7RZo2tVrq1ZKKV9lZyL4HJgoIiFAGNAPeN1ra9u5EOY+DHnHoE4MdBkG3UdDq4FaKkIpFdC8lghEZBpwGRAnIinAc0AogDHmbWPMNhH5CtgIOIH3jDHnvNS02uonQHxf6H4LtBusJSKUUspFjPFMl3tNSUpKMsnJyXaHoZRStYqIrDHGlFsSWftElFIqwGkiUEqpAKeJQCmlApwmAqWUCnCaCJRSKsBpIlBKqQCniUAppQKcJgKllApwtW5AmYikAweq+PY44LgHw6kNdJsDg25zYKjONrcyxjQq74ValwiqQ0SSzzWyzl/pNgcG3ebA4K1t1q4hpZQKcJoIlFIqwAVaIphkdwA20G0ODLrNgcEr2xxQ5wiUUkqdLdCOCJRSSp1BE4FSSgU4v0wEInKtiOwQkd0i8lQ5r9cRkU9cr/8oIok2hOlRbmzz70Vkq4hsFJFvRKSVHXF6UkXbXKbdCBExIlLrLzV0Z5tF5BbX73qLiHxc0zF6mht/2wki8p2IrHP9fV9nR5yeIiLvi0iaiJQ7Y6NY3nB9HhtFpHe1V2qM8asfIBjYA7TBmgt5A9D5jDYPAm+77o8BPrE77hrY5suBCNf9BwJhm13tooGlwCogye64a+D33A5YBzRwPW5sd9w1sM2TgAdc9zsD++2Ou5rbfAnQG9h8jtevAxYAAvQHfqzuOv3xiOBCYLcxZq8xphiYDtx0RpubgCmu+zOBK0VEajBGT6twm40x3xljClwPVwHxNRyjp7nzewb4C/ASUFSTwXmJO9v8K+DfxpgTAMaYtBqO0dPc2WYDxLju1wMO12B8HmeMWQpknqfJTcAHxrIKqC8izaqzTn9MBC2AQ2Uep7ieK7eNMaYUyAZiayQ673Bnm8u6B+sbRW1W4Ta7DplbGmO+rMnAvMid33N7oL2I/CAiq0Tk2hqLzjvc2eYJwHgRSQHmAw/XTGi2qez/e4VCqhWOqnVEZDyQBFxqdyzeJCJBwGvAnTaHUtNCsLqHLsM66lsqIt2MMVl2BuVlY4HJxphXRWQA8KGIdDXGOO0OrLbwxyOCVKBlmcfxrufKbSMiIViHkxk1Ep13uLPNiMhVwP8BQ40xJ2soNm+paJujga7AEhHZj9WXOreWnzB25/ecAsw1xpQYY/YBO7ESQ23lzjbfA3wKYIxZCYRjFWfzV279v1eGPyaCn4B2ItJaRMKwTgbPPaPNXOAO1/2RwLfGdRamlqpwm0WkF/AOVhKo7f3GUME2G2OyjTFxxphEY0wi1nmRocaYZHvC9Qh3/rbnYB0NICJxWF1Fe2swRk9zZ5sPAlcCiEgnrESQXqNR1qy5wO2uq4f6A9nGmCPVWaDfdQ0ZY0pF5CFgIdYVB+8bY7aIyJ+BZGPMXOC/WIePu7FOyoyxL+Lqc3ObXwaigBmu8+IHjTFDbQu6mtzcZr/i5jYvBK4Rka2AA/iDMabWHu26uc2PAe+KyKNYJ47vrM1f7ERkGlYyj3Od93gOCAUwxryNdR7kOmA3UADcVe111uLPSymllAf4Y9eQUkqpStBEoJRSAU4TgVJKBThNBEopFeA0ESilVIDTRKD8jogMraAa6WUi8kUFy7hTRCZWcr37Xdfuu9u+0us44/2JIjKuzOMkEXmjqstTgcvvxhEo5bq23C/GEYhIiKseVnkSgXHAxwCuwXK1ecCcsokeEahaw/UNeLuITBaRnSIyVUSuchVY2yUiF7ranf6mLSKjRGSziGwQkaXlLPNCEVnpqmW/QkQ6lHm5pYgscS37uTLvGS8iq0VkvYi8IyLB5Sy33DYicpcr9tXAwHNs5wQR+VBEfsAa+JgoIstEZK3r5yJX0xeBQa51PFr2SEdEGorIHFe9+lUi0r1KH7oKCJoIVG3TFngV6Oj6GQdcDDwOPFNO+2eBwcaYHkB5I6m3A4OMMb1cbf9e5rULgRFAd2CUq+ulEzAaGGiM6Yk1evfWsgs8VxtXqeDnsRLAxVi188+lM3CVMWYskAZcbYzp7Vruqe6fp4BlxpiexpjXz3j/88A6Y0x31+fywXnWpQKcdg2p2mafMWYTgIhsAb4xxhgR2YTVVXKmH4DJIvIp8Fk5r9cDpohIO6zyBKFlXlt8qjyDiHyGtfMuBfoAP7lKddTF2lGXdeU52vQDlhhj0l3L/ASrFlB55hpjCl33Q4GJItITK6mc6z1lXYyVxDDGfCsisSISY4zJceO9KsBoIlC1Tdmqqc4yj52U8/dsjLlfRPoB1wNrRKTPGU3+AnxnjBkm1pSlS8q+/czFYc0KNcUY8/R5Yiy3jYjcfJ73nCm/zP1HgWNAD6yjeH+YZEf5EO0aUn5NRC4wxvxojHkWqyJlyzOa1OPnEr53nvHa1a6+9rrAzVhHF98AI0WksWv5DeXs+Z/P1eZH4FLXt/NQYJSbm1EPOOKqr38bVvE1gFysctvlWYary0pELgOO69GAOhdNBMrfvSwim8SaCHwF1py3Zf0DeEFE1nH2EcVqYBawEZhljEk2xmwF/ggsEpGNwGLgF9MEnquNq1TwBGAlVlLZ5uY2/Ae4Q0Q2YJ0XOXW0sBFwuE6EP3rGeyYAfVzrf5Gfy64rdRatPqqUUgFOjwiUUirAaSJQSqkAp4lAKaUCnCYCpZQKcJoIlFIqwGkiUEqpAKeJQCmlAtz/A+C5cuw1Ble0AAAAAElFTkSuQmCC\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": 43,
   "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": 44,
   "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": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation Coefficient: 0.8971151819558723\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": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Correlation Coefficient for0.8971151819558723\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAooAAAGSCAYAAABkGeDnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAABsSUlEQVR4nO3de1yUZf4//tcIDCAHFZVgQEVULA+kkCbrASv302Zqu5ureEDbdbUTrqv2+ZRQq7Qie9Ityf2uZmlZq+ZmWrseynPlDw+gkRoeQjCZQTziICeB+f3hMivOPcMMc19z3zPzej4ePZJ7rrnv634x4pv7vq/r0phMJhOIiIiIiO7RRukOEBEREZE6sVAkIiIiIkksFImIiIhIEgtFIiIiIpLEQpGIiIiIJPkq3QFPM3DgQFy+fBk9e/ZUuitERERENp07dw6dO3fGsWPHJF9noSizy5cvo7KyUuluEBEREbWopZqFhaLMmq4k7tu3T9mOEBEREbVg5MiRNl/nM4ousHTpUqW74LGYrVjMVxxmKw6zFYfZiqXGfFkougBvRYvDbMVivuIwW3GYrTjMViw15stCkYiIiIgksVAkIiIiIkksFImIiIhIEgtFIiIiIpLEQtEFkpOTle6Cx2K2YjFfcZitOMxWHGYrlhrz1ZhMJpPSnfAkTfMRcR5FIiIiag2jwYAvs7Kgz8tDQ20tfPz9oUtMxPCMDIRERsp6rJbqFl5RdAE1zovkKZitWMxXHGYrDrMVh9mK9Ze//AW7FizA24MG4ciKFSjNzUXZsWMozc3FkRUr8PagQdi1YAFceY2PVxRlJlWZG41GhISEKNMhD8dsxWK+4jBbcZitOMxWrG3z5+P4ypW4feuW1TZ+QUEYPHs2RmVny3JMXlFUAb1er3QXPBazFYv5isNsxWG24jBbcYwGA0588IHNIhEAbt+6hYJ161BZVuaSfrFQdIENGzYo3QWPxWzFYr7iMFtxmK04zFacL7OyUF1ebldbY2kpDmRlCe7RHSwUiYiIiBSmz8tzqL3BwfatxUKRiIiISGENtbUOta+vqRHUk+ZYKBIREREpzMff36H2vgEBgnrSHAtFIiIiIoXpEhMdah/pYPvWYqFIREREpLDhGRmAnVMPhURFYURGhuAe3cF5FGXGeRRdi9mKxXzFYbbiMFtxmK1YnEfRS3HeKXGYrVjMVxxmKw6zFYfZihU7cyYGz56NkKgoyddDoqIwePZsPLZkicv6xELRBfLz85XugsditmIxX3GYrTjMVhxmK9axY8cwKjsbs44exaC0NEQnJSFi4EBEJyVhUFoaZh09ilHZ2dBoNC7rE289y6ylS7hEREREasFbzyqwfv16pbvgsZitWMxXHGYrDrMVh9mKpcZ8WSi6wJkzZ5TugsditmIxX3GYrTjMVhxmK5Ya82WhSERERESSWCgSERERkSQWikREREQkiYUiEREREUnyVboD3iAuLk7pLngsZisW8xWH2YqjVLZGgwFfZmVBn5eHhtpa+Pj7Q5eYiOEZGQiJjFSkT3Lj51YsNebLeRRlxnkUiYi8i8lkwu70dBSsWwdjaanF6yFRUYhPTcVjS5a4dKJkIntwHkUVUOO8SJ6C2YrFfMVhtuK4Otvd6ek4nJMjWSQCgLG0FIdzcrA7Pd2l/RKBn1ux1JivrLeeGxoacOHCBRQVFeGHH37AlStXcP36ddTU1OD27dvw8/NDQEAA2rVrh86dOyMqKgqxsbGIiYmBr6/n3gVPSEhQugsei9mKxXzFYbbiuDJbo8GAgnXrcPvWLZvtbt+6hYJ16zBkzhwER0S4qHfy4+dWLDXm63R1dvPmTeTm5uLYsWM4deoUampqHN6HVqvFAw88gAEDBuBHP/oR2rdv72y3VEWn0yndBY/FbMVivuIwW3Fcme2XWVlWryTey1haigNZWRidkyO4V+LwcyuWGvNt1a1nk8mEI0eOIDs7G88++yzeeecd5Ofnt6pIBIC6ujp88803eO+99/D8889j8eLFOHToEBobG1u1P7VZtmyZ0l3wWMxWLOYrDrMVx5XZ6vPyHGpvcLC92vBzK5Ya83XoiuLt27fxxRdf4N///jeuXLkipEONjY349ttv8e2336Jjx4548skn8eMf/xharVbI8YiIiFqrobbWofb1rbygQqQUuwrFhoYG7Ny5E1u3bsWNGzcEd+m/rl69ivfffx9bt27FT3/6U/zP//yPRz/LSERE7sXH39+h9r4BAYJ6QiRGi1XXoUOH8OGHH+LSpUuu6I+kiooKvPfee9ixYwemTp2KwYMHK9YXIiKiJrrERJTm5trdPjIxUWBviOTX4jOKy5Yta1WRqNFo0K5dO3Tt2hU9e/bE/fffj549e6Jr164IDQ1tVWcvXbqkyvv3RETknYZnZCAkKsqutiFRURiRkSG4R0TykuU+rlarRVxcHHr37o2YmBh07doV4eHhaNPGeh3a2NiIS5cu4YcffkBxcTEKCwtx9uxZ1NXV2TyWXPODFxYWYvXq1dDr9ejSpQueffZZxMbGNmtTV1eHP/zhDzh79ixqa2sxdepUjBs3TpbjExGR+wuJjER8aioO5+TYnCLHLygI8ampbj01DnmnVheK7dq1w5AhQ5CYmIi+ffs6/OxgmzZtEBkZicjISPOt5Pr6epw4cQJ5eXnIzc3FzZs3W9s9m+rq6rB06VJotVpMnz4dmzdvxrJly7B8+fJmxW1jYyOCg4MxYMAAHDp0qNXHS0lJkaPbJIHZisV8xWG24rg628eWLAEAu1ZmcXf83Iqlxnwdqu7atGmDhx56CI888ggGDBhg84phqzrj64sBAwZgwIAB+OUvf4njx49jz549yMvLk3WqnOPHj6OiogJTp07F448/jhs3buDjjz/GyZMn0b9/f3O7gIAAzJs3D/v27XOqUFTjvEiegtmKxXzFYbbiuDpbjUaDUdnZGDJnDg5kZcGQl4f6mhr4BgQgMjERIzIyPOZKIj+3YqkxX7sqvYCAAIwbNw45OTmYP38+EhISZC8SLTrWpg0SEhLw0ksvIScnB2PHjkWATKPFysvLAQBhYWEAgI4dOwKAsAE7q1atErJfYraiMV9xmK04SmUbHBGB0Tk5mHHwIJ7Nz8eMgwcxOifHY4pEgJ9b0dSYb4tXFJ9++mmMHj0awcHBruiPpE6dOmHq1Kn46U9/im3btsm+fzmee9y1axd27dqFoqIi+Pv7IzMzs9nrmZmZCA4Oxvz5880Lb48cORJLly5FZWWlxf6Sk5PNr8+aNQt6vR4bNmyQPPa8efOg1+uRn5+PSZMmYf369Thz5oxFu7i4OPPrCQkJ0Ol0VgcHpaSkQKfTYdWqVeY+79+/36KdGs4JgMedk5q+T6dPn/a4c1LD96mystLi54S7n5Oavk9N2XrSOTVR+pz27dvnceeklu9TE1eeU3FxMWJiYiT7BQAak1yjQ9zI4cOH8Ze//AVTpkzBU089hY0bN+Ljjz/Ga6+9ht69e6NNmzbNnrnct28f/va3v9k1mGXkyJHm99z9/qbtJC9mKxbzFYfZisNsxWG2YimRr1Tdcjex949VasCAAWjXrh0+//xzfP7559izZw86d+6Mzp07Y+rUqfjLX/5ibrt7926cOnUKAHDu3Dns3r3b4aUKpX4rIHkwW7GYrzjMVhxmKw6zFUuN+SpSKJaVlSlxWDOtVou5c+ciICAAa9asQbt27TBv3jzJ5y5XrlxprrJzc3OxcuVKYaOxiYiIiNREkfXw5syZg7Zt2yImJgaPP/44hgwZ4vI+9OnTB0uXLrXY/tFHH9n8moiIiMhbKHbruaqqCqdOncLp06eV6gIRERER2aDIFUVHFRQUoKqqCrGxsQgPD1e6O0RERERewSWFoslkgkajafX78/PzsX37dgBAUFAQ3n33Xbm65hJKTi3k6ZitWMxXHGYrDrMVh9mKpcZ8XTI9zrRp09C9e3f06NEDPXr0wPLly82vjR49GtOnT7f5/rVr15oLRQDYuHGjsL46q6Vh5kRERERqoYrpcWpra1FYWIh///vfzYpEADh79iwOHDiAkpISNDQ0SL7f0elo1IZFozjMVizmKw6zFYfZisNsxVJjvoo/o3j27FmcPXsWwJ21nnU6Hbp164aYmBh07doVGo0G+fn5CveSiIiIyPu45NbzxIkTZdtXmzZtsH79etn2JzfeeiYSz2gw4MusLOjz8tBQWwsff3/oEhMxPCMDIZGRSnePiMhtqOLWc0BAgGz7at++vWz7chWp+RpJHsxWLLXlazKZsGvBArw9aBCOrFiB0txclB07htLcXBxZsQJvDxqEXQsWyLJ+u2hqy9aTMFtxmK1YaszXJbee33vvPZSWluLcuXM4d+4cPv/881bvq0+fPjL2zDWkFusmeTBbsdSW7+70dBzOycHtW7ckXzeWluJwTg4AYFR2tiu75jC1ZetJmK04zFYsNebrsgm3o6KikJycjBkzZjTb3qdPHzzxxBPo06dPi8PCAwMD8fTTT4vsJhGplNFgQMG6dVaLxCa3b91Cwbp1qFR4qVAiIk+g+GCWmJiYZtPjXLt2DcXFxSgpKcGFCxdQXl4OAOjSpQvGjRsHnU6nVFeJSEFfZmXBWFpqV1tjaSkOZGVh9H+uLhIRUesoUiguXrwY58+fR3FxMSLvefA8LCwMYWFhSEhIUKJrRKRS+rw8h9obHGxPRESWFCkUe/XqhV69eilxaCJyUw21tQ61r3fz+VeJiNTAZc8oerPk5GSlu+CxmK1YasrXx9/fofa+Ms62IIKasvU0zFYcZiuWGvNVpFC8cuUK1q5di71796KoqAj19fVKdMNlmuYoIvkxW7HUlK8uMdGh9pEOtnc1NWXraZitOMxWLDXmq0ih+N1332H79u34+9//jgULFlgs61dcXIwVK1YgMzMTb7zxBr766isluikbNc6L5CmYrVhqynd4RgZCoqLsahsSFYURGRmCe+QcNWXraZitOMxWLDXm65KVWe717rvvYufOneav/+///g+J//nt/+zZs3j99ddRV1fX7D39+vXDyy+/DK1W69K+OkpqhnOj0YiQkBBlOuThmK1Yast314IFNudRBAC/oCAMnj1b9fMoqi1bT8JsxWG2YimRrypWZrlXSUmJ+c9arRb9+/c3f71mzRqLIhEATpw4gdWrV7ukf3LT6/VKd8FjMVux1JbvY0uWYPDs2VavLIZERWHw7Nl4bMkSF/fMcWrL1pMwW3GYrVhqzFeRQrGiosL8565du5qvEl64cAHff/+91fcdOHAAP/zwg/D+yW3Dhg1Kd8FjMVux1JavRqPBqOxszDp6FIPS0hCdlISIgQMRnZSEQWlpmHX0KEZlZ0Oj0Sjd1RapLVtPwmzFYbZiqTFfRabHMRqN5j/fPY9iXgvznplMJnz11VeYNGmSsL4RkfoFR0RwMm0iIhdQ5IpiVVWV+c9t27Y1/7mwsLBZu5dffhl//vOf4efnZ952+vRp8R0kIiIiImWuKGq1WtT8ZzLcmrsmxT1//rz5z6GhoebVWfr27Yvjx48DAAwGg+s6SkTkBYwGA77MyoI+Lw8NtbXw8feHLjHxzkjze1bPIiLvokih2L59e5SVlQG4M8oZuPMA593PLt69ckunTp3Mf777aiQREbWeyWTC7vR0FKxbZ7GOdmluLgq3bEF8aioeW7LELZ77JCL5KVIodunSxVwo6vV6rFy5EteuXWvWpmfPnuY/3/0DytMn5yYicpXd6ek2pxsylpbi8H+eBVX7dENEJIYizyg23VJusmfPHvOt5SZ3T5lz664fYgEqX5ZLyrx585TugsditmIxX3GUztZoMKBg3Tqbc1ICwO1bt1Cwbh0q//PLvTtQOltPxmzFUmO+ihSKw4YNQ/v27a2+Hh0d3ezW893zCtl6n1qpcV4kT8FsxWK+4iid7ZdZWRa3m60xlpbiQFaW4B7JR+lsPRmzFUuN+SpSKGq1WsyePRu+vpZ3vtu0aYPp06ebv66pqcHFixfNX0e64YPV+fn5SnfBYzFbsZivOEpnq29hOrJ7ndq0CauTkrAyIQGrk5KwLS0NRpUOLlQ6W0/GbMVSY76KLOHX5MKFC9i8eTPOnDmD2tpadO3aFT//+c+b3Xb++uuvm60F/Ytf/ALjx49Xort2aWkpHCIiNViZkICyY8ec2kdIVBQHuxC5OVUu4dc0kKVr16747W9/i7/97W945513sHDhwmZFIgBs27at2df333+/y/opl/Xr1yvdBY/FbMVivuIona2Pv7/T+2ga7LI7PV2GHslH6Ww9GbMVS435KjLqec6cOWjbti1iYmLw+OOPY8iQIVbbvvzyyyguLkZJSQl++OEHtywUz5w5o3QXPBazFYv5iqN0trrERJTm5jq9n6bBLkPmzEFwRIQMPXOe0tl6MmYrlhrzVeSKInBnPsRTp061uNJKaGgo4uPjMXbsWLzwwguSzzUSEZFjhmdkICQqSpZ9udtgFyKyn1tUXQUFBaiqqkJsbCzCw8OV7g4ReQlPXrEkJDIS8ampNudRdITBwcExROQeXFIomkwmpx50zs/Px/bt2wEAQUFBePfdd+XqGhGRBW9ZseSxJUsAQPI8HVV/13KsROQ5XFIoTp8+Hd27d0ePHj3Qo0cPp/Z1S4bffImIbPGWFUs0Gg1GZWdjyJw5OJCVBUNeHuprauAbEIDrRUW4demS3fvydcPFEIioZS4pFGtra1FYWIjCwkKL186ePYsDBw6gW7duiI6Oho+Pj0WbGgG/qRYWFmL16tXQ6/Xo0qULnn32WcTGxlq0++KLL/Dxxx/DaDTiwQcfxPPPP4+QkBCHjhUXFydXt+kezFYsb8zX0RVLWjuIQ03ZBkdEYPR/Ct8m29LScGTFCrv3EZmYKHe3Wk1N2XoaZiuWGvN1yTyKEydOtKudr68vdDodunXrhpiYGHTt2hUajQY5OTmoqKgwt9u4caNT/amrq8OLL74IrVaLcePGYfPmzfDz88Py5cvRps1/x/ecP38eL7/8Mvr374/4+HisX78ew4YNQ1pamtV9cx5FIvfmaIE0KC3NosjyBEaDAW8PGmTXLemQqCjMOnpUNaOeich+qpxH0Zr6+npcuHABX375JdatW4esrCwsXry4WZF4dyHXWsePH0dFRQUef/xxPP7443j00UdRXl6OkydPNmvXFNqkSZPw1FNPoXfv3vj6669RV1fn0PHUOC+Sp2C2Ynljvo6uWNLaQRxqz7ZpsItfUJDNdn5BQYhPTVVVkaj2bN0ZsxVLjfm6pFAMkPHZFTnWei4vLwcAhIWFAQA6duwIALh0z/M497YLCwtDQ0MDrl696tDxEhISnOovWcdsxfLGfBtqax1q39pBHO6Q7WNLlmDw7NlWp9EJiYrC4NmzzYNi1MIdsnVXzFYsNebrkmcU33vvPZSWluLcuXM4d+4cPv/881bvq0+fPjL27A57777bardr1y7s2rULRUVF8Pf3R2ZmpkWb4OBgzJ8/33ylcuTIkVi6dCkqKyst2iYnJ5tfnzVrFvR6PTZs2CB57Hnz5kGv1yM/Px+TJk3C+vXrJSftjIuLM7+ekJAAnU6HZcuWSe4zJSUFOp0Oq1atMvd5//79qjun2NhY9O7d26POSU3fp8mTJ+P06dMedU4tfZ8iHJyr9UZlJU6fPq3qc3Lm+/R1QACQkgJ8+SWg1wP19YCvL3olJ+PRRYvw4datGKXRuNU5eeL3iefkGef02WefoXfv3i49p+LiYsTExEj2C1Boree7n1ns06cPunXrhpKSEly4cEHyZJsEBgZiyZIl0Ol0Th3/8OHD+Mtf/oIpU6bgqaeewsaNG/Hxxx/jtddeQ+/evdGmTRv4+vpizZo12L59O5YsWYKePXti4cKFOHPmDN577z1otVrJfUvd68/MzMTChQud6jNJY7ZieWO+rnpG0RuzdRVmKw6zFUuJfFt6RlHxCbdjYmIwffp089fXrl0zL9l34cIF8+3fLl26YNy4cU4XiQAwYMAAtGvXDp9//jkCAwOxZ88edO7cGZ07d8bUqVORkJCAV155BcnJydi+fTvWr1+P+Ph4nD59GkOHDrVaJBKR+xuekYHCLVvsHsQxIiPDBb0iIlKGIoXi4sWLcf78eRQXFyPyntUNwsLCEBYWJvQ+vVarxdy5c/HOO+9gzZo15ulx7h0oExsbixkzZmDz5s0oLCzEgAEDmhW1ROR57F2xRI2DOIiI5KZIodirVy/06tVLiUOb9enTB0uXLrXY/tFHHzX7umlkNBF5j5ZWLAmJijKvzEJE5MkUv/VMRKQ2tlYsiUxMxIiMDF5JJCKvIFuhWFxcjGvXrqGiogI1NTUIDAxEaGgodDod7rvvPrdeD5WIvJPUiiVERN7EqULx7Nmz2LlzJ44fPw6j0Wi1Xdu2bdGvXz88/PDDGDJkCHwdnH7C3aWkpCjdBY/FbMVivuIwW3GYrTjMViw15tuqiu369etYu3YtcnNz7WpfVVWFw4cP4/Dhw3j33XcxevRojBkzRtaJuNVMjpHaJI3ZisV8xWG24jBbcZitWGrM1+GVWfR6PV599VW7i8R73bp1C5s2bcLs2bNbvQ93s2rVKqW74LGYrVjMVxxmKw6zFYfZiqXGfB2acPvKlSt4+eWXbU6K7ahHH30UM2fOlGUNZzVoaeJKIiIiIrVoqW5xqDpbuXKlrEUiAOzZswfZ2dmor6+Xdb9qwqJRHGYrFvMVh9mKw2zFYbZiqTFfuwvFr7/+GgUFBUI6UVBQgDfeeEPIvtVAar1GkgezFYv5isNsxWG24jBbsdSYr92F4p49e0T2A0eOHLGY7JqIiIiIlGPXqOcbN27g5MmTLbbr0aMH4uLi0L59ezQ2NuLmzZu4cuUKTp06hVs2lsJqsnnzZiQmJqJHjx72dIuIiIiIBLKrUDx+/DhsjXmJi4vDzJkz0bVrV8nXTSYTTp8+jc2bN+Obb76xuh+TyYR3330XWVlZ9nSLiIiIiASy69ZzcXGx1df69u2L3/3ud1aLRODOclj3338/0tPT8corr6Bt27ZW2547dw4nTpywp1tEREREJJBdhWJ5ebnkdq1Wi7S0NPj5+dl9wIEDByIrKwvt27e32mbXrl12788dBAcHK90Fj8VsxWK+4jBbcZitOMxWLDXma9c8ii+//LLkVcVHHnkEzz33XKsOXFhYiNdffx0NDQ0Wr/n7++Odd95xqABVC86jSERERO5ClnkUrQ1EGThwYKs6BQD3338/xowZI/labW0tvv/++1bvW21YNIrDbMWSO1+jwYBtaWlYnZSElQkJWJ2UhG1paTAaDLIexx3wsysOsxWH2YqlxnztGsxSXV0tub179+5OHXzMmDHYvn076urqLF4rKirC/fff79T+iUgdTCYTdqeno2DdOhhLS5u9Vpqbi8ItWxCfmorHliyBRqNRqJckB6PBgC+zsqDPy0NDbS18/P2hS0zE8IwMhERGKt09InKQXYWiVCEHAKGhoU4dPDQ0FA899BAOHjxo8VpZWZlT+1aTpsu6JD9mK5Zc+e5OT8fhnBzctnJ3wlhaisM5OQCAUdnZshxTre4upE57UCGlpl8G+HNBHGYrlhrztevWs9RzhAAQEBDgdAf69esnuf3y5ctO71stli5dqnQXPBazFUuOfI0GAwrWrbNaJDa5fesWCtatQ6UH/ZJ4N5PJhF0LFuDtQYNwZMUKlObmouzYMZTm5uLIihV4e9Ag7FqwwOZUZGrW9MvAvUVik6ZfBnanpwvvC38uiMNsxVJjvk4VinLo1auX5PaKigphx3Q1udfHpv9itmLJke+XWVlWi4d7GUtLccBD51FVUyElN7X9MsCfC+IwW7HUmK/dS/iJYu32tT0ruRCR+unz8hxqb3CwvTtQWyElN/4yQOS57HpG0ZrZs2eje/fu5v9iY2Mdfm7R2pxBVVVVznSNiFSiobbWofb1NTWCeqKc1hRSo//zzKY74C8DRJ7LqUKxvLwc5eXlOHTokHlbhw4dmhWOMTEx6NSpk/UO+Ep3odbBf1yISJ18/P0dau8rw7PPauPphRR/GSDyXE4VilKuX7+O69evIz8/37wtJCSk2ZXH7t27IyIiwuZ+RD4XSUSuo0tMRGlurt3tIxMTBfZGGZ5eSPGXASLPJXuhKMVoNKKgoAAFBQXmbYGBgYiJibE6F2NjY6MruuYSycnJSnfBYzFbseTId3hGBgq3bLHr1mtIVBRGZGQ4fUy18fRCSm2/DPDngjjMViw15qvYYJbq6mp899132LZtm+TrnlQoqnFeJE8hd7ZcOaQ5OfINiYxEfGoq/IKCbLbzCwpCfGoqglu42+COdA4WRu52VXV4RgZCoqLsauuKXwb4M1ccZiuWGvNVfNSzN1DjvEieQq5sPX2Ou9aSK9/HlizB4NmzrRYTIVFRGDx7Nh5bskSW46mN2gopuantlwH+zBWH2Yqlxnw1Jjv+5Vu7di2Ki4tRUlLi0tHIGzdudNmx5CK1uLbRaERISIgyHfJwcmW7a8ECmyuHAHf+kRs8e7bHrxxyN7k/u5VlZTiQlQVDXh7qa2rgGxCAyMREjMjI8MgriXfz9M+YrZVZgDsFsKtWZuHPXHGYrVhK5CtVt9zNrkLxbuXl5Th//jyKi4tx/vx5lJSU4Nq1a872U5KnFIqnT59G7969lemQh5MjW6PBgLcHDbL7GbpZR496fFHThJ9d+aipkBJJDb8M8HMrDrMVS4l8WyoUHR7MEh4ejvDwcDz88MPmbTdv3kRxcbH5v/Pnz8NgMHjdbTprNmzYgIULFyrdDY8kR7aePsedM/jZlY9Go8Go7GwMmTMHB7KycGTLFkR07uxxV1WDIyIU//vBz604zFYsNeYry6jn0NBQxMfHIz4+3rytrq4OJSUl5sKxuLgYP/zwA+rq6uQ4JJFsPH2OO1KXpkLqSKdOeFZl/yAQEd1L2PQ4Wq0WvXr1araWc2NjI/R6fbPisbi4WJVrG5L38PQ57uRmNBjwZVYW9Hl5aKithY+/P3SJiXcGbERGKt09IiKSkUvmUWzSpk0bREdHIzo6GsOGDTNvv3r1arPCsbi4GJcvX3Zl18iLefocd3Kx9YxdaW4uCrds8Yhn7IiI6L9cWiha07FjR3Ts2BEPPfSQeRvXeiZXUdtkwWq1Oz3d5qhdY2kpDv/n2TR3HLVLRESWVDuPYtu2bZXuAnkJT5/jTg5GgwEF69bZnNoFAG7fuoWCdetQWVbmop4REZFIDk+PQ7ZxHkXX4jyKYjXluy0tDUdWrLD7fYPS0hQf+ap2/LkgDrMVh9mKpcZ5FFV7RVGU6upqvPHGG0hNTcXMmTPx6aefWm37ySef4Pnnn8eECRMwf/78Vh9Tr9e3+r1km1zZevvKIdY05cuR4fLjzwVxmK04zFYsNebrdYXihg0bcPDgQYwdOxZxcXH44IMPcOLECcm2DQ0NGD58uNPHzM/Pd3ofJE2ubJvmuJt19CgGpaUhOikJEQMHIjopCYPS0jDr6FGMys72ukEaTflyZLj8+HNBHGYrDrMVS435et2t52eeeQZhYWFYtmwZLl26hNmzZ2P48OGYPXu21fdMmDABXbp0sWsNxpYu4RK5o9VJSQ4N+IlOSsKMgwcF9oiIiOQg+8os7qyyshJVVVXo2bMngDujrYE7yxI6a9euXdi1axeKiorg7++PzMxMizbBwcGYP3+++ZsxcuRILF26VHIeyeTkZPPrs2bNgl6vx4YNGySPPW/ePOj1euTn52PSpElYv349zpw5Y9EuLi7O/HpCQgJ0Oh2WLVsmuc+UlBTodDqsWrXK3Of9+/er7pyCgoLw0ksvedQ5qen7FB4ejsGDB6O0oUHy+NZcbGho9ndATefkid8nnhPPiefkGef05ptv4tVXX3XpORUXFyMmJkayX4CHXlF87rnnJNefnjZtGt5//33Ex8fj1Vdfxe3btzFlyhT07t0bv//9763uz9kripmZmapbksdTMFuxmvLletjy42dXHGYrDrMVS4l8vfKK4qJFi9AgcQWkQ4cO2LRpE65evQoA5mIyPDwcAFBfX4/GxkZotVrXdZbIDYRERiI+NdWukeHxqaksEomIPIRHFooRNv6RSk5Oxo4dO7Bp0yYUFxcD+G81vXjxYpw6dQqrV69GaGgoTp06BYPBAODObevdu3eje/fuiI2NFX0KRKrTNOJbamUW4M6VxKaVWYiIyDN4ZKFoS0pKCioqKrB161YEBgZi8uTJ6N+/v2TbvXv3mp8RuH79OlauXInx48ezUCSv1DQyfMicOTiQlQVDXh7qa2rgGxCAyMREjMjI4JVEIiIPI7xQPHXqVLOvQ0NDER0dLfqwVrVt2xZz586VfG3RokXNvn7xxRfx4osvuqBXRO4jOCKCk2kTEXkJ4YXivaN/Bw0ahJdeekn0YVUlLi5O6S54LGYrFvMVh9mKw2zFYbZiqTFf4aOeJ06c2OxrTy8UOY8iERERuQsu4acC69evV7oLHovZisV8xWG24jBbcZitWGrM1+sGsyghISFB6S54LGYrllryNRoM+DIrC/q8PDTU1sLH3x+6xEQMz8hASGSk0t1rFbVk64mYrTjMViw15stC0QV0Op3SXfBYzFYspfM1mUzYnZ4uOSVPaW4uCrdsMU/J427rcCudrSdjtuIwW7HUmC9vPbuAtSV7yHnMViyl892dno7DOTlWV4QxlpbicE4Odqenu7hnzlM6W0/GbMVhtmKpMV8WikSkSkaDAQXr1tlcCQYAbt+6hYJ161BZVuainhEReQ8WikSkSl9mZdm1tjRw58rigawswT0iIvI+LBSJSJX0eXkOtTc42J6IiFrGQpGIVKmhttah9vU1NYJ6QkTkvTjqmchNeOIUMbb4+Ps71N43IEBQT4iIvBcLRRdISUlRugseyxuyVXKKGCXz1SUmojQ31+72kYmJAnsjP2/47CqF2YrDbMVSY7689ewCapwXyVN4Q7ZKThGjZL7DMzIQEhVlV9uQqCiMyMgQ3CN5ecNnVynMVhxmK5Ya82Wh6AKrVq1Sugsey9OzVXqKGCXzDYmMRHxqKvyCgmy28wsKQnxqKoIjIlzUM3l4+mdXScxWHGYrlhrz1ZhMJpPIA0ycOLHZ14MGDcJLL70k8pCKamlxbSJHbEtLw5EVK+xuPygtDaNzcgT2yLVs3XYH7lxJdNeVWYiI1KCluoVXFF2ARaM4np6t0lPEKJ2vRqPBqOxszDp6FIPS0hCdlISIgQMRnZSEQWlpmHX0KEZlZ7tlkah0tp6M2YrDbMVSY74sFF1g//79SnfBY3l6tkpPEaOWfIMjIjA6JwczDh7Es/n5mHHwIEbn5Ljd7ea7qSVbT8RsxWG2YqkxXxaKRCrGKWKIiEhJshaK1dXVuHjxokPvOXPmjJxdIPIoOgenfHG3KWKIiEjdZCsUq6ursXjxYixcuBAlJSV2vWfHjh147bXX8OGHH8rVDSKP4sgUMX5BQUj49a8F94iIiLyJLIViVVUVsrKycO7cOVRWVuL111/HhQsXbL5nx44dWLNmDQDg008/ZbFIJMHeKWKAO1Pk/OPJJ7FrwQIInsyAiIi8hCyF4ldffYWzZ8+av24qFq1dWdy5c6e5SGyyY8cOlMk8B5xaBAcHK90Fj+UN2T62ZAkGz55t15VFuSff9oZ8lcJsxWG24jBbsdSYr2zzKH744Yf49NNPm20LCQmB0Whsti04OBiVlZXNtmm1Wvzv//4v4uPj5eiKojiPIolS9s03eHfo0BYn3wbuzC846+hRtx4VTERE4rlsHsUpU6Zg7NixzbbdWyQC8Ogi0RoWjeJ4U7b5b79tV5EI3LmyeCAry+ljelO+rsZsxWG24jBbsdSYr6+cO5s6dSoA4LPPPrOrvTcUiaQORoMBX2ZlQZ+Xh4baWvj4+0OXmHhnsEhkpNLds4vSk28TEZH3EbKE37p16/Cvf/3LZhtPLRJ561ldPGkJuJUJCSg7dszu9hEDB+LZ/HyBPSIiInenyBJ+qampePLJJ62+7qlFojVLly5Vugseq6Vsd6en43BOjmSRCMg/+EMkJSbf5mdXHGYrDrMVh9mKpcZ8ha3MMm3aNMli0duKRMDyuUySj61sjQYDCtata/G5vtu3bqFg3TpUqnzUvRKTb/OzKw6zFYfZisNsxVJjvkKX8Js2bRpGjx5t/tobi0RSzpdZWVavJN5LrsEfIjky+XZIVBRGZGQI7hEREXk6WQezSJk+fTomT54MAGjTpg18fHxEH5IIgOcN/miafPtwTo7Nq6R+QUGIT03l1DhEROQ04YUiAPj5+bniMETNNNTWOtS+vqZGUE/k89iSJQBg1+AcIiIiZ7mkUCRSghKDP0TTaDQYlZ2NIXPm4EBWFgx5eaivqYFvQAAiExMxIiODVxKJiEg2LBRdIDk5WekueCxb2eoSE1Gam2v3vuQY/OEqwRERGJ2TI/w4/OyKw2zFYbbiMFux1JivkHkUvRnnUVQPo8GAtwcNsmtAC5e8IyIib6TIPIpqVl1djTfeeAOpqamYOXOmxfrUTSorK5GdnY2ZM2di6tSpyMjIQFFRUauOqcZ5kTyFrWybBn/4BQXZ3AcHf1jHz644zFYcZisOsxVLjfl63RXFNWvWYPv27Rg/fjxKSkpw5MgR/O53v0O/fv2atSsvL8ef//xnJCcno7q6Gv/85z/RqVMnrFixwub+pSpzo9GIkJAQuU+F0HK2nrQyixL42RWH2YrDbMVhtmIpkS+vKN5j//79iI6OxoQJEzBt2jQAwN69ey3adezYEX/84x8xZswY/OIXv0BMTAwuX76MWgdH0gKAXq93ut8kraVsmwZ/zDp6FIPS0hCdlISIgQMRnZSEQWlpmHX0KEZlZ7NItIKfXXGYrTjMVhxmK5Ya8/WqQrGyshJVVVUICwsDcKcYBO5cPbyXj48P2rS5E8/ly5eh1+sRGxsLfwdH0gLAhg0bnOg12WJvtk2DP2YcPIhn8/Mx4+BBjM7J4e3mFvCzKw6zFYfZisNsxVJjvh456vm5557DtWvXLLY3XUFsYs9d9xs3biA7Oxu+vr548cUXrbbbtWsXdu3ahaKiIvj7+yMzM7PZ65mZmQgODsb8+fPNl3dHjhyJpUuXSi7Zk5ycbH591qxZ0Ov1Vj9A8+bNg16vR35+PiZNmoT169fjzJkzFu3i4uLMryckJECn02HZsmWS+0xJSYFOp8OqVavMfd6/f79FO6XPqYknnZOavk8AcPr0aY86J7V8nwBY/Jxw93NS0/epKVtPOqcmSp/Tvn37PO6c1PJ9auLKcyouLkZMTIxkvwAAJg9kMBhMFy9etPjv1q1bpmnTppl++9vfmkwmk6msrMz0i1/8wrR8+XKTyWQy3b5921RbW2vez9WrV01z5swxPfPMM6Zz587Zdezk5GRTcnJys22LFi2S58TIArMVi/mKw2zFYbbiMFuxlMhXqm65m9ArigsWLECvXr3Qq1cv9O3b13zLV7QIG7cTk5OTsWPHDmzatAnFxcUA/vsg5+LFi3Hq1CmsXr0aWq0WmZmZMBgMGDduHMrKylBWVobExEQEuMHEzOQYo8GAL7OyoM/LQ0NtLXz8/aFLTLyzvnJkZKvbEhERuTOhhWJRURGKioqwc+dOjB49GtOnTwcALFu2DDExMeb/XFVAAncu71ZUVGDr1q0IDAzE5MmT0b9/f4t2N2/ehMFgAIBmU+i89dZbLBQ9iMnGqOjS3FwUbtnSbEk8e9tycAwREXkCRZ5RPHToEA4dOmT+OjQ0FN26dWtWPOp0OvNgEjm1bdsWc+fOlXxt0aJFzfr00UcfyX58Upfd6ek4nJOD27duSb5uLC3F4btWQLG37ajsbPk7S0RE5GJC51GcOHGi+c93X1G8e7s1Wq0W0dHRzYrHbt26qf5qHudRdC1nsnVk5Zag/zzOcKusrMW2nrTKCz+74jBbcZitOMxWLM6j6IC6ujoUFRVhz549ePfdd/G73/0OzzzzDObMmaN01xymxnmRPIUz2X6ZlWVXkQjcKRDtKRKBO1cWD2RltbpfasLPrjjMVhxmKw6zFUuN+QotFN966y385je/wRNPPIFIGR7yN5lMKLPzH2s1yc/PV7oLHsuZbPV5eTL2pDmDwH27Ej+74jBbcZitOMxWLDXmq8gSfqdOnUJxcTGKi4tRUlKCixcvor6+3u73b9y4UWDvnNPSJVxSj5UJCSg7dkzIviMGDsSzKvwLT0REdDdV3nru06cPRo8ejRdeeAF//OMf8f777+NPf/oTXnjhBTz55JPo27cvgoODleiaEOvXr1e6Cx7LmWx9WrHKjr18Vf4srb342RWH2YrDbMVhtmKpMV9VrMzi4+ODbt26oVu3bs22X7lyBSUlJearj8XFxbh8+bJCvWw9WyuKkHOcyVaXmIjS3FwZe/NfkYmJQvbravzsisNsxWG24jBbsdSYryoKRWs6deqETp06IfGuf3RramoU7BF5kuEZGSjcskXIqOcRGRlO94+IiEhpqh31bI3ap8ch9xESGYn41FT4BQXZbOcXFIQBzzyDAc88Y1fb+NRUj5gah4iISLYrisXFxbh27RoqKipQU1ODwMBAhIaGQqfT4b777uNKFaRKTSuuSK22Aty5Onj3yiyOtiUiInJnThWKZ8+exc6dO3H8+HEYjUar7dq2bYt+/frh4YcfxpAhQ+Drq+o73uRFNBoNRmVnY8icOTiQlQVDXh7qa2rgGxCAyMREjMjIaHZ10JG2RERE7q5VFdv169exdu1a5No5EKCqqgqHDx/G4cOH8e6772L06NEYM2aM19xGjouLU7oLHkuubIMjIjD6rqX65Grr7vjZFYfZisNsxWG2YqkxX4fnUdTr9cjKysKVK1ecOnBoaChmzJiBIUOGOLUfteE8ikREROQuZJ1H8cqVK3jttdecLhIB4ObNm/jrX/+KlStXorGx0en9qZka50XyFMxWLOYrDrMVh9mKw2zFUmO+DhWKK1euRGVlpawd2LNnD7Kzsx1amcXdJCQkKN0Fj8VsxWK+4jBbcZitOMxWLDXma3eh+PXXX6OgoEBIJwoKCvDGG28I2bca6HQ6pbvgsZitWMxXHGYrDrMVh9mKpcZ87S4U9+zZI7IfOHLkCD766COhx1DKsmXLlO6Cx2K2YjFfcZitOMxWHGYrlhrztWvU840bN3Dy5MkW2/Xo0QNxcXFo3749GhsbcfPmTVy5cgWnTp3CrVu3Wnz/5s2bkZiYiB49etjTLSIiIiISyK5C8fjx47A1ODouLg4zZ85E165dJV83mUw4ffo0Nm/ejG+++cbqfkwmE959911kZWXZ0y1SAaPBgC+zsqDPy0NDbS18/P2hS0zE8IwMhERGKt09IiIicoJdhWJxcbHV1/r27YsFCxbAz8/PahuNRoP7778f6enpOHbsGJYvX46qqirJtufOncOJEyfQr18/e7pGCjGZTNidni65Sklpbi6Or12LAb/8JZ5Yvpyr8hAREbkpu55RLC8vl9yu1WqRlpZms0i818CBA5GVlYX27dtbbbNr1y6790fK2J2ejsM5OZJL2QHA7Vu3cOStt/DOj35k82o0ERERqZddheLVq1cltw8dOhRhYWEOH1Sn02Hu3Lnw8fGRfD0/Px+3b992eL/kGkaDAQXr1uG2Hc+dlh46hO2/+Y0LekVERERys6tQtDYQZeDAga0+8P33348xY8ZIvlZbW4vvv/++1ftWm5SUFKW7IKsvs7KsXkm0YDLh+Jo1qCwrE9IXT8tWbZivOMxWHGYrDrMVS4352lUoVldXS27v3r27UwcfM2YMtFqt5GtFRUVO7VtN1DgvkjP0eXkOtb996xYOCBqg5GnZqg3zFYfZisNsxWG2YqkxX7sKxbq6OsntoaGhTh08NDQUDz30kORrZYKuQClh1apVSndBVg21tQ6/x+BgcWkvT8tWbZivOMxWHGYrDrMVS4352lUoNjQ0SG4PCAhwugPWRjdfvnzZ6X2rxfz585Xugqx8/P0dfk99TY2AnnhetmrDfMVhtuIwW3GYrVhqzNepQlEOvXr1ktxeUVEh7Jiutm/fPqW7ICtdYqLD7/GV4ZcKKZ6WrdowX3GYrTjMVhxmK5Ya87V7CT9RrN2+tmclF3exf/9+pbsgq+EZGfALCnLoPZGtKC7t4WnZqg3zFYfZisNsxWG2YqkxX7sm3LZm9uzZ6N69u/m/2NhYh59bDA4OltxubUJuUl5IZCQG/PKXOPLWW/a1j4rCiIwMwb0iIiIiuTlVKJaXl6O8vByHDh0yb+vQoUOzwjEmJgadOnWy3gFf6S7UtmLABLnOE8uXQ3/0KEoPHQJsTKjt27Yt4lNTERwR0epj2VomkIiIiMRxqlCUcv36dVy/fh35+fnmbSEhIc2uPHbv3h0RLRQOIp+LJOdpNBrMOHgQ23/zGxxfs0Zy8u2QqCjEp6bisSVLWnWMlpYJLNyyBejeHabf/Y7LBBIREQkge6EoxWg0oqCgAAUFBeZtgYGBiImJsToXY2Njoyu6Rk7QaDQYnZODERkZOJCVBUNeHuprauAbEIDIxESMyMhw6kpi0zKB1laAMZaWAuXl2J2ejlHZ2a0+DhEREUlzSaEopbq6Gt999x2+++47ydc9qVC09hympwiOiMDonBxZ92n3MoG3b6Ng3ToMmTPHqaKUpHn6Z1dJzFYcZisOsxVLjflqTCYbD5j9x8SJE13RFwsbN25U5LjOGDlyJAB1DnF3J9vS0nBkxQq72w9KS5O9WCUiIvJ0LdUtdk2P88QTT+CBBx5A27Zt5eqXV2HR6DhHlwkUtfKLt+NnVxxmKw6zFYfZiqXGfO269fzMM8+Y/1xeXo7z58+juLgY58+fR0lJCa5duyaqf+SlHF0mUNTKL0RERN7M4WcUw8PDER4ejocffti87ebNmyguLjb/d/78eRgMBthxV9vlqqursXLlSuTl5SEgIABjx47FuHHjJNsuXboU3377LW7fvo377rsPEyZMwJAhQxw+ZtNlXbKfo8sEilr5xdvxsysOsxWH2YrDbMVSY76yrMwSGhqK+Ph4jBs3Dr/5zW/w17/+Fe+//z4WL16MX//613jsscfQo0cPaLVaOQ7nlA0bNuDgwYMYO3Ys4uLi8MEHH+DEiROSbbt06YLU1FRMmTIFV69exYoVK1o1bc/SpUud7bYijAYDtqWlYXVSElYmJGB1UhK2paXBaDAIP7ajywSKWvnF27nrZ9cdMFtxmK04zFYsNeYrbNSzVqtFr169mq3l3NjYCL1eb77q2HQFsrKyUlQ3LOzfvx/R0dGYMGECLl26hCNHjmDv3r3o16+fRdsJEyagsrIS169fx2effdbqfrry/ORgz/yFTfMjipq/cHhGBgq3bLE4vhSu/CKOu3123QmzFYfZisNsxVJjvi6dHqdNmzaIjo5GdHQ0hg0bZt5+9erVZoVjcXExLl++LPvxKysrUVVVhZ49ewIAOnbsCODOc5fWpKWloaqqCn5+fpg9ezZ8fHwk2+3atQu7du1CUVER/P39kZmZ2ez1zMxMBAcHY/78+eaHVUeOHImlS5dKfjCSk5PNr8+aNQt6vR4bNmyQPPa8efOg1+uRn5+PSZMmYf369Thz5oxFu7i4OPPrCQkJ0Ol0WLZsmdTJwCcvDw3V1ZLHM5aW4uulS/H1V18h+Kc/FXZO0aNHo/D992Gy9byinx/iU1Px2d69ts8JQEpKCnQ6HVatWmXus9S6mm7zfXLBOQHA6dOnPeqc1PJ9AmDxc8Ldz0lN36embD3pnJoofU779u3zuHNSy/epiSvPqbi4GDExMZL9AuycHkcJVVVVrR5l/dxzz0kOsJk2bRref/99xMfH49VXX8Xt27cxZcoU9O7dG7///e8l93Xy5ElcunQJH374IUJDQ/GnP/0Jfn5+Vo8tNcw8MzMTCxcubNW5uJrRYMDbgwbZfSVv1tGjwuYvtHVls+n4xu7d8bsDB7gyiyDu9Nl1N8xWHGYrDrMVS4l8W5oeR7EJt1vizFQ8ixYtknyWsEOHDti0aROuXr0KAOZiMjw8HABQX1+PxsbGZs9S9u3bF3379sWpU6dw4MABXLhwAT169Gh139Tuy6wsu4pE4M6VxQNZWcLmL9RoNBiVnY0hc+ZYXfll6cqVLBKJiIgEUW2h6Axb60gnJydjx44d2LRpE4qLiwH8t5pevHgxTp06hdWrV+PGjRv4+OOP0a9fP1RXV+PIkSPw8/PDfffd54IzUI4a5y8UsfILERERtcwjC0VbUlJSUFFRga1btyIwMBCTJ09G//79LdoFBgairKwM+fn50Gg05gEwrVleJzk5WY6uu4S7zV/oTtm6I+YrDrMVh9mKw2zFUmO+qn1G0V25+xJ+q5OSUJqba3f76KQkzDh4UGCPiIiISBSnl/DLzMzEyZMn5exTq504ccJilKA7UOO8SNa42/yF7pStO2K+4jBbcZitOMxWLDXm2+IVxYkTJwIAevbsiSeffBJDhgxBmzayzNNtl8bGRuTm5mL79u3m4ecbN2502fEdJVWZG41GhISEKNMhB6lp1LM93Clbd8R8xWG24jBbcZitWErk6/QVxSbnzp3Dm2++ieeffx7/+Mc/cPHiRTn6Z5Ver8f69evx4osv4s0335Sco8hd6PV6pbtgt5DISMSnpsIvKMhmO7+gIMSnpipaJALula07Yr7iMFtxmK04zFYsNebr8KXBGzduYOvWrZg/fz5eeuklbNiwAWfOnGnV0nZ3a2xsxLlz5/DRRx/h//7v/zB37lxs2bJFcj5Ed2Nt0k61emzJEgyePRshUVGSr4dERWHw7Nl4bMkSF/fMkrtl626YrzjMVhxmKw6zFUuN+To16vmHH37ADz/8gE8++QRarRY9e/ZETEwMunTpgoiICHTo0AGhoaHw9/eHr68v6uvrUVdXh4qKCly/fh1lZWW4ePEiSkpKcPbsWdQ6OOKWxLBn/kKlryQSERGReC0Win5+frh9+3aLO6qrq8OpU6dw6tQpWTpmzd2TYZNY9sxfaDQY8GVWFvR5eWiorYWPvz90iYkYnpGBkMhIF/WUiIiIRGixUHzzzTfx4Ycf4uuvv3ZFf2waOnQopkyZonQ3CLaX1yvNzUXhli2IT03FY0uWcOUUIiIiN9ViodixY0f85je/wZNPPolNmzbh2LFjruhXMwMHDsSECRMQGxvr8mOTtN3p6Tick4Pbt25Jvm4sLcXh/1yNHJWd7cquERERkUzsfkaxR48eeOWVV1BUVIRPP/0Uhw8fdnoAiy1t2rTBww8/jHHjxrFAVBmjwYCCdeusFolNbt+6hYJ16zBkzhw+00hEROSGWr0yy/Xr17Fnzx589dVXsg7n1ul0GDZsGB555BGEhYXJtl9Xcfd5FO2xLS0NR1assLv9oLQ0YWs1e1q2asN8xWG24jBbcZitWGqcR7HVo547dOiAp59+Gk8//TRKSkpw7NgxFBQU4Ny5cw6NXm4aLR0fH4+BAwciJiamtV1SLb1ej969eyvdDdno8/Icam9wsL0jPC1btWG+4jBbcZitOMxWLDXm69T0OE26deuGbt264ac//SlMJhP0ej1KS0tx+fJlXL9+HTU1Naivr4evry/8/f3RoUMHdOrUCVFRUYiKinLpSi9KyM/PV9033hkNDk5jVF9TI6gnnpet2jBfcZitOMxWHGYrlhrzbfWtZ5LW0iVcT7A6KQmlubl2t49OSsKMgwcF9oiIiIhaQ7Yl/Kj11q9fr3QXZKVLTHSofaSD7R3hadmqDfMVh9mKw2zFYbZiqTHfFm89Z2ZmNvtao9Fgzpw5aNeunXmb1CTbcXFx8PWV5c6223PndaqlDM/IQOGWLRbzJ0oJiYrCiIwMYX3xtGzVhvmKw2zFYbbiMFux1Jhvi5WcVBF470ot9xaTALBixQp06tTJia6RWoVERiI+NdXmPIoA4BcUhPjUVE6NQ0RE5KZ4yY9a5bElSwBAcmUW4E6ROOCXvzS3IyIiIvfDZxSpVTQaDR5bsgT3/+xn8AsKsnj99q1bKPzkE+xOTwfHSxEREbmnVl1RrBE43Qm5j93p6Ti+Zg2X8SMiIvJQrbqieOHCBbn74dHi4uKU7oLsHF3Gr7KsTEg/PDFbNWG+4jBbcZitOMxWLDXm2+I8itOnT7e4ghgWFoaf//zniIyMRJs2bSQHs8yZMwft27d3qnN9+vRx6v1K8IZ5FAF1LeNHREREreP0En4hISEWheK1a9ewevVqm+9788037euhFRqNBhs2bHBqH2qxfv16TJo0SeluyEoty/h5YrZqwnzFYbbiMFtxmK1Yasy3xVvPXbt2dUU/LHjSAIiEhASluyA7R5fxqzUahfTDE7NVE+YrDrMVh9mKw2zFUmO+LRaK/fv3d0U/PJpOp1O6C7Lz8fd3qP3V06exa8EC2X8B8MRs1YT5isNsxWG24jBbsdSYb4uF4ogRIxAYGOiKvnisZcuWKd0FC0aDAdvS0rA6KQkrExKwOikJ29LSYDQY7Hq/o8v4Nd6+jcM5Odidnt6a7lqlxmw9CfMVh9mKw2zFYbZiqTHfFgvFoKAg/OpXv3JFX8gFTCYTdi1YgLcHDcKRFStQmpuLsmPHUJqbiyMrVuDtQYPsuvI3PCMDIVFRDh1b9AhoIiIikpdd0+OMGDECs2fPRkhIiOj+kGC709NxOCfH6jrNTXMftnTlr2kZP6nJtm0xlpbiQFaWQ+8hIiIiZdg94fawYcMwePBgHDlyBN999x2uXbuGmpoamEwmyfWge/bsCa1WK2tnyZLRYMCXWVnQ5+WhobYWPv7+0CUm3rniFxlp0daRuQ+HzJljc53mpuX5/r+lS9F4z/rftogaAU1ERETycmhlFq1Wi6FDh2Lo0KHNtk+cONGi7dy5c9GpUyfnekdWmUwm7E5Pl1xruTQ3F4VbtiA+NRWPLVkCjUYDAPgyK8vqlcR7NV35szX3oUajwajsbJz5179w+cQJu/tez5V9iIiI3EKrlvAj5TXdQnZk+TxRcx9qg4Md2q9vQIBD7YmIiEgZrVrCjxyTkpIi6/5au3yeo3Mf2nvlz9ER0JEOtrdF7mypOeYrDrMVh9mKw2zFUmO+slxRXLhwocU2Z5fv8yRyz4vU2lvIjs59aO+Vv+EZGSjcssWuPoVERWFERoZD/bBFjXNOeRLmKw6zFYfZisNsxVJjvrJcUezTp4/Ff76+vKvdZNWqVbLur7W3kEVd+bN3BLRfUBDiU1NtDpBxlNzZUnPMVxxmKw6zFYfZiqXGfDUmT1orTwVaWlxbDisTElB27Jjd7SMGDsSz+fkwGgx4e9Agu6/8zTp61O6iztbgmqb93Tu4hoiIiJTVUt3idc8oVldX44033kBqaipmzpyJTz/91GZ7k8mERYsWYcKECfjDH/7QqmPKXTS29hayyCt/TSOgZx09ikFpaYhOSkLEwIGITkrCoLQ0zDp6FKOys2UvEkUW5MR8RWK24jBbcZitWGrMV9j94draWpSUlMBoNKK6uhoNDQ0O7yM5OVn2fm3YsAEHDx7E+PHjUVJSgg8++ACxsbHo16+fZPvdu3fj+++/d+qY+/fvN1fsctAlJqI0N9fu9nffQm6a+9CeK3+tERwRYXNKHbnJnS01x3zFYbbiMFtxmK1YasxX1kKxsbERe/bswd69e1FUVITGxkan9ieiUNy/fz+io6MxYcIEXLp0CUeOHMHevXslC8Xr16/jgw8+wMSJE/H+++/L3pfWcmbwSNOVvyFz5uBAVhYMeXmor6mBb0AAIhMTMSIjQ9ZnCImIiMh9yVYolpWVYdmyZSgpKZFrl7KrrKxEVVUVevbsCQDo2LEjAKC8vFyy/TvvvIP+/ftj8ODBqioUm24h25pHEbB9C9nVV/6IiIjI/chSKN64cQOvv/46rl69KsfunPbcc8/h2rVrFtunTZvW7Gtb43i+/fZbHDt2DK+99hquXLkC4M7t9GvXriEsLMyi/a5du7Br1y4UFRXB398fmZmZzV7PzMxEcHAw5s+fb34GYeTIkVi6dCkqKyst9pecnGx+fdasWdDr9diwYcN/G/j7AwMHAt98AxiNlicQEoLbDz6Ir/398fV/+hIXF4dJkyZh/fr1SEhIgE6nw7JlyyTPPyUlBTqdDqtWrTL3ef/+/RbtZD2nu8ybNw96vR75+fnmPp85c0ayLQCPOic1fZ8A4PTp0x51Tmr5PgGw+Dnh7uekpu9Tpgf/3FP6nPbt2+dx56SW71MTV55TcXExYmJiJPsFyDTqecWKFThw4ICzu7GwcePGVr2vrKxM8pnIDh064Pnnn0dYWBj++te/4tKlS5g9ezaGDx+O2bNno76+Ho2NjdBqtdi3bx/+9re/Weyjf//+eO2116weW2r0UGZmpuRck3KoLCvz6lvIIrMl5isSsxWH2YrDbMVSIt+WRj07fUWxqqoKX331lbO7kVWEjQIpOTkZO3bswKZNm1BcXAzgvyEtXrwYp06dwurVq9G3b1/MmzcPAHDz5k2sXr0asbGxGD9+vMP9CXZwiTuH9u3lt5BFZkvMVyRmKw6zFYfZiqXGfJ0uFE+ePOn0oBVXSklJQUVFBbZu3YrAwEBMnjwZ/fv3t2jXuXNndO7cGcB/n2Fs3749HnjgAYePOX/+fOc6TVYxW7GYrzjMVhxmKw6zFUuN+TpdKNp6LtHPzw9du3ZF+/btERAQAB8fH8UnW27bti3mzp0r+dqiRYskt4eHh+Ojjz5q9TGbnucg+TFbsZivOMxWHGYrDrMVS435Ol0o1tTUSG4fNGgQXnjhBbRt29bZQxARERGRApwezLJ//36LQR+hoaFYsWIFtFqtU51zR65Ywo+IiIhIDsKX8Lt7OHeTBx54wCuLRGuaphkh+TFbsZivOMxWHGYrDrMVS435Ol0o9urVC506dWq2zZ0Gt7iC1PxGJA9mKxbzFYfZisNsxWG2YqkxX6cLRQB44oknmn199uxZFotEREREbk6WQnH06NGIjY01f33jxg1s2bJFjl0TERERkUJkKRTbtGmDl156CeHh4eZtGzduxAcffGB1VDQRERERqZssaz03rUeYnJyMTZs2mbd/9tln+OKLL/Dggw8iJiYGoaGh8PPzs3u/ycnJcnSPiIiIiFpBlkJRak3kJjU1NTh06BAOHTrk8H49pVD0lPNQI2YrFvMVh9mKw2zFYbZiqTFfp+dRBICJEyfK0RcLGzduFLJfkTiPIhEREbkL4fMoUsvUOC+Sp2C2YjFfcZitOMxWHGYrlhrz5RVFmUlV5kajESEhIcp0yMMxW7GYrzjMVhxmKw6zFUuJfHlFUQX0er3SXfBYzFYs5isOsxWH2YrDbMVSY74sFF1gw4YNSnfBYzFbsZivOMxWHGYrDrMVS435yjLqWY2jdIiIiIjIObIUii+88IIcuyEiIiIiFeGtZyIiIiKSJMsVRVI/o8GAL7OyoM/LQ0NtLXz8/aFLTMTwjAyEREYq3T0iIiJSIRaKHs5kMmF3ejoK1q2DsbS02Wulubko3LIF8ampeGzJEmg0GoV6SURERGokyzyK9F9qm0dx14IFOJyTg9u3bllt4xcUhMGzZ2NUdrYLeyYPzuklFvMVh9mKw2zFYbZiqXEeRbuuKF65ckWu/jikU6dOihxXbnq9Hr1793b5cY0GAwrWrbNZJALA7Vu3ULBuHYbMmYPgiAgX9U4eSmXrLZivOMxWHGYrDrMVS4352lUovvjii6L7YUGj0ahyPqHWyM/PV+Qb/2VWlsXtZmuMpaU4kJWF0Tk5/93mBs81KpWtt2C+4jBbcZitOMxWLDXma9etZ1FL9LXEU5bwU8rqpCSU5uba3T46KQkzDh60+VwjAIRERfG5RiIiIg/AJfxUYP369Yoct6G21qH29TU1AIDd6ek4nJNj9WqksbQUh3NysDs93ek+OkupbL0F8xWH2YrDbMVhtmKpMV8Wii5w5swZRY7r4+/vUHvfgACHn2usLCtzpotOUypbb8F8xWG24jBbcZitWGrMl4WiB9MlJjrUPjIxsVXPNRIREZFnYqHowYZnZCAkKsqutiFRURiRkQF9Xp5DxzA42J6IiIjcBwtFDxYSGYn41FT4BQXZbOcXFIT41FQER0S0+rlGIiIi8jx2TY/z/PPPi+4HCfLYkiUAYNcIZqB1zzUSERGRZ7KrUGwaOk2tExcXp9ixNRoNRmVnY8icOTiQlQVDXh7qa2rgGxCAyMREjMjIaDbJti4x0aEpdSIdfA5Sbkpm6w2YrzjMVhxmKw6zFUuN+XIJP5mpaR7F1jAaDHh70CC7BrSEREVh1tGjbreaCxEREd3BeRRVQI3zIlnTmucaleRO2boj5isOsxWH2YrDbMVSY7523Xom5yQkJCjdBYc4+lyjktwtW3fDfMVhtuIwW3GYrVhqzJeFogvodDqlu+AQR59rVJK7ZetumK84zFYcZisOsxVLjfny1rMLLFu2TOkutEpwRARG5+RgxsGDeDY/HzMOHsTonBzVFImA+2brLpivOMxWHGYrDrMVS435et0VxerqaqxcuRJ5eXkICAjA2LFjMW7cOMm2ixYtwqlTp8xft23bFmvXrnVRT4mIiIiU5XWF4oYNG3Dw4EGMHz8eJSUl+OCDDxAbG4t+/fpJto+KisL48eMBAL6+ysdlNBjwZVYW9Hl5aKithY+/P3SJiXdWYYmMVLp7RERE5EGUr3xcbP/+/YiOjsaECRNw6dIlHDlyBHv37rVaKLZr1w4JCQkIDAx0cU+bM5lM2J2eLjnApDQ3F4VbtpgHmGg0GoV6SURERJ7EqwrFyspKVFVVoWfPngCAjh07AgDKy8utvue7777D9OnTERgYiKeeego///nPJdvt2rULu3btQlFREfz9/ZGZmdns9czMTAQHB2P+/PnmuYpGjhyJpUuXorKy0mJ/ycnJ5tdnzZqF7fPn47u1a4HbtyWPbywtxcG//hUAcDk+HmfOnLFoExcXh0mTJmH9+vVISEiATqez+jxESkoKdDodVq1aZe7z/v37Ldo5c056vR4bNmyQPP68efOg1+uRn59v7rPUOTXxpHNS0/cJAE6fPu1R56SW7xMAi58T7n5Oavo+NWXrSefUROlz2rdvn8edk1q+T01ceU7FxcWIiYmR7BfgoRNuP/fcc7h27ZrF9mnTpuH9999HfHw8Xn31Vdy+fRtTpkxB79698fvf/96i/fbt2xESEgJfX1989NFHuHjxIjIzM/HAAw9YPbbUxJWZmZlYuHBhq8+Hk2Bb52y2ZBvzFYfZisNsxWG2YimRb0sTbnvkFcVFixahoaHBYnuHDh2wadMmXL16FQDMxWR4eDgAoL6+Ho2NjdBqtQCAJ554wvze69evY82aNbh48aLNQlFKSkpKq86jyZdZWXYVicCdK4sHsrIwOifHqWO6C2ezJduYrzjMVhxmKw6zFUuN+XpkoRhh42pacnIyduzYgU2bNqG4uBjAf6vpxYsX49SpU1i9ejV8fX3xxz/+EYMHD4ZWq8W2bdug0WjQo0cPh/vj7LxI+rw8h9oXbt6MJ5Yv94pnFdU455QnYb7iMFtxmK04zFYsNebrdfMopqSkICkpCVu3bsWZM2cwefJk9O/f36Kdr68vQkNDsWXLFqxduxZ+fn5IS0tDbGysw8dctWqVU31uqK11qL3RYMDu9HSnjukunM2WbGO+4jBbcZitOMxWLDXm65HPKCqppXv9rbE6KQmlubkOvcfbnlUkIiIix7VUt3jdFUUlOFs06hITHX5P07OKnk7OgpwsMV9xmK04zFYcZiuWGvNloegCUkPcHTE8IwMhUVEOv8/g4LON7sjZbMk25isOsxWH2YrDbMVSY74sFN1ASGQk4lNTgTaOfbvqa2oE9YiIiIi8AQtFN/HYkiUOP2/oGxAgqDdERETkDVgougmNRoMHfvYzh94T2YpnG4mIiIiasFB0I448qxgSFYURGRmCe0RERESejIWiCwQHB8uyn6ZnFf2Cgmy28wsKQnxqqldMjSNXtiSN+YrDbMVhtuIwW7HUmC/nUZSZiHkU72YymbA7PR0F69ZJLusXEhWF+NRUPLZkiVeszEJEREStx3kUVUDOolGj0WBUdjZmHT2KQWlpiE5KQsTAgYhOSsKgtDTMOnoUo7KzvaZIVOOcU56E+YrDbMVhtuIwW7HUmK9HrvXsDYIjIjA6J0fpbhAREZEH461nmYm+9UxEREQkF956VoGlS5cq3QWPxWzFYr7iMFtxmK04zFYsNebLQtEFKisrle6Cx2K2YjFfcZitOMxWHGYrlhrzZaFIRERERJJYKBIRERGRJBaKRERERCSJo55lFh0djcrKSgwYMMC8rbi4GDExMYr1yZMxW7GYrzjMVhxmKw6zFUuJfI8fP47g4GBcvHhR8nXOoyizzp07W2xr166dAj3xDsxWLOYrDrMVh9mKw2zFUiLf4OBgydqlCa8ousArr7yCP/zhD0p3wyMxW7GYrzjMVhxmKw6zFUuN+fIZRSIiIiKSxEKRiIiIiCSxUHSBUaNGKd0Fj8VsxWK+4jBbcZitOMxWLDXmy2cUiYiIiEgSrygSERERkSROjyOD6upqrFy5Enl5eQgICMDYsWMxbtw4i3aVlZXIyclBUVERqqur0a1bN8yYMQOxsbEAgMLCQqxevRp6vR5dunTBs88+a37NW9mbLQB88skn+Pzzz3H16lV06dKl2eLqK1aswP79+5u1X7NmDYKCgoT2X83kyvbatWv4+9//jpMnT6Jdu3ZISUnBiBEjXHUaquRIthcvXsTf//53FBUVoXPnzvjVr36FBx98EADw4osv4vLly+a23bp1w5///GeXnIPa2Pvz8YsvvsDHH38Mo9GIBx98EM8//zxCQkIAAJs2bcKOHTtQV1eHIUOGYObMmdBqta4+FVVyNt+TJ08iMzOzWdvp06fjySefdNUpqJY92dbV1eEPf/gDzp49i9raWkydOrXZz4zDhw9j3bp1uHbtGnr16oUXXngB4eHhLuk/ryjKYMOGDTh48CDGjh2LuLg4fPDBBzhx4oRFu6qqKly7dg1PPfUUnnrqKZw7d878D25dXR2WLl2K6upqTJ8+HTdu3MCyZcvQ2Njo6tNRFXuzBYCGhgYMHz7c6r5CQkIwZ84c83/+/v6iuu0W5Mp29erVOHHiBCZNmoTOnTtjxYoVKCsrE9l11XMk2zfffBOlpaWYNm0afH19sWzZMlRVVZlff+CBB8yf2SlTprjqFFTF3p+P58+fx9tvv42oqChMmDAB+fn5eO+99wDc+Yd206ZN6N+/P5544gns378fn3zyiRKnozpy5Nvk6aefNn9eBw4c6MrTUCV7s21sbERwcHCzxTqa3LhxA2+++Sbatm2LqVOnoqioCCtWrHDRGbBQlMX+/fsRHR2NCRMmYNq0aQCAvXv3WrTr2LEj/vjHP2LMmDH4xS9+gZiYGFy+fBm1tbU4fvw4Kioq8Pjjj+Pxxx/Ho48+ivLycpw8edLVp6Mq9mYLAOPHj8fkyZOt7isgIACJiYn40Y9+hKFDh8LX17svqMuRbWVlJfLy8tC/f3/z59pkMmHfvn0iu6569mZ7/vx5lJSUYOjQofjJT36CJ598EtXV1cjNzTW3CQ8PR0JCAoYOHSr5j4g3sPfnY9PnbtKkSXjqqafQu3dvfP3116irqzO/9qtf/QqTJ09Gx44dvf5z2kSOfJs88MADGDRoEIYOHQqdTufK01Ale7MNCAjAvHnzkJiYaLGPr776Crdv38ZPf/pTPPHEExg8eDC+++47l/1CzkLRSZWVlaiqqkJYWBiAO8UgAJSXl1u09fHxQZs2dyK/fPky9Ho9YmNj4e/vb25/734uXbok/BzUypFs7XHlyhVMmzYNU6dOxTvvvOPVV2vlyra8vBwmk8m8n6b/t/Z75Akcydaev/cHDhzA9OnT8etf/xp79uwR2ne1svfn473twsLC0NDQgKtXr6K8vBw+Pj4IDQ017+PatWuor693yTmomRz5NsnKykJqaioyMjKg1+uF913t5Pi3XSr3u7eL5t2XVBzw3HPP4dq1axbbm64WNLFnEPmNGzeQnZ0NX19fvPjii5JtvGkwupzZWtOvXz/07dsXQUFB+Oyzz7Bz50706tXL45+lc0W23kpEtve2feyxx6DT6VBXV4d//OMfWLVqFfr16+eyZ5PUyt5MbbXjZ9661uTbrl07TJ06FVFRUThz5gw++eQTrF69Gr/73e9EddMtuePnjoWinRYtWoSGhgaL7R06dMCmTZvMv1E1/cPR9IO8vr4ejY2N5gemr127htdffx0VFRV49dVX0aVLl2bt793PfffdJ/Cs1EGubG1JTk42/1mj0aCwsNDqAuieRHS24eHh0Gg05vffux9PJke2Tdvuza/p7/3Pf/5z836Li4vxr3/9C3q93ivyvZutn491dXVo06YNfH19m+UZFhaG69evw8fHBx07dkR4eDguXLiAiooKtGvXztzG2x9BAeTJV6vVIjo6GgCQmJiIL774wit+xrbE3mxbsw9X/Rzg3xA7RUREWH0tOTkZO3bswKZNm1BcXAwAGDlyJABg8eLFOHXqFFavXg2tVovMzEwYDAaMGzcOZWVlKCsrQ2JiIgYMGIB27drh888/R2BgIPbs2YPOnTujb9++Ljg7ZcmRbWhoKE6dOgWDwQDgzu2/3bt3o3v37oiNjUVmZiYGDBiAkJAQ7Ny5EwDQs2dPoeelBq7INiEhAd988w3+9a9/4ciRI9BoNM0Kc08lR7bdu3dHt27d8PXXXyM6OhpffPEFAgMD8fDDD6OkpATr16/HgAED0NjYiP3790Or1aJr164uODt1sfbzsXPnzpg6dSoSEhLwyiuvIDk5Gdu3b8f69esRHx+P06dPY+jQodBqtUhOTsbRo0exZs0ahIeH4+rVq80KcW8mR77//Oc/UVlZiW7duuH7779HZWUlHnroIaVPTXH2ZgsAu3fvxunTpwEA586dw+7duzF06FAMHToU//jHP7B161ZUVFTg8OHDuP/++23+DJITC0UZpKSkoKKiAlu3bkVgYCAmT56M/v37W7S7efOm+R/bTz/91Lz9rbfeQnh4OObOnYt33nkHa9asMQ+hb3qm0VvZmy1wZ7BA0xQ4169fx8qVKzF+/HjExsYiIiICO3bswM2bNxEWFoZp06Zh8ODBrjwV1ZEr25kzZ+L//b//h/Xr1yM0NBQvvPACIiMjXXkqquNItr/5zW/w97//He+//z46d+6MuXPnIigoCHV1dTCZTNi0aRNqa2sRHR2NlJQU8/NJ3kSr1dr18zE2NhYzZszA5s2bUVhYiAEDBmD69OkAgIcffhhPP/00Pv/8c9TV1WHEiBEsFP9Djnyjo6Px8ccfY/fu3dBqtfjRj36EZ555RoGzURd7swWAlStXmv+cm5uL3Nxc9O/fH+Hh4ZgzZw4++OADrFu3Dr169cLzzz/vsnPgyixEREREJMm7L1cRERERkVUsFImIiIhIEgtFIiIiIpLEQpGIiIiIJLFQJCIiIiJJLBSJiIiISBILRSIiIiKSxAm3iUioyspKHDhwACdOnEBJSQkqKytRU1NjseZpnz59sGjRIqv7uXLlCn7729+irq6u2fYHHngAmZmZIrpO5FIfffQR/vnPf1psnzdvHoYMGaJAj4hYKBK5hX379uFvf/ub1debVvdRmwMHDuCdd95BdXW10/v6xz/+YVEkAsD48ePt3sfatWuxbds2m218fHzg4+MDrVaLwMBABAcHm9cKjomJwYMPPogOHTo43H9vxtztM3r0aPz73/+2+Pvy4Ycf4qGHHuK61KQIfuqISIivvvoKb731liz7+v777/H1119bbO/Zs6fVpfGknD9/vsU2DQ0NaGhoQF1dHSorK3H58uVm79NoNOjXrx8eeeQRDBs2zO5jezPmbp/g4GD8+Mc/brbEKwBcunQJO3bswJgxYxTqGXkzPqNIRLKrra3FmjVrZNvfpk2bLG5VA3euwNjLZDKhpKTE6b6YTCZ8++23WL58ORYvXozLly87vU9Pxtwd85Of/ERyHeCtW7dKXlEnEo2FIhHJ7siRIzAajbLsq6ioCPn5+Rbb27dv79BzW+Xl5aiqqpKlT00KCgrwyiuvoLS0VNb9ehLm7phOnTrhoYcestheUVGBzz//XIEekbfjrWcikl1hYaHV1zp06IDU1FR069YN/v7+5u1arVay/b234ZqMGDHCoWe27Ln92RpGoxGLFy9GVlYWwsLChBzDnTF3xz366KM4fPiwxfZt27Zh9OjRklcciUThp42IZHft2jWrrz399NMYNmwYunTpgvDwcPN/7du3l9zPoUOHJPczYsQIh/pUXFzsUHtHXL16FWvXrhW2f3fG3B334IMPol27dhbbr1y5gqNHjyrQI/JmvKJIRLKzNco5IiLC7v3s3bsXDQ0NFtu7dOmCrl27OtQnWwVL586dsWLFCgB3noWrrq7GzZs3UVxcjPz8fBw8eLDF58Nyc3Nx5swZxMXFOdQvT8fcHefj44MhQ4Zg586dFq998cUXGDx4sAK9Im/FQpGIANz5h/rs2bPQ6/W4ceMG/P390bFjR/Tt2xdBQUEO78saHx8fu/fz1VdfSW5PTEx0qD+A7YKle/fu5j9rNBq0bdsWbdu2RUREBIYMGYKJEyfirbfewsmTJ20eY+fOnR5VsMiBubdOYmKiZKH47bffoqKiQvKKI5EILBSJPNiKFSuwf/9+yddeeOEFjBw5Eo2Njdi2bRu2b98uOZK0TZs2GDZsGKZMmWJ1HruTJ0/aPem1tXYLFy5E3759zV8XFxdbHayQkJBg17Ga3Lx50+bt8NjYWJvv79ixIxYsWIDXX38dZ86csdru+PHjaGxsdKtnyHJzc9G1a1fodDrZ983cW69fv37w9/dHbW1ts+2NjY3Izc3F448/rlDPyNt4zt8qInLYlStXkJGRgffff9/qdCONjY04cOAA0tPTYTAYXNa348ePS27XarXo2bOnQ/tq6Tm5u69sWaPVajFz5kxoNBqrbYxGo9Bn8uT21Vdf4Y033kBmZib0er3s+2furefr64tevXpJvnbs2DEX94a8GQtFIi91+fJlLFq0CN9//71d7a9evYply5ahvr5ecM/u+OabbyS39+zZ0+EVKloaeWtPwQIA3bp1a/EqmK0raGrSNCF6Y2Mjrl+/LqRYZO7Ouf/++yW3nzx50mV/D4lYKBJ5qX/+858oLy936D0lJSXYu3evoB79V2NjI86dOyf5WkxMjMP7s3W1qUOHDpIjrq3p3bu3zddv3rxp976UdPLkSTQ2Npq/FlEsMnfnWPus19bW4sKFC67tDHktFopEXuruASft2rXDQw89hIcffhghISE237dnzx7RXYNer7d4NqtJly5dHN6fvQMq7NHSIIKamhqH9qeUmTNn4pFHHmm2Te5ikbk7x9bI/qKiIhf2hLwZB7MQebkJEybgZz/7mXk0cm1tLZYvX44jR45Iti8qKkJNTQ0CAgLM23r16tVsXec333wTZ8+elXz/nDlzJJ+9uvvqkq0VN+677z6b53Ov2tpam4WPowXL3VfhpNydi5q1adMGzz33HDQaTbPiv6lYXLhwoVMDXJi78zp37gyNRiM5i8APP/ygQI/IG7FQJPJiY8aMwfjx45tt8/f3xwsvvIBZs2bh9u3bFu9pWrv37luBWq0W4eHh5q/9/PysHrN9+/bN2kqxtY6vo6twlJSU2Jyux9GCpaWlCUNDQyW3l5eXIy0trdm22NhY/OEPf3Do+HLSaDR49tlnAUD2YlEtubszHx8fhIaGoqKiwuK1K1euKNAj8kYsFIm8lL+/P37xi19IvhYUFISuXbtaHegi1zrO1ly/ft3qa44WBHKMvL2brSIWgNXCSmp6F2ujWq1ZtGgRTp065dB7Wuv69etYtGgRFi5ciKioKIffr5bc3V27du0kC0Vbf0eI5MRCkchLPfjggwgMDLT6urU5EwGgqqpKRJfMrD2fCFhfE9oaWwVLSEgIOnfubPe+GhsbbRZqTZNFS5G6Fe9ooehqN27cwL59+zBlyhSH36uW3E0mE5555plmqwX5+/vjvffeEzrvolzHtfZ598RnMkmdWCgSeamWruj4+/tbfa2l58WcJXXLu4mcU+M4OoL6zJkzuHXrltXX+/XrZ7UI0Ol0GD16dLNtd08w7mnUkntpaanFkpIxMTHCJ+eW67jWHuOw9XeESE4sFIm8VEujmx1Zak9utorB+vp6u68qNjY22nzo39Hbn5s3b7b5uq01eN11JY3WDBJRU+5S0yz16NHDoeO3hlzHtVYQ2noOmEhOLBSJvFRLxZatlTBEs3U1s66uzu5CsbS0FHV1dVZfb2kS57sdO3bM6moxwJ3nOocMGWL3/lrj/vvvR9u2bWXfr9FoxOnTpy22JyQkYNy4cQ7vT025SxVsjq7s0xpyHddajrb+jhDJiYUiEamOrecjb968ieDgYLv209KACntvger1eixfvtxmmyeeeMJqASu1FvbDDz+M+fPn23X8JikpKQ61t0dFRYXk+tsDBw7E/PnzW3XlSuncz5w5g1dffdXqe5YvX26x3zfeeMM8IKa2thZff/018vPzceHCBVRUVKCurg5t27ZFcHAw2rVrh5iYGPTs2RMPPPCA+XlLZ48rRWogCwCHJisncgYLRSJSHVsDHa5du2b3CFdbz8kFBgYiMjKyxX0UFhbir3/9q81n5EJCQjBmzBirr0sVTq1ZYUZuTUXixYsXm20fOHAgXnrppVbf3lQ6d0fXfb67TydOnEBOTo7kqGKj0Qij0QiDwYDCwkIAwE9+8hP86le/cvq4UhoaGqyuOOPIYCAiZ7BQJCLVsVUIXrp0Cf369bNrPyUlJVZfi4mJsXl7/ebNm/jXv/6Fzz77DA0NDTaPM2PGDJu3hNVYKIoqEgHlc3e0YGvq04ULF5Cdne3QQJG7v4+tPa41ly5dsjoXZWumLCJqDRaKRKQ60dHR0Gq1ks9n3VvY2GLvEnL19fWorKxERUUFzp49ixMnTiAvL8/mND1NHnnkEfzoRz+y2UaqcFK6UFy+fLmQIhFQPveuXbti9OjRKC4utphWp1evXhbTEsXFxQG4M2jm3iJRp9OhZ8+eCAwMRFVVFQwGA0pKSsztunXr5vRxrbE1IMiR5zyJnMFCkYhUp02bNujZs6fk3Hn2XrW5cuWKzYnBt23bhm3btrW2iwCA/v37Y+bMmTbb1NfXWxRkISEh6Nixo1PHdtaMGTOQmZlpvsU6YMAAWYpENeT+k5/8BACwdu1ai8/Qj3/8Y4wcOVLyffcO6Hn00Ufx3HPPWbSrra3Ft99+i3379jVbe7y1x7XG2mfdz8+vWYFKJJLYiaSIiFopPj5ecvu5c+dQX1/f4vsdvQ3oqIceeggvv/xyi/M6Xrx40aK/Sl9NBO5cKVu0aBHCwsIwYMAA/O///q8sU66oJXfA8Su5917Bvnr1quS64/7+/njooYfw0ksvSQ5gkusKctNzkPfq06ePwxPPE7UWrygSkSolJCRgw4YNFttra2tRVFTU4m07UQWLRqPBz372M0yYMMGuyZOl+qGWq0GRkZH4/e9/j/bt28s2L59acgcsCzYfHx9ER0dbbd+lS5dmVwK/+eYbzJ07F+3atUNsbCx69+6NxMTEFr9/jh5XSn19veQUO8Cdq79ErsJCkYhUKSYmBjqdDnq93uK1/Pz8FgtFWyNvW6tHjx741a9+5dDSe2p8PvFuco+eVUvuV69eRWVlZbNtUVFRNq9E/vznP0dhYaHFykMVFRU4duwYjh07hg0bNqBHjx745S9/KfkZbM1xpZw4cULyWU2NRoOkpCSH9kXkDN56JiLVGjZsmOT2vLy8Ft8r15Utf39/DBkyBK+++iqys7MdXp9ZjSOeRVJL7lIFektXAuPj47FgwYIWRxR///33yMzMRFFRkSzHlXL06FHJ7f369UNYWJjD+yNqLV5RJCLVevTRR/Hxxx9bTJNSUlKCixcvWr2dd+vWLVy+fNnmvjUaDXx8fODj4wOtVttsMuVOnTohIiICPXr0QI8ePZx6HuzewsHPz89jpzZRU+6tveX/4IMPYtmyZTh79iwKCgrw/fff4+zZsxbzGd6+fRvbtm1DWlqaLMe9W0NDAw4dOiT52qhRoxzaF5GzWCgSuYGRI0c6PGISAF588UW8+OKLrTqmM+9dtGhRq953r7CwMDz88MM4ePCgxWsHDhzA5MmTJd8XFBSEjz76SJY+OOPKlSsWtyG7dOmi6DraIqkldwC4cOGCxTZ7CzaNRoO4uDjzrWWTyYS8vDz86U9/atZOqih25rhNjh8/LrkiS8eOHW2ua00kAm89E5GqjR07VnL7/v37W5yQWWnedttZTaSKOGuTW9+8eRPp6en46quvUF1dLfm+8PBwi/dLLaPnyHGt2bt3r+T20aNHe+wvGaRevKJIRKrWo0cPDBw4EMeOHWu2/fr168jNzcXQoUMV6lnLWCgqR2pFk5ycHCQmJiIgIADAnQnGH3zwQRQXF+PcuXNYvnw5fH190aVLF0RGRiI4OBiNjY24cuUKTp48abHPxMREp44r5fLly5LPJ7Zr1w7/8z//0/KJE8mMhSIRqd6ECRNw/Phxi3+Et23bxkKRJHXt2tViepmKigrs2bPH/HXTreW7v0/19fU4f/58i6O3+/btKznYypHjStm5c6fFqGsAeOqpp+Dv72+zT0Qi8NYzEalejx49JAvCs2fP4ttvv1WgR/a5dyCLRqNRzRyKnm7s2LEIDAy02aZpGTxbS+XdS6PRYMSIEXjllVck53N05Lj3qqysxBdffGGx/b777sPjjz9udx+J5MQrikTkFiZPnozDhw9brJ7xz3/+E/3791eoV9ZVV1ejvLy82bbw8PAWiwiSR1RUFLKysrB582acPHkSFRUVza7UtW3bFvfddx8AYNasWRgxYgS+++47FBUVoaysDNevX0dtbS18fHzQtm1b6HQ69O7dG8OGDUPXrl1lOe69tm3bJvmM5JQpU2SbEJ3IURqT1AMVREREROT1eOuZiIiIiCSxUCQiIiIiSSwUiYiIiEgSC0UiIiIiksRCkYiIiIgksVAkIiIiIkksFImIiIhIEgtFIiIiIpL0/wOhl172rtm/RgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setting a larger default font size\n",
    "import matplotlib as mpl\n",
    "mpl.rcParams.update({'font.size': 40, 'font.weight': 'bold'})\n",
    "plt.style.use('ggplot')\n",
    "# Initialize a list to keep all the correlation coefficients\n",
    "cor_score_lst = []\n",
    "\n",
    "array1 = np.array(loo_score)\n",
    "array2 = np.array(dual_loo_score)\n",
    "\n",
    "# Calculate the correlation coefficient\n",
    "correlation_coefficient, _ = pearsonr(loo_score, dual_loo_score)\n",
    "\n",
    "# Print the correlation coefficient\n",
    "print(f\"Correlation Coefficient for{correlation_coefficient}\")\n",
    "\n",
    "# Scatter plot\n",
    "plt.figure(figsize=(10, 6))\n",
    "ax = plt.gca()  # Get the current Axes instance\n",
    "ax.set_facecolor('none')  # Removing background color\n",
    "#     ax.spines['top'].set_color('none')\n",
    "#     ax.spines['right'].set_color('none')\n",
    "\n",
    "# Making all spines visible to create a box\n",
    "for spine in ax.spines.values():\n",
    "    spine.set_visible(True)\n",
    "    spine.set_color('black')\n",
    "    spine.set_linewidth(1.5)\n",
    "\n",
    "# Making grid lines visible\n",
    "ax.grid(True, which='both', axis='both', color='grey', linestyle='-.', linewidth=1.0)\n",
    "\n",
    "# Scatter plot adjustments\n",
    "plt.scatter(array1, array2, c='maroon', marker='o', s=150, label='values')\n",
    "# plt.title('CIFAR10 [Non-convex]', fontsize=40, fontweight='bold')    \n",
    "# Updating axis labels with new notation\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",
    "# Correcting the missing parenthesis\n",
    "plt.show()  # Show the plot\n",
    "    \n",
    "plt.show()  # Show the plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spearman Rank Correlation Coefficient: 0.9550611790878754\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": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearson Correlation Coefficient: 0.8971\n",
      "Spearman Correlation Coefficient: 0.9551\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()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearson Correlation Coefficient: 0.8971\n",
      "Spearman Correlation Coefficient: 0.9551\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",
    "# 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
}