CNN_training_validation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports \n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.init as init\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from utills import set_seed\n",
    "import pickle\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_seed()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading Data\n",
    "We are using our data_setup python script to load digital modulations from RML2016.10a Dataset\n",
    "and also creating train and test splits  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape of the train and test **samples** are --> ((128000, 2, 128), (32000, 2, 128))\n",
      "shape of the train and test **labels** are --> ((128000, 2), (32000, 2))\n"
     ]
    }
   ],
   "source": [
    "from data_setup import load_data , load_digital_mods\n",
    "\n",
    "data = load_data(path='RML2016.10a/RML2016.10a_dict.pkl')\n",
    "X_train , y_train , X_test , y_test, mods = load_digital_mods(data=data , ratio= 0.2)\n",
    "print(f\"shape of the train and test **samples** are --> {X_train.shape , X_test.shape}\")\n",
    "print(f\"shape of the train and test **labels** are --> {y_train.shape , y_test.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fitting a label encoder\n",
    "Fitting a label encoder inorder to convert the labels into integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dict, numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data) , type(X_train), type(y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-2 {\n",
       "  /* Definition of color scheme common for light and dark mode */\n",
       "  --sklearn-color-text: black;\n",
       "  --sklearn-color-line: gray;\n",
       "  /* Definition of color scheme for unfitted estimators */\n",
       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
       "  --sklearn-color-unfitted-level-3: chocolate;\n",
       "  /* Definition of color scheme for fitted estimators */\n",
       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
       "\n",
       "  /* Specific color for light theme */\n",
       "  --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n",
       "  --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n",
       "  --sklearn-color-icon: #696969;\n",
       "\n",
       "  @media (prefers-color-scheme: dark) {\n",
       "    /* Redefinition of color scheme for dark theme */\n",
       "    --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n",
       "    --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n",
       "    --sklearn-color-icon: #878787;\n",
       "  }\n",
       "}\n",
       "\n",
       "#sk-container-id-2 {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 pre {\n",
       "  padding: 0;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 input.sk-hidden--visually {\n",
       "  border: 0;\n",
       "  clip: rect(1px 1px 1px 1px);\n",
       "  clip: rect(1px, 1px, 1px, 1px);\n",
       "  height: 1px;\n",
       "  margin: -1px;\n",
       "  overflow: hidden;\n",
       "  padding: 0;\n",
       "  position: absolute;\n",
       "  width: 1px;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-dashed-wrapped {\n",
       "  border: 1px dashed var(--sklearn-color-line);\n",
       "  margin: 0 0.4em 0.5em 0.4em;\n",
       "  box-sizing: border-box;\n",
       "  padding-bottom: 0.4em;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-container {\n",
       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
       "     so we also need the `!important` here to be able to override the\n",
       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
       "  display: inline-block !important;\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-text-repr-fallback {\n",
       "  display: none;\n",
       "}\n",
       "\n",
       "div.sk-parallel-item,\n",
       "div.sk-serial,\n",
       "div.sk-item {\n",
       "  /* draw centered vertical line to link estimators */\n",
       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
       "  background-size: 2px 100%;\n",
       "  background-repeat: no-repeat;\n",
       "  background-position: center center;\n",
       "}\n",
       "\n",
       "/* Parallel-specific style estimator block */\n",
       "\n",
       "#sk-container-id-2 div.sk-parallel-item::after {\n",
       "  content: \"\";\n",
       "  width: 100%;\n",
       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
       "  flex-grow: 1;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-parallel {\n",
       "  display: flex;\n",
       "  align-items: stretch;\n",
       "  justify-content: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  position: relative;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-parallel-item {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-parallel-item:first-child::after {\n",
       "  align-self: flex-end;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-parallel-item:last-child::after {\n",
       "  align-self: flex-start;\n",
       "  width: 50%;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-parallel-item:only-child::after {\n",
       "  width: 0;\n",
       "}\n",
       "\n",
       "/* Serial-specific style estimator block */\n",
       "\n",
       "#sk-container-id-2 div.sk-serial {\n",
       "  display: flex;\n",
       "  flex-direction: column;\n",
       "  align-items: center;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  padding-right: 1em;\n",
       "  padding-left: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
       "clickable and can be expanded/collapsed.\n",
       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
       "*/\n",
       "\n",
       "/* Pipeline and ColumnTransformer style (default) */\n",
       "\n",
       "#sk-container-id-2 div.sk-toggleable {\n",
       "  /* Default theme specific background. It is overwritten whether we have a\n",
       "  specific estimator or a Pipeline/ColumnTransformer */\n",
       "  background-color: var(--sklearn-color-background);\n",
       "}\n",
       "\n",
       "/* Toggleable label */\n",
       "#sk-container-id-2 label.sk-toggleable__label {\n",
       "  cursor: pointer;\n",
       "  display: block;\n",
       "  width: 100%;\n",
       "  margin-bottom: 0;\n",
       "  padding: 0.5em;\n",
       "  box-sizing: border-box;\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 label.sk-toggleable__label-arrow:before {\n",
       "  /* Arrow on the left of the label */\n",
       "  content: \"▸\";\n",
       "  float: left;\n",
       "  margin-right: 0.25em;\n",
       "  color: var(--sklearn-color-icon);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {\n",
       "  color: var(--sklearn-color-text);\n",
       "}\n",
       "\n",
       "/* Toggleable content - dropdown */\n",
       "\n",
       "#sk-container-id-2 div.sk-toggleable__content {\n",
       "  max-height: 0;\n",
       "  max-width: 0;\n",
       "  overflow: hidden;\n",
       "  text-align: left;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-toggleable__content.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-toggleable__content pre {\n",
       "  margin: 0.2em;\n",
       "  border-radius: 0.25em;\n",
       "  color: var(--sklearn-color-text);\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-toggleable__content.fitted pre {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
       "  /* Expand drop-down */\n",
       "  max-height: 200px;\n",
       "  max-width: 100%;\n",
       "  overflow: auto;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
       "  content: \"▾\";\n",
       "}\n",
       "\n",
       "/* Pipeline/ColumnTransformer-specific style */\n",
       "\n",
       "#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator-specific style */\n",
       "\n",
       "/* Colorize estimator box */\n",
       "#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-label label.sk-toggleable__label,\n",
       "#sk-container-id-2 div.sk-label label {\n",
       "  /* The background is the default theme color */\n",
       "  color: var(--sklearn-color-text-on-default-background);\n",
       "}\n",
       "\n",
       "/* On hover, darken the color of the background */\n",
       "#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "/* Label box, darken color on hover, fitted */\n",
       "#sk-container-id-2 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
       "  color: var(--sklearn-color-text);\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Estimator label */\n",
       "\n",
       "#sk-container-id-2 div.sk-label label {\n",
       "  font-family: monospace;\n",
       "  font-weight: bold;\n",
       "  display: inline-block;\n",
       "  line-height: 1.2em;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-label-container {\n",
       "  text-align: center;\n",
       "}\n",
       "\n",
       "/* Estimator-specific */\n",
       "#sk-container-id-2 div.sk-estimator {\n",
       "  font-family: monospace;\n",
       "  border: 1px dotted var(--sklearn-color-border-box);\n",
       "  border-radius: 0.25em;\n",
       "  box-sizing: border-box;\n",
       "  margin-bottom: 0.5em;\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-estimator.fitted {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-0);\n",
       "}\n",
       "\n",
       "/* on hover */\n",
       "#sk-container-id-2 div.sk-estimator:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
       "}\n",
       "\n",
       "#sk-container-id-2 div.sk-estimator.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-2);\n",
       "}\n",
       "\n",
       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
       "\n",
       "/* Common style for \"i\" and \"?\" */\n",
       "\n",
       ".sk-estimator-doc-link,\n",
       "a:link.sk-estimator-doc-link,\n",
       "a:visited.sk-estimator-doc-link {\n",
       "  float: right;\n",
       "  font-size: smaller;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1em;\n",
       "  height: 1em;\n",
       "  width: 1em;\n",
       "  text-decoration: none !important;\n",
       "  margin-left: 1ex;\n",
       "  /* unfitted */\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted,\n",
       "a:link.sk-estimator-doc-link.fitted,\n",
       "a:visited.sk-estimator-doc-link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
       ".sk-estimator-doc-link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover,\n",
       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
       ".sk-estimator-doc-link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "/* Span, style for the box shown on hovering the info icon */\n",
       ".sk-estimator-doc-link span {\n",
       "  display: none;\n",
       "  z-index: 9999;\n",
       "  position: relative;\n",
       "  font-weight: normal;\n",
       "  right: .2ex;\n",
       "  padding: .5ex;\n",
       "  margin: .5ex;\n",
       "  width: min-content;\n",
       "  min-width: 20ex;\n",
       "  max-width: 50ex;\n",
       "  color: var(--sklearn-color-text);\n",
       "  box-shadow: 2pt 2pt 4pt #999;\n",
       "  /* unfitted */\n",
       "  background: var(--sklearn-color-unfitted-level-0);\n",
       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link.fitted span {\n",
       "  /* fitted */\n",
       "  background: var(--sklearn-color-fitted-level-0);\n",
       "  border: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "\n",
       ".sk-estimator-doc-link:hover span {\n",
       "  display: block;\n",
       "}\n",
       "\n",
       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
       "\n",
       "#sk-container-id-2 a.estimator_doc_link {\n",
       "  float: right;\n",
       "  font-size: 1rem;\n",
       "  line-height: 1em;\n",
       "  font-family: monospace;\n",
       "  background-color: var(--sklearn-color-background);\n",
       "  border-radius: 1rem;\n",
       "  height: 1rem;\n",
       "  width: 1rem;\n",
       "  text-decoration: none;\n",
       "  /* unfitted */\n",
       "  color: var(--sklearn-color-unfitted-level-1);\n",
       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 a.estimator_doc_link.fitted {\n",
       "  /* fitted */\n",
       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
       "  color: var(--sklearn-color-fitted-level-1);\n",
       "}\n",
       "\n",
       "/* On hover */\n",
       "#sk-container-id-2 a.estimator_doc_link:hover {\n",
       "  /* unfitted */\n",
       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
       "  color: var(--sklearn-color-background);\n",
       "  text-decoration: none;\n",
       "}\n",
       "\n",
       "#sk-container-id-2 a.estimator_doc_link.fitted:hover {\n",
       "  /* fitted */\n",
       "  background-color: var(--sklearn-color-fitted-level-3);\n",
       "}\n",
       "</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LabelEncoder()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow fitted\">&nbsp;&nbsp;LabelEncoder<a class=\"sk-estimator-doc-link fitted\" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.4/modules/generated/sklearn.preprocessing.LabelEncoder.html\">?<span>Documentation for LabelEncoder</span></a><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></label><div class=\"sk-toggleable__content fitted\"><pre>LabelEncoder()</pre></div> </div></div></div></div>"
      ],
      "text/plain": [
       "LabelEncoder()"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fit a label encoder to transform the labels into one-hot encodings\n",
    "label_encoder = LabelEncoder()\n",
    "label_encoder.fit(list(set(y_train[:,0])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converting train and test arrays into Tensors\n",
    "* first reshaping out input data to have the following shape : ( samples, number_of_channels = 1 , 2 , 128)\n",
    "* then converting the labels using the label_encoder\n",
    "* finally creating DataLoaders for out model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X_train.reshape(-1,1,2,128)\n",
    "X_test = X_test.reshape(-1,1,2,128)\n",
    "y_train_encoded = label_encoder.transform(y_train[:,0]).astype(np.float32)\n",
    "y_test_encoded = label_encoder.transform(y_test[:,0]).astype(np.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(dict, numpy.ndarray, numpy.ndarray)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data) , type(X_train), type(y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert train arrays to PyTorch tensors\n",
    "\n",
    "train_tensor = torch.tensor(X_train, dtype=torch.float)\n",
    "train_targets_tensor = torch.tensor(y_train_encoded, dtype=torch.long)\n",
    "\n",
    "# Convert test arrays to PyTorch tensors\n",
    "test_tensor = torch.tensor(X_test, dtype=torch.float)\n",
    "test_targets_tensor = torch.tensor(y_test_encoded, dtype=torch.long)\n",
    "\n",
    "# Create a TensorDataset\n",
    "trainset = TensorDataset(train_tensor, train_targets_tensor)\n",
    "testset = TensorDataset(test_tensor, test_targets_tensor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataloader = DataLoader(dataset = trainset,\n",
    "                              batch_size= 1024,\n",
    "                              shuffle=True)\n",
    "test_dataloader = DataLoader(dataset = testset,\n",
    "                             batch_size= 1024,\n",
    "                             shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating model's class\n",
    "Here we are using Pytorch to creat our CNN model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNNModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.conv_block = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=1, out_channels=256, kernel_size=(1, 3), padding='same'),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.Conv2d(in_channels=256, out_channels=80, kernel_size=(2, 3), padding='same'),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.AvgPool2d(kernel_size = (2,2))\n",
    "        )\n",
    "        self.fc_layers = nn.Sequential(\n",
    "            nn.Flatten(start_dim=1),\n",
    "            nn.Linear(5120, 256),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(256, 8)\n",
    "        )\n",
    "    \n",
    "    def filters_output(self,x):\n",
    "        return self.conv_block(x)\n",
    "\n",
    "    def initialize_weights(self):\n",
    "        for module in self.modules():\n",
    "            if isinstance(module, nn.Conv2d) or isinstance(module, nn.Linear):\n",
    "                # Initialize weights using Xavier initialization\n",
    "                init.xavier_uniform_(module.weight)\n",
    "                # Initialize biases to zeros\n",
    "                if module.bias is not None:\n",
    "                    init.constant_(module.bias, 0.0)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.fc_layers(self.conv_block(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the Model\n",
    "\n",
    "for training we are using the  `train_functions` python script\n",
    "\n",
    "this script includes functions to train a model and returning the results of the  \n",
    "train and test results in each epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from train_functions import train\n",
    "\n",
    "# Make device agnostic code\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "# Set number of epochs\n",
    "NUM_EPOCHS = 50\n",
    "# initial the loss function and ompitmizer\n",
    "learning_rate = 0.001\n",
    "loss_function = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ea3650755cbb466eb0d2ee9c5b185587",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/50 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 | train_loss: 2.0795 | train_acc: 0.1265 | test_loss: 2.0792 | test_acc: 0.1272\n",
      "Epoch: 2 | train_loss: 2.0061 | train_acc: 0.1815 | test_loss: 1.8494 | test_acc: 0.2785\n",
      "Epoch: 3 | train_loss: 1.7123 | train_acc: 0.3116 | test_loss: 1.5754 | test_acc: 0.3548\n",
      "Epoch: 4 | train_loss: 1.5489 | train_acc: 0.3616 | test_loss: 1.4911 | test_acc: 0.3932\n",
      "Epoch: 5 | train_loss: 1.4782 | train_acc: 0.3960 | test_loss: 1.4261 | test_acc: 0.4161\n",
      "Epoch: 6 | train_loss: 1.4053 | train_acc: 0.4234 | test_loss: 1.3390 | test_acc: 0.4498\n",
      "Epoch: 7 | train_loss: 1.3546 | train_acc: 0.4453 | test_loss: 1.3073 | test_acc: 0.4575\n",
      "Epoch: 8 | train_loss: 1.3196 | train_acc: 0.4555 | test_loss: 1.2741 | test_acc: 0.4667\n",
      "Epoch: 9 | train_loss: 1.2919 | train_acc: 0.4662 | test_loss: 1.2665 | test_acc: 0.4608\n",
      "Epoch: 10 | train_loss: 1.2736 | train_acc: 0.4729 | test_loss: 1.2384 | test_acc: 0.4785\n",
      "Epoch: 11 | train_loss: 1.2483 | train_acc: 0.4835 | test_loss: 1.2525 | test_acc: 0.4788\n",
      "Epoch: 12 | train_loss: 1.2297 | train_acc: 0.4909 | test_loss: 1.2002 | test_acc: 0.5010\n",
      "Epoch: 13 | train_loss: 1.2102 | train_acc: 0.4988 | test_loss: 1.1732 | test_acc: 0.5033\n",
      "Epoch: 14 | train_loss: 1.1961 | train_acc: 0.5009 | test_loss: 1.1641 | test_acc: 0.5053\n",
      "Epoch: 15 | train_loss: 1.1860 | train_acc: 0.5042 | test_loss: 1.1600 | test_acc: 0.5094\n",
      "Epoch: 16 | train_loss: 1.1746 | train_acc: 0.5093 | test_loss: 1.1516 | test_acc: 0.5049\n",
      "Epoch: 17 | train_loss: 1.1640 | train_acc: 0.5134 | test_loss: 1.1458 | test_acc: 0.5150\n",
      "Epoch: 18 | train_loss: 1.1550 | train_acc: 0.5152 | test_loss: 1.1428 | test_acc: 0.5142\n",
      "Epoch: 19 | train_loss: 1.1480 | train_acc: 0.5201 | test_loss: 1.1304 | test_acc: 0.5132\n",
      "Epoch: 20 | train_loss: 1.1411 | train_acc: 0.5215 | test_loss: 1.1251 | test_acc: 0.5243\n",
      "Epoch: 21 | train_loss: 1.1379 | train_acc: 0.5223 | test_loss: 1.1332 | test_acc: 0.5140\n",
      "Epoch: 22 | train_loss: 1.1308 | train_acc: 0.5246 | test_loss: 1.1283 | test_acc: 0.5207\n",
      "Epoch: 23 | train_loss: 1.1279 | train_acc: 0.5273 | test_loss: 1.1421 | test_acc: 0.5013\n",
      "Epoch: 24 | train_loss: 1.1189 | train_acc: 0.5312 | test_loss: 1.1324 | test_acc: 0.5126\n",
      "Epoch: 25 | train_loss: 1.1159 | train_acc: 0.5315 | test_loss: 1.1152 | test_acc: 0.5190\n",
      "Epoch: 26 | train_loss: 1.1104 | train_acc: 0.5339 | test_loss: 1.1086 | test_acc: 0.5264\n",
      "Epoch: 27 | train_loss: 1.1032 | train_acc: 0.5374 | test_loss: 1.1062 | test_acc: 0.5208\n",
      "Epoch: 28 | train_loss: 1.0998 | train_acc: 0.5388 | test_loss: 1.1051 | test_acc: 0.5248\n",
      "Epoch: 29 | train_loss: 1.0998 | train_acc: 0.5384 | test_loss: 1.0981 | test_acc: 0.5297\n",
      "Epoch: 30 | train_loss: 1.0947 | train_acc: 0.5405 | test_loss: 1.0988 | test_acc: 0.5274\n",
      "Epoch: 31 | train_loss: 1.0916 | train_acc: 0.5423 | test_loss: 1.0954 | test_acc: 0.5254\n",
      "Epoch: 32 | train_loss: 1.0895 | train_acc: 0.5442 | test_loss: 1.0956 | test_acc: 0.5191\n",
      "Epoch: 33 | train_loss: 1.0848 | train_acc: 0.5450 | test_loss: 1.1099 | test_acc: 0.5160\n",
      "Epoch: 34 | train_loss: 1.0839 | train_acc: 0.5463 | test_loss: 1.0891 | test_acc: 0.5312\n",
      "Epoch: 35 | train_loss: 1.0787 | train_acc: 0.5476 | test_loss: 1.0872 | test_acc: 0.5321\n",
      "Epoch: 36 | train_loss: 1.0753 | train_acc: 0.5499 | test_loss: 1.0887 | test_acc: 0.5366\n",
      "Epoch: 37 | train_loss: 1.0716 | train_acc: 0.5514 | test_loss: 1.0998 | test_acc: 0.5271\n",
      "Epoch: 38 | train_loss: 1.0718 | train_acc: 0.5513 | test_loss: 1.0965 | test_acc: 0.5267\n",
      "Epoch: 39 | train_loss: 1.0655 | train_acc: 0.5540 | test_loss: 1.0881 | test_acc: 0.5254\n",
      "Epoch: 40 | train_loss: 1.0634 | train_acc: 0.5555 | test_loss: 1.0760 | test_acc: 0.5415\n",
      "Epoch: 41 | train_loss: 1.0568 | train_acc: 0.5595 | test_loss: 1.0741 | test_acc: 0.5438\n",
      "Epoch: 42 | train_loss: 1.0558 | train_acc: 0.5598 | test_loss: 1.0806 | test_acc: 0.5357\n",
      "Epoch: 43 | train_loss: 1.0498 | train_acc: 0.5615 | test_loss: 1.0748 | test_acc: 0.5332\n",
      "Epoch: 44 | train_loss: 1.0474 | train_acc: 0.5636 | test_loss: 1.0668 | test_acc: 0.5417\n",
      "Epoch: 45 | train_loss: 1.0423 | train_acc: 0.5679 | test_loss: 1.0700 | test_acc: 0.5404\n",
      "Epoch: 46 | train_loss: 1.0422 | train_acc: 0.5668 | test_loss: 1.0686 | test_acc: 0.5419\n",
      "Epoch: 47 | train_loss: 1.0355 | train_acc: 0.5707 | test_loss: 1.0627 | test_acc: 0.5450\n",
      "Epoch: 48 | train_loss: 1.0307 | train_acc: 0.5731 | test_loss: 1.0648 | test_acc: 0.5435\n",
      "Epoch: 49 | train_loss: 1.0279 | train_acc: 0.5741 | test_loss: 1.0620 | test_acc: 0.5436\n",
      "Epoch: 50 | train_loss: 1.0255 | train_acc: 0.5764 | test_loss: 1.0578 | test_acc: 0.5436\n"
     ]
    }
   ],
   "source": [
    "# intial the model\n",
    "cnn_model = CNNModel().to(device)\n",
    "cnn_model.initialize_weights()\n",
    "optimizer = optim.AdamW(cnn_model.parameters(), lr=learning_rate)\n",
    "\n",
    "results = train(model=cnn_model, \n",
    "                train_dataloader = train_dataloader,\n",
    "                test_dataloader = test_dataloader,\n",
    "                optimizer=optimizer,\n",
    "                criterion=loss_function, \n",
    "                epochs=NUM_EPOCHS,\n",
    "                device=device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from train_functions import plot_loss, plot_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_loss(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_accuracy(results)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving the results\n",
    "here we save the model itself, its label encoder, and the train and test loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model saved to cnn_models\\cnnModel\n",
      "LabelEncoder saved to label_encoders\\LabelEncoder\n",
      "Metrics saved to models_results\\cnnModel\n"
     ]
    }
   ],
   "source": [
    "from utills import save_model, save_label_encoder, save_metrics\n",
    "\n",
    "save_model(model = cnn_model,\n",
    "           dir_path = \"cnn_models\",\n",
    "           file_name = \"cnnModel\")\n",
    "\n",
    "save_label_encoder(label_encoder=label_encoder,\n",
    "                   dir_path = \"label_encoders\",\n",
    "                    file_name = \"LabelEncoder\" )\n",
    "\n",
    "save_metrics(metrics= results,\n",
    "             dir_path = \"models_results\",\n",
    "             file_name = \"cnnModel\" )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation phase\n",
    "\n",
    "in this section we validate the model's performance and\n",
    "print out the confusion matrices and some metrics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loading model and label encoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LabelEncoder loaded from label_encoders/LabelEncoder\n",
      "Model loaded from cnn_models/cnnModel\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "CNNModel(\n",
       "  (conv_block): Sequential(\n",
       "    (0): Conv2d(1, 256, kernel_size=(1, 3), stride=(1, 1), padding=same)\n",
       "    (1): ReLU()\n",
       "    (2): Dropout(p=0.5, inplace=False)\n",
       "    (3): Conv2d(256, 80, kernel_size=(2, 3), stride=(1, 1), padding=same)\n",
       "    (4): ReLU()\n",
       "    (5): Dropout(p=0.5, inplace=False)\n",
       "    (6): AvgPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0)\n",
       "  )\n",
       "  (fc_layers): Sequential(\n",
       "    (0): Flatten(start_dim=1, end_dim=-1)\n",
       "    (1): Linear(in_features=5120, out_features=256, bias=True)\n",
       "    (2): ReLU()\n",
       "    (3): Linear(in_features=256, out_features=8, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from utills import load_label_encoder , load_model\n",
    "\n",
    "labelencoder = load_label_encoder(file_path= \"label_encoders/LabelEncoder\")\n",
    "cnn_model = CNNModel()\n",
    "cnn_model = load_model(model= cnn_model , file_path= \"cnn_models/cnnModel\")\n",
    "# Make device agnostic code\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "cnn_model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from torchmetrics import ConfusionMatrix\n",
    "from mlxtend.plotting import plot_confusion_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "defining a list to append the predictions  into it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n",
      "c:\\Users\\shahr\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\sklearn\\preprocessing\\_label.py:153: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    }
   ],
   "source": [
    "y_preds = []\n",
    "with torch.inference_mode():\n",
    "    for data , label in test_dataloader:\n",
    "        X = data.to(device)\n",
    "        output = cnn_model(X)\n",
    "        \n",
    "        # appending the labels as their str format\n",
    "        main_pred_lbl = label_encoder.inverse_transform(output.argmax(dim=1,keepdim=True).cpu())\n",
    "        y_preds.append(main_pred_lbl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_preds_flat = [item for sublist in y_preds for item in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# again fitting a lebel encoder to turn the predictions into integers\n",
    "\n",
    "class_names = list(set(y_test[:,0]))\n",
    "# Create and fit LabelEncoder\n",
    "le = LabelEncoder()\n",
    "le.fit(class_names)\n",
    "\n",
    "# Encode predictions and true labels\n",
    "y_preds_encoded = le.transform(y_preds_flat)\n",
    "y_test_encoded = le.transform(y_test[:,0])\n",
    "\n",
    "# Convert numpy arrays to PyTorch tensors\n",
    "y_preds_tensor = torch.tensor(y_preds_encoded)\n",
    "y_true_tensor = torch.tensor(y_test_encoded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "snr_index = []\n",
    "for i in range(-20,20,2):\n",
    "    snrs = bytes(str(i), 'utf-8')\n",
    "    snr_index.append([y_test[:,1] == snrs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 10000x700 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Number of subplots (one for each SNR index)\n",
    "num_plots = len(snr_index)\n",
    "\n",
    "number_of_classes = len(class_names)\n",
    "confmat = ConfusionMatrix(num_classes = number_of_classes, task='multiclass')\n",
    "\n",
    "# Create subplots\n",
    "fig, axes = plt.subplots(nrows=1, ncols=num_plots, figsize=(5 * num_plots, 7))\n",
    "\n",
    "# Ensure axes is iterable\n",
    "if num_plots == 1:\n",
    "    axes = [axes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining a accuaracy function to calculate acc at each SNR further in the code\n",
    "\n",
    "def accuracy(predictions , true_labels):\n",
    "    \n",
    "    correct_predictions = (predictions == true_labels).sum().item()\n",
    "    \n",
    "    return (correct_predictions / len(predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in this snippet we print the confusion matrix at each snr.  \n",
    "and then calculate the accuracy and save it at a list  \n",
    "then save each plot at the desired path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a folder if it doesn't exist\n",
    "save_folder = 'confusion_matrices'\n",
    "if not os.path.exists(save_folder):\n",
    "    os.makedirs(save_folder, exist_ok=True)\n",
    "\n",
    "snr_acc_list = []\n",
    "snrs = range(-20,20,2)\n",
    "for i, snr_i in enumerate(snr_index):\n",
    "\n",
    "    confmat_tensor = confmat(preds=y_preds_tensor[snr_i[0]], target=y_true_tensor[snr_i[0]])\n",
    "    # Convert the confusion matrix tensor to a NumPy array\n",
    "    cm = confmat_tensor.cpu().numpy()\n",
    "\n",
    "    # Convert confusion matrix to percentages\n",
    "    cm_percent = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] * 100\n",
    "\n",
    "    acc = accuracy(predictions= y_preds_tensor[snr_i[0]], true_labels = y_true_tensor[snr_i[0]])\n",
    "    acc = acc * 100\n",
    "    snr_acc_list.append([acc,snrs[i]])\n",
    "\n",
    "    _ , axes[i] = plot_confusion_matrix(conf_mat=cm_percent, # matplotlib likes working with NumPy \n",
    "                                    class_names=le.classes_, # turn the row and column labels into class names\n",
    "                                    )\n",
    "    axes[i].set_title(f'SNR : {snrs[i]} , accuracy = {acc:.2f}%')\n",
    "\n",
    "    save_path = os.path.join(save_folder, f'confusion_matrix_at_SNR{snrs[i]}.jpeg')\n",
    "    plt.savefig(save_path, format='jpeg')\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "here we use `sklearn.metrics` to print out some validation metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 55.04%\n",
      "Class 0: Precision: 47.10%, Recall: 48.40%, F1-Score: 47.74%, Support: 4000.0\n",
      "Class 1: Precision: 62.29%, Recall: 63.35%, F1-Score: 62.82%, Support: 4000.0\n",
      "Class 2: Precision: 56.62%, Recall: 65.77%, F1-Score: 60.85%, Support: 4000.0\n",
      "Class 3: Precision: 62.90%, Recall: 70.60%, F1-Score: 66.53%, Support: 4000.0\n",
      "Class 4: Precision: 71.27%, Recall: 69.77%, F1-Score: 70.52%, Support: 4000.0\n",
      "Class 5: Precision: 40.71%, Recall: 32.52%, F1-Score: 36.16%, Support: 4000.0\n",
      "Class 6: Precision: 49.86%, Recall: 40.38%, F1-Score: 44.62%, Support: 4000.0\n",
      "Class 7: Precision: 45.73%, Recall: 49.55%, F1-Score: 47.56%, Support: 4000.0\n",
      "Class macro avg: Precision: 54.56%, Recall: 55.04%, F1-Score: 54.60%, Support: 32000.0\n",
      "Class weighted avg: Precision: 54.56%, Recall: 55.04%, F1-Score: 54.60%, Support: 32000.0\n",
      "Macro Avg: Precision: 54.56%, Recall: 55.04%, F1-Score: 54.60%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# 2. Accuracy as a Percentage\n",
    "accuracy = (y_preds_tensor == y_true_tensor).sum().item() / len(y_true_tensor) * 100\n",
    "print(f'Accuracy: {accuracy:.2f}%')\n",
    "\n",
    "# Convert tensors to NumPy for classification_report\n",
    "y_preds = y_preds_tensor.cpu().numpy()\n",
    "y_true = y_true_tensor.cpu().numpy()\n",
    "\n",
    "# Generate classification report\n",
    "report = classification_report(y_true, y_preds, output_dict=True)\n",
    "\n",
    "# Convert to percentages and display for each class\n",
    "for label, metrics in report.items():\n",
    "    if isinstance(metrics, dict):  # Ignore 'accuracy' field\n",
    "        precision = metrics['precision'] * 100\n",
    "        recall = metrics['recall'] * 100\n",
    "        f1_score = metrics['f1-score'] * 100\n",
    "        support = metrics['support']\n",
    "        print(f\"Class {label}: Precision: {precision:.2f}%, Recall: {recall:.2f}%, F1-Score: {f1_score:.2f}%, Support: {support}\")\n",
    "\n",
    "# 4. Macro and Weighted Metrics as Percentages\n",
    "macro_precision = report['macro avg']['precision'] * 100\n",
    "macro_recall = report['macro avg']['recall'] * 100\n",
    "macro_f1_score = report['macro avg']['f1-score'] * 100\n",
    "print(f\"Macro Avg: Precision: {macro_precision:.2f}%, Recall: {macro_recall:.2f}%, F1-Score: {macro_f1_score:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "at the end you can the model's **accuracy vs snr** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "snr_acc_arr = np.array(snr_acc_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHHCAYAAACle7JuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABfyklEQVR4nO3deVgU9QMG8Hd3YRcEdrkv5RRFQPEWyTxDEY+08OxQyzTN7KdmmeWZeWSWpWmWGVqeaWVq3nclnom3eAvKKQrLIbuwO78/kE0CFBSYXXg/z7NPMjs7+w4o+/ad78xIBEEQQERERGSCpGIHICIiInpSLDJERERkslhkiIiIyGSxyBAREZHJYpEhIiIik8UiQ0RERCaLRYaIiIhMFosMERERmSwWGSIiIjJZLDJERERkslhkiEzMmTNn0KdPH3h5ecHCwgK1a9dG586dsXDhwiLreXt7QyKRYPTo0cW2sX//fkgkEmzYsMGwbPny5ZBIJIaHmZkZateujSFDhuD27duVvl/l1a9fP0gkEkyYMEHsKEQkIhYZIhNy6NAhtGjRAqdOncKwYcPw9ddf44033oBUKsVXX31V4muWLl2KhISEMr/Hxx9/jJ9++glLlixBREQEVq5cifbt2yM3N7eiduOpqdVqbN68Gd7e3lizZg14yziimstM7ABEVHYzZ86ESqXCsWPHYGtrW+S5lJSUYusHBQUhNjYWc+bMwYIFC8r0HhEREWjRogUA4I033oCjoyM+/fRTbNq0Cf369XvqfagIv/zyC3Q6HX744Qd06tQJBw8eRPv27cWOVYwgCMjNzYWlpaXYUYiqLY7IEJmQq1evIigoqFiJAQBnZ+diy7y9vTFo0KByj8o8rG3btob3fpR58+ZBIpHg5s2bxZ6bOHEi5HI57t27BwC4fPkyIiMj4erqCgsLC9SpUwcDBgxARkZGmTKtWrUKnTt3RseOHREQEIBVq1aVuN7FixfRr18/ODk5wdLSEv7+/vjoo4+KrHP79m0MHToU7u7uUCgU8PHxwciRI6HVagEA06ZNg0QiKbbtwkNxN27cMCzz9vZGjx49sGPHDrRo0QKWlpb49ttvAQBRUVHo1KkTnJ2doVAoEBgYiG+++abE3Nu2bUP79u1hY2MDpVKJli1bYvXq1QCAqVOnwtzcHKmpqcVeN3z4cNja2hrV6BlRZWORITIhXl5eOHHiBM6ePVvm13z00UfIz8/HnDlznug9Cz+o7ezsHrle4ZyVn3/+udhzP//8M7p06QI7OztotVqEh4fj8OHDGD16NBYtWoThw4fj2rVrSE9Pf2yehIQE7Nu3DwMHDgQADBw4EBs2bDAUj0KnT59GSEgI9u7di2HDhuGrr75C7969sXnz5iLbatWqFdauXYv+/ftjwYIFePXVV3HgwAHk5OQ8NktJYmNjMXDgQHTu3BlfffUVmjRpAgD45ptv4OXlhQ8//BCff/45PDw88NZbb2HRokVFXr98+XJ0794dd+/excSJEzFnzhw0adIE27dvBwC8+uqryM/Px7p164q8TqvVYsOGDYiMjISFhcUTZScySQIRmYydO3cKMplMkMlkQmhoqPD+++8LO3bsELRabbF1vby8hO7duwuCIAivvfaaYGFhISQkJAiCIAj79u0TAAjr1683rB8VFSUAEHbv3i2kpqYK8fHxwoYNGwQnJydBoVAI8fHxj80XGhoqNG/evMiyo0ePCgCEH3/8URAEQTh58mSx9y6PefPmCZaWloJarRYEQRAuXbokABB+++23Iuu1a9dOsLGxEW7evFlkuV6vN/x50KBBglQqFY4dO1bsfQrXmzp1qlDSr8rC79f169cNy7y8vAQAwvbt24utn5OTU2xZeHi44Ovra/g6PT1dsLGxEUJCQoT79++Xmjs0NFQICQkp8vyvv/4qABD27dtX7H2IqjOOyBCZkM6dOyM6OhrPP/88Tp06hblz5yI8PBy1a9fGpk2bSn3dpEmTyjwqExYWBicnJ3h4eKBPnz6wsrLCpk2bUKdOnce+tn///jhx4kSRw1Dr1q2DQqFAr169AAAqlQoAsGPHjica9Vi1ahW6d+8OGxsbAEC9evXQvHnzIoeXUlNTcfDgQbz++uvw9PQs8vrCw0R6vR4bN25Ez549DXOCSlqvvHx8fBAeHl5s+cPzZDIyMnDnzh20b98e165dMxxS27VrFzIzM/HBBx8UG1V5OM+gQYNw5MiRIt/nVatWwcPDwyjnChFVJhYZIhPTsmVL/Prrr7h37x6OHj2KiRMnIjMzE3369MH58+dLfI2vry9effVVfPfdd0hMTHzk9hctWoRdu3Zhw4YN6NatG+7cuQOFQlGmbH379oVUKjUc9hAEAevXr0dERASUSiWAgg/6cePG4fvvv4ejoyPCw8OxaNGiMs2PuXDhAk6ePIk2bdrgypUrhkeHDh2wZcsWqNVqAMC1a9cAAA0bNix1W6mpqVCr1Y9c50n4+PiUuPzvv/9GWFgYrKysYGtrCycnJ3z44YcAYNj3wmLyuEz9+/eHQqEwlLeMjAxs2bIFL7/88hMXMCJTxSJDZKLkcjlatmyJWbNm4ZtvvkFeXh7Wr19f6vqFc2U+/fTTR263VatWCAsLQ2RkJDZt2oSGDRvipZdeQlZW1mMzubu7o23btoZ5MocPH0ZcXBz69+9fZL3PP/8cp0+fxocffoj79+/jnXfeQVBQEG7duvXI7a9cuRIAMHbsWNSrV8/w+Pzzz5Gbm4tffvnlsRnLq7RioNPpSlxe0hlKV69exXPPPYc7d+7giy++wB9//IFdu3Zh7NixAApGh8rDzs4OPXr0MBSZDRs2QKPR4JVXXinXdoiqAxYZomqg8NDIo0Zb6tati1deeQXffvvtY0dlCslkMsyePRsJCQn4+uuvy/Sa/v3749SpU4iNjcW6detQq1Yt9OzZs9h6jRo1wqRJk3Dw4EH8+eefuH37NpYsWVLqdgVBwOrVq9GxY0esX7++2CM4ONjwwe7r6wsAj5wU7eTkBKVS+diJ04WTnP87Ebmks7NKs3nzZmg0GmzatAlvvvkmunXrhrCwsGKlp27duo/NXWjQoEG4dOkSjh07hlWrVqFp06YICgoqcyai6oJFhsiE7Nu3r8SLv23duhUA4O/v/8jXT5o0CXl5eZg7d26Z37NDhw5o1aoVvvzyyzKd1hsZGQmZTIY1a9Zg/fr16NGjB6ysrAzPq9Vq5OfnF3lNo0aNIJVKodFoSt3u33//jRs3buC1115Dnz59ij369++Pffv2ISEhAU5OTmjXrh1++OEHxMXFFdlO4fdPKpUazmI6fvx4sfcrXK+wXBw8eNDwXHZ2NlasWPHY70UhmUxWZJtAweGgqKioIut16dIFNjY2mD17drHv9X9/7hEREYZr/Bw4cICjMVRj8YJ4RCZk9OjRyMnJwQsvvIAGDRpAq9Xi0KFDWLduHby9vfHaa6898vWFozLl+RAGgPfeew99+/bF8uXLMWLEiEeu6+zsjI4dO+KLL75AZmZmscNKe/fuxdtvv42+ffuifv36yM/Px08//QSZTIbIyMhSt7tq1SrIZDJ07969xOeff/55fPTRR1i7di3GjRuHBQsW4Nlnn0WzZs0wfPhw+Pj44MaNG/jjjz8QExMDAJg1axZ27tyJ9u3bY/jw4QgICEBiYiLWr1+Pv/76C7a2tujSpQs8PT0xdOhQvPfee5DJZPjhhx/g5ORUrCSVpkuXLpDL5ejZsyfefPNNZGVlYenSpXB2di4yOqZUKjF//ny88cYbaNmyJV566SXY2dnh1KlTyMnJKfJzMzc3x4ABA/D1119DJpMZTkcnqnFEPGOKiMpp27Ztwuuvvy40aNBAsLa2FuRyueDn5yeMHj1aSE5OLrLuw6dfP+zy5cuCTCYr9fTrkk5F1ul0Qt26dYW6desK+fn5j825dOlSAYBgY2NT7DTia9euCa+//rpQt25dwcLCQrC3txc6duwo7N69u9TtabVawcHBQWjbtu0j39fHx0do2rSp4euzZ88KL7zwgmBraytYWFgI/v7+wuTJk4u85ubNm8KgQYMMp5n7+voKo0aNEjQajWGdEydOCCEhIYJcLhc8PT2FL774otTTr0v6nguCIGzatEkIDg4WLCwsBG9vb+HTTz8Vfvjhh2LbKFz3mWeeESwtLQWlUim0atVKWLNmTbFtFp7a3qVLl0d+X4iqM4kg8CYlRESm6NSpU2jSpAl+/PFHvPrqq2LHIRIF58gQEZmopUuXwtraGi+++KLYUYhEwzkyREQmZvPmzTh//jy+++47vP3220UmUxPVNDy0RERkYry9vZGcnIzw8HD89NNPhqscE9VELDJERERksjhHhoiIiEwWiwwRERGZrGo/2Vev1yMhIQE2Nja8mRoREZGJEAQBmZmZcHd3h1Ra+rhLtS8yCQkJ8PDwEDsGERERPYH4+HjUqVOn1OerfZEpnM0fHx8PpVIpchoiIiIqC7VaDQ8Pj8eelVfti0zh4SSlUskiQ0REZGIeNy2Ek32JiIjIZLHIEBERkclikSEiIiKTVe3nyJSVTqdDXl6e2DGohjM3N4dMJhM7BhGRyajxRUYQBCQlJSE9PV3sKEQAAFtbW7i6uvK6R0REZVDji0xhiXF2dkatWrX44UGiEQQBOTk5SElJAQC4ubmJnIiIyPjV6CKj0+kMJcbBwUHsOESwtLQEAKSkpMDZ2ZmHmYiIHqNGT/YtnBNTq1YtkZMQ/avw7yPnbBERPV6NLjKFeDiJjAn/PhIRlR2LDBEREZksFhkiIiIyWSwyJig1NRUjR46Ep6cnFAoFXF1dER4ejr///tuwjre3NyQSCQ4fPlzktWPGjEGHDh0MX0+bNg0SiQQSiQQymQweHh4YPnw47t69W1W7U8SaNWsgk8kwatQoUd6fiIhMC4uMCYqMjMTJkyexYsUKXLp0CZs2bUKHDh2QlpZWZD0LCwtMmDDhsdsLCgpCYmIi4uLiEBUVhe3bt2PkyJGVFf+Rli1bhvfffx9r1qxBbm6uKBkKabVaUd+fiGqG3Dwd8nV6sWM8MU2+TtT3Z5ExMenp6fjzzz/x6aefomPHjvDy8kKrVq0wceJEPP/880XWHT58OA4fPoytW7c+cptmZmZwdXVF7dq1ERYWhr59+2LXrl2lrr9z505YWFgUu4jg//73P3Tq1AkAcPPmTfTs2RN2dnawsrJCUFDQY3Ncv34dhw4dwgcffID69evj119/LbbODz/8gKCgICgUCri5ueHtt98u8r1588034eLiAgsLCzRs2BBbtmwBUDDy1KRJkyLb+vLLL+Ht7W34esiQIejduzdmzpwJd3d3+Pv7AwB++ukntGjRAjY2NnB1dcVLL71kuNZLoXPnzqFHjx5QKpWwsbFB27ZtcfXqVRw8eBDm5uZISkoqsv6YMWPQtm3bR34/iKpKnk6P307ewopDN3D6VjryTPhD1VTc1+qw+VQC3lhxHI2m7UCLmbsxe+sFxKXliB2tzK6kZOHjzefRauYenEvIEC1Hjb6OzH8JgoD7eeI0S0tzWZnOVrG2toa1tTU2btyI1q1bQ6FQlLquj48PRowYgYkTJ6Jr166QSh/fW2/cuIEdO3ZALpeXus5zzz0HW1tb/PLLLxg6dCiAgmvyrFu3DjNnzgQAjBo1ClqtFgcPHoSVlRXOnz8Pa2vrR753VFQUunfvDpVKhVdeeQXLli3DSy+9ZHj+m2++wbhx4zBnzhxEREQgIyPDcDhNr9cjIiICmZmZWLlyJerWrYvz58+X+zose/bsgVKpLFLk8vLyMGPGDPj7+yMlJQXjxo3DkCFDDMXs9u3baNeuHTp06IC9e/dCqVTi77//Rn5+Ptq1awdfX1/89NNPeO+99wzbW7VqFebOnVuubEQVTRAEbD2ThM92XMSNhz5ALcylaFzHFs297NDcyw7NPO1gZ1X67wQqm3ydHn9duYNNMQnYcS4J2dp/P2/Sc/Lw7cFr+O7Pa+hQ3wmvhnqhfX1nyKTGdRajJl+H7WeTsOpIHI5e/3cKwuZTiQhyV4mSiUXmIffzdAicskOU9z7/cThqyR//4zAzM8Py5csxbNgwLFmyBM2aNUP79u0xYMAABAcHF1t/0qRJiIqKwqpVq/Dqq6+WuM0zZ87A2toaOp3OcDjniy++KDWDTCbDgAEDsHr1akOR2bNnD9LT0xEZGQkAiIuLQ2RkJBo1agQA8PX1feR+6fV6LF++HAsXLgQADBgwAO+++y6uX78OHx8fAMAnn3yCd999F//73/8Mr2vZsiUAYPfu3Th69CguXLiA+vXrl+k9S2JlZYXvv/++SJF7/fXXDX/29fXFggUL0LJlS2RlZcHa2hqLFi2CSqXC2rVrYW5uDgCGDAAwdOhQREVFGYrM5s2bkZubi379+pU7H1FFib6ahjnbLuDUrYL/k3a0liPIXYWY+HRk3M/Dket3ceShD6q6TlaGYtPcyw6+jtaQGtmHrDESBAH/xKXj95jb+ON0ItKy/z1kXcfOEr2auKNnY3fE372Pnw7fxMFLqdgXW/DwsLfEyyFe6NfCA/YiF8nrd7Kx5mgcNpy4hbsP9kEqAZ4LcMFLIZ5oV89JtGwsMiYoMjIS3bt3x59//onDhw9j27ZtmDt3Lr7//nsMGTKkyLpOTk4YP348pkyZgv79+5e4PX9/f2zatAm5ublYuXIlYmJiMHr06EdmePnll9G6dWskJCTA3d0dq1atQvfu3WFrawsAeOeddzBy5Ejs3LkTYWFhiIyMLLFoFdq1axeys7PRrVs3AICjoyM6d+6MH374ATNmzEBKSgoSEhLw3HPPlfj6mJgY1KlTp0iBeBKNGjUqNhp14sQJTJs2DadOncK9e/eg1xcMu8fFxSEwMBAxMTFo27atocT815AhQzBp0iQcPnwYrVu3xvLly9GvXz9YWVk9VVaiJ3ExSY052y5if2wqAKCWXIbh7XwxrK0vrBRm0OsFXLuThRM37xkeV1OzDY+fj98CAKgszdHMs2DUppmXHRrXsYWVgh8phS4nZ2JjzG38HpOAW/fuG5Y7WMnRI9gNzzepjWaetoaR+AauSnQOdMH1O9lYdfgmfj4ej/i79zFn20V8sesSejRyw6uhXmjiYVtl15rS5uux83wSVh+Jw6Gr/87BdFNZYEBLT/Rv6QFXlUWVZHkU/q17iKW5DOc/DhftvcvDwsICnTt3RufOnTF58mS88cYbmDp1arEiAwDjxo3D4sWLsXjx4hK3JZfL4efnBwCYM2cOunfvjunTp2PGjBmlvn/Lli1Rt25drF27FiNHjsRvv/2G5cuXG55/4403EB4ejj/++AM7d+7E7Nmz8fnnn5dakJYtW4a7d+8aLtEPFIzSnD59GtOnTy+yvCSPe14qlUIQhCLLSrpy7n/LRXZ2NsLDwxEeHo5Vq1bByckJcXFxCA8PN0wGftx7Ozs7o2fPnoiKioKPjw+2bduG/fv3P/I1RBXtdvp9fLHzEn49eQuCAJhJJXgpxBOjO9WDk82/h6ilUgn8nG3g52yD/i09AQD3srU4GX8Px28UFJtTtwpGbQpHDgBAJpUgwM0GzT0Lik1zLzvUtrV86g/dPJ0embn5UN/Pgzo3D+r7+Q/+W/B1xv2CZZp8HbwcrODnbI16ztbwtK8FM1nVTgNNSL+PTacS8HtMAi4kqg3LreQyhAe54vkm7mjj5wjzR+TycbTCpB6BeLeLPzafSsCPh2/g7G01fj15G7+evI2GtZUY1NobPRu7w1JeObcwiUvLweqjcdhwIh53sgp+z0kkQEd/Z7zUyhMd/J2q/Hv7KCwyD5FIJGU6vGOMAgMDsXHjxhKfs7a2xuTJkzFt2rRiE4JLMmnSJHTq1AkjR46Eu7t7qeu9/PLLWLVqFerUqQOpVIru3bsXed7DwwMjRowwzNNZunRpiUUmLS0Nv//+O9auXYugoCDDcp1Oh2effRY7d+5E165d4e3tjT179qBjx47FthEcHIxbt27h0qVLJY7KODk5ISkpCYIgGH6xxsTEPPZ7cfHiRaSlpWHOnDnw8PAAABw/frzYe69YsQJ5eXmljsq88cYbGDhwIOrUqYO6deuiTZs2j31vooqQnqPF4v1XsfzQDWjzC0YTuzdyw/hwf/g4lm1U0M5Kjk4NXNCpgQuAgnJxIVFtGLH55+Y9JGTk4uxtNc7eVmNF9E0AgItSYZhj09TTDgozaZFCkmH4cx7UJZSVjPt5yNE+2bxFuUwKX6fCYmODei4FBcfLwQpys4r7EL6XrcXWs4n4PSahyJwRc5kE7es7o1cTd4QFuJS7dFjKZejX0gN9W9RBTHw6fjp8E1tOJ+LsbTXe/+U0PvnjPPq28MArrb3K/HN8lDydHnsuJGPVkTj8efmOYbmzjQL9W3qgf0sP1LEzztv5mOandg2WlpaGvn374vXXX0dwcDBsbGxw/PhxzJ07F7169Sr1dcOHD8f8+fOxevVqhISEPPI9QkNDERwcjFmzZuHrr78udb2XX34Z06ZNw8yZM9GnT58iE4/HjBmDiIgI1K9fH/fu3cO+ffsQEBBQ4nZ++uknODg4oF+/fsX+761bt25YtmwZunbtimnTpmHEiBFwdnY2TOz9+++/MXr0aLRv3x7t2rVDZGQkvvjiC/j5+eHixYuQSCTo2rUrOnTogNTUVMydOxd9+vTB9u3bsW3bNiiVykd+Lzw9PSGXy7Fw4UKMGDECZ8+eLTZS9fbbb2PhwoUYMGAAJk6cCJVKhcOHD6NVq1aGM5/Cw8OhVCrxySef4OOPP37kexJVhNw8HZYfuoHF+65AnZsPAGjta48PIgLQxMP2qbZtLpMiuI4tguvY4rU2BXPYEtLv45+4f4vNuQQ1ktUabD2ThK1nkh6zxcezksugtDSHytIcSgtzKC3NHvzXHEoLM8ikUtxIy8bllExcSclCbp4eF5MycTEpE0CiYTtmUgm8Ha1Q78HIjZ+LDfycrOHrZAWLMo6M52jzsftCCjbF3MaBS6nI0xWM9kokQIiPPXo1qY2Ihq6wrfX081okEgmaPiiCk7oH4ufj8Vh5+CZu3buPZX9dx7K/rqNtPUcMCvVGpwblnxx8614O1h6Nx8/H45GSqTHsR9t6TniplSeeC3B+5AiSMWCRMTHW1tYICQnB/PnzcfXqVeTl5cHDwwPDhg3Dhx9+WOrrzM3NMWPGjCJnAT3K2LFjMWTIEEyYMMEwEvFffn5+aNWqFY4ePYovv/yyyHM6nQ6jRo3CrVu3oFQq0bVrV8yfP7/E7fzwww944YUXShyCjoyMxKuvvoo7d+5g8ODByM3Nxfz58zF+/Hg4OjqiT58+hnV/+eUXjB8/HgMHDkR2djb8/PwwZ84cAEBAQAAWL16MWbNmYcaMGYiMjMT48ePx3XffPfL74OTkhOXLl+PDDz/EggUL0KxZM8ybN6/IyJaDgwP27t2L9957D+3bt4dMJkOTJk2KjLpIpVIMGTIEs2bNwqBBgx75nkRPQ6cX8Os/t/DFrktIzCiYvN/A1QYTIhqgQ32nSptf4W5rCXdbS/QILhjFva/V4fStdJyIu4cTN+7h9O0MSCWA0uJBGXlQQJT/KSb/PvfvMhsLs3IdytDrBdxOv48rKVm4nJKJy8lZuJyShSspWcjS5OPKgz9ve+g1UgngaV8Lfg+N3tRztkFdZyvUkpsh78EZR7+fvI2d55OLjBQFuSvRq4k7egS7w9320Yean4a9lRwj2tfFsLa+OHApBT9F38T+S6n48/Id/Hn5DmrbWuKlkIK5K47WpZ/Rmq/TY19sKlYduYkDl1JReNTd0VqOvi08MLClJzwdjHP0pSQS4b8TB6qQTqfDtGnTsHLlSiQlJcHd3d0wMbLwH5sgCJg6dSqWLl2K9PR0tGnTBt988w3q1atXpvdQq9VQqVTIyMgo9n/fubm5hrNiLCzEn7BE1dvQoUORmpqKTZs2PXI9/r2kJyEIAvbFpuDTbbGITc4EALirLDCuiz9eaFrb6E7jFYMgCEhS5z5UbP4tORn3S7/bfB07S+RodYazdYCC0tOriTt6NXGHn7NNVcQvUVxaDlYduYl1x+ORnlOwD+YyCbo1csOgUC8087QzfJ4mZtzH2qPxWHcsHknqfy842sbPAS+18kLnQJcKPez2tB71+f0wUUdkPv30U3zzzTdYsWIFgoKCcPz4cbz22mtQqVR45513AABz587FggULsGLFCvj4+GDy5MkIDw/H+fPn+UueTEJGRgbOnDmD1atXP7bEED2Jk3H3MGfbRcPp0ipLc4zqWBeDQr3LfLikJpBIJHBTWcJNZYl29f89XVgQBNzJ0hoOSxWUm4I/38nSGs46crSWo0dwQXmpyrOHHsXToRYmdgvA2M718cfpRPx4+CZOxafj95iCSccBbkq80NQdR6/fw96LydA/GLqwt5KjT/M6GNjKs0Lm2IhJ1BGZHj16wMXFBcuWLTMsi4yMhKWlJVauXAlBEODu7o53330X48ePB1DwoeDi4oLly5djwIABj30PjsiQ2Dp06ICjR4/izTffLPXw2sP495LK6lpqFubtjDXMQZGbSfHaM954q4MfVLVKnnhO5XM3W4vLD0a4mnvZGdXZOqU5fSsdP0XfxKZTCdDkF71Kc4iPPV4K8UTXhq5QmBl3yTWJEZlnnnkG3333neFMk1OnTuGvv/4yXIzt+vXrSEpKQlhYmOE1KpUKISEhiI6OLrHIaDQaaDQaw9dqtbrYOkRViadaU0VLzdTgqz2XsOZoPHR6ARIJENmsDsZ1rl+pczRqInsrOUJ8HcSOUS7BdWzxWV9bfNQ9ABtO3MKeCykIcFPipRAPUQ+DVRZRi8wHH3wAtVqNBg0aQCaTQafTYebMmXj55ZcBwHB/GhcXlyKvc3FxKXbvmkKzZ8/G9OnTKzc4EZEIsjT5+O7gNXz/5zXDZNNODZzxfld/NHB99Bl4VPPY1pLjjba+eKNt+a9ybkpELTI///wzVq1ahdWrVyMoKAgxMTEYM2YM3N3dMXjw4Cfa5sSJEzFu3DjD12q1utSzbgqJeHSNqBj+faxZ9HoBWdp8ZOSUdMG3/CIXfjt4KdVwgbLGHraYGNEArU1stICooolaZN577z188MEHhkNEjRo1ws2bNzF79mwMHjwYrq6uAIDk5GS4ubkZXpecnFzsTsaFFArFI2+k+LDCi5fl5OQ89uqsRFUlJ6fg5n2lXVyPjJMgCLiamo20LE2pF3cr6eq0mZp8lKe7+jha4b1wf0Q0dDWKyaZEYhO1yOTk5BS7I7NMJjPcy8bHxweurq7Ys2ePobio1WocOXIEI0eOfOr3l8lksLW1RUpKCgCgVq1a/MVAohEEATk5OUhJSYGtrW2579xN4jmXkIHpm88XubJrecnNpA8u9vbwtVX+/VplaY46dpYID3I1+guUEVUlUYtMz549MXPmTHh6eiIoKAgnT57EF198YbjbsEQiwZgxY/DJJ5+gXr16htOv3d3d0bt37wrJUDjqU1hmiMRma2tr+HtJxi0tS4N5Oy9h7bE4CELBZfHr2FnC5rEXeyv+HE+TJnoyohaZhQsXYvLkyXjrrbeQkpICd3d3vPnmm5gyZYphnffffx/Z2dkYPnw40tPT8eyzz2L79u0VdlqqRCKBm5sbnJ2dS7yJIFFVMjc350iMCcjT6fFj9E18ufsSMh9c/r9nY3d8ENEAtXnWEFGVEvU6MlWhrOehExGVxf7YFMzYch5XU7MBFFyefmrPILTysRc5GVH1YhLXkSEiMhXXUrPwyR8XsPdiwWFoBys53gv3R98WHrz8P5GIWGSIiB5BnZuHr/deQdTf15GnE2AmleC1Nt4Y/Vw9KC14ZhmR2FhkiIhKoNcLWH8iHp/tiDVcu6WjvxMm9QhEXSdrkdMRUSEWGSKi/zh+4y6mbz6PM7czAAC+jlaY3CMQHRs4i5yMiP6LRYaI6IHEjPuYs+0ifo9JAADYKMzwv7B6GBTqDbkZr91CZIxYZIioxsvN0+G7g9fwzf6ruJ+ng0QC9G/hgXe7+MPJpmxXCicicbDIEFGNJQgCtp1Nwsw/LuB2+n0AQEtvO0ztGYSGtVUipyOismCRIaIa6XyCGh9vOYfD1wpuK+CmssDEbgHoGezGW5UQmRAWGSKqUe5ma/H5zlisORoHvQAozKQY0b4uRrSvC0s5r6pMZGpYZIioRhAEAT8dvol5O2KhfnBbge7BbpgY0QB17GqJnI6InhSLDBHVCBtO3MKU388BAALdlJjaMxAhvg4ipyKip8UiQ0TVXsb9PMzZdhEAMKJ9XbwX7s/bChBVE7wwAhFVe/N3XUJathZ1nawwrnN9lhiiaoRFhoiqtfMJavwYfQMA8HGvhrywHVE1w3/RRFRtCYKAqZvOQi8A3Ru5oY2fo9iRiKiCscgQUbW1MeY2jt24B0tzGT7qHiB2HCKqBCwyRFQtZebmYdbWggm+b3fyg7utpciJiKgysMgQUbX05e7LSM3UwMfRCm+09RE7DhFVEhYZIqp2YpMysfzQDQDAtOeDoDDjFXuJqisWGSKqVgRBwJTfz0KnFxAe5IL29Z3EjkRElYhFhoiqlc2nE3Hk+l0ozKSY3CNQ7DhEVMlYZIio2sjS5GPmH+cBAKM6+vEeSkQ1AIsMEVUbC/dcRrJaAy+HWhjezlfsOERUBVhkiKhauJKSiWV/XQcATO0ZCAtzTvAlqglYZIjI5BVcwfcc8vUCwgKc0amBi9iRiKiKsMgQkcnbeiYJf19Jg9xMiik9gsSOQ0RViEWGiExajjYfnzyY4DuifV14OnCCL1FNwiJDRCbt671XkJiRizp2lnirQ12x4xBRFWORISKTdS01C0v/vAYAmNKDE3yJaiIWGSIySYIgYNrm88jTCejg74TOgZzgS1QTscgQkUnacS4ZBy+lQi6TYmrPIEgkErEjEZEIWGSIyOTc1+owY0vBBN9h7Xzg42glciIiEguLDBGZnG/2X8Ht9PtwV1lgVEc/seMQkYhYZIjIpNxMy8aSgwUTfCf3CEQtuZnIiYhITCwyRGRSpm8+D22+Hm3rOaJrQ1ex4xCRyFhkiMhk7D6fjL0XU2Auk2Da85zgS0QsMkRkInLzdJi+5RwAYOizvqjrZC1yIiIyBqIWGW9vb0gkkmKPUaNGAQByc3MxatQoODg4wNraGpGRkUhOThYzMhGJ5NsD1xB/9z5clRYY3YkTfImogKhF5tixY0hMTDQ8du3aBQDo27cvAGDs2LHYvHkz1q9fjwMHDiAhIQEvvviimJGJSATxd3OweP8VAMBH3QNgpeAEXyIqIOpvAycnpyJfz5kzB3Xr1kX79u2RkZGBZcuWYfXq1ejUqRMAICoqCgEBATh8+DBat24tRmQiEsHHW85Dk6/HM3Ud0CPYTew4RGREjGaOjFarxcqVK/H6669DIpHgxIkTyMvLQ1hYmGGdBg0awNPTE9HR0aVuR6PRQK1WF3kQkenaF5uCXeeTYSaVYDon+BLRfxhNkdm4cSPS09MxZMgQAEBSUhLkcjlsbW2LrOfi4oKkpKRStzN79myoVCrDw8PDoxJTE1Fl0uTrMH1TwQTf19p4o56LjciJiMjYGE2RWbZsGSIiIuDu7v5U25k4cSIyMjIMj/j4+ApKSERVbenBa7iRlgMnGwXeea6e2HGIyAgZxYy5mzdvYvfu3fj1118Ny1xdXaHVapGenl5kVCY5ORmurqVfBEuhUEChUFRmXCKqArfT7+PrfQ8m+HYLgI2FuciJiMgYGcWITFRUFJydndG9e3fDsubNm8Pc3Bx79uwxLIuNjUVcXBxCQ0PFiElEVeiTLeeRm6dHKx979GrydCO1RFR9iT4io9frERUVhcGDB8PM7N84KpUKQ4cOxbhx42Bvbw+lUonRo0cjNDSUZywRVXN/Xk7FtrNJkEkl+LgXJ/gSUelELzK7d+9GXFwcXn/99WLPzZ8/H1KpFJGRkdBoNAgPD8fixYtFSElEVUWbr8fUBxN8B4V6oYGrUuRERGTMJIIgCGKHqExqtRoqlQoZGRlQKvkLkcjYfbP/Kj7dfhGO1nLsebcDVJacG0NUE5X189so5sgQEQFAYsZ9LNx7GQDwQUQASwwRPRaLDBEZjZl/XECOVofmXnZ4sWltseMQkQlgkSEio3AzLRtbTidCIgE+7hUEqZQTfIno8VhkiMgorDtWcPHKdvWcEOSuEjkNEZkKFhkiEl2+To/1J24BAAa05G1FiKjsWGSISHT7YlORmqmBg5UczwW4iB2HiEwIiwwRiW7dsTgAQGTzOpCb8dcSEZUdf2MQkaiSMnKx92IKAKBfCx5WIqLyYZEhIlH98s8t6AWglbc9/JytxY5DRCaGRYaIRKPXC4azlfpzki8RPQEWGSISTfS1NMTdzYGNwgzdGrmJHYeITBCLDBGJZu2D0ZheTd1hKZeJnIaITBGLDBGJ4l62FjvOJgEABrT0FDkNEZkqFhkiEsVvJ29Dq9MjyF2JhrV5JV8iejIsMkRU5QTh30m+vJIvET0NFhkiqnIx8emITc6EwkyK55vwLtdE9ORYZIioyhWOxnRv5AaVpbnIaYjIlLHIEFGVytLkY9OpBADAgFac5EtET4dFhoiq1JZTCcjR6uDraIWW3nZixyEiE8ciQ0RVau1DV/KVSCQipyEiU8ciQ0RV5mKSGjHx6TCTSvBiszpixyGiaoBFhoiqTOEk37AAFzjZKEROQ0TVAYsMEVWJ3Dwdfjt5GwDQvxWvHUNEFYNFhoiqxM7zyUjPyYObygLt6jmJHYeIqgkWGSKqEuuOxQEA+rbwgEzKSb5EVDFYZIio0sWl5eDvK2mQSIB+LTjJl4gqDosMEVW6dccLRmPa1nNCHbtaIqchouqERYaIKlW+To/1x28B4A0iiajiscgQUaXaH5uKlEwN7K3kCAtwETsOEVUzLDJEVKkKr+Qb2aw25Gb8lUNEFYu/VYio0iSrc7EvNgVAwS0JiIgqGosMEVWaDSduQacX0MLLDn7ONmLHIaJqiEWGiCqFXi/g5+P/3iCSiKgysMgQUaU4fD0NN9NyYKMwQ/dgN7HjEFE1xSJDRJVi7dGC0Zjnm7ijltxM5DREVF2xyBBRhbuXrcX2s0kAgAEtPUVOQ0TVGYsMEVW4jTG3odXpEeimRMPaSrHjEFE1JnqRuX37Nl555RU4ODjA0tISjRo1wvHjxw3PC4KAKVOmwM3NDZaWlggLC8Ply5dFTExEjyIIguGw0oBWHpBIeINIIqo8ohaZe/fuoU2bNjA3N8e2bdtw/vx5fP7557CzszOsM3fuXCxYsABLlizBkSNHYGVlhfDwcOTm5oqYnIhKc+pWBmKTM6Ewk6JX49pixyGiak7UGXiffvopPDw8EBUVZVjm4+Nj+LMgCPjyyy8xadIk9OrVCwDw448/wsXFBRs3bsSAAQOqPDMRPdq6YwU3iOzWyA2qWuYipyGi6k7UEZlNmzahRYsW6Nu3L5ydndG0aVMsXbrU8Pz169eRlJSEsLAwwzKVSoWQkBBER0eXuE2NRgO1Wl3kQURVI1uTj00xCQB47RgiqhqiFplr167hm2++Qb169bBjxw6MHDkS77zzDlasWAEASEoqOOvBxaXojeZcXFwMz/3X7NmzoVKpDA8PD/4yJaoqf5xORLZWB2+HWgjxsRc7DhHVAKIWGb1ej2bNmmHWrFlo2rQphg8fjmHDhmHJkiVPvM2JEyciIyPD8IiPj6/AxET0KGseHFbq39KTk3yJqEqIWmTc3NwQGBhYZFlAQADi4gp+Gbq6ugIAkpOTi6yTnJxseO6/FAoFlEplkQcRVb7YpEycjEuHmVSCyOac5EtEVUPUItOmTRvExsYWWXbp0iV4eXkBKJj46+rqij179hieV6vVOHLkCEJDQ6s0KxE92rpjBaOfzwU4w9nGQuQ0RFRTiHrW0tixY/HMM89g1qxZ6NevH44ePYrvvvsO3333HQBAIpFgzJgx+OSTT1CvXj34+Phg8uTJcHd3R+/evcWMTkQP0eTr8OvJWwB4JV8iqlqiFpmWLVvit99+w8SJE/Hxxx/Dx8cHX375JV5++WXDOu+//z6ys7MxfPhwpKen49lnn8X27dthYcH/4yMyFjvPJSM9Jw+uSgu0q+8kdhwiqkEkgiAIYoeoTGq1GiqVChkZGZwvQ1RJXvn+CP66cgfvdPLDuC7+YschomqgrJ/fot+igIhMW/zdHPx15Q4kEqBvC17ugIiqFosMET2Vn48XTPJ91s8RHva1RE5DRDUNiwwRPbF8nd5QZHglXyISA4sMET2xA5dSkazWwK6WOToHujz+BUREFYxFhoie2NoH146JbFYHCjOZyGmIqCZikSGiJ5KizsXeiykAeFiJiMTDIkNET2TDP7eg0wto7mWHei42YschohqKRYaIyk0QBMMtCTgaQ0RiYpEhonI7fO0ubqblwFphhu6N3MSOQ0Q1GIsMEZXbumMFd6jv2dgdVgpR73RCRDUciwwRlUt6jhZbzyYBAAbwsBIRiYxFhojKZePJ29Dm69HA1QbBdVRixyGiGo5FhojKTBAEw7VjBrbyhEQiETkREdV0LDJEVGanb2XgYlIm5GZS9G5SW+w4REQsMkRUdoWjMd0aukJVy1zkNERELDJEVEaafB3+OJ0AAOjXgpN8icg4sMgQUZnsu5gKdW4+XJUWaO3rIHYcIiIALDJEVEYbT94GADzfxB1SKSf5EpFxYJEhosfKuJ9nuEFkrybuIqchIvoXiwwRPdb2s4nQ6vSo52yNQDel2HGIiAxYZIjosTaeLJjk27tpbV47hoiMCosMET1SUkYuDl9PA8DDSkRkfFhkiOiRNp26DUEAWnrboY5dLbHjEBEVwSJDRI9UeFipF6/kS0RGiEWGiEp1KTkT5xPVMJNK0L2Rm9hxiIiKYZEholIVXjumg78T7KzkIqchIiqORYaISqTXC/g9hoeViMi4scgQUYlOxN3D7fT7sJLLEBbgInYcIqISscgQUYkKDyt1begGS7lM5DRERCVjkSGiYrT5evxxJhEA0Lsprx1DRMaLRYaIijl4KRXpOXlwslHgmbqOYschIioViwwRFbMxpuCwUs9gd8h4p2siMmIsMkRURGZuHnadTwbAw0pEZPxYZIioiB3nkqHJ18PX0QqNaqvEjkNE9EgsMkRUxO8PDiv1asI7XROR8WORISKDlMxc/H3lDgAeViIi0yBqkZk2bRokEkmRR4MGDQzP5+bmYtSoUXBwcIC1tTUiIyORnJwsYmKi6m3zqUToBaCppy28HKzEjkNE9Fiij8gEBQUhMTHR8Pjrr78Mz40dOxabN2/G+vXrceDAASQkJODFF18UMS1R9VZ4WKk3b0lARCbCTPQAZmZwdXUttjwjIwPLli3D6tWr0alTJwBAVFQUAgICcPjwYbRu3bqqoxJVa9dSs3D6VgZkUgm6B/NO10RkGkQfkbl8+TLc3d3h6+uLl19+GXFxcQCAEydOIC8vD2FhYYZ1GzRoAE9PT0RHR4sVl6ja2vjgBpFt6znC0VohchoiorIRdUQmJCQEy5cvh7+/PxITEzF9+nS0bdsWZ8+eRVJSEuRyOWxtbYu8xsXFBUlJSaVuU6PRQKPRGL5Wq9WVFZ+o2hAEgYeViMgklXtEZsWKFfjjjz8MX7///vuwtbXFM888g5s3b5ZrWxEREejbty+Cg4MRHh6OrVu3Ij09HT///HN5YxnMnj0bKpXK8PDw8HjibRHVFCfj03EzLQeW5jJ0DuSdronIdJS7yMyaNQuWlpYAgOjoaCxatAhz586Fo6Mjxo4d+1RhbG1tUb9+fVy5cgWurq7QarVIT08vsk5ycnKJc2oKTZw4ERkZGYZHfHz8U2Uiqgl+f3Cn6y5BLrBSiD51joiozMpdZOLj4+Hn5wcA2LhxIyIjIzF8+HDMnj0bf/7551OFycrKwtWrV+Hm5obmzZvD3Nwce/bsMTwfGxuLuLg4hIaGlroNhUIBpVJZ5EFEpcvT6bHldOGdrnlYiYhMS7mLjLW1NdLS0gAAO3fuROfOnQEAFhYWuH//frm2NX78eBw4cAA3btzAoUOH8MILL0Amk2HgwIFQqVQYOnQoxo0bh3379uHEiRN47bXXEBoayjOWiCrQX1fuIC1bCwcrOdr68U7XRGRayj2G3LlzZ7zxxhto2rQpLl26hG7dugEAzp07B29v73Jt69atWxg4cCDS0tLg5OSEZ599FocPH4aTkxMAYP78+ZBKpYiMjIRGo0F4eDgWL15c3shE9AiFh5V6BLvBTCb6iYxEROVS7iKzaNEiTJo0CfHx8fjll1/g4OAAoOB06YEDB5ZrW2vXrn3k8xYWFli0aBEWLVpU3phEVAY52nzsfHCn6148rEREJkgiCIIgdojKpFaroVKpkJGRwfkyRP/xe8xt/G9tDLwcamH/+A68SSQRGY2yfn6Xexw5KioK69evL7Z8/fr1WLFiRXk3R0Qi2vjgsFKvxu4sMURkkspdZGbPng1Hx+ITAp2dnTFr1qwKCUVEle9OlgYHLxfc6ZqHlYjIVJW7yMTFxcHHx6fYci8vL8PtBYjI+P1xOhE6vYDgOirUdbIWOw4R0RMpd5FxdnbG6dOniy0/deqUYeIvERm/jQ9uSdCLtyQgIhNW7iIzcOBAvPPOO9i3bx90Oh10Oh327t2L//3vfxgwYEBlZCSiCnYzLRsn49IhlQA9G/NO10Rkusp9+vWMGTNw48YNPPfcczAzK3i5Xq/HoEGDOEeGyET8/uBO1238HOFsYyFyGiKiJ1fuIiOXy7Fu3Tp88skniImJgaWlJRo1agQvL6/KyEdEFUwQBB5WIqJq44nvDlevXj3Uq1evIrMQURU4e1uNa6nZUJhJER7EO10TkWkr9xyZyMhIfPrpp8WWz507F3379q2QUERUeQpHY8ICXWBjYS5yGiKip1PuInPw4EHD/ZUeFhERgYMHD1ZIKCKqHDq9gE2nCubH9OZhJSKqBspdZLKysiCXy4stNzc3h1qtrpBQRFQ5Dl29g9RMDWxrmaN9fSex4xARPbVyF5lGjRph3bp1xZavXbsWgYGBFRKKiCrHxpMFozHdG7lBbsY7XROR6Sv3ZN/JkyfjxRdfxNWrV9GpUycAwJ49e7B69Wps2LChwgMSUcXIzdNhx7kkAEBv3pKAiKqJcheZnj17YuPGjZg1axY2bNgAS0tLNG7cGHv37oW9vX1lZCSiCrD7QjKyNPmobWuJ5p52YschIqoQT3T6dffu3dG9e3cABbfZXrNmDcaPH48TJ05Ap9NVaEAiqhiFh5V6NXGHVMo7XRNR9fDEB8kPHjyIwYMHw93dHZ9//jk6deqEw4cPV2Q2Iqog6TlaHLiUAoCHlYioeinXiExSUhKWL1+OZcuWQa1Wo1+/ftBoNNi4cSMn+hIZsT/OJCJPJyDATYn6LjZixyEiqjBlHpHp2bMn/P39cfr0aXz55ZdISEjAwoULKzMbEVWQjScLLoL3QlN3kZMQEVWsMo/IbNu2De+88w5GjhzJWxMQmZBb93Jw7MY9SCTA8415WImIqpcyj8j89ddfyMzMRPPmzRESEoKvv/4ad+7cqcxsRFQBCu903drHAa4q3umaiKqXMheZ1q1bY+nSpUhMTMSbb76JtWvXwt3dHXq9Hrt27UJmZmZl5iSiJyAIAn5/cG+l3jysRETVULnPWrKyssLrr7+Ov/76C2fOnMG7776LOXPmwNnZGc8//3xlZCSiJ3QhMROXkrMgl0nRtaGb2HGIiCrcU12j3N/fH3PnzsWtW7ewZs2aispERBWkcDSmUwNnqCx5p2siqn4q5GYrMpkMvXv3xqZNmypic0RUAfQP3+mah5WIqJriXeOIqqkj1+8iMSMXSgszdPB3FjsOEVGlYJEhqqYKrx3TrZEbLMxlIqchIqocLDJE1VBung5bzyYCAHo14bVjiKj6YpEhqob2x6YgMzcfbioLhPjwrvREVH2xyBBVQ4V3un6+Me90TUTVG4sMUTWTcT8Pey8W3Omah5WIqLpjkSGqZrafTYRWp0d9F2sEuPFO10RUvbHIEFUzhYeVejWpDYmEh5WIqHpjkSGqRhIz7uPw9TQAQK8mvAgeEVV/LDJE1cjqI3EQBKCVtz3q2NUSOw4RUaVjkSGqJm7dy8F3B68BAF5r4y1uGCKiKsIiQ1RNzN52EZp8PVr72qNrQ1ex4xARVQmjKTJz5syBRCLBmDFjDMtyc3MxatQoODg4wNraGpGRkUhOThYvJJGROnwtDX+cToRUAkztGcRJvkRUYxhFkTl27Bi+/fZbBAcHF1k+duxYbN68GevXr8eBAweQkJCAF198UaSURMZJpxcwffN5AMBLIZ4IcFOKnIiIqOqIXmSysrLw8ssvY+nSpbCzszMsz8jIwLJly/DFF1+gU6dOaN68OaKionDo0CEcPnxYxMRExmXdsXhcSFRDaWGGcZ39xY5DRFSlRC8yo0aNQvfu3REWFlZk+YkTJ5CXl1dkeYMGDeDp6Yno6OiqjklklDJy8jBvZywAYFzn+rC3kouciIioapmJ+eZr167FP//8g2PHjhV7LikpCXK5HLa2tkWWu7i4ICkpqdRtajQaaDQaw9dqtbrC8hIZm6/2XMbdbC3qOVvj5dZeYschIqpyoo3IxMfH43//+x9WrVoFCwuLCtvu7NmzoVKpDA8PD48K2zaRMbmSkokfo28AAKb0DIS5TPQBViKiKifab74TJ04gJSUFzZo1g5mZGczMzHDgwAEsWLAAZmZmcHFxgVarRXp6epHXJScnw9W19FNLJ06ciIyMDMMjPj6+kveEqOoJgoCPt1xAvl5A50AXtK3nJHYkIiJRiHZo6bnnnsOZM2eKLHvttdfQoEEDTJgwAR4eHjA3N8eePXsQGRkJAIiNjUVcXBxCQ0NL3a5CoYBCoajU7ERi23sxBQcvpUIuk+KjbgFixyEiEo1oRcbGxgYNGzYssszKygoODg6G5UOHDsW4ceNgb28PpVKJ0aNHIzQ0FK1btxYjMpFR0ObrMWNLwenWrz/rA29HK5ETERGJR9TJvo8zf/58SKVSREZGQqPRIDw8HIsXLxY7FpGoov6+jhtpOXCyUeDtTn5ixyEiEpVEEARB7BCVSa1WQ6VSISMjA0olLxRGpi0lMxed5h1AliYf8/o2Rp/mdcSORERUKcr6+c3THIhMyLwdscjS5KOxhy1ebFpb7DhERKJjkSEyEadvpWP9iVsAgKk9AyGV8n5KREQsMkQmQBAETNt0DoIAvNi0Npp52j3+RURENQCLDJEJ2HQqAf/EpaOWXIYJEQ3EjkNEZDRYZIiMXI42H7O3XgQAjOroBxdlxV0Jm4jI1LHIEBm5b/ZfRZI6Fx72lhj6rI/YcYiIjAqLDJERi7+bg28PXgMAfNQtEBbmMpETEREZFxYZIiM2a+sFaPP1aOPngPAgF7HjEBEZHRYZIiN16OodbDubBKkEmNIjCBIJT7cmIvovFhkiI5Sv0+PjzQX3U3qltRf8XW1ETkREZJxYZIiM0Jpj8biYlAnbWuYY17m+2HGIiIwWiwyRkUnP0eKLnbEAgHGd68O2llzkRERExotFhsjIfLn7Mu7l5MHfxQYvtfIUOw4RkVFjkSEyIpeSM/HT4ZsAgCk9A2Em4z9RIqJH4W9JIiMhCAJmbDkPnV5AeJAL2vg5ih2JiMjoscgQGYld55Px5+U7kJtJ8VG3QLHjEBGZBBYZIiOgydfhkz8uAACGtfWBp0MtkRMREZkGFhkiI/DDXzcQdzcHzjYKvNXBT+w4REQmg0WGSGQp6lx8vfcyAOCDiAawUpiJnIiIyHSwyBCJ7NPtscjW6tDU0xa9m9QWOw4RkUlhkSESUUx8On755xYAYGrPIEilvJ8SEVF5sMgQiUSvFzBt0zkAQGSzOmjiYStuICIiE8QiQySSjTG3EROfDiu5DBO6+osdh4jIJLHIEIkgW5OPOdsuAgDe7lQPzkoLkRMREZkmFhkiESzadwUpmRp4OdTC6896ix2HiMhkscgQVbG4tBx8/+d1AMCk7oFQmMlETkREZLpYZIiq2Myt56HV6dG2niPCApzFjkNEZNJYZIiq0J+XU7HjXDJkUgmm9AiERMLTrYmIngaLDFEV0eTrMPX3gtOtB4V6oZ6LjciJiIhMH4sMURX5/s/ruHYnG042CoztXF/sOERE1QKLDFEVuJ1+Hwsf3E/po24BUFqYi5yIiKh6YJEhqgIzNp9Hbp4erXzs0auJu9hxiIiqDRYZokq2PzYF288lQSaVYEavhpzgS0RUgVhkiCqRJl9nuJ/Sa894w9+VE3yJiCoSiwxRJVp68BpupOXA2UaB/4XVEzsOEVG1wyJDVEni7+bg631XAAAfdQ+ADSf4EhFVOBYZokoyY0vBBN8QH3s835gTfImIKoOoReabb75BcHAwlEollEolQkNDsW3bNsPzubm5GDVqFBwcHGBtbY3IyEgkJyeLmJiobPZdTMHO8wVX8J3RmxN8iYgqi6hFpk6dOpgzZw5OnDiB48ePo1OnTujVqxfOnSuYHDl27Fhs3rwZ69evx4EDB5CQkIAXX3xRzMhEj5Wbp8O0zQV/h19v4436vIIvEVGlkQiCIIgd4mH29vb47LPP0KdPHzg5OWH16tXo06cPAODixYsICAhAdHQ0WrduXabtqdVqqFQqZGRkQKlUVmZ0IgDAgj2X8cWuS3BRKrDn3Q6wVpiJHYmIyOSU9fPbaObI6HQ6rF27FtnZ2QgNDcWJEyeQl5eHsLAwwzoNGjSAp6cnoqOjS92ORqOBWq0u8iCqKvF3c7DIMME3kCWGiKiSiV5kzpw5A2traygUCowYMQK//fYbAgMDkZSUBLlcDltb2yLru7i4ICkpqdTtzZ49GyqVyvDw8PCo5D0g+tf0zeehydcj1NcBPYPdxI5DRFTtiV5k/P39ERMTgyNHjmDkyJEYPHgwzp8//8TbmzhxIjIyMgyP+Pj4CkxLVLo9F5Kx+0IyzKQSfNwriBN8iYiqgOjj3nK5HH5+fgCA5s2b49ixY/jqq6/Qv39/aLVapKenFxmVSU5Ohqura6nbUygUUCgUlR2bqIiHJ/gOfdYH9TjBl4ioSog+IvNfer0eGo0GzZs3h7m5Ofbs2WN4LjY2FnFxcQgNDRUxIVFxSw5cRfzd+3BVWmD0c7yCLxFRVRF1RGbixImIiIiAp6cnMjMzsXr1auzfvx87duyASqXC0KFDMW7cONjb20OpVGL06NEIDQ0t8xlLRFUhLi0Hi/dfBQBM6hHACb5ERFVI1N+4KSkpGDRoEBITE6FSqRAcHIwdO3agc+fOAID58+dDKpUiMjISGo0G4eHhWLx4sZiRiYqZvvkctPl6tPFzQPdGnOBLRFSVjO46MhWN15GhyrT7fDLe+PE4zGUSbPtfO/g5W4sdiYioWjC568gQmZqiE3x9WWKIiETAIkP0hBbvv4pb9+7DTWWB0Z38xI5DRFQjscgQPYEbd7Kx5EDBBN/JPQJhxQm+RESiYJEhKidBEDDtwQTftvUcEdGw9OsaERFR5WKRISqnXeeTsT82FeYyCaY9zyv4EhGJiUWGqBzua3WYvrngFhrD2vqirhMn+BIRiYlFhqgcFu+/gtvp9+GussDbnOBLRCQ6FhmiMrp+JxvfHrgGAJjSMxC15JzgS0QkNhYZojIQBAFTN52DVqdHu/pOCA/iBF8iImPAIkNUBjvOJePgpVTIZVJM5wRfIiKjwSJD9Bg52nzM2FIwwXd4O1/4OFqJnIiIiAqxyBA9xqJ9BRN8a9taYlRHTvAlIjImLDJEj3AtNQvfHfx3gq+lXCZyIiIiehiLDFEpCif45ukEdPB3QpdAF7EjERHRf7DIEJVi+9kk/Hn5DuQyKab15ARfIiJjxCJDVIIcbT4+fjDBd0R7X3hzgi8RkVFikSEqwcK9V5CYkYs6dpYY2YETfImIjBWLDNF/XEnJwvd/FkzwndoziBN8iYiMGIsM0UM0+Tp8+NsZ5OkEdGrgjLAAZ7EjERHRI7DIED2gzddj1Kp/cPT6XViayzC1ZyAn+BIRGTkWGSIAeTo9Rq/5B7svpEBhJsX3g1vAy4ETfImIjB2LDNV4+To9xqyLwY5zyZDLpPhuUAu08XMUOxYREZUBiwzVaDq9gHfXn8IfpxNhLpNgyavN0L6+k9ixiIiojFhkqMbS6wW8v+E0fo9JgJlUgkUvNUOnBrx6LxGRKWGRoRpJrxcw8dcz+OWfW5BJJVg4sCm6BLmKHYuIiMqJRYZqHEEQMPn3s1h3PB5SCfBl/yaIaOQmdiwiInoCLDJUowiCgGmbzmHVkThIJMDn/RqjZ2N3sWMREdETYpGhGkMQBHzyxwWsiL4JiQSYGxmMF5rWETsWERE9BRYZqhEEQcCc7Rex7K/rAIDZLzRC3xYeIqciIqKnxSJDNcIXuy7h2wMF90+a0bshBrTyFDkRERFVBBYZqva+2n0ZC/deAQBM7RmIV1t7iZyIiIgqCosMVWuL9l3B/N2XAAAfdQvAa218RE5EREQViUWGqq3vDl7FZztiAQDvd/XHsHa+IiciIqKKxiJD1dKyv65j1taLAIBxnevjrQ5+IiciIqLKwCJD1c6P0TcwY8t5AMA7nfzwznP1RE5ERESVhUWGqpXVR+Iw5fdzAICRHepibOf6IiciIqLKxCJD1cbPx+Px4W9nAADD2vrg/XB/SCQSkVMREVFlErXIzJ49Gy1btoSNjQ2cnZ3Ru3dvxMbGFlknNzcXo0aNgoODA6ytrREZGYnk5GSREpOx+vWfW5jwy2kAwGttvPFhtwCWGCKiGkDUInPgwAGMGjUKhw8fxq5du5CXl4cuXbogOzvbsM7YsWOxefNmrF+/HgcOHEBCQgJefPFFEVOTsfk95jbGrz8FQQBebe2FKT0CWWKIiGoIiSAIgtghCqWmpsLZ2RkHDhxAu3btkJGRAScnJ6xevRp9+vQBAFy8eBEBAQGIjo5G69atH7tNtVoNlUqFjIwMKJXKyt4FqmJ/nE7EO2tPQqcXMLCVB2b2bgSplCWGiMjUlfXz26jmyGRkZAAA7O3tAQAnTpxAXl4ewsLCDOs0aNAAnp6eiI6OLnEbGo0GarW6yIOqpx3nkvC/ByWmT/M6LDFERDWQ0RQZvV6PMWPGoE2bNmjYsCEAICkpCXK5HLa2tkXWdXFxQVJSUonbmT17NlQqleHh4cEbA1ZHey4k4+3V/yBfL+CFprXxaWQwSwwRUQ1kNEVm1KhROHv2LNauXftU25k4cSIyMjIMj/j4+ApKSMZi1/lkjFz5D/J0Ano2dsdnfYIhY4khIqqRzMQOAABvv/02tmzZgoMHD6JOnTqG5a6urtBqtUhPTy8yKpOcnAxXV9cSt6VQKKBQKCo7MolAEAQs3n8V83bGQhCAiIaumN+vMcxkRtPHiYioion6CSAIAt5++2389ttv2Lt3L3x8it7Qr3nz5jA3N8eePXsMy2JjYxEXF4fQ0NCqjksiytbkY9Tqf/DZjoIS80prTywY2JQlhoiohhN1RGbUqFFYvXo1fv/9d9jY2BjmvahUKlhaWkKlUmHo0KEYN24c7O3toVQqMXr0aISGhpbpjCWqHuLScjD8p+O4mJQJc5kEH/dqiIGtPMWORURERkDU069Lu9ZHVFQUhgwZAqDggnjvvvsu1qxZA41Gg/DwcCxevLjUQ0v/xdOvTdufl1Px9uqTyLifBycbBZa80gzNvezFjkVERJWsrJ/fRnUdmcrAImOaBEHA939ex+xtF6AXgMYetvj2leZwVVmIHY2IiKpAWT+/jWKyL9HDcvN0+OCX09gYkwAA6Nu8Dmb0bggLc5nIyYiIyNiwyJBRuZ1+H2/+dBxnb6shk0owpUcgBoV68ZYDRERUIhYZMhpHrqXhrVX/IC1bC3srORa91AyhdR3EjkVEREaMRYZEJwgCfjp8Ex9vPo98vYAgdyW+fbU56tjVEjsaEREZORYZEpUmX4fJG8/i5+O3AADPN3bHp5HBsJRzPgwRET0eiwyJJlmdixErT+BkXDqkEuCDiAYY1taX82GIiKjMWGRIFP/E3cOIn04gJVMDlaU5Fg5sinb1ncSORUREJoZFhqrcumNxmLzxHLQ6Peq7WGPpoBbwcrASOxYREZkgFhmqMtp8PWZsOY+fDt8EAHQNcsW8fo1hreBfQyIiejL8BKEqcSdLg7dW/oOjN+5CIgHGhdXHqI5+kEo5H4aIiJ4ciwxVujO3MvDmT8eRkJELa4UZvuzfBGGBLmLHIiKiaoBFhirVxpO3MeGX09Dk6+HraIXvBrWAn7O12LGIiKiaYJGhSpGv02POtov4/q/rAIBODZzx5YAmUFqYi5yMiIiqExYZqnDJ6ly8+/Mp/HXlDgDg7Y5+GNe5PufDEBFRhWORoQqTp9NjxaEbmL/rErK1OtSSyzCvb2N0a+QmdjQiIqqmWGSoQhy9fheTN55FbHImAKCppy3mvBgMf1cbkZMREVF1xiJDTyU1U4PZ2y7g139uAwDsapnjg4gG6Nvcg4eSiIio0rHI0BPR6QWsPHwT83bGIjM3HxIJMKClJ94P94edlVzseEREVEOwyFC5/RN3D5M3nsW5BDUAoFFtFWb0bogmHrbiBiMiohqHRYbK7G62FnO3X8TaY/EAAKWFGd7r2gAvtfKEjIeRiIhIBCwy9Fh6vYC1x+Ixd8dFpOfkAQD6NK+DDyIawNFaIXI6IiKqyVhk6JHO3MrApN/P4lR8OgCggasNZvRuiJbe9uIGIyIiAosMlSIjJw/zdsZi5ZGbEATAWmGGcZ3rY1CoF8xkUrHjERERAWCRof/Q6wX88s8tzNl2EWnZWgBArybu+KhbAJyVFiKnIyIiKopFhgwuJKoxeeNZHL95DwDg52yNj3sF4Zm6jiInIyIiKhmLzBPadCoBf11ORaCbEkG1VWjgagMbE70hYmZuHr7YdQk/Rt+ETi+gllyGd56rh9fb+EBuxsNIRERkvFhkntCB2FT88s+tIsu8HWoh0F1ZUG7cVQh0V8LZRgGJxDhPTRYEAZtOJeCTPy4gNVMDAOjWyBWTugfC3dZS5HRERESPxyLzhCKb1UZtWwucT1TjXIIaiRm5uJGWgxtpOdh6JsmwnoOVvKDcPFRwfBytRLvuSr5Oj7s5WsTfzcG8HZcQfS0NAODjaIVpzwehfX0nUXIRERE9CYkgCILYISqTWq2GSqVCRkYGlEplpb3P3WwtzieocT4xA+cTCsrN1dQs6Ev47lqYS9HAVYmghwpOA1clLOWyJ3rv+1od7mRpcCdLg7QsbcF/s7VIzSy+7F6OFg//xBVmUrzd0Q/D2/tCYfZk709ERFTRyvr5zSJTiXLzdIhNysS5hwrOhcRM3M/TFVtXKgF8nawfjNoUFBxXpQXuZmtxp7CIZGmQmqVFWmFpydbiTqYG2dri23sUqQSwt5KjlY89JkYEwMO+VkXtMhERUYVgkXlAzCJTEp1ewI20bMOozflENc4nZOBOlvaptiuXSeFoLYejjQKO1go4WBX82cFKDqfCZdZyOForYFdLzlsKEBGRUSvr5zfnyFQxmVSCuk7WqOtkjZ6N3Q3LU9S5OJeoLjg8laDGuYQMpGVr/y0l1go42sjhYKUoKCtWD5UWazlsFGZGO6mYiIiosrDIGAlnpQWclRbo6O8sdhQiIiKTwYuEEBERkclikSEiIiKTxSJDREREJotFhoiIiEyWqEXm4MGD6NmzJ9zd3SGRSLBx48YizwuCgClTpsDNzQ2WlpYICwvD5cuXxQlLRERERkfUIpOdnY3GjRtj0aJFJT4/d+5cLFiwAEuWLMGRI0dgZWWF8PBw5ObmVnFSIiIiMkainn4dERGBiIiIEp8TBAFffvklJk2ahF69egEAfvzxR7i4uGDjxo0YMGBAVUYlIiIiI2S0c2SuX7+OpKQkhIWFGZapVCqEhIQgOjq61NdpNBqo1eoiDyIiIqqejLbIJCUV3EHaxcWlyHIXFxfDcyWZPXs2VCqV4eHh4VGpOYmIiEg8RltkntTEiRORkZFheMTHx4sdiYiIiCqJ0RYZV1dXAEBycnKR5cnJyYbnSqJQKKBUKos8iIiIqHoy2iLj4+MDV1dX7Nmzx7BMrVbjyJEjCA0NFTEZERERGQtRz1rKysrClStXDF9fv34dMTExsLe3h6enJ8aMGYNPPvkE9erVg4+PDyZPngx3d3f07t1bvNBERERkNEQtMsePH0fHjh0NX48bNw4AMHjwYCxfvhzvv/8+srOzMXz4cKSnp+PZZ5/F9u3bYWFhIVZkIiIiMiISQRAEsUNUpoyMDNja2iI+Pp7zZYiIiEyEWq2Gh4cH0tPToVKpSl1P1BGZqpCZmQkAPA2biIjIBGVmZj6yyFT7ERm9Xo+EhATY2NhAIpFU2HYLm2JNGempSfvLfa2+atL+cl+rr5qyv4IgIDMzE+7u7pBKSz83qdqPyEilUtSpU6fStl/TTvGuSfvLfa2+atL+cl+rr5qwv48aiSlktKdfExERET0OiwwRERGZLBaZJ6RQKDB16lQoFAqxo1SJmrS/3NfqqybtL/e1+qpp+/s41X6yLxEREVVfHJEhIiIik8UiQ0RERCaLRYaIiIhMFosMERERmSwWmXK6ceMGhg4dCh8fH1haWqJu3bqYOnUqtFptkfVOnz6Ntm3bwsLCAh4eHpg7d65IiZ/ezJkz8cwzz6BWrVqwtbUtcR2JRFLssXbt2qoNWgHKsq9xcXHo3r07atWqBWdnZ7z33nvIz8+v2qCVxNvbu9jPcc6cOWLHqhCLFi2Ct7c3LCwsEBISgqNHj4odqVJMmzat2M+wQYMGYseqEAcPHkTPnj3h7u4OiUSCjRs3FnleEARMmTIFbm5usLS0RFhYGC5fvixO2ArwuP0dMmRIsZ91165dxQkrIhaZcrp48SL0ej2+/fZbnDt3DvPnz8eSJUvw4YcfGtZRq9Xo0qULvLy8cOLECXz22WeYNm0avvvuOxGTPzmtVou+ffti5MiRj1wvKioKiYmJhkfv3r2rJmAFety+6nQ6dO/eHVqtFocOHcKKFSuwfPlyTJkypYqTVp6PP/64yM9x9OjRYkd6auvWrcO4ceMwdepU/PPPP2jcuDHCw8ORkpIidrRKERQUVORn+Ndff4kdqUJkZ2ejcePGWLRoUYnPz507FwsWLMCSJUtw5MgRWFlZITw8HLm5uVWctGI8bn8BoGvXrkV+1mvWrKnChEZCoKc2d+5cwcfHx/D14sWLBTs7O0Gj0RiWTZgwQfD39xcjXoWJiooSVCpVic8BEH777bcqzVOZStvXrVu3ClKpVEhKSjIs++abbwSlUlnk522qvLy8hPnz54sdo8K1atVKGDVqlOFrnU4nuLu7C7NnzxYxVeWYOnWq0LhxY7FjVLr//s7R6/WCq6ur8NlnnxmWpaenCwqFQlizZo0ICStWSb9jBw8eLPTq1UuUPMaEIzIVICMjA/b29oavo6Oj0a5dO8jlcsOy8PBwxMbG4t69e2JErBKjRo2Co6MjWrVqhR9++AFCNbxEUXR0NBo1agQXFxfDsvDwcKjVapw7d07EZBVnzpw5cHBwQNOmTfHZZ5+Z/GEzrVaLEydOICwszLBMKpUiLCwM0dHRIiarPJcvX4a7uzt8fX3x8ssvIy4uTuxIle769etISkoq8nNWqVQICQmptj9nANi/fz+cnZ3h7++PkSNHIi0tTexIVa7a3zSysl25cgULFy7EvHnzDMuSkpLg4+NTZL3CD76kpCTY2dlVacaq8PHHH6NTp06oVasWdu7cibfeegtZWVl45513xI5WoZKSkoqUGKDoz9bUvfPOO2jWrBns7e1x6NAhTJw4EYmJifjiiy/EjvbE7ty5A51OV+LP7eLFiyKlqjwhISFYvnw5/P39kZiYiOnTp6Nt27Y4e/YsbGxsxI5XaQr//ZX0c64O/zZL0rVrV7z44ovw8fHB1atX8eGHHyIiIgLR0dGQyWRix6syHJF54IMPPihxwurDj//+0rt9+za6du2Kvn37YtiwYSIlfzJPsr+PMnnyZLRp0wZNmzbFhAkT8P777+Ozzz6rxD0ou4reV1NTnv0fN24cOnTogODgYIwYMQKff/45Fi5cCI1GI/JeUFlFRESgb9++CA4ORnh4OLZu3Yr09HT8/PPPYkejCjZgwAA8//zzaNSoEXr37o0tW7bg2LFj2L9/v9jRqhRHZB549913MWTIkEeu4+vra/hzQkICOnbsiGeeeabYJF5XV1ckJycXWVb4taura8UEfkrl3d/yCgkJwYwZM6DRaES/H0hF7qurq2uxs12M7Wf7X0+z/yEhIcjPz8eNGzfg7+9fCekqn6OjI2QyWYn/Jo31Z1aRbG1tUb9+fVy5ckXsKJWq8GeZnJwMNzc3w/Lk5GQ0adJEpFRVy9fXF46Ojrhy5Qqee+45seNUGRaZB5ycnODk5FSmdW/fvo2OHTuiefPmiIqKglRadGArNDQUH330EfLy8mBubg4A2LVrF/z9/Y3msFJ59vdJxMTEwM7OTvQSA1TsvoaGhmLmzJlISUmBs7MzgIKfrVKpRGBgYIW8R0V7mv2PiYmBVCo17KspksvlaN68Ofbs2WM4k06v12PPnj14++23xQ1XBbKysnD16lW8+uqrYkepVD4+PnB1dcWePXsMxUWtVuPIkSOPPeOyurh16xbS0tKKFLmagEWmnG7fvo0OHTrAy8sL8+bNQ2pqquG5wv8jeOmllzB9+nQMHToUEyZMwNmzZ/HVV19h/vz5YsV+KnFxcbh79y7i4uKg0+kQExMDAPDz84O1tTU2b96M5ORktG7dGhYWFti1axdmzZqF8ePHixv8CTxuX7t06YLAwEC8+uqrmDt3LpKSkjBp0iSMGjXKKErb04iOjsaRI0fQsWNH2NjYIDo6GmPHjsUrr7xiNAX8SY0bNw6DBw9GixYt0KpVK3z55ZfIzs7Ga6+9Jna0Cjd+/Hj07NkTXl5eSEhIwNSpUyGTyTBw4ECxoz21rKysIiNL169fR0xMDOzt7eHp6YkxY8bgk08+Qb169eDj44PJkyfD3d3dJC8FATx6f+3t7TF9+nRERkbC1dUVV69exfvvvw8/Pz+Eh4eLmFoEYp82ZWqioqIEACU+Hnbq1Cnh2WefFRQKhVC7dm1hzpw5IiV+eoMHDy5xf/ft2ycIgiBs27ZNaNKkiWBtbS1YWVkJjRs3FpYsWSLodDpxgz+Bx+2rIAjCjRs3hIiICMHS0lJwdHQU3n33XSEvL0+80BXkxIkTQkhIiKBSqQQLCwshICBAmDVrlpCbmyt2tAqxcOFCwdPTU5DL5UKrVq2Ew4cPix2pUvTv319wc3MT5HK5ULt2baF///7ClStXxI5VIfbt21fiv8/BgwcLglBwCvbkyZMFFxcXQaFQCM8995wQGxsrbuin8Kj9zcnJEbp06SI4OTkJ5ubmgpeXlzBs2LAil4aoKSSCUA3PkSUiIqIagWctERERkclikSEiIiKTxSJDREREJotFhoiIiEwWiwwRERGZLBYZIiIiMlksMkRERGSyWGSIiIjIZLHIEJGoUlNTMXLkSHh6ekKhUMDV1RXh4eH4+++/AQDe3t6QSCQ4fPhwkdeNGTMGHTp0MHw9bdo0w928ZTIZPDw8MHz4cNy9e7cqd4eIqhjvtUREooqMjIRWq8WKFSvg6+uL5ORk7NmzB2lpaYZ1LCwsMGHCBBw4cOCR2woKCsLu3buh0+lw4cIFvP7668jIyMC6desqezeISCQsMkQkmvT0dPz555/Yv38/2rdvDwDw8vJCq1atiqw3fPhwLFmyBFu3bkW3bt1K3Z6ZmZnh5q21a9dG3759ERUVZXheEARMnz4dP/zwA5KTk+Hg4IA+ffpgwYIFlbB3RFQVeGiJiERjbW0Na2trbNy4ERqNptT1fHx8MGLECEycOBF6vb5M275x4wZ27NgBuVxuWPbLL79g/vz5+Pbbb3H58mVs3LgRjRo1eur9ICLxsMgQkWjMzMywfPlyrFixAra2tmjTpg0+/PBDnD59uti6kyZNwvXr17Fq1apSt3fmzBlYW1vD0tISPj4+OHfuHCZMmGB4Pi4uDq6urggLC4OnpydatWqFYcOGVcq+EVHVYJEhIlFFRkYiISEBmzZtQteuXbF//340a9YMy5cvL7Kek5MTxo8fjylTpkCr1Za4LX9/f8TExODYsWOYMGECwsPDMXr0aMPzffv2xf379+Hr64thw4bht99+Q35+fmXuHhFVMhYZIhKdhYUFOnfujMmTJ+PQoUMYMmQIpk6dWmy9cePG4f79+1i8eHGJ25HL5fDz80PDhg0xZ84cyGQyTJ8+3fC8h4cHYmNjsXjxYlhaWuKtt95Cu3btkJeXV2n7RkSVi0WGiIxOYGAgsrOziy23trbG5MmTMXPmTGRmZj52O5MmTcK8efOQkJBgWGZpaYmePXtiwYIF2L9/P6Kjo3HmzJkKzU9EVYdFhohEk5aWhk6dOmHlypU4ffo0rl+/jvXr12Pu3Lno1atXia8ZPnw4VCoVVq9e/djth4aGIjg4GLNmzQIALF++HMuWLcPZs2dx7do1rFy5EpaWlvDy8qrQ/SKiqsMiQ0Sisba2RkhICObPn4927dqhYcOGmDx5MoYNG4avv/66xNeYm5tjxowZyM3NLdN7jB07Ft9//z3i4+Nha2uLpUuXok2bNggODsbu3buxefNmODg4VORuEVEVkgiCIIgdgoiIiOhJcESGiIiITBaLDBEREZksFhkiIiIyWSwyREREZLJYZIiIiMhkscgQERGRyWKRISIiIpPFIkNEREQmi0WGiIiITBaLDBEREZksFhkiIiIyWSwyREREZLL+D5aq8Vg8auWHAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.plot(snr_acc_arr[:,1], snr_acc_arr[:,0], label='SNR vs Accuracy')\n",
    "\n",
    "# Adding labels and title\n",
    "plt.xlabel('SNRs')\n",
    "plt.ylabel('Accs')\n",
    "plt.title('SNR vs Accuracy')\n",
    "\n",
    "# Adding a legend\n",
    "plt.legend()\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}