{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QX3MhUFoqNrM",
        "outputId": "ca3eb108-c669-4b1d-f74b-37a3d5a20823"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
            "CSV found: True\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "BASE_DIR  = '/content/drive/MyDrive/MidOcean/NLP'\n",
        "DATA_PATH = f'{BASE_DIR}/spam.csv'\n",
        "\n",
        "import os\n",
        "print(\"CSV found:\", os.path.exists(DATA_PATH))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import re, warnings\n",
        "from collections import Counter\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "import nltk\n",
        "from nltk.corpus import stopwords\n",
        "from nltk.tokenize import word_tokenize\n",
        "from nltk.stem import PorterStemmer\n",
        "\n",
        "from sklearn.model_selection import train_test_split, GridSearchCV\n",
        "from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.metrics import (accuracy_score, precision_score, recall_score,\n",
        "                             f1_score, confusion_matrix, classification_report)\n",
        "\n",
        "from imblearn.over_sampling import RandomOverSampler, SMOTE\n",
        "from imblearn.under_sampling import RandomUnderSampler\n",
        "\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "\n",
        "nltk.download(\"punkt\", quiet=True)\n",
        "nltk.download(\"punkt_tab\", quiet=True)\n",
        "nltk.download(\"stopwords\", quiet=True)\n",
        "nltk.download(\"wordnet\", quiet=True)\n",
        "\n",
        "RANDOM_STATE   = 42\n",
        "MINORITY_CLASS = \"spam\"\n",
        "FAST_MODE      = False      # True for the first pass, False for final numbers\n",
        "SCORING        = \"accuracy\"\n",
        "\n",
        "print(\"Libraries loaded.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kRNgqmyPt59a",
        "outputId": "06be40dd-4b09-48d2-dc7e-bc0cf1867829"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Libraries loaded.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df = pd.read_csv(DATA_PATH, encoding=\"latin-1\")\n",
        "df = df[[\"v1\", \"v2\"]].rename(columns={\"v1\": \"label\", \"v2\": \"text\"})\n",
        "\n",
        "print(\"Raw shape:\", df.shape)\n",
        "print(\"\\nRaw class distribution:\")\n",
        "print(df[\"label\"].value_counts())\n",
        "\n",
        "df = df.drop_duplicates().dropna().reset_index(drop=True)\n",
        "print(\"\\nAfter dropping duplicates:\", df.shape)\n",
        "\n",
        "df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 362
        },
        "id": "twKgB-Cat9r4",
        "outputId": "17336c0b-92a9-4214-9ad3-23f8a8b91519"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Raw shape: (5572, 2)\n",
            "\n",
            "Raw class distribution:\n",
            "label\n",
            "ham     4825\n",
            "spam     747\n",
            "Name: count, dtype: int64\n",
            "\n",
            "After dropping duplicates: (5169, 2)\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "  label                                               text\n",
              "0   ham  Go until jurong point, crazy.. Available only ...\n",
              "1   ham                      Ok lar... Joking wif u oni...\n",
              "2  spam  Free entry in 2 a wkly comp to win FA Cup fina...\n",
              "3   ham  U dun say so early hor... U c already then say...\n",
              "4   ham  Nah I don't think he goes to usf, he lives aro..."
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-63c08f9c-7588-4340-8aa3-62a675c248c5\" class=\"colab-df-container\">\n",
              "    <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>label</th>\n",
              "      <th>text</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>ham</td>\n",
              "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>ham</td>\n",
              "      <td>Ok lar... Joking wif u oni...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>spam</td>\n",
              "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>ham</td>\n",
              "      <td>U dun say so early hor... U c already then say...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>ham</td>\n",
              "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-63c08f9c-7588-4340-8aa3-62a675c248c5')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-63c08f9c-7588-4340-8aa3-62a675c248c5 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-63c08f9c-7588-4340-8aa3-62a675c248c5');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "df",
              "summary": "{\n  \"name\": \"df\",\n  \"rows\": 5169,\n  \"fields\": [\n    {\n      \"column\": \"label\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          \"spam\",\n          \"ham\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"text\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 5169,\n        \"samples\": [\n          \"Did u download the fring app?\",\n          \"Pass dis to all ur contacts n see wat u get! Red;i'm in luv wid u. Blue;u put a smile on my face. Purple;u r realy hot. Pink;u r so swt. Orange;i thnk i lyk u. Green;i realy wana go out wid u. Yelow;i wnt u bck. Black;i'm jealous of u. Brown;i miss you Nw plz giv me one color\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "counts = df[\"label\"].value_counts()\n",
        "print(\"Class distribution:\"); print(counts)\n",
        "print(\"\\nProportions:\"); print((counts / len(df)).round(4))\n",
        "print(f\"\\nImbalance ratio = {counts.max() / counts.min():.2f} : 1\")\n",
        "\n",
        "fig, axes = plt.subplots(1, 2, figsize=(11, 4))\n",
        "sns.countplot(x=\"label\", data=df, palette=\"Set2\", ax=axes[0])\n",
        "axes[0].set_title(\"Class distribution\"); axes[0].set_xlabel(\"\")\n",
        "axes[1].pie(counts, labels=counts.index, autopct=\"%1.1f%%\",\n",
        "            colors=sns.color_palette(\"Set2\"), startangle=90)\n",
        "axes[1].set_title(\"Class proportions\")\n",
        "plt.tight_layout(); plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 633
        },
        "id": "U4O3iyP5uCYi",
        "outputId": "7ad973d2-8d39-4b5f-d49e-60018251d4cc"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Class distribution:\n",
            "label\n",
            "ham     4516\n",
            "spam     653\n",
            "Name: count, dtype: int64\n",
            "\n",
            "Proportions:\n",
            "label\n",
            "ham     0.8737\n",
            "spam    0.1263\n",
            "Name: count, dtype: float64\n",
            "\n",
            "Imbalance ratio = 6.92 : 1\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1100x400 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+IAAAGGCAYAAAD/4DsuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXtBJREFUeJzt3Xd4VHWixvF3Jr1NQkISEgiEJhASioAaKSIgiNjBgq4oYkHBXcQVr3tZiuteXHaxoYhiwbrYdRUBASmKAelSQze0FCAF0pM59w9klqGGkMzJzHw/zzMPzDm/Oec9CWTmzWkWwzAMAQAAAAAAl7CaHQAAAAAAAG9CEQcAAAAAwIUo4gAAAAAAuBBFHAAAAAAAF6KIAwAAAADgQhRxAAAAAABciCIOAAAAAIALUcQBAAAAAHAhijgAAAAAAC5EEQdwURITE3XfffeZHaNKJkyYIIvF4jTNVfn37Nkji8WimTNnOqbdd999Cg0NrfV1n2CxWDRhwgSXrQ8AYD53ep/2ZIsXL5bFYtHixYvNjoI6giIO4Ix27typhx9+WM2aNVNgYKBsNpu6du2ql156ScXFxWbHM9V3331XZwttXc4GAKg5vE/XTdOmTXP6pTtwNr5mBwBQ98yePVu33XabAgICNGTIECUnJ6usrEw//fSTnnzySW3atElvvPGG2TFrRHp6uqzWC/ud5HfffadXX331ggpvkyZNVFxcLD8/vwtMeGHOla24uFi+vvzYBwB3503v0+5m2rRpql+//mlHIfTo0UPFxcXy9/c3JxjqHD6RAXCye/du3XnnnWrSpIl++OEHxcXFOeaNGDFCO3bs0OzZs01MWLMCAgJqdfkVFRWy2+3y9/dXYGBgra7rfMxePwDg4nnb+/Sp7Ha7ysrK6tx7WlFRkYKDg88632q11rnMMBeHpgNwMnnyZB07dkxvvfWW05v7CS1atNCf/vSns77+yJEj+vOf/6yUlBSFhobKZrOpf//+Wr9+/Wljp06dqrZt2yo4OFj16tVT586d9dFHHznmHz16VKNGjVJiYqICAgIUExOja665RmvWrDnvdvz000/q0qWLAgMD1bx5c73++utnHHfquXPl5eWaOHGiWrZsqcDAQEVFRalbt26aP3++pOPndb/66quSjp9zfeIh/fc88H/961968cUX1bx5cwUEBGjz5s1nPEf8hF27dqlfv34KCQlRfHy8nnnmGRmG4Zh/tvPKTl3mubKdmHbqnvK1a9eqf//+stlsCg0NVe/evbV8+XKnMTNnzpTFYtGyZcs0evRoRUdHKyQkRLfccotycnLO/A0AANQKT3ifPnHNlq1bt+r222+XzWZTVFSU/vSnP6mkpMRprMVi0ciRI/Xhhx+qbdu2CggI0Ny5cyVd2HvY0qVL9fDDDysqKko2m01DhgxRbm7uadmmTZvmWE98fLxGjBihvLw8pzE9e/ZUcnKyVq9erR49eig4OFh/+ctflJiYqE2bNmnJkiWO9+CePXtKOvt7+aeffqpOnTopKChI9evX1x/+8Aft37/facyJa8rs379fN998s0JDQxUdHa0///nPqqysdBo7a9YsderUSWFhYbLZbEpJSdFLL710zu8HzMEecQBOvvnmGzVr1kxXXnlltV6/a9cuffXVV7rtttvUtGlTZWVl6fXXX9dVV12lzZs3Kz4+XpI0Y8YM/fGPf9SgQYMcb7y//vqrVqxYobvuukuSNHz4cH322WcaOXKkkpKSdPjwYf3000/asmWLLr300rNm2LBhg/r27avo6GhNmDBBFRUVGj9+vGJjY8+bf8KECZo0aZIeeOABXXbZZSooKNCqVau0Zs0aXXPNNXr44Yd14MABzZ8/X++///4Zl/HOO++opKREDz30kAICAhQZGSm73X7GsZWVlbr22mt1xRVXaPLkyZo7d67Gjx+viooKPfPMM+fNe7KqZDvZpk2b1L17d9lsNo0ZM0Z+fn56/fXX1bNnTy1ZskSXX3650/jHHntM9erV0/jx47Vnzx69+OKLGjlypD7++OMLygkAqD5PeJ8+4fbbb1diYqImTZqk5cuX6+WXX1Zubq7ee+89p3E//PCDPvnkE40cOVL169d3FN4LeQ8bOXKkIiIiNGHCBKWnp+u1117Tb7/95ijI0vHPABMnTlSfPn30yCOPOMatXLlSy5Ytczq97PDhw+rfv7/uvPNO/eEPf1BsbKx69uypxx57TKGhofrf//1fSTrnZ4+ZM2dq6NCh6tKliyZNmqSsrCy99NJLWrZsmdauXauIiAjH2MrKSvXr10+XX365/vWvf2nBggWaMmWKmjdvrkceeUSSNH/+fA0ePFi9e/fWP/7xD0nSli1btGzZsnP+cgYmMQDgd/n5+YYk46abbqrya5o0aWLce++9juclJSVGZWWl05jdu3cbAQEBxjPPPOOYdtNNNxlt27Y957LDw8ONESNGVDnLCTfffLMRGBho/Pbbb45pmzdvNnx8fIxTf+ydmr99+/bGgAEDzrn8ESNGnLYcwzi+nZIMm81mZGdnn3HeO++845h27733GpKMxx57zDHNbrcbAwYMMPz9/Y2cnBzDMAxj0aJFhiRj0aJF513m2bIZhmFIMsaPH+94fvPNNxv+/v7Gzp07HdMOHDhghIWFGT169HBMe+eddwxJRp8+fQy73e6Y/vjjjxs+Pj5GXl7eGdcHAKhZnvI+PX78eEOSceONNzpNf/TRRw1Jxvr16x3TJBlWq9XYtGmT09gLfQ/r1KmTUVZW5pg+efJkQ5Lx9ddfG4ZhGNnZ2Ya/v7/Rt29fp6/PK6+8Ykgy3n77bce0q666ypBkTJ8+/bRta9u2rXHVVVedNv3U9/KysjIjJibGSE5ONoqLix3jvv32W0OSMW7cOMe0E58XTv7+GIZhdOzY0ejUqZPj+Z/+9CfDZrMZFRUVp60fdQ+HpgNwKCgokCSFhYVVexkBAQGOi59VVlbq8OHDCg0NVatWrZwOVYuIiNC+ffu0cuXKsy4rIiJCK1as0IEDB6q8/srKSs2bN08333yzGjdu7Jjepk0b9evX77yvj4iI0KZNm7R9+/Yqr/NUAwcOVHR0dJXHjxw50vH3E4fglZWVacGCBdXOcD6VlZX6/vvvdfPNN6tZs2aO6XFxcbrrrrv0008/Of49nPDQQw85HerevXt3VVZW6rfffqu1nACA//KE9+mTjRgxwun5Y489Jun4hUdPdtVVVykpKcnxvLrvYSfv0X7kkUfk6+vrWNeCBQtUVlamUaNGOV3E9cEHH5TNZjvtvPuAgAANHTq0OpstSVq1apWys7P16KOPOp07PmDAALVu3fqM5/kPHz7c6Xn37t21a9cux/OIiAgVFhY6TqdD3UYRB+Bgs9kkHT/nq7rsdrteeOEFtWzZUgEBAapfv76io6P166+/Kj8/3zHuqaeeUmhoqC677DK1bNlSI0aM0LJly5yWNXnyZG3cuFEJCQm67LLLNGHCBKc3nDPJyclRcXGxWrZsedq8Vq1anTf/M888o7y8PF1yySVKSUnRk08+qV9//bWKW39c06ZNqzzWarU6fYiQpEsuuUTS8XPAa0tOTo6KiorO+DVp06aN7Ha79u7d6zT95F9sSFK9evUk6Yzn2AEAap4nvE+f7NT36ubNm8tqtZ72/nfq+2p13sNOXVdoaKji4uIc6zrxS+VTl+nv769mzZqd9kvnhg0bXtQV0M+2Pklq3br1aesLDAw87Zf89erVc3oPfvTRR3XJJZeof//+atSoke6//37H+fSoeyjiABxsNpvi4+O1cePGai/j//7v/zR69Gj16NFDH3zwgebNm6f58+erbdu2TudJt2nTRunp6Zo1a5a6deumzz//XN26ddP48eMdY26//Xbt2rVLU6dOVXx8vP75z3+qbdu2mjNnzkVt57n06NFDO3fu1Ntvv63k5GS9+eabuvTSS/Xmm29WeRlBQUE1munkvdAnO/UCLbXNx8fnjNONky4sBwCoPZ7+Pn2297uafl+tCa7OdLb34JPFxMRo3bp1+s9//qMbb7xRixYtUv/+/XXvvfe6ICEuFEUcgJPrr79eO3fuVFpaWrVe/9lnn+nqq6/WW2+9pTvvvFN9+/ZVnz59TrviqCSFhITojjvu0DvvvKOMjAwNGDBAf//7352umBoXF6dHH31UX331lXbv3q2oqCj9/e9/P+v6o6OjFRQUdMZDy9PT06u0DZGRkRo6dKj+/e9/a+/evWrXrp3T1cbP9kGhOux2+2l7D7Zt2ybp+BXdpf/ueT71a3imQ8Krmi06OlrBwcFn/Jps3bpVVqtVCQkJVVoWAMB13P19+mSnvlfv2LFDdrvd8f53NtV5Dzt1XceOHdPBgwcd62rSpImk0z8rlJWVaffu3Y7551PV9+Gzre/EtKqu71T+/v664YYbNG3aNO3cuVMPP/yw3nvvPe3YsaNay0PtoYgDcDJmzBiFhITogQceUFZW1mnzd+7cec7bYPj4+Jy2h/TTTz897VYchw8fdnru7++vpKQkGYah8vJyVVZWOh0iJx3/TW98fLxKS0vPuf5+/frpq6++UkZGhmP6li1bNG/evLO+7my5QkND1aJFC6d1hoSESDq9GFfXK6+84vi7YRh65ZVX5Ofnp969e0s6/mbt4+OjpUuXOr1u2rRppy2rqtl8fHzUt29fff31106HAGZlZemjjz5St27dHIdAAgDqDnd/nz7ZiVtunjB16lRJUv/+/c/5uuq8h73xxhsqLy93PH/ttddUUVHhWFefPn3k7++vl19+2enr89Zbbyk/P18DBgyo0jaFhIRU6fNB586dFRMTo+nTpzt9vebMmaMtW7ZUeX0nO/V7ZrVa1a5dO0mq8vcErsPtywA4ad68uT766CPdcccdatOmjYYMGaLk5GSVlZXp559/1qeffup03+1TXX/99XrmmWc0dOhQXXnlldqwYYM+/PDD086D7tu3rxo0aKCuXbsqNjZWW7Zs0SuvvKIBAwYoLCxMeXl5atSokQYNGqT27dsrNDRUCxYs0MqVKzVlypRzbsPEiRM1d+5cde/eXY8++qgqKioc90I93/neSUlJ6tmzpzp16qTIyEitWrXKcWuWEzp16iRJ+uMf/6h+/frJx8dHd95553m+smcWGBiouXPn6t5779Xll1+uOXPmaPbs2frLX/7iOBcsPDxct912m6ZOnSqLxaLmzZvr22+/VXZ29mnLu5Bszz77rObPn69u3brp0Ucfla+vr15//XWVlpZq8uTJ1doeAEDt8oT36RN2796tG2+8Uddee63S0tL0wQcf6K677lL79u3P+9oLfQ8rKytT7969dfvttys9PV3Tpk1Tt27ddOONN0o6vpf96aef1sSJE3XttdfqxhtvdIzr0qWL/vCHP1Rpmzp16qTXXntNzz77rFq0aKGYmBj16tXrtHF+fn76xz/+oaFDh+qqq67S4MGDHbcvS0xM1OOPP16l9Z3sgQce0JEjR9SrVy81atRIv/32m6ZOnaoOHTqoTZs2F7w81DITr9gOoA7btm2b8eCDDxqJiYmGv7+/ERYWZnTt2tWYOnWqUVJS4hh3ptuiPPHEE0ZcXJwRFBRkdO3a1UhLSzOuuuoqp9t5vP7660aPHj2MqKgoIyAgwGjevLnx5JNPGvn5+YZhGEZpaanx5JNPGu3btzfCwsKMkJAQo3379sa0adOqlH/JkiVGp06dDH9/f6NZs2bG9OnTHbdLOdmp+Z999lnjsssuMyIiIoygoCCjdevWxt///nenW55UVFQYjz32mBEdHW1YLBbHMk/cTuyf//znaXnOdvuykJAQY+fOnUbfvn2N4OBgIzY21hg/fvxpt5bJyckxBg4caAQHBxv16tUzHn74YWPjxo2nLfNs2Qzj9NuXGYZhrFmzxujXr58RGhpqBAcHG1dffbXx888/O405ceuXlStXOk0/223VAAC1z53fp0+8H2/evNkYNGiQERYWZtSrV88YOXKk0628DOP4e9fZbpF2Ie9hS5YsMR566CGjXr16RmhoqHH33Xcbhw8fPm2Zr7zyitG6dWvDz8/PiI2NNR555BEjNzfXacxVV1111lu7ZWZmGgMGDDDCwsIMSY6v6dneMz/++GOjY8eORkBAgBEZGWncfffdxr59+5zGnPi8cKpTP9d89tlnRt++fY2YmBjD39/faNy4sfHwww8bBw8ePGNWmMtiGFxlBwAAAIBrTJgwQRMnTlROTo7q169fq+uaOXOmhg4dqpUrV6pz5861ui7gQnCOOAAAAAAALkQRBwAAAADAhSjiAAAAAAC4EOeIAwAAAADgQuwRBwAAAADAhSjiAAAAAAC4kK/ZAdyB3W7XgQMHFBYWJovFYnYcAABgAsMwdPToUcXHx8tqZV8GAKD6KOJVcODAASUkJJgdAwAA1AF79+5Vo0aNzI4BAHBjFPEqCAsLk3T8jddms5mcBgAAmKGgoEAJCQmOzwUAAFQXRbwKThyObrPZKOIAAHg5TlMDAFwsTnACAAAAAMCFKOIAAAAAALgQRRwAAAAAABeiiAMAAAAA4EIUcQAAAAAAXIgiDgAAAACAC1HEAQAAAABwIYo4AAAAAAAuRBEHAAAAAMCFKOIAAAAAALgQRRwAAAAAABeiiAMAAAAA4EIUcQAAAAAAXMjX7ABw9sSc98yOALidKf2HmB0BAAAAqDL2iAMAAAAA4EIUcQAAAAAAXIgiDgAAAACAC1HEAQAAAABwIYo4AAAAAAAuRBEHAAAAAMCFKOIAAAAAALgQRRwAAAAAABeiiAMAAAAA4EIUcQAAAAAAXIgiDgAAAABu4LPPPlNKSoqCgoIUFRWlPn36qLCwUPfdd59uvvlmTZw4UdHR0bLZbBo+fLjKysocr507d666deumiIgIRUVF6frrr9fOnTsd8/fs2SOLxaJPPvlE3bt3V1BQkLp06aJt27Zp5cqV6ty5s0JDQ9W/f3/l5OSYsfkehSIOAAAAAHXcwYMHNXjwYN1///3asmWLFi9erFtvvVWGYUiSFi5c6Jj+73//W1988YUmTpzoeH1hYaFGjx6tVatWaeHChbJarbrllltkt9ud1jN+/HiNHTtWa9aska+vr+666y6NGTNGL730kn788Uft2LFD48aNc+m2eyJfswMAAAAAAM7t4MGDqqio0K233qomTZpIklJSUhzz/f399fbbbys4OFht27bVM888oyeffFJ/+9vfZLVaNXDgQKflvf3224qOjtbmzZuVnJzsmP7nP/9Z/fr1kyT96U9/0uDBg7Vw4UJ17dpVkjRs2DDNnDmzlrfW87FHHAAAAADquPbt26t3795KSUnRbbfdphkzZig3N9dpfnBwsON5amqqjh07pr1790qStm/frsGDB6tZs2ay2WxKTEyUJGVkZDitp127do6/x8bGSnIu/LGxscrOzq7x7fM2FHEAAAAAqON8fHw0f/58zZkzR0lJSZo6dapatWql3bt3V+n1N9xwg44cOaIZM2ZoxYoVWrFihSQ5nUcuSX5+fo6/WyyWM0479XB2XDgOTQcAAABQ5xmGocKKUh0tL1VpZYXshvH7w65Kw1B8aZFsZaWS1UeyWn//8/dHYLAUHC6L1b33Q1osFnXt2lVdu3bVuHHj1KRJE3355ZeSpPXr16u4uFhBQUGSpOXLlys0NFQJCQk6fPiw0tPTNWPGDHXv3l2S9NNPP5m2HaCIAwAAADBRub1SmUUFOlJaqKPlpSooK9HR8pMeZaU6Wl6iYxWlsv9+YbIzGZt7RKE71p59RRaLFGyTQiKkkHBZQo//qdAIWUIiHNMVUjcL+4oVK7Rw4UL17dtXMTExWrFihXJyctSmTRv9+uuvKisr07BhwzR27Fjt2bNH48eP18iRI2W1WlWvXj1FRUXpjTfeUFxcnDIyMvQ///M/Zm+SV6OIAwAAAKh1dsOu7OJjOlCUp/2FeTpQmK/9RfnKKT4qu85esGuMYUiF+ccfktMandZ+orDXT5AltokssYlSbBNZbFG1n/EcbDabli5dqhdffFEFBQVq0qSJpkyZov79++vjjz9W79691bJlS/Xo0UOlpaUaPHiwJkyYIEmyWq2aNWuW/vjHPyo5OVmtWrXSyy+/rJ49e5q6Td7MYhjn+LUSJEkFBQUKDw9Xfn6+bDZbra7riTnv1eryAU80pf8QsyMA8AKu/DwAuLtye6V2FRzSnqOHfy/e+cosLlC5vbLW1jk294jiz7VH/GIFhR0v5LGJssQ2kWITZQmLrL31XYD77rtPeXl5+uqrr8yOgipijzgAAACAi2I3DGUcO6KteVnampepHQU5tVq6TVF8VNqzUcaejf/dgx5sO17OYxJladhCSmgtiw8VC+fHvxIAAAAAFyyzqEBb8zK1JS9T2/KzVVRRdv4XeZqiAmn3Bhm7Nxwv5/6BsiQmS806yNKsnSyBIWYnRB1FEQcAAABwXuX2Sm08ckDrD+/T1rws5ZYVmR2p7ikrkbFtlbRtlQyrjxTfQpYWHWVp3kGW8OhaW+3MmTNrbdmoHRRxAAAAAGdUabdrc95Brcz5TesP71NJZYXZkdyHvVLaly5jX7qMxbOkqIbHC3nzDlKDpo57dMM7UcQBAAAAONlZkKO0rN1acyhDhd54yHltOLxfxuH9Mn6ZffwWaS06ypLc/fhV2eF1KOIAAAAAdKS0UMuzdmt59m5lFR81O45nK8yXsX6xjPWLpZgmsrS7SpbWl8viH2h2MrgIRRwAAADwYltyMzV//xZtzs2U4Yr7ecNZ9m8yFrwnY8nHx8t4u57Hb48Gj0YRBwAAALxMpWHX6pwMfb9vi/YW5podB5JUXipjw1IZG5ZKDVvKeuk1UouOslisZidDLaCIAwAAAF6ipLJcP2Xu1A/703W4tNDsODib/dtl379dCq8vS4desiT3kCUgyOxUqEEUcQAAAMDD5ZcV64cD6Vp6cId33u/bXeUfkrHkExlp/5ElpYcslw2QJSjU7FSoARRxAAAAwENlFhXo+31btCJ7tyoMu9lxUF1lJTJWfy9j44+ydOkvS8drZPHzNzsVLkKdOeHgueeek8Vi0ahRoxzTSkpKNGLECEVFRSk0NFQDBw5UVlaW0+syMjI0YMAABQcHKyYmRk8++aQqKpzvb7h48WJdeumlCggIUIsWLbjhPQAAADzasfISfbRjpSaunq1lWTsp4Z6itFjGT1/I/vbTsm9YKsPO99Vd1YkivnLlSr3++utq166d0/THH39c33zzjT799FMtWbJEBw4c0K233uqYX1lZqQEDBqisrEw///yz3n33Xc2cOVPjxo1zjNm9e7cGDBigq6++WuvWrdOoUaP0wAMPaN68eS7bPgAAAMAVKuyVmrdvs8au/EZLDm6Xnauge6bCPBnz35X9vXEydqw1Ow2qwfQifuzYMd19992aMWOG6tWr55ien5+vt956S88//7x69eqlTp066Z133tHPP/+s5cuXS5K+//57bd68WR988IE6dOig/v37629/+5teffVVlZUdP/dl+vTpatq0qaZMmaI2bdpo5MiRGjRokF544QVTthcAAACoDWsOZWj86tn6Yvc6FVeWmx0HrnDkoOz/eUWVHz8n48AOs9PgAphexEeMGKEBAwaoT58+TtNXr16t8vJyp+mtW7dW48aNlZaWJklKS0tTSkqKYmNjHWP69eungoICbdq0yTHm1GX369fPsYwzKS0tVUFBgdMDAAAAqIt+O3pE/1q/QK9v+UmHSo6ZHQdm2L9d9lmTVPn1KzKOHDQ7DarA1Iu1zZo1S2vWrNHKlStPm5eZmSl/f39FREQ4TY+NjVVmZqZjzMkl/MT8E/PONaagoEDFxcUKCjr9NgCTJk3SxIkTq71dAAAAQG3LLS3SV3vWa0X2bg5Ax3E718q+a70sKd1l6TZIlsBgsxPhLEzbI75371796U9/0ocffqjAwECzYpzR008/rfz8fMdj7969ZkcCAAAAJEl2w9D3+7Zo3KpvtJwSjlMZdhm/Ljl+/viejWanwVmYVsRXr16t7OxsXXrppfL19ZWvr6+WLFmil19+Wb6+voqNjVVZWZny8vKcXpeVlaUGDRpIkho0aHDaVdRPPD/fGJvNdsa94ZIUEBAgm83m9AAAAADMllN8TFN+XaDPd69Vmb3S7Dioy47lyv7FC7LPf09GWYnZaXAK04p47969tWHDBq1bt87x6Ny5s+6++27H3/38/LRw4ULHa9LT05WRkaHU1FRJUmpqqjZs2KDs7GzHmPnz58tmsykpKckx5uRlnBhzYhkAAACAO1h6cLv+tvY77SjIMTsK3IixYYns74+XsTfd7Cg4iWnniIeFhSk5OdlpWkhIiKKiohzThw0bptGjRysyMlI2m02PPfaYUlNTdcUVV0iS+vbtq6SkJN1zzz2aPHmyMjMzNXbsWI0YMUIBAQGSpOHDh+uVV17RmDFjdP/99+uHH37QJ598otmzZ7t2gwEAAIBqyCst0vvbV2hjLhfhQjXlH5L903/K0rG3LN0GyuLnb3Yir2fqxdrO54UXXpDVatXAgQNVWlqqfv36adq0aY75Pj4++vbbb/XII48oNTVVISEhuvfee/XMM884xjRt2lSzZ8/W448/rpdeekmNGjXSm2++qX79+pmxSQAAAECV/ZK9R//euUpFFWVmR4HbM2SsXSBjzwZZ+90vS3wLswN5NYthGFzf4TwKCgoUHh6u/Pz8Wj9f/Ik579Xq8gFPNKX/ELMjAPACrvw8ABwrL9VHO1Zq9aEMs6O4jbG5RxS/Y63ZMdyDxSpL536ypN4ki6+f2Wm8Up3eIw4AAAB4m025BzQzfbkKyrnAFmqJYZexco6MXetlve4hWaITzE7kdUy7WBsAAACA/zIMQ99lbNTUjUso4XCNwwdk//f/ydi2yuwkXociDgAAAJispKJc07f8qK9/+1UGdwaHK1WUyf7tdNmXf2N2Eq/CoekAAACAibKKCvTa5qU6WFxgdhR4LUPGz1/JfvigLP2Gct64C1DEAQAAAJNszj2oN7b8pOLKcrOjADLSV8jIz5b1xpGyhEaYHcejcWg6AAAAYILFB7Zp6sbFlHDULZm7Zf/oWRlZv5mdxKNRxAEAAAAXsht2/XvHKv175yrZOR8cddGxXNk/fo6LuNUiijgAAADgIqWVFXpl0xItPrjN7CjAuZ24iFvaf8xO4pEo4gAAAIALFFeU66WNi7Qp96DZUYAqMmSkfS377OkyysvMDuNRKOIAAABALSuqKNOLG3/QzoIcs6MAF8xIXyn7Vy/JKC81O4rHoIgDAAAAtehYeale2LBQe44eNjsKUH17t8r+xYsyykrMTuIRKOIAAABALTlaVqIXNixUxrFcs6MAF2//Ntm/fFFGWbHZSdweRRwAAACoBfllxZqyYaH2FeaZHQWoOfu3y/75CzJKKeMXgyIOAAAA1LDc0iJN+XWBDhblmx0FqHkHd+rI0o9VXFFudhK3RREHAAAAatDhkkL969cFyio+anYUoFYcbXSJngnw1yubFqusssLsOG6JIg4AAADUkBN7wg+VHDM7ClAr8hNaa1yDBJVYpB0FOZq2eanK7ZVmx3I7FHEAAACgBpRUluvVTUt0uLTQ7ChArchr3EbjYhuq1PLfaVvyMvXGlp9UabebF8wNUcQBAACAi2Q37Jqx5SftLeTq6PBMuU2SNC42TuWW0+f9emS/3tmWJsMwXB/MTVHEAQAAgIs0a+dqbcw9aHYMoFYcSWyrcdFxqtAZWvjvVub8pm8zNrowlXujiAMAAAAX4ft9W7Tk4HazYwC14lDTFI2v30CVZ+/gDrMzNmh1Tkbth/IAFHEAAACgmlbnZOiL3WvNjgHUiuxm7TQhKqZKJVySDEkzt6Up49iRWs3lCSjiAAAAQDXsKjh0/LxYs4MAtSCzeQdNjKwvexVL+All9kpN27xUBWXFtRPMQ1DEAQAAgAuUU3xM0zYv4bZN8EgHW3TU3+pFyrBcYAv/XW5pkV7b/CP/P86BIg4AAABcgMLyMk3dtFhHy0vNjgLUuH0tL72oEn7CrqOH9MH2X2ooleehiAMAAAAX4L3ty5VVXGB2DKDG7b2kk/4vol6NLW959m7N27e5xpbnSSjiAAAAQBUtObhd6w7vMzsGUOP2tOqsSeERNb7cL3ev14Yj+2t8ue6OIg4AAABUwYHCPH26a43ZMYAat6v1ZZpsC6+VZRsy9Hb6z8otLaqV5bsrX7MDAAAAAHVdub1SM7Yu4+JTHmDpzkxNWbxBa/Yd0sGCYn1+X2/dlNJEklReaddf56zW3C37tOvIUYUH+ql3y3j934Auig8PPudy9+cX6ulvV2nu1n0qKqtQi/o2vXlnd3VOqC9JmrJog/61eIMk6cmrUzS6Z4rjtSt+y9ZjX6Tp5z/eIF8f1+4r3dHmcj0fGlqr6yiqKNfMbWkaldxLlos899xTUMQBAACA8/h01xodKMo3OwZqQGFZudrFR2roZS01aOYPTvOKyiq0dt9h/e817dUuPkq5xaV6/KvluuXt+Vrx+E1nXWZuUal6TJ2tni3i9O2DfRUdEqjthwpUL8hfkvTrgSOaMG+Nvh52jQxDuumt+bqmVUOlxEWqotKuEZ/9rNdu6+ryEp7e5gq9FBriknVtzcvSDwfS1btha5esr66jiAMAAADnsO7wPi05uN3sGKgh/dskqH+bhDPOCw/y17zh1zpNe/mWVKW+9I0yco+pcb0z7zme/MOvahQRorfu7O6Y1jQqzPH39Ow8pcRFqlfLeElSSnw9pWfnKyUuUv9avEHdmzdQl8bRF7tpF2RLUqqmhpx7L39N+3LPeiXVi1NccO0cBu9OOEccAAAAOIvc0iK9t22F2TFgovySMlksUsTve7fP5NvNe9Upob7uePcHxY3/SJ2nfKU3l6c75ifHRWp7Tr4yco/ptyPHtD2nQG0b1NPOQwV695fteubaTq7YFIeNba90eQmXjp/i8XZ6mirtdpevu65hjzgAAABwBnbj+EWmCiu4X7i3Kimv0F9mr9KdHZrJFnj2Ir7r8FG9/vNWjbqqrf6nd3ut2pujUV8ul7+PVUO6tFSb2Ag9e11nXfv6XEnS36/rrDaxEeo7fY6eu76Lvk/fp2e+Xys/q1XP33yFejRvUGvbtD65q14PCqy15Z9PxrEjmp2xUTcmtjMtQ11AEQcAAADOYO7ezdqWn212DJikvNKuO99bJMOQXh105TnH2g1DnRrV19+v6yxJ6tgoSpsy8/R62lYN6dJSkvTwla318JX/PT/6vZXbFRbgpysSY5T03OdaPuoG7csv0t0fLNKO/71dAb4+Nb5Na1O6aUZgQI0v90LN2btJKZHxamqrb3YU03BoOgAAAHCKzKJ8zc7YYHYMmOR4Cf9BGbnHNPfhfufcGy5JcbYgJcVGOE1rHRuuvbmFZxx/6FiJ/vb9Wr10S6p++S1HLaNtahkdrqtbxKm80tC2nJq+MKBFq+tICZckuwy9vS1NZZUVZkcxDUUcAAAAOMWHO1aqwuA8Vm90ooTvOFSgecOvVVTI+Q/jvjIxVumnlOdtOQVnvbjbE/9ZoT/1SFajiBBVGnZVVP7331qF3a5Ku3FxG+HEol/addNbdaSEn5BdfFSf7V5rdgzTUMQBAACAk/yctYtD0j3YsdJyrdt/WOv2H5Yk7T5yVOv2H1ZG7jGVV9p1+7s/aPXew3rv7qtUaTeUWVCkzIIilVX89x7y17w2R6/+tNnx/E892mrFb9matGC9dhwq0L/X7NSby9P1aNc2p61/fvp+bcvJd8zrnBCtrdn5mrNlr2akbZWPxaJWMTV0VXGLRWntumtmwLn36JtlycHt2u6l/9c4RxwAAAD43bHyUn22y3v30nmDVXsPqc9rcxzP//yfXyRJQzq30Lh+HfXNpgxJUqcpXzu9bsEj/dWzRZyk4xdnO1RY4pjXpXG0PhvaW2Nnr9az89epaWSonr/pct3VqbnTMorLK/SnL9P00T1Xy2q1SJIaRYTopVuu0AMf/6QAX6veHtxDQX41UNMsFv3Uroc+8q/ble+TXav1dIdrZbVYzI7iUhbDMGryuAePVFBQoPDwcOXn58tms9Xqup6Y816tLh/wRFP6DzE7AgAv4MrPAzDPe9tWaFnWTrNjoBrG5h5R/A5+iSJJsli1tF13zarjJfyEIS0vV9cGzc8/0INwaDoAAAAgac/Rw/qZEg53Z/XRovbuU8Il6as961VSUW52DJeiiAMAAMDrGYahWTtXiUNF4dasPlrQrrs+rYlD212ooLxEc/ZuMjuGS1HEAQAA4PVWZO/R7qOHzY4BVJ/VR/Pa99AXfjV//3FXWLB/qw6VHDM7hstQxAEAAODVSirL9cWedWbHAKrN8PHVnPY99LWv+9a7CsOuz73oQonu+50CAAAAasD3+7Yov6zY7BhAtRg+vprdrru+ceMSfsKaw3u95taB7v/dAgAAAKqpuKJMP+xPNzsGUC2Gj5/+076HvvOAEn7CJztXy+4FN/bynO8YAAAAcIEW7k9XcaV3Xa0ZnsHw9deX7btrno9n3X97b2Gufs7aZXaMWkcRBwAAgFcqqSjXwgPsDYf7MfwC9Hm7blrgYSX8hNkZG1Rpt5sdo1ZRxAEAAOCVFh3cpqKKMrNjABfE8AvQJyld9YOHlnBJOlJapOXZu82OUaso4gAAAPA6pZUVWrBvq9kxgAti+AdqVrtuWuLBJfyEefs2e/S54hRxAAAAeJ0lB7frWEWp2TGAKjP8g/RhSlf96CUNLqv4qFYfyjA7Rq3xkm8jAAAAcFxZZYXm79tidgygyoyAYL2XcqV+9rL2NnfvJrMj1Bov+1YCAADA2/2YuUMF5SVmxwCqxAgM0TvJqVrhhc1tX2GeNh45YHaMWuGF304AAAB4q3J7pb5nbzjchBEYqreSr9AqL25tC/Z75rUcvPhbCgAAAG+zInuP8sqKzY4BnJcRFKY3ki/XGs+/Lts5bcnL1P7CPLNj1DiKOAAAALzGT5k7zI4AnJc9OEzT216u9V5ewk+Y74F7xSniAAAA8AoHCvO0++hhs2MA52QPtum1pMu1weK5t+66UCuz9yjfw45koYgDAADAK/yUtdPsCMA52UMi9Erby7SJEu6kwrBredZus2PUKIo4AAAAPF6FvVIrsvaYHQM4K3toPb3cprO2ihJ+JsuzKeI15rXXXlO7du1ks9lks9mUmpqqOXPmOOaXlJRoxIgRioqKUmhoqAYOHKisrCynZWRkZGjAgAEKDg5WTEyMnnzySVVUVDiNWbx4sS699FIFBASoRYsWmjlzpis2DwAAAHXE+sP7dayi1OwYwBnZwyL1YptLtY094Wd1oChfe4/lmh2jxphaxBs1aqTnnntOq1ev1qpVq9SrVy/ddNNN2rTp+I3bH3/8cX3zzTf69NNPtWTJEh04cEC33nqr4/WVlZUaMGCAysrK9PPPP+vdd9/VzJkzNW7cOMeY3bt3a8CAAbr66qu1bt06jRo1Sg888IDmzZvn8u0FAACAOTgsHXVVpS1Kz7e6VFxG8Pw8aa+4xTCMOvVrl8jISP3zn//UoEGDFB0drY8++kiDBg2SJG3dulVt2rRRWlqarrjiCs2ZM0fXX3+9Dhw4oNjYWEnS9OnT9dRTTyknJ0f+/v566qmnNHv2bG3cuNGxjjvvvFN5eXmaO3dulTIVFBQoPDxc+fn5stlsNb/RJ3liznu1unzAE03pP8TsCAC8gCs/D6BmHSkp1F9W/kcGh/x6tLG5RxS/Y63ZMS5IZXh9Tbmkg/bwb7NKbH6B+sflN8tqcf8zrOvMFlRWVmrWrFkqLCxUamqqVq9erfLycvXp08cxpnXr1mrcuLHS0tIkSWlpaUpJSXGUcEnq16+fCgoKHHvV09LSnJZxYsyJZZxJaWmpCgoKnB4AAABwT8uydlHCUedUhEdrcktK+IUoKC/RlrxMs2PUCNOL+IYNGxQaGqqAgAANHz5cX375pZKSkpSZmSl/f39FREQ4jY+NjVVm5vEvfmZmplMJPzH/xLxzjSkoKFBx8ZkvgT9p0iSFh4c7HgkJCTWxqQAAAHAxu2EoLWuX2TEAJxX1YvVcy3bayznhF2xF9h6zI9QI04t4q1attG7dOq1YsUKPPPKI7r33Xm3evNnUTE8//bTy8/Mdj71795qaBwAAANWTnpelw6WFZscAHCrqNdBzzVN0wGJ2Eve07tA+lVZWnH9gHedrdgB/f3+1aNFCktSpUyetXLlSL730ku644w6VlZUpLy/Paa94VlaWGjRoIElq0KCBfvnlF6flnbiq+sljTr3SelZWlmw2m4KCgs6YKSAgQAEBATWyfQAAADDPusPsUEHdUR4Zp0nNk5TJ4ejVVmqv0NpDe3VFbFOzo1wU0/eIn8put6u0tFSdOnWSn5+fFi5c6JiXnp6ujIwMpaamSpJSU1O1YcMGZWdnO8bMnz9fNptNSUlJjjEnL+PEmBPLAAAAgOfamHvA7AiAJKk8Kl7PNmsrzzjD2VyecPV0U/eIP/300+rfv78aN26so0eP6qOPPtLixYs1b948hYeHa9iwYRo9erQiIyNls9n02GOPKTU1VVdccYUkqW/fvkpKStI999yjyZMnKzMzU2PHjtWIESMce7SHDx+uV155RWPGjNH999+vH374QZ988olmz55t5qYDAACglh0sytehEg5Lh/nK6jfS35q21mH2hNeIrXlZOlpWojD/QLOjVJupRTw7O1tDhgzRwYMHFR4ernbt2mnevHm65pprJEkvvPCCrFarBg4cqNLSUvXr10/Tpk1zvN7Hx0fffvutHnnkEaWmpiokJET33nuvnnnmGceYpk2bavbs2Xr88cf10ksvqVGjRnrzzTfVr18/l28vAAAAXGfDEfaGw3yl0Qn6W+IlOkIJrzGGDG3Ny1SXmESzo1RbnbuPeF3EfcSBuo37iANwBe4j7n6m/LpA2/Kzzz8QHqEu3ke8JKaxJja+RPlcHb3GdY1tpiGXXGF2jGoz/WJtAAAAQE0rrijXjoIcs2PAi5XENtHExi2Uz57wWrHZze8nXucu1gYAAABcrM25B2XnwE+YpLhBU41v3EL5ZgfxYLmlRcoqKjA7RrVRxAEAAOBxNnC1dJikKK6ZxjVqpqNmB/EC7rxXnCIOAAAAj2IYhjZxoTaYoDC+ucY1aqpCi9lJvMMWijgAAABQN/x27IgKykvMjgEvc6xhC41rmKgis4N4kW15WbIbdrNjVAtFHAAAAB5lc+5BsyPAyxxtdInGxTVRsdlBvExxZbl2Hz1sdoxqoYgDAADAo+w6esjsCPAiBQmtNK5Bgko4HN0UW3Ld8/B0ijgAAAA8yh433UMG95PfuLX+GttIpZRw07jreeIUcQAAAHiMnOJjOlpeanYMeIHcJkn6a2y8yinhptpz9LAq3fA8cYo4AAAAPMZuDkuHCxxJbKtx0XGqEC3cbBWGXZlueD9xijgAAAA8hrteuAnu41DTZI2v30CVdPA6Y39hntkRLpiv2QEAAACAmpJx7IjZEeDBcpq108TIaNkp4XUKRRwAAAAwiWEY2ueGH8jhHrKat9cz9aJkUMLrHHf8f08RBwAAgEc4VFKokspys2PAA2W26KC/RUTKsNDC66L9RXlmR7hgnCMOAAAAj7C3MNfsCPBA+1teSgmv43JLi1RUUWZ2jAtCEQcAAIBH2EcRRw3be0kn/T2iHiXcDbjb4ekUcQAAAHiEg0X5ZkeAB8m4pLMmhUeYHQNVtN/NfhHHOeIAAADwCEdKi8yOAA+xu3UX/TPMZnYMXID9he71iziKOAAAADxCLkUcNWBH68v1fFio2TFwgdzt1JRqHZreq1cv5eXlnTa9oKBAvXr1uthMAAAAwAWptNtVUFZidgy4uW1tKOHuKqf4mNkRLki1ivjixYtVVnb6VelKSkr0448/XnQoAAAA4ELklhXJkGF2DLixrUlX6MVQSri7OlZRqnJ7pdkxquyCDk3/9ddfHX/fvHmzMjMzHc8rKys1d+5cNWzYsObSAQAAAFXAYem4GJvaXqlXg4PMjoGLlF9WrPqB7vHLlAsq4h06dJDFYpHFYjnjIehBQUGaOnVqjYUDAAAAqoIijura0PZKvUYJ9wi5pUWeWcR3794twzDUrFkz/fLLL4qOjnbM8/f3V0xMjHx8fGo8JAAAAHAuXDEd1bEuuaveCAo0OwZqSJ4b/Ry4oCLepEkTSZLdbq+VMAAAAEB15JYWmh0BbsWiNSld9WZggNlBUIPyyorNjlBl1b592fbt27Vo0SJlZ2efVszHjRt30cEAAACAquLQdFSdRStTuumdQH+zg6CGHSsvNTtClVWriM+YMUOPPPKI6tevrwYNGshisTjmWSwWijgAAABcikPTUTUWLW/XXe8F+JkdBLXgWIWHF/Fnn31Wf//73/XUU0/VdB4AAADggh0t5x7iOA+LRcvaddeH/pRwT+Xxe8Rzc3N122231XQWAAAAoFrKuYYRzsVi1dJ23TXLv9pn5sINuFMRt1bnRbfddpu+//77ms4CAAAAVEuFUWl2BNRVFqsWt+9BCfcChW5UxKv1r7FFixb661//quXLlyslJUV+fs6Hd/zxj3+skXAAAABAVVSwRxxnYvXRgnbd9YUft1j2BiX2CrMjVFm1ivgbb7yh0NBQLVmyREuWLHGaZ7FYKOIAAABwGcMwVGlQxHEKq4++b99dX/lSwr2GYXaAqqtWEd+9e3dN5wAAAACqpYISjlMYPr6a1667/uNbrTNx4aYMN2rinCgBAAAAt1Zh5/xw/Jfh46vv2nfXbB9KOOquahXx+++//5zz33777WqFAQAAAC4UV0zHCYaPn75p311zfSxmR4EJ7IaH7xHPzc11el5eXq6NGzcqLy9PvXr1qpFgAAAAQFVwfjgkqcLqo6/bd9f3lHC4gWoV8S+//PK0aXa7XY888oiaN29+0aEAAACAquLQdEjSq+HhOmp2CJjKffaHV/M+4mdckNWq0aNH64UXXqipRQIAAADnxaHpkEQJh9ypitfoFQx27typigr3uXcbAAAA3J87XSkZQO2xu9GPgmodmj569Gin54Zh6ODBg5o9e7buvffeGgkGAAAAVEWgj5/ZEQDUCe7TxKtVxNeuXev03Gq1Kjo6WlOmTDnvFdUBAACAmhTkSxEH4E41vJpFfNGiRTWdAwAAAKiWQB8/WeReH8IB1Dwfi/vcO75aRfyEnJwcpaenS5JatWql6OjoGgkFAAAAVJXVYlGAj69KKrlWEeDNwvwCzI5QZdX6lUFhYaHuv/9+xcXFqUePHurRo4fi4+M1bNgwFRUV1XRGAAAA4JyCfPzNjgDAZKGeXsRHjx6tJUuW6JtvvlFeXp7y8vL09ddfa8mSJXriiSdqOiMAAABwTpwnDsCdini1Dk3//PPP9dlnn6lnz56Oadddd52CgoJ0++2367XXXqupfAAAAMB5UcQBhPkFmh2hyqq1R7yoqEixsbGnTY+JieHQdAAAALhcELcwA7xeqK/77BGvVhFPTU3V+PHjVVJS4phWXFysiRMnKjU1tcbCAQAAAFUR5Ms54oC38/hD01988UVde+21atSokdq3by9JWr9+vQICAvT999/XaEAAAADgfNgjDsCdrpperSKekpKi7du368MPP9TWrVslSYMHD9bdd9+toKCgGg0IAAAAnE+wH3vEAW8X6kbniFeriE+aNEmxsbF68MEHnaa//fbbysnJ0VNPPVUj4QAAAICqiAoIMTsCAJO506Hp1TpH/PXXX1fr1q1Pm962bVtNnz79okMBAAAAF6J+YKjZEQCYzJ0OTa9WEc/MzFRcXNxp06Ojo3Xw4MGLDgUAAABcCIo44N18LFbPv31ZQkKCli1bdtr0ZcuWKT4+/qJDAQAAABciKiBEVlnMjgHAJDFBYfKxVqvemqJa54g/+OCDGjVqlMrLy9WrVy9J0sKFCzVmzBg98cQTNRoQAAAAOB8fq1X1AoJ1uLTQ7CgATBAfHG52hAtSrSL+5JNP6vDhw3r00UdVVlYmSQoMDNRTTz2lp59+ukYDAgAAAFURExRGEQe8VJw3FHGLxaJ//OMf+utf/6otW7YoKChILVu2VECA+5wcDwAAAM/SINimLXmZZscAYAJ32yN+UQfRh4aGqkuXLkpOTq5WCZ80aZK6dOmisLAwxcTE6Oabb1Z6errTmJKSEo0YMUJRUVEKDQ3VwIEDlZWV5TQmIyNDAwYMUHBwsGJiYvTkk0+qoqLCaczixYt16aWXKiAgQC1atNDMmTMvOC8AAADqrrgg9/ogDqDmxIe41/9/U89mX7JkiUaMGKHly5dr/vz5Ki8vV9++fVVY+N9Dih5//HF98803+vTTT7VkyRIdOHBAt956q2N+ZWWlBgwYoLKyMv3888969913NXPmTI0bN84xZvfu3RowYICuvvpqrVu3TqNGjdIDDzygefPmuXR7AQAAUHvigm1mRwBgAl+LVTFBYWbHuCAWwzAMs0OckJOTo5iYGC1ZskQ9evRQfn6+oqOj9dFHH2nQoEGSpK1bt6pNmzZKS0vTFVdcoTlz5uj666/XgQMHFBsbK0maPn26nnrqKeXk5Mjf319PPfWUZs+erY0bNzrWdeeddyovL09z5849b66CggKFh4crPz9fNlvt/oB/Ys57tbp8wBNN6T/E7AgAvIArPw+gegrKSvTkii/MjgHAxeKDwzW+0wCzY1yQOnV99/z8fElSZGSkJGn16tUqLy9Xnz59HGNat26txo0bKy0tTZKUlpamlJQURwmXpH79+qmgoECbNm1yjDl5GSfGnFgGAAAA3J/NP1BhflyzCPA27nZ+uFSHirjdbteoUaPUtWtXJScnS5IyMzPl7++viIgIp7GxsbHKzMx0jDm5hJ+Yf2LeucYUFBSouLj4tCylpaUqKChwegAAAKDuaxZW3+wIAFzM3c4Pl+pQER8xYoQ2btyoWbNmmR1FkyZNUnh4uOORkJBgdiQAAABUQfPwaLMjAHCxuOAIsyNcsDpRxEeOHKlvv/1WixYtUqNGjRzTGzRooLKyMuXl5TmNz8rKUoMGDRxjTr2K+onn5xtjs9kUFBR0Wp6nn35a+fn5jsfevXsvehsBAABQ+1rYKOKAt0kIqWd2hAtmahE3DEMjR47Ul19+qR9++EFNmzZ1mt+pUyf5+flp4cKFjmnp6enKyMhQamqqJCk1NVUbNmxQdna2Y8z8+fNls9mUlJTkGHPyMk6MObGMUwUEBMhmszk9AAAAUPc1CY2Un9XH7BgAXCTCP0jRQaFmx7hgphbxESNG6IMPPtBHH32ksLAwZWZmKjMz03Hednh4uIYNG6bRo0dr0aJFWr16tYYOHarU1FRdccUVkqS+ffsqKSlJ99xzj9avX6958+Zp7NixGjFihOPe5sOHD9euXbs0ZswYbd26VdOmTdMnn3yixx9/3LRtBwAAQM3ztfooMTTK7BgAXKRleIzZEarF1CL+2muvKT8/Xz179lRcXJzj8fHHHzvGvPDCC7r++us1cOBA9ejRQw0aNNAXX/z3thQ+Pj769ttv5ePjo9TUVP3hD3/QkCFD9MwzzzjGNG3aVLNnz9b8+fPVvn17TZkyRW+++ab69evn0u0FAABA7WvBeeKA12hpc88i7mvmyqtyC/PAwEC9+uqrevXVV886pkmTJvruu+/OuZyePXtq7dq1F5wRAAAA7oXzxAHv0dJNf/FWJy7WBgAAANSU5rb6sshidgwAtSzUN0BxbngPcYkiDgAAAA8T5Ouvhm54X2EAF6Z1RKwsFvf8pRtFHAAAAB6Hw9MBz5dUL87sCNVGEQcAAIDHaRXRwOwIAGoZRRwAAACoQ5Lrxcmf+4kDHisuyKZ6AcFmx6g2ijgAAAA8jr+Pr5LrxZsdA0AtaePGe8MlijgAAAA81KX1E8yOAKCWdIhqZHaEi0IRBwAAgEdKiWwoPw5PBzxOhH+QWobHmB3jolDEAQAA4JECff2UxEXbAI/TObqJrG5627ITKOIAAADwWJfWb2x2BAA17LLoRLMjXDSKOAAAADxWu6iG8rXwkRfwFLFBNjUJizQ7xkXjpxIAAAA8VrCvv1pHxJodA0ANuSy6idkRagRFHAAAAB6Nw9MBz3FZTKLZEWoERRwAAAAerUNUI7e/sBMAKTE0UjFBYWbHqBEUcQAAAHi0EL8AdYzinuKAu+viIXvDJYo4AAAAvMDV8ZeYHQHARbDIoi4ecn64RBEHAACAF2gZHqNGIRFmxwBQTW0iYhXuH2R2jBpDEQcAAIBXYK844L56N2xtdoQaRREHAACAV7gsOlEhvv5mxwBwgeKDw5UcGW92jBpFEQcAAIBX8PfxVdcGzc2OAeAC9fGwveESRRwAAABe5Kq4lrKIW5kB7sLmF6jLPehq6SdQxAEAAOA16geGql1UQ7NjAKiiq+Mvka/Vx+wYNY4iDgAAAK9ydRwXbQPcgb/VR1fFtTQ7Rq2giAMAAMCrtKnXQHFBNrNjADiPK2ObKcQvwOwYtYIiDgAAAK/TNyHJ7AgAzsEii0depO0EijgAAAC8zhUxiYoNCjM7BoCz6BDVSNEe/H+UIg4AAACvY7VYdX3jFLNjADiLvo3amB2hVlHEAQAA4JU6RzdRfHC42TEAnKJjVIKa2eqbHaNWUcQBAADglawWC3vFgTrGx2LVrU07mB2j1lHEAQAA4LUurZ+gxNBIs2MA+F3PuJaK8eBzw0+giAMAAMBrWSwW3dq0o9kxAEgK9vXXgMbJZsdwCYo4AAAAvFqriFilRMabHQPwegMaJ3vsfcNPRREHAACA1xvYtKOsspgdA/Ba0YGh6hnX0uwYLkMRBwAAgNeLCw5X1wbNzY4BeK1bm3aQr9XH7Bgu42t2AAAAAKAuuDmxndYd3quj5aVmR3EZe6Vdq9/5XDu+X6aiI3kKrl9Prfr3UMchN8tiOX6EwBs97j7jay9/ZLDaD77+vOtY98F/9MsbHyt50LW68o/3OKanvfKBts1ZKt/AAF328J1q2berY96uRSu0bd6Puva5P1/kFsIdtLBF69L6jc2O4VIUcQAAAEBSqF+gbm/WSW+l/2x2FJdZ/9E32vz1Al39l+Gql9hIOem7tGTSG/IPCVLyoGslSX/48lWn1+xdsV5L/jFDTa+67LzLz96yU1v+84MimzuXrN+WrdGOBT/ruin/o/x9mVry3BtKuKydAiPCVHasSCtnfKIBLzxdcxuKOssiaVAz77tgIoemAwAAAL+7LCbRqy7clrVxmxK7dlLj1I4Ki4tWs56Xq2GXFGVv2eUYExwV4fTY89NqxXdMki0+5pzLLi8q0aK/TVP3MQ8oICzEaV7ub/sV16GNols3U4s+V8o/JEgFB7MlSctf+7fa3NxHobH1a36DUedcEdNUTcO873tNEQcAAABOcneLyxTo4x0HjsYmX6L9azYpb+9BSdLhHb8pa0O6Ei5vf8bxRUfylZG2Tq0HXHXeZf/0wkwlpHZQo86n344qqkUTHUrfrdKjhcpJ362K0jKFN2qgzF/TdXj7HiUP7HdxGwa3YPML1G3NOpkdwxTe8RMGAAAAqKJ6AcG6NbGjPtq50uwota7D3TeorLBYn/zhSVmsVhl2u7o8eJvT+don2zZ3qfyDA5XYo8s5l7tjYZoObdutW9742xnnJ1zWTi2u6aovH/qrfPz91PMvw+UbGKAfp7ytnn8Zrs1fLdCmL75XYHiouj/5gCKbNrrobUXdc1eLLgrx8zc7hiko4gAAAMApesS10C85e7SjIMfsKLVq56IV2jF/mXqNG6HIxIY6tOM3pU39QCFR9XRJ/x6njU//bolaXNNVvgFnL0/Hsg4r7eX3dN3zT59zXOf7B6rz/QMdz1e/87kadk6W1ddHa9//SoNmPqeMn9dq8d9f061v/v3iNhR1Tqf6jdWxfoLZMUzDoekAAADAKSwWi4a0vFx+Hn47pRXTPlKHu29Qi96pimzeWJf0666U267V2g//c9rYg+u3Kj/joFpf3/Ocyzy0bbeKcwv0xQP/qxlX36MZV9+jg+u2aOPn8zTj6ntkr7Sf9pq83w5o+/fL1GXYbTq4drPi2rdWUIRNza6+XIe27VFZUXFNbTLqgFDfAA1u3tnsGKZijzgAAABwBrHBNg1onKyv9qw3O0qtqSgtk8XqvG/O4mOV7MZpY9NnL1b9Vk0V1aLJOZcZ36mtBs18zmnakufeUHjjOHW46wZZfZzXZxiGfvzXW0od+Qf5BQfKbjdkr6iUJMefxhnKO9zX3S27KMw/0OwYpmKPOAAAAHAWfRu1UUJIPbNj1JomV3bU2ve/UkbaWh09mKPdS1dqw8dzlNjdeW9lWWGRdi3+5ax7w78d9X/a+Pn3kiT/4CBFNktwevgGBijQFqbIZqcfirz120UKjAhTk66XSpIa/H4BuaxN27Xh0zmql9jwtKuuw31dEdPU6+4ZfibsEQcAAADOwsdi1X2trtBz675Xub3S7Dg17spR92rVm5/pp+ffUXFugYLr11ObG3vp0vtudRq3c+FyGYahFr2vPONyCg5kqST/6AWvv+hIvta+/7VumjbBMS0mqbna3XGd5j71LwVF2NTzL8MveLmom6ICQnSnlx+SfoLFMIzTjzuBk4KCAoWHhys/P182m61W1/XEnPdqdfmAJ5rSf4jZEQB4AVd+HkDdk5a1SzO3LTc7BuC2LLLoiXa91TL83Pef9xYcmg4AAACcR2psM3Vv0MLsGIDbujYhiRJ+Eoo4AAAAUAV3NO+kJqGRZscA3E5yvTjd2KSd2THqFIo4AAAAUAV+Vh893Ka7QnwDzI4CuI2YoDANa91VVovF7Ch1CkUcAAAAqKKowBANa50qiygVwPkE+vjp0aQeCvb1NztKnUMRBwAAAC5A23rxGtA42ewYQJ1mkXR/q1TFBYebHaVOoogDAAAAF+j6xslKrhdndgygzrqhSTu1j2pkdow6iyIOAAAAXCCLxaL7W12pqIAQs6MAdc6l9RM4auQ8KOIAAABANYT4BWhk26s4/xU4SaOQCN13SarZMeo8ijgAAABQTfEhEXqsbU8FWH3NjgKYLsQ3QI8k9VCAD/8fzociDgAAAFyEZrb6ejipm3wsfLSG9wqw+urRpB6qHxhqdhS3wE8LAAAA4CK1rRevoZdcwW3N4JX8rD56tG0PtQiPNjuK26CIAwAAADWgS0yiBjfvbHYMwKV8LVYNb9NdrSMamB3FrZhaxJcuXaobbrhB8fHxslgs+uqrr5zmG4ahcePGKS4uTkFBQerTp4+2b9/uNObIkSO6++67ZbPZFBERoWHDhunYsWNOY3799Vd1795dgYGBSkhI0OTJk2t70wAAAOCFropvqRsap5gdA3AJq8WiB1t3VXJkvNlR3I6pRbywsFDt27fXq6++esb5kydP1ssvv6zp06drxYoVCgkJUb9+/VRSUuIYc/fdd2vTpk2aP3++vv32Wy1dulQPPfSQY35BQYH69u2rJk2aaPXq1frnP/+pCRMm6I033qj17QMAAID3ub5JinrFX2J2DKBWWWTR/ZekqkP9BLOjuCVTL2fXv39/9e/f/4zzDMPQiy++qLFjx+qmm26SJL333nuKjY3VV199pTvvvFNbtmzR3LlztXLlSnXufPwwoKlTp+q6667Tv/71L8XHx+vDDz9UWVmZ3n77bfn7+6tt27Zat26dnn/+eafCDgAAANSU25t10rHyMv2Ss8fsKECNs0gacsnl6hKTaHYUt1VnzxHfvXu3MjMz1adPH8e08PBwXX755UpLS5MkpaWlKSIiwlHCJalPnz6yWq1asWKFY0yPHj3k7//f+zv269dP6enpys3NddHWAAAAwJtYLBbd1+oKda7f2OwoQI0b3LyLroxtZnYMt1Zni3hmZqYkKTY21ml6bGysY15mZqZiYmKc5vv6+ioyMtJpzJmWcfI6TlVaWqqCggKnBwAAAHAhfCxWDWvdVd0aNDc7ClBjBjXtqKviW5odw+3V2SJupkmTJik8PNzxSEjgvAcAAABcOKvFontaXq5rGrYxOwpwUSyy6I5mnXRNI/4t14Q6W8QbNDh++fusrCyn6VlZWY55DRo0UHZ2ttP8iooKHTlyxGnMmZZx8jpO9fTTTys/P9/x2Lt378VvEAAAALzWoGYddWOTdmbHAKrFz+qj4W26qVfDVmZH8Rh1tog3bdpUDRo00MKFCx3TCgoKtGLFCqWmpkqSUlNTlZeXp9WrVzvG/PDDD7Lb7br88ssdY5YuXary8nLHmPnz56tVq1aqV6/eGdcdEBAgm83m9AAAAAAuxoDGybq7xWWyymJ2FKDKwvwC9ERKb66OXsNMLeLHjh3TunXrtG7dOknHL9C2bt06ZWRkyGKxaNSoUXr22Wf1n//8Rxs2bNCQIUMUHx+vm2++WZLUpk0bXXvttXrwwQf1yy+/aNmyZRo5cqTuvPNOxccfv5fdXXfdJX9/fw0bNkybNm3Sxx9/rJdeekmjR482aasBAADgrXrEtdDwpO7yt/qYHQU4r9igMD3Vvp+a2uqbHcXjmHr7slWrVunqq692PD9Rju+9917NnDlTY8aMUWFhoR566CHl5eWpW7dumjt3rgIDAx2v+fDDDzVy5Ej17t1bVqtVAwcO1Msvv+yYHx4eru+//14jRoxQp06dVL9+fY0bN45blwEAAMAU7aMaaXRKb72yaYmOVZSaHQc4o+a2aD2a1EOhfgFmR/FIFsMwDLND1HUFBQUKDw9Xfn5+rR+m/sSc92p1+YAnmtJ/iNkRAHgBV34egHfIKi7QK5uWKLv4qNlRACed6jfW0Fap8uPIjVpTZ88RBwAAADxZbJBNf+lwrTpENTI7CuBwTcM2erB1V0p4LaOIAwAAACYJ8vXTI0k9NKhpR1ktXMQN5vG1WHVXiy4a1KyjLPxbrHWmniMOAAAAQLqmURs1DYvSjK3LlFdWbHYceJmogBA91KabEsOizI7iNdgjDgAAANQBLcJj9L8d+6tVeKzZUeBF2kc10thL+1PCXYwiDgAAANQRNv9AjUrppf4JbbnbOGqVj8WqQU076tGkHgr29Tc7jtfh0HQAAACgDrFaLLo5sb2a2+rrnfQ0FVaUmR0JHiY2KEzDWnVVk7BIs6N4LfaIAwAAAHVQSmRD/W/H/rokPMbsKPAg3Ro019iO/SnhJmOPOAAAAFBHRQWGaHRKb/2UuVNf7FmroopysyPBTYX4BmhIy8vUoX6C2VEgijgAAABQp1ksFnWPa6F2UQ01a8cqrTm81+xIcDNXxCRqYNOOsvkHmR0Fv6OIAwAAAG4g3D9IDyd117rD+/TvHSu5zRnOKz44XIObd9YlEVyJv66hiAMAAABupENUI7UKj9WXe9Zp6cHtMswOhDonwOqrAU2S1Se+tXysXBasLqKIAwAAAG4myNdPd7XoosuiE/XB9hU6WFxgdiTUER2jEnR780sVGRBidhScA0UcAAAAcFMtwqM19tL++n7fFs3bt0UllVzMzVtFB4bqzuadlRwZb3YUVAFFHAAAAHBjvlYfXdc4WVfFtdTcfZu16MA2ldsrzY4FF/Gz+qhfoza6NqGt/Kw+ZsdBFVHEAQAAAA8Q4heggU07qk/D1pqdsVE/Ze5UpWE3OxZqib/VRz3iWqpvozYK52robociDgAAAHiQcP8g3dWii/o2aqNvfvtVK7J/k8El3TyGv9VHV8Vdor6N2sjmH2h2HFQTRRwAAADwQPUDQzW01ZXq1yhJX//2q9Yd3md2JFyEAKuvropvqWsaUsA9AUUcAAAA8GDxIRF6JKmH9hw9rG8zNmjjkQPsH3cjAT6+6hl3ia5p2FphFHCPQREHgDom+7UxZkcA3E7MI5PNjgDUeYlhURrZtqeyigr0w4F0pWXtVqm9wuxYOItgXz/1iDu+BzzUL8DsOKhhFHEAAADAi8QG2zS4RRfdlNheyzJ3atGBbTpcWmh2LPyupS1G3eKaq1P9xlwF3YNRxAEAAAAvFOzrr2satVHvhq21OfegfszcoV+P7Jfd4MB1VwvzC9AVMc3UrUFzNQi2mR0HLkARBwAAALyY1WJRcmS8kiPjlVdapGVZO7Uscxd7yWuZRVKbiAbq1qCFOkQ1ko/VanYkuBBFHAAAAIAkKSIgWAMap+i6hGTtOXZYaw7t1bpDe5VdcszsaB6jXkCwUmOaqmuD5qofGGp2HJiEIg4AAADAicViUdOw+moaVl8Dm3bU/sI8rTmUobWH9ml/UZ7Z8dxOXHC4OkQ1UoeoRkoMizI7DuoAijgAAACAc2oYEqGGIRG6oUk7ZRcf1dpDe7X28F7tOXqYW6GdgY/Fqua2+kqOjFeHqEaKDeK8bzijiAMAAAAm6Nmzpzp06KAXX3zR7CgXJCYoTP0SktQvIUm5pUXanHtQOwtytKPgkLKKC8yOZ5qogBC1rRentpHxah0eq0BfP7MjoQ6jiAMAAAColnoBweraoLm6NmguSTpWXqqdBTnaWXBIOwty9NuxIyq3V5qcsuYF+fipSVikEkOj1CQsSomhkYoMDDE7FtwIRRwAAABAjQj1C1D7qEZqH9VIklRhr1TGsVxHOd9flKfDJYWqNOwmJ606f6uPEkIjlRgaqcSwKDUJi1RMYJgsFovZ0eDGKOIAAACASex2u8aMGaM333xT/v7+Gj58uCZMmCBJev755/XOO+9o165dioyM1A033KDJkycrNPT4lbZnzpypUaNG6YMPPtATTzyhvXv36rrrrtN7772nTz/9VOPHj1d+fr7uuecevfDCC/Lx8XH59vlafdTMVl/NbPV1ze/TKg27jpQUKafkqLKLjyq75Khyio8pp/iockqOqcKEkh7qG6DIwGBFBoT8/jj+9wbBNsUF22S1cGsx1CyKOAAAAGCSd999V6NHj9aKFSuUlpam++67T127dtU111wjq9Wql19+WU2bNtWuXbv06KOPasyYMZo2bZrj9UVFRXr55Zc1a9YsHT16VLfeeqtuueUWRURE6LvvvtOuXbs0cOBAde3aVXfccYeJW/pfPharooNCFR0UqqR6cU7z7IahvNIiZZccVX5ZsYoqylRYXnb8z4oyFVeUqdReobLKSpXZK1Rmr1RZZYWk46Xfz+ojP6v19z9/f1h8Tprno2BfP0UFOhdufx9qEVyLf3EAAACASdq1a6fx48dLklq2bKlXXnlFCxcu1DXXXKNRo0Y5xiUmJurZZ5/V8OHDnYp4eXm5XnvtNTVvfvwc7UGDBun9999XVlaWQkNDlZSUpKuvvlqLFi2qM0X8XKwWiyIDQzjfGh6PIg4AAACYpF27dk7P4+LilJ2dLUlasGCBJk2apK1bt6qgoEAVFRUqKSlRUVGRgoODJUnBwcGOEi5JsbGxSkxMdBy+fmLaiWUCqBs42QEAAAAwiZ+f8y2uLBaL7Ha79uzZo+uvv17t2rXT559/rtWrV+vVV1+VJJWVlZ3z9WdbJoC6gz3iAAAAQB2zevVq2e12TZkyRVbr8X1nn3zyicmpANQU9ogDAAAAdUyLFi1UXl6uqVOnateuXXr//fc1ffp0s2MBqCEUcQAAAKCOad++vZ5//nn94x//UHJysj788ENNmjTJ7FgAaojFMAzD7BB1XUFBgcLDw5Wfny+bzVar63piznu1unzAE03pP8TsCDUq+7UxZkcA3E7MI5NrfR2u/DwAAPBs7BEHAAAAAMCFKOIAAAAAALgQRRwAAAAAABeiiAMAAAAA4EIUcQAAAAAAXIgiDgAAAACAC1HEAQAAAABwIYo4AAAAAAAuRBEHAAAAAMCFKOIAAAAAALgQRRwAAAAAABeiiAMAAAAA4EIUcQAAAAAAXIgiDgAAAACAC1HEAQAAAABwIYo4AAAAAAAuRBEHAAAAAMCFKOIAAAAAALgQRRwAAAAAABeiiAMAAAAA4EIUcQAAAAAAXMirivirr76qxMREBQYG6vLLL9cvv/xidiQAAAAAgJfxmiL+8ccfa/To0Ro/frzWrFmj9u3bq1+/fsrOzjY7GgAAAADAi3hNEX/++ef14IMPaujQoUpKStL06dMVHByst99+2+xoAAAAAAAv4mt2AFcoKyvT6tWr9fTTTzumWa1W9enTR2lpaaeNLy0tVWlpqeN5fn6+JKmgoKDWs5YWFdf6OgBP44r/m650tLj0/IMAOAl0wc+BEz9rDMOo9XUBADybVxTxQ4cOqbKyUrGxsU7TY2NjtXXr1tPGT5o0SRMnTjxtekJCQq1lBFB9r2q42REAmO2Jl122qqNHjyo8PNxl6wMAeB6vKOIX6umnn9bo0aMdz+12u44cOaKoqChZLBYTk8EsBQUFSkhI0N69e2Wz2cyOA8AE/ByAYRg6evSo4uPjzY4CAHBzXlHE69evLx8fH2VlZTlNz8rKUoMGDU4bHxAQoICAAKdpERERtRkRbsJms/EBHPBy/BzwbuwJBwDUBK+4WJu/v786deqkhQsXOqbZ7XYtXLhQqampJiYDAAAAAHgbr9gjLkmjR4/Wvffeq86dO+uyyy7Tiy++qMLCQg0dOtTsaAAAAAAAL+I1RfyOO+5QTk6Oxo0bp8zMTHXo0EFz58497QJuwJkEBARo/Pjxp52yAMB78HMAAADUFIvBPTgAAAAAAHAZrzhHHAAAAACAuoIiDgAAAACAC1HEAQAAAABwIYo4vE7Pnj01atQos2MAAAAA8FIUcQAAAAAAXIgiDgAAAACAC1HE4ZXsdrvGjBmjyMhINWjQQBMmTHDMe/7555WSkqKQkBAlJCTo0Ucf1bFjxxzzZ86cqYiICH377bdq1aqVgoODNWjQIBUVFendd99VYmKi6tWrpz/+8Y+qrKw0YesAnOqzzz5TSkqKgoKCFBUVpT59+qiwsFD33Xefbr75Zk2cOFHR0dGy2WwaPny4ysrKHK+dO3euunXrpoiICEVFRen666/Xzp07HfP37Nkji8WiTz75RN27d1dQUJC6dOmibdu2aeXKlercubNCQ0PVv39/5eTkmLH5AACgjqGIwyu9++67CgkJ0YoVKzR58mQ988wzmj9/viTJarXq5Zdf1qZNm/Tuu+/qhx9+0JgxY5xeX1RUpJdfflmzZs3S3LlztXjxYt1yyy367rvv9N133+n999/X66+/rs8++8yMzQNwkoMHD2rw4MG6//77tWXLFi1evFi33nqrDMOQJC1cuNAx/d///re++OILTZw40fH6wsJCjR49WqtWrdLChQtltVp1yy23yG63O61n/PjxGjt2rNasWSNfX1/dddddGjNmjF566SX9+OOP2rFjh8aNG+fSbQcAAHWTxTjxSQTwEj179lRlZaV+/PFHx7TLLrtMvXr10nPPPXfa+M8++0zDhw/XoUOHJB3fIz506FDt2LFDzZs3lyQNHz5c77//vrKyshQaGipJuvbaa5WYmKjp06e7YKsAnM2aNWvUqVMn7dmzR02aNHGad9999+mbb77R3r17FRwcLEmaPn26nnzySeXn58tqPf331YcOHVJ0dLQ2bNig5ORk7dmzR02bNtWbb76pYcOGSZJmzZqlwYMHa+HCherVq5ck6bnnntPMmTO1devWWt5iAABQ17FHHF6pXbt2Ts/j4uKUnZ0tSVqwYIF69+6thg0bKiwsTPfcc48OHz6soqIix/jg4GBHCZek2NhYJSYmOkr4iWknlgnAPO3bt1fv3r2VkpKi2267TTNmzFBubq7T/BMlXJJSU1N17Ngx7d27V5K0fft2DR48WM2aNZPNZlNiYqIkKSMjw2k9J/9ciY2NlSSlpKQ4TeNnAgAAkCji8FJ+fn5Ozy0Wi+x2u/bs2aPrr79e7dq10+eff67Vq1fr1VdflSSnc0bP9PqzLROAuXx8fDR//nzNmTNHSUlJmjp1qlq1aqXdu3dX6fU33HCDjhw5ohkzZmjFihVasWKFJOefCZLzzwWLxXLGafxMAAAAkuRrdgCgLlm9erXsdrumTJniOCT1k08+MTkVgItlsVjUtWtXde3aVePGjVOTJk305ZdfSpLWr1+v4uJiBQUFSZKWL1+u0NBQJSQk6PDhw0pPT9eMGTPUvXt3SdJPP/1k2nYAAADPQBEHTtKiRQuVl5dr6tSpuuGGG7Rs2TLO8Qbc3IoVK7Rw4UL17dtXMTExWrFihXJyctSmTRv9+uuvKisr07BhwzR27Fjt2bNH48eP18iRI2W1WlWvXj1FRUXpjTfeUFxcnDIyMvQ///M/Zm8SAABwcxyaDpykffv2ev755/WPf/xDycnJ+vDDDzVp0iSzYwG4CDabTUuXLtV1112nSy65RGPHjtWUKVPUv39/SVLv3r3VsmVL9ejRQ3fccYduvPFGxy0NrVarZs2apdWrVys5OVmPP/64/vnPf5q4NQAAwBNw1XQAgNe67777lJeXp6+++srsKAAAwIuwRxwAAAAAABeiiAMAAAAA4EIcmg4AAAAAgAuxRxwAAAAAABeiiAMAAAAA4EIUcQAAAAAAXIgiDgAAAACAC1HEAQAAAABwIYo4AAAAAAAuRBEHAAAAAMCFKOIAAAAAALgQRRwAAAAAABf6f44k7WsobvrNAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "stemmer    = PorterStemmer()\n",
        "stop_words = set(stopwords.words(\"english\"))\n",
        "\n",
        "def preprocess_text(text):\n",
        "    text = text.lower()\n",
        "    text = re.sub(r\"http\\S+|www\\.\\S+\", \"\", text)\n",
        "    text = re.sub(r\"<.*?>\", \"\", text)\n",
        "    text = re.sub(r\"[^a-zA-Z\\s]\", \"\", text)\n",
        "    tokens = word_tokenize(text)\n",
        "    tokens = [w for w in tokens if w not in stop_words]\n",
        "    tokens = [stemmer.stem(w) for w in tokens]\n",
        "    return \" \".join(tokens)\n",
        "\n",
        "df[\"clean_text\"] = df[\"text\"].apply(preprocess_text)\n",
        "\n",
        "before = len(df)\n",
        "df = df[df[\"clean_text\"].str.strip() != \"\"].reset_index(drop=True)\n",
        "print(f\"Dropped {before - len(df)} rows emptied by preprocessing.\")\n",
        "\n",
        "for i in range(3):\n",
        "    print(f\"\\nRAW  : {df['text'][i][:75]}\")\n",
        "    print(f\"CLEAN: {df['clean_text'][i][:75]}\")\n",
        "\n",
        "X = df[\"clean_text\"]\n",
        "y = df[\"label\"]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "taf9C4WPuJBQ",
        "outputId": "8de97252-da3d-4e52-81ac-f02b1b8dbc75"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dropped 6 rows emptied by preprocessing.\n",
            "\n",
            "RAW  : Go until jurong point, crazy.. Available only in bugis n great world la e b\n",
            "CLEAN: go jurong point crazi avail bugi n great world la e buffet cine got amor wa\n",
            "\n",
            "RAW  : Ok lar... Joking wif u oni...\n",
            "CLEAN: ok lar joke wif u oni\n",
            "\n",
            "RAW  : Free entry in 2 a wkly comp to win FA Cup final tkts 21st May 2005. Text FA\n",
            "CLEAN: free entri wkli comp win fa cup final tkt st may text fa receiv entri quest\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 70 / 10 / 20 via two successive stratified splits.\n",
        "# First peel off 20% test, then take 12.5% of the remainder as validation\n",
        "# (0.125 x 0.80 = 0.10 of the original).\n",
        "X_temp, X_test, y_temp, y_test = train_test_split(\n",
        "    X, y, test_size=0.20, random_state=RANDOM_STATE, stratify=y)\n",
        "\n",
        "X_train, X_val, y_train, y_val = train_test_split(\n",
        "    X_temp, y_temp, test_size=0.125, random_state=RANDOM_STATE, stratify=y_temp)\n",
        "\n",
        "for name, yy in [(\"Train\", y_train), (\"Val\", y_val), (\"Test\", y_test)]:\n",
        "    c = Counter(yy)\n",
        "    print(f\"{name:<6}: {dict(c)}  ({len(yy)} rows, {len(yy)/len(y)*100:.1f}%, \"\n",
        "          f\"ratio {c['ham']/c['spam']:.2f}:1)\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "87J16UQYuLsc",
        "outputId": "717b12d4-ee83-45a5-d945-2d2bf6b68d5a"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train : {'ham': 3156, 'spam': 457}  (3613 rows, 70.0%, ratio 6.91:1)\n",
            "Val   : {'spam': 65, 'ham': 452}  (517 rows, 10.0%, ratio 6.95:1)\n",
            "Test  : {'spam': 131, 'ham': 902}  (1033 rows, 20.0%, ratio 6.89:1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def evaluate_model(model_name, y_true, y_pred, verbose=True):\n",
        "    rep = classification_report(y_true, y_pred, output_dict=True, zero_division=0)\n",
        "    metrics = {\n",
        "        \"Model\": model_name,\n",
        "        \"Accuracy\": accuracy_score(y_true, y_pred),\n",
        "        \"Precision (weighted)\": precision_score(y_true, y_pred, average=\"weighted\", zero_division=0),\n",
        "        \"Recall (weighted)\": recall_score(y_true, y_pred, average=\"weighted\", zero_division=0),\n",
        "        \"F1 (weighted)\": f1_score(y_true, y_pred, average=\"weighted\", zero_division=0),\n",
        "        \"F1 (macro)\": f1_score(y_true, y_pred, average=\"macro\", zero_division=0),\n",
        "        f\"Recall ({MINORITY_CLASS})\": rep[MINORITY_CLASS][\"recall\"],\n",
        "        f\"F1 ({MINORITY_CLASS})\": rep[MINORITY_CLASS][\"f1-score\"],\n",
        "    }\n",
        "    if verbose:\n",
        "        print(f\"\\n{'='*60}\\n  {model_name}\\n{'='*60}\")\n",
        "        for k, v in metrics.items():\n",
        "            if k != \"Model\": print(f\"  {k:<24}: {v:.4f}\")\n",
        "        print(\"\\n\", classification_report(y_true, y_pred, zero_division=0))\n",
        "        print(\"Confusion matrix:\\n\", confusion_matrix(y_true, y_pred))\n",
        "    return metrics"
      ],
      "metadata": {
        "id": "b_4xz_FxuTJx"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "PARAM_GRIDS = {\n",
        "    \"RandomForest\": {\n",
        "        \"n_estimators\": [100, 200] if FAST_MODE else [100, 200, 300],\n",
        "        \"max_depth\":    [None, 20]  if FAST_MODE else [None, 10, 20, 30]},\n",
        "    \"LogisticRegression\": {\n",
        "        \"C\": [1, 10] if FAST_MODE else [0.1, 1, 10],\n",
        "        \"solver\": [\"liblinear\"]},\n",
        "    \"SVC\": {\n",
        "        \"C\": [1, 10],\n",
        "        \"kernel\": [\"linear\"] if FAST_MODE else [\"linear\", \"rbf\"]},\n",
        "}\n",
        "\n",
        "ESTIMATORS = {\n",
        "    \"RandomForest\":       RandomForestClassifier(random_state=RANDOM_STATE),\n",
        "    \"LogisticRegression\": LogisticRegression(max_iter=1000, random_state=RANDOM_STATE),\n",
        "    \"SVC\":                SVC(random_state=RANDOM_STATE),\n",
        "}\n",
        "\n",
        "def train_with_grid_search(name, X_tr, y_tr, X_te, y_te, label=None, verbose=True):\n",
        "    grid = GridSearchCV(ESTIMATORS[name], PARAM_GRIDS[name],\n",
        "                        cv=5, scoring=SCORING, n_jobs=-1)\n",
        "    grid.fit(X_tr, y_tr)\n",
        "    y_pred = grid.best_estimator_.predict(X_te)\n",
        "    m = evaluate_model(label or name, y_te, y_pred, verbose=verbose)\n",
        "    m[\"Best params\"] = grid.best_params_\n",
        "    if verbose: print(\"\\nBest hyperparameters:\", grid.best_params_)\n",
        "    return m, grid.best_estimator_"
      ],
      "metadata": {
        "id": "dfaL7eDnwBt5"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "VECTORIZERS = {\n",
        "    \"TF-IDF\":          TfidfVectorizer(max_features=5000),\n",
        "    \"CountVectorizer\": CountVectorizer(max_features=5000),\n",
        "}\n",
        "\n",
        "stage_a, vectorized = [], {}\n",
        "for vec_name, vec in VECTORIZERS.items():\n",
        "    X_tr_vec  = vec.fit_transform(X_train)\n",
        "    X_val_vec = vec.transform(X_val)\n",
        "    X_te_vec  = vec.transform(X_test)\n",
        "    vectorized[vec_name] = (X_tr_vec, X_val_vec, X_te_vec)\n",
        "    print(f\"\\n>>> {vec_name}: {X_tr_vec.shape[1]} features\")\n",
        "    m, _ = train_with_grid_search(\"RandomForest\", X_tr_vec, y_train,\n",
        "                                  X_val_vec, y_val, label=f\"RF + {vec_name}\")\n",
        "    stage_a.append(m)\n",
        "\n",
        "stage_a_df = pd.DataFrame(stage_a).set_index(\"Model\")\n",
        "print(\"\\n\\n--- STAGE A (selected on VALIDATION) ---\")\n",
        "print(stage_a_df[[\"Accuracy\", \"F1 (macro)\", f\"Recall ({MINORITY_CLASS})\"]].round(4))\n",
        "\n",
        "best_vec_name = stage_a_df[\"F1 (macro)\"].idxmax().replace(\"RF + \", \"\")\n",
        "X_train_vec, X_val_vec, X_test_vec = vectorized[best_vec_name]\n",
        "print(f\"\\n==> Winning representation: {best_vec_name}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tCDY2W-gwMq_",
        "outputId": "34335689-b738-4662-8282-c11f97597dac"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            ">>> TF-IDF: 5000 features\n",
            "\n",
            "============================================================\n",
            "  RF + TF-IDF\n",
            "============================================================\n",
            "  Accuracy                : 0.9652\n",
            "  Precision (weighted)    : 0.9657\n",
            "  Recall (weighted)       : 0.9652\n",
            "  F1 (weighted)           : 0.9630\n",
            "  F1 (macro)              : 0.9113\n",
            "  Recall (spam)           : 0.7385\n",
            "  F1 (spam)               : 0.8421\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.96      1.00      0.98       452\n",
            "        spam       0.98      0.74      0.84        65\n",
            "\n",
            "    accuracy                           0.97       517\n",
            "   macro avg       0.97      0.87      0.91       517\n",
            "weighted avg       0.97      0.97      0.96       517\n",
            "\n",
            "Confusion matrix:\n",
            " [[451   1]\n",
            " [ 17  48]]\n",
            "\n",
            "Best hyperparameters: {'max_depth': None, 'n_estimators': 100}\n",
            "\n",
            ">>> CountVectorizer: 5000 features\n",
            "\n",
            "============================================================\n",
            "  RF + CountVectorizer\n",
            "============================================================\n",
            "  Accuracy                : 0.9691\n",
            "  Precision (weighted)    : 0.9701\n",
            "  Recall (weighted)       : 0.9691\n",
            "  F1 (weighted)           : 0.9671\n",
            "  F1 (macro)              : 0.9211\n",
            "  Recall (spam)           : 0.7538\n",
            "  F1 (spam)               : 0.8596\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.97      1.00      0.98       452\n",
            "        spam       1.00      0.75      0.86        65\n",
            "\n",
            "    accuracy                           0.97       517\n",
            "   macro avg       0.98      0.88      0.92       517\n",
            "weighted avg       0.97      0.97      0.97       517\n",
            "\n",
            "Confusion matrix:\n",
            " [[452   0]\n",
            " [ 16  49]]\n",
            "\n",
            "Best hyperparameters: {'max_depth': None, 'n_estimators': 100}\n",
            "\n",
            "\n",
            "--- STAGE A (selected on VALIDATION) ---\n",
            "                      Accuracy  F1 (macro)  Recall (spam)\n",
            "Model                                                    \n",
            "RF + TF-IDF             0.9652      0.9113         0.7385\n",
            "RF + CountVectorizer    0.9691      0.9211         0.7538\n",
            "\n",
            "==> Winning representation: CountVectorizer\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "stage_b = []\n",
        "for name in [\"RandomForest\", \"LogisticRegression\", \"SVC\"]:\n",
        "    m, _ = train_with_grid_search(name, X_train_vec, y_train, X_val_vec, y_val)\n",
        "    stage_b.append(m)\n",
        "\n",
        "stage_b_df = pd.DataFrame(stage_b).set_index(\"Model\")\n",
        "print(\"\\n\\n--- STAGE B (selected on VALIDATION) ---\")\n",
        "print(stage_b_df[[\"Accuracy\", \"F1 (macro)\", f\"Recall ({MINORITY_CLASS})\"]].round(4))\n",
        "\n",
        "best_model_name = stage_b_df[\"F1 (macro)\"].idxmax()\n",
        "print(f\"\\n==> Winning classifier: {best_model_name}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "--OWJXszzTNT",
        "outputId": "f0d122bf-7dab-42ed-9a02-1e0f6fb53cdd"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "============================================================\n",
            "  RandomForest\n",
            "============================================================\n",
            "  Accuracy                : 0.9691\n",
            "  Precision (weighted)    : 0.9701\n",
            "  Recall (weighted)       : 0.9691\n",
            "  F1 (weighted)           : 0.9671\n",
            "  F1 (macro)              : 0.9211\n",
            "  Recall (spam)           : 0.7538\n",
            "  F1 (spam)               : 0.8596\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.97      1.00      0.98       452\n",
            "        spam       1.00      0.75      0.86        65\n",
            "\n",
            "    accuracy                           0.97       517\n",
            "   macro avg       0.98      0.88      0.92       517\n",
            "weighted avg       0.97      0.97      0.97       517\n",
            "\n",
            "Confusion matrix:\n",
            " [[452   0]\n",
            " [ 16  49]]\n",
            "\n",
            "Best hyperparameters: {'max_depth': None, 'n_estimators': 100}\n",
            "\n",
            "============================================================\n",
            "  LogisticRegression\n",
            "============================================================\n",
            "  Accuracy                : 0.9729\n",
            "  Precision (weighted)    : 0.9727\n",
            "  Recall (weighted)       : 0.9729\n",
            "  F1 (weighted)           : 0.9719\n",
            "  F1 (macro)              : 0.9340\n",
            "  Recall (spam)           : 0.8154\n",
            "  F1 (spam)               : 0.8833\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.97      1.00      0.98       452\n",
            "        spam       0.96      0.82      0.88        65\n",
            "\n",
            "    accuracy                           0.97       517\n",
            "   macro avg       0.97      0.91      0.93       517\n",
            "weighted avg       0.97      0.97      0.97       517\n",
            "\n",
            "Confusion matrix:\n",
            " [[450   2]\n",
            " [ 12  53]]\n",
            "\n",
            "Best hyperparameters: {'C': 10, 'solver': 'liblinear'}\n",
            "\n",
            "============================================================\n",
            "  SVC\n",
            "============================================================\n",
            "  Accuracy                : 0.9749\n",
            "  Precision (weighted)    : 0.9750\n",
            "  Recall (weighted)       : 0.9749\n",
            "  F1 (weighted)           : 0.9738\n",
            "  F1 (macro)              : 0.9383\n",
            "  Recall (spam)           : 0.8154\n",
            "  F1 (spam)               : 0.8908\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.97      1.00      0.99       452\n",
            "        spam       0.98      0.82      0.89        65\n",
            "\n",
            "    accuracy                           0.97       517\n",
            "   macro avg       0.98      0.91      0.94       517\n",
            "weighted avg       0.98      0.97      0.97       517\n",
            "\n",
            "Confusion matrix:\n",
            " [[451   1]\n",
            " [ 12  53]]\n",
            "\n",
            "Best hyperparameters: {'C': 1, 'kernel': 'linear'}\n",
            "\n",
            "\n",
            "--- STAGE B (selected on VALIDATION) ---\n",
            "                    Accuracy  F1 (macro)  Recall (spam)\n",
            "Model                                                  \n",
            "RandomForest          0.9691      0.9211         0.7538\n",
            "LogisticRegression    0.9729      0.9340         0.8154\n",
            "SVC                   0.9749      0.9383         0.8154\n",
            "\n",
            "==> Winning classifier: SVC\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "SAMPLERS = {\n",
        "    \"Baseline (none)\":    None,\n",
        "    \"RandomOverSampler\":  RandomOverSampler(random_state=RANDOM_STATE),\n",
        "    \"RandomUnderSampler\": RandomUnderSampler(random_state=RANDOM_STATE),\n",
        "    \"SMOTE\":              SMOTE(random_state=RANDOM_STATE),\n",
        "}\n",
        "\n",
        "stage_c, fitted_best = [], {}\n",
        "for strategy, sampler in SAMPLERS.items():\n",
        "    if sampler is None:\n",
        "        X_res, y_res = X_train_vec, y_train\n",
        "    else:\n",
        "        X_res, y_res = sampler.fit_resample(X_train_vec, y_train)\n",
        "    print(f\"\\n>>> {strategy}: {Counter(y_res)}\")\n",
        "    m, est = train_with_grid_search(best_model_name, X_res, y_res,\n",
        "                                    X_test_vec, y_test, label=strategy)\n",
        "    stage_c.append(m)\n",
        "    fitted_best[strategy] = est"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xhs9PnM8z1nI",
        "outputId": "2d0ace48-fb0b-4068-ecfd-a596e6b56b59"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            ">>> Baseline (none): Counter({'ham': 3156, 'spam': 457})\n",
            "\n",
            "============================================================\n",
            "  Baseline (none)\n",
            "============================================================\n",
            "  Accuracy                : 0.9787\n",
            "  Precision (weighted)    : 0.9785\n",
            "  Recall (weighted)       : 0.9787\n",
            "  F1 (weighted)           : 0.9782\n",
            "  F1 (macro)              : 0.9496\n",
            "  Recall (spam)           : 0.8626\n",
            "  F1 (spam)               : 0.9113\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.98      1.00      0.99       902\n",
            "        spam       0.97      0.86      0.91       131\n",
            "\n",
            "    accuracy                           0.98      1033\n",
            "   macro avg       0.97      0.93      0.95      1033\n",
            "weighted avg       0.98      0.98      0.98      1033\n",
            "\n",
            "Confusion matrix:\n",
            " [[898   4]\n",
            " [ 18 113]]\n",
            "\n",
            "Best hyperparameters: {'C': 1, 'kernel': 'linear'}\n",
            "\n",
            ">>> RandomOverSampler: Counter({'ham': 3156, 'spam': 3156})\n",
            "\n",
            "============================================================\n",
            "  RandomOverSampler\n",
            "============================================================\n",
            "  Accuracy                : 0.9816\n",
            "  Precision (weighted)    : 0.9820\n",
            "  Recall (weighted)       : 0.9816\n",
            "  F1 (weighted)           : 0.9810\n",
            "  F1 (macro)              : 0.9557\n",
            "  Recall (spam)           : 0.8550\n",
            "  F1 (spam)               : 0.9218\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.98      1.00      0.99       902\n",
            "        spam       1.00      0.85      0.92       131\n",
            "\n",
            "    accuracy                           0.98      1033\n",
            "   macro avg       0.99      0.93      0.96      1033\n",
            "weighted avg       0.98      0.98      0.98      1033\n",
            "\n",
            "Confusion matrix:\n",
            " [[902   0]\n",
            " [ 19 112]]\n",
            "\n",
            "Best hyperparameters: {'C': 10, 'kernel': 'rbf'}\n",
            "\n",
            ">>> RandomUnderSampler: Counter({'ham': 457, 'spam': 457})\n",
            "\n",
            "============================================================\n",
            "  RandomUnderSampler\n",
            "============================================================\n",
            "  Accuracy                : 0.9419\n",
            "  Precision (weighted)    : 0.9535\n",
            "  Recall (weighted)       : 0.9419\n",
            "  F1 (weighted)           : 0.9452\n",
            "  F1 (macro)              : 0.8843\n",
            "  Recall (spam)           : 0.9313\n",
            "  F1 (spam)               : 0.8026\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.99      0.94      0.97       902\n",
            "        spam       0.71      0.93      0.80       131\n",
            "\n",
            "    accuracy                           0.94      1033\n",
            "   macro avg       0.85      0.94      0.88      1033\n",
            "weighted avg       0.95      0.94      0.95      1033\n",
            "\n",
            "Confusion matrix:\n",
            " [[851  51]\n",
            " [  9 122]]\n",
            "\n",
            "Best hyperparameters: {'C': 10, 'kernel': 'rbf'}\n",
            "\n",
            ">>> SMOTE: Counter({'ham': 3156, 'spam': 3156})\n",
            "\n",
            "============================================================\n",
            "  SMOTE\n",
            "============================================================\n",
            "  Accuracy                : 0.8635\n",
            "  Precision (weighted)    : 0.9099\n",
            "  Recall (weighted)       : 0.8635\n",
            "  F1 (weighted)           : 0.8781\n",
            "  F1 (macro)              : 0.7623\n",
            "  Recall (spam)           : 0.8321\n",
            "  F1 (spam)               : 0.6072\n",
            "\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "         ham       0.97      0.87      0.92       902\n",
            "        spam       0.48      0.83      0.61       131\n",
            "\n",
            "    accuracy                           0.86      1033\n",
            "   macro avg       0.73      0.85      0.76      1033\n",
            "weighted avg       0.91      0.86      0.88      1033\n",
            "\n",
            "Confusion matrix:\n",
            " [[783 119]\n",
            " [ 22 109]]\n",
            "\n",
            "Best hyperparameters: {'C': 10, 'kernel': 'linear'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "results = pd.DataFrame(stage_c).set_index(\"Model\")\n",
        "display_cols = [\"Accuracy\", \"Recall (weighted)\", \"F1 (weighted)\", \"F1 (macro)\",\n",
        "                f\"Recall ({MINORITY_CLASS})\", f\"F1 ({MINORITY_CLASS})\"]\n",
        "\n",
        "print(\"=\"*70)\n",
        "print(f\"  FINAL COMPARISON - {best_model_name} + {best_vec_name}\")\n",
        "print(\"=\"*70)\n",
        "print(results[display_cols].round(4).to_string())\n",
        "\n",
        "print(\"\\nBest hyperparameters per strategy:\")\n",
        "for name, params in results[\"Best params\"].items():\n",
        "    print(f\"  {name:<22}: {params}\")\n",
        "\n",
        "results[display_cols].round(4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 466
        },
        "id": "SN5xLbOb00tf",
        "outputId": "f6961bcb-01a3-4860-f21b-c07ccaada027"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "======================================================================\n",
            "  FINAL COMPARISON - SVC + CountVectorizer\n",
            "======================================================================\n",
            "                    Accuracy  Recall (weighted)  F1 (weighted)  F1 (macro)  Recall (spam)  F1 (spam)\n",
            "Model                                                                                               \n",
            "Baseline (none)       0.9787             0.9787         0.9782      0.9496         0.8626     0.9113\n",
            "RandomOverSampler     0.9816             0.9816         0.9810      0.9557         0.8550     0.9218\n",
            "RandomUnderSampler    0.9419             0.9419         0.9452      0.8843         0.9313     0.8026\n",
            "SMOTE                 0.8635             0.8635         0.8781      0.7623         0.8321     0.6072\n",
            "\n",
            "Best hyperparameters per strategy:\n",
            "  Baseline (none)       : {'C': 1, 'kernel': 'linear'}\n",
            "  RandomOverSampler     : {'C': 10, 'kernel': 'rbf'}\n",
            "  RandomUnderSampler    : {'C': 10, 'kernel': 'rbf'}\n",
            "  SMOTE                 : {'C': 10, 'kernel': 'linear'}\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                    Accuracy  Recall (weighted)  F1 (weighted)  F1 (macro)  \\\n",
              "Model                                                                        \n",
              "Baseline (none)       0.9787             0.9787         0.9782      0.9496   \n",
              "RandomOverSampler     0.9816             0.9816         0.9810      0.9557   \n",
              "RandomUnderSampler    0.9419             0.9419         0.9452      0.8843   \n",
              "SMOTE                 0.8635             0.8635         0.8781      0.7623   \n",
              "\n",
              "                    Recall (spam)  F1 (spam)  \n",
              "Model                                         \n",
              "Baseline (none)            0.8626     0.9113  \n",
              "RandomOverSampler          0.8550     0.9218  \n",
              "RandomUnderSampler         0.9313     0.8026  \n",
              "SMOTE                      0.8321     0.6072  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-2893fc77-e299-4e76-a807-c6122e298a49\" class=\"colab-df-container\">\n",
              "    <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>Accuracy</th>\n",
              "      <th>Recall (weighted)</th>\n",
              "      <th>F1 (weighted)</th>\n",
              "      <th>F1 (macro)</th>\n",
              "      <th>Recall (spam)</th>\n",
              "      <th>F1 (spam)</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Model</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>Baseline (none)</th>\n",
              "      <td>0.9787</td>\n",
              "      <td>0.9787</td>\n",
              "      <td>0.9782</td>\n",
              "      <td>0.9496</td>\n",
              "      <td>0.8626</td>\n",
              "      <td>0.9113</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>RandomOverSampler</th>\n",
              "      <td>0.9816</td>\n",
              "      <td>0.9816</td>\n",
              "      <td>0.9810</td>\n",
              "      <td>0.9557</td>\n",
              "      <td>0.8550</td>\n",
              "      <td>0.9218</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>RandomUnderSampler</th>\n",
              "      <td>0.9419</td>\n",
              "      <td>0.9419</td>\n",
              "      <td>0.9452</td>\n",
              "      <td>0.8843</td>\n",
              "      <td>0.9313</td>\n",
              "      <td>0.8026</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>SMOTE</th>\n",
              "      <td>0.8635</td>\n",
              "      <td>0.8635</td>\n",
              "      <td>0.8781</td>\n",
              "      <td>0.7623</td>\n",
              "      <td>0.8321</td>\n",
              "      <td>0.6072</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-2893fc77-e299-4e76-a807-c6122e298a49')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-2893fc77-e299-4e76-a807-c6122e298a49 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-2893fc77-e299-4e76-a807-c6122e298a49');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "summary": "{\n  \"name\": \"results[display_cols]\",\n  \"rows\": 4,\n  \"fields\": [\n    {\n      \"column\": \"Model\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 4,\n        \"samples\": [\n          \"RandomOverSampler\",\n          \"SMOTE\",\n          \"Baseline (none)\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Accuracy\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.05500299234284136,\n        \"min\": 0.8635,\n        \"max\": 0.9816,\n        \"num_unique_values\": 4,\n        \"samples\": [\n          0.9816,\n          0.8635,\n          0.9787\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Recall (weighted)\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.05500299234284136,\n        \"min\": 0.8635,\n        \"max\": 0.9816,\n        \"num_unique_values\": 4,\n        \"samples\": [\n          0.9816,\n          0.8635,\n          0.9787\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"F1 (weighted)\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.04786205003270684,\n        \"min\": 0.8781,\n        \"max\": 0.981,\n        \"num_unique_values\": 4,\n        \"samples\": [\n          0.981,\n          0.8781,\n          0.9782\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"F1 (macro)\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.08979982832203338,\n        \"min\": 0.7623,\n        \"max\": 0.9557,\n        \"num_unique_values\": 4,\n        \"samples\": [\n          0.9557,\n          0.7623,\n          0.9496\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Recall (spam)\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.04271459547586361,\n        \"min\": 0.8321,\n        \"max\": 0.9313,\n        \"num_unique_values\": 4,\n        \"samples\": [\n          0.855,\n          0.8321,\n          0.8626\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"F1 (spam)\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0.1459924969533252,\n        \"min\": 0.6072,\n        \"max\": 0.9218,\n        \"num_unique_values\": 4,\n        \"samples\": [\n          0.9218,\n          0.6072,\n          0.9113\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_cols = [\"Accuracy\", \"F1 (macro)\", f\"Recall ({MINORITY_CLASS})\"]\n",
        "ax = results[plot_cols].plot(kind=\"bar\", figsize=(11, 5), width=0.75,\n",
        "                             colormap=\"Set2\", edgecolor=\"black\", linewidth=0.5)\n",
        "ax.set_title(f\"Effect of resampling - {best_model_name} + {best_vec_name}\")\n",
        "ax.set_ylabel(\"Score\"); ax.set_xlabel(\"\"); ax.set_ylim(0, 1.05)\n",
        "ax.legend(loc=\"lower right\")\n",
        "plt.xticks(rotation=15, ha=\"right\"); plt.grid(axis=\"y\", alpha=0.3)\n",
        "plt.tight_layout(); plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 507
        },
        "id": "qqF91LLG0-St",
        "outputId": "a312a222-a403-45ac-d898-742a36f32b66"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1100x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ax = results[plot_cols].plot(kind=\"bar\", figsize=(11, 5), width=0.75,\n",
        "                             colormap=\"Set2\", edgecolor=\"black\", linewidth=0.5)\n",
        "ax.set_title(\"Effect of resampling (zoomed) - SVC + CountVectorizer\")\n",
        "ax.set_ylabel(\"Score\"); ax.set_xlabel(\"\")\n",
        "ax.set_ylim(0.70, 1.0)          # the only change\n",
        "ax.legend(loc=\"lower left\")\n",
        "plt.xticks(rotation=15, ha=\"right\"); plt.grid(axis=\"y\", alpha=0.3)\n",
        "plt.tight_layout(); plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 507
        },
        "id": "_sBTVfba14Wd",
        "outputId": "81c6d637-2a21-4bd8-9df2-7321cea38b29"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1100x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "labels = sorted(y.unique())\n",
        "fig, axes = plt.subplots(1, 4, figsize=(18, 4))\n",
        "for ax_i, (strategy, est) in zip(axes, fitted_best.items()):\n",
        "    cm = confusion_matrix(y_test, est.predict(X_test_vec), labels=labels)\n",
        "    sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\", cbar=False, ax=ax_i,\n",
        "                xticklabels=labels, yticklabels=labels)\n",
        "    ax_i.set_title(strategy, fontsize=10)\n",
        "    ax_i.set_xlabel(\"Predicted\"); ax_i.set_ylabel(\"Actual\")\n",
        "plt.tight_layout(); plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 407
        },
        "id": "7I9P5DQS0_L1",
        "outputId": "552940dc-e7be-4097-95cd-39fbd79ed58e"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1800x400 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "out_path = f\"{BASE_DIR}/results_comparison.csv\"\n",
        "results[display_cols].round(4).to_csv(out_path)\n",
        "print(\"Saved ->\", out_path)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F34b6C3w1BiE",
        "outputId": "583744ed-edd5-4d5d-efa8-82b481b38cdd"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saved -> /content/drive/MyDrive/MidOcean/NLP/results_comparison.csv\n"
          ]
        }
      ]
    }
  ]
}