phase-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TJD1wf5c5Wn6"
   },
   "source": [
    "<div style=\"direction:ltr; line-height:300%; font-size:20px;\">\n",
    "  <div align=\"center\">\n",
    "    <img src=\"./images/logo_sharif.png\" alt=\"Sharif University Logo\" width=\"350px\">\n",
    "    <h1>Advanced Recommender Systems</h1>\n",
    "    <h3>Sharif University of Technology</h3>\n",
    "    <p>Department of Computer Engineering</p>\n",
    "  </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MNIMhq-Y5Wn7"
   },
   "source": [
    "# 🛠️ Phase 2: Machine Learning and Clustering for Document Retrieval\n",
    "\n",
    "In this phase, you'll enhance the system's retrieval capabilities using machine learning techniques. This involves implementing document classification and clustering to improve the search system developed in Phase 1.\n",
    "\n",
    "### Key Components:\n",
    "\n",
    "- **📂 Dataset**: Download the scientific articles dataset from [Kaggle](https://www.kaggle.com/datasets/spsayakpaul/arxiv-paper-abstracts?resource=download).\n",
    "- **📊 Naive Bayes Classification**: Implement a Naive Bayes classifier from scratch to categorize documents.\n",
    "- **🤖 Neural Network Classifier**: Implement a neural network classifier from scratch to categorize documents.\n",
    "- **🧠 Large Language Models**: Fine-tune a pre-trained language model to classify documents.\n",
    "- **🧮 Hierarchical Clustering**: Apply hierarchical clustering to group similar documents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 📂 Dataset Download and Exploration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Start by downloading the dataset from Kaggle. Familiarize yourself with its structure and features.\n",
    "\n",
    "### Steps:\n",
    "\n",
    "1. **Download Dataset**: Obtain the dataset from the provided Kaggle link.\n",
    "2. **Explore the Data**: Inspect the dataset to understand its structure and contents.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: Your Kaggle API key is readable by other users on this system! To fix this, you can run 'chmod 600 /home/alireza/.kaggle/kaggle.json'\n"
     ]
    }
   ],
   "source": [
    "import ast\n",
    "import collections\n",
    "import os\n",
    "\n",
    "import kaggle\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "dataset_path = \"./arxiv_data.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>titles</th>\n",
       "      <th>summaries</th>\n",
       "      <th>terms</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Survey on Semantic Stereo Matching / Semantic ...</td>\n",
       "      <td>Stereo matching is one of the widely used tech...</td>\n",
       "      <td>['cs.CV', 'cs.LG']</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>FUTURE-AI: Guiding Principles and Consensus Re...</td>\n",
       "      <td>The recent advancements in artificial intellig...</td>\n",
       "      <td>['cs.CV', 'cs.AI', 'cs.LG']</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Enforcing Mutual Consistency of Hard Regions f...</td>\n",
       "      <td>In this paper, we proposed a novel mutual cons...</td>\n",
       "      <td>['cs.CV', 'cs.AI']</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Parameter Decoupling Strategy for Semi-supervi...</td>\n",
       "      <td>Consistency training has proven to be an advan...</td>\n",
       "      <td>['cs.CV']</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Background-Foreground Segmentation for Interio...</td>\n",
       "      <td>To ensure safety in automated driving, the cor...</td>\n",
       "      <td>['cs.CV', 'cs.LG']</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              titles  \\\n",
       "0  Survey on Semantic Stereo Matching / Semantic ...   \n",
       "1  FUTURE-AI: Guiding Principles and Consensus Re...   \n",
       "2  Enforcing Mutual Consistency of Hard Regions f...   \n",
       "3  Parameter Decoupling Strategy for Semi-supervi...   \n",
       "4  Background-Foreground Segmentation for Interio...   \n",
       "\n",
       "                                           summaries  \\\n",
       "0  Stereo matching is one of the widely used tech...   \n",
       "1  The recent advancements in artificial intellig...   \n",
       "2  In this paper, we proposed a novel mutual cons...   \n",
       "3  Consistency training has proven to be an advan...   \n",
       "4  To ensure safety in automated driving, the cor...   \n",
       "\n",
       "                         terms  \n",
       "0           ['cs.CV', 'cs.LG']  \n",
       "1  ['cs.CV', 'cs.AI', 'cs.LG']  \n",
       "2           ['cs.CV', 'cs.AI']  \n",
       "3                    ['cs.CV']  \n",
       "4           ['cs.CV', 'cs.LG']  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def load_dataset(dataset_path):\n",
    "    if not os.path.exists(dataset_path):\n",
    "        kaggle.api.authenticate()\n",
    "        kaggle.api.dataset_download_files('spsayakpaul/arxiv-paper-abstracts', path='.', unzip=True)\n",
    "    return pd.read_csv(dataset_path)\n",
    "\n",
    "dataset_df = load_dataset(dataset_path)\n",
    "dataset_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Missing values in each column:\n",
      "titles       0\n",
      "summaries    0\n",
      "terms        0\n",
      "dtype: int64\n",
      "\n",
      "Data types of each column:\n",
      "titles       object\n",
      "summaries    object\n",
      "terms        object\n",
      "dtype: object\n",
      "\n",
      "Distribution of the number of terms associated with papers:\n",
      "num_terms\n",
      "1     20282\n",
      "2     16449\n",
      "3     10417\n",
      "4      3380\n",
      "5       983\n",
      "6       210\n",
      "7        44\n",
      "8         6\n",
      "9         2\n",
      "11        1\n",
      "Name: count, dtype: int64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_736920/1268097819.py:23: FutureWarning: \n",
      "\n",
      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
      "\n",
      "  sns.countplot(x=self.dataset_df['num_terms'], palette='viridis')\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Most common terms (categories) and their counts:\n",
      "[('cs.CV', 30413), ('cs.LG', 29067), ('stat.ML', 15578), ('cs.AI', 7944), ('eess.IV', 2484), ('cs.RO', 1896), ('cs.CL', 1620), ('cs.NE', 1296), ('cs.CR', 717), ('cs.SI', 678)]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Summary statistics of title lengths:\n",
      "count    51774.000000\n",
      "mean        72.269402\n",
      "std         22.627789\n",
      "min          9.000000\n",
      "25%         57.000000\n",
      "50%         71.000000\n",
      "75%         86.000000\n",
      "max        234.000000\n",
      "Name: title_length, dtype: float64\n",
      "\n",
      "Summary statistics of summary lengths:\n",
      "count    51774.000000\n",
      "mean      1203.778673\n",
      "std        313.454487\n",
      "min         29.000000\n",
      "25%        986.000000\n",
      "50%       1193.000000\n",
      "75%       1412.000000\n",
      "max       3309.000000\n",
      "Name: summary_length, dtype: float64\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsAAAAIhCAYAAABANwzIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8S0lEQVR4nO3dd3xUVf7/8deQRhLCkBDSpGNoUqQoBAsgVUFUXFHRiKKIi6ui8LPuV3DXBcUVccGKLKCA6Cq4VpoiioD0HpCVEkpCCIRAID3398d1BoYUkjDJnWTez8djHvfm3jN3PnOZkHdOzj3XZhiGgYiIiIiIl6hhdQEiIiIiIpVJAVhEREREvIoCsIiIiIh4FQVgEREREfEqCsAiIiIi4lUUgEVERETEqygAi4iIiIhXUQAWEREREa+iACwiIiIiXkUBWKQamzVrFjabzfmoWbMmUVFR9OzZk4kTJ5KSklLoOePHj8dms5Xpdc6ePcv48eP58ccfy/S8ol6rcePGDBw4sEzHuZh58+YxZcqUIvfZbDbGjx/v1tdzt++//57OnTsTHByMzWbjiy++KLbtwYMHGTVqFM2bNycwMJCwsDDatm3LiBEjOHjwYOUVXY38+OOP2Gw2PvvsM6tLKVJJ33+O77HU1NTKL0zEg/laXYCIVLyZM2fSsmVLcnNzSUlJYeXKlbz66qv885//5JNPPqF3797Otg899BD9+/cv0/HPnj3LSy+9BECPHj1K/bzyvFZ5zJs3j+3btzN69OhC+1avXk39+vUrvIbyMgyDIUOG0Lx5c7788kuCg4Np0aJFkW0PHTpEx44dqVOnDmPGjKFFixakp6ezc+dOPv30U/bu3UuDBg0q+R1IRSvv95+IN1MAFvECbdq0oXPnzs6vb7/9dp588kmuvfZaBg8ezJ49e4iMjASgfv36FR4Iz549S1BQUKW81sV07drV0te/mCNHjnDixAluu+02evXqVWLb6dOnk5qaytq1a2nSpIlz+6233srzzz9PQUFBRZfrcTIzM6lZs2aZ/6ohItWbhkCIeKmGDRvy+uuvc/r0ad577z3n9qKGJfzwww/06NGDunXrEhgYSMOGDbn99ts5e/Ys+/fvp169egC89NJLzuEW999/v8vxNm7cyJ/+9CdCQ0Np1qxZsa/lsHDhQtq1a0fNmjVp2rQp//rXv1z2O4Z37N+/32W748/Vjj8H9+jRg2+++YYDBw64DAdxKGoIxPbt27nlllsIDQ2lZs2aXHnllcyePbvI1/n444954YUXiImJoXbt2vTu3Zvdu3cXf+LPs3LlSnr16kVISAhBQUF069aNb775xrl//Pjxzl8QnnnmGWw2G40bNy72eMePH6dGjRpEREQUub9GjXP/5ffo0aPI3sL777/f5TX279+PzWbjtdde49VXX6Vx48YEBgbSo0cPfvvtN3Jzc3n22WeJiYnBbrdz2223FRpa4xjW8vXXX9OhQwcCAwNp1aoVX3/9NWD+W7Zq1Yrg4GCuvvpq1q9f7/L89evXc9dddzlfu3Hjxtx9990cOHDApZ3jM7FkyRKGDx9OvXr1CAoKYuXKlc5/qwt9+OGH2Gw21q1bV+x5La3k5GRGjhxJ/fr18ff3p0mTJrz00kvk5eUVOp///Oc/mTx5Mk2aNKFWrVrExcWxZs2aQsecPn06zZs3JyAggNatWzNv3jyXf6OLff85HD16lLvvvhu73U5kZCTDhw8nPT3dpc1//vMfunTpgt1uJygoiKZNmzJ8+PBLPi8inkgBWMSL3XTTTfj4+PDTTz8V22b//v0MGDAAf39//v3vf7No0SJeeeUVgoODycnJITo6mkWLFgHw4IMPsnr1alavXs3//d//uRxn8ODBXH755fznP//h3XffLbGuzZs3M3r0aJ588kkWLlxIt27deOKJJ/jnP/9Z5vf49ttvc8011xAVFeWsbfXq1cW23717N926dWPHjh3861//YsGCBbRu3Zr777+fSZMmFWr//PPPc+DAAT744APef/999uzZw80330x+fn6Jda1YsYIbbriB9PR0ZsyYwccff0xISAg333wzn3zyCWAOEVmwYAEAjz32GKtXr2bhwoXFHjMuLo6CggIGDx7M4sWLOXXqVGlOUam89dZb/PLLL7z11lt88MEH7Nq1i5tvvpkHH3yQY8eO8e9//5tJkyaxbNkyHnrooULP37JlC8899xzPPPMMCxYswG63M3jwYMaNG8cHH3zAhAkTmDt3Lunp6QwcOJDMzEznc/fv30+LFi2YMmUKixcv5tVXXyUpKYmrrrqqyLGtw4cPx8/Pj48++ojPPvuMbt260aFDB956661CbadNm8ZVV13FVVdddUnnJzk5mauvvprFixfz4osv8t133/Hggw8yceJERowYUeT5XLp0KVOmTGHu3LmcOXOGm266ySWUvv/++zz88MO0a9eOBQsW8Ne//pWXXnrJZaxvab//br/9dpo3b87nn3/Os88+y7x583jyySed+1evXs2dd95J06ZNmT9/Pt988w0vvviiS3gXqVYMEam2Zs6caQDGunXrim0TGRlptGrVyvn1uHHjjPP/a/jss88MwNi8eXOxxzh27JgBGOPGjSu0z3G8F198sdh952vUqJFhs9kKvV6fPn2M2rVrG2fOnHF5b/v27XNpt3z5cgMwli9f7tw2YMAAo1GjRkXWfmHdd911lxEQEGAkJia6tLvxxhuNoKAg4+TJky6vc9NNN7m0+/TTTw3AWL16dZGv59C1a1cjIiLCOH36tHNbXl6e0aZNG6N+/fpGQUGBYRiGsW/fPgMwXnvttRKPZxiGUVBQYIwcOdKoUaOGARg2m81o1aqV8eSTTxY6T927dze6d+9e6BjDhg1zOVeO12/fvr2Rn5/v3D5lyhQDMAYNGuTy/NGjRxuAkZ6e7tzWqFEjIzAw0Dh06JBz2+bNmw3AiI6Odv6bGoZhfPHFFwZgfPnll8W+z7y8PCMjI8MIDg423nzzTed2x2fivvvuK/Qcx75NmzY5t61du9YAjNmzZxf7WoZx7t/6P//5T7FtRo4cadSqVcs4cOCAy/Z//vOfBmDs2LHDMIxz57Nt27ZGXl5eoVo+/vhjwzAMIz8/34iKijK6dOnicrwDBw4Yfn5+Lv9Gpfn+mzRpksv2UaNGGTVr1nR+zhx1Oj7fItWdeoBFvJxhGCXuv/LKK/H39+fhhx9m9uzZ7N27t1yvc/vtt5e67RVXXEH79u1dtg0dOpRTp06xcePGcr1+af3www/06tWr0MVi999/P2fPni3Uezxo0CCXr9u1awdQ6M/z5ztz5gy//vorf/rTn6hVq5Zzu4+PD/Hx8Rw6dKjUwyjOZ7PZePfdd9m7dy9vv/02DzzwALm5ubzxxhtcccUVrFixoszHdLjppptchlC0atUKgAEDBri0c2xPTEx02X7llVdy2WWXFWrXo0cPgoKCCm0///xlZGTwzDPPcPnll+Pr64uvry+1atXizJkzJCQkFKq1qM/a3XffTUREhEsv8NSpU6lXrx533nnnRd79xX399df07NmTmJgY8vLynI8bb7wRoNC5HzBgAD4+Ps6vL/zc7N69m+TkZIYMGeLyvIYNG3LNNdeUub6iPqdZWVnO4SqOHvAhQ4bw6aefcvjw4TK/hkhVogAs4sXOnDnD8ePHiYmJKbZNs2bNWLZsGRERETz66KM0a9aMZs2a8eabb5bptaKjo0vdNioqqthtx48fL9PrltXx48eLrNVxji58/bp167p8HRAQAODyJ/wLpaWlYRhGmV6nLBo1asSf//xnZsyYwZ49e/jkk0/Iysri//2//1fuY4aFhbl87e/vX+L2rKwstz1/6NChTJs2jYceeojFixezdu1a1q1bR7169Yo8z0Wd14CAAEaOHMm8efM4efIkx44d49NPP+Whhx5y/ptdiqNHj/LVV1/h5+fn8rjiiisACg3VuNjnxvHv77g49XxFbbuYi73e9ddfzxdffEFeXh733Xcf9evXp02bNkWOmxapDjQLhIgX++abb8jPz7/o1EnXXXcd1113Hfn5+axfv56pU6cyevRoIiMjueuuu0r1WmW5Cj85ObnYbY4f5DVr1gQgOzvbpd2lzndat25dkpKSCm0/cuQIAOHh4Zd0fIDQ0FBq1KhR4a/jMGTIECZOnMj27dud22rWrFnoIii49PPnbunp6Xz99deMGzeOZ5991rk9OzubEydOFPmc4j5rf/7zn3nllVf497//TVZWFnl5eTzyyCNuqTM8PJx27drxj3/8o8j9Jf2SWRTH5/zo0aOF9hX1/eEOt9xyC7fccgvZ2dmsWbOGiRMnMnToUBo3bkxcXFyFvKaIVdQDLOKlEhMTGTt2LHa7nZEjR5bqOT4+PnTp0sX5Z2THcITS9HqWxY4dO9iyZYvLtnnz5hESEkLHjh0BnFfBb9261aXdl19+Weh4AQEBpa6tV69e/PDDD84g6vDhhx8SFBTklmnTgoOD6dKlCwsWLHCpq6CggDlz5lC/fn2aN29e5uMWFajBHEJw8OBBlxDWuHFjfvvtN5dfII4fP86qVavK/LoVyWazYRhGoV7aDz744KIXGl4oOjqaO+64g7fffpt3332Xm2++mYYNG7qlzoEDB7J9+3aaNWtG586dCz3KGoBbtGhBVFQUn376qcv2xMTEQv9G7v7+CwgIoHv37rz66qsAbNq0yS3HFfEk6gEW8QLbt293jklMSUnh559/ZubMmfj4+LBw4ULnNEpFeffdd/nhhx8YMGAADRs2JCsri3//+98AzhtohISE0KhRI/773//Sq1cvwsLCCA8PL3HKrpLExMQwaNAgxo8fT3R0NHPmzGHp0qW8+uqrzvGiV111FS1atGDs2LHk5eURGhrKwoULWblyZaHjtW3blgULFvDOO+/QqVMnatSo4TIv8vnGjRvnHM/54osvEhYWxty5c/nmm2+YNGkSdru9XO/pQhMnTqRPnz707NmTsWPH4u/vz9tvv8327dv5+OOPyzVv7T/+8Q9++eUX7rzzTq688koCAwPZt28f06ZN4/jx47z22mvOtvHx8bz33nvce++9jBgxguPHjzNp0iRq167tlvfnLrVr1+b666/ntddec36mVqxYwYwZM6hTp06Zj/fEE0/QpUsXwLxBTFkUNU0ZQPfu3fnb3/7G0qVL6datG48//jgtWrQgKyuL/fv38+233/Luu++Wac7rGjVq8NJLLzFy5Ej+9Kc/MXz4cE6ePMlLL71EdHS0y3hsd3z/vfjiixw6dIhevXpRv359Tp48yZtvvomfnx/du3cv9XFEqgoFYBEv8MADDwDm+Mo6derQqlUrnnnmGR566KESwy+YFy8tWbKEcePGkZycTK1atWjTpg1ffvklffv2dbabMWMG/+///T8GDRpEdnY2w4YNY9asWeWq98orr+SBBx5g3Lhx7Nmzh5iYGCZPnuwybZOPjw9fffUVf/nLX3jkkUcICAjgrrvuYtq0aYUuzHriiSfYsWMHzz//POnp6RiGUezFfy1atGDVqlU8//zzPProo2RmZtKqVStmzpxZaG7VS9G9e3d++OEHxo0bx/33309BQQHt27fnyy+/LPetoOPj4wGYP38+r732Gunp6YSFhdGpUye+/fZb5wVZANdccw2zZ8/mlVde4ZZbbqFp06aMGzeOb7/9tsy3tK5o8+bN44knnuDpp58mLy+Pa665hqVLlxb6dy6Nq6++2jmf8MVuLHKh119/vcjty5cvp0ePHqxfv56///3vvPbaaxw6dIiQkBCaNGlC//79CQ0NLXOtDz/8MDabjUmTJnHbbbfRuHFjnn32Wf773/8WusjwUr//unTpwvr163nmmWc4duwYderUoXPnzvzwww/Occwi1YnNuNgl4CIiItXE1q1bad++PW+99RajRo2yupwyO3nyJM2bN+fWW2/l/ffft7ockSpLAVhERKq933//nQMHDvD888+TmJjI//73P5fp1zxRcnIy//jHP+jZsyd169blwIEDvPHGG+zatYv169erZ1bkEmgIhIiIVHt///vf+eijj2jVqhX/+c9/PD78gnkx2v79+xk1ahQnTpxwXoT57rvvKvyKXCL1AIuIiIiIV9E0aCIiIiLiVRSARURERMSrKACLiIiIiFfRRXClVFBQwJEjRwgJCSnXBPUiIiIiUrEMw+D06dPExMS43DDmQgrApXTkyBEaNGhgdRkiIiIichEHDx4s8e6LCsClFBISApgn1NNuFSoiIiIicOrUKRo0aODMbcVRAC4lx7CH2rVrKwCLiIiIeLCLDVfVRXAiIiIi4lUUgEVERETEqygAi4iIiIhXUQAWEREREa+iACwiIiIiXkUBWERERES8igKwiIiIiHgVBWARERER8SoKwCIiIiLiVRSARURERMSrKACLiIiIiFdRABYRERERr6IALCIiIiJeRQFYRERERLyKArCIiIiIeBVLA3Djxo2x2WyFHo8++igAhmEwfvx4YmJiCAwMpEePHuzYscPlGNnZ2Tz22GOEh4cTHBzMoEGDOHTokEubtLQ04uPjsdvt2O124uPjOXnyZGW9TRERERHxIJYG4HXr1pGUlOR8LF26FIA77rgDgEmTJjF58mSmTZvGunXriIqKok+fPpw+fdp5jNGjR7Nw4ULmz5/PypUrycjIYODAgeTn5zvbDB06lM2bN7No0SIWLVrE5s2biY+Pr9w3KyIiIiIewWYYhmF1EQ6jR4/m66+/Zs+ePQDExMQwevRonnnmGcDs7Y2MjOTVV19l5MiRpKenU69ePT766CPuvPNOAI4cOUKDBg349ttv6devHwkJCbRu3Zo1a9bQpUsXANasWUNcXBy7du2iRYsWpart1KlT2O120tPTqV27dgW8exERERG5FKXNa76VWFOJcnJymDNnDk899RQ2m429e/eSnJxM3759nW0CAgLo3r07q1atYuTIkWzYsIHc3FyXNjExMbRp04ZVq1bRr18/Vq9ejd1ud4ZfgK5du2K321m1alWxATg7O5vs7Gzn16dOnaqAdy1StSUmJpKamlrm5+Xk2Dh82J/8fBv5+Taio3No2jSUhg0bVkCVIiIirjwmAH/xxRecPHmS+++/H4Dk5GQAIiMjXdpFRkZy4MABZxt/f39CQ0MLtXE8Pzk5mYiIiEKvFxER4WxTlIkTJ/LSSy+V+/2IVHeJiYm0bNmKzMyzZXxmN+BT4LLztuVSo8b3/POfwQwZUpeYGLDZzD3Z2bBrF2zYAOvXw4kT0LYtdOwIcXFQp45b3o6IiHgRjwnAM2bM4MYbbyQmJsZlu83xU/APhmEU2nahC9sU1f5ix3nuued46qmnnF+fOnWKBg0alPi6It4kNTWVzMyz3HbbHOrVa3XR9oYBO3bUY/Xq+hiGDV/ffPz8CgDIzPSjoKA/Tz0FTz0FdetCy5aQlAT790NBgeuxPvnEXNrt5nq/fm5+cyIiUq15RAA+cOAAy5YtY8GCBc5tUVFRgNmDGx0d7dyekpLi7BWOiooiJyeHtLQ0l17glJQUunXr5mxz9OjRQq957NixQr3L5wsICCAgIODS3piIF6hXrxXR0R0v2m7xYlizxly/4goYNMgHf38fABISdvDpp58SG/sMe/cGcfw4/PLLuefa7WaPb6dOUK8ebNkCq1aZ4XjAAHjzTfhj8hgREZGL8oh5gGfOnElERAQDBgxwbmvSpAlRUVHOmSHAHCe8YsUKZ7jt1KkTfn5+Lm2SkpLYvn27s01cXBzp6emsXbvW2ebXX38lPT3d2UZEKlZi4rnw27cv3H47+Puf21+nTjbwN+bP30VGhjnU4eOP4ccfzV7gtDT44Qd47TV4+mmYO9ccFjFsGOTnw1/+An9cKysiInJRlvcAFxQUMHPmTIYNG4av77lybDYbo0ePZsKECcTGxhIbG8uECRMICgpi6NChANjtdh588EHGjBlD3bp1CQsLY+zYsbRt25bevXsD0KpVK/r378+IESN47733AHj44YcZOHBgqWeAEJHyKyiAb78116+80hy3W5KaNc2e3k6dSm4XEAAzZ0KrVvDsszBpElx/vdkjLCIiUhLLA/CyZctITExk+PDhhfY9/fTTZGZmMmrUKNLS0ujSpQtLliwhJCTE2eaNN97A19eXIUOGkJmZSa9evZg1axY+Pj7ONnPnzuXxxx93zhYxaNAgpk2bVvFvTkRYtw6OHjWD7R+/l7qNzWb2/B47Bq+/Dg8/DNu3wwXXxYqIiLjwqHmAPZnmARZxtXHjRjp16sTDD28odgxwRgZMm2bO5DBgAHTuXPSxkpI28v77nZgzZw6tWl38groLZWXZGDq0FQcO1GTgwOO89dYZTakmIuKFqtw8wCJS/fz4oxl+Y2LMi9iKk5GRBNi49957L+HVugIr+frruixZMpI9eyYrBIuISJEUgEWkQuTkwLZt5nrv3lCjhEtus7JOAgY9e04jNvYig4RLsGZNKlu3RpKTM4mkpFQFYBERKZICsIhUiO3bzRBcty40bly654SGXl6qKdWKM2AA7NmTS2ZmU7755gDn3QBSRETEySOmQROR6mfjRnPZseO5u7pVNH9/aN/enPd7xowocnMr53VFRKRqUQAWEbdLTobDh81hD+3bV+5rt259DEjmyJEAZs+u3NcWEZGqQQFYRNzO0fvbsiUEB1fua/v6GsCrALz8sjkMQ0RE5HwKwCLiVrm5sHWruV7SzA8V613q1s3lwAGYNcuqGkRExFMpAIuIWyUkmFOf1akDTZtaVUUW99+fDMA//2nejU5ERMRBAVhE3GrXLnPZrl3lXfxWlFtvPU6dOrBnD3z1lXV1iIiI51EAFhG3yc+H338315s3t7aWoKACHnnEXH/9dWtrERERz6IALCJuc/CgedFZUJB59zerPfYY+PnBzz/D2rVWVyMiIp5CAVhE3GbPHnN5+eXWDn9wiImBu+8219ULLCIiDgrAIuI2//ufubz8cmvrON+YMebys89g/35LSxEREQ+hACwibpGeDikpZs9vs2ZWV3NOu3bQp485E8SUKVZXIyIinkABWETcwtH7W7++OQbYkzh6gWfMgJMnLS1FREQ8gAKwiLjF+eN/PU3fvtCmDWRkwPvvW12NiIhYTQFYRC5ZXh7s22eux8ZaW0tRbLZzvcBvvqnbI4uIeDsFYBG5ZI7pz4KDISrK6mqKdvfdZm1HjsAnn1hdjYiIWEkBWEQuWWKiuWzSxDOmPytKQAA8/ri5/vrrYBjW1iMiItZRABaRS3bwoLls0MDaOi5m5EjzAr0tW2DJEqurERERq/haXYCIVG2GAYcOmeueFIATEhKK3H7rrZcxb14kzzyTQXj4byX2WIeHh9OwYcMKqlBERKyiACwilyQtrSbZ2eYthyMjra4GMjKSABv33ntvMS2igb1s2VKLzp3HAD8We6zAwCB27UpQCBYRqWYUgEXkkhw9GgyY8//W8IBBVVlZJwGDnj2nERsbV2SblStPsXNnTaKjv+Tmm/cU2ebYsQQWLryX1NRUBWARkWpGAVhELklyci3As4Y/AISGXk50dMci9/XtC7t2QVJSCDk5HWnUqJKLExERS3lAf42IVGWOHmBPC8AlsduhQwdz/aefrK1FREQqnwKwiFyCepw6VRMwh0BUJddeaw7Z2LsXDhywuhoREalMCsAicgnMMbb16kHNmhaXUkZ16pzrBf7+e80LLCLiTRSAReQSdAOq1vCH83XvDr6+5jzGe4q+Fk5ERKohBWARuQRVOwCHhECXLua6eoFFRLyHArCIlEturg24Cqi6ARjgmmvM2ySnpMC2bVZXIyIilUEBWETK5bffAoGaBATkERZmdTXlFxhohmCAH3+E/HxLyxERkUqgACwi5ZKQEARAvXpnSrydcFXQpQsEB0NaGmzcaHU1IiJS0RSARaRcHAE4PDzT4kounb+/eUEcwIoVkJNjbT0iIlKxFIBFpFzO9QCftbgS9+jY0Zwa7cwZ+PVXq6sREZGKpAAsImWWnQ2//25O/BseXj0CsI8P9Oxprv/yC2Rl+VhbkIiIVBgFYBEps23bIC+vBpBKrVrVZ7xA27YQEWEG/C1bIq0uR0REKogCsIiU2YYNzrUqfwHc+Ww26NXLXN++PQKIsbQeERGpGArAIlJm5wfg6iY21pzXOD+/BvB/VpcjIiIVQAFYRMqsOgfg83uB4SESEwOsLEdERCqAArCIlEl29vl3TKt+ARigUSNo0CAd8OXdd6OtLkdERNxMAVhEymT7dsjNBbs9DzhgdTkV5qqrjgCweHEYmzZZXIyIiLiVArCIlIlj+EPLltVj+rPimDf4mAfAxInW1iIiIu6lACwiZeIIwK1aVe8AbHoVgIULISnJ4lJERMRtFIBFpEy8KwBvpV27DPLyYMYMq2sRERF3UQAWkVLLyTl3AZx3BGC4445UAN57D/LyLC5GRETcQgFYREpt+3YzBIeGQkxM9bkDXEl69Uqjbl04dAi++cbqakRExB0UgEWk1BzDHzp2pFrdAa4kAQEGw4eb6++8Y20tIiLiHgrAIlJqGzeay06drK2jso0caS4XL4bff7e2FhERuXQKwCJSao4eYG8LwM2aQb9+5vpHH1lbi4iIXDoFYBEpldxc2LrVXPe2AAxw113m8osvLC1DRETcQAFYREplxw7zNsh2OzRtanU1le/mm6FGDdiyBfbts7oaERG5FArAIlIq3ngB3Pnq1oXrrzfX1QssIlK1WR6ADx8+zL333kvdunUJCgriyiuvZIPjJy1gGAbjx48nJiaGwMBAevTowY4dO1yOkZ2dzWOPPUZ4eDjBwcEMGjSIQ4cOubRJS0sjPj4eu92O3W4nPj6ekydPVsZbFKkWvPUCuPPdequ5VAAWEanaLA3AaWlpXHPNNfj5+fHdd9+xc+dOXn/9derUqeNsM2nSJCZPnsy0adNYt24dUVFR9OnTh9OnTzvbjB49moULFzJ//nxWrlxJRkYGAwcOJD8/39lm6NChbN68mUWLFrFo0SI2b95MfHx8Zb5dkSrNWy+AO58jAK9cCceOWVqKiIhcAl8rX/zVV1+lQYMGzJw507mtcePGznXDMJgyZQovvPACgwcPBmD27NlERkYyb948Ro4cSXp6OjNmzOCjjz6id+/eAMyZM4cGDRqwbNky+vXrR0JCAosWLWLNmjV06dIFgOnTpxMXF8fu3btp0aJF5b1pkSooL88c+wreHYAbNYIOHWDTJvjqK5zzA4uISNViaQ/wl19+SefOnbnjjjuIiIigQ4cOTJ8+3bl/3759JCcn07dvX+e2gIAAunfvzqpVqwDYsGEDubm5Lm1iYmJo06aNs83q1aux2+3O8AvQtWtX7Ha7s82FsrOzOXXqlMtDxFvt3AlZWRASYk4J5s1uu81cahiEiEjVZWkA3rt3L++88w6xsbEsXryYRx55hMcff5wPP/wQgOTkZAAiIyNdnhcZGencl5ycjL+/P6GhoSW2iYiIKPT6ERERzjYXmjhxonO8sN1up0GDBpf2ZkWqMMf4344dzZkQvJljGMSSJZCRYWkpIiJSTpb+KCsoKKBjx45MmDCBDh06MHLkSEaMGME7F9xv1HbBJeeGYRTadqEL2xTVvqTjPPfcc6SnpzsfBw8eLO3bEql2NP73nDZtzGngsrNh+XKrqxERkfKwNABHR0fTunVrl22tWrUiMTERgKioKIBCvbQpKSnOXuGoqChycnJIS0srsc3Ro0cLvf6xY8cK9S47BAQEULt2bZeHiLdSAD7HZoNevcz1n3+2thYRESkfSwPwNddcw+7du122/fbbbzRq1AiAJk2aEBUVxdKlS537c3JyWLFiBd26dQOgU6dO+Pn5ubRJSkpi+/btzjZxcXGkp6ezdu1aZ5tff/2V9PR0ZxsRKVpeHmzebK537GhpKR7juuvM5U8/WVuHiIiUj6WzQDz55JN069aNCRMmMGTIENauXcv777/P+++/D5jDFkaPHs2ECROIjY0lNjaWCRMmEBQUxNChQwGw2+08+OCDjBkzhrp16xIWFsbYsWNp27atc1aIVq1a0b9/f0aMGMF7770HwMMPP8zAgQM1A4TIRezeDZmZUKsWNG9udTWewXFDjA0b4MwZCA62th4RESkbSwPwVVddxcKFC3nuuef429/+RpMmTZgyZQr33HOPs83TTz9NZmYmo0aNIi0tjS5durBkyRJCQkKcbd544w18fX0ZMmQImZmZ9OrVi1mzZuHj4+NsM3fuXB5//HHnbBGDBg1i2rRplfdmRaoox/CHDh10AZxDo0bQsCEkJsKaNeeGRIiISNVgaQAGGDhwIAMHDix2v81mY/z48YwfP77YNjVr1mTq1KlMnTq12DZhYWHMmTPnUkoV8Uoa/1u0666DuXPNYRAKwCIiVYv6c0SkRI4ArPG/rhzDIDQOWESk6lEAFpFi5eefuwBOPcCuHAF4zRpzSjQREak6LB8CISKe67ffzl3k5a3XiyYkJBS53TAgNLQtaWl+zJu3m/btz5R4nPDwcBo2bFgRJYqISBkpAItIsRzDH668Es67ptQrZGQkATbuvffeElp9BtzO8OEzgVdLPF5gYBC7diUoBIuIeAAFYBEpljdfAJeVdRIw6NlzGrGxcUW22batHqtXQ4MGz3HjjUOKPdaxYwksXHgvqampCsAiIh5AAVhEirVxo7n05gvgQkMvJzq6+BOwejWkpNiJjOyoaeJERKoI/XctIkUqKIBNm8x1b+wBLo3ISPD3Ny+CO37c6mpERKS0FIBFpEh79sDp0xAYCC1bWl2NZ6pRwwzBAElJ1tYiIiKlpwAsIkU6/wI4Xw2WKlZUlLlMTra2DhERKT0FYBEpksb/lk50tLlUABYRqToUgEWkSGvXmsvOna2tw9M5eoCTksy5gUVExPMpAItIIXl554ZAdOlibS2erl49cyxwVhakp1tdjYiIlIYCsIgUsmMHnD0LtWt77x3gSsvX1wzBoGEQIiJVhQKwiBTiGP5w1VVobttS0DhgEZGqRT/aRKSQX381lxr+UDqaCUJEpGpRABaRQhwB+Oqrra2jqjj/QjgREfF8CsAi4uL0aXMMMCgAl5YjAJ86ZY6dFhERz6YALCIuNmwwp/Nq0ODc2FYpWUAAhIaa6xoGISLi+RSARcSFxv+Wjy6EExGpOnSDUxEvk5iYSGpqarH7lyxpAoRy2WWH2Lgxpdh2CQkJFVBd1RUVBTt3KgCLiFQFCsAiXiQxMZGWLVuRmVnSQNWDQChvvjmUN9/8+aLHzMg47bb6qjJdCCciUnUoAIt4kdTUVDIzz3LbbXOoV69Vof1nzvgxd259bDaD++//F35+BcUea8+eb1m+/P/IysqqyJKrjMhIc3n8OOTng4+PtfWIiEjxFIBFvFC9eq2Iju5YaLtjVENEhI2GDa8s8RipqRoCcb6QEPD3h5wcOHHi3N3hRETE8+giOBFxOnzYXF52mbV1VEU2G4SHm+slDLEWEREPoAAsIk4KwJdGAVhEpGpQABYRAAoK4MgRc10BuHwUgEVEqgYFYBEBzNCWkwN+fhq/Wl4KwCIiVYMCsIgA54Y/xMRADf3PUC7nB2DDsLYWEREpnn7MiQgAhw6ZSw1/KL+wMPNiuJwcOK3pkUVEPJYCsIgA58b/1q9vbR1VmY+PGYJBwyBERDyZArCIkJsLR4+a6+oBvjQaBywi4vkUgEWEI0fMMashIVC7ttXVVG0KwCIink8BWEQ0/68bKQCLiHg+BWARUQB2IwVgERHPpwAsIgrAbuQIwKdPQ3a2tbWIiEjRFIBFvFxGBqSnm+sxMdbWUh3UrAm1apnr6gUWEfFMCsAiXs7R+1uvHgQEWFtLdaFhECIink0BWMTLafiD+ykAi4h4NgVgES+nAOx+CsAiIp5NAVjEixnGuQCsO8C5T9265vLECWvrEBGRoikAi3ix48fNmQp8fSEiwupqqo/QUHOZlmb+kiEiIp5FAVjEix06ZC5jYqCG/jdwmzp1wGYzbzGdkWF1NSIiciH9yBPxYo7hD5r+zL18fMBuN9fT0qytRUREClMAFvFiGv9bcRzDIDQOWETE8ygAi3ip3Fw4etRc1wwQ7nf+OGAREfEsCsAiXio5GQoKIDj43J/rxX3CwsylArCIiOdRABbxUufP/2uzWVtLdaQhECIinksBWMRL6QYYFUs9wCIinksBWMRLKQBXLEcP8NmzkJOj/2pFRDyJ/lcW8UJZWT7OnkkF4IoREABBQeb6qVMB1hYjIiIuFIBFvFBKSjBg3rK3Zk2Li6nGHMMgFIBFRDyLArCIFzp2zOyaVO9vxXIMg1AAFhHxLJYG4PHjx2Oz2VweUVFRzv2GYTB+/HhiYmIIDAykR48e7Nixw+UY2dnZPPbYY4SHhxMcHMygQYM45Li/6x/S0tKIj4/Hbrdjt9uJj4/n5MmTlfEWRTySowdYd4CrWArAIiKeyfIe4CuuuIKkpCTnY9u2bc59kyZNYvLkyUybNo1169YRFRVFnz59OH36tLPN6NGjWbhwIfPnz2flypVkZGQwcOBA8vPznW2GDh3K5s2bWbRoEYsWLWLz5s3Ex8dX6vsU8STqAa4c54ZA+FtbiIiIuPC1vABfX5deXwfDMJgyZQovvPACgwcPBmD27NlERkYyb948Ro4cSXp6OjNmzOCjjz6id+/eAMyZM4cGDRqwbNky+vXrR0JCAosWLWLNmjV06dIFgOnTpxMXF8fu3btp0aJF5b1ZEY/QiKwsP2rUgCK+9cSN1AMsIuKZLO8B3rNnDzExMTRp0oS77rqLvXv3ArBv3z6Sk5Pp27evs21AQADdu3dn1apVAGzYsIHc3FyXNjExMbRp08bZZvXq1djtdmf4BejatSt2u93ZpijZ2dmcOnXK5SFSPVwNQGQk+Fr+K3D15ugBPnPGH/CztBYRETnH0gDcpUsXPvzwQxYvXsz06dNJTk6mW7duHD9+nOTkZAAiIyNdnhMZGencl5ycjL+/P6GObpZi2kRERBR67YiICGebokycONE5Zthut9OgQYNLeq8inuMqQMMfKkNwMPj5gWHYgMZWlyMiIn+wNADfeOON3H777bRt25bevXvzzTffAOZQBwfbBfdoNQyj0LYLXdimqPYXO85zzz1Henq683Hw4MFSvScRz2f2AOsCuIpns50bBgHNrCxFRETOY/kQiPMFBwfTtm1b9uzZ4xwXfGEvbUpKirNXOCoqipycHNIuuNfohW2OHj1a6LWOHTtWqHf5fAEBAdSuXdvlIVLVmdeGdgLUA1xZHMMgFIBFRDyHRwXg7OxsEhISiI6OpkmTJkRFRbF06VLn/pycHFasWEG3bt0A6NSpE35+fi5tkpKS2L59u7NNXFwc6enprF271tnm119/JT093dlGxFvs21cTqIWfXz7h4VZX4x3q1HGsKQCLiHgKSy+BGTt2LDfffDMNGzYkJSWFl19+mVOnTjFs2DBsNhujR49mwoQJxMbGEhsby4QJEwgKCmLo0KEA2O12HnzwQcaMGUPdunUJCwtj7NixziEVAK1ataJ///6MGDGC9957D4CHH36YgQMHagYI8To7dpjz/4aHn6VGjRCLq/EO53qAm1hZhoiInMfSAHzo0CHuvvtuUlNTqVevHl27dmXNmjU0atQIgKeffprMzExGjRpFWloaXbp0YcmSJYSEnPvB/cYbb+Dr68uQIUPIzMykV69ezJo1Cx8fH2ebuXPn8vjjjztnixg0aBDTpk2r3Dcr4gF27DDn/61X7yygAFwZzvUANwXyrCtEREScLA3A8+fPL3G/zWZj/PjxjB8/vtg2NWvWZOrUqUydOrXYNmFhYcyZM6e8ZYpUG44e4IiIMxZX4j3OXQTXBMPYY2UpIiLyB48aAywiFScrC/bsCQQcPcBSGc71AIdw8qRPCS1FRKSyKACLeInNmyE/3wYcpVatHKvL8Rq+vhAUZJ7vI0d0RzgREU+gACziJc5NhLKOi0ylLW4WEmIG4MOHFYBFRDyBArCIl1i3zrG2tqRmUgFCQrIBOHzY3+JKREQEFIBFvMa5HmAF4MpWu7ZjCIQCsIiIJ1AAFvECJ0/Cb785vlpvYSXe6VwPsIZAiIh4AgVgES+w/o/Me9ll2cBxS2vxRufGAKsHWETEEygAi3gBx/CHNm00/68Vatc2e4CTk/3Jz7e4GBERUQAW8QaOC+Bat9b8v1YICsoFcsjLq8Hhw1ZXIyIiCsAiXsDRA3zFFeoBtkKNGgAHANi3z9JSREQEBWCRau/wYThyxAxhLVtmWl2OFzOTrwKwiIj1FIBFqjnH8Ic2bSAwsMDaYryamXz37rW4DBERUQAWqe4cwx+uvtraOkQ9wCIinkIBWKSac/QAX3WVtXWI2fWrACwiYj0FYJFqzDBg0yZzvVMna2sR9QCLiHgKBWCRauzwYTh+HHx84IorrK7G25nJ98gRyNS1iCIillIAFqnGtmwxly1bQs2a1tYixwkKMu+CceCAxaWIiHg5BWCRaswRgK+80tIy5A/mrag1DEJExGoKwCLV2ObN5rJ9e0vLkD/ExOQACsAiIlZTABapxtQD7FkcPcCaC1hExFoKwCLV1JkzsGePua4eYM+gHmAREc+gACxSTW3bZk6DFhUFERFWVyOgMcAiIp5CAVikmtLwB89z2WXqARYR8QQKwCLVlC6A8zyOIRAnT0JamrW1iIh4MwVgkWpKPcCeJzCwwDkcRb3AIiLWUQAWqYYKCmDrVnNdPcCepWlTc6kALCJiHQVgkWro99/NWSBq1oTYWKurkfM1aWIuFYBFRKyjACxSDTmGP7RtC76+1tYirhwBWHMBi4hYRwFYpBrSBXCeSz3AIiLWUwAWqYa2bzeX7dpZW4cUpjHAIiLWUwAWqYZ27jSXV1xhbR1SmKMHeP9+82JFERGpfArAItVMVpZ5ERxA69bW1iKFNWgAPj6QnQ1JSVZXIyLinRSARaqZ334zexbr1IHISKurkQv5+pohGDQMQkTEKgrAItVMQoK5bN0abDZra5GiaRywiIi1FIBFqhnH+F8Nf/BcmglCRMRaCsAi1YwjALdqZW0dUjzNBSwiYi0FYJFq5vwhEOKZ1AMsImItBWCRaiQ317wIDhSAPZnGAIuIWEsBWKQa+f13MwQHB5+baUA8j6MH+NAhyMmxthYREW+kACxSjZw//lczQHiuiAgICgLDgMREq6sREfE+CsAi1YjG/1YNNtu5XuD//c/aWkREvJECsEg1ohkgqo7mzc2lY8y2iIhUHgVgkWpEcwBXHQrAIiLWKVcA3qdLl0U8Tn4+7NplrisAe74WLczl7t3W1iEi4o3KFYAvv/xyevbsyZw5c8jKynJ3TSJSDgcOQFYWBAScG18qnksBWETEOuUKwFu2bKFDhw6MGTOGqKgoRo4cydq1a91dm4iUgWP4Q4sW4ONjbS1ycY4hEAcPwtmz1tYiIuJtyhWA27Rpw+TJkzl8+DAzZ84kOTmZa6+9liuuuILJkydz7Ngxd9cpIhfhmAFCF8BVDeHhEBZmru/ZY20tIiLe5pIugvP19eW2227j008/5dVXX+X3339n7Nix1K9fn/vuu4+kpCR31SkiF+EY/9uypbV1SOnpQjgREWtcUgBev349o0aNIjo6msmTJzN27Fh+//13fvjhBw4fPswtt9zirjpF5CIcY0kdY0vF82kcsIiINXzL86TJkyczc+ZMdu/ezU033cSHH37ITTfdRI0aZp5u0qQJ7733Hi3VFSVSaRy9iArAVYcCsIiINcoVgN955x2GDx/OAw88QFRUVJFtGjZsyIwZMy6pOBEpnbQ0cAy9d/xZXTyfhkCIiFijXAF4Tymu2PD392fYsGHlObyIlJGjB/Gyy6BWLWtrkdI7vwfYMMxbJIuISMUr1xjgmTNn8p///KfQ9v/85z/Mnj27XIVMnDgRm83G6NGjndsMw2D8+PHExMQQGBhIjx492LFjh8vzsrOzeeyxxwgPDyc4OJhBgwZx6NAhlzZpaWnEx8djt9ux2+3Ex8dz8uTJctUpYoXExEQ2btxY7GPx4v0AREefLrFdgmOqCPEIzZqZoTc9HVJSrK5GRMR7lKsH+JVXXuHdd98ttD0iIoKHH364zD2/69at4/3336ddu3Yu2ydNmsTkyZOZNWsWzZs35+WXX6ZPnz7s3r2bkJAQAEaPHs1XX33F/PnzqVu3LmPGjGHgwIFs2LABnz8mQx06dCiHDh1i0aJFADz88MPEx8fz1Vdflefti1SqxMREWrZsRWZmSZPF/gN4nvXr59Cp06iLHjMj47Tb6pPyCwyERo1g/35zGERkpNUViYh4h3IF4AMHDtCkiFtNNWrUiMTExDIdKyMjg3vuuYfp06fz8ssvO7cbhsGUKVN44YUXGDx4MACzZ88mMjKSefPmMXLkSNLT05kxYwYfffQRvXv3BmDOnDk0aNCAZcuW0a9fPxISEli0aBFr1qyhS5cuAEyfPp24uDh2795NC10xJB4uNTWVzMyz3HbbHOrVK3qS3yVLmrB/P8TFDaRt2y7FHmvPnm9Zvvz/dAdHD9KihRmAd++G666zuhoREe9QriEQERERbN26tdD2LVu2ULdu3TId69FHH2XAgAHOAOuwb98+kpOT6du3r3NbQEAA3bt3Z9WqVQBs2LCB3NxclzYxMTG0adPG2Wb16tXY7XZn+AXo2rUrdrvd2aYo2dnZnDp1yuUhYqV69VoRHd2xyMfZs6EANGnSoNg20dEdCQ3VPZI9jS6EExGpfOXqAb7rrrt4/PHHCQkJ4frrrwdgxYoVPPHEE9x1112lPs78+fPZuHEj69atK7QvOTkZgMgL/iYYGRnJgQMHnG38/f0JDQ0t1Mbx/OTkZCIiIgodPyIiwtmmKBMnTuSll14q9XsRsUpBARw/bq6Hh1tbi5SdpkITEal85QrAL7/8MgcOHKBXr174+pqHKCgo4L777mPChAmlOsbBgwd54oknWLJkCTVr1iy2ne2Cy6INwyi07UIXtimq/cWO89xzz/HUU085vz516hQNGjQo8XVFrJCeDvn54OMDdrvV1UhZOXqAFYBFRCpPuQKwv78/n3zyCX//+9/ZsmULgYGBtG3blkaNGpX6GBs2bCAlJYVOnTo5t+Xn5/PTTz8xbdo0dv/x0yA5OZno6Ghnm5SUFGevcFRUFDk5OaSlpbn0AqekpNCtWzdnm6NHjxZ6/WPHjhXqXT5fQEAAAQEBpX4/IlZx9P6GhUGNS7q3o1jB0QP8+++Qmwt+ftbWIyLiDS7px2Xz5s254447GDhwYJnCL0CvXr3Ytm0bmzdvdj46d+7MPffcw+bNm2natClRUVEsXbrU+ZycnBxWrFjhDLedOnXCz8/PpU1SUhLbt293tomLiyM9PZ21a9c62/z666+kp6c724hUZamp5rKMw+/FQ9SvD8HBkJcHpZhiXURE3KBcPcD5+fnMmjWL77//npSUFAoKClz2//DDDxc9RkhICG3atHHZFhwcTN26dZ3bR48ezYQJE4iNjSU2NpYJEyYQFBTE0KFDAbDb7Tz44IOMGTOGunXrEhYWxtixY2nbtq3zorpWrVrRv39/RowYwXvvvQeY06ANHDhQM0BIteDoAVYArppq1IArr4RffoGNG6F1a6srEhGp/soVgJ944glmzZrFgAEDaNOmzUXH5JbX008/TWZmJqNGjSItLY0uXbqwZMkS5xzAAG+88Qa+vr4MGTKEzMxMevXqxaxZs5xzAAPMnTuXxx9/3DlbxKBBg5g2bVqF1CxS2XQBXNXXoYMZgDdtgnvvtboaEZHqr1wBeP78+Xz66afcdNNNbi3mxx9/dPnaZrMxfvx4xo8fX+xzatasydSpU5k6dWqxbcLCwpgzZ46bqhTxLOoBrvo6dDCXmzZZW4eIiLco1xhgf39/Lr/8cnfXIiJllJMDjimqFYCrro4dzeWmTWAY1tYiIuINytUDPGbMGN58802mTZtWYcMfROTiHL2/gYEQFGRtLXJxCQkJRW7PzbXh69uekydr8PXX27nsspwSjxMeHk7Dhg0rokQREa9QrgC8cuVKli9fznfffccVV1yB3wXz9ixYsMAtxYlIyTT+t2rIyEgCbNxb4gDfDUBHBg16EVhY4vECA4PYtStBIVhEpJzKFYDr1KnDbbfd5u5aRKSMNAVa1ZCVdRIw6NlzGrGxcUW2WbGiIbt3Q4cOb3HVVX8t9ljHjiWwcOG9pKamKgCLiJRTuQLwzJkz3V2HiJTDiRPmUgG4aggNvZzo6I5F7mva1LwbXEZGtMvNf0RExP3KfSOMvLw8li1bxnvvvcfp06cBOHLkCBkZGW4rTkRK5ugB1hCIqs+ReZOSrK1DRMQblKsH+MCBA/Tv35/ExESys7Pp06cPISEhTJo0iaysLN5991131ykiFzAMTYFWnTjuzJ6RYT5q1bK2HhGR6qxcPcBPPPEEnTt3Ji0tjcDAQOf22267je+//95txYlI8TIyzGnQbDYIDbW6GrlU/v7nevKTk62tRUSkuiv3LBC//PIL/v7+LtsbNWrE4cOH3VKYiJTMMfyhTh3wLdd3sniaqCjz3zUpCTTVuohIxSlXD3BBQQH5+fmFth86dMjlNsUiUnE0BVr1ExVlLtUDLCJSscoVgPv06cOUKVOcX9tsNjIyMhg3bpzbb48sIkXT+N/qx3Eh3JEj1tYhIlLdlesPp2+88QY9e/akdevWZGVlMXToUPbs2UN4eDgff/yxu2sUkSIoAFc/MTHmmO6TJyE9Hex2qysSEameyhWAY2Ji2Lx5Mx9//DEbN26koKCABx98kHvuucflojgRqTi6CUb1U7MmXHYZHDoEe/dChw5WVyQiUj2V+9KZwMBAhg8fzvDhw91Zj4iUQl6e2UsIGgNc3TRpYgbgffsUgEVEKkq5AvCHH35Y4v777ruvXMWISOmkpZnzAPv7a77Y6qZpU/j5Z7MH2DDMIREiIuJe5QrATzzxhMvXubm5nD17Fn9/f4KCghSARSrY+cMfFJCql/r1wc8PzpyBY8cgIsLqikREqp9yzQKRlpbm8sjIyGD37t1ce+21ughOpBJoCrTqy9cXGjY01/futbYWEZHqqlwBuCixsbG88sorhXqHRcT9NANE9da0qblUABYRqRhuC8AAPj4+HNEEliIVTgG4enME4AMHoIh7DomIyCUq1xjgL7/80uVrwzBISkpi2rRpXHPNNW4pTESKpynQqrfISAgKgrNn4fDhc0MiRETEPcoVgG+99VaXr202G/Xq1eOGG27g9ddfd0ddIlKMs2chM9NcVwCunmw2czq0HTvMYRAKwCIi7lWuAFxQUODuOkSklI4dM5e1a5vToEn15AjAe/ZAjx5WVyMiUr24dQywiFQ8RwDW9FjVW4sWZk/wkSNw4oTV1YiIVC/l6gF+6qmnSt128uTJ5XkJESlGSoq5VACu3mrVMnuB9+6F7dvh+uutrkhEpPooVwDetGkTGzduJC8vjxYtWgDw22+/4ePjQ8eOHZ3tbJqhX8TtHD3A9epZW4dUvLZtzQC8bRtcd51ueiIi4i7lCsA333wzISEhzJ49m9DQUMC8OcYDDzzAddddx5gxY9xapIicox5g79GyJXz9tTnrx9GjEBVldUUiItVDucYAv/7660ycONEZfgFCQ0N5+eWXNQuESAU6c8acBQLUA+wNataE5s3N9W3brK1FRKQ6KVcAPnXqFEePHi20PSUlhdOnT19yUSJSNEfvb2go+PlZW4tUjjZtzOWOHWAY1tYiIlJdlCsA33bbbTzwwAN89tlnHDp0iEOHDvHZZ5/x4IMPMnjwYHfXKCJ/0PAH7xMbCwEBkJ4OBw9aXY2ISPVQrgD87rvvMmDAAO69914aNWpEo0aNuOeee7jxxht5++233V2jiPzBEYA1/MF7+PlBq1bm+pYt1tYiIlJdlCsABwUF8fbbb3P8+HHnjBAnTpzg7bffJjg42N01isgfNAewd2rXzlzu2AF5eZoKQkTkUl3SjTCSkpJISkqiefPmBAcHY2iAmkiFMQwNgfBWjRtDnTqQnQ1794ZerLmIiFxEuQLw8ePH6dWrF82bN+emm24iKSkJgIceekhToIlUkLNn/cjONueCrVvX6mqkMtls0KGDub57t/7xRUQuVbkC8JNPPomfnx+JiYkEBQU5t995550sWrTIbcWJyDknTtQEzPDrW64ZvKUqa9/eXCYlhQDNLK1FRKSqK9eP0SVLlrB48WLq16/vsj02NpYDBw64pTARcZWWFgjoAjhvZbfD5ZfD//4H8IDV5YiIVGnl6gE+c+aMS8+vQ2pqKgEBAZdclIgU5ugB1vhf7+UYBgH3k5dnZSUiIlVbuQLw9ddfz4cffuj82mazUVBQwGuvvUbPnj3dVpyInKMeYGneHAIC8oDLWL26ttXliIhUWeUaAvHaa6/Ro0cP1q9fT05ODk8//TQ7duzgxIkT/PLLL+6uUUSwkZamHmBv5+sLsbEn2L49gm+/DeOJJ6yuSESkaipXD3Dr1q3ZunUrV199NX369OHMmTMMHjyYTZs20ayZLs4Qcb9Y8vJ88PXVDBDeLjb2OAArVtQhPd3iYkREqqgy9wDn5ubSt29f3nvvPV566aWKqElECukEQFQU1Lik2bulqgsPzwQSyM5uxeefw/DhVlckIlL1lPlHqZ+fH9u3b8dm092IRCpPRwCioy0uQyxn/tf7EQBz5lhaiohIlVWuvqT77ruPGTNmuLsWESmWArCcby4AP/4IBw9aW4mISFVUrovgcnJy+OCDD1i6dCmdO3cmODjYZf/kyZPdUpyImLdAVgAWV4l06nSaDRtCmDsXnn3W6npERKqWMgXgvXv30rhxY7Zv307HjuYP5N9++82ljYZGiLjXoUP+QB1q1CigXj0NABbTTTedYMOGED76CJ55xjE0QkRESqNMATg2NpakpCSWL18OmLc+/te//kVkZGSFFCcisGuXedOZunUz8fEJvkhr8Ra9ep1k0qRG7NwJmzeff5MMERG5mDJ1Jxnm32KdvvvuO86cOePWgkTElSMAh4eftbgS8SQhIfkMHGiuz59vbS0iIlXNJf099cJALCLul5CgACxFu+suc/npp46x4iIiUhplCsA2m63QGF+N+RWpOIZxfg9wpsXViKe56SYIDob9+2HtWqurERGpOso0BtgwDO6//34CAgIAyMrK4pFHHik0C8SCBQvcV6GIFzt4ENLTfYFcwsIUgMVVUBAMGgQffwyffAJdulhdkYhI1VCmADxs2DCXr++99163FiMirjZscKxtx8dHf+OWwu680wzAn34K//yn7hQoIlIaZQrAM2fOrKg6RKQIGzc61wBd5i+F9e8PdjscPgy//ALXXWd1RSIins/SvoJ33nmHdu3aUbt2bWrXrk1cXBzfffedc79hGIwfP56YmBgCAwPp0aMHO3bscDlGdnY2jz32GOHh4QQHBzNo0CAOHTrk0iYtLY34+Hjsdjt2u534+HhOnjxZGW9R5JKcC8AbSmomXiwgAG691Vz/5BNLSxERqTIsDcD169fnlVdeYf369axfv54bbriBW265xRlyJ02axOTJk5k2bRrr1q0jKiqKPn36cPr0aecxRo8ezcKFC5k/fz4rV64kIyODgQMHkp+f72wzdOhQNm/ezKJFi1i0aBGbN28mPj6+0t+vSFkYxvkXNikAS/HuvNNc/uc/kJdnbS0iIlWBpQH45ptv5qabbqJ58+Y0b96cf/zjH9SqVYs1a9ZgGAZTpkzhhRdeYPDgwbRp04bZs2dz9uxZ5s2bB0B6ejozZszg9ddfp3fv3nTo0IE5c+awbds2li1bBkBCQgKLFi3igw8+IC4ujri4OKZPn87XX3/N7t27rXz7IiX6/XdITQV//wJgk9XliAfr3RvCwiAlBVassLoaERHP5zGXS+Tn5zN//nzOnDlDXFwc+/btIzk5mb59+zrbBAQE0L17d1atWgXAhg0byM3NdWkTExNDmzZtnG1Wr16N3W6ny3mXR3ft2hW73e5sU5Ts7GxOnTrl8hCpTGvWmMuWLc8CuZbWIp7Nzw9uv91c1zAIEZGLszwAb9u2jVq1ahEQEMAjjzzCwoULad26NcnJyQCFbrMcGRnp3JecnIy/vz+hoaEltomIiCj0uhEREc42RZk4caJzzLDdbqdBgwaX9D5Fymr1anPZtq3utigX5xgG8fnnkKvfl0RESmR5AG7RogWbN29mzZo1/PnPf2bYsGHs3LnTuf/CG20YhnHRm29c2Kao9hc7znPPPUd6errzcfDgwdK+JRG3cPQAKwBLaXTvDhERcOIE/DECTEREimF5APb39+fyyy+nc+fOTJw4kfbt2/Pmm28SFRUFUKiXNiUlxdkrHBUVRU5ODmlpaSW2OXr0aKHXPXbsWKHe5fMFBAQ4Z6dwPEQqy5kzsGWLua4ALKXh6wt33GGuaxiEiEjJLA/AFzIMg+zsbJo0aUJUVBRLly517svJyWHFihV069YNgE6dOuHn5+fSJikpie3btzvbxMXFkZ6eztrz7hP666+/kp6e7mwj4mk2bID8fLjsMoiK0t+zpXQcwyC++AKysy0tRUTEo5XpRhju9vzzz3PjjTfSoEEDTp8+zfz58/nxxx9ZtGgRNpuN0aNHM2HCBGJjY4mNjWXChAkEBQUxdOhQAOx2Ow8++CBjxoyhbt26hIWFMXbsWNq2bUvv3r0BaNWqFf3792fEiBG89957ADz88MMMHDiQFi1aWPbeRUriGP7Qtau1dUjVcs015i9Nhw/D4sXmbZJFRKQwSwPw0aNHiY+PJykpCbvdTrt27Vi0aBF9+vQB4OmnnyYzM5NRo0aRlpZGly5dWLJkCSEhIc5jvPHGG/j6+jJkyBAyMzPp1asXs2bNwsfHx9lm7ty5PP74487ZIgYNGsS0adMq982KlIHjAjgFYCmLGjXMYRBTpsD8+QrAIiLFsTQAz5gxo8T9NpuN8ePHM378+GLb1KxZk6lTpzJ16tRi24SFhTFnzpzylilSqQzjXA9wXJy1tYjnSkhIKHL7lVcGAS1ZuDCflSu3ERRUUOJxwsPDadiwYQVUKCLiuSwNwCJS2IEDkJxsXtTUsSMUk3PES2VkJAE27r333hJa/UZWVizXXfc6UPIv/4GBQezalaAQLCJeRQFYxMM4en87dIDAQGtrEc+TlXUSMOjZcxqxsUX/iWDjxmDWr4fLLnuLAQOeLPZYx44lsHDhvaSmpioAi4hXUQAW8TAa/yulERp6OdHRHYvc160brF8Phw/XJji4I5rFUUTElcdNgybi7Rx36Nb4Xymv0FBo1Mhc37rV2lpERDyRArCIB8nIgE2bzPVrr7W2Fqna2rUzl1u3mhdWiojIOQrAIh7k11/NG2A0bAgNGlhdjVRlrVubF1IeOwZJSVZXIyLiWRSARTzIL7+Yy2uusbYOqfpq1oSWLc11x221RUTEpAAs4kFWrjSXGv4g7tC+vbnctg3y8qytRUTEkygAi3iIvLxzM0CoB1jcoWlTqF0bMjNh1y6rqxER8RwKwCIeYts28yK42rWhTRurq5HqoEaNc73AjosrRUREAVjEYziGP3TrBj4+1tYi1UeHDuZy7144edLSUkREPIYCsIiH0AVwUhFCQ6FJE3NdvcAiIiYFYBEPYBjw88/mui6AE3dz9AJv3gwFBZaWIiLiERSARTzAgQNw5Ig5b+vVV1tdjVQ3rVqZ06KdOmUOhRAR8XYKwCIewDH8oWNHCAqythapfnx9z90ZTsMgREQUgEU8goY/SEVzDIPYtQvOnLG2FhERqykAi3iAn34yl9dfb20dUn1FRUF0tDkGeOtWq6sREbGWArCIxVJSICHBXFcPsFQkRy/wpk3mhZciIt5KAVjEYo75f9u0gbp1ra1Fqre2bc3xwMeOweHDVlcjImIdBWARi2n4g1SWmjWhdWtzfeNGa2sREbGSArCIxRSApTI5hkHs2AG5ufoRICLeSf/7iVgoPd28OQHAdddZWop4iUaNICwMcnJg7946VpcjImIJBWARC/3yi3kx0uWXQ0yM1dWIN7DZzp8SLdzaYkRELKIALGIhDX8QK7Rvbwbho0drAS2tLkdEpNL5Wl2ASHWWmJhIampqsfu/+645UIuGDfezceOJItskOOZIE3GTkBCIjYXffgMYbnU5IiKVTgFYpIIkJibSsmUrMjPPFtMiEEgHYPz4nowfv7/E42VknHZrfeLdOnRwBOD7yM09YnU5IiKVSgFYpIKkpqaSmXmW226bQ716rQrtP3y4Ft9840dwcA5Dh36OzVb0cfbs+Zbly/+PrKysCq5YvElsLAQG5pKZGcnPP5+hSxerKxIRqTwKwCIVrF69VkRHdyy0ffduc9mkiT8xMYX3O6SmagiEuJ+PDzRvfpwtW6L44ou6jB1rdUUiIpVHF8GJWCQx0Vw2amRtHeK9WrQ4DsDq1bV1ZzgR8SoKwCIWyM+HgwfNdQVgsUqdOtnAzxQU2PjkE6urERGpPArAIhY4cgTy8iAoCMI1FatY6mMA5s+3uAwRkUqkACxigQMHzGXDhhR78ZtI5fiMGjUM1q2D33+3uhYRkcqhACxiAY3/Fc9xjKuuMqfY0zAIEfEWCsAilaygQAFYPEu/fmmAhkGIiPdQABapZEePQnY2+PtDZKTV1YhAz54n8fODbdtgxw6rqxERqXgKwCKV7PzxvzX0HSgeoHbtfPr3N9c1DEJEvIF+/IpUMg1/EE90113mcv58MAxraxERqWgKwCKVyDDO9QArAIsnGTQIAgNhzx7YtMnqakREKpYCsEglSk2Fs2fB1xdiYqyuRuScWrVg4EBzXRfDiUh1pwAsUon27TOXDRqAj4+1tYhcyDEM4pNPzNlKRESqKwVgkUq0f7+5bNzYyipEinbjjRASYo5TX7PG6mpERCqOArBIJTGMcwG4SRNLSxEpUmAg3Hqrua5hECJSnSkAi1SSo0chMxP8/DT+VzyXYxjEp59Cfr61tYiIVBQFYJFK4hj/26iRxv+K5+rdG8LCzF/YVqywuhoRkYqhACxSSTT+V6oCf3+4/XZzXcMgRKS6UgAWqQQFBefm/9X4X/F0jmEQn30GubnW1iIiUhEUgEUqQVISZGdDQABERVldjUjJuneHyEhIS4Nly6yuRkTE/RSARSrB+cMfaui7Tjycjw/86U/m+iefWFuLiEhF0I9ikUqg8b9S1dx5p7n84gvzrxciItWJArBIBcvPtznH/yoAS1VxzTXmdH3p6bB4sdXViIi4lwKwSAVLSQkmNxeCgsxxlSJVQY0acMcd5rqGQYhIdaMALFLBDh0KAaBpU7DZLC5GpAwcwyC+/NK8iYuISHVhaQCeOHEiV111FSEhIURERHDrrbeye/dulzaGYTB+/HhiYmIIDAykR48e7Nixw6VNdnY2jz32GOHh4QQHBzNo0CAOHTrk0iYtLY34+Hjsdjt2u534+HhOnjxZ0W9RhEOHagNmABbxRAkJCWzcuLHQw99/I1FR2WRkwFtv7S2yzfmPxMREq9+KiEip+Fr54itWrODRRx/lqquuIi8vjxdeeIG+ffuyc+dOgoODAZg0aRKTJ09m1qxZNG/enJdffpk+ffqwe/duQkLMnrXRo0fz1VdfMX/+fOrWrcuYMWMYOHAgGzZswOePW24NHTqUQ4cOsWjRIgAefvhh4uPj+eqrr6x58+Il6pCaGgRAs2YWlyJygYyMJMDGvffeW0KrScD/4//9v/XAnSUeLzAwiF27EmjYsKEbqxQRcT9LA7AjjDrMnDmTiIgINmzYwPXXX49hGEyZMoUXXniBwYMHAzB79mwiIyOZN28eI0eOJD09nRkzZvDRRx/Ru3dvAObMmUODBg1YtmwZ/fr1IyEhgUWLFrFmzRq6dOkCwPTp04mLi2P37t20aNGict+4eJEbMAwb4eFQu7bVtYi4yso6CRj07DmN2Ni4ItukpgayYAH4+PyJ+PhN+PsXFNnu2LEEFi68l9TUVAVgEfF4lgbgC6WnpwMQFhYGwL59+0hOTqZv377ONgEBAXTv3p1Vq1YxcuRINmzYQG5urkubmJgY2rRpw6pVq+jXrx+rV6/Gbrc7wy9A165dsdvtrFq1qsgAnJ2dTfZ5c/+cOnXK7e9XvEEfQMMfxLOFhl5OdHTHIvdFRcFPP0Fqag1OnLiSDh0quTgRkQrgMRfBGYbBU089xbXXXkubNm0ASE5OBiDygkvnIyMjnfuSk5Px9/cnNDS0xDYRERGFXjMiIsLZ5kITJ050jhe22+00aNDg0t6geCkFYKnabDZo185c37bN2lpERNzFYwLwX/7yF7Zu3crHH39caJ/tgkvnDcMotO1CF7Ypqn1Jx3nuuedIT093Pg4ePFiatyHidOiQP9AMm83Q/L9SpbVtay737QP9MUxEqgOPCMCPPfYYX375JcuXL6d+/frO7VFRUQCFemlTUlKcvcJRUVHk5OSQlpZWYpujR48Wet1jx44V6l12CAgIoHbt2i4PkbL49VfzMxMZeYaAAIuLEbkEdeqAY1iveoFFpDqwNAAbhsFf/vIXFixYwA8//ECTJk1c9jdp0oSoqCiWLl3q3JaTk8OKFSvo1q0bAJ06dcLPz8+lTVJSEtu3b3e2iYuLIz09nbVr1zrb/Prrr6SnpzvbiLjbr7+as5Rcdpm6zKTq0zAIEalOLL0I7tFHH2XevHn897//JSQkxNnTa7fbCQwMxGazMXr0aCZMmEBsbCyxsbFMmDCBoKAghg4d6mz74IMPMmbMGOrWrUtYWBhjx46lbdu2zlkhWrVqRf/+/RkxYgTvvfceYE6DNnDgQM0AIRUiN/dcAK5f/xQQY21BIpeodWv47js4etR86K6GIlKVWRqA33nnHQB69Ojhsn3mzJncf//9ADz99NNkZmYyatQo0tLS6NKlC0uWLHHOAQzwxhtv4Ovry5AhQ8jMzKRXr17MmjXLOQcwwNy5c3n88ceds0UMGjSIadOmVewbFK+1ejVkZPgCx6hX76zV5YhcssBAiI2FXbtgyxY4b+IdEZEqx9IAbBjGRdvYbDbGjx/P+PHji21Ts2ZNpk6dytSpU4ttExYWxpw5c8pTpkiZffutY20RNWpcYWUpIm5z5ZVmAN68GW64AXw9aiJNEZHS84iL4ESqm3MB+NuSmolUKbGx5g1dMjNh506rqxERKT8FYBE3O3jQvFCoRg0DWGJ1OSJuU6MGdOpkrq9fb20tIiKXQgFYxM2++85ctmlzBjhhaS0i7tahgxmEDx40L4YTEamKFIBF3Mwx/OGaazT9mVQ/ISHQsqW5rl5gEamqFIBF3Cg7G5YtM9evuSbd2mJEKkjnzuZy61bIybG2FhGR8lAAFnGjn3+GM2cgKgpatMi0uhyRCtG4MdSta4bfTZusrkZEpOwUgEXcyDH84cYbzXGSItWRzQZdu5rrv/wCeXnW1iMiUlb6ES3iJoYBX35prg8YYG0tIhXtyivNKdFOn4YNG6yuRkSkbBSARdxk5074/XcICIB+/ayuRqRi+frCddeZ6ytXQl6ezdqCRETKQAFYxE3++19z2asX1KplbS0ilaFDB7DbISMDEhLCrS5HRKTUFIBF3MQRgG+5xdo6RCqLj8+5XuDNm6OAQEvrEREpLQVgETc4cgTWrjXXb77Z2lpEKtOVV5q9wJmZfsA4q8sRESkVBWARN/jqK3PZpQtER1tbi0hl8vExZz0xjWXnziAryxERKRUFYBE30PAH8WYtWkCzZicAH156qZFujiEiHk8BWOQSnT4N339vrisAi7fq1u0QcIz//S+QSZOsrkZEpGQKwCKXaPFi845Yl18OrVpZXY2INQID84DHAXjpJfjhB2vrEREpiQKwyCVasMBc3nqreYcsEe81n379TpCXB4MHw44dVtcjIlI0BWCRS5CVde4CuD/9ydpaRDzBuHEHuPZaSE+Hm26CpCSrKxIRKUwBWOQSLF1q3gSgfn246iqrqxGxXkCAwRdfQPPmkJgIN9wA27dbXZWIiCsFYJFL8Nln5vL226GGvptEAKhbF779FmJiYNcu85fD6dPBMFzb5ebC7t2wfj2sWGHeTlxEpDL4Wl2ASFWVkwNffmmu3367tbWIeJpmzWDTJrjvPvNC0YcfhgkTzDAcGwsbNsDKlXDmzLnn1KgB330HfftaV7eIeAcFYJFy+uEHOHkSoqKgWzerqxHxPBERZk/w66/DX/8K+/ebj/PVqgWhoZCfb95Rcdgw2LYNwsOtqFhEvIUCsEg5ff65ubztNvNuWCICCQkJhbb16gVXX+1DQkIQCQlBHDgQwOWXZ3LVVRk0a5ZJjRqQmWkjPr4l+/YFcs89Z1m0KEizqohIhVEAFimHvDxYuNBc1+wPIpCRkQTYuPfeey/hKO2BX1myJIhXXz3Os8/WdVN1IiKuFIBFyuGnn+D4cfNin+uvt7oaEetlZZ0EDHr2nEZsbFy5j7Nq1Xa2b+/E3/5Wh7/8xRwiISLibgrAIuXgmP3httvAV99FIk6hoZcTHd2x3M+Pi9vI9u37ycxszC+/QL9+bixOROQPmrhJpIzy888Nf9DsDyLuZY77Ne+jvHy5paWISDWmACxSRqtWQXIy1KljTvIvIu5mJl8FYBGpKArAImXkmP1h0CDw97e2FpHqyUy+GzbAqVMWlyIi1ZICsEgZFBScC8Ca/UGkohymQYMs8vPh55+trkVEqiMFYJEyWLcODh0yr0zv08fqakSqr86dMwANgxCRiqHr10UukJiYSGpqapH73nrrMiCSa645wc6d+0s8TlE3BBCR0unc+TQLF4YrAItIhVAAFjlPYmIiLVu2IjPzbDEtfgdg8eIRLF68oFTHzMg47abqRLxHp07m982mTZCWZt4uWUTEXRSARc6TmppKZuZZbrttDvXqtbpgXyALFjTF1zef++77K76+L5R4rD17vmX58v8jKyurIksWqZbq1cujZUvYtQtWrIBbb7W6IhGpThSARYpQr16rQpP579xpLmNjfWjQoMNFj5GaqiEQIpeiRw8zAC9frgAsIu6li+BESsEwwDGkt3Vra2sR8RY9e5rLH3+0tAwRqYYUgEVK4dgxOH4cfHwgNtbqakS8Q9eu5jIhAXJzra1FRKoXBWCRUnAMf7j8cggIsLYWEW9Rvz4EBZnhd98+q6sRkepEAVikFBzDH1q1KrmdiLhPjRrQooW5vmuXtbWISPWiACxyEampkJJi/jBu3tzqakS8S8uW5lIBWETcSQFY5CIcvb9Nm0JgoLW1iHgbRwDevdvaOkSkelEAFrkIx/hfDX8QqXzqARaRiqAALFKC48chORlstnM/iEWk8jjGACckmNMRioi4gwKwSAm2bzeXzZqZV6OLSOWKjTV/AU1LM8fji4i4gwKwSDEM41wAvuIKa2sR8VZBQdCokbmuYRAi4i4KwCLFSEkxe5x8fDT8QcRKGgcsIu6mACxSDEfvb2ws1KxpbS0i3kwBWETcTQFYpAjnD39o08baWkS8nQKwiLibArBIEY4dC+LkSfDz080vRKymACwi7qYALFKE//0vFDB/8Pr5WVyMiJdzBOB9+yAry9paRKR6UAAWKcSH338PAzT7g4gniIiAOnXMoUl79lhdjYhUBwrAIoX0JTPTj6AguPxyq2sRkfNvRKNhECLiDpYG4J9++ombb76ZmJgYbDYbX3zxhct+wzAYP348MTExBAYG0qNHD3bs2OHSJjs7m8cee4zw8HCCg4MZNGgQhw4dcmmTlpZGfHw8drsdu91OfHw8J0+erOB3J1XXMADatjWnQBMR6zkC8O7d1tYhItWDpQH4zJkztG/fnmnTphW5f9KkSUyePJlp06axbt06oqKi6NOnD6dPn3a2GT16NAsXLmT+/PmsXLmSjIwMBg4cSH5+vrPN0KFD2bx5M4sWLWLRokVs3ryZ+Pj4Cn9/UvWcOuUD3AJA+/bW1iIi55x/S2QRkUvla+WL33jjjdx4441F7jMMgylTpvDCCy8wePBgAGbPnk1kZCTz5s1j5MiRpKenM2PGDD766CN69+4NwJw5c2jQoAHLli2jX79+JCQksGjRItasWUOXLl0AmD59OnFxcezevZsWjv9VRYBly+oANQkNzSQqKtDqckTkD47ZWP73P2vrEJHqwWPHAO/bt4/k5GT69u3r3BYQEED37t1ZtWoVABs2bCA3N9elTUxMDG3atHG2Wb16NXa73Rl+Abp27Yrdbne2KUp2djanTp1yeUj19/XXdQFo3vw4NpvFxYiIU7Nm5nLvXmvrEJHqwWMDcHJyMgCRkZEu2yMjI537kpOT8ff3JzQ0tMQ2ERERhY4fERHhbFOUiRMnOscM2+12GjRocEnvRzzfnj2wZUstIJ/Y2BNWlyMi52na1FympoL6I0TkUnlsAHawXdANZxhGoW0XurBNUe0vdpznnnuO9PR05+PgwYNlrFyqmg8/dKwtISgoz8pSROQCISFQr565rl5gEblUHhuAo6KiAAr10qakpDh7haOiosjJySEtLa3ENkePHi10/GPHjhXqXT5fQEAAtWvXdnlI9ZWXBzNnOr6aZWElIlIcRy+wArCIXCqPDcBNmjQhKiqKpUuXOrfl5OSwYsUKunXrBkCnTp3w8/NzaZOUlMT27dudbeLi4khPT2ft2rXONr/++ivp6enONiLffQeHD0OdOrnAF1aXIyJFcATg33+3tg4RqfosnQUiIyOD/513Se++ffvYvHkzYWFhNGzYkNGjRzNhwgRiY2OJjY1lwoQJBAUFMXToUADsdjsPPvggY8aMoW7duoSFhTF27Fjatm3rnBWiVatW9O/fnxEjRvDee+8B8PDDDzNw4EDNACFO06eby4EDTzBnTo61xYhIkdQDLCLuYmkAXr9+PT179nR+/dRTTwEwbNgwZs2axdNPP01mZiajRo0iLS2NLl26sGTJEkJCQpzPeeONN/D19WXIkCFkZmbSq1cvZs2ahc95dzCYO3cujz/+uHO2iEGDBhU797B4n8OH4ZtvzPVbb01lzhxr6xGRomkmCBFxF0sDcI8ePTAMo9j9NpuN8ePHM378+GLb1KxZk6lTpzJ16tRi24SFhTFHqUaK8e9/Q0EBXH89NGmSbXU5IlIM9QCLiLt47BhgkcpQUAAzZpjrI0ZYW4uIlMwRgPfvNy9cFREpLwVg8WpLl8KBA1CnDtx+u9XViEhJLrsM/P3N8HvokNXViEhVpgAsXu2dd8zlffdBoO58LOLRatSAJk3MdQ2DEJFLoQAsXisxEb76ylz/85+trUVESkfjgEXEHRSAxWu9/745BviGG6BlS6urEZHS0FzAIuIOCsDilXJyzs39O2qUtbWISOlpKjQRcQcFYPFKCxZASgrExMCgQVZXIyKlpSEQIuIOls4DLGKVt982lyNGgJ+ftbWISGEJCQlFbs/Kqgm05rff8ti4cetFjxMeHk7Dhg3dXJ2IVHUKwOJ1tm2Dn38GHx/N/SviaTIykgAb9957bzEtgoAznDrlS6dOvYCTJR4vMDCIXbsSFIJFxIUCsHidf/3LXN52mzmvqIh4jqysk4BBz57TiI2NK7LNRx/lkpnpx+DBqwgPzyz2WMeOJbBw4b2kpqYqAIuICwVg8SqpqeC4K/YTT1hbi4gULzT0cqKjOxa5r25d80YYPj6tiI6u5MJEpFrQRXDiVd5/H7KyoGNHuOYaq6sRkfIIDTWXJ05YW4eIVF0KwOI1cnPPXfz2xBNgs1lbj4iUT1iYuVQAFpHyUgAWr/H553D4MERGwp13Wl2NiJRX3brm8vhxa+sQkapLAVi8xpQp5vLPf4aAAEtLEZFLoAAsIpdKAVi8wi+/wK+/gr8/PPKI1dWIyKVwBOAzZ8wx/SIiZaVZIKRaSExMJDU1tdj9zzzTDLAzYEAqhw8ncvhw0e2Km3xfRDxHQADUqgUZGWYvsKYzFJGyUgCWKi8xMZGWLVuRmXm2mBbtgc1APgsXdmXhwt8vesyMjNNurFBE3C083AzAqakKwCJSdgrAUuWlpqaSmXmW226bQ716rQrtX7asCXv3QrNm6fTq9WmJx9qz51uWL/8/svR3VRGPFhYG+/drHLCIlI8CsFQb9eq1KjRx/vHjsHevud6nTxiRkWElHiM1VUMgRKqC8HBzqQAsIuWhi+CkWlu50lw2b25OfyYi1YNmghCRS6EALNVWaips2WKuX3uttbWIiHud3wNsGNbWIiJVjwKwVFvff2/+YGzeHBo0sLoaEXGnOnWgRg3Iy4NTp6yuRkSqGgVgqZYOHIBdu8zbHffubXU1IuJuNWqcuyVyCTMgiogUSQFYqh3DgCVLzPWOHaFePWvrEZGKoXHAIlJeCsBS7ezYAUeOmHd969HD6mpEpKIoAItIeSkAS7WSlXWu9/eaa8y7RYlI9aQALCLlpQAs1crixXD6tDk2MC7O6mpEpCI5ZoLQGGARKSsFYKk2EhNrs3mzuX7LLeDnZ2k5IlLBHD3A6emQm2ttLSJStSgASzVh5+efGwLQtSs0bGhxOSJS4YKCoGZNc/3ECWtrEZGqRQFYqjxzEvx3OXPGn7AwuOEGqysSkcpgs53rBdYwCBEpCwVgqfI++igCuAubzeDWWzX0QcSbOG5xnpRkbR0iUrUoAEuVtmwZTJ16GQDduh3UHd9EvEz9+uby8GFr6xCRqkUBWKqsvXvhzjuhoMAG/JvWrfU3UBFvc34ALiiwthYRqToUgKVKSkqCPn3MC1+uuOIMMAqbzeqqRKSyhYdDQIA5C0RKitXViEhVoQAsVc6JE9C3r9kD3LQpvP7670C21WWJiAVsNrjMHAXFoUPW1iIiVYcCsFQpp0/DgAGwfTtER8PSpVCvXp7VZYmIhTQOWETKSgFYqoyTJ82e3zVrIDTUvOVx06ZWVyUiVnMEYPUAi0hpKQBLlZCaas7ve374bdPG6qpExBM4hkCkpkJmprW1iEjVoAAsHu/QIejRAzZtgnr14McfoXNnq6sSEU8RFARhYea6hkGISGkoAItH274d4uJgxw6IiYGffoJ27ayuSkQ8jYZBiEhZ+FpdgHivxMREUku4f+m6dbUYO7YpGRm+NGmSydSpv3P2bA4bN7q2S0hIqOBKRcTT1a8PW7cqAItI6SgAiyUSExNp2bIVmZlni2nxKPAG5kf0J/btu5WBA9NKPGZGxmk3VykiVcX5M0EYBpoXXERKpAAslkhNTSUz8yy33TaHevVaObfn5dlYubIhv/1WF4BmzU7QvXsIvr7Lij3Wnj3fsnz5/5GVlVXhdYuIZ4qIAF9fyMoyb4gRGWl1RSLiyRSAxVL16rUiOrojAMnJ8M03cPSo2XvTuzfExYVhs4WVeIzUVA2BEPF2Pj7QpAns2WMOhejTx+qKRMST6SI4sVxBgXlx2/TpZvgNCoJ774Vu3fRnTBEpvY7m79Js3gx5uj+OiJRAPcBiIRt799bh88/h+HFzS8uWMHAgBAdbW5mIVD3Nm0NIiHnHyF27oG5dqysSEU+lHmCpdGfPwjffhAHrWLasKcePm72+t90GQ4Yo/IpI+dSoAR06mOsXzhYjInI+9QBLpcjMNG9g8d//wvz5kJ7eGGiMn18+3br5EBcHAQEWFykiVV7HjuaQqn37ID1d/6mISNEUgKVCnDkDa9fCL7+YjxUrXG9Retll2Rw+/HfuumsITZvqzhYi4h52O8TGmhfDJSSEW12OiHgoBWAps6JuYJGc7MeWLbXYsiWYLVtqsWdPIPn5rlewRUTkcO216fTufZJatdZy333/IDBwcGWWLiJeoGNHMwDv3l0XiLG6HBHxQArAUiaJiYm0aNGerKzLgTjgGqAb0KCo1sCqPx4rSEnZyoIFsGDBuRa6eYWIuFvz5lCvHhw75gssJj093+qSRMTDeFUAfvvtt3nttddISkriiiuuYMqUKVx33XVWl+WxDANOnIDt22HTJvOxenU4WVkpgJ9LW5vNoG7ds0RFnSEy8gyRkRnUqpULNP/jcb9Le928QkQqSo0aMHQoTJ+ew9mzbRg9OoNVq3SBrYic4zUB+JNPPmH06NG8/fbbXHPNNbz33nvceOON7Ny5k4YNG1pdntvl55uzLWRkmONxz5yB7GzIyTEfubnmMjPTDLnHj7s+jhyBvXshPf3CIwcBEBCQR8OGvtSvDw0bQkyMDX//YKB0P2F08woRqUh16sBNN/2Pzz6LZuvWUOLi4NFH4e67oXZtq6sTEat5TQCePHkyDz74IA899BAAU6ZMYfHixbzzzjtMnDjR4upcnToF48dDWtppMjKyyM+3kZ8P+fk28vLMh2M9M7MGWVk1yMyswdmzNcjM9CErqwbZ2e6b4S4qKpsWLTJp2fIsQUG/8cYb93HffV8QE9PRba8hIuJuYWFZwACCgn5m2zYfHnkEnnoK2rWDRo2gQQOzVzggAGrWNJcBAeDnZ96Ex/EA16+L2nb+13JpDKPitlfksd213ZNqKW57WY8RGws9exa9zypeEYBzcnLYsGEDzz77rMv2vn37smrVqiKfk52dTXZ2tvPr9D+6Qk+dOlVxhf4hNRXeeMPx1cWm8TGA/D8eRSkAzgCZfzxygZw/HrlANnASOHHB4yiwH0gkOTmL5GRzJgeHfftWkpubUbY3dp5jxxL+WG7jwIHAch/HG47liTV5w7E8sSZvOJY7a0pN3Q2s5m9/m8vvv1/Ft9+GceBAIGvWwJo1l3RoESmDQYPO0qlTUKW8liOnGcWlcQfDCxw+fNgAjF9++cVl+z/+8Q+jefPmRT5n3LhxBma61EMPPfTQQw899NCjCj0OHjxYYjb0ih5gB9sFf5syDKPQNofnnnuOp556yvl1QUEBJ06coG7dusU+p7xOnTpFgwYNOHjwILU1OM1tdF4rhs5rxdB5rRg6rxVD59X9dE7dwzAMTp8+TUxMyVMgekUADg8Px8fHh+TkZJftKSkpREZGFvmcgIAAAi64NVmdOnUqqkQAateurQ99BdB5rRg6rxVD57Vi6LxWDJ1X99M5vXR2u/2ibdx3pZQH8/f3p1OnTixdutRl+9KlS+nWrZtFVYmIiIiIFbyiBxjgqaeeIj4+ns6dOxMXF8f7779PYmIijzzyiNWliYiIiEgl8poAfOedd3L8+HH+9re/kZSURJs2bfj2229p1KiR1aUREBDAuHHjCg25kEuj81oxdF4rhs5rxdB5rRg6r+6nc1q5bIZxsXkiRERERESqD68YAywiIiIi4qAALCIiIiJeRQFYRERERLyKArCIiIiIeBUFYIu9/fbbNGnShJo1a9KpUyd+/vlnq0vyaOPHj8dms7k8oqKinPsNw2D8+PHExMQQGBhIjx492LFjh8sxsrOzeeyxxwgPDyc4OJhBgwZx6NChyn4rlvrpp5+4+eabiYmJwWaz8cUXX7jsd9d5TEtLIz4+Hrvdjt1uJz4+npMnT1bwu7POxc7r/fffX+jz27VrV5c2Oq+uJk6cyFVXXUVISAgRERHceuut7N6926WNPq9lV5rzqs9r2b3zzju0a9fOeTOLuLg4vvvuO+d+fVY9SIk3SpYKNX/+fMPPz8+YPn26sXPnTuOJJ54wgoODjQMHDlhdmscaN26cccUVVxhJSUnOR0pKinP/K6+8YoSEhBiff/65sW3bNuPOO+80oqOjjVOnTjnbPPLII8Zll11mLF261Ni4caPRs2dPo3379kZeXp4Vb8kS3377rfHCCy8Yn3/+uQEYCxcudNnvrvPYv39/o02bNsaqVauMVatWGW3atDEGDhxYWW+z0l3svA4bNszo37+/y+f3+PHjLm10Xl3169fPmDlzprF9+3Zj8+bNxoABA4yGDRsaGRkZzjb6vJZdac6rPq9l9+WXXxrffPONsXv3bmP37t3G888/b/j5+Rnbt283DEOfVU+iAGyhq6++2njkkUdctrVs2dJ49tlnLarI840bN85o3759kfsKCgqMqKgo45VXXnFuy8rKMux2u/Huu+8ahmEYJ0+eNPz8/Iz58+c72xw+fNioUaOGsWjRogqt3VNdGNTcdR537txpAMaaNWucbVavXm0Axq5duyr4XVmvuAB8yy23FPscndeLS0lJMQBjxYoVhmHo8+ouF55Xw9Dn1V1CQ0ONDz74QJ9VD6MhEBbJyclhw4YN9O3b12V73759WbVqlUVVVQ179uwhJiaGJk2acNddd7F3714A9u3bR3Jysss5DQgIoHv37s5zumHDBnJzc13axMTE0KZNG533P7jrPK5evRq73U6XLl2cbbp27Yrdbvfqc/3jjz8SERFB8+bNGTFiBCkpKc59Oq8Xl56eDkBYWBigz6u7XHheHfR5Lb/8/Hzmz5/PmTNniIuL02fVwygAWyQ1NZX8/HwiIyNdtkdGRpKcnGxRVZ6vS5cufPjhhyxevJjp06eTnJxMt27dOH78uPO8lXROk5OT8ff3JzQ0tNg23s5d5zE5OZmIiIhCx4+IiPDac33jjTcyd+5cfvjhB15//XXWrVvHDTfcQHZ2NqDzejGGYfDUU09x7bXX0qZNG0CfV3co6ryCPq/ltW3bNmrVqkVAQACPPPIICxcupHXr1vqsehivuRWyp7LZbC5fG4ZRaJucc+ONNzrX27ZtS1xcHM2aNWP27NnOizPKc0513gtzx3ksqr03n+s777zTud6mTRs6d+5Mo0aN+Oabbxg8eHCxz9N5Nf3lL39h69atrFy5stA+fV7Lr7jzqs9r+bRo0YLNmzdz8uRJPv/8c4YNG8aKFSuc+/VZ9QzqAbZIeHg4Pj4+hX5bS0lJKfTboRQvODiYtm3bsmfPHudsECWd06ioKHJyckhLSyu2jbdz13mMiori6NGjhY5/7Ngxnes/REdH06hRI/bs2QPovJbkscce48svv2T58uXUr1/fuV2f10tT3Hktij6vpePv78/ll19O586dmThxIu3bt+fNN9/UZ9XDKABbxN/fn06dOrF06VKX7UuXLqVbt24WVVX1ZGdnk5CQQHR0NE2aNCEqKsrlnObk5LBixQrnOe3UqRN+fn4ubZKSkti+fbvO+x/cdR7j4uJIT09n7dq1zja//vor6enpOtd/OH78OAcPHiQ6OhrQeS2KYRj85S9/YcGCBfzwww80adLEZb8+r+VzsfNaFH1ey8cwDLKzs/VZ9TSVesmduHBMgzZjxgxj586dxujRo43g4GBj//79VpfmscaMGWP8+OOPxt69e401a9YYAwcONEJCQpzn7JVXXjHsdruxYMECY9u2bcbdd99d5BQz9evXN5YtW2Zs3LjRuOGGG7xuGrTTp08bmzZtMjZt2mQAxuTJk41NmzY5p+Bz13ns37+/0a5dO2P16tXG6tWrjbZt21brqXpKOq+nT582xowZY6xatcrYt2+fsXz5ciMuLs647LLLdF5L8Oc//9mw2+3Gjz/+6DId19mzZ51t9Hktu4udV31ey+e5554zfvrpJ2Pfvn3G1q1bjeeff96oUaOGsWTJEsMw9Fn1JArAFnvrrbeMRo0aGf7+/kbHjh1dpqCRwhxzJvr5+RkxMTHG4MGDjR07djj3FxQUGOPGjTOioqKMgIAA4/rrrze2bdvmcozMzEzjL3/5ixEWFmYEBgYaAwcONBITEyv7rVhq+fLlBlDoMWzYMMMw3Hcejx8/btxzzz1GSEiIERISYtxzzz1GWlpaJb3LylfSeT179qzRt29fo169eoafn5/RsGFDY9iwYYXOmc6rq6LOJ2DMnDnT2Uaf17K72HnV57V8hg8f7vyZXq9ePaNXr17O8GsY+qx6EpthGEbl9TeLiIiIiFhLY4BFRERExKsoAIuIiIiIV1EAFhERERGvogAsIiIiIl5FAVhEREREvIoCsIiIiIh4FQVgEREREfEqCsAiIiIi4lUUgEVEpFrYv38/NpuNzZs3W12KiHg4BWARkQukpKQwcuRIGjZsSEBAAFFRUfTr14/Vq1dbXZrlPCVk3n///dx6662W1iAiVZev1QWIiHia22+/ndzcXGbPnk3Tpk05evQo33//PSdOnLC6NLfJycnB39/f6jJERCyhHmARkfOcPHmSlStX8uqrr9KzZ08aNWrE1VdfzXPPPceAAQOAontBT548ic1m48cffwTgxx9/xGazsXjxYjp06EBgYCA33HADKSkpfPfdd7Rq1YratWtz9913c/bsWedxevTowWOPPcbo0aMJDQ0lMjKS999/nzNnzvDAAw8QEhJCs2bN+O6775zPyc/P58EHH6RJkyYEBgbSokUL3nzzTZf35egxnThxIjExMTRv3py//e1vtG3bttA56NSpEy+++GK5zp9hGEyaNImmTZsSGBhI+/bt+eyzz5z7Hefl+++/p3PnzgQFBdGtWzd2797tcpyXX36ZiIgIQkJCeOihh3j22We58sorARg/fjyzZ8/mv//9LzabzeW8A+zdu5eePXsSFBRE+/bt1XMvIoUoAIuInKdWrVrUqlWLL774guzs7Es+3vjx45k2bRqrVq3i4MGDDBkyhClTpjBv3jy++eYbli5dytSpU12eM3v2bMLDw1m7di2PPfYYf/7zn7njjjvo1q0bGzdupF+/fsTHxzuDc0FBAfXr1+fTTz9l586dvPjiizz//PN8+umnLsf9/vvvSUhIYOnSpXz99dcMHz6cnTt3sm7dOmebrVu3smnTJu6///5yvd+//vWvzJw5k3feeYcdO3bw5JNPcu+997JixQqXdi+88AKvv/4669evx9fXl+HDhzv3zZ07l3/84x+8+uqrbNiwgYYNG/LOO+84948dO5YhQ4bQv39/kpKSSEpKolu3bi7HHjt2LJs3b6Z58+bcfffd5OXllev9iEg1ZYiIiIvPPvvMCA0NNWrWrGl069bNeO6554wtW7Y49+/bt88AjE2bNjm3paWlGYCxfPlywzAMY/ny5QZgLFu2zNlm4sSJBmD8/vvvzm0jR440+vXr5/y6e/fuxrXXXuv8Oi8vzwgODjbi4+Od25KSkgzAWL16dbHvYdSoUcbtt9/u/HrYsGFGZGSkkZ2d7dLuxhtvNP785z87vx49erTRo0ePYo9b1Ht3yMjIMGrWrGmsWrXKZfuDDz5o3H333YZhFH1evvnmGwMwMjMzDcMwjC5duhiPPvqoyzGuueYao3379i7v55Zbbimytg8++MC5bceOHQZgJCQkFPueRMT7qAdYROQCt99+O0eOHOHLL7+kX79+/Pjjj3Ts2JFZs2aV+Vjt2rVzrkdGRhIUFETTpk1dtqWkpBT7HB8fH+rWresyVCEyMhLA5XnvvvsunTt3pl69etSqVYvp06eTmJjocty2bdsWGvc7YsQIPv74Y7KyssjNzWXu3LkuvbFlsXPnTrKysujTp4+zJ71WrVp8+OGH/P7778W+x+joaJf3s3v3bq6++mqX9hd+XZKSji0iAroITkSkSDVr1qRPnz706dOHF198kYceeohx48Zx//33U6OG2XdgGIazfW5ubpHH8fPzc67bbDaXrx3bCgoKin1OUc+z2WwAzud9+umnPPnkk7z++uvExcUREhLCa6+9xq+//upynODg4EL13XzzzQQEBLBw4UICAgLIzs7m9ttvL/qkXISjnm+++YbLLrvMZV9AQECx7/HC93P+Nofzz/XFXOzYIiIKwCIipdC6dWu++OILAOrVqwdAUlISHTp0ALB0WrCff/6Zbt26MWrUKOe2C3tci+Pr68uwYcOYOXMmAQEB3HXXXQQFBZWrjtatWxMQEEBiYiLdu3cv1zEAWrRowdq1a4mPj3duW79+vUsbf39/8vPzy/0aIuLdFIBFRM5z/Phx7rjjDoYPH067du0ICQlh/fr1TJo0iVtuuQWAwMBAunbtyiuvvELjxo1JTU3lr3/9q2U1X3755Xz44YcsXryYJk2a8NFHH7Fu3TqaNGlSquc/9NBDtGrVCoBffvmlVM+5cNYGMAPw2LFjefLJJykoKODaa6/l1KlTrFq1ilq1ajFs2LBSHfuxxx5jxIgRdO7cmW7duvHJJ5+wdetWl6EjjRs3ZvHixezevZu6detit9tLdWwREVAAFhFxUatWLbp06cIbb7zB77//Tm5uLg0aNGDEiBE8//zzznb//ve/GT58OJ07d6ZFixZMmjSJvn37WlLzI488wubNm7nzzjux2WzcfffdjBo1ymWqtJLExsbSrVs3jh8/TpcuXUr1nLvuuqvQtn379vH3v/+diIgIJk6cyN69e6lTpw4dO3Z0OXcXc88997B3717Gjh1LVlYWQ4YM4f7772ft2rXONiNGjODHH3+kc+fOZGRksHz5cho3blzq1xAR72YzyjKwSkREqh3DMGjZsiUjR47kqaeesrqcIvXp04eoqCg++ugjq0sRkWpAPcAiIl4sJSWFjz76iMOHD/PAAw9YXQ4AZ8+e5d1336Vfv374+Pjw8ccfs2zZMpYuXWp1aSJSTSgAi4h4scjISMLDw3n//fcJDQ21uhzAnLnh22+/5eWXXyY7O5sWLVrw+eef07t3b6tLE5FqQkMgRERERMSr6EYYIiIiIuJVFIBFRERExKsoAIuIiIiIV1EAFhERERGvogAsIiIiIl5FAVhEREREvIoCsIiIiIh4FQVgEREREfEq/x+jsVRaUi/KFwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class DataAnalysis:\n",
    "    def __init__(self, dataset_df):\n",
    "        self.dataset_df = dataset_df\n",
    "\n",
    "    def display_missing_values(self):\n",
    "        \"\"\"Displays missing values for each column in the DataFrame.\"\"\"\n",
    "        print(\"\\nMissing values in each column:\")\n",
    "        print(self.dataset_df.isnull().sum())\n",
    "\n",
    "    def display_data_types(self):\n",
    "        \"\"\"Displays the data types of each column in the DataFrame.\"\"\"\n",
    "        print(\"\\nData types of each column:\")\n",
    "        print(self.dataset_df.dtypes)\n",
    "\n",
    "    def analyze_terms_distribution(self):\n",
    "        \"\"\"Analyzes and plots the distribution of the 'terms' column.\"\"\"\n",
    "        self.dataset_df['num_terms'] = self.dataset_df['terms'].apply(lambda x: len(ast.literal_eval(x)))\n",
    "\n",
    "        print(\"\\nDistribution of the number of terms associated with papers:\")\n",
    "        print(self.dataset_df['num_terms'].value_counts())\n",
    "\n",
    "        plt.figure(figsize=(8, 6))\n",
    "        sns.countplot(x=self.dataset_df['num_terms'], palette='viridis')\n",
    "        plt.title('Distribution of Number of Terms per Paper')\n",
    "        plt.xlabel('Number of Terms')\n",
    "        plt.ylabel('Count')\n",
    "        plt.show()\n",
    "\n",
    "    def analyze_most_common_terms(self):\n",
    "        \"\"\"Finds and plots the most common terms in the 'terms' column.\"\"\"\n",
    "        all_terms = [term for sublist in self.dataset_df['terms'].apply(ast.literal_eval).tolist() for term in sublist]\n",
    "        term_counts = collections.Counter(all_terms)\n",
    "\n",
    "        print(\"\\nMost common terms (categories) and their counts:\")\n",
    "        print(term_counts.most_common(10))\n",
    "\n",
    "        most_common_terms = term_counts.most_common(10)\n",
    "        terms, counts = zip(*most_common_terms)\n",
    "\n",
    "        plt.figure(figsize=(10, 6))\n",
    "        sns.barplot(x=counts, y=terms, color='blue')\n",
    "        plt.title('Top 10 Most Common Terms')\n",
    "        plt.xlabel('Count')\n",
    "        plt.ylabel('Term')\n",
    "        plt.show()\n",
    "\n",
    "    def analyze_paper_lengths(self):\n",
    "        \"\"\"Analyzes the lengths of summaries and titles and plots the distribution.\"\"\"\n",
    "        self.dataset_df['summary_length'] = self.dataset_df['summaries'].apply(len)\n",
    "        self.dataset_df['title_length'] = self.dataset_df['titles'].apply(len)\n",
    "\n",
    "        print(\"\\nSummary statistics of title lengths:\")\n",
    "        print(self.dataset_df['title_length'].describe())\n",
    "\n",
    "        print(\"\\nSummary statistics of summary lengths:\")\n",
    "        print(self.dataset_df['summary_length'].describe())\n",
    "\n",
    "        plt.figure(figsize=(8, 6))\n",
    "        sns.histplot(self.dataset_df['title_length'], bins=30, kde=True, color='blue')\n",
    "        plt.title('Distribution of Title Lengths')\n",
    "        plt.xlabel('Title Length')\n",
    "        plt.ylabel('Frequency')\n",
    "        plt.show()\n",
    "\n",
    "        plt.figure(figsize=(8, 6))\n",
    "        sns.histplot(self.dataset_df['summary_length'], bins=30, kde=True, color='blue')\n",
    "        plt.title('Distribution of Summary Lengths')\n",
    "        plt.xlabel('Summary Length')\n",
    "        plt.ylabel('Frequency')\n",
    "        plt.show()\n",
    "\n",
    "analysis = DataAnalysis(dataset_df)\n",
    "analysis.display_missing_values()\n",
    "analysis.display_data_types()\n",
    "analysis.analyze_terms_distribution()\n",
    "analysis.analyze_most_common_terms()\n",
    "analysis.analyze_paper_lengths()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 📊 Naive Bayes Classification:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "In this section, you'll classify documents using a Naive Bayes classifier, which you'll implement from scratch.\n",
    "\n",
    "### Steps:\n",
    "1. **Reduce Dataset Size**: Choose a smaller subset of the data that still covers all relevant classes.\n",
    "2. **Build Feature Vectors**: Create vectors based on word counts for each document.\n",
    "3. **Implement Naive Bayes Classifier**: Develop the classifier from the ground up and use it to categorize documents.\n",
    "4. **Train & Evaluate**: Train the classifier on the reduced dataset and evaluate its performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import nltk\n",
    "from nltk import word_tokenize\n",
    "import string\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.metrics import (\n",
    "    accuracy_score,\n",
    "    confusion_matrix,\n",
    "    ConfusionMatrixDisplay,\n",
    "    f1_score,\n",
    "    precision_recall_fscore_support,\n",
    "    recall_score,\n",
    "    roc_curve,\n",
    "    auc,\n",
    ")\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import label_binarize\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Data Reduction\n",
    "\n",
    "To optimize the performance of your Naive Bayes classifier, you may reduce the dataset size. Focus on selecting a representative subset that includes all three classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_terms</th>\n",
       "      <th>summary_length</th>\n",
       "      <th>title_length</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>21000.000000</td>\n",
       "      <td>21000.000000</td>\n",
       "      <td>21000.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>2.005762</td>\n",
       "      <td>1207.161952</td>\n",
       "      <td>72.351714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.051290</td>\n",
       "      <td>313.989256</td>\n",
       "      <td>22.502443</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>29.000000</td>\n",
       "      <td>9.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>989.000000</td>\n",
       "      <td>57.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>2.000000</td>\n",
       "      <td>1199.000000</td>\n",
       "      <td>71.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>3.000000</td>\n",
       "      <td>1417.000000</td>\n",
       "      <td>86.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>8.000000</td>\n",
       "      <td>3309.000000</td>\n",
       "      <td>211.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          num_terms  summary_length  title_length\n",
       "count  21000.000000    21000.000000  21000.000000\n",
       "mean       2.005762     1207.161952     72.351714\n",
       "std        1.051290      313.989256     22.502443\n",
       "min        1.000000       29.000000      9.000000\n",
       "25%        1.000000      989.000000     57.000000\n",
       "50%        2.000000     1199.000000     71.000000\n",
       "75%        3.000000     1417.000000     86.000000\n",
       "max        8.000000     3309.000000    211.000000"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NB_DATA_SIZE = 21000\n",
    "NB_TRAIN_SIZE = 19000\n",
    "\n",
    "\n",
    "reduced_df = dataset_df.sample(NB_DATA_SIZE)\n",
    "reduced_df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Build Feature Vectors\n",
    "\n",
    "Extract the label from the 'terms' column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def extract_label_from_labels(labels):\n",
    "    splitted = labels.split()\n",
    "    return splitted[0].replace(\"'\", \"\").replace('[', '').replace(']', '').replace(',', '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "h6UJBgbU5WoD"
   },
   "outputs": [],
   "source": [
    "def preprocess_text(text, minimum_length=1, stopword_removal=True, stopwords_domain=[], lower_case=True,\n",
    "                       punctuation_removal=True):\n",
    "    \n",
    "    tokens = word_tokenize(text)\n",
    "\n",
    "    if stopword_removal:\n",
    "        stopwords = [x.lower() for x in nltk.corpus.stopwords.words('english')]\n",
    "        domain_stopwords = [x.lower() for x in stopwords_domain]\n",
    "        tokens = [word for word in tokens if word.lower() not in domain_stopwords + stopwords]\n",
    "\n",
    "    if punctuation_removal:\n",
    "        tokens = [word for word in tokens if word not in string.punctuation]\n",
    "\n",
    "    if lower_case:\n",
    "        tokens = [word.lower() for word in tokens if len(word) > minimum_length]\n",
    "    else:\n",
    "        tokens = [word for word in tokens if len(word) > minimum_length]\n",
    "\n",
    "    return tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "p0OOvg7M5WoD"
   },
   "outputs": [],
   "source": [
    "labels = [extract_label_from_labels(labels) for labels in reduced_df['terms']]\n",
    "corpus = []\n",
    "for i, (index, row) in enumerate(reduced_df.iterrows()):\n",
    "    titles, summaries, label = row['titles'], row['summaries'], labels[i]\n",
    "    title_token = preprocess_text(titles)\n",
    "    summaries_token = preprocess_text(summaries)\n",
    "    corpus.append({'title':title_token, 'summaries':summaries_token, 'label':label})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "W6FnUEq35WoD"
   },
   "outputs": [],
   "source": [
    "flattened_corpus = []\n",
    "for paper in corpus:\n",
    "    data_title = ' '.join(paper['title'])\n",
    "    data_summary = ' '.join(paper['summaries'])\n",
    "    flattened_corpus.append(data_title + \" \" + data_summary)\n",
    "\n",
    "vectorizer = CountVectorizer()\n",
    "doc_word_matrix = vectorizer.fit_transform(flattened_corpus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Implement Naive Bayes Classifier\n",
    "We'll implement the `fit` and `predict` methods of the NaiveBayes class in the following code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "O5-Fh_c65WoD"
   },
   "outputs": [],
   "source": [
    "class NaiveBayes():\n",
    "    def __init__(self, alpha=1.0):\n",
    "        self.prior = None\n",
    "        self.word_counts = None\n",
    "        self.lk_word = None\n",
    "        self.alpha = alpha\n",
    "        \n",
    "    def fit(self, x, y):\n",
    "        '''\n",
    "        Fit the features and the labels\n",
    "        Calculate prior, word_counts and lk_word\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        x: np.ndarray\n",
    "            An m * n matrix - m is count \n",
    "            of docs and n is size of vocabulary\n",
    "\n",
    "        y: np.ndarray\n",
    "            The real class label for each doc\n",
    "            \n",
    "        Returns\n",
    "        -------\n",
    "        self\n",
    "            Returns self as a classifier\n",
    "        '''\n",
    "        \n",
    "        size = x.shape[1]\n",
    "        self.prior = np.bincount(y) / len(y)\n",
    "        self.word_counts = np.zeros((len(np.unique(y)), size))\n",
    "        for c in np.unique(y):\n",
    "            self.word_counts[c] = np.sum(x[y == c], axis=0)\n",
    "        self.lk_word = (self.word_counts + self.alpha) / (np.sum(self.word_counts, axis=1)[:, np.newaxis] + self.alpha * size)\n",
    "        return self\n",
    "\n",
    "    def predict(self, x):\n",
    "        '''\n",
    "        Parameters\n",
    "        ----------\n",
    "        x: np.ndarray\n",
    "            An k * n matrix - k is count \n",
    "            of docs and n is vocabulary size\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        np.ndarray\n",
    "            Return the predicted class for each doc\n",
    "            with the highest probability (argmax)\n",
    "        '''\n",
    "        \n",
    "        posterior = np.log(self.prior) + np.dot(x, np.log(self.lk_word.T))\n",
    "        return np.argmax(posterior, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Train & Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "T-sWLxdS5WoE"
   },
   "outputs": [],
   "source": [
    "distinct_labels = list(set([paper['label'] for paper in corpus]))\n",
    "indices = [distinct_labels.index(paper['label']) for paper in corpus]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "XRGX7Ucg5WoE"
   },
   "outputs": [],
   "source": [
    "classifier = NaiveBayes()\n",
    "nb_train_x, nb_train_y= np.array(doc_word_matrix.toarray()[:NB_TRAIN_SIZE]), np.array(indices[:NB_TRAIN_SIZE])\n",
    "nb_test_x, nb_test_y = np.array(doc_word_matrix.toarray()[NB_TRAIN_SIZE:]), np.array(indices[NB_TRAIN_SIZE:])\n",
    "classifier.fit(nb_train_x, nb_train_y)\n",
    "prediction = classifier.predict(nb_test_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "m_HoZIey5WoE",
    "outputId": "2a8d36fe-7504-435d-f5fc-64f24952be47"
   },
   "outputs": [],
   "source": [
    "def get_metric(actual, pred, func, **kwargs):\n",
    "    return round(100 * func(actual, pred, **kwargs), 2)\n",
    "\n",
    "print(f'accuracy = {get_metric(nb_test_y, prediction, accuracy_score)}%')\n",
    "\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(f'macro precision = {get_metric(nb_test_y, prediction, precision_score, average=\"macro\")}%')\n",
    "print(f'macro recall = {get_metric(nb_test_y, prediction, recall_score, average=\"macro\")}%')\n",
    "print(f'macro f1-score = {get_metric(nb_test_y, prediction, f1_score, average=\"macro\")}%')\n",
    "\n",
    "print(\"---------------------------------------------------------------\")\n",
    "print(f'micro precision = {get_metric(nb_test_y, prediction, precision_score, average=\"micro\")}%')\n",
    "print(f'micro precision = {get_metric(nb_test_y, prediction, precision_score, average=\"micro\")}%')\n",
    "print(f'micro precision = {get_metric(nb_test_y, prediction, precision_score, average=\"micro\")}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "RqZNdRZ15WoE",
    "outputId": "7bd3f4d2-0277-44ff-fc57-a5217e8bc02b"
   },
   "outputs": [],
   "source": [
    "actual_labels = nb_test_y \n",
    "predicted_labels = prediction\n",
    "\n",
    "n_classes = 3\n",
    "\n",
    "binarized_labels = label_binarize(actual_labels, classes=np.unique(actual_labels))\n",
    "\n",
    "predicted_labels_2d = np.zeros((len(predicted_labels), n_classes))\n",
    "predicted_labels_2d[np.arange(len(predicted_labels)), predicted_labels] = 1\n",
    "\n",
    "fpr = dict()\n",
    "tpr = dict()\n",
    "roc_auc = dict()\n",
    "for i in range(n_classes):\n",
    "    fpr[i], tpr[i], _ = roc_curve(binarized_labels[:, i], predicted_labels_2d[:, i])\n",
    "    roc_auc[i] = auc(fpr[i], tpr[i])\n",
    "\n",
    "fpr[\"micro\"], tpr[\"micro\"], _ = roc_curve(binarized_labels.ravel(), predicted_labels_2d.ravel())\n",
    "roc_auc[\"micro\"] = auc(fpr[\"micro\"], tpr[\"micro\"])\n",
    "\n",
    "plt.figure()\n",
    "lw = 2\n",
    "plt.plot(fpr[\"micro\"], tpr[\"micro\"], color='deeppink', lw=lw, label='micro-average ROC curve (AUC = {0:0.2f})'\n",
    "         ''.format(roc_auc[\"micro\"]))\n",
    "for i in range(n_classes):\n",
    "    plt.plot(fpr[i], tpr[i], lw=lw, label='ROC curve of class {0} (AUC = {1:0.2f})'\n",
    "             ''.format(i, roc_auc[i]))\n",
    "\n",
    "plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')\n",
    "plt.xlim([0.0, 1.0])\n",
    "plt.ylim([0.0, 1.05])\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver Operating Characteristic (ROC) Curve')\n",
    "plt.legend(loc=\"lower right\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "nrtgc5gY5WoF",
    "outputId": "6c362b9f-5234-4275-a7dd-b1eb9c8fa4fa",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, classes):\n",
    "    confusion_mat = np.zeros((3, 3), dtype=int)\n",
    "\n",
    "    for true, pred in zip(y_true, y_pred):\n",
    "        confusion_mat[true, pred] += 1\n",
    "\n",
    "    sns.heatmap(confusion_mat, annot=True, xticklabels=classes, yticklabels=classes)\n",
    "    plt.xlabel(\"predicted\")\n",
    "    plt.ylabel(\"actual\")\n",
    "    plt.show()\n",
    "\n",
    "plot_confusion_matrix(nb_test_y, prediction, distinct_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 🤖 Neural Network Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "In this section, you'll implement a simple neural network to classify the documents. This will allow you to compare the performance of traditional methods like Naive Bayes with more modern techniques like neural networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from transformers import (\n",
    "    BertTokenizer,\n",
    "    BertForSequenceClassification,\n",
    "    TrainingArguments,\n",
    "    Trainer\n",
    ")\n",
    "from torch.utils.data import random_split\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "import nltk\n",
    "import string\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import (\n",
    "    precision_recall_fscore_support,\n",
    "    recall_score,\n",
    "    f1_score,\n",
    "    accuracy_score,\n",
    "    confusion_matrix,\n",
    "    ConfusionMatrixDisplay,\n",
    ")\n",
    "from torch import nn\n",
    "\n",
    "from nltk import word_tokenize\n",
    "from tqdm import tqdm\n",
    "import torch\n",
    "from transformers import (\n",
    "    BertTokenizer,\n",
    "    BertForSequenceClassification,\n",
    "    TrainingArguments,\n",
    "    Trainer,\n",
    ")\n",
    "import fasttext\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import recall_score, accuracy_score, f1_score, precision_score\n",
    "\n",
    "\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Load & Preprocess Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "pLdIp2J85WoF"
   },
   "outputs": [],
   "source": [
    "# read data\n",
    "df = pd.read_csv('./arxiv_data.csv')\n",
    "df = df.drop_duplicates(subset=['summaries', 'titles'])\n",
    "df = df.head(NB_DATA_SIZE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "z8bv7u7j5WoH"
   },
   "outputs": [],
   "source": [
    "def preprocess_text(text, minimum_length=1, stopword_removal=True, stopwords_domain=[], lower_case=True,\n",
    "                       punctuation_removal=True):\n",
    "    \n",
    "    tokens = word_tokenize(text)\n",
    "\n",
    "    if stopword_removal:\n",
    "        stopwords = [x.lower() for x in nltk.corpus.stopwords.words('english')]\n",
    "        domain_stopwords = [x.lower() for x in stopwords_domain]\n",
    "        tokens = [word for word in tokens if word.lower() not in domain_stopwords + stopwords]\n",
    "\n",
    "    if punctuation_removal:\n",
    "        tokens = [word for word in tokens if word not in string.punctuation]\n",
    "\n",
    "    if lower_case:\n",
    "        tokens = [word.lower() for word in tokens if len(word) > minimum_length]\n",
    "    else:\n",
    "        tokens = [word for word in tokens if len(word) > minimum_length]\n",
    "\n",
    "    return tokens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "id": "970g_i4R5WoH"
   },
   "source": [
    "\n",
    "<div dir=\"rtl\">\n",
    "<font face=\"XB Zar\" size=5>\n",
    "</font>\n",
    "<font face=\"XB Zar\" size=3>\n",
    "     <br>\n",
    "\n",
    "</font>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "pY_JQXVz5WoH"
   },
   "outputs": [],
   "source": [
    "# preprocess text\n",
    "df['preprocessed_abstract'] = df['summaries'].apply(lambda x: preprocess_text(x))\n",
    "df['preprocessed_title'] = df['titles'].apply(lambda x: preprocess_text(x))\n",
    "df['text'] = df['preprocessed_abstract'] + df['preprocessed_title']\n",
    "df['label'] = [extract_label_from_labels(labels) for labels in df['terms']]\n",
    "df['text'] = df['text'].apply(lambda x: \" \".join(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "1Sjb1z_SseTZ"
   },
   "outputs": [],
   "source": [
    "distinct_labels = ['cs.CV' , 'cs.LG', 'stat.ML']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "id": "1fh87DsT5WoH"
   },
   "source": [
    "### Feature Extraction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "id": "4JCaxGLF5WoH"
   },
   "source": [
    "this section, we'll utilize **FastText** to generate initial embeddings for each document in the dataset. Thus, we'll use the following steps:\n",
    "1. **Train FastText Model**:\n",
    "   - Use the available data to train a FastText model that generates 100-dimensional embeddings for each token.\n",
    "  \n",
    "2. **Compute Document Embeddings**:\n",
    "   - For each document (title + abstract), compute a weighted average of the FastText embeddings of its tokens.\n",
    "   - The weights for each token are derived from its TF-IDF score, allowing for a more meaningful representation of the document.\n",
    "  \n",
    "3. **Final Embedding**:\n",
    "   - The final embedding for each document is the weighted average of its token embeddings, where the weights are the tokens' TF-IDF values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "F_i84iRx5WoH"
   },
   "outputs": [],
   "source": [
    "class FastText:\n",
    "\n",
    "    def __init__(self, preprocessor=None, method='skipgram'):\n",
    "        self.method = method\n",
    "        self.model = None\n",
    "        self.preprocessor = preprocessor\n",
    "\n",
    "    def train(self, texts):\n",
    "        \"\"\"\n",
    "        train the fasttext model and save it into self.model\n",
    "        Parameters\n",
    "        ----------\n",
    "        texts: list of list of str\n",
    "        \"\"\"\n",
    "        self.model = fasttext.train_unsupervised(texts, model=self.method, dim=100, epoch=20)\n",
    "\n",
    "    def get_query_embedding(self, query, tf_idf_vectorizer):\n",
    "        \"\"\"\n",
    "        get the embedding of the query. You can use the tf_idf_vectorizer to get the weights of the words in the query. preprocess the query using self.preprocessor if it is not None\n",
    "        Parameters\n",
    "        ----------\n",
    "        query: str\n",
    "        tf_idf_vectorizer: TfidfVectorizer\n",
    "        Returns embedding of the query\n",
    "        \"\"\"\n",
    "        if tf_idf_vectorizer is not None:\n",
    "            query_tokens = tf_idf_vectorizer.transform([query]).nonzero()[1]\n",
    "            feature_names = np.array(tf_idf_vectorizer.get_feature_names_out())\n",
    "            word_vectors = [self.model.get_word_vector(feature_names[token]) for token in query_tokens]\n",
    "            if word_vectors:\n",
    "                query_embedding = np.mean(word_vectors, axis=0)\n",
    "            else:\n",
    "                query_embedding = np.zeros(self.model.get_dimension()) \n",
    "\n",
    "            return query_embedding\n",
    "        \n",
    "        query_embed = self.model.get_sentence_vector(query)\n",
    "\n",
    "        return query_embed\n",
    "\n",
    "    def save_FastText_model(self, path='FastText_model.bin'):\n",
    "        self.model.save_model(path)\n",
    "  \n",
    "    def load_FastText_model(self, path=\"FastText_model.bin\"):\n",
    "        self.model = fasttext.load_model(path)\n",
    "\n",
    "    def prepare(self, dataset, mode, save=False):\n",
    "        if mode == 'train':\n",
    "            self.train(dataset)\n",
    "        if mode == 'load':\n",
    "            self.load_FastText_model()\n",
    "        if save:\n",
    "            self.save_FastText_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "kPIMGwjT5WoI",
    "outputId": "00e33e08-e46f-44be-c121-30cdc83e60c5"
   },
   "outputs": [],
   "source": [
    "FastText_model = FastText(preprocessor=preprocess_text)\n",
    "FastText_model.prepare('df.txt', mode='train', save=True)\n",
    "# FastText_model.prepare(preprocessed_total, mode='load')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "nFxXTOvB5WoI",
    "outputId": "442e5e53-62e9-4115-ad69-66a03a72b677"
   },
   "outputs": [],
   "source": [
    "text = 'covid'\n",
    "FastText_model.model.get_nearest_neighbors(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "XbRxpXVR5WoI"
   },
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "class TF_IDF:\n",
    "    def __init__(self):\n",
    "        self.vectorizer = TfidfVectorizer()\n",
    "\n",
    "    def fit_vectorizer(self, data):\n",
    "        \"\"\"\n",
    "        fit the vectorizer on the data\n",
    "        Parameters\n",
    "        ----------\n",
    "        data: list of list of str\n",
    "        \"\"\"\n",
    "        self.vectorizer.fit(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "c6XB6rcR5WoI"
   },
   "outputs": [],
   "source": [
    "TF_IDF_model = TF_IDF()\n",
    "TF_IDF_model.fit_vectorizer(df['text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "KpvwYus85WoI",
    "outputId": "35ec5351-faf5-40c4-fa9c-88ac84708e5d"
   },
   "outputs": [],
   "source": [
    "text =  \"backpropagation is good\"\n",
    "TF_IDF_model.vectorizer.transform([' '.join(text)])\n",
    "FastText_model.get_query_embedding(text, TF_IDF_model.vectorizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "DZjwGNYJ5WoI"
   },
   "outputs": [],
   "source": [
    "embeddings = []\n",
    "for paper in df['text']:\n",
    "    embedding = FastText_model.get_query_embedding(paper, TF_IDF_model.vectorizer)\n",
    "    embeddings.append(embedding)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "id": "sAU36KzH5WoI"
   },
   "source": [
    "### Prepare the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "1h_GdcAQ5WoJ"
   },
   "outputs": [],
   "source": [
    "class PapersDataSet(Dataset):\n",
    "    def __init__(self, embeddings: list, labels: list):\n",
    "        self.embeddings = embeddings\n",
    "        self.labels = labels\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "\n",
    "    def __getitem__(self, i):\n",
    "        return self.embeddings[i], self.labels[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "HXdxUzKD5WoJ"
   },
   "outputs": [],
   "source": [
    "BATCH_SIZE = 128\n",
    "labels_str, labels = np.unique(df['label'], return_inverse=True)\n",
    "dataset = PapersDataSet(embeddings, labels)\n",
    "train_dataset, val_dataset, test_dataset = random_split(dataset, [0.8, 0.1 , 0.1])\n",
    "\n",
    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE)\n",
    "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "id": "WhelHobx5WoJ"
   },
   "source": [
    "### Define the Network Architecture\n",
    "\n",
    "In this section, we define the network architecture of our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "U69ULC_q5WoJ"
   },
   "outputs": [],
   "source": [
    "class ClassifierModel(nn.Module):\n",
    "    def __init__(self, in_features=100, num_classes=3):\n",
    "        super().__init__()\n",
    "        self.num_classes = num_classes\n",
    "        self.in_features = in_features\n",
    "        \n",
    "        self.fc1 = nn.Linear(self.in_features, 32)\n",
    "        self.bn1 = nn.BatchNorm1d(32)\n",
    "        self.act1 = nn.GELU()\n",
    "        self.fc2 = nn.Linear(32, self.num_classes)\n",
    "\n",
    "    \n",
    "    def forward(self, x):\n",
    "        out = self.fc1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.act1(out)\n",
    "        out = self.fc2(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# define the loss function and the optimizer. We suggest using Adam optimizer\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "model = ClassifierModel().to(device)\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.0002)\n",
    "lr_scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=3, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true,
    "id": "cwvv2aT85WoJ"
   },
   "source": [
    "### Train the Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "NhGoe5nZ5WoK"
   },
   "outputs": [],
   "source": [
    "def eval_epoch(model: nn.Module, criterion: nn.Module, dataloader: torch.utils.data.DataLoader, test_mode=False):\n",
    "    \"\"\"\n",
    "    Evaluate the model on the given dataloader. used for validation and test\n",
    "    Parameters\n",
    "    ----------\n",
    "    model: nn.Module\n",
    "    criterion: nn.Module\n",
    "    dataloader: torch.utils.data.DataLoader\n",
    "    test_mode: bool\n",
    "        If True, the function will print 'Test' instead of 'Validation'\n",
    "    Returns\n",
    "    -------\n",
    "    eval_loss: float\n",
    "        The loss on the given dataloader\n",
    "    predicted_labels: list\n",
    "        The predicted labels\n",
    "    true_labels: list\n",
    "        The true labels\n",
    "    f1_score_macro: float\n",
    "        The f1 score on the given dataloader\n",
    "    \"\"\"\n",
    "\n",
    "    \n",
    "    total_loss = 0.0\n",
    "    predicted_labels, actual_labels = [], []\n",
    "    model.eval()\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for x, labels in dataloader:\n",
    "            x, labels= x.to(device), labels.to(device)\n",
    "\n",
    "            model_out = model(x)\n",
    "            loss = criterion(model_out, labels) * len(labels)\n",
    "            total_loss += loss.item()\n",
    "            preds = torch.argmax(model_out, axis=1)\n",
    "            predicted_labels.extend(preds.cpu().tolist())\n",
    "            actual_labels.extend(labels.cpu().tolist())\n",
    "\n",
    "    total_loss /= len(dataloader.dataset)\n",
    "\n",
    "    f1_score_macro = f1_score(predicted_labels, actual_labels, average='macro')\n",
    "    print(f\"Loss: {round(total_loss, 4)} - f1 macro: {round(f1_score_macro, 4)} on {'test' if test_mode else 'validation'} set\")\n",
    "    return total_loss, predicted_labels, actual_labels, f1_score_macro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "v85uPoHM5WoK",
    "outputId": "b666e777-7ff9-475d-9f95-b8d1fa93341b"
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Train the model for num_epochs epochs\n",
    "epoch_true and epoch_all are used to calculate the accuracy.\n",
    "epoch_true is the number of correct predictions and epoch_all is the total number of predictions in the epoch\n",
    "\"\"\"\n",
    "EPOCHS = 60\n",
    "train_losses, validation_losses, train_f1_macros, val_f1_macros = [], [], [], []\n",
    "for epoch in range(EPOCHS):\n",
    "    train_loss, val_loss, correct_predicted = 0, 0, 0\n",
    "    predicted_labels_train, true_labels_train = [], []\n",
    "\n",
    "    model.train()\n",
    "    for i , (x, label) in enumerate(train_loader):\n",
    "        x, label = x.to(device), label.to(device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(x)\n",
    "        loss = criterion(outputs, label) * len(label)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_loss += loss.item()\n",
    "        preds = torch.argmax(outputs, 1)\n",
    "        correct_predicted += (preds == label).sum().item()\n",
    "\n",
    "        predicted_labels_train.extend(preds.cpu().numpy())\n",
    "        true_labels_train.extend(label.cpu().numpy())\n",
    "      \n",
    "    train_loss /= len(train_dataset)    \n",
    "    model.eval()\n",
    "    train_f1 = f1_score(true_labels_train, predicted_labels_train, average='macro')\n",
    "\n",
    "    val_loss, predicted_labels, true_labels, f1_score_macro = eval_epoch(model, criterion, val_loader)\n",
    "    lr_scheduler.step(val_loss)\n",
    "\n",
    "    train_losses.append(train_loss)\n",
    "    validation_losses.append(val_loss)\n",
    "    train_f1_macros.append(train_f1)\n",
    "    val_f1_macros.append(f1_score_macro)\n",
    "    print(f'Epoch {epoch + 1} - Train Loss = {round(train_loss, 4)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "itFwRGkP5WoK",
    "outputId": "65853aa9-9c1a-4678-ffd4-3d6bfc0a5cc3"
   },
   "outputs": [],
   "source": [
    "plt.plot(train_losses)\n",
    "plt.plot(validation_losses)\n",
    "plt.title('Loss')\n",
    "plt.legend(['train', 'validation'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "4BtRPVAq5WoK",
    "outputId": "e1632ffb-46cb-4e31-e5d4-62a4549f3819"
   },
   "outputs": [],
   "source": [
    "plt.plot(train_f1_macros)\n",
    "plt.plot(val_f1_macros)\n",
    "plt.title('F1 macro')\n",
    "plt.legend(['train', 'validation'])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "We will evaluate the model on the test set with the following metrics:\n",
    "- accuracy\n",
    "- Loss\n",
    "- F1-Macro\n",
    "- F1-Micro\n",
    "- Confusion matrix\n",
    "- Macro-average precision\n",
    "- Macro-average recall\n",
    "- Micro-average precision\n",
    "- Micro-average recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "UEpblVVd5WoL",
    "outputId": "5f007060-0ce3-4515-a757-eef9d3bdbefc",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model.eval()\n",
    "eval_loss, predicted_labels, true_labels, f1_score_macro = eval_epoch(model, criterion, test_loader, test_mode=True)\n",
    "\n",
    "print(\"Accuracy: \" + str(accuracy_score(true_labels, predicted_labels)))\n",
    "print(\"F1 macro: \" + str(f1_score(true_labels, predicted_labels, average='macro')))\n",
    "print(\"F1 micro: \" + str(f1_score(true_labels, predicted_labels, average='micro')))\n",
    "print(\"Precision macro: \" + str(precision_score(true_labels, predicted_labels, average='macro')))\n",
    "print(\"Precision micro: \" + str(precision_score(true_labels, predicted_labels, average='micro')))\n",
    "print(\"Recall macro: \" + str(recall_score(true_labels, predicted_labels, average='macro')))\n",
    "print(\"Recall micro: \" + str(recall_score(true_labels, predicted_labels, average='micro')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "xUb4RJia5WoL",
    "outputId": "ce478124-1746-4866-97fe-52d44e47bfe6"
   },
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, classes):\n",
    "    confusion_mat = np.zeros((3, 3), dtype=int)\n",
    "\n",
    "    for true, pred in zip(y_true, y_pred):\n",
    "        confusion_mat[true, pred] += 1\n",
    "\n",
    "    sns.heatmap(confusion_mat, annot=True, xticklabels=classes, yticklabels=classes)\n",
    "    plt.xlabel(\"predicted\")\n",
    "    plt.ylabel(\"actual\")\n",
    "    plt.show()\n",
    "\n",
    "plot_confusion_matrix(true_labels, predicted_labels, distinct_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "3K040kbI5WoL"
   },
   "outputs": [],
   "source": [
    "def predict(x):\n",
    "    \"\"\"\n",
    "    predict the class code of a given query\n",
    "    :param x: the que|ry\n",
    "    :return: the class of the query in the form of real strings.\n",
    "    \"\"\"\n",
    "    embedding = FastText_model.get_query_embedding(x, TF_IDF_model.vectorizer)\n",
    "    embedding = torch.tensor(embedding).view(1, -1).to(device)\n",
    "    model.eval()\n",
    "    output = model(embedding)\n",
    "    _ , predicted_class = torch.max(output.data, 1)\n",
    "    return labels_str[predicted_class]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "xF-lBTJI5WoL",
    "outputId": "9f7637a6-2e70-4dfb-929d-9dace8f1afb0"
   },
   "outputs": [],
   "source": [
    "predict('hardware and computerc architecture is good')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "id": "duQo7eSP5WoL"
   },
   "source": [
    "## 🧠 Large Language Models (LLM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "In this part, you will explore and implement Large Language Models (LLMs) to improve the classification and retrieval capabilities of your recommender system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "DwLUsyaz5WoM"
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import string\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import torch\n",
    "from tqdm import tqdm\n",
    "\n",
    "import nltk\n",
    "from nltk import word_tokenize\n",
    "\n",
    "from sklearn.metrics import (\n",
    "    accuracy_score,\n",
    "    confusion_matrix,\n",
    "    ConfusionMatrixDisplay,\n",
    "    f1_score,\n",
    "    precision_recall_fscore_support,\n",
    "    recall_score,\n",
    ")\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "from transformers import (\n",
    "    BertTokenizer,\n",
    "    BertForSequenceClassification,\n",
    "    TrainingArguments,\n",
    "    Trainer,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "id": "BF6b98Ay5WoM"
   },
   "source": [
    "### Load & Preprocess Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "Ygcw4IVZ5WoQ"
   },
   "outputs": [],
   "source": [
    "# read data\n",
    "df = pd.read_csv('./arxiv_data.csv')\n",
    "df = df.drop_duplicates(subset=['titles', 'summaries'])\n",
    "labels_str = [extract_label_from_labels(labels) for labels in df['terms']]\n",
    "label_encoder = LabelEncoder()\n",
    "labels = label_encoder.fit_transform(labels_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 641
    },
    "hidden": true,
    "id": "7A2eM-vY5WoR",
    "outputId": "b45d1ae4-4ddd-4645-a741-93109c7c3763"
   },
   "outputs": [],
   "source": [
    "df['preprocessed_abstract'] = df['summaries'].apply(lambda x: preprocess_text(x))\n",
    "df['preprocessed_title'] = df['titles'].apply(lambda x: preprocess_text(x))\n",
    "df['text'] = df['preprocessed_abstract'] + df['preprocessed_title']\n",
    "df['label'] = labels_str[:20000]\n",
    "df['text'] = df['text'].apply(lambda x: \" \".join(x))\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "7e1aESM0seTe"
   },
   "outputs": [],
   "source": [
    "distinct_labels =  ['cs.CV' , 'cs.LG', 'stat.ML']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "id": "YiaWe0yL5WoR"
   },
   "source": [
    "### Prepare the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "BniJl07z5WoR"
   },
   "outputs": [],
   "source": [
    "X, y = list(zip(*random.sample(list(zip( df['text'], labels)), 10000)))\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "id": "4K3gBHrq5WoR"
   },
   "source": [
    "### Bert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "hidden": true,
    "id": "BLDVy5UJ5WoR",
    "outputId": "7774fabd-0cf0-4cfc-c2b0-08a4f0859ae0"
   },
   "outputs": [],
   "source": [
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "sqiylI3Z5WoR"
   },
   "outputs": [],
   "source": [
    "bert_model = BertForSequenceClassification.from_pretrained(\"./drive/MyDrive/bert_model/\", num_labels=3).to(device)\n",
    "bert_freeze_model = BertForSequenceClassification.from_pretrained(\"./drive/MyDrive/bert_freeze_model/\", num_labels=3).to(device)\n",
    "for param in bert_freeze_model.bert.parameters():\n",
    "    param.requires_grad = False\n",
    "\n",
    "tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\", do_lower_case=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "nWdtp3ny5WoS"
   },
   "outputs": [],
   "source": [
    "class BertDataset(torch.utils.data.Dataset):\n",
    "    def __init__(self, data, labels, tokenizer):\n",
    "        self.tokenizer = tokenizer\n",
    "        self.encoded_data = self.tokenizer(data, truncation=True, padding=True, max_length=512)\n",
    "        self.labels = labels\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        item = {k: torch.tensor(v[idx]) for k, v in self.encoded_data.items()}\n",
    "        item['labels'] = torch.tensor([self.labels[idx]])\n",
    "        return item\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "\n",
    "train_dataset = BertDataset(X_train, y_train, tokenizer)\n",
    "test_dataset = BertDataset(X_test, y_test, tokenizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "pHlbm7TY5WoS"
   },
   "outputs": [],
   "source": [
    "def compute_metrics(pred):\n",
    "    labels = pred.label_ids\n",
    "    preds = pred.predictions.argmax(-1)\n",
    "    acc = accuracy_score(labels, preds)\n",
    "    f1_score_macro = f1_score(labels, preds, average='macro')\n",
    "    f1_score_micro = f1_score(labels, preds, average='micro')\n",
    "    precision_macro = precision_score(labels, preds, average='macro')\n",
    "    precision_micro = precision_score(labels, preds, average='micro')\n",
    "    recall_macro = recall_score(labels, preds, average='macro')\n",
    "    recall_micro = recall_score(labels, preds, average='micro')    \n",
    "\n",
    "    return {\n",
    "      'accuracy': acc,\n",
    "      'f1 macro': f1_score_macro,\n",
    "      'f1 micro': f1_score_micro,\n",
    "      'precision macro': precision_macro,\n",
    "      'precisoin micro': precision_micro,\n",
    "      'recall macro': recall_macro,\n",
    "      'recall micro': recall_micro,\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Fine-tune Bert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 328
    },
    "hidden": true,
    "id": "uHjskZEC5WoS",
    "outputId": "50a94dd9-dc26-48bf-9b96-bc34e0f08fda"
   },
   "outputs": [],
   "source": [
    "# fine tune bert and train model\n",
    "training_args = TrainingArguments(\n",
    "    output_dir='./bert_model',         \n",
    "    num_train_epochs=3,           \n",
    "    per_device_train_batch_size=20,\n",
    "    per_device_eval_batch_size=20,\n",
    "    weight_decay=0.01,\n",
    "    learning_rate=2e-4,\n",
    "    load_best_model_at_end=True,    \n",
    "    evaluation_strategy=\"steps\",\n",
    ")\n",
    "\n",
    "trainer = Trainer(\n",
    "    model=bert_model,                       \n",
    "    args=training_args,\n",
    "    train_dataset=train_dataset,\n",
    "    eval_dataset=test_dataset,\n",
    "    compute_metrics=compute_metrics,\n",
    ")\n",
    "\n",
    "trainer.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 398
    },
    "hidden": true,
    "id": "-ijDDxnE5WoS",
    "outputId": "47657727-b0da-4fd9-a9ea-fdd3d9e47dc1"
   },
   "outputs": [],
   "source": [
    "# freeze bert weights and then train model_2\n",
    "training_args_freeze = TrainingArguments(\n",
    "    output_dir='./bert_freeze_model/',         \n",
    "    num_train_epochs=3,           \n",
    "    per_device_train_batch_size=20,\n",
    "    per_device_eval_batch_size=20,\n",
    "    weight_decay=0.01,\n",
    "    learning_rate=2e-4,\n",
    "    load_best_model_at_end=True,\n",
    "    evaluation_strategy=\"steps\",\n",
    ")\n",
    "\n",
    "trainer_freeze = Trainer(\n",
    "    model=bert_freeze_model,                       \n",
    "    args=training_args_freeze,\n",
    "    train_dataset=train_dataset,\n",
    "    eval_dataset=test_dataset,\n",
    "    compute_metrics=compute_metrics,\n",
    ")\n",
    "\n",
    "trainer_freeze.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "lJ3QLo1nJCg3"
   },
   "outputs": [],
   "source": [
    "trainer_freeze.save_model('./drive/MyDrive/bert_freeze_model')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "id": "bE2-PJL45WoS"
   },
   "source": [
    "### Evaluate model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true,
    "id": "DTd4hblQNDBT"
   },
   "source": [
    "We will evaluate the model on the test set with the following metrics:\n",
    "- accuracy\n",
    "- Loss\n",
    "- F1-Macro\n",
    "- F1-Micro\n",
    "- Confusion matrix\n",
    "- Macro-average precision\n",
    "- Macro-average recall\n",
    "- Micro-average precision\n",
    "- Micro-average recall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 72
    },
    "hidden": true,
    "id": "opO3itNl5WoS",
    "outputId": "ebb288aa-08ef-4cb5-e599-7ceaaff36ee9"
   },
   "outputs": [],
   "source": [
    "# you can add more cells here if you need\n",
    "y_pred_transformers_1 = [np.argmax(prediction, axis=0) for prediction in trainer.predict(test_dataset)[0]]\n",
    "y_pred_transformers_2 = [np.argmax(prediction, axis=0) for prediction in trainer_freeze.predict(test_dataset)[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 455
    },
    "hidden": true,
    "id": "vow7tQrUOZxm",
    "outputId": "be840e0c-51ec-4b75-fd59-4e190ea522dd"
   },
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, classes):\n",
    "    confusion_mat = np.zeros((3, 3), dtype=int)\n",
    "\n",
    "    for true, pred in zip(y_true, y_pred):\n",
    "        confusion_mat[true, pred] += 1\n",
    "\n",
    "    sns.heatmap(confusion_mat, annot=True, xticklabels=classes, yticklabels=classes)\n",
    "    plt.xlabel(\"predicted\")\n",
    "    plt.ylabel(\"actual\")\n",
    "    plt.show()\n",
    "\n",
    "plot_confusion_matrix(y_test, y_pred_transformers_1, distinct_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 449
    },
    "hidden": true,
    "id": "o0usemMjOdt9",
    "outputId": "51b83d3a-976a-4906-ecb4-70ccf1b8bbfd"
   },
   "outputs": [],
   "source": [
    "plot_confusion_matrix(y_test, y_pred_transformers_2, distinct_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true,
    "id": "jJLMMw4l5WoT"
   },
   "outputs": [],
   "source": [
    "def predict(x, model):\n",
    "    \"\"\"\n",
    "    predict the class code of a given query\n",
    "    :param x: the query\n",
    "    :return: the class of the query in the form of real strings.\n",
    "    \"\"\"\n",
    "    encoded_input = tokenizer(x, padding=True, truncation=True, max_length=512, return_tensors='pt')\n",
    "    input_ids = encoded_input['input_ids'].to(device)\n",
    "    attention_mask = encoded_input['attention_mask'].to(device)\n",
    "    output = model(input_ids, attention_mask)\n",
    "    _, prediction = torch.max(output[0], dim=1)\n",
    "\n",
    "    return list(label_encoder.inverse_transform(prediction.to('cpu').numpy()))[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "hidden": true,
    "id": "elIy6FXt5WoT",
    "outputId": "7836897e-332a-41a0-9ac8-14fa1d5d624b"
   },
   "outputs": [],
   "source": [
    "predict('hardware is very good.', trainer.model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 🧮 Clustering "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section encompasses the following three parts:\n",
    "1. **Document Embedding Extraction**\n",
    "2. **Dimensionality Reduction**\n",
    "2. **K-Means Clustering**\n",
    "3. **Hierarchical Clustering**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import random\n",
    "import string\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.cluster.hierarchy as shc\n",
    "import torch\n",
    "from tqdm import tqdm\n",
    "from typing import List\n",
    "\n",
    "import nltk\n",
    "from nltk import word_tokenize\n",
    "\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.metrics import (\n",
    "    accuracy_score,\n",
    "    confusion_matrix,\n",
    "    ConfusionMatrixDisplay,\n",
    "    f1_score,\n",
    "    precision_recall_fscore_support,\n",
    "    precision_score,\n",
    "    recall_score,\n",
    ")\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "from transformers import BertTokenizer, BertForSequenceClassification, TrainingArguments, Trainer, BertTokenizerFast, BertModel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dMmGLx3I5WoT"
   },
   "source": [
    "### Document Embedding Extraction\n",
    "\n",
    "Although it's possible to create document embeddings using the Bag of Words approach, this section will guide you through leveraging **Transformer-based language models** to potentially achieve better clustering results. We'll follow these steps:\n",
    "\n",
    "1. **Use Transformer Models**:\n",
    "   - Instead of traditional methods, you'll use Transformer-based models to extract embeddings for each document. These models are available through the HuggingFace library, which offers a variety of pre-trained models.\n",
    "  \n",
    "2. **Implement the `extract_embedding` Function**:\n",
    "   - Implement the `extract_embedding` function, which takes a list of documents as input and returns a list of corresponding embeddings.\n",
    "  \n",
    "3. **Embedding Calculation Methods**:\n",
    "   - There are multiple approaches to calculating the embedding for each document, including:\n",
    "     - **CLS Token Embedding**: Using the embedding of the CLS token from models like BERT.\n",
    "     - **Averaging**: Computing the average of token embeddings, which can be weighted or unweighted.\n",
    "   - Choose the method that best fits your needs.\n",
    "\n",
    "This process will generate meaningful embeddings for each document, enabling more effective clustering and analysis.\n",
    "\n",
    "---\n",
    "\n",
    "This translation captures the purpose and technical details of the original Persian text, maintaining a clear and professional tone in line with the other sections. Let me know if there's anything else you need!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1W5wy7JxseTi"
   },
   "outputs": [],
   "source": [
    "df = df.head(20000)\n",
    "label = labels[:20000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MFVgm8ufx7AV"
   },
   "outputs": [],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(device)\n",
    "tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')\n",
    "bert = BertModel.from_pretrained('bert-base-uncased').to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UoCicySm5WoU"
   },
   "outputs": [],
   "source": [
    "def extract_embedding(doc_list : List):\n",
    "    \"\"\"Extracts embedding vector for each document in doc_list\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    doc_list : List\n",
    "        A list of documents\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    list\n",
    "        A list of embedding vectors\n",
    "    \"\"\"\n",
    "    embeddings = []\n",
    "    with torch.no_grad():\n",
    "        for doc in doc_list:\n",
    "            inputs = tokenizer(doc, return_tensors='pt', truncation=True, padding=True, max_length=512).to(device)\n",
    "            h = bert(**inputs, output_hidden_states=True).hidden_states[-1][0,0,:]\n",
    "            embeddings.append(h.detach().cpu().numpy())\n",
    "\n",
    "        return np.array(embeddings)\n",
    "\n",
    "df_embedding = extract_embedding(df['text'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "12rVFKPNseTi",
    "outputId": "75d7a52f-c980-405e-8010-e0b18a7f0e5c"
   },
   "outputs": [],
   "source": [
    "with open('docs_embedding.pkl', 'rb') as f:\n",
    "      df_embedding = pickle.load(f)\n",
    "\n",
    "df_embedding.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dimentionality Reduction\n",
    "\n",
    "In this part, we will use [TSNE](https://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html) to reduce the dimensionality of the embedding vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cEzmtlIX5WoU"
   },
   "outputs": [],
   "source": [
    "def convert_to_2d_tsne(emb_vecs : List):\n",
    "    \"\"\"Converts each raw embedding vector to 2d vector \n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    emb_vecs : List\n",
    "        A list of vectors\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    list\n",
    "        A list of 2d vectors\n",
    "    \"\"\"\n",
    "    return TSNE(n_components=2).fit_transform(emb_vecs)\n",
    "\n",
    "df_2d = convert_to_2d_tsne(df_embedding) # return [[NUM, NUM], [NUM, NUM], [NUM, NUM], ...]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Z7Kvvfrc5WoU"
   },
   "outputs": [],
   "source": [
    "def plot_docs(emb_vecs_2d: List, labels : List, title):\n",
    "    \"\"\"Draws a 2d plot of input vectors\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    emb_2d_vecs : List\n",
    "        A list of 2d vectors\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    \"\"\"\n",
    "    plt.scatter(emb_vecs_2d[:, 0], emb_vecs_2d[:, 1], c=labels, alpha=0.4)\n",
    "    plt.title(title)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f0zdReIr5WoU"
   },
   "source": [
    "### K-MEANS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, we'll implement K-Means clustering to group similar documents together, which will help in improving the accuracy and relevancy of the recommender system. Steps include:\n",
    "1. **Preprocess the Data**: Prepare the document embeddings for clustering.\n",
    "2. **Implement K-Means**: Apply the K-Means algorithm to cluster the dataset.\n",
    "3. **Analyze Results**: Silhouette analysis, purity score, and plot the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uISPG0RE5WoU",
    "outputId": "d253d0ff-154b-4c49-b48b-7e4aaaab6e88",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def cluster_kmeans(emb_vecs : List, n_clusters : int):\n",
    "    \"\"\"Clusters input vectors using K-means method\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    emb_vecs : List\n",
    "        A list of vectors\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    list\n",
    "        Two lists: 1) A list containing cluster centers 2) A list containing cluster index for each input vector\n",
    "    \"\"\"\n",
    "    \n",
    "    total_cnt = len(emb_vecs)\n",
    "    rand_indices = np.random.choice(total_cnt, n_clusters, replace=False)\n",
    "    \n",
    "    cluster_centers = np.array(emb_vecs)[rand_indices]\n",
    "    cluster_labels = -1 * np.ones(total_cnt, dtype=int) \n",
    "    n_iters = 20\n",
    "    for _ in range(n_iters):\n",
    "        # calculate samples label\n",
    "        for i in range(total_cnt):\n",
    "            to_center_dists = [np.linalg.norm(emb_vecs[i] - cluster_centers[j]) for j in range(n_clusters)]\n",
    "            cluster_labels[i] = np.argmin(to_center_dists)\n",
    "        \n",
    "        # recalculate cluster centers position\n",
    "        for i in range(n_clusters):\n",
    "            cluster_centers[i] = np.mean([emb_vecs[j] for j in range(total_cnt) if cluster_labels[j] == i], axis=0)\n",
    "\n",
    "    return cluster_centers.tolist(), cluster_labels.tolist()\n",
    "\n",
    "cluster_centers, cluster_labels = [], []\n",
    "\n",
    "\n",
    "k_s = list(range(2, 7))\n",
    "for k in k_s:\n",
    "    clusters_centers, clusters_labels = cluster_kmeans(df_embedding, k)\n",
    "    cluster_centers.append(clusters_centers)\n",
    "    cluster_labels.append(clusters_labels)\n",
    "    plot_docs(df_2d, clusters_labels, f'k = {k}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "IqOEdIyd5WoV",
    "outputId": "4555bef3-b30b-4b1a-b081-748a91e92150"
   },
   "outputs": [],
   "source": [
    "# silhouette analysis \n",
    "from sklearn.metrics import silhouette_samples, silhouette_score\n",
    "\n",
    "silhouette_scores = []\n",
    "for i in range(len(k_s)):\n",
    "    silhouette_scores.append(silhouette_score(df_embedding, cluster_labels[i]))\n",
    "    \n",
    "plt.plot(k_s, silhouette_scores)\n",
    "\n",
    "plt.title('silhouette scores')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8YnbrZcd5WoV",
    "outputId": "adb7238c-af72-414c-9df0-309d114ba7d6"
   },
   "outputs": [],
   "source": [
    "# plot purity for different value of k\n",
    "purities = []\n",
    "for i in range(len(k_s)):\n",
    "    conf_mat = confusion_matrix(label, cluster_labels[i])\n",
    "    purities.append(np.sum(np.amax(conf_mat, axis=0)) / np.sum(conf_mat))\n",
    "plt.plot(k_s, purities)\n",
    "plt.title('purity')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15, 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "q7MOUXUB5WoV",
    "outputId": "d0d4a0bb-b391-4659-fa9c-c3dfd023a056"
   },
   "outputs": [],
   "source": [
    "Z = shc.linkage(df_embedding, 'ward')\n",
    "dn = shc.dendrogram(Z)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZqWlGlc_5WoV"
   },
   "outputs": [],
   "source": [
    "title_query = 'Survey on Semantic Stereo Matching / Semantic Depth Estimation',\n",
    "summaries_query = 'Survey on Semantic Stereo Matching / Semantic Depth Estimation',\n",
    "doc_ids = search(\n",
    "    'Survey on Semantic Stereo Matching / Semantic Depth Estimation',\n",
    "    'Survey on Semantic Stereo Matching / Semantic Depth Estimation',\n",
    "    10,\n",
    "    method='ltc-lnc',\n",
    "    category='all',\n",
    ")\n",
    "\n",
    "kmeans_clusters_center = cluster_centers[0]\n",
    "embeddings = df_embedding[np.array(doc_ids)]\n",
    "current_predicted_labels = []\n",
    "for i, emb in enumerate(embeddings):\n",
    "    to_center_dists = [np.linalg.norm(emb - kmeans_clusters_center[j]) for j in range(len(kmeans_clusters_center))]\n",
    "    current_predicted_labels[i] = np.argmin(to_center_dists)\n",
    "\n",
    "for paper_id, current_predicted_label in zip(doc_ids, current_predicted_labels):\n",
    "    print(f'Paper Id = {paper_id}, Predicted Cluster = {current_predicted_label}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zK7hl9Qd5WoV"
   },
   "source": [
    "### 🔍 Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This task involves implementing a function to find documents similar to a given one.\n",
    "\n",
    "#### Function: `find_similar_docs`\n",
    "\n",
    "- **Input**: Index of the target document, number of similar documents to find, and list of embedding vectors.\n",
    "- **Output**: Indices of the most similar documents in the dataset, ranked by similarity.\n",
    "- **Similarity Measure**: You can choose the similarity metric that best fits your data and objectives.\n",
    "\n",
    "#### Steps:\n",
    "\n",
    "1. **Calculate Similarity**: Identify the closest vectors to the target document's vector.\n",
    "2. **Rank & Return**: Sort the documents by similarity and return the top results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_CNYAns05WoV"
   },
   "outputs": [],
   "source": [
    "def find_similar_docs(input_doc_index : int,\n",
    "                      num_of_similar_docs: int,\n",
    "                      emb_vecs : List):\n",
    "    \"\"\"Finds similar documents to input in dataset\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    input_doc_index: int\n",
    "        Index of input document vector in emb_vecs list to search for specific paper\n",
    "\n",
    "    num_of_similar_docs:\n",
    "        Number of similar documents to return \n",
    "\n",
    "    emb_vecs : List\n",
    "        A list of vectors corresponding to documents\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    List\n",
    "        A list of similar document indexes to input document\n",
    "    \"\"\"\n",
    "\n",
    "    input_doc = emb_vecs[input_doc_index]\n",
    "    docs_similarity = [np.dot(input_doc, doc) for doc in emb_vecs]\n",
    "    return np.argsort(docs_similarity)[1:num_of_similar_docs + 1]\n"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "gpuType": "T4",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.19"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}