BaseLineWithGridSearch_H2C.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "BaseLineWithGridSearch.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "afMJ4aqRBvQ0",
        "6Mb30c58Byq0",
        "dj_wNk4ibwqm",
        "R4W2-_aXCAXX",
        "d5xu5C8l92m1"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBz3rNazY1nz"
      },
      "source": [
        "# Install and Import Required Libraries"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "afMJ4aqRBvQ0"
      },
      "source": [
        "## Install"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0SMG5tHCzkOA",
        "outputId": "1742e4b0-30ad-49da-beb9-59762bea1b88",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "!pip install hazm\n",
        "!pip install stanfordnlp\n",
        "!pip install -U nltk\n",
        "!pip install pandas\n",
        "!pip install sklearn\n",
        "!pip install numpy"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: hazm in /usr/local/lib/python3.6/dist-packages (0.7.0)\n",
            "Processing /root/.cache/pip/wheels/d1/ab/40/3bceea46922767e42986aef7606a600538ca80de6062dc266c/nltk-3.3-cp36-none-any.whl\n",
            "Requirement already satisfied: libwapiti>=0.2.1; platform_system != \"Windows\" in /usr/local/lib/python3.6/dist-packages (from hazm) (0.2.1)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from nltk==3.3->hazm) (1.12.0)\n",
            "Installing collected packages: nltk\n",
            "  Found existing installation: nltk 3.5\n",
            "    Uninstalling nltk-3.5:\n",
            "      Successfully uninstalled nltk-3.5\n",
            "Successfully installed nltk-3.3\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "nltk"
                ]
              }
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: stanfordnlp in /usr/local/lib/python3.6/dist-packages (0.2.0)\n",
            "Requirement already satisfied: protobuf in /usr/local/lib/python3.6/dist-packages (from stanfordnlp) (3.10.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from stanfordnlp) (4.41.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from stanfordnlp) (1.18.4)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.6/dist-packages (from stanfordnlp) (2.23.0)\n",
            "Requirement already satisfied: torch>=1.0.0 in /usr/local/lib/python3.6/dist-packages (from stanfordnlp) (1.5.0+cu101)\n",
            "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.6/dist-packages (from protobuf->stanfordnlp) (1.12.0)\n",
            "Requirement already satisfied: setuptools in /usr/local/lib/python3.6/dist-packages (from protobuf->stanfordnlp) (46.3.0)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests->stanfordnlp) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests->stanfordnlp) (2.9)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests->stanfordnlp) (2020.4.5.1)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests->stanfordnlp) (1.24.3)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch>=1.0.0->stanfordnlp) (0.16.0)\n",
            "Processing /root/.cache/pip/wheels/ae/8c/3f/b1fe0ba04555b08b57ab52ab7f86023639a526d8bc8d384306/nltk-3.5-cp36-none-any.whl\n",
            "Requirement already satisfied, skipping upgrade: tqdm in /usr/local/lib/python3.6/dist-packages (from nltk) (4.41.1)\n",
            "Requirement already satisfied, skipping upgrade: click in /usr/local/lib/python3.6/dist-packages (from nltk) (7.1.2)\n",
            "Requirement already satisfied, skipping upgrade: joblib in /usr/local/lib/python3.6/dist-packages (from nltk) (0.14.1)\n",
            "Requirement already satisfied, skipping upgrade: regex in /usr/local/lib/python3.6/dist-packages (from nltk) (2019.12.20)\n",
            "\u001b[31mERROR: hazm 0.7.0 has requirement nltk==3.3, but you'll have nltk 3.5 which is incompatible.\u001b[0m\n",
            "Installing collected packages: nltk\n",
            "  Found existing installation: nltk 3.3\n",
            "    Uninstalling nltk-3.3:\n",
            "      Successfully uninstalled nltk-3.3\n",
            "Successfully installed nltk-3.5\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.colab-display-data+json": {
              "pip_warning": {
                "packages": [
                  "nltk"
                ]
              }
            }
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (1.0.3)\n",
            "Requirement already satisfied: python-dateutil>=2.6.1 in /usr/local/lib/python3.6/dist-packages (from pandas) (2.8.1)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas) (2018.9)\n",
            "Requirement already satisfied: numpy>=1.13.3 in /usr/local/lib/python3.6/dist-packages (from pandas) (1.18.4)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.6/dist-packages (from python-dateutil>=2.6.1->pandas) (1.12.0)\n",
            "Requirement already satisfied: sklearn in /usr/local/lib/python3.6/dist-packages (0.0)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.6/dist-packages (from sklearn) (0.22.2.post1)\n",
            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.6/dist-packages (from scikit-learn->sklearn) (0.14.1)\n",
            "Requirement already satisfied: numpy>=1.11.0 in /usr/local/lib/python3.6/dist-packages (from scikit-learn->sklearn) (1.18.4)\n",
            "Requirement already satisfied: scipy>=0.17.0 in /usr/local/lib/python3.6/dist-packages (from scikit-learn->sklearn) (1.4.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (1.18.4)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6Mb30c58Byq0"
      },
      "source": [
        "## Import"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OLQ0-YGbBoFm"
      },
      "source": [
        "import pandas as pd\n",
        "from sklearn.model_selection import KFold\n",
        "\n",
        "from sklearn.linear_model import LinearRegression\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "from sklearn.svm import LinearSVC\n",
        "from sklearn.svm import SVC\n",
        "\n",
        "import seaborn as sns\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.metrics import accuracy_score\n",
        "from sklearn.metrics import f1_score\n",
        "from sklearn import metrics\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from sklearn.utils import shuffle\n",
        "import stanfordnlp\n",
        "import numpy as np\n",
        "\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.feature_selection import SelectKBest\n",
        "\n",
        "import os.path\n",
        "import joblib"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dj_wNk4ibwqm"
      },
      "source": [
        "# Import my class from google drive"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RDqlb6kRb6aO",
        "outputId": "3f11ea17-61ef-41a8-f5f9-5986ff95247d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "from pydrive.auth import GoogleAuth\n",
        "from pydrive.drive import GoogleDrive\n",
        "from google.colab import auth\n",
        "from oauth2client.client import GoogleCredentials\n",
        "\n",
        "auth.authenticate_user()\n",
        "gauth = GoogleAuth()\n",
        "gauth.credentials = GoogleCredentials.get_application_default()\n",
        "drive = GoogleDrive(gauth)\n",
        "\n",
        "FeatureExtractor = drive.CreateFile({'id':'1IwEfIW-lYHvGSSr6TwMsGX3xX1Z829cP'})\n",
        "FeatureExtractor.GetContentFile('psfeatureextractor.py')\n",
        "from psfeatureextractor import PSFeatureExtractor as FeatureExtractor"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Unzipping tokenizers/punkt.zip.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R4W2-_aXCAXX"
      },
      "source": [
        "# Common Functions and Variables"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PxF5KWtM_3-d"
      },
      "source": [
        "stanford_models_path  = '/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/' \n",
        "dataset_path = '/content/drive/My Drive/Stance Detection Paper/HeadlineToClaim.csv'\n",
        "stopWord_path = '/content/drive/My Drive/ImportantNLPFiles/StopWords_fa.txt'\n",
        "polarity_dataset_path = '/content/drive/My Drive/Stance Detection Paper/PolarityDataset.xlsx'\n",
        "save_load_path = \"/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/vectors\"\n",
        "w2v_model_path = \"/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/vectors/w2v_persian.pkl\"\n",
        "train_test_sets_save_path = \"/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data\"\n",
        "train_test_sets_load_path = \"/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "19kgNIXjbwBA"
      },
      "source": [
        "## k_fold_train_test function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vh4V5QklSxlI"
      },
      "source": [
        "def k_fold_train_test(X, Y, k_fold, model, scoring = 'accuracy' , additional_description = ''):\n",
        "  model_name = model.__class__.__name__\n",
        "  accuracies = cross_val_score(model, X, Y, scoring = scoring, cv= k_fold)\n",
        "  result = []\n",
        "  df_result = pd.DataFrame(index=range(k_fold))\n",
        "  for fold_index, accuracy in enumerate(accuracies):\n",
        "    result.append((model_name, fold_index, accuracy))\n",
        "  \n",
        "  df_result = pd.DataFrame(result, columns=['model_name', 'fold_index', scoring])\n",
        "\n",
        "  sns.boxplot(x = 'model_name', y = scoring, data = df_result)\n",
        "  sns.stripplot(x='model_name', y=scoring, data = df_result, \n",
        "                size=8, jitter=True, edgecolor=\"gray\", linewidth=2)\n",
        "  plt.show()\n",
        "\n",
        "  print('Mean '+scoring + ' of ' + model_name + ' in ' + str(k_fold) + ' fold is: ', np.average(accuracies, axis=0))\n",
        "  if len(additional_description)>0:\n",
        "    print(additional_description)\n",
        "  return df_result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XKpfAwRrbpHR"
      },
      "source": [
        "## common_train_test function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wlVZ2DJD9gJO"
      },
      "source": [
        "def common_train_test(model, X, Y, test_size= 0.2\n",
        ",save_datasets = True, save_path = '', load_if_exist = True, load_path = '', additional_description = ''\n",
        ", features_name= ''):\n",
        "  \n",
        "  model_name = model.__class__.__name__\n",
        "  file_not_exist = False\n",
        "  if load_if_exist :\n",
        "    assert len(load_path) > 0, \"Please enter load_path.\"\n",
        "    load_X_train = load_path + '/X_train_'+features_name+'.pkl'\n",
        "    load_X_test = load_path + '/X_test_'+features_name+'.pkl'\n",
        "    load_y_train = load_path + '/y_train_'+features_name+'.pkl'\n",
        "    load_y_test = load_path + '/y_test_'+features_name+'.pkl'\n",
        "    if os.path.isfile(load_X_train) == True :\n",
        "      X_train = joblib.load(load_X_train)\n",
        "      print('X_train loaded successfully.')\n",
        "    else:\n",
        "      print('X_train file is not exist.')\n",
        "      file_not_exist = True\n",
        "    if os.path.isfile(load_X_test) == True :\n",
        "      X_test = joblib.load(load_X_test)\n",
        "      print('X_test loaded successfully.')\n",
        "    else:\n",
        "      print('X_test file is not exist.')  \n",
        "      file_not_exist = True\n",
        "    if os.path.isfile(load_y_train) == True :\n",
        "      y_train = joblib.load(load_y_train)\n",
        "      print('y_train loaded successfully.')\n",
        "    else:\n",
        "      print('y_train file is not exist.') \n",
        "      file_not_exist = True\n",
        "    if os.path.isfile(load_y_test) == True :\n",
        "      y_test = joblib.load(load_y_test)\n",
        "      print('y_test loaded successfully.')\n",
        "    else:\n",
        "      print('y_test file is not exist.')\n",
        "      file_not_exist = True\n",
        "  if load_if_exist == False or file_not_exist == True:\n",
        "    X_train, X_test, y_train, y_test = train_test_split(X, Y, shuffle= True , test_size = test_size, random_state = 0)\n",
        "    print('Train and test sets created successfully.')\n",
        "    if save_datasets:\n",
        "      joblib.dump(X_train,load_path + '/X_train_'+features_name+'.pkl')\n",
        "      joblib.dump(X_test,load_path + '/X_test_'+features_name+'.pkl')\n",
        "      joblib.dump(y_train,load_path + '/y_train_'+features_name+'.pkl')\n",
        "      joblib.dump(y_test,load_path + '/y_test_'+features_name+'.pkl')\n",
        "      print('Train and test sets saved successfully.')\n",
        "  else:\n",
        "    print('Train and test sets loaded successfully.')\n",
        "\n",
        "  model.fit(X_train, y_train)\n",
        "  y_pred = model.predict(X_test)\n",
        "\n",
        "  conf_mat = confusion_matrix(y_test, y_pred)\n",
        "  fig, ax = plt.subplots(figsize=(4,4))\n",
        "  labels_name = np.unique(Y)\n",
        "  sns.heatmap(conf_mat, annot=True, fmt='d', xticklabels = labels_name, yticklabels = labels_name)\n",
        "  plt.ylabel('Actual')\n",
        "  plt.xlabel('Predicted')\n",
        "  print(model_name)\n",
        "  plt.show()\n",
        "\n",
        "  print(metrics.classification_report(y_test, y_pred, labels_name))\n",
        "  print('accuracy : ', accuracy_score(y_test, y_pred))\n",
        "  print('weighted f1 score : ', f1_score(y_test, y_pred, average='weighted'))\n",
        "  if len(additional_description)>0:\n",
        "    print(additional_description)\n",
        "  return y_pred"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tPTiAwfAAPuk"
      },
      "source": [
        "## Create Feature Extractor Object"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hAGzuYtgALiv",
        "outputId": "8003a6c8-4326-44a3-baec-5f0490874eb8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 156
        }
      },
      "source": [
        "psf_extractor = FeatureExtractor(dataset_path = dataset_path, stopWord_path = stopWord_path\n",
        "                                    , polarity_dataset_path = polarity_dataset_path,\n",
        "                                  stanford_models_path = stanford_models_path\n",
        "                                  ,use_google_drive = True, important_words = ['؟',\n",
        "             'تکذیب',\n",
        "             'تکذیب شد',\n",
        "             ':',\n",
        "             ])\n",
        "\n",
        "tokens_claims , tokens_headlines = psf_extractor.nltk_tokenize()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/drive\n",
            "/content/drive/My Drive/ImportantNLPFiles/StopWords_fa.txt\n",
            "(2029,) (2029,) (2029,) (2029,) (2029,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qfOh7sH9A701"
      },
      "source": [
        "labels = np.reshape(psf_extractor.labels,(len(psf_extractor.labels),1))\n",
        "labels.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9IfJJJ6NK_Hy",
        "outputId": "93820ddf-4b85-49d4-b75e-588a90439f4c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        }
      },
      "source": [
        "metrics.SCORERS.keys()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "dict_keys(['explained_variance', 'r2', 'max_error', 'neg_median_absolute_error', 'neg_mean_absolute_error', 'neg_mean_squared_error', 'neg_mean_squared_log_error', 'neg_root_mean_squared_error', 'neg_mean_poisson_deviance', 'neg_mean_gamma_deviance', 'accuracy', 'roc_auc', 'roc_auc_ovr', 'roc_auc_ovo', 'roc_auc_ovr_weighted', 'roc_auc_ovo_weighted', 'balanced_accuracy', 'average_precision', 'neg_log_loss', 'neg_brier_score', 'adjusted_rand_score', 'homogeneity_score', 'completeness_score', 'v_measure_score', 'mutual_info_score', 'adjusted_mutual_info_score', 'normalized_mutual_info_score', 'fowlkes_mallows_score', 'precision', 'precision_macro', 'precision_micro', 'precision_samples', 'precision_weighted', 'recall', 'recall_macro', 'recall_micro', 'recall_samples', 'recall_weighted', 'f1', 'f1_macro', 'f1_micro', 'f1_samples', 'f1_weighted', 'jaccard', 'jaccard_macro', 'jaccard_micro', 'jaccard_samples', 'jaccard_weighted'])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XyjAncnj9rUd"
      },
      "source": [
        "# TF-IDF With Other Features"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9uQkO49tRZRO"
      },
      "source": [
        "## Extract Feature"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XnDF49XjRYOI",
        "outputId": "f22da778-2140-456f-b625-11dcf4cb4a30",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "features, features_name = psf_extractor.generate_Features(w2v_model_path = w2v_model_path,save_path = save_load_path\n",
        "                                                          , save_feature= True\n",
        "                                                          , load_path= save_load_path\n",
        "                                                          , load_if_exist = True, bow = False, w2v = False, polarity= False)\n",
        "\n",
        "features.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Features loaded successfully.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2029, 728)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_SIb0MD_Rliv"
      },
      "source": [
        "## Train Best Models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RbKOEfX5VVEf"
      },
      "source": [
        "### *SVM*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SCJimwHR65DF",
        "outputId": "5bc0dc1d-7383-426b-e7ad-3134602d0d27",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 636
        }
      },
      "source": [
        "model = SVC(C=10, break_ties=False, cache_size=200, class_weight='balanced', coef0=0.0,\n",
        "    decision_function_shape='ovo', degree=3, gamma='scale', kernel='rbf',\n",
        "    max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
        "    tol=0.001, verbose=False)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train file is not exist.\n",
            "X_test file is not exist.\n",
            "y_train file is not exist.\n",
            "y_test file is not exist.\n",
            "Train and test sets created successfully.\n",
            "Train and test sets saved successfully.\n",
            "SVC\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.49      0.60      0.54        70\n",
            "    Disagree       0.62      0.58      0.60        31\n",
            "     Discuss       0.68      0.62      0.65       166\n",
            "   Unrelated       0.68      0.68      0.68       139\n",
            "\n",
            "    accuracy                           0.63       406\n",
            "   macro avg       0.62      0.62      0.62       406\n",
            "weighted avg       0.64      0.63      0.64       406\n",
            "\n",
            "accuracy :  0.6330049261083743\n",
            "weighted f1 score :  0.6350416228750646\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKo77bPZVgYe"
      },
      "source": [
        "### RandomForestClassifier"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Msp0HPwtA8ND",
        "outputId": "86792a8d-f895-4d18-d015-28176fa46064",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 619
        }
      },
      "source": [
        "model = RandomForestClassifier(bootstrap=True, ccp_alpha=0.0,\n",
        "                       class_weight='balanced_subsample', criterion='entropy',\n",
        "                       max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
        "                       max_samples=None, min_impurity_decrease=0.0,\n",
        "                       min_impurity_split=None, min_samples_leaf=1,\n",
        "                       min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
        "                       n_estimators=75, n_jobs=None, oob_score=False,\n",
        "                       random_state=None, verbose=0, warm_start=False)      \n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "RandomForestClassifier\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAAEGCAYAAAB7IBD2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3dd3xUVf7/8dc7AalSAlgBFcReUFBBLCDoKiq6dhZdLN9l9bcWbGtjlbX3jiiKWFZQXCtSLIiiriIoiIAKCCoiVToqkOTz++PewBBTJuPc3Jnk8/RxH5m5mTnnE5ycnH5kZjjnXEXlxB2Acy47eeHhnEuJFx7OuZR44eGcS4kXHs65lNSIO4DSPNrizKwaBrpw0bi4Q6iwVg23jTuECmuyxZZxh1BhH88fp2Rfu2HpnKQ/9zWbtko63Sh4zcM5l5KMrXk4Vy0VFsQdQdK88HAukxTkxx1B0rzwcC6DmBXGHULSvPBwLpMUeuHhnEuF1zyccynxDlPnXEq85uGcS4X5aItzLiXeYeqcS4k3W5xzKfEOU+dcSrzm4ZxLiXeYOudS4h2mzrlUmHmfh3MuFd7n4ZxLiTdbnHMpyaKah29D6FwmKdiQ/FUOSU9KWixpWsK9PElvS5oVfm0c3pekByXNljRV0v7lpe+Fh3OZpLAw+at8TwFHF7t3NTDWzNoAY8PnAMcAbcKrDzCwvMS98HAuk1hh8ld5SZmNB5YVu30C8HT4+GngxIT7z1jgE6CRpDK3168WfR7KESePvIm1C5cz+px76PrgBTTbpxWF+fksnjKH8Vc/SWF+Zg6R/emoztx7743k5uTw5JBh3HnXgLhD+p1bH7ieLkcews9Ll3PcYacDcHSPrlx0ZR9a77ITpxzVm2lffBVzlJtcd88/ObhbB5YvXcGZXc8F4KaB19OydQsAtmxQn9Wr1tD7qL9VfnDRd5hubWYLwscLga3Dx9sD8xJe92N4bwGlqBY1j73PO5rls3/a+HzWK//j+c5XMrzbNeTW3oLdenaOL7gy5OTk8OADt3Dc8Wey975dOP30E9l99zZxh/U7Lz8/gvPOuGize7O++pYLz/4nEz+eHFNUpRs5fAyX9rpqs3v/uuBGeh/1N3of9TfGjRrP+6M+iCe4CjRbJPWRNCnh6lORrMzMgJTPR6ryhUe9bfJoeURbvhr23sZ7P4z7YuPjJVO+pf62eTFEVr4DD9iPb7/9jrlzf2DDhg0MH/4aPY7/U9xh/c6kjyezcvmqze59O+s75n77fUwRlW3KhKmsWrGq1O93Pb4zb702thIj2sQKNiR/mQ0ys/YJ16AkslhU1BwJvy4O788HWiS8rnl4r1RVvvA4uP+ZfHLrMCj8fQGbUyOXNicdwg/vTY0hsvJtt/02zPtxU43px/kL2G67bWKMqOpre9A+LFuynB/nlvl7E5009nmU4nWgd/i4N/Bawv2/hqMuHYCVCc2bEkVWeEjaWtJgSaPD53tIOi+q/ErSsmtbfvt5FUu//K7E7x96y9ksmPA1Cz/9pjLDchnsyBOP4O2Yah1AWkdbJA0DPgZ2lfRj+Pt3O3CkpFlAt/A5wChgDjAbeBz4f+WlH2WH6VPAEOC68PlM4AVgcGlvCNtsfQD+0uhADq3/x9r327TfhR2O3J+WXfYlt1ZNam5ZhyMeuIB3LxlIu75/pnaTLXn/6if/UB5R+mn+Qlo0327j8+bbb8tPPy2MMaKqLTc3h87HHMrZx/w9viDSOEnMzHqW8q2uJbzWgH9UJP0omy1NzWw4UAhgZvlAmUMaiW24P1pwAHx6x3D+c+DFPHfwpbzzjwH89NEM3r1kILud0ZkWh+/NOxcOAMvc87QnTprCzjvvxI47tqBmzZqcdtoJjHjjrbjDqrIOOLQd38+ex5IFS+MLIr3zPCIVZc1jraQmhL25Re2oCPNL2mG3ncPq+Uv586v9AZg7eiKfPfBqvEGVoKCggEv69mPUyKHk5uTw1NMvMGPGzLjD+p17H7uFAzu1o3FeI8Z/MZIH7xzEyuUr+ddtV5LXpDGDht7PV9Nnct5pF5WfWCX494B+7N+xLY3yGvLapOE8cfdTjHh+FN1OiLnJAlk1PV0W0V/ecHrrQ8BewDSgGXCKmSXVO/loizMzt0pQggsXjYs7hApr1bDMOUAZqckWW8YdQoV9PH+ckn3tryPvT/pzX+fYvkmnG4XIah5m9rmkw4FdAQHfmFn5E/Kdq86yqOYRWeEhqS5wGbCDmf1NUhtJu5rZG1Hl6VzWy4C+jGRF2WE6BFgPdAyfzwdujjA/57Jf9PM80ibKwqO1md0JbAAws18Imi/OudL4aAsA6yXVYdNoS2tgXYT5OZf9MqBGkawoC48bgDFAC0nPAZ2AsyPMz7nsl1/Nj16QlAM0Bk4COhA0Vy4xsxhn3ziXBTJ40mJxkRQeZlYo6Z/hDNORUeThXJWUAX0ZyYqy2fKOpCsI1rOsLbppZsV3NnLOFfHCA4DTw6+Ji20MaBVhns5lN+8wBTPbKaq0nauyCjJzO8ySRDnD9KQSbq8EvjSzxSV8zznnzRYAziOYXVq0Yqwz8Bmwk6QbzezZCPN2Ljt54bEx7d3NbBEEO4sBzwAHAeMBLzycK877PABoUVRwhBaH95ZJ8tW1zpXASthrN1NFWXi8J+kN4MXw+cnhvXrAigjzdS57ebMFCIZoTwIOCZ9PIjhwZi3QJcJ8ncteWTTaEtmq2nBD1TlAPvBnggIjc44Ncy4TVedVtZJ2AXqG11KCGaYyM69tOFeeDCgUkhVFs+Vr4APgODObDSDp0gjyca7qyaKFcVE0W04iOBx3nKTHJXXFNwFyLjlZ1GxJe+FhZq+a2RnAbgQTxPoCW0kaKOmodOfnXJVSaMlfMYtybctaYCgwVFJj4FTgKiCpU4v6LhkfVWiR2L/pznGHUGGzV/9U/osyzC8Fv8UdQrSyaLQlyqHajcxsOTAovJxzpbAMaI4kq1IKD+dckjKgOZIsLzycyyS+tsU5l5IsqnlEeW6Lc66i8guSv8oh6VJJ0yVNkzRMUm1JO0maIGm2pBckbZFqqF54OJdJ0nRinKTtgYuB9ma2F5ALnAHcAdxnZjsDywn23UmJFx7OZZL0zvOoAdSRVAOoSzB58wjgv+H3nwZOTDVULzycyyBWWJj0JamPpEkJV5+N6ZjNB+4GfiAoNFYS7OS3wsyKTpb6Edg+1Vi9w9S5TFKBDlMzK3XuVDgx8wRgJ4L9c14Ejk5DhBt54eFcJknfaEs3YK6ZLQGQ9DLBka+NJNUIax/NgfmpZuDNFucySUFB8lfZfgA6SKorSUBXYAbBerNTwtf0Bl5LNVQvPJzLIFZoSV9lpmM2gaBj9HPgS4Lf9UEE68sukzQbaAIMTjVWb7Y4l0nSOEnMzG4Abih2ew5wYDrS98LDuUziC+OccynJounpXng4l0m88HDOpcIKvNninEuF1zycc6nw4yadc6nxwsM5l5Ls6fLwwsO5TGL52VN6eOHhXCbJnrKj+hQezZtvy+DB97HVVs0wMwYPHsqAAU/GHdbv9Lv3Kg7p1pHlS5fT84hzNt4/7dyTOOXsEyksKOSjsZ/w0M2Pxhhl6aZMG8eaNWspKCgkPz+froefFHdI5fq/C86i51knY2Z8PWMWl1/Yj3Xr1scSi3eYZqD8/AKuuupmpkyZRv369fj445GMHfsBX389K+7QNjPyhdG8OORl+j9w7cZ77Q7ej8P+1Ile3c5jw/oNNG7SKMYIy9fj2LNY9vPyuMNIyjbbbsW5fXpxRMcT+O23dQx88m56nHQMLw5LebHpH5NFNY9qs6p24cLFTJkyDYA1a9by9dez2X77bWKO6vcmT5jKquWrN7t38l9P4OmHh7Jh/QYAlv+8Io7QqqwaNWpQu3YtcnNzqVOnDosWLoktlnStqq0MkRYeknaRNFbStPD5PpL6RZlnMnbYoTlt2+7Jp59OjjuUpLRs3Zy2B+3Dk28M5NGXHmD3fXeLO6RSmRkvvTqEd8e/Qu9zTo87nHItXLCYxx5+iglT3+Hzr8axetVqxo/7X3wBFVbgilnUNY/HgWuADQBmNpVgB+cSJe7JWFCwJpKA6tWry7Bhj3HFFf9m9epo8ki33NxcGjZqwLnHXcCDNw3ktsf6xx1Sqbof1ZMuh57IaSedx3l/60XHTgfEHVKZGjZswFHHdKHjfn+i3R5HUKduHU469bjY4rH85K+4RV141DWzT4vdK/XHNrNBZtbezNrn5tZPezA1atTg+ecf4/nnX+G118akPf2oLF6whHGjgoO/Z0z5msLCQhrlNYw5qpItWLAIgKVLlzFyxNu0a7dPzBGV7ZDOHZj3w3yW/byc/Px8Rr8xlnYHto0tnjSdvFApoi48lkpqDRiApFMIdnKOxWOP3cXXX8/mwQefiCuElLw/5kPaddoPgJatmlNzi5qsWLYy5qh+r27dOtSvX2/j4y5dD+GrGTNjjqpsP/24gP3a70PtOrUBOOSwg5g9c058AWVRsyXq0ZZ/EGx9tpuk+cBc4MyI8yzRwQcfQK9eJ/Pll18xYcJoAK6//k7efHNcHOGU6qZHrqddx7Y0ymvIiEkv8vg9Q3j9+VH8696rGPbuEDZsyOffl9wad5glarZVU54dOgAIann/HT6Cse98EHNUZZv82ZeMev1txowbTn5BAdOnfs1zT78YWzyZUKNIlsyi77WVVA/IMbPV5b44VLt2y/i7kytgn7yd4g6hwmav/inuECqsbs1acYdQYT8um6ZkX7u46+FJf+63Gvt+0ulGIerRlq0lDQb+a2arJe0hKeXj7Zyr6qxASV9xi7rP4yngTWC78PlMoG/EeTqXtbzDdJOmZjacsHsnPGim/OO9naumrFBJX3GLusN0raQmbBpt6UBwZqZzrgSZUKNIVtSFx2XA60BrSR8Bzdh0WpVzrhiz+GsUyYqs8JCUCxweXrsCAr4xsw1R5elctvOaB2BmBZJ6mtl9wPSo8nGuKinMgFGUZEXdbPlI0sPAC8Daoptm9nnE+TqXlTKhIzRZURceRYsEbky4Z8AREefrXFbywiNkZl2iTN+5qqYSJnynTamFh6SHCIdYS2JmF5eXuKTLSri9EvjMzKYkFaFz1UhVqXlMSkP67cNrRPj8OGAqcL6kF83szjTk4VyVke6hWkmNgCeAvQgqA+cC3xD0Q+4IfAecZmYV3jey1MLDzJ5OIdbimgP7m9kaAEk3ACOBw4DPAC88nEtQkP7RlgeAMWZ2iqQtgLrAtcBYM7td0tXA1cBVFU243D4PSc3ChPcAahfdN7NkOj23AtYlPN8AbG1mv0paV8p7nKu20lnzkNSQ4A/12UHath5YL+kEoHP4sqeB94ii8ACeI6jiHAucD/QGkt0h9jlggqSiraiPB4aGS/RnVDBW56q8ivR5SOoD9Em4NcjMBiU834ngd3WIpH0JavuXEPwBL9qUayGwdSqxJlN4NDGzwZIuMbP3gfclTUwmcTO7SdIY4ODw1vlmVtSX0iuFeJ2r0ioy2hIWFIPKeEkNYH/gIjObIOkBgiZKYhomKaUxnmQKj6Lp5AskHQv8BOQlm4GZTZT0PWGTR1JLM/uhwpE6Vw2kebTlR+BHM5sQPv8vQeGxSNK2ZrZA0rbA4lQST2ZJ/s1h2+ly4AqCnttLk0lcUg9Jswi2H3w//Do6lUCdqw4KCnOSvspjZguBeZJ2DW91JegueJ2g+4Hwa0onXJVb8zCzN8KHK4GKTvq6CegAvGNm+0nqQkx7mDqXDSKYJHYR8Fw40jIHOIeg0jA83NXve+C0VBJOZrRlCCVMFjOzc5NIf4OZ/SwpR1KOmY2TdH8qgTpXHRSmeZ5HOBmzfQnf6vpH006mz+ONhMe1gT8T9HskY4Wk+sB4gtJvMQkL5Jxzm6tS+3mY2UuJzyUNAz5MMv0TgF8J+kh6AQ3ZfJGccy5BlVjbUoY2BJO/kmZm+ZI+BnYDViXzno5Ndy3/RRnk02Wz4g6hwn7++JG4Q6iwgccPjTuESKW72RKlZPo8VrN5n8dCkp+NNh44VFJj4C1gInA6PsfDuRIlM4qSKZJptmz5B9KXmf0S9uo+YmZ3SvLVtM6VIotaLeXP85A0Npl7pb9dHQlqGiPDe7nJh+dc9VJoSvqKW1n7edQmWIHXNGx2FEXbANg+yfT7AtcAr5jZdEmtgMw6HNa5DFJVRlv+TvDLvx3Bgpqin2oV8HAyiRethUl4PgcodxMh56qrLNo8vcz9PB4AHpB0kZk9VJFEJd1vZn0ljaDkCWY9Kh6qc1WfUTVqHkUKJTUysxUAYROmp5mVNc73bPj17j8aoHPVSX4VabYU+ZuZDSh6YmbLJf0NKLXwMLPPwq/vh5sJYWbJ7gHiXLWVTTWPZAaVcyVt/InCk+C2KO9NkvpLWkqwX+JMSUskXZ96qM5VfYUVuOKWTOExBnhBUldJXYFhlLOsPtw1vRNwgJnlmVlj4CCgk6SklvM7Vx0ZSvqKWzLNlqsItjo7P3w+FdimnPecBRxpZkuLbpjZHElnEsw0vS+FWJ2r8jKhRpGsZGaYFkqaALQmWPffFHip7HdRM7HgSEhriaSaKUXqXDVQkAE1imSVNUlsF6BneC0l2AQ52VPg1qf4PeeqtSw686nMmsfXwAfAcWY2G6AC/RX7Sipp9axIOL7BObe5wqpQ8wBOAs4AxoU7oD8Pyf1kZubrV5xLQZVYGGdmr5rZGQR7cIwjmKq+laSBko6qrACdq06q1FCtma01s6FmdjzB8ZGTSeF0Kedc+QqlpK+4VWgnsfAw3PIOmnHOpagg7gAqIJVtCJ1zEakqoy3OuUpWVUZbnHOVLJtGW7zwcC6DeLMlQ/zz7svp0O0gVixdwbnd+gDQevdWXHr7JdSpV4eF8xZyy0W388uaX2KOtGS1atXirbdfoNYWtcitkcurr47mlpvjXxZ0/SPDGP/5DPIa1ufle4KBt5Vr1vLP+57hpyXL2K5ZHndd2psG9etufM+02T/w134PcEffsziyQ9u4Qt+McsRf3riJNYuW89o599CgRTO6P/wP6jTekkVfzmVM34EUbqjcLsxMGIJNVvbs856CMS++xVVnXrvZvSvuuozHbxvMed368OGYjzj9/FNjiq5869ato/sxf6FDh2Po2KE7Rx55OAccsF/cYXFC5wMZeG2fze49+epYDty7DSMevI4D927D4Fc37ZFdUFjI/c+NoOO+mXUWz37nHs2y2ZsOPzz0mjP4/IkxDDnsctatXMtep3eu9JgKlPwVtypdeEyd8CWrVqze7F7zVs354pOpAEwa/zmHdT80jtCStnZtUCuqWbMGNWvWwDKgVdxuj9Y0qF9vs3vjJk6jx+EHANDj8AMYN/HLjd8bNvoDuh20L3kN6ldqnGWpv00eO3Vty7Tn39t4r8XBezBr1KcAzPjvB7T+U7tKj6tKTRL7IySdKmnL8HE/SS9L2j/KPMvz3czv6PSngwHofNxhbLVdszjDKVdOTg4ffzKK777/jHfHfsikiZl57M2ylatp1rghAE0bNWDZyqDQXrRsBe9++iWnHXVwnOH9Tuf+Z/LBrcOwwqAwrt24PutW/YIVBL+Wqxcso/42jSs9Li88NvmXma2WdAjQDRgMDCztxZL6SJokadJPa3+MJKA7L7+HE/7ag8dGDaBO/Tps2JAfST7pUlhYSMcO3dmlTUfatd+XPfbYJe6QyiUJwhmQdz31Kn17HUdOTuZUcnfq2pZflq5i8ZffxR3K75iSv+IWdYdpUW/TscAgMxsp6ebSXmxmG2evdml+ZCT183nfzuOfva4GoPlO29Oh60FRZJN2K1euYvz4jznyyMOZMWNm3OH8Tl7DLVmyfCXNGjdkyfKVG5so07+dx1UPPAPA8lVr+WDyV+Tm5HLEgXvHFut27Xeh1ZH7s2OXfalRqyZbbFmHzv3PolaDuig3BysoZMtt81izcHmlx5buGkW4begkYL6ZHSdpJ4JFrk0IjlQ5y8xS2iYj6j8H8yU9RnA+7ShJtSohzzI1atIICP46nnVJL0Y8+0ac4ZSpadM8GjZsAEDt2rU44ohD+GbmtzFHVbLO7ffi9fcnAvD6+xPpcsBeAIwe8C9GD7ie0QOu58gO+3Ld/50ca8EB8NEdw3nioIt5stOljLpwAPP+N4Mxlwxk3sczaNP9QAD2OOVQvn3r80qPraACV5IuAb5KeH4HcJ+Z7QwsB85LNdaoax6nAUcDd5vZCknbAldGnOdG/R6+lrYd96FhXkOGTxzKU/c8Q516dTihd3BszAejP2T0C29WVjgVts02WzHo8XvIzckhJyeHl14eyZjR78YdFlfd/wyTZsxmxeq1HHl+fy447WjOPbErV973NK++O4FtmzXmrkt7xx1mhX142/N0f/hCOl15Kounf8f0F96r9BjSOc9DUnOCWv8twGXhRuZHAH8JX/I00J8yuhLKTN8sut57Sa2BH81snaTOwD7AM0VnwJQlqmZLVD5dNivuECrs54/LOnonMw08fmjcIVTYpT/8J+ki4b6WZyb9ub9s3nN/J9hfuMigsOkPgKT/ArcBWwJXAGcDn4S1DiS1AEab2V7J5pko6ibES0CBpJ0J+jJaANn3f9+5SlKR0RYzG2Rm7ROuxILjOGBx0RlKUYi62VJoZvmSTgIeMrOHJE2OOE/nslYaq9udgB6SuhNs/dkAeABoJKmGmeUT7M8zP9UMoq55bJDUE/grUNQz6bunO1eKQiV/lcXMrjGz5ma2I8F2ou+aWS+CXQFPCV/WG3gt1VijLjzOAToCt5jZ3HCY6Nly3uNctRXBaEtxVxF0ns4mGK4dnGpCkTZbzGwGcHHC87kEQ0XOuRIURrD8wMzeA94LH88BDkxHupEWHpLmUkIzzsxaRZmvc9kqE6adJyvqDtP2CY9rA6cCeRHn6VzWyqb5CZH2eZjZzwnXfDO7n2DSinOuBNm0MC7qZkviCtocgppIld6AyLk/Il/ZU/eI+hf5noTH+cBcginrzrkSZE/REf1oSzKHYjvnQpnQHElW1JsB3SqpUcLzxmUtyXeuuivEkr7iFvUksWMSF8GFJ851jzhP57KWVeCKW9R9HrmSapnZOgBJdYBaEefpXNbKpmZL1IXHc8BYSUPC5+cQ7CHgnCtBQUbUKZITdYfpHZK+INi/FOAmM8vc3Xeci5nXPEKS6gFvmdkYSbsCu0qqaWYboszXuWyVCUdrJCvqDtPxQG1J2wNjgLOApyLO07mslU0zTKMuPGRmvwAnAQPN7FRgz4jzdC5r+VDtJpLUEegFjAzv5Uacp3NZy4dqN+kLXAO8YmbTJbUi2MnIOVeC/IwoFpIT9WjL+8D7Cc/nkLA5kHNuc9nUYRpJ4SHpfjPrK2kEJW8G1KO8NL5Y+V0UoUVmQ0FmH1tZkj8f91DcIVTY65MHxB1CpDKhIzRZUdU8ivYpvTui9J2rkqp9zaPorAgze19Ss/Dxkijycq4qyaaaR2SjLZL6S1oKfAPMlLRE0vVR5edcVVBglvQVt0gKD0mXERw6c4CZ5ZlZY+AgoJOkS6PI07mqwOd5BDNJe4ZHLQAbR1rOJDgAyjlXAqvAf3GLqsO0ppktLX7TzJZI8hPjnCtFNvV5RFV4rE/xe85Va5nQHElWVIXHvpJWlXBfBOe3OOdKkAnNkWRFNVTr61ecS0EmjKIky89QcS6DeLPFOZcS7zB1zqUkm/o8ot7PwzlXAemcJCaphaRxkmZImi7pkvB+nqS3Jc0KvzZOJVYvPJzLIGaW9JWEfOByM9sD6AD8Q9IewNXAWDNrA4wNn1eYFx7OZZACLOmrPGa2wMw+Dx+vBr4CtgdOYNMRKE8DJ6YSqxcezmWQijRbJPWRNCnh6lNaupJ2BPYDJgBbm9mC8FsLga1TidU7TJ3LIEk2R4peOwgYVN7rJNUHXgL6mtkqSYlpmKSUemm98HAug6R7nke4luwl4Dkzezm8vUjStma2QNK2wOJU0vZmi3MZJJ2rahVUMQYDX5nZvQnfeh3oHT7uDbyWSqxe83Aug6R5enongu0xvpQ0Jbx3LXA7MFzSecD3wGmpJO6Fh3MZJJ3NFjP7kGAxakm6/tH0vfBwLoP42pYMNWXaONasWUtBQSH5+fl0PfykuEMq06DH7qZ7924sWbKU/fbvFnc4JWq6bVOuuP8KGjdtjJkxeuhoXnvyNQ459hDOvPRMWrRpQd/j+zJr6qxY4+x3672M/+hT8ho34tX/PArAm+9+wCOD/8Oc7+cx7PH72Wv3XQD436efc/+jQ9iwIZ+aNWtw+T/O46B2bSslzoqMtsSt2nWY9jj2LA7v1CPjCw6AZ559keOOPzPuMMpUUFDA4zc9zt+7/p1LT7iU43ofR8s2Lfn+m++5qc9NTJswLe4QATix+5E8eu/Nm93budUO3H/rv2jXdq/N7jdu1ICH7+jPK88O5JZ+l3PNjZV3gkg27WFarWoe2ebDDyewww7N4w6jTMsXL2f54uUA/Lr2V+bNnkeTbZow+YPJMUe2ufZt92b+gkWb3Wu9Y8sSX7v7LjtvfLzzTjvw27p1rF+/ni222CLSGMEXxmUsM+OlV4fw7vhX6H3O6XGHU+Vs1XwrWu/Zmm8mfxN3KGnz9nsfsseuO1dKwQFQYIVJX3GL6rjJ/cv6ftF8+8rW/aieLFiwiKZN83j59aeYOXMOH380MY5QqpzadWvT77F+PNb/MX5Z80vc4aTF7Dnfc+8jTzLovlsqLc9s6vOIqtlyT/i1NtAe+IJgyGgfYBLQsaQ3hXPz+wDUrdWMWjUbpjWoBWG1denSZYwc8Tbt2u3jhUca5NbIpd+gfox7dRz/G/O/uMNJi4WLl3DJtTdx67+uoGXz7Sot30zoy0hWJM0WM+tiZl2ABcD+ZtbezNoRLMyZX8b7BoWvbZ/ugqNu3TrUr19v4+MuXQ/hqxkz05pHddX3rr7MmzWPVx5/Je5Q0mLV6jX8vytvoO/557D/PntWat7ZdG6LoqwmSZpuZnuWd68keVu2SWtgO+zYgmeHBies16hRg/8OH8G9dw9MW/pr1v+atrSKPPvMwxx2WEeaNs1j0aKl3HjTPTz11PNpS7/rVnv/4TT2PGBP7n75biaBfwkAAAweSURBVOZ+NZfCwqAd/vQdT1OzVk0uuPECGuY1ZM2qNcyZMYd+Z/b7w/m9PnlASu+78obbmTh5KitWrKJJXiP+33ln0bBBfW67byDLVqxky/r12a1NKwbddwuPPTWMJ559gZbNt9/4/kH330KTxo1Syrtm01alTdT6nb227pD0537aok+STjcKURcew4C1wH/CW72A+mbWs7z3prvwiFoUhUfU0lF4VLZUC484VaTw2HPrg5L+3E9fNCHWwiPqodpzgAuAS8Ln44H0/bl3rorJhFGUZEVaeJjZb5IeBUaZWdUZv3MuIoVZNNoS6TwPST2AKcCY8HlbSa9Hmadz2SybOkyjniR2A3AgsALAzKYAO0Wcp3NZq9As6StuUfd5bDCzlYnbnkEGFJnOZahMqFEkK+rCY7qkvwC5ktoAFwNVYxaRcxEosIK4Q0ha1M2Wi4A9gXXAUGAlm0ZenHPFpPnclkhFXfM41syuA64ruiHpVODFiPN1LitV++npCa5J8p5zDq95IOkYoDuwvaQHE77VgOAIPOdcCTJhFCVZUTVbfiJYPdsD+Czh/mrg0ojydC7rVfvRFjP7AvhC0lAz2xBFHs5VRT49fZMdJd0G7EGwtwcAZtYq4nydy0qZ0JeRrKg7TIcQLITLB7oAz7Bpha1zrphsmmEadeFRx8zGEiz9/97M+gPHRpync1mr2o+2JFgnKQeYJelCgl3E6kecp3NZy+d5bHIJUJdgWno7gnMze5f5DueqMa95hMysaHfhNQQbAznnylDtR1skjaCM1bNm1iOKfJ3LdpnQEZqsqGoelXc+n3NVSCY0R5IV1SSx94seS6oDtPRtCJ0rXzpnmEo6GngAyAWeMLPb05Y40W9DeDy+DaFzSUtXh6mkXGAAcAzBJM2ekvZIZ6xRj7b0x7chdC5paZwkdiAw28zmmNl64HnghHTGmrHbEC5bPSuyMykk9TGzQVGln27ZFi9kX8yZEm/++vlJf+4Tj2cNDUr4GbYH5iV870fgoD8e4SZR1zw224ZQ0kNkxjaEfcp/SUbJtngh+2LOtng3O541vCq18ItjG8K+EefpnAtmc7dIeN6cMs6JTkVkzZaww2ZkeOD1deW93jmXVhOBNpJ2Iig0zgD+ks4MIis8zKxAUqGkhma2Mqp8UhR727aCsi1eyL6Ysy3eMplZfrie7E2CodonzWx6OvOI+qDr14D9gLcJDrwGwMwujixT51yliHq05eXwcs5VMZHWPJxzVVfUM0w7SXpb0kxJcyTNlTQnzXmcKMkk7ZbOdFMlqUDSFEnTJX0h6fJwTxMktS+2m3zGyeT4Je0oaVqxe/0lXZGGtDtLeqOc17SV1D2FtN+T1D716DJT1M2WwQS7pX8GRHWOXk/gw/DrDcm+SVKuWSRn+/1qZm3DPLYiGKJuANxgZpMIdpWPhKQaZvZHj7aILf6opeHfpy3QHhiVppCyW0Xm0lf0AiZEnH59gmGoXYBvwns5wCPA1wQdtaOAU8LvfQfcAXxOMHR1FPBx+PxFoH74unbA+wSF3pvAthWIaU2x562AnwEBnYE3wvuHE6z7mQJMBrYMf56xYTxfAickpPMv4BuCgnIYcEV4/z3gfoJf6stLix1oTbDG6DPgA2C3dMcf3r8qjP0L4PaEGNuHj5sC34WP9wQ+DdOYCrQB6gEjw/dPA05PiGVHYFqx+PoDV4R53BGmNxM4NPz+2cDrwLvhv0s94MnwdZOL/o2L/WwHhp+LyQSTGncFtgB+AJaE8Z5eRlp1CKaDfwW8Akwo+vmr0hV14XE7cBfQEdi/6Epj+r2AweHj/4W/OKcQFBg5wDbAcjYvPP6Z8CEeD9RL+NBfD9QM02oW3j+dYJgrpcIjvLcC2LrYB3QE0Cl8XJ+gFlgDaJAQ32yCX9oDwg9sbYJCZhabFx6PhI9LjZ2gUGoTPj4IeDeC+I8J868b3s9LiLGkwuMhoFf4eIvwl+5k4PGEvBsmPN6RsguPe8J73YF3wsdnE0zNLorlVuDM8HEjgoKmXrGfrQFQI3zcDXgpIa2HE/IuLa3LEv7d9yHYALzKFR5RN1uK5tK3C7+KYG3LEWlKvyfBkmMISvqeBB/iF82sEFgoaVyx97wQfu1AsNrwo3DtzRYEf212BfYC3g7v5wIL0hRvoo+AeyU9B7xsZj9KqgncKukwoJBgfcLWQCfgNTP7Dfgt3GyppJ+pxNgl1QcOBl5MWGdUK4L4uwFDzOwXADNbVk4aHwPXSWoepjFL0pfAPZLuIPhl/iDh9aX17hfdLxrZ+4ygoCnydkIsRwE9EvpJagMti6XXEHhaUpsw7Zql5FtaWocBDwKY2VRJU0t5f1aLaiexy8KHRR1QRlDd+9DM5qYpjzyCQmhvSUbwi2IE1cSyFM03EcGHqmexdPcGpptZxzTF2Yqgv2cxsHvRfTO7XdJIgr+SH0n6E0GB1gxoZ2YbJH1Hwnk3ZUj8mX4Xu6QGwAoL+zIijL80+WzqnE88v2eopAkEO+qPkvR3M3tX0v5hujdLGmtmN4Zv+RloXCztPKDoM7Uu/FrA5p/ttQmPBZxsxfaXkbR1wtObgHFm9mdJOxLUakpSWlqlvLxqiWq0ZUs2teHrh4/bA6MlnZGmPE4BnjWzHcxsRzNrQfAhWgacLCkn/EB0LuX9nwCdJO0MIKmepF0I+hWaSeoY3q8pac9UApTUDHiUoKprxb7X2sy+NLM7CKYS70bwF29xWHB0AXYIX/4RcLyk2mEt4rhSsiwxdjNbBcyVdGp4X5L2jSD+t4FzJNUNX5MXvvw7NtU+T0lIoxUwx8weBF4D9pG0HfCLmf2HoMm7f9HrzWwNQU3qiIT0jyboB0rWm8BFCn/DJe1XwmsasmkdyNkJ91cTfJbLS2s84VRwSXsRNF2qnKh2Evt3SffD/9nvEDQx/qieBB1kiV4i+Ov4IzCDYEny5wQL8orHuETS2cAwSUVV+H5mNlPSKcCDkhoS/BvdDyQ7tbeOpCkEVd184Fng3hJe1zcsIArDtEcTfDBHhFX3SQSdvpjZRAWbKE0FFhF0SJb0M60vI/ZewEBJ/cLYnifolExb/Ga2TlJbYJKk9QR9T9cSbEs5XMES8pEJaZwGnCVpA7CQoA/hAOAuSYXABuCCYvn+FRggqSimf5vZtxX4a39T+G8yNRyCnsvvC+M7CZot/YrFOw64Ovz3ua2MtAYCQyR9RdBpmnhec5VR6ZPEJE02s5JK+3TmUd/M1khqQtAT3snMFkaZZ9QSfqa6BH/Z+pjZ53HH5aqvqDtMNxP+pVpeCVm9IakRQSfoTdlecIQGKdhGrjbwtBccLm6R1DzCanfxhPOAn4C/mtnXac/UOVepoio8dih2y4CfzWxtSa93zmUfXxjnnEtJ1NsQOueqKC88soA2rXSdJunFonkUKab1VDici6QnVMZZHgpWmh6cQh7fSWqaaowuO3jhkR1+NbO2ZrYXsB44P/GbklIaNTOz/zOzGWW8pDPBtHbnfscLj+zzAbBzWCv4IJw8NkNSrqS7JE2UNFXS32HjbNKHJX0j6R1gq6KElLDPhKSjJX2uYA+PseG07POBS8Naz6GSmkl6KcxjoqRO4XubSHpLwR4gTxBM23ZVXKXO83B/TFjDOIbw+E6Cqdt7mdnccPbmSjM7IJwx+5Gktwj2kN2VYBHg1gQzb58slm4z4HHgsDCtPDNbJulRglW2d4evGwrcZ2YfSmpJMD17d4J9VD40sxslHQucF+k/hMsIXnhkh6Ip4xDUPAYTNCc+TVhoeBTB2pCitSMNCfbHOAwYZsHGRz9JereE9DsA44vSKmM1bDdgj4Sp4A3CtTaHASeF7x0pqTImArqYeeGRHTbu7lUk/AUuvlr0IjN7s9jrKrxtXhlygA7h1gDFY3HVjPd5VB1vAhco2BMESbtIqkewDub0sE9kW6BLCe/9BDhMwQFBiathi68ifYvgFEDC1xUVaImrSI/h98vmXRXkhUfV8QRBf8bnCjYJfoygZvkKwc5jM4BnCDbg2YyZLSE4q/VlSV+waXOhEcCfizpMgYuB9mGH7Aw2jfr8m6DwmU7QfPkhop/RZRCfYeqcS4nXPJxzKfHCwzmXEi88nHMp8cLDOZcSLzyccynxwsM5lxIvPJxzKfn/3fZ/OvBTb1IAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.62      0.60      0.61        70\n",
            "    Disagree       0.80      0.52      0.63        31\n",
            "     Discuss       0.74      0.63      0.68       166\n",
            "   Unrelated       0.63      0.81      0.71       139\n",
            "\n",
            "    accuracy                           0.67       406\n",
            "   macro avg       0.70      0.64      0.66       406\n",
            "weighted avg       0.69      0.67      0.67       406\n",
            "\n",
            "accuracy :  0.6748768472906403\n",
            "weighted f1 score :  0.6725625048978913\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B6AR6TcxVl1w"
      },
      "source": [
        "### Linear SVC"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "58sPvAO1N5EW",
        "outputId": "a10368ac-5772-4a5b-e467-78c9be4c4fc1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 621
        }
      },
      "source": [
        "model = LinearSVC(C=0.5, class_weight='balanced', dual=True, fit_intercept=True,\n",
        "          intercept_scaling=1, loss='hinge', max_iter=1000, multi_class='ovr',\n",
        "          penalty='l2', random_state=None, tol=0.0001, verbose=0)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "LinearSVC\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.47      0.66      0.55        70\n",
            "    Disagree       0.56      0.74      0.64        31\n",
            "     Discuss       0.82      0.57      0.67       166\n",
            "   Unrelated       0.66      0.73      0.69       139\n",
            "\n",
            "    accuracy                           0.65       406\n",
            "   macro avg       0.63      0.67      0.64       406\n",
            "weighted avg       0.69      0.65      0.65       406\n",
            "\n",
            "accuracy :  0.6502463054187192\n",
            "weighted f1 score :  0.6544023635914299\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KSXKfVR0Vsaj"
      },
      "source": [
        "### Logistic Regression"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PiuoewVvN5oX",
        "outputId": "f2a342d7-e56d-4f21-f1ee-7ad4d526b2e3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 619
        }
      },
      "source": [
        "# with \"l1_ratio\": ['None']\n",
        "model = LogisticRegression(C=1, class_weight='balanced', dual=False, fit_intercept=True,\n",
        "                   intercept_scaling=1, l1_ratio=None, max_iter=1000,\n",
        "                   multi_class='ovr', n_jobs=None, penalty='l1',\n",
        "                   random_state=None, solver='saga', tol=0.0001, verbose=0,\n",
        "                   warm_start=False)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "LogisticRegression\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.51      0.76      0.61        70\n",
            "    Disagree       0.59      0.74      0.66        31\n",
            "     Discuss       0.80      0.52      0.63       166\n",
            "   Unrelated       0.68      0.76      0.72       139\n",
            "\n",
            "    accuracy                           0.66       406\n",
            "   macro avg       0.64      0.69      0.65       406\n",
            "weighted avg       0.69      0.66      0.66       406\n",
            "\n",
            "accuracy :  0.6600985221674877\n",
            "weighted f1 score :  0.6587457606192086\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wG54yCTEprOt",
        "outputId": "9d72399f-115d-47ed-ee78-9e8bda2bc468",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 619
        }
      },
      "source": [
        "# with \"l1_ratio\": [0.1]\n",
        "model = LogisticRegression(C=1, class_weight='balanced', dual=False, fit_intercept=True,\n",
        "                   intercept_scaling=1, l1_ratio=0.1, max_iter=1000,\n",
        "                   multi_class='ovr', n_jobs=None, penalty='elasticnet',\n",
        "                   random_state=None, solver='saga', tol=0.0001, verbose=0,\n",
        "                   warm_start=False)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "LogisticRegression\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAAEGCAYAAAB7IBD2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3dd3xUVfrH8c83CUhvUqSoCCqKuoKiglhgcS1YsCtiL6hrw/LTtdfd1bV3RRGxoMKqq4ii0sXCoog0UREsKEoRkLZAkuf3x72BIaRMxrm5M+F5+7qvzL25c84TnJyce6rMDOecq6icuANwzmUnLzyccynxwsM5lxIvPJxzKfHCwzmXkry4AyjN8Ga9s6obqNeS8XGHUGG1q9eIO4QK69hgu7hDqLCx80Yq2XvXLZqT9Oe+WuM2SacbBa95OOdSkrE1D+c2S4UFcUeQNC88nMskBflxR5A0LzycyyBmhXGHkDQvPJzLJIVeeDjnUuE1D+dcSrzB1DmXEq95OOdSYd7b4pxLiTeYOudS4o8tzrmUZFGDqc9tcS6TWGHyRzkkPSNpgaTpCdcaSXpf0jfh14bhdUl6SNJsSVMl7VFe+l54OJdJCvKTP8r3LHBosWt/A0aZ2Q7AqPAc4DBgh/DoCzxeXuJeeDiXSQoLkz/KYWbjgd+KXe4FDApfDwKOTrj+nAU+ARpIal5W+l54OJdBzAqSPiT1lfRpwtE3iSyamdn88PUvQLPwdUvgx4T75oXXSuUNps5lkgr0tphZf6B/ylmZmaSUF93ywsO5TBL9OI9fJTU3s/nhY8mC8PpPwNYJ97UKr5XKH1ucyyRp7G0pxZvAGeHrM4A3Eq6fHva6dAaWJTzelMhrHs5lkoJ1aUtK0ktAN6CxpHnAzcCdwBBJ5wDfAyeGt78N9ARmA6uAs8pL3wsP5zJJGh9bzKx3Kd/qUcK9BlxUkfS98HAuk2TR8PTNo80jR+w38p90euH/ANhy/13Y7/1/sN+of9LlzZup1bpZOQnE55CDuzFj+nhmzZzA1f9XoT8MscnJyeGDD9/klaFPxR1Kia6+5ypenzKUgSM3xLd9+7Y89ubDPP3uEzw5/FF26tAunuDSOM4japtF4bHdeYex4psNDce73nUOU/76CBN6XMvPr33E9pcfE2N0pcvJyeGhB//OEUeeym67d+ekk45m5513iDuscl341zP56qtv4w6jVCOGvsvVp1670bXzrz+PZ+9/jnMPuYBn7h3EBdcnM2QiAl54ZI4azRvR9C8d+fHFMRsumpFXtyYAefVqsebXJTFFV7a99+rIt99+x9y5P7Bu3TqGDHmDo448JO6wytSixVYccmh3nhs0JO5QSjV14jSWL12+0TUzqF2nNgC169Zm0a+L4wgNK1iX9BG3Kt/m0f720/nytsHk1dmwO9rUK/qz14vXUPC/teQvX81HPW+KMcLStWi5FT/O+3n9+byf5rP3Xh1jjKh8d/7rBm664S7q1K0ddygV8sgtj3H3i3dy4Y19UU4OF/e6NJ5AvM0DJDWTNEDSO+F5+7B7qNI0/UtH1i76nd+nzt3oepvzezKpz12M7ngx814ex863nVqZYVVZhxzanYULFzNlyvTyb84wvU4/kkdvfZwT9z6FR295nKvvuSqeQPyxBQhm9L0LtAjPvwb6lfWGxLH6I1bP/sMBNNy7HU0P2YPukx6i45OX0rjrLuz1wtXU3WVblk4Onsl/fuNjGnba8Q/nFYWff/qFrVu1WH/eqmVzfv75lxgjKlvnzntyWM8eTJ0xjmeefZADDuxC/6fvjTuspBxy/MGMf/sDAMa+NS6+BtPoB4mlTZSFR2MzGwIUAphZPlDmSidm1t/MOplZp0Nrbv+HA/jq7y8zuuPFjNnrUj4//yEWfTiDT8+4h2p1a1G7zVYANDlwt40aUzPJpE+nsP3229G69dZUq1aNE0/sxbC33os7rFLdess9tG+3H3/a5UDOPvMyxo/7mL7nXhl3WElZ/OsiOnTZHYA9unZk3tyYPhNZVPOIss1jpaQtAQMoGvIaYX5JsYJCpl7Znz2euRwKjXVLV/LF5U/GHVaJCgoKuKzfDbw9fDC5OTk8O+gVZs78Ou6wst6Nj1xHhy67U79RfYZOeomB9w7inqvv5+Jb/0puXi5r16zl3mvujye4DKhRJEvBwLIIEg5WInoY2BWYDjQBjjezqcm8f3iz3tEEFpFeS8bHHUKF1a5eo/ybMkzHBtvFHUKFjZ03Usneu3r4A0l/7mse3i/pdKMQWc3DzCZLOhBoBwj4yszi719yLpNlUc0jssJDUi3gCmBbMztP0g6S2pnZW1Hl6VzWy4C2jGRF2WA6EFgLdAnPfwLuiDA/57Kf97YA0NbM/gWsAzCzVQSPL8650nhvCwBrJdVkQ29LW2BNhPk5l/0yoEaRrCgLj5uBEcDWkl4EugJnRpifc9kvfzPfq1ZSDtAQOBboTPC4cpmZLYoiP+eqjIiGTkQhksLDzAolXR2OMB0eRR7OVUkZ0JaRrCgfW0ZKugp4BVhZdNHMim9C45wr4oUHACeFXxOXvzKgTYR5OpfdvMEUzCz7xhE7F7eCMueOZpQoR5geW8LlZcA0M1tQwvecc/7YAsA5BKNLi9b/6wZ8Bmwn6TYzez7CvJ3LTl54rE97ZzP7FYKVxYDngH2A8YAXHs4V520eAGxdVHCEFoTXfpPks2udK4EVbubjPEJjJb0FDA3Pjwuv1QaWRpivc9nLH1uAoIv2WGC/8PxToJmZrQS6R5ivc9kri3pbIptVG+59OQfIB44hKDC+jCo/56qEzXlWraQdgd7hsYhghKnMzGsbzpUnAwqFZEXx2DIL+AA4wsxmA0i6PIJ8nKt6smhiXBSPLccC84Exkp6S1ANfBMi55GTRY0vaCw8z+4+ZnQzsRDBArB/QVNLjkg5Od37OVSmFlvwRsyjntqwEBgODJTUETgCuAZLateik5Z9EFVokDt5q97hDqLDRC7JvW8ipy76PO4RopbG3JWwuOJdgQuo04CygOfAysCXBiO/TzGxtKulHuYbpema2JNwNrkdl5OdctrLCwqSPskhqCVwKdDKzXYFc4GTgLuB+M9seWEIwjSQllVJ4OOeSlN7HljygpqQ8oBZBW+SfgX+H3x8EHJ1qqF54OJdJKrD1QuLG8OHRd30yZj8B9wA/EBQaywgeU5aG+0YDzANaphpqlCNMnXMVVYGGUDPrD/Qv6XthO2MvYDuC6SBDgUPTEOF6Xng4l0ny09ZgehAw18wWAkh6jWAHgwaS8sLaRyuCzdhS4o8tzmWS9O0Y9wPQWVItSQJ6ADMJhk8cH95zBvBGqqF64eFcJklTg6mZTSRoGJ1M0E2bQ/CIcw1whaTZBN21A1IN1R9bnMsg5XXBVigts5sJNl9LNAfYOx3pe+HhXCbJgJGjyfLCw7lM4oWHcy4lWbQYkBcezmUQX8PUOZcaLzyccynJgHU6kuWFh3OZxGsezrmUeOHhnEuFFfhji3MuFV7zcM6lwrtqnXOp8cLDOZeS7Gny8MLDuUxi+dlTenjh4VwmyZ6yY/MpPLbYojrvvj+ELapXJy8vl//85x3+fscDcYe1icbNG3Pl/VfSsElDzIwRg0fwxjNvsN/h+9Hn8j5svf3WXH7U5Xwz9Zu4Q91Eq1bNGTDgfpo2bYKZMWDAYB599Jm4wyrXlOljWLFiJQUFheTn59PjwGNji8UbTDPQmjVrOfywU1i5chV5eXm8P2oo7707lkmTpsQd2kYKCgp4+o6n+Xb6t9SsXZOHhj/E5A8m8/1X33NH3zu45J+XxB1iqfLzC7jmmjuYMmU6derU5uOPhzNq1AfMmpV5BV1xRx1+Gr8tXhJ3GF7zyFQrV64CoFq1PKpVyyMTy/glC5awZEHwIV69cjU/zP6Bxls15vMPPo85svL98ssCfvllAQArVqxk1qzZtGy5VVYUHpkim2oeka5hKmlHSaMkTQ/P/yTphijzLEtOTg4ffTKcud9/yuhRE/g0w2odxTVt1ZS2u7Rl1uez4g6lwrbdthUdOuzCf/+b+YWemfHqfwYyevzrnHHWSfEGU1iBI2ZRL4D8FHAtsA7AzKYSbHlXosRNbNblL097MIWFhezb+XDa7dCFTp12p337HdOeR7rUqFWD65+8nv639mf1itVxh1MhtWvX4qWXnuSqq25l+fIVcYdTrp4H96b7/kdz4rHncM55fejSda/YYrH85I+4RV141DKz/xa7VuqPHe5n28nMOlXLqxtZUMuWLWf8+I856C8HRpbHH5Gbl8v1T17P2NfH8tGIj+IOp0Ly8vJ4+eUnefnl13njjRFxh5OU+fN/BWDRot8YPux99tzzT7HFkr6dF6IXdeGxSFJbgl26kXQ8wdZ3la5x40bUrx8USDVqbMGf/7w/X3/9bRyhlKvf3f34cfaPvP7063GHUmFPPnk3s2bN5qGHno47lKTUqlWTOnVqr3/dvcd+fDnz6/gCyqLHlqgbTC8i2CtiJ0k/AXOBUyPOs0TNtmpK/6fuITcnl5wc8dprwxnxzug4QilT+73a0+O4Hsz9ci4Pv/MwAIP+NYhq1atx4W0XUr9RfW4ZeAtzZs7hxtNujDnaje2771706XMc06Z9ycSJ7wBw003/4t13x8QcWemaNG3M84MfBYJa07+HDGPUyA9iiycTahTJkln0rbuSagM5ZpZ0Q0adWttlT7MzcEDjneMOocJGL5gedwgVVqvaFnGHUGG/Lf9Gyd67oMeBSX/um44al3S6UYi6t6WZpAHAv81suaT2ks6JMk/nspkVKOkjblG3eTwLvAu0CM+/BvpFnKdzWcsbTDdobGZDCJt3wp25s2djCucqmRUq6SNuUTeYrpS0JRt6WzoDyyLO07mslQk1imRFXXhcAbwJtJX0IdAEOD7iPJ3LWmbx1yiSFVnhISkXODA82gECvjKzdVHl6Vy285oHYGYFknqb2f3AjKjyca4qKcyAXpRkRf3Y8qGkR4BXgJVFF81scsT5OpeV0t0QKqkB8DSwK0Hb49nAVwS/k62B74ATzazC6xFEXXh0CL/elnDNgD9HnK9zWSmCXpQHgRFmdryk6kAt4DpglJndKelvwN+AayqacKSFh5l1jzJ956qadA74llQfOAA4M0jb1gJrJfUCuoW3DQLGks7CQ9LDUPp6OWZ2aXmJS7qihMvLgM/MLLMX03AuBhWpeUjqC/RNuNTfzPonnG8HLAQGStod+Ay4DGhmZkUTVH8BmqUSa1k1j09TSbCYTuExLDw/ApgKXCBpqJn9Kw15OFdlVKSrNiwo+pdxSx6wB3CJmU2U9CDBI0piGiYppfpOqYWHmQ1KJcFiWgF7mNkKAEk3A8MJqlKfAV54OJegIL29LfOAeWY2MTz/N0Hh8auk5mY2X1JzYEEqiZfb5iGpCcHzUHugRtF1M0um0bMpsCbhfB1BlWm1pDWlvMe5zVY6B4mZ2S+SfpTUzsy+AnoAM8PjDODO8OsbqaSfTIPpiwTdOocDF4SZLUwy/ReBiZKKgjsSGBxO0Z9ZwVidq/Ii6G25BHgx7GmZA5xFMKdtSDjD/XvgxFQSTqbw2NLMBki6zMzGAeMkTUomcTO7XdIIYN/w0gVmVtSW0ieFeJ2r0tK9vE7YMdGphG/1+KNpJ1N4FA0nny/pcOBnoFGyGZjZJEnfEz7ySNrGzH6ocKTObQYyYbZsspIpPO4I+4uvBB4G6gGXJ5O4pKOAewnW81gAbAPMAnZJKVrnqriCwqhXyUifcgsPM3srfLkMqOigr9uBzsBIM+soqTsxrWHqXDaohFVB0yaZ3paBlDBYzMzOTiL9dWa2WFKOpBwzGyMp8zaIdS5DFFaxKflvJbyuARxD0O6RjKWS6gDjCVp8F5AwQc45t7EqtZ6Hmb2aeC7pJWBCkun3AlYTtJH0Aeqz8SQ551yCKvXYUoIdCAZ/Jc3M8iV9DOwE/J7Me/o17ZJCaPF5bHFSvdcZZckLfcu/KcM8eGX27dtbEVXqsUXScjZu8/iF5GfgjQf2l9QQeA+YBJyEj/FwrkRVrbflj2waKzNbFY5ke8zM/iXJZ9M6V4osemopf+sFSaOSuVb629WFoKYxPLyWm3x4zm1eCk1JH3Eraz2PGgSrDjUOHzuKoq0HtEwy/X7AtcDrZjZDUhsgczcudS5mVaW35XyCX/4WBNPni36q34FHkkm8aC5MwvkcoNxFhJzbXGXR4ullrufxIPCgpEvM7OGKJCrpATPrJ2kYJQ8wO6rioTpX9RlVo+ZRpFBSAzNbChA+wvQ2s8fKeM/z4dd7/miAzm1O8qvIY0uR88zs0aITM1si6Tyg1MLDzD4Lv44LFxPCzJJdA8S5zVY21TyS6VTOlbT+Jwp3gqte3psk3SJpEcEeEV9LWijpptRDda7qK6zAEbdkCo8RwCuSekjqAbwEvFPWG8JV07sCe5lZIzNrCOwDdJWU1HR+5zZHhpI+4pbMY8s1BMu7XxCeTwW2Kuc9pwF/MbNFRRfMbI6kUwlGmt6fQqzOVXmZUKNIVjIjTAslTQTaEqx12Bh4tex3US2x4EhIa6GkailF6txmoCADahTJKmuQ2I5A7/BYRLAIcrK7wK1N8XvObdayaBXCMmses4APgCPMbDZABdordpdU0uxZkbB9g3NuY4VVoeYBHAucDIwJV0B/GZL7yczM5684l4IqMTHOzP5jZicTrMExhmCoelNJj0s6uLICdG5zUqW6as1spZkNNrMjCbaP/JwUdtR2zpWvUEr6iFuFVhIzsyUEG+uWtbmucy5FBXEHUAGpLEPonItIVeltcc5VsqrS2+Kcq2TZ1NvihYdzGcQfWzJE3hbVOPeVm8jdIo+c3FxmvDOR0fdvGFl/+M2ns8eJ3bh9l2Q2v4vHlOljWLFiJQUFheTn59PjwGPjDmkTL370Ja9N+gYDju20A6d23Zllq9Zw9cvj+XnpSlo0qM3dvQ+gXs0t4g4VgNwtqtFnyA3kVc9Debl89fZ/mXD/a/QZeiPVawdjGGs1rsf8Kd/yWt/K3eAwE7pgk1WlC4/8Net45pQ7WLtqDTl5uZz375v5euwXzPt8Ni12246a9WvHHWJSjjr8NH5bvCTuMEo0+9clvDbpG164sCfVcnO4aNAoDtipJa9O+oZ92jbn7AN35Zlx03lm3Az6HbpH3OECULBmHS/1/gfrws/Fqf++kTljv+DFE25ff88xT1zKN+9NrvzYsqjmkT2bRKRo7ao1AOTm5ZKblwtmKEccet0pjPjnSzFHl/3mLPid3bZuTM3qeeTl5rBn62aMmvEjY7+cx5Ed2wBwZMc2jPnyx5gj3di68HORk5dLTrW8jXZqq16nJtvuuwtfv/dZpceV7kFiknIlfS7prfB8O0kTJc2W9IqkctfmKU2khYekEyTVDV/fIOk1SZX650c54qK3/8HfPnuC2ROmMW/Kt3Q+4xBmjZzMioVLKzOUlJgZr/5nIKPHv84ZZ50Udzib2L5ZAyZ/t4Clq9awem0+E77+iV+XrWTxitU0qVcLgMZ1a7J4xeqYI92YcsRZb/+dSyc/xncfTGP+lG/Xf2/Hg/fkuw9nsDaGmCMYYXoZ8GXC+V3A/Wa2PbAEOCfVWKOuedxoZssl7QccBAwAHi/tZkl9JX0q6dPJy2enJQArNB7teR13d7mYVru3pfXeO7Frz3345Nl305J+1Hoe3Jvu+x/Niceewznn9aFL173iDmkjbZrW56wDduHCgSO5aNAo2jVvRE7OxnVvSSjDuiCt0BjY83oe7XwpzTu0pfGOrdZ/b+deXfjyzY/jiUvJH+WR1Ao4HHg6PBfwZ+Df4S2DgKNTjTXqwqNowNzhQH8zG04ZSxiaWX8z62Rmnfaou31aA/nf76uY+/FMtuvSnkatm3H5uPu5csKDVKtZncvH3pfWvNJp/vxfAVi06DeGD3ufPff8U8wRbeqYTjvw0kWH88x5h1C3ZnW23bIeW9apycLfVwGw8PdVNKqTmZOp1/y+ih8+mkmbbsG/a82GdWixextmj45nY8OK1DwS/9iGR/HNhx8ArmZDRWVLYKmZ5Yfn80h+D6ZNRF14/CTpSYL9ad+WtEUl5LlerUZ1qRFWnfO2qEbb/Xbj52lzuWuvv3Lvfpdx736XsW71Wu7vdkVlhVQhtWrVpE6d2utfd++xH1/O/DrmqDb1W1i9n790JaNn/MBhu2/HgTu1YtjncwAY9vkcuu3cqqwkKlXNRnXZIuFz0Xr/3Vg8+2cA2vXcm9mjplCwZl0ssRVU4Ej8Yxse66eNSDoCWFC0GHkUou5tORE4FLjHzJZKag78X8R5rle3aQOOu/dCcnJyUI6YPvwTvhr9eWVl/4c1adqY5wcHC9fn5eXx7yHDGDXyg5ij2tSVg8ezbNUa8nJzuPaovalXszpnH7grV780ntc/m02LBrX518kHxB3menWaNuCI+85H4edi1lsT+TasabQ/sgsfPz4sttjSOM6jK3CUpJ4Ea+jUAx4EGkjKC2sfrYCfUs1AZtGNaZPUFphnZmskdQP+BDxXtAdMWW5ofUo2DbbjscWT4g6hwn4aeEbcIVTYg1fOijuECvvb9y8kXSTcv82pSX/uL/8huXTD372rzOwISUOBV83sZUlPAFPL2YOpVFE/QrwKFEjanmAm7tbA4IjzdC5rVcJ6HtcAV0iaTdAGMiDVhKJ+bCk0s3xJxwIPm9nDkrLnucG5ShZFddvMxgJjw9dzgL3TkW7Uhcc6Sb2B04Ejw2u+erpzpcimuS1RP7acBXQB/m5mcyVtx4Z9bJ1zxVSktyVukdY8zGwmcGnC+VyCEW7OuRIUZtGk/EgLD0lzKeExzszaRJmvc9nKZ9Vu0CnhdQ3gBKBRxHk6l7Wyp94RcZuHmS1OOH4yswcIhqo750qQTVsvRP3YkjiDNoegJlKl1xBx7o/IV/bUPaL+Rb434XU+MJdgyLpzrgTZU3RE39uSzKbYzrlQJjyOJCvqxYD+IalBwnlDSXdEmadz2awQS/qIW9SDxA5LnAQX7jjXM+I8nctaVoEjblG3eeRK2sLM1gBIqglkxhLazmWgbHpsibrweBEYJWlgeH4WwdJnzrkSFGREnSI5UTeY3iXpC4L1SwFuN7PsWDzUuRh4zSMkqTbwnpmNkNQOaCepmpnFs8abcxnOsqjmEXWD6XighqSWwAjgNODZiPN0Lmtl0wjTqAsPmdkq4FjgcTM7Adgl4jydy1reVbuBJHUB+gDDw2u5EefpXNbyrtoN+gHXAq+b2QxJbYAxEefpXNbKz4hiITlR97aMA8YlnM8hYXEg59zGsqnBNJLCQ9IDZtZP0jBKXgzoqPLSGLn25yhCi8yKtZm1F2syul4yIu4QKmzitOfiDiFSmdAQmqyoah5F65TeE1H6zlVJm33No2iLOzMbJ6lJ+HphFHk5V5VkU80jst4WSbdIWgR8BXwtaaGkm6LKz7mqoMAs6SNukRQekq4g2CtzLzNrZGYNgX2ArpIujyJP56oCH+cRjCTtHW61AKzvaTmVYAMo51wJrAL/xS2qBtNqZrao+EUzWyjJd4xzrhTZ1OYRVeGxNsXvObdZy4THkWRFVXjsLun3Eq6LYP8W51wJMuFxJFlRddX6/BXnUpAJvSjJ8j1UnMsg2fTYEvWsWudcBaRzPQ9JW0saI2mmpBmSLguvN5L0vqRvwq8NU4nVCw/nMkiau2rzgSvNrD3QGbhIUnvgb8AoM9sBGBWeV5gXHs5lkHQOEjOz+WY2OXy9HPgSaAn0YsNC5IOAo1OJ1ds8nMsgFlGDqaTWQEdgItDMzOaH3/oFaJZKml7zcC6DFGBJH5L6Svo04ehbUpqS6gCvAv3MbKMhFBaUVimVWF7zcC6DVKS3xcz6A/3Luicc0f0q8KKZvRZe/lVSczObL6k5sCCVWL3m4VwGMbOkj/JIEjAA+NLM7kv41pvAGeHrM4A3UonVax7OZZA0j/PoSjBJdZqkKeG164A7gSGSzgG+B05MJXEvPJzLIOkcnm5mEwimhJSkxx9N3wsP5zKID093zqUkm4ane+HhXAbJpsKjSve2XH/f1bw99XVeHD1wo+snnH0ML49/jsFjBnLxDefHFF35+j95D/N+nMLnk0fGHUqZbr7vWkZOG8aQMZtui3Dq+Sczef4EGjSqH0NkG9zwj/s44PCTOfrUC9ZfW/b7cs697Dp6nnQO5152Hct+Xw7A8hUruejqmzn2jL/Sq8/5vD78vUqLM529LVGr0oXH8FdGcHmfqze6tse+HTjgkP047aBzOKX7Wbz4+CsxRVe+554fyhFHnhp3GOUaNuRtLj7lyk2uN2vRlC7d9mL+vF9iiGpjR/f8C0/cd8dG155+fgidO3Xg7VcG0LlTBwa8MASAl14dRtvW2/DaoMcY+Mhd3P3wU6xbt65S4vQ1TDPElIlT+X3J8o2uHXt6L557ZDDr1gYfhiWLl8YRWlImTJjIkiWZG1+RyZ98wbIlm679dOWtl/DA7Y9nxF/JTh12o369uhtdG/PBx/Q67CAAeh12EKPHfwyAJFauWo2ZsWr1/6hfry65uZWzRE02rWFapQuPkmzTdmt232c3Brz1GI+9+gA7794u7pCqpAMP2Y8Fvyzim5mz4w6lVIuXLKVJ40YANN6yIYvDgvqU445kznc/0r1XH445/UL+1u8CcnIq51elwAqTPuIW1XaTe5T1/aKZfnHIzc2lfoN6nHPEX2nfYSf+/uQtHNu5d1zhVEk1am7B2ZeezkUnZ88uG5IIBmTCh//9jJ12aMMzD9/Jjz/N57x+17Hn7rtQp3btyOPIhFpasqIqTu8Nj0cJZvH1B54KXz9a2psSJ/osWBXNXrUL5i9kzNvjAZg5ZRaFhYWxN+ZVNa22bUnLbZrz8qhneeu/Q2navAkvvvcMWzZpFHdoG9myYQMWLvoNgIWLfqNRg+Bz8Prw9znowK5IYptWLWjZfCvmfj+vUmLa7Ns8zKy7mXUH5gN7mFknM9uTYErwT2W8r394b6emtVpEERrjR0xgz64dAdi6TSuqVa/G0t+WRZLX5mr2rDkctNuRHLH3CRyx9wksmL+QPgefzeKFv8Ud2ka67deZN94JerLeeLBGKVUAAAx7SURBVGck3ffvAkDzZk345LNgNPei35bw3Q/zaNViq0qJyds8NmhnZtOKTsxsOrBzxHmud9tjN/LUsEfZtu3WvPnpUI7s3ZNhL79Ny21a8OLogdzx+E3cdtk/KyucCnv+uUcYP+4NdtyxLXO+ncSZZ54cd0gl+sdjt/DsW0+wbdtteOez1+jV+/C4Q9rE/918J33Ov5zvfphHj6NP5dVh73LuaSfy8aTJ9DzpHD759HPOPS2Y4nHBmacwZdpMjjntQs699Fou/+vZNGxQObXTQrOkj7gpymcsSS8BK4EXwkt9gDpmVm4jQ+cW3eL/16mAyYszt2GwNLs2ah13CBU2cdqmY0kyXbXGbUqbX7KJXZrtk/TnfsavE5NONwpRjzA9C7gQuCw8Hw88HnGezmWtTOhFSVakhYeZ/U/SE8DbZvZVlHk5VxVkwuNIsiJt85B0FDAFGBGed5D0ZpR5OpfNvMF0g5uBvYGlAGY2Bdgu4jydy1rZ1GAadZvHOjNbVjT4JhT/T+1chsqEGkWyoi48Zkg6BciVtANwKfBRxHk6l7UKrCDuEJIW9WPLJcAuwBpgMLCMDT0vzrlismlKftQ1j8PN7Hrg+qILkk4Ahkacr3NZKROGnScr6prHtUlec87hNQ8kHQb0BFpKeijhW/UINt91zpUgE3pRkhXVY8vPwKfAUcBnCdeXA9kzT9u5SrbZ97aY2RfAF5IGm1nlrN/mXBXgw9M3aC3pn0B7oEbRRTNrE3G+zmWlTGjLSFbUDaYDCSbC5QPdgefYMMPWOVdMNo0wjbrwqGlmowim/n9vZrcAmbfYg3MZYrPvbUmwRlIO8I2kiwlWEasTcZ7OZS0f57HBZUAtgmHpexLs2H1GxHk6l7W85hEys0nhyxUECwM558qw2fe2SBpGGbNnzeyoKPJ1LttlQkNosqKqedwTUbrOVWmZ8DiSrKgGiY0rei2pJrCNL0PoXPnSOcJU0qHAg0Au8LSZ3Zm2xIl+GcIj8WUInUtauhpMJeUSbLB2GMEgzd6S2qcz1qh7W27BlyF0LmlpHCS2NzDbzOaY2VrgZaBXOmPN2GUIP/l5bGR7Ukjqa2b9o0o/3bItXsi+mDMl3vy1PyX9uZfUF+ibcKl/ws/QEvgx4XvzgH3+eIQbRF3z2GgZQkkPkxnLEPYt/5aMkm3xQvbFnG3xbrQ9a3hUauEXxzKE/SLO0zkXjObeOuG8FWXsE52KyB5bwgab4eGG19eXd79zLq0mATtI2o6g0DgZOCWdGURWeJhZgaRCSfXNLNO2oY/92baCsi1eyL6Ysy3eMplZfjif7F2CrtpnzGxGOvOIeqPrN4COwPsEG14DYGaXRpapc65SRN3b8lp4OOeqmEhrHs65qivqEaZdJb0v6WtJcyTNlTQnzXkcLckk7ZTOdFMlqUDSFEkzJH0h6cpwTRMkdSq2mnzGyeT4JbWWNL3YtVskXZWGtLtJequcezpI6plC2mMldUo9uswU9WPLAILV0j8DotpHrzcwIfx6c7JvkpRrFsnefqvNrEOYR1OCLup6wM1m9inBqvKRkJRnZn90a4vY4o9aGv59OgCdgLfTFFJ2q8hY+ooewMSI069D0A21I/BVeC0HeAyYRdBQ+zZwfPi974C7gMkEXVcHAx+H50OBOuF9ewLjCAq9d4HmFYhpRbHzNsBiQEA34K3w+oEE836mAJ8DdcOfZ1QYzzSgV0I6NwJfERSULwFXhdfHAg8Q/FJfWVrsQFuCOUafAR8AO6U7/vD6NWHsXwB3JsTYKXzdGPgufL0L8N8wjanADkBtYHj4/unASQmxtAamF4vvFuCqMI+7wvS+BvYPv38m8CYwOvx3qQ08E973edG/cbGfbe/wc/E5waDGdkB14AdgYRjvSWWkVZNgOPiXwOvAxKKfvyodURcedwJ3A12APYqONKbfBxgQvv4o/MU5nqDAyAG2ApawceFxdcKHeDxQO+FDfxNQLUyrSXj9JIJurpQKj/DaUqBZsQ/oMKBr+LoOQS0wD6iXEN9sgl/avcIPbA2CQuYbNi48Hgtflxo7QaG0Q/h6H2B0BPEfFuZfK7zeKCHGkgqPh4E+4evq4S/dccBTCXnXT3jdmrILj3vDaz2BkeHrMwmGZhfF8g/g1PB1A4KCpnaxn60ekBe+Pgh4NSGtRxLyLi2tKxL+3f9EsAB4lSs8on5sKRpLv2f4VQRzW/6cpvR7E0w5hqCk703wIR5qZoXAL5LGFHvPK+HXzgSzDT8M595UJ/hr0w7YFXg/vJ4LzE9TvIk+BO6T9CLwmpnNk1QN+IekA4BCgvkJzYCuwBtm9j/gf+FiSyX9TCXGLqkOsC8wNGGe0RYRxH8QMNDMVgGY2W/lpPExcL2kVmEa30iaBtwr6S6CX+YPEu4vrXW/6HpRz95nBAVNkfcTYjkYOCqhnaQGsE2x9OoDgyTtEKZdrZR8S0vrAOAhADObKmlqKe/PalGtJHZF+LKoAcoIqnsTzGxumvJoRFAI7SbJCH5RjKCaWJai8SYi+FD1LpbubsAMM+uSpjjbELT3LAB2LrpuZndKGk7wV/JDSYcQFGhNgD3NbJ2k70jY76YMiT/TJrFLqgcstbAtI8L4S5PPhsb5xP17BkuaSLCi/tuSzjez0ZL2CNO9Q9IoM7stfMtioGGxtBsBRZ+pNeHXAjb+bK9MeC3gOCu2voykZgmntwNjzOwYSa0JajUlKS2tUm6vWqLqbanLhmf4OuHrTsA7kk5OUx7HA8+b2bZm1trMtib4EP0GHCcpJ/xAdCvl/Z8AXSVtDyCptqQdCdoVmkjqEl6vJmmXVAKU1AR4gqCqa8W+19bMppnZXQRDiXci+Iu3ICw4ugPbhrd/CBwpqUZYiziilCxLjN3MfgfmSjohvC5Ju0cQ//vAWZJqhfc0Cm//jg21z+MT0mgDzDGzh4A3gD9JagGsMrMXCB559yi638xWENSk/pyQ/qEE7UDJehe4ROFvuKSOJdxTnw3zQM5MuL6c4LNcXlrjCYeCS9qV4NGlyolqJbFbS7oe/s8eSfCI8Uf1JmggS/QqwV/HecBMginJkwkm5BWPcaGkM4GXJBVV4W8ws68lHQ88JKk+wb/RA0CyQ3trSppCUNXNB54H7ivhvn5hAVEYpv0OwQdzWFh1/5Sg0Rczm6RgEaWpwK8EDZIl/Uxry4i9D/C4pBvC2F4maJRMW/xmtkZSB+BTSWsJ2p6uI1iWcoiCKeTDE9I4EThN0jrgF4I2hL2AuyUVAuuAC4vlezrwqKSimG41s28r8Nf+9vDfZGrYBT2XTQvjfxE8ttxQLN4xwN/Cf59/lpHW48BASV8SNJom7tdcZVT6IDFJn5tZSaV9OvOoY2YrJG1J0BLe1cx+iTLPqCX8TLUI/rL1NbPJccflNl9RN5huJPxLtaQSsnpLUgOCRtDbs73gCPVXsIxcDWCQFxwubpHUPMJqd/GEGwE/A6eb2ay0Z+qcq1RRFR7bFrtkwGIzW1nS/c657OMT45xzKYl6GULnXBXlhUcW0IaZrtMlDS0aR5FiWs+G3blIelpl7OWhYKbpvink8Z2kxqnG6LKDFx7ZYbWZdTCzXYG1wAWJ35SUUq+ZmZ1rZjPLuKUbwbB25zbhhUf2+QDYPqwVfBAOHpspKVfS3ZImSZoq6XxYP5r0EUlfSRoJNC1KSAnrTEg6VNJkBWt4jAqHZV8AXB7WevaX1ETSq2EekyR1Dd+7paT3FKwB8jTBsG1XxVXqOA/3x4Q1jMMIt+8kGLq9q5nNDUdvLjOzvcIRsx9Keo9gDdl2BJMAmxGMvH2mWLpNgKeAA8K0GpnZb5KeIJhle09432DgfjObIGkbguHZOxOsozLBzG6TdDhwTqT/EC4jeOGRHYqGjENQ8xhA8Djx34SJhgcTzA0pmjtSn2B9jAOAlyxY+OhnSaNLSL8zML4orTJmwx4EtE8YCl4vnGtzAHBs+N7hkipjIKCLmRce2WH96l5Fwl/g4rNFLzGzd4vdV+Fl88qQA3QOlwYoHovbzHibR9XxLnChgjVBkLSjpNoE82BOCttEmgPdS3jvJ8ABCjYISpwNW3wW6XsEuwAS3ldUoCXOIj2MTafNuyrIC4+q42mC9ozJChYJfpKgZvk6wcpjM4HnCBbg2YiZLSTYq/U1SV+wYXGhYcAxRQ2mwKVAp7BBdiYben1uJSh8ZhA8vvwQ0c/oMoiPMHXOpcRrHs65lHjh4ZxLiRcezrmUeOHhnEuJFx7OuZR44eGcS4kXHs65lPw/BIjf6ijj8b4AAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.48      0.69      0.56        70\n",
            "    Disagree       0.78      0.68      0.72        31\n",
            "     Discuss       0.82      0.54      0.65       166\n",
            "   Unrelated       0.64      0.78      0.70       139\n",
            "\n",
            "    accuracy                           0.66       406\n",
            "   macro avg       0.68      0.67      0.66       406\n",
            "weighted avg       0.70      0.66      0.66       406\n",
            "\n",
            "accuracy :  0.6576354679802956\n",
            "weighted f1 score :  0.6596193020786388\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mU9YGiP-punL",
        "outputId": "ac67361f-0d2a-4310-8e8f-226449ecece0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 619
        }
      },
      "source": [
        "# with \"l1_ratio\": [0.2]\n",
        "model = LogisticRegression(C=1, class_weight='balanced', dual=False, fit_intercept=True,\n",
        "                   intercept_scaling=1, l1_ratio=0.2, max_iter=1000,\n",
        "                   multi_class='ovr', n_jobs=None, penalty='elasticnet',\n",
        "                   random_state=None, solver='saga', tol=0.0001, verbose=0,\n",
        "                   warm_start=False)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "LogisticRegression\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.48      0.69      0.57        70\n",
            "    Disagree       0.76      0.71      0.73        31\n",
            "     Discuss       0.81      0.55      0.65       166\n",
            "   Unrelated       0.64      0.76      0.70       139\n",
            "\n",
            "    accuracy                           0.66       406\n",
            "   macro avg       0.67      0.68      0.66       406\n",
            "weighted avg       0.69      0.66      0.66       406\n",
            "\n",
            "accuracy :  0.6576354679802956\n",
            "weighted f1 score :  0.659402945370372\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GeLKyoRVpl8-",
        "outputId": "70608a0b-6e53-4087-dad6-245baa618416",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 619
        }
      },
      "source": [
        "# with \"l1_ratio\": [0.3]\n",
        "model = LogisticRegression(C=1, class_weight='balanced', dual=False, fit_intercept=True,\n",
        "                   intercept_scaling=1, l1_ratio=0.3, max_iter=1000,\n",
        "                   multi_class='ovr', n_jobs=None, penalty='elasticnet',\n",
        "                   random_state=None, solver='saga', tol=0.0001, verbose=0,\n",
        "                   warm_start=False)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "LogisticRegression\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.50      0.71      0.59        70\n",
            "    Disagree       0.73      0.71      0.72        31\n",
            "     Discuss       0.81      0.55      0.65       166\n",
            "   Unrelated       0.65      0.76      0.70       139\n",
            "\n",
            "    accuracy                           0.66       406\n",
            "   macro avg       0.67      0.68      0.67       406\n",
            "weighted avg       0.69      0.66      0.66       406\n",
            "\n",
            "accuracy :  0.6625615763546798\n",
            "weighted f1 score :  0.6635468562009657\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FDzDsGUDVwwV"
      },
      "source": [
        "### Gussian Naive Bays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OoaiTAWLN6Ko",
        "outputId": "5ffc5976-786a-4357-e359-f164a8429b67",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 620
        }
      },
      "source": [
        "model = GaussianNB()\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "GaussianNB\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQkAAAEHCAYAAAC9YrMUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3dd3wU1frH8c83hV4kgogFRRQUKxoLYsHeu6Jc6716Ua8N1Ou1/qzXhgp2L4KIHTsWrNiwgSCKiKKIoCBIk96S7PP7YyawhGSzgZ0t5HnzmldmZmfPeRI2J6fNGZkZzjlXlbxMB+Ccy25eSDjnEvJCwjmXkBcSzrmEvJBwziXkhYRzLqGCTAdQlbmn7p9TY7PNXxif6RBqrENR60yHUGPb1G2Z6RBqbNDkV5XstSWzJib9uS9svkW16UpaD+gHbAcY8A9gPDAI2ByYBHQ1s7+qSsNrEs6t2+4F3jazrYEdgR+AK4GhZrYVMDQ8rpIXEs5lk1hZ8ls1JDUF9gH6A5jZcjObCxwDDAwvGwgcmyidrG1uOFcrlZWmMrU2wExggKQdgVHAJUBLM5sWXjMdSNiG85qEc1nELJb0Jqm7pJFxW/cKyRUAOwMPm1lHYBEVmhYW3JeRsB/EaxLOZZNYLOlLzawv0DfBJVOAKWY2PDx+kaCQ+FNSKzObJqkVMCNRPl6TcC6bWCz5rbqkzKYDv0tqH546ABgHvAacGZ47ExicKB2vSTiXTZLokKyhi4CnJdUBJgJ/J6gcPC/pbGAy0DVRAl5IOJdNkqgh1Cg5s2+A4kpeOiDZNLyQcC6LWGpHN1LCCwnnskkNOi7TxQsJ57JJipsbqeCFhHPZJPUdl2vNCwnnsonXJJxzCXnHpXMuIe+4dM4lYuZ9Es65RLxPwjmXkDc3nHMJeU3COZdQWUmmI1iNFxLOZRNvbjjnEvLmRoYoj0a3PIz9NYtFd11DnYOOpe6hJ5C/4cbMO/dYbOH8TEdYqbp16/LRBy9Rp25dCgryefnlN7nxprszHdZqbux9DfsetCdzZv3F8V1OA6DJek3o9b+b2WjTVvzx+zQu734tC+YtyHCkgfN6XcjO+xczf/Y8Lj/4khXnDz3rCA4+/TBisRijPxjF07cNTJBKRLKwJlErVqaqe+jxxP74bcVx2U9jWXTb5cRmTs9gVNVbtmwZBx7clV2KD2KX4oM55OAu7L7bzpkOazWvDXqT87v1XOXc2RedzvBhIzlqz64MHzaSsy86PUPRre7jFz7gtjNvWuXctp22o/ig3bjisB5cftDFvN731cwEF4slv6XJOl9IqKg5BTvtwfIPh6w4VzZ5ArFZf2YwquQtWrQYgMLCAgoKCwnWLc0uo778hnlzV62N7XfI3rz2fPAzf+35Iex/6D6ZCK1SP4wYx8K5C1c5d9BphzH4oZcoXR5Mi54/e14mQsPKSpLe0iWyQkJSS0n9Jb0VHncIl8tKq/qnX8DSZ/+XlW29ZOTl5THyq3eZNnUMQ4d+woivRmc6pKQUtShi1ozZAMyaMZuiFkUZjiixVm02YuvdOnDLq3dy/aBbaLvDlpkJJIVrXKZKlDWJx4F3gI3C45+AHhHmt5qCjntg8+ZSNunndGabUrFYjOJdD2azNsXsWtyRbbdtX/2bslEW1oDi5Rfk0Wi9xlx77BU8detAejz078wEUsuaG83N7HkgBmBmpUDCienxzxF4fMIfax1AQbvtKNxlT5r0eYYGF15HQYeONDj/qrVONxPmzZvPRx9/xiEHd8l0KEmZM3MOzTdYH4DmG6zPnFlVPmoyK8yeNpsRb38BwC/f/kwsZjQuapL+QGpZTWKRpPUJH/whaQ8gYUPPzPqaWbGZFZ+15UaJLk3K0kH9mH/Ryczv8TcWP3AzpeNGs/jh29Y63XRp3ryIpk2DD2q9evU48IB9GD/+lwxHlZyP3v2Uo7seDsDRXQ/nw3eGZTiixL56dzgdOm0PBE2PgsICFszJwKhXFtYkohwCvZRgff+2kj4DWgAnRphf0uocchz1jjwFNS2i8e39KPlmOEv6Zd/QYqtWLXmsfx/y8/PIy8vjxRdf580h72c6rNXc8fCNFO+5M+sVrcd7Xw/moV796H//E9zV978c97ejmDZlOpd3vzbTYa5w8X2X0qHTdjRu1oSHvuzHC72f48Pnh3J+rwu56917KS0p5aHL7s1McFnYd6Yoe8slFQDtAQHjzSzpLtm5p+6f3Y3YCpq/MD7TIdRYh6LWmQ6hxrapm/CxlVlp0ORXley1S97sk/Tnvv4RPZJOd21EVpOQ1ICgNrGZmf1T0laS2pvZG1Hl6VzOy8KaRJR9EgOA5UCn8HgqcEuE+TmX+7KwTyLKQqKtmd0JlACY2WKCZodzripZOLoRZcflckn1WTm60RZYFmF+zuW+LLx3I8pC4nrgbWBTSU8DnYGzIszPudyXhX0SkRQSkvKAZsDxwB4EzYxLzGxWFPk5t84orSVL6ptZTNIV4YzLN6PIw7l1UoqnJEiaBCwgmO1cambFkoqAQcDmwCSgq5lVOSU2yo7L9yVdLmlTSUXlW4T5OZf7ohnd2M/MdjKz4vD4SmComW0FDA2PqxRln8TJ4dcL4s4ZsEWEeTqX29LTcXkM0CXcHwh8BPynqosjKyTMrE1UaTu3zkp9x6UB70oy4H9m1hdoaWbTwtenAwmnsUY54/L4Sk7PA74zsxlR5etcTitL/glekroD3eNO9Q0LgXh7mdlUSRsA70n6Mf5FM7OwAKlSlM2NswlmW34YHncBRgFtJN1kZk9GmLdzuakGzY2wQKhYKFS8Zmr4dYakV4DdgD8ltTKzaZJaAQn/aEfZcVkAbGNmJ5jZCUAHgqrP7iRo/zhXq6Ww41JSQ0mNy/eBg4GxBHdnnxlediYwOFE6UdYkNjWz+IUkZ4Tn5kjKvieQOJcNUtsn0RJ4RRIEv+vPmNnbkr4Cng+Xk5wMdE2USJSFxEeS3gBeCI9PCM81BOZGmK9zOctiqZsnYWYTgR0rOT8bOCDZdKIsJC4gmHG5V3g8kqBXdRGwX4T5Ope7svDejcj6JCxYzWYiUAocR1Aw/BBVfs6tE8rKkt/SJOU1CUntgG7hNotg+qfMzGsPzlUnC2sSUTQ3fgSGAUea2QQAST0Tv8U5B2RlIRFFc+N4YBrwoaRHJR2ALzbjXHLMkt/SJOWFhJm9amanAFsTTKTqAWwg6WFJB6c6P+fWKbVp+TozW2Rmz5jZUcAmwGh8EpVzicUs+S1NohwCXSG8V73aKaTxNnxpQnQBReCIDTtmOoQa+3xe7j3+cNqSOZkOIVppHLVIVloKCedcciwLOy69kHAum6SxGZEsLyScyya1ZSFc59wa8pqEcy6hUu+4dM4l4s0N51xC3txwziXiQ6DOucS8JuGcS8gLCedcQj4t2zmXSCrXuEwVLyScyyZeSDjnEvLRDedcQl6TcM4l5IWEcy4RK/PmhnMuEa9JOOcS8SFQ51xiWVhIRLZatnNuDcRqsCVBUr6k0eHDu5HURtJwSRMkDZJUp7o0vJBwLotYaSzpLUmXsOozeO8AepvZlsBfwNnVJVDrCom8vDy+/HIIL788INOhVOqiXpcw8OunuO+9B1ecO6Xn33hsxEB6v3Ufvd+6j132K85ghIk1adqYx564l8+/eovPRgyheNedMh1StbIq5hTWJCRtAhwB9AuPBewPvBheMhA4trp0al2fxIUX/oPx4yfQuHHjTIdSqaEvvM+bA9+gR+9LVzn/Wr9XebXvKxmKKnm33n4NH7w/jH+ccQmFhYXUb1Av0yFVK5tiTnHHZR/gCqD8w74+MNfMSsPjKcDG1SVSq2oSG2+8IYcddgADBjyX6VCqNG7E9yycuyDTYayRxk0asUfnXXnqieAPVUlJCfPnZff3knUx16AmIam7pJFxW/fyZCQdCcwws1FrG1KkhYSkdpKGShobHu8g6doo80ykV68buPrqW4ll4fz46hx+5pHc+879XNTrEho2bZjpcCq12WabMHvWHO5/6DY+GPYKve+/hQYN6mc6rISyLWaLWfKbWV8zK47b4p+Q1xk4WtIk4DmCZsa9wHqSylsQmwBTq4sp6prEo8BVQAmAmY0BTok4z0oddtgBzJw5i9Gjv8tE9mvlrSeHcN7e/6THoRfz14w5/OPaczIdUqXyCwrYYccODOj/LPvvfRyLFy3h4p7dq39jBmVdzCnqkzCzq8xsEzPbnOB37gMzO5XgId4nhpedCQyuLqSoC4kGZjaiwrnSSq9k1epTWdnClAay557FHHHEQYwf/xlPPPEAXbrsyYABfVKaR1TmzZpLLBbDzHj32XfYaqd2mQ6pUtOmTuePqdP5etQYAF4f/DY77Nghw1Ellm0xW2ny2xr6D3CppAkEfRT9q3tD1IXELEltAQOQdCIwraqL46tP+fmNUhrIddfdwZZb7k779p0544wL+eijz/n733ukNI+oNNug2Yr9PQ7pxG/jJ2cwmqrNmDGLP6ZOp+2WbQDYe99OjB//S4ajSizbYrZY8lvSaZp9ZGZHhvsTzWw3M9vSzE4ys2XVvT/q0Y0LCJ4kvrWkqcCvwGkR55nTLrv/32zXaXuaNGtC/+GP8+w9T7Ndp+1p02ELMGPGlBk8dNUDmQ6zSlddcTOP9LuLwsJCJk/6nYsvuCrTIVUrq2LOwu4ymUU/DVRSQyDPzJLuNq5Xr3X2zU9N4JANdsh0CDX2+byfMx1CrTBz3nglfe1B+yb9uW/x3sdJp7s2oh7daCmpP/CimS2Q1EFStTO8nKutomhurK2o+yQeB94BNgqPfwJyoyPAuQywMiW9pUvUhURzM3uesKUVzvTKvjXDncsS2ViTiLrjcpGk9Vk5urEHMC/iPJ3LWRZLXw0hWVEXEpcCrwFtJX0GtGDlRA7nXAVZ+FDx6AoJSfnAvuHWHhAw3sxKosrTuVxnln01icj6JMysDOhmZqVm9r2ZjfUCwrnEamOfxGeSHgAGAYvKT5rZ1xHn61xOiqVx1CJZURcS5at33BR3zgjuSHPOVVDrOi7NbL8o03duXZNThYSk+wmHLitjZhdXl7ikSys5PQ8YZWbfJBWhc7VIGu6SqLFENYmRKUi/ONxeD4+PBMYA50l6wczuTEEezq0zcqomYWYDU5D+JsDOZrYQQNL1wJvAPsAowAsJ5+Jk4xBotX0SkloQLFTRAVixQqiZJdP5uAEQf796CdDSzJZIqvY+dudqm7IcHd14mmAI8wjgPIIlr2Ymmf7TwHBJ5UtkHQU8E946Pq6GsTq3zsvJmgSwvpn1l3SJmX0MfCzpq2QSN7ObJb0N7BmeOs/Myvs6Tl2DeJ1bp+VUn0Sc8lmS0yQdAfwBFCWbgZl9JWkyYVNFUmsz+63GkTpXC+Ta6Ea5WyQ1BS4D7geaAD2TSVzS0cDdBOtJzABaAz8C265RtM6t43KyJmFmb4S784CaTo66GdgDeN/MOkraD1/j0rkqlcWy73lZyYxuDKCSSVVm9o8k0i8xs9mS8iTlmdmHknJjHXvnMiBXmxtvxO3XA44j6JdIxlxJjYBPgKclzSDuRi/n3KpiuTi6YWYvxR9Lehb4NMn0jwGWEPRhnAo0ZdWbvZxzcXJ1CLSirQgmSSXNzEolfQFsDcxfgzydqxVysrkhaQGr9klMJ5iBmYxPgL0lNQPeBb4CTiaJORJ/DbowySyyw/cXfJ7pEGqsw3V7ZzqEGpv2+O+ZDiFSudrcaLwW6cvMFofP2njIzO6U5Hd/OleFbBzdqDYiSUOTOVf129WJoObwZnguP/nwnKtdrAZbuiRaT6Ie0ABoHjYXyutBTYCNk0y/B3AV8IqZfS9pC4JHnzvnKpFrzY1zCX7JNyK4rbs8+vlAUk+sLb/XI+54IlDtYjXO1VapHN0I/9B/AtQl+F1/0cyul9QGeA5Yn+B3+3QzW15VOonWk7gXuFfSRWZ2fw2D62NmPSS9TuUTsY6uSXrO1RYpXgR7GbC/mS2UVAh8Kuktgufh9Daz5yQ9ApwNPFxVIskMgcYkrWdmcwHCpkc3M3sowXueDL/elcx34pwLGKmrSZiZAQvDw8JwK1+I+m/h+YHADaxlIfFPM3swLuO/JP0TqLKQMLNR4dePw0VrMLNk16BwrtYqTXGfRPiQrFHAlsCDwC/A3PC5vABTqKaPMZnxlnxJKyIPM62TRHA3SJoFjAd+kjRT0v8lkZ9ztZahpDdJ3SWNjNu6r5aeWZmZ7USwlORuBBMaaySZmsTbwCBJ/wuPzwXeSvSGcJXszsCuZvZreG4L4GFJPc2sd00Dda42qEmfhJn1Bfomee1cSR8CnYD1JBWEtYlNgKmJ3ptMTeI/wAcES9edB3wH1K/mPacT9Fv8GhfkRILbxM9IIk/naqWa1CSqI6mFpPXC/frAQcAPBNMQyh/cfSYwuPIUAsnMuIxJGg60BboCzYGXEr+LQjObVUlaM8NeVudcJVI8utEKGBh2EeQBz5vZG5LGAc9JugUYDfRPlEiiyVTtgG7hNotgMdxkn8pV5ZhrNa85V6uVpXZ0YwzQsZLzEwn6J5KSqCbxIzAMONLMJgBISmrZOmBHSZXd7SniluV3zq0qC1evS1hIHA+cAnwYrnj9HCRXzJmZ35/h3BqIpbAmkSpVdlya2atmdgrBkMmHBFO0N5D0sKSD0xWgc7VJNt7gVe3ohpktMrNnzOwoguGS0SS/noRzrgZiNdjSpUYrU5nZXwTjskmNzTrnaiam7GturMnydc65iJRlOoBKeCHhXBbJtdEN51yaZePohhcSzmWRLFwse90vJA67bRAN6xaSJ1GQl8czlxzDPW+M4JMffqMwP49N1m/CjV33pkn9upkOFQDVLWTrl/6L6hSi/Hz+GvI5f9z9HG3u70nDHbbESkpZ9M3PTL7yYaw0i1qwEvVOuw5b+BfLXrmfuqdcgeqE8+YaNCE27VeWD34wcRppojqFbDTw7hU/44XvDeOvB5+kxS2XUb94B2ILg+dHzbjmLpaPn5jW2Ly5kSGPnns4zRqunOi5R7uNuPiwYgry8+gzZASPffgtPQ5PepZqpGxZCeO7/h+xxUtRQT7tX7mNeR9+zZxXPuHXi4KbZ9s8cCnNux3EzCffznC0KxXsfCCxOdNWFAzLnrtzxWt1jj6fsgnZs0i6LS/hj39cgS1ZCgX5bPzEPSwe9hUAs+9+lEXvJfvsqdRL59BmsrJv/e402LPdJhTkB9/6Dq034M+5izMc0apii5cCoIJ8VJAPZsz7YNSK1xd/8zN1Wq2fqfBWo0bNyN9iB0rHDFv9xTr1yG+9NWUTRqc/sARsSfnPuGDFzzgblCn5LV3W+UJCwPmPvk23e1/lxS9/XO31V7/6ib223iT9gSWSl0eHd3qz47cDmT/sWxaN/nnFSyrIp+iELsz7KHt+6Qr3P5nln7xIZS3q/C07UvbbD7B8afoDSyQvj01efIjNPxnE4i9Gs+y78QAUXXwWm7z8MOtfcS4Upv+G5WycTBVpISHpJEmNw/1rJb0saeco86xowL+O5Lkex/Lg2Yfw/Bc/MGritBWvPTr0G/Lz8ji8Y9t0hlS9WIxxh/RkzK7n0HCnrajXvvWKl1rfei4Lh49j4YhxGQxwpbwtdsAWL8D+nFzp6wXb7EbZDyPSHFUSYjGmnPgvJh9wKvW2b0+dLTdjTp8B/H7UOUw5+WLymzam2dld0x9WDbZ0ibomcZ2ZLZC0F3AgwX3rVS64Gb8cV/93hqckgJZNGwJQ1Kg++227GWN/D5a5GDzyJ4b98Bu3duuCsnCWG0DZ/EUs+Pw7mnYJ7vZt1fNkCoqa8vuNj2U4spXyN96S/LY7Uu+ft1P3yO7ktd6aOoefE7xYvxF5G7ahbOKYzAaZQGzBIpaM+Jb6e+1K2aw5wcmSEua/+i51t2+f9nhMyW/pEnUhUd79fgTQ18zeJMH6mGbW18yKzaz47EN2X+vMlywvYdHS5Sv2v/h5Kltu2IzPxk9h4Eff0eesg6hfJ7v6bguKmpDfJCjYVK8OTfbeiaUTptK824E03bcjEy+8O2vazwAlw15m6f+uYOmjV7Lsjb7EfvuR5UP6AVDQbpeggCgrrSaV9Mpr1pS8xuHPuG4d6nfamZJffye/edGKaxruvyfLf56U9tiysSYR9W/I1HBtzIOAOyTVJY39ILMXLOHSJ4InEpbGYhy2U1s6t9+Eo+54nuWlMc57NBgd2KH1Blx7Qud0hZVQYctmtOl9CeTnIYk5b3zGvKEj2WXSSyybMpNtBt8BwF9vfcG0Ps9nONrE8rfejZLhQzIdxmoKWhSxwX8vD3/GeSx85xMWfzycjfrfQV6zpkhi2fhfmHnjfWmPLYsGtVeQRfhXSVID4FDgOzP7WVIrYHsze7e69y4ZfGf2/LlMQk4+VbxH80yHUGO5+FTxtmPfSbpxcG/r05L+3F/y21NpaXREXZNoBbxpZsskdQF2AJ6IOE/nclZtnCfxElAmaUuC28s3BZ6JOE/nclY29klEXUjEwrX9jwfuN7N/E9QunHOVyMaVqaJubpRI6kbwrI2jwnO+pL5zVcjGezeirkn8neCJQf81s1/DR54/Wc17nKu1ymqwpUukNQkzGwdcHHf8K3BHlHk6l8tiWXizeKSFhKRfqaT5ZGZbRJmvc7kqG0c3ou6TKI7brwecBBRVca1ztV721SMi7pMws9lx21Qz60MwRds5V4lsHAKNurkRf8dnHkHNIrtulnAui5Qq++oSUf/C3h23Xwr8SvBkcudcJVJZREjalGCGc8sw6b5mdq+kIoIHgG8OTAK6hs/UqVTUoxvJPIHcORdKcTOiFLjMzL4O13UZJek94CxgqJndLulK4EoSPJUv6kVnbpW0XtxxM0m3RJmnc7kshiW9VcfMppnZ1+H+AuAHYGPgGGBgeNlA4NhE6UQ9meowM5tbfhBWaQ6POE/nclZU07IlbQ50BIYDLc2sfIm26QTNkSpFXUjkh2tIACCpPpAda9c7l4VqMroRv5JbuHWvLE1JjQhutuxhZvPjX7NgrYiEZU7UHZdPA0MlDQiP/87Kao5zroKyGtQRzKzah3dLKiQoIJ42s5fD039KamVm08I1XmYkSiPqjss7JH1LsL4lwM1m9k6UeTqXy1LZcalg8db+wA9mdk/cS68BZwK3h18HJ0on6nkSDYF3zextSe2B9pIKzawkynydy1WW2jmXnYHTge8klT8d6WqCwuF5SWcDk6lmWkLUzY1PgL0lNQPeBkYCJwOnRpyvczkplTUJM/sUqnwC8QHJphN1x6XMbDHBojMPm9lJwLYR5+lczkrlEGiqRF5ISOpEUHN4MzyXH3GezuWs2rgyVQ/gKuAVM/te0hbAhxHn6VzOKs3C+0CjHt34GPg47ngicYvQOOdWleKOy5SIpJCQ1MfMekh6ncoXnTm62sA6nxhFaJEZkv9tpkOosXvvn5PpEGqsd4cse/BwitWmRWfK17G8K6L0nVsn1ZqahJmNCr9+LKlFuD8zirycW5dkY00istENSTdImgWMB36SNFPS/0WVn3PrgjKzpLd0iaSQkHQpwWyvXc2syMyaAbsDnSX1jCJP59YFtWmexOlAt3AJfWDFyMZpBA/qcc5VwmrwL12i6rgsNLNZFU+a2czwrjTnXCWysU8iqkJi+Rq+5lytVpsezrOjpPmVnBfB8zecc5WoTUOgfn+Gc2sgnaMWyfJnYDiXRWpTc8M5twZqU8elc24N1Jo+CefcmvHmhnMuIfOOS+dcIjVZUj9dvJBwLot4c8M5l5A3N5xzCXlNwjmXkA+BOucS8mnZzrmEvLnhnEvIC4kMmL9gIdff3ocJEyeDxM1X9+TPGbN4qP9TTJz8O88+2ofttmmX6TBXaNKqiGN7n0/D5k0xM75+5gNGDHiHA6/uRrsDdqaspJS/Jv/J4H/3Zdn8xZkOF4Bzel1Ax/2LmT97Hlcd3AOACx64jFZbbARAgyYNWTx/Edceflkmw1ypsA5Ne92HCgshP5/ln37M4qcGULhjRxqe8y8oKKB0wk8s7H0nxMrSGpqPbmTA7X0eofPuxfT+77WUlJSwZOkyGjdqSJ9br+PGXvdlOrzVxMpivHvL00wfO4k6DevxzzduYeKnY5k4bCxD7xiElcU44MpT2OtfRzP09ucyHS4Aw174kPcGvsV596x87tKDF969Yr/btWexZP6iTIRWuZLlzLuyJyxdAvn5NL3rAQpGjaDRZVcz76qexKZOocHp/6DugYew7N0haQ0tG2sSUT8LNKMWLFzEqG/HcsJRhwBQWFhIk8aNaLt5a9pstkmGo6vcwhlzmT52EgDLFy1l1oQ/aNKyGROHfYeVBfcIThk9gSatijIY5arGjxjHorkLqnx99yP25IvXPk1jRElYuiT4WlCACgogFoPSEmJTpwCw/OuR1N1r37SHlco1LiU9JmmGpLFx54okvSfp5/Brs+rSieoJXjsnet3Mvo4i34qm/jGdZus15dr/3sP4CRPp0H4rruxxHg3q58biWE03ac6G227GlG9+WeV8x6778v0bX2Yoqpppv1sH5s2ay5+TpmU6lFXl5bHefX3J32hjlrzxKqXjf4C8fAq2ak/pz+Opu9e+5DXfIO1hlVlKbxZ/HHgAeCLu3JXAUDO7XdKV4fF/EiUSVU3i7nB7EBgO9AUeDfcfjCjP1ZSWlfHDTxM4+bgjePHxB6lfvx79n3w+XdmvlcIGdTnpkR68c9OTLF+4ZMX5vS48hlhpGd+98lkGo0tep6P34stsq0UAxGLMvfAc5px+EgXttiF/szYsuP0mGna/kKZ9HsGWLE57fwQEfRLJbkmk9QlQ8VmOxwADw/2BwLHVpRNJIWFm+5nZfsA0YGczKzazXYCOwNSq3iepu6SRkkb2e+LZtY5jww2a07JFc3bYdmsADu6yF+N+mrDW6UYtryCfro/0YOyrn/Hj2yNXnN/xxH1od0BHXr7koQxGl7y8/DyKD92DL1/P3gLNFi2kZMxo6hTvRumP3zPv3xcxr8d5lIz9lrKw6ZFOaXjuRkszK6/WTQdaVveGqPsk2pvZd+UHZjYW2Kaqi82sb1igFJ9zRre1zrz5+kVsuEELfp0c/Gd/Oeob2v7DBjMAAAygSURBVG7eeq3TjdpRd/6TmROm8mW/t1aca7vvDux53pE8d/bdlC7NjQXHt91rR6b9MpW/ps/OdCirUNOmqGGj4KBOHep0LKb0999Q0/WCc4WF1D/pbywdMjjtsdWkTyL+j2q4da9RXkF1pNrSJurRjTGS+gFPhcenAmMiznMVV/c8n//ceCclpSVsulErbr66J+9//Bm39X6YOXPn8a9/X8/WW21B397/TWdYVdq0uB07nrA3f/7wG92H3ArAB70GcegNZ5Bfp5DTnroKCDovh1zzWCZDXeFf9/Vkm07b0ahZY+798lFe7v0cHw8aSqejOvPFa8MyHd5q8pqtT+PLr4a8PJBYNuwjSkZ8QYOzz6PObntCnlj65mBKvh2d9thiNRgCNbO+BE35mvhTUiszmyapFTCjujcoynFZSfWA84F9wlOfAA+bWbXPjy+ZNTH7xoISuG2X6zIdQo39zJLqL8oyvTtkV60kGc3f+ljJXrtty92T/tx//+fwatOVtDnwhpltFx73AmbHdVwWmdkVidKItCZhZkslPQIMMbPxUebl3LoglaMbkp4FugDNJU0BrgduB56XdDYwGehaXTqRFhKSjgZ6AXWANpJ2Am4ys6OjzNe5XFWT5kZ1zKyqjr0DapJO1B2X1wO7AXMBzOwboE3EeTqXs2rTA4PLlZjZPGmVplNO9TU4l06prEmkStSFxPeS/gbkS9oKuBj4POI8nctZ2bjoTNTNjYuAbYFlwDPAPOCSiPN0LmeVWVnSW7pEXZM4wsyuAa4pPyHpJOCFiPN1Lidl463iUdckrkrynHOOtEzLrrGo7gI9DDgc2FhS/KINTYDSKPJ0bl2QjTWJqJobfwAjgaOBUXHnFwA9I8rTuZxXa0Y3zOxb4FtJz5hZSRR5OLcuysbRjag7LjeXdBvQAVix0ouZbRFxvs7lpBQvOpMSUXdcDgAeJuiH2I9ghZynEr7DuVoslYvOpErUhUR9MxtKcLfpZDO7ATgi4jydy1kxs6S3dIm6ubFMUh7ws6QLCValahRxns7lrGwc3Yi6JnEJ0IBgOvYuwOnAmRHn6VzOqjXzJMqZ2Vfh7kLg71Hm5dy6IBtrElFNpnqdBHd7+noSzlUuG0c3oqpJ3BVRus6t02rTZKqPy/cl1Qda+/J1zlUvG5sbkXZcSjoK+AZ4OzzeSdJrUebpXC7LxpWpoh7duAFfvs65pGXjZCpfvs65LJKNfRJRP3ejPzCU4KGkJxDMlyg0s/MiyzS5uLqHDzbJCbkWL+RezLkWbzplYvm6HhHnmYwaPQ4tC+RavJB7MedavGkTWXNDUj7wZvjg4Guqu945l50iq0mYWRkQk9Q0qjycc9GLuuNyIfCdpPeAReUnzeziiPOtTq61PXMtXsi9mHMt3rSJuuOy0pu5zGxgZJk651Iq0kLCOZf7op5x2VnSe5J+kjRR0q+SJqY4j2MlmaStU5numpJUJukbSd9L+lbSZeGaGkgqrrB6eNbJ5vglbS5pbIVzN0i6PAVpd5H0RjXX7CTp8DVI+yNJxWseXWZF3SfRn2B17FFAVI8c6gZ8Gn69Ptk3ScoPO1dTbYmZ7RTmsQHB0G8T4HozG0mwingkJBWY2do+siBj8UctBT+fnYBiYEiKQsoNNZkGWtMNGB5x+o0IVrtqB4wPz+UBDwE/Au8R/IeeGL42CbgD+Bo4BTgY+CI8fgFoFF63C/AxQeH2DtCqBjEtrHC8BTAbENAFeCM8vy/BfS3fAKOBxuH3MzSM5zvgmLh0rgPGExSIzwKXh+c/AvoQ/PJeVlXsQFuCe2hGAcOArVMdf3j+P2Hs3wK3x8VYHO43ByaF+9sCI8I0xgBbAQ2BN8P3jwVOjotlc2BshfhuAC4P87gjTO8nYO/w9bOA14APwp9LQ+Cx8LrR5T/jCt/bbuHnYjTBs2vbA3WA34CZYbwnJ0irPvAc8APwCjC8/PvPxS3qQuJ2oBfQCdi5fEth+qcC/cP9z8NfkBMJCoY8YEPgL1YtJK6I+7B+AjSM+3D/H1AYptUiPH8y8FgNYlpYybm5QMsKH8TXgc7hfiOCWl0B0CQuvgkEv5y7hh/MegSFyc+sWkg8FO5XGTtB4bNVuL878EEE8R8W5t8gPF8UF2NlhcT9wKnhfp3wl+sE4NG4vJvG7W9O4kLi7vDc4cD74f5ZwJS4WG4FTgv31yMoUBpW+N6aAAXh/oHAS3FpPRCXd1VpXRr3c9+BYCHonC0kom5u7B5+3SX8KoJ7N/ZPUfrdgHvD/efC4wLgBTOLAdMlfVjhPYPCr3sQLPX/WXhvSR2Cvx7tge2A98Lz+cC0FMUb7zPgHklPAy+b2RRJhcCtkvYBYsDGBL+cnYHBZrYUWBou6lPZ91Rp7JIaAXsCL8TdR1M3gvgPBAaY2WIAM5tTTRpfANdI2iRM42dJ3wF3S7qD4Jd2WNz1VfWyl59/Ofw6iqBAKfdeXCwHA0fH9WPUA1pXSK8pMFDSVmHahVXkW1Va+wD3AZjZGEljqnh/TohqZapLw93yjiAjqKZ9ama/piiPIoLCZntJRvALYQTVu0TK52uI4MPTrUK62wPfm1mnFMW5BUF/zAxgm/LzZna7pDcJ/up9JukQgoKrBbCLmZVImkTc80oSiP+eVotdUhNgroV9DRHGX5VSVnaSxz9/5RlJwwlWUB8i6Vwz+0DSzmG6t0gaamY3hW+ZDTSrkHYRUP6ZWhZ+LWPVz/aiuH0BJ1iF9U0ktYw7vBn40MyOk7Q5QS2lMlWlVcXluSmq0Y3GrGxjNwr3i4G3JJ2SojxOBJ40s83MbHMz25TgwzIHOEFSXvgf36WK938JdJa0JYCkhpLaEbT7W0jqFJ4vlLTtmgQoqQXwCEEV1Sq81tbMvjOzO4CvgK0J/oLNCAuI/YDNwss/A46SVC+sFRxZRZaVxm5m84Ffwye6o8COEcT/HvB3SQ3Ca4rCyyexsjZ5YlwaWwATzew+YDCwg6SNgMVm9hRBU3Xn8uvNbCFBzWj/uPQPJeinSdY7wEUKf5MldazkmqYEfV0QNDHKLSD4LFeX1ifA38Jz2xE0OXJWVCtT3VjZ+fA/9X2CpsHa6kbQURXvJYK/dlOAccDvBJ2A8yqJcaaks4BnJZVXva81s58knQjcF04pLyDoGPw+ybjqS/qGoIpaCjwJ3FPJdT3CgiAWpv0WwQfw9bDKPZKg8xUz+0rBYj1jgD8JOgYr+56WJ4j9VOBhSdeGsT1H0DmYsvjNbJmknYCRkpYT9A1dTbCc4fOSuhN0SpbrCpwuqQSYTtDG3xXoJSkGlADnV8j3DOBBSeUx3Whmv9Tgr/fN4c9kTDi0+yurF7p3EjQ3rq0Q74fAleHP57YEaT0MDJD0A0HnZfzzcHNO2idTSRptZpWV3qnMo5GZLZS0PkHPc2czmx5lnlGL+54aEPyl6m5mX2c6Lrfui7rjchXhX56/0pDVG5LWI+iMvDnXC4hQX0nlz1Qd6AWES5dIahJhdbliwkXAH8AZZvZjyjN1zkUiqkJiswqnDJhtZosqu945l738Bi/nXEJRL1/nnMtxXkjkAK28M3OspBfK5yGsYVqPh8OkSOoXdoZWdW0XSXuuQR6TJDVf0xhddvFCIjcsMbOdzGw7YDmwymrjktZolMrMzjGzcQku6UIwndvVYl5I5J5hwJbhX/lh4SSrcZLyJfWS9JWkMZLOhRWzKx+QNF7S+8AG5Qkpbp0DSYdK+lrBGhJDw+nI5wE9w1rM3pJaSHopzOMrSZ3D964v6V0Fa1D0I5iu7NYRaZ0n4dZOWGM4jPCxiQRTlrczs1/D2YzzzGzXcAbpZ5LeBToS3PjVgeBmsXEEtzfHp9sCeBTYJ0yryMzmSHqE4K7Qu8LrngF6m9mnkloTTEvehmAdj0/N7CZJRwBnR/qDcGnlhURuKJ8qDUFNoj9BM2BE3A1zBxPc+1B+b0RTgvUZ9gGetWCBnT8kfVBJ+nsAn5SnleDuzQOBDnFToJuE95LsAxwfvvdNSemYMOfSxAuJ3LBitahy4S9qxbsbLzKzdypcV+Pl1hLIA/YIb1mvGItbR3mfxLrjHeB8BWtSIKmdpIYE93mcHPZZtAL2q+S9XwL7SGoTvrf87s2Kdz2+S/BUNsLryguu+LseD2P127ldDvNCYt3Rj6C/4WsFi8X+j6Cm+ArBSlbjgCcIFnpZhZnNJHjM3cuSvmXlIjavA8eVd1wSPMu1OOwYHcfKUZYbCQqZ7wmaHb9F9D26DPAZl865hLwm4ZxLyAsJ51xCXkg45xLyQsI5l5AXEs65hLyQcM4l5IWEcy4hLySccwn9P6nMdbSLoWgkAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.26      0.59      0.36        70\n",
            "    Disagree       0.21      0.48      0.29        31\n",
            "     Discuss       0.59      0.28      0.38       166\n",
            "   Unrelated       0.41      0.28      0.33       139\n",
            "\n",
            "    accuracy                           0.35       406\n",
            "   macro avg       0.37      0.41      0.34       406\n",
            "weighted avg       0.44      0.35      0.35       406\n",
            "\n",
            "accuracy :  0.3497536945812808\n",
            "weighted f1 score :  0.3541173136251047\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VLqZEIsBN610"
      },
      "source": [
        "## With 10 Fold Cross Validation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Up3HIuuQmN-f"
      },
      "source": [
        "## SVM"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ns_cbDfimQCR"
      },
      "source": [
        "model = SVC(C=10, break_ties=False, cache_size=200, class_weight='balanced', coef0=0.0,\n",
        "    decision_function_shape='ovo', degree=3, gamma='scale', kernel='rbf',\n",
        "    max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
        "    tol=0.001, verbose=False)\n",
        "df_result = k_fold_train_test(X=features, Y=labels, k_fold = 10, model=model , scoring = 'accuracy'\n",
        ", additional_description = 'With the features : '+ features_name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ARO4Vq-ab8E5",
        "outputId": "307190cd-8027-4403-975b-37ccef8bd96b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 314
        }
      },
      "source": [
        "features, labels = shuffle(features, labels, random_state=0)\n",
        "model = RandomForestClassifier(n_estimators=100, random_state=0)\n",
        "df_result = k_fold_train_test(X=features, Y=labels, k_fold = 10, model=model , scoring = 'accuracy'\n",
        ", additional_description = 'With the features : '+ features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Mean accuracy of RandomForestClassifier in 10 fold is:  0.6727235038774814\n",
            "With the features : tfidf_similarity_important_words_more_than2_parts_root_distance_polarity_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d5xu5C8l92m1"
      },
      "source": [
        "# BOW With Other Features"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dHJRoe2STdjs"
      },
      "source": [
        "## Extract Feature"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_UDNrXtuBDrb",
        "outputId": "3d57e5e1-3376-4c8e-e523-91caf6c540a9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 802
        }
      },
      "source": [
        "features, features_name = psf_extractor.generate_Features(w2v_model_path = w2v_model_path,save_path = save_load_path\n",
        "                                                          , save_feature= True\n",
        "                                                          , load_path= save_load_path\n",
        "                                                          , load_if_exist = True, tfidf = False, w2v = False, polarity= False)\n",
        "\n",
        "features.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Features vector file is not exist.\n",
            "Start to generate similarity feature\n",
            "End of similarity feature\n",
            "Start to generate important words feature\n",
            "End of important words feature\n",
            "\"is question\" feature was added.\n",
            "\"more than tow parts\" feature was added.\n",
            "Start to generate root distance feature\n",
            "Use device: gpu\n",
            "---\n",
            "Loading: tokenize\n",
            "With settings: \n",
            "{'model_path': '/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/fa_seraji_models/fa_seraji_tokenizer.pt', 'lang': 'fa', 'shorthand': 'fa_seraji', 'mode': 'predict'}\n",
            "---\n",
            "Loading: mwt\n",
            "With settings: \n",
            "{'model_path': '/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/fa_seraji_models/fa_seraji_mwt_expander.pt', 'lang': 'fa', 'shorthand': 'fa_seraji', 'mode': 'predict'}\n",
            "Building an attentional Seq2Seq model...\n",
            "Using a Bi-LSTM encoder\n",
            "Using soft attention for LSTM.\n",
            "Finetune all embeddings.\n",
            "---\n",
            "Loading: pos\n",
            "With settings: \n",
            "{'model_path': '/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/fa_seraji_models/fa_seraji_tagger.pt', 'pretrain_path': '/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/fa_seraji_models/fa_seraji.pretrain.pt', 'lang': 'fa', 'shorthand': 'fa_seraji', 'mode': 'predict'}\n",
            "---\n",
            "Loading: lemma\n",
            "With settings: \n",
            "{'model_path': '/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/fa_seraji_models/fa_seraji_lemmatizer.pt', 'lang': 'fa', 'shorthand': 'fa_seraji', 'mode': 'predict'}\n",
            "Building an attentional Seq2Seq model...\n",
            "Using a Bi-LSTM encoder\n",
            "Using soft attention for LSTM.\n",
            "Finetune all embeddings.\n",
            "[Running seq2seq lemmatizer with edit classifier]\n",
            "---\n",
            "Loading: depparse\n",
            "With settings: \n",
            "{'model_path': '/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/fa_seraji_models/fa_seraji_parser.pt', 'pretrain_path': '/content/drive/My Drive/Stance Detection Paper/persian_stance_baseline_data/fa_seraji_models/fa_seraji.pretrain.pt', 'lang': 'fa', 'shorthand': 'fa_seraji', 'mode': 'predict'}\n",
            "Done loading processors!\n",
            "---\n",
            "End of root distance feature\n",
            "Start to generate bow feature\n",
            "End of bow feature\n",
            "Features saved successfully.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2029, 20360)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2tq4fShpTpO-"
      },
      "source": [
        "## Train Best Models"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wf8eWqtIW2x5"
      },
      "source": [
        "### SVM"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6baACwqATpgE",
        "outputId": "cae586f7-813d-43c1-b4c8-be9cfba6f6bf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 640
        }
      },
      "source": [
        "model = SVC(C=10, break_ties=False, cache_size=200, class_weight='balanced', coef0=0.0,\n",
        "    decision_function_shape='ovo', degree=3, gamma='scale', kernel='rbf',\n",
        "    max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
        "    tol=0.001, verbose=False)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train file is not exist.\n",
            "X_test file is not exist.\n",
            "y_train file is not exist.\n",
            "y_test file is not exist.\n",
            "Train and test sets created successfully.\n",
            "Train and test sets saved successfully.\n",
            "SVC\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.52      0.47      0.49        70\n",
            "    Disagree       0.63      0.39      0.48        31\n",
            "     Discuss       0.66      0.72      0.69       166\n",
            "   Unrelated       0.67      0.68      0.67       139\n",
            "\n",
            "    accuracy                           0.64       406\n",
            "   macro avg       0.62      0.56      0.58       406\n",
            "weighted avg       0.64      0.64      0.63       406\n",
            "\n",
            "accuracy :  0.6379310344827587\n",
            "weighted f1 score :  0.6334370004218493\n",
            "With the features : similarity_important_words_more_than2_parts_root_distance_bow_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9rdGPilJW2IS"
      },
      "source": [
        "### RandomForestClassifier"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jJsrbDJdTwqR",
        "outputId": "a1c1dcbf-20b0-4ff6-b90c-4c184d4414c4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 619
        }
      },
      "source": [
        "model = RandomForestClassifier(bootstrap=True, ccp_alpha=0.0,\n",
        "                       class_weight='balanced_subsample', criterion='gini',\n",
        "                       max_depth=None, max_features='auto', max_leaf_nodes=None,\n",
        "                       max_samples=None, min_impurity_decrease=0.0,\n",
        "                       min_impurity_split=None, min_samples_leaf=1,\n",
        "                       min_samples_split=2, min_weight_fraction_leaf=0.0,\n",
        "                       n_estimators=75, n_jobs=None, oob_score=False,\n",
        "                       random_state=None, verbose=0, warm_start=False)      \n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "RandomForestClassifier\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.62      0.59      0.60        70\n",
            "    Disagree       0.75      0.39      0.51        31\n",
            "     Discuss       0.78      0.67      0.72       166\n",
            "   Unrelated       0.64      0.83      0.72       139\n",
            "\n",
            "    accuracy                           0.69       406\n",
            "   macro avg       0.70      0.62      0.64       406\n",
            "weighted avg       0.70      0.69      0.68       406\n",
            "\n",
            "accuracy :  0.6896551724137931\n",
            "weighted f1 score :  0.6849083879539749\n",
            "With the features : similarity_important_words_more_than2_parts_root_distance_bow_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jm7cJaoPW9nh"
      },
      "source": [
        "### Linear SVC"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YsfJD2TpTzoS",
        "outputId": "0b19a75c-90b7-4957-c964-af6aa12add99",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 619
        }
      },
      "source": [
        "model = LinearSVC(C=1, class_weight='balanced', dual=True, fit_intercept=True,\n",
        "          intercept_scaling=1, loss='squared_hinge', max_iter=1200,\n",
        "          multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n",
        "          verbose=0)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "X_train loaded successfully.\n",
            "X_test loaded successfully.\n",
            "y_train loaded successfully.\n",
            "y_test loaded successfully.\n",
            "Train and test sets loaded successfully.\n",
            "LinearSVC\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQ8AAAEGCAYAAAB7IBD2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3dd3xUVfrH8c83IUIoSgkgKyqg2MCOK4iiCCqKqytW1rauK6vrz+6uXRBd18YqNhAE7F1sgKiLCKi7rCiIIEqvFhCCVCEkz++PewNDTJkMczMz4Xn7uq/M3Myc8wQnJ6cfmRnOOVdZWakOwDmXmbzwcM4lxAsP51xCvPBwziXECw/nXEJqpDqAsvxfi7Mzahho4HcfpzqESjugUctUh1BpdbNqpjqEShu/ZIzifW3BT3Pj/tzn5LWKO90oeM3DOZeQtK15OLddKipMdQRx88LDuXRSuCnVEcTNCw/n0ohZUapDiJsXHs6lkyIvPJxzifCah3MuId5h6pxLiNc8nHOJMB9tcc4lxDtMnXMJ8WaLcy4h3mHqnEuI1zyccwnxDlPnXEK8w9Q5lwgz7/NwziXC+zyccwnxZotzLiFe83DOJaSwINURxM0LD+fSiTdbnHMJ8WZLeqhRM4erX+5DjZo5ZGdnMfndiYx68FX+cO9f2O2APRCwdN73PHv942xctyHV4f7K4EH96H5SV5Yu+4mDDu6S6nDK1PtfN3HUcUew4qd8zup8web7Z//pdM66qAdFhUV8/O9P6X/XgBRGuUWT3zTm5v430jCvAWbGO8+P5LUhw6lXvx59BtxGs12b8v2iH+l9aV/W/LymaoPLoJqHzNLzeJRknduyQ+2abFy3gawa2Vz72h28dsfT/DBrMb+sWQ9Aj1vPZ/XyVXww4K1tyieKc1uOOvJw1qxZy7Bh/SMpPJJ1bssh7Q9k3dr19H341s2FR7sjDubiqy7kyvP/RsHGAho0qk/+8pXbnFcyzm1p1KQhjZo0Yua0WeTWyeXJ0QO5+U+3c+JZJ7B65Sqef+wlzr38HOrtVI+Bdw/e5vwqc27LLxOejftzX+uo8/3cligV1yiya2STXaMGZra54ADIqbUD6VqATvh4Iivyt/0XLmpf/PdLfs5ftdW9My48jWGPPkfBxqADMBkFR7IsX7qCmdNmAbB+7XoWzFpA453zOPKEIxj96vsAjH71fY7s1rHKY7PCgrivVKvWzRYAZYkbRtxD4913Zvyz77FgymwAzrv/MvY75iB+mL2E4Xc9m+Ioq5/dW+3KIYcfwOU39mLjhg08eMdjfP3lN6kO61d2bt6U1m335OvJM2iQ14DlS1cAQQHTIK9B1QeUQX0ekdU8JDWVNETSu+Hz/SRdHFV+ZbEi456TbuDWDpex+4F70myvXQF47m8DuOXwS/lh9hIO/d0RVR1WtZddI5sd6+/Ihd178VDfx7l3UN9Uh/QrubVrcefgPjzS+3HWrVn36xekokZaVBT/lWJRNlueAt4DfhM+nwlcXd4bJPWSNEnSpOmr5yQ1mPWr1jHzP9PZ7+gDN9+zIuPzdz7loG6/TWpeDpZ+v4wPR40DYPqUGRQVGfUb1U9xVFtk18jmzsF9+OCNMYx/N+ivyv8pn0ZNGgJBv0hKmlpWFP+VYlEWHnlm9gpQBGBmm4ByV/2Y2SAza2dm7drU22ObA6jbsB65O9YGIKdmDvscuT8/zv2OvN2bbn7NAV0P5cc5321zXm5rY0ePp13HQwDYrdWu5OTUYGUa9Xvc0O96FsxeyCuDXtt875P3P6XbmccD0O3M4/n4vU+rPrAk1jwkDZW0VNK0mHsNJX0gaVb4tUF4X5IeljRb0lRJh1SUfpR9HmslNQIsDK498HOE+f3Kjk0acH6/v5KVlYWysvhi5H+Y/uFkrn71DnLr5oLEkhkLePnWJ6syrLg99+xjHN2pA3l5DZk/dxJ39H2AYU+9lOqwfuXux/tw6BEHUb9hfd79fDgDHxjCWy+OpM+DN/HK2GcoKCig91X/SHWYm+1/WFu6nXE8c76ey5D3nwBg8D1DeP6xl7hj4G1073kiPyz+kd6X3ln1wSW3RvEU8CjwTMy9G4ExZnaPpBvD5zcAJwKtw+twYED4tUyRDdWGJdcjQFtgGtAYOMPMpsbz/mQN1VaVKIZqo5asodqqlIyh2qpWmaHa9SMfivtzn9v96grTldQCGGFmbcPn3wLHmNn3kpoBH5nZ3pKeCB+/WPJ1ZaUdWc3DzL6QdDSwNyDgWzNL/fiSc+msEjUPSb2AXjG3BpnZoAre1jSmQPgBKG7D7wIsinnd4vBe1RcekmoD1wK7m9klklpL2tvMRkSVp3MZrxKjKGFBUVFhUd77TVLCNfwoO0yHARuBDuHzJcBdEebnXOaLfrTlx7C5Qvh1aXh/CbBrzOuah/fKFGXhsYeZ3QcUAJjZOoLmi3OuLNHP83gbuDB8fCHwVsz9C8JRl/bAz+X1d0C0oy0bJeWyZbRlDyD9Vp85l06SONoi6UXgGCBP0mKgN3AP8Eo4YXMBcFb48lHAScBsYB1wUUXpR1l49AZGA7tKeh7oCPwxwvycy3ybknf0gpn1LONbv1placGw6+WVST+SwkNSFtAA6AG0J2iuXGVmP0WRn3PVRpou0ixNJIWHmRVJ+ns4w3RkFHk4Vy2lwZqVeEXZbPm3pOuBl4G1xTfNbEWEeTqX2bzwAODs8GtsO8qAVhHm6VxmS4MFb/GKcoZp5s19di7VCv3EOCT1KOX2z8BXZra0lO8557zZAsDFBLNLx4bPjwE+B1pK6mtmvn2XcyV54bE57X3N7EcIdhYjWBp8ODAe8MLDuZK8zwOAXYsLjtDS8N4KSb661rlSWNF2Ps8j9JGkEcCr4fPTw3t1gPTZUsq5dOLNFiAYou0BHBk+n0Swl8BaoHOE+TqXuTJotCWyVbXhXPm5wCbgNIICY0ZU+TlXLWTQ7ulJr3lI2gvoGV4/EcwwlZl5bcO5iqRBoRCvKJot3wATgJPNbDaApGsiyMe56ieDFsZF0WzpQbDv4VhJgyV1wTcBci4+GdRsSXrhYWZvmtk5wD4EE8SuBppIGiDp+GTn51y1UmTxXykW5dqWtcALwAvhwTJnEpwP8X487x+2dGJUoUXi8MZ7pzqESpu5ptwtKtNS/vo1qQ4hWhk02lIlB12bWT7BLs8J7/Ts3PbA0qA5Eq8qKTycc3FKg+ZIvLzwcC6d+NoW51xCvObhnEvIJu8wdc4lwpstzrmEeLPFOZcIH6p1ziXGax7OuYR44eGcS4hPT3fOJSKT9jCNbCcx51wCkriqVtI1kqZLmibpRUm1JLWUNFHSbEkvS9oh0VC98HAunSRpPw9JuwBXAu3MrC2QDZwD3As8aGZ7AvkE5yslxAsP59JJcvfzqAHkSqoB1CbYpOtY4LXw+08Dv080VC88nEsnlSg8JPWSNCnm6lWcjJktAR4AFhIUGj8TnNi40sw2hS9bDOySaKjeYepcGrHC+CeJmVmZe+SEG3CdCrQkOCfpVaBbEkLczAsP59JJ8kZbugLzzGwZgKThQEegvqQaYe2jOZDwdnLebHEujViRxX1VYCHQXlJtSQK6AF8T7Ct8RviaC4G3Eo3VCw/n0kmSOkzNbCJBx+gXwFcEv+uDCPYRvlbSbKARMCTRUL3Z4lw6SeK6ODPrDfQucXsu8NtkpO+Fh3NpxDb5qlrnXCIyp+zY/vo8srKy+PQ/I3nt9YSbepG6qd/fGPHl6zw7Zkt8e+7XiifefoRn/v0k9z71D2rXrZ3CCMu2x54tGTvhzc3X3EWf85fLLkx1WOUaPKgf3y3+kimTx6Q6FCCpHaaR2+4Kj8svv4hvv5md6jDKNOqV97j23Bu3unfj/dcz4O7BXND1z4x/dwLnXnZ2iqIr35zZ8+h81O/pfNTv6XJ0D9avX8/IER+kOqxyPfPMK3Q/+dxUh7FFUSWuFNuuCo/f7LIz3body1NPvZTqUMr05cSprFq5aqt7u7ZqzpT/TgXgswmfc/RJR6UitErpdEwH5s9bxOJF36U6lHJN+HgiK/JXpjqMzbzmEZK0l6QxkqaFzw+QdGuUeZbnvvtu55Zb/0lRGvzDV8a8mQs46oSOAHQ++Wia/qZJiiOq2Gk9ujP8tRGpDiPzeM1js8HATUABgJlNJVjZV6rYufqbNq1OaiDdTjyWZcuWM2XytKSmWxXuvvY+elx4KkPeHUjtOrUpKChIdUjlysnJ4YSTjuXtN0enOpSMY5viv1It6tGW2mb2v2CC22Zl/tixc/Xr1G6R1OpBh/bt6N69Kyec0JlatWpSr15dhgx5kIsvviaZ2URi4ZxFXPOHvwNBE+aILu1THFH5uhzXialfTmfZsuWpDiXjZNDJC5HXPH6StAdgAJLOIFjhV+V6976PvVp3YL99j+TCC65g3LhPM6LgAKjfqD4AkrjwqvN489m3UxxR+Xqc0Z03XhuZ6jAyUwY1W6KueVxOUJPYR9ISYB5wXsR5ZrQ+j93KwR0OpH7DnXhj0ssMeeApcuvk0uOPpwIwbtTHjHw5fZsDtWvncnTnI7ju6ttTHUpcnnv2MY7u1IG8vIbMnzuJO/o+wLAUdqhnUs1DZtF3HkqqA2SZWdwdGclutkTtoAatUh1Cpc1ck/CCypTJX78m1SFU2qaNS1TxqwJLuxwd9+e+yZhxcacbhahHW5pKGgK8ZmarJe0nKeFtz5yr7qxQcV+pFnWfx1PAe8BvwuczgasjztO5jGVF8V+pFnXhkWdmrxB274QbkGTOwRTOVTErUtxXqkXdYbpWUiO2jLa0J9hL0TlXinSoUcQr6sLjWuBtYA9JnwCN2bKLkXOuBLPU1yjiFVnhISkbODq89gYEfGtm6T090rkU8poHYGaFknqa2YPA9Kjyca46KUqDUZR4Rd1s+UTSo8DLwNrim2b2RcT5OpeR0qEjNF5RFx4HhV/7xtwzglOrnHMleOERMrPOUabvXHVTBRO+k6bMwkPSI4RDrKUxsysrSlzStaXc/hn43MymxBWhc9uR6lLzmJSE9NuF1zvh85OBqcClkl41s/uSkIdz1Ua1GKo1s6eTkH5z4BAzWwMgqTcwEuhEcOiuFx7OxSisTqMtkhoTnDK1H1Cr+L6ZxdPp2QTYEPO8AGhqZuslbSjjPc5tt6pFzSPG8wRDrd2BSwnOt1wWZ/rPAxMlFZ+H+TvghXCJ/teVjNW5aq+69HkUa2RmQyRdZWbjgHGSPosncTO7U9Jo4Ijw1qVmVtyXkkb73TuXHqrFaEuM4unk30vqDnwHNIw3AzP7TNICwiaPpN3MbGGlI3VuO1Ddah53SdoJuA54BNgRiGvzT0mnAP0I9vNYCuwGfAO0SSha56q5wqLk7pIhqT7wJNCWYOrFn4BvCboiWgDzgbPMLL+yaVcYqZmNMLOfzWyamXU2s0PNLN4deO8E2gMzzawl0BX4b2WDdG57YRb/Faf+wGgz2wc4EJgB3AiMMbPWwJjweaXFM9oyjFImi5nZn+JIv8DMlkvKkpRlZmMlPZRIoM5tD4qSONoSthg6AX8EMLONwEZJpwLHhC97GviIYES1UuJptsQe+1ULOI2g3yMeKyXVBcYDz0taSswCOefc1iozVCupF9Ar5tag8OyjYi0JRkaHSTqQYG7VVQTTJYqPQPkBaJpIrBUWHmb2eomAXwQ+jjP9U4H1BH0k5wI7sfUiOedcjMqMtsQeklaGGsAhwBVmNlFSf0o0UczMJCU0xpPIwrjWBJO/4mZmmyT9B9gHWFXR6wEObbBHAqGlzow1i1MdQqV9N+fdVIdQad0P/muqQ4hUMpstwGJgsZlNDJ+/RlB4/CipmZl9L6kZwWBGpVXYYSpptaRVxRfBOpV420fjgVqSdgHeB84n2FHdOVeKwqKsuK+KmNkPwCJJe4e3uhBMznybYLIn4de3Snl7heJpttRLJOGQzGxdeFbL42Z2nyRfTetcGSKYI3YFQX/jDsBc4CKCSsMr4e/lAuCsRBKOZ7RljJl1qehe2W9XB4L+juLDnrIrH6Zz24ckN1sIt75oV8q34vn9LVd5+3nUAmoDeZIaEGxgDMEksV3iTP9q4CbgDTObLqkVMHYb4nWuWqsuC+P+QvDL/xuCIZ7in2oV8Gg8iRevhYl5PheocBMh57ZXGbR5ern7efQH+ku6wsweqUyikh4ys6slvUPpE8xOqXyozlV/RvWoeRQrklTfzFYChE2Ynmb2eDnveTb8+sC2Bujc9mRTNWm2FLvEzB4rfmJm+ZIuAcosPMzs8/DruHAzIcws3j1AnNtuZVLNI54lfNmSNv9E4UlwO1T0Jkl9JP1EsIJvpqRlkm5PPFTnqr+iSlypFk/hMRp4WVIXSV2AF4FypyaGu6Z3BA4zs4Zm1gA4HOgoKa7l/M5tjwzFfaVaPM2WGwgW31waPp8K7FzBe84HjjOzn4pvmNlcSecRzDR9MIFYnav20qFGEa94ZpgWSZoI7EEwEy0PeL38d5ETW3DEpLVMUk5CkTq3HShMgxpFvMqbJLYX0DO8fiLYeSjeU+A2Jvg957ZrGbQLYbk1j2+ACcDJZjYboBL9FQeGi+hKEjHHNzjntlZUHWoeQA/gHGBsuAP6SxDfT2Zmvn7FuQRk0ObpZY+2mNmbZnYOwR4cYwmmqjeRNEDS8VUVoHPbk2o1VGtma83sBTP7HcHxkZNJYL9D51zFiqS4r1Sr1E5i4fbsFW195pxLUGGqA6iERLYhdM5FpLqMtjjnqlh1GW1xzlWxTBpt8cLDuTTizZY00eQ3jbm5/400zGuAmfHO8yN5bchw6tWvR58Bt9Fs16Z8v+hHel/alzU/r0l1uL+yx54teXLYlmVAu7fYlXvvfpgnBjydwqjg1rv/xfhP/kfDBvV587mBALz34QQeH/Iccxcs4sXBD9F2370AGPHehwx7Yctqhplz5vHq0EfYZ6/UHa3RuFkef3vobzTIq48ZjHphFG8OfYtLbvkz7bseTkHBJr5f8B0PXPcv1q6q2jPK0mEINl6yypwyU4U67dJlmwNr1KQhjZo0Yua0WeTWyeXJ0QO5+U+3c+JZJ7B65Sqef+wlzr38HOrtVI+Bdw/epryiPrclKyuLr74ZzwldzmLxongP7Ctfoue2TJryFbVzc7n5zgc2Fx5z5i8kS1nccf/DXH/5nzcXHrFmzpnHlTf2ZfSrwxKOORnntjRs0pCGTRoye9pscuvk8tioR+jz5740bpbH5E+mUFRYxMU3BaepDvnn0G3O7/1Fo+OuTwxpfl7cn/uLFz+X0npKco/kTjPLl65g5rRZAKxfu54FsxbQeOc8jjzhCEa/+j4Ao199nyO7dUxlmHHpdEwH5s9blLSCY1u0O2h/dtpx6xM59mixGy13b17u+0Z9MI4Tux4dZWhxWbF0BbOnzQaCz8XC2YvI27kRn4//gqLC4G//N5O/oXGzvCqPrVpNEtsWks6UVC98fKuk4ZIOiTLPsuzcvCmt2+7J15Nn0CCvAcuXrgCCAqZBXoNUhFQpp/XozvDXRlT8wjQ2esw4TjrumFSHsZWmzZuyZ5s9+Gbyt1vdP+Gs4/ls7KQqj8cLjy1uM7PVko4EugJDgAFlvVhSL0mTJE36fu2SpAWRW7sWdw7uwyO9H2fdmnW/fkGaNt2K5eTkcMJJx/L2m6NTHUrCpk7/htxatWjdqkWqQ9msVu1a3P7ErQzo88RWn4ueV5xDYWEhY974sMpjMsV/pVrUhUfxhLnuBCd4j6ScLQzNbJCZtTOzds3qxHs0TPmya2Rz5+A+fPDGGMa/G5zPnf9TPo2aNASCfpH85SuTkldUuhzXialfTmfZsuWpDiVh7/47PZosxbJrZHP7oNv48M2xfDL6k833jzvzOA7vcjj3XHFfSuLymscWSyQ9AZwNjJJUswry3MoN/a5nweyFvDLotc33Pnn/U7qdGazt63bm8Xz83qdVGVKl9TijO2+8NjLVYSSsqKiI9z6ckFaFx7X3X8PCWQt5ffDwzffaHXMoZ116Br3/1IcNv2xISVyFlbhSLdLRFkm1gW7AV2Y2KzyRe38ze7+i9yZjtGX/w9ry2Jv9mfP1XIosKKsH3zOEryd/wx0Db6PpLk34YfGP9L70TlavXL1NeUU12lK7di6Tp4+l3YFdWb0qucPJiY62/K33PXw2eSorV66iUcP6/PXi89lpx7r888EBrFj5M/Xq1mWf1q0Y9OA/APjfF1N5aMBQXhj80DbHnIzRljaHteHB4f2YO2MeVhR8Lobe+xR/7XsZO+yQw6r8YCuaGV98w8M3V+rIolJVZrSl/27xj7ZctTC1oy1RFx57AIvNbIOkY4ADgGeKz4ApTzIKj6oU9VBtFBItPFIpGYVHVatM4fFgJQqPa1JceETdhHgdKJS0J8FK3F2BFyLO07mM5X0eWxSZ2SaCXckeMbO/Ac0iztO5jGWVuOIhKVvSZEkjwuctJU2UNFvSy5IqPIOpLFEXHgWSegIXAMWTFHz3dOfKUKT4rzhdBcyIeX4v8KCZ7QnkAxcnGmvUhcdFQAfgH2Y2T1JLtpxj65wrIZmjLZKaE0yTeDJ8LuBYoHjo8Wng94nGGunCODP7Grgy5vk8gpLPOVeKokosypfUi+BAtmKDzCx2l7+HgL8DxWsJGgErw64EgMVAwhOqIi08JM2jlOaZmbWKMl/nMlVlOkLDgqLULUElnQwsNbPPw5HOpIt6SX67mMe1gDOBhhHn6VzGSuL8hI7AKZJOIvjd2xHoD9SXVCOsfTQHEl4HEmmfh5ktj7mWmNlDBG0w51wpkjVUa2Y3mVlzM2tBcP7Sh2Z2LsExKmeEL7sQeCvRWKNutsSuoM0iqIlU6w2InNsWmxT53MgbgJck3UVwjMqQRBOK+he5X8zjTcA8gsOynXOliKLoMLOPgI/Cx3OB3yYj3ahHW+I5FNs5F0qHmaPxinozoLsl1Y953iCsLjnnSlGExX2lWtSTxE6MXQQXnjh3UsR5Opexkj09PUpR93lkS6ppZhsAJOUCNSPO07mMlUnNlqgLj+eBMZKKt8u+iGBKrHOuFIVpUaeIT9QdpvdK+pJg/1KAO83svSjzdC6Tec0jJKkO8L6ZjZa0N7C3pBwzK4gyX+cylWVQzSPqDtPxQC1JuwCjgfOBpyLO07mM5ZsBbSEzW0ewGdAAMzsTaBNxns5lLB+q3UKSOgDnAsXbf2dHnKdzGcuHare4GrgJeMPMpktqRbAwxzlXik1pUSzEJ+rRlnHAuJjnc4nZHMg5t7VM6jCNpPCQ9JCZXS3pHUrfDOiUitLYMbtWFKFFJn99cs9UqQoXHnpdqkOotDcuTv9zhbdFOnSExiuqmkfxPqUPRJS+c9XSdl/zMLPPw6/jJDUOHy+LIi/nqpNMqnlENtoiqY+kn4BvgZmSlkm6Par8nKsOCs3ivlItksJD0rUEeygeZmYNzawBcDjQUdI1UeTpXHXg8zyCmaQ9w6MWgM0jLecRHADlnCuFVeK/VIuqwzTHzH4qedPMlknyE+OcK0Mm9XlEVXhsTPB7zm3X0qE5Eq+oCo8DJa0q5b4IzpBwzpUiHZoj8YpqqNbXrziXgHQYRYmXn6HiXBrxZotzLiHeYeqcS8h23+fhnEuMN1uccwkx7zB1ziUik45eiHobQudcJSRzbYukXSWNlfS1pOmSrgrvN5T0gaRZ4deENknxwsO5NGJmcV9x2ARcZ2b7Ae2ByyXtB9wIjDGz1sCY8HmleeHhXBpJZs3DzL43sy/Cx6uBGcAuwKlsObnxaeD3icTqhYdzaaQyq2ol9ZI0KebqVVa6kloABwMTgaZm9n34rR+AponE6h2mzqWRykxPN7NBwKCKXiepLvA6cLWZrZIUm4ZJSqiX1gsP59JIsud5hFtgvA48b2bDw9s/SmpmZt9LagYsTSRtb7Y4l0aSPNoiYAgww8z+FfOtt4ELw8cXAm8lEmu1rnnkNcvj2gevo37j+pgZ770wmreHvr35+6ddchoX3/Zn/nBgT1bll7aDQGoNHtSP7id1Zemynzjo4C6pDqdUDZs14rIHr2KnvPpgxocvfMDoYSPYfb8W/Okfl5JTcweKCgsZdusg5nw5K9Xhblaj/YnkHHIsYBT9uIgNbw2ETQXkHHsWNdq0h6IiCiZ9wKaJ71VpXEmeJNaRYFe/ryRNCe/dDNwDvCLpYmABcFYiiVfrwqOwsJAhdz3JnGlzyK2Ty0Mj+zN5wmQWzVpEXrM8Du50MEsXJ1RjqxLPPPMKjz8+jGHD+qc6lDIVFRbx/F1PMX/aXGrVqcU/RvTjq4+n0POmCxne/xW+/OgLDup8CD1vuoC7zrkt1eECoHoNyDm8G+sfux42FVDzzKuo0bYDILRTI9Y/eh2YQZ0dqzy2ZDZbzOxjgj10SrPNf42qdbMlf2k+c6bNAWD92vUsmr2IRjs3AuCS3pcw7O5haT0deMLHE1mRvzLVYZRr5dJ85k+bC8Ava39hyezFNGjaCMzIrZsLQG692uQvXZHKMH8tKxtydoCsLMjZAVudT43DulIwbnhQcACsrfraqO9hmoaaNG9Cqzat+Hbytxx+XHuW/7CceTPmVfxGF7e85o1p0aYlc6bM5Jm+Q7nxmds595Y/oizRp8dNqQ5vM1udT8GnI6h9zaNQsJHCOVMpnPMVNU+/ghptOpC972HY2lVsfPdpbMUPVRpboWXOovyojl44pLwrijzLU6t2LW5+4hYG3zGYok1FnPV/Z/Fcv+eqOoxqrWbtWlwz8Aae7TuU9WvW0/W8E3j2zqFc0eESnu07lF73XZ7qELeoVYca+7Rj3UNXsq7fX2GHmmQfcCTUyME2FfDLoFvY9MWH1Dz1L1UeWpJnmEYqqmZLv/B6jGBSyiBgcPj4sbLeFDvpZeGahUkJJLtGNjc/cTMfvTGW/4z+lJ1335mmuzblkdGPMuSToeQ1y+OhUf2p37h6n4Eapewa2Vwz8O988uZ4Phv9XwA6nd6Zz94NHk8c+SmtDmydyhC3kt2qLUX5S2HdaigqpHDGZ2Tvuhe2ajmFM/4HQOGMz8hquluVx5ZJ57ZEtYdpZwBJw4FDzOyr8HlboE8579s86eXk3bon5V/nqvuvYtHsRbz55Nc1hLYAAAxDSURBVJsALPh2Aecdcu7m7w/5ZCjXnHx1Wo62ZIpe913OktmLGfXklpGs/KX57Nu+DTP+O502Hffnx/nfl5NC1bKffyK7eeugz6NgI1kt21L03VxswzqyW7Zh0+SPyGqxL0XLqz7mdOjLiFfUfR57FxccAGY2TdK+Eee52X6H7cexp3dh3ox5PPzuIwA8c9/TTBo7qapC2CbPPfsYR3fqQF5eQ+bPncQdfR9g2FMvpTqsrezdbl+OOr0zC2fM5+5RwVSCV+5/jidveJwL+lxMVnYWBRsKePLGx1Mc6RZFS+aw6euJ5P7lbigqouj7+Wz6fAzk7EDNHv9HTvsTsY2/sPHtCidvJj+2NGiOxEtRtp0kvQisBYo7GM4F6ppZz4rem6yaR1UZ/cOUil+UZs5q9ttUh1Bpgy/KvJM76vR5sazh0l9p0/TwuD/303+cGHe6UYi65nERcBlwVfh8PDAg4jydy1iZNNoSaeFhZr9IGgiMMrNvo8zLueogk5otkU4Sk3QKMAUYHT4/SNLb5b/Lue1XJk0Si3qGaW/gt8BKADObArSMOE/nMlaRWdxXqkXd51FgZj/H7h8AaVBkOpem0qFGEa+oC4/pkv4AZEtqDVwJfBpxns5lrEIrTHUIcYu62XIF0AbYALwA/MyWkRfnXAmZND096ppHdzO7Bbil+IakM4FXI87XuYyUDtPO4xV1zaO0pZTps7zSuTSz3dc8JJ0InATsIunhmG/tSHCWhHOuFOkwihKvqJot3wGTgFOAz2PurwauiShP5zLedj/aYmZfAl9KesHMCqLIw7nqyKenb9FC0j+B/YDNK5rMrFXE+TqXkdKhLyNeUXeYDiNYCLcJ6Aw8w5YVts65EjJphmnUhUeumY0hWPq/wMz6AN0jztO5jLXdj7bE2CApC5gl6f+AJUDdiPN0LmP5PI8trgJqE0xLP5TgAJoLy32Hc9sxr3mEzOyz8OEago2BnHPl2O5HWyS9QzmrZ83slCjydS7TpUNHaLyiqnk8EFG6zlVr6dAciVdUk8TGFT+WlAvs5tsQOlexTJphGvU2hL/DtyF0Lm6Z1GEa9WhLH3wbQufilkmTxNJ2G8IRC0dGdiaFpF7h6XQZIdPihcyLOV3i3bRxSUrPYqmMqGseW21DKOkR0mMbwl6pDqCSMi1eyLyYMy3elEvFNoRXR5ync64KRNZskZQNjAwPvb6lotc75zJLZDUPMysEiiTtFFUe2yDlbdtKyrR4IfNizrR4Uy7qg67fAg4GPiA48BoAM7syskydc1Ui6tGW4eHlnKtmIq15OOeqr6hnmHaU9IGkmZLmSponaW6S8/i9JJO0TzLTTZSkQklTJE2X9KWk68I9TZDUrsRu8mknneOX1ELStBL3+ki6PglpHyNpRAWvOUjSSQmk/ZGkdolHl56ibrYMIdgt/XMgqnP0egIfh197x/smSdlhp26yrTezg8I8mhAMUe8I9DazSQS7ykdCUg0z29ajLVIWf9SS8O9zENAOGJWkkDJbZebSV/YCJkacfl2C3cn2Ar4N72UBjwPfEHTUjgLOCL83H7gX+AI4Bzge+E/4/FWgbvi6Q4FxBIXee0CzSsS0psTzVsByQMAxwIjw/tEE636mAJOBeuHPMyaM5yvg1Jh0bgO+JSgoXwSuD+9/BDxE8Et9XVmxA3sQrDH6HJgA7JPs+MP7N4SxfwncExNju/BxHjA/fNwG+F+YxlSgNVAHGBm+fxpwdkwsLYBpJeLrA1wf5nFvmN5M4Kjw+38E3gY+DP9d6gBDw9dNLv43LvGz/Tb8XEwmmNS4N7ADsBBYFsZ7djlp5QIvATOAN4CJxT9/dbqiLjzuAe4HOgCHFF9JTP9cYEj4+NPwF+cMggIjC9gZyGfrwuPvMR/i8UCdmA/97UBOmFbj8P7ZwNBKxLSmlHsrgaYlPqDvAB3Dx3UJaoE1gB1j4ptN8Et7WPiBrUVQyMxi68Lj8fBxmbETFEqtw8eHAx9GEP+JYf61w/sNY2IsrfB4BDg3fLxD+Et3OjA4Ju+dYh63oPzCo1947yTg3+HjPwKLY2K5GzgvfFyfoKCpU+Jn2xGoET7uCrwek9ajMXmXlda1Mf/uBxBsAF7tCo+omy2Hh18PDb+KYG3LsUlKvyfQP3z8Uvi8BvCqmRUBP0gaW+I9L4df2xMcCfFJuPZmB4K/NnsDbYEPwvvZwPdJijfWJ8C/JD0PDDezxZJygLsldQKKgF0Ifmk7Am+Z2S/AL+FmS6X9TKXGLqkucATwasw6o5oRxN8VGGZm6wDMbEUFafwHuEVS8zCNWZK+AvpJupfgl3lCzOvL6t0vvl88svc5QUFT7IOYWI4HTonpJ6kF7FYivZ2ApyW1DtPOKSPfstLqBDwMYGZTJU0t4/0ZLaqdxK4NHxZ3QBlBde9jM5uXpDwaEhRC+0sygl8UI6gmlqd4vokIPlQ9S6S7PzDdzDokKc5WBP09S4F9i++b2T2SRhL8lfxE0gkEBVpj4FAzK5A0n5jzbsoR+zP9KnZJOwIrLezLiDD+smxiS+d87Pk9L0iaSLCj/ihJfzGzDyUdEqZ7l6QxZtY3fMtyoEGJtBsCxZ+pDeHXQrb+bK+NeSzgdCuxv4ykpjFP7wTGmtlpkloQ1GpKU1ZaZby8eolqtKUeW9rwdcPH7YB3JZ2TpDzOAJ41s93NrIWZ7UrwIVoBnC4pK/xAHFPG+/8LdJS0J4CkOpL2IuhXaCypQ3g/R1KbRAKU1BgYSFDVtRLf28PMvjKze4HPgH0I/uItDQuOzsDu4cs/AX4nqVZYizi5jCxLjd3MVgHzJJ0Z3pekAyOI/wPgIkm1w9c0DF8+ny21zzNi0mgFzDWzh4G3gAMk/QZYZ2bPETR5Dyl+vZmtIahJHRuTfjeCfqB4vQdcofA3XNLBpbxmJ4K+NAiaKsVWE3yWK0prPPCH8F5bgqZLtRPVTmJ3lHY//J/9b4ImxrbqSdBBFut1gr+Oi4GvgUUEnY8/lxLjMkl/BF6UVFyFv9XMZko6A3g4nFpfg6BDcnqcceVKmkJQ1d0EPAv8q5TXXR0WEEVh2u8SfDDfCavukwg6fTGzzxRsojQV+JGgQ7K0n2ljObGfCwyQdGsY20sEnZJJi9/MNkg6CJgkaSNB39PNBNtSviKpF0FnaLGzgPMlFQA/EPQhHAbcL6kIKAAuK5HvBcBjkopjusPM5lTir/2d4b/J1HAIeh6/LozvI2i23Foi3rHAjeG/zz/LSWsAMEzSDIJO09jzmquNKp8kJmmymZVW2iczj7pmtkZSI4Ke8I5m9kOUeUYt5meqTfCXrZeZfZHquNz2K+oO062Ef6nyqyCrEZLqE3SC3pnpBUdokKTiM3+f9oLDpVokNY+w2l0y4YbAd8AFZvZN0jN1zlWpqAqP3UvcMmC5ma0t7fXOuczjC+OccwmJehtC51w15YVHBtCWla7TJL1aPI8iwbSeCodzkfRk2Alb1muPkXREAnnMl5SXaIwuM3jhkRnWm9lBZtYW2AhcGvtNSQmNmpnZn83s63JecgzBtHbnfsULj8wzAdgzrBVMCCePfS0pW9L9kj6TNFXSX2DzbNJHJX0r6d9Ak+KEFLPPhKRukr5QsIfHmHBa9qXANWGt5yhJjSW9HubxmaSO4XsbSXpfwR4gTxJM23bVXJXO83DbJqxhnEh4fCfB1O22ZjYvnL35s5kdFs6Y/UTS+wR7yO5NsAiwKcHM26El0m0MDAY6hWk1NLMVkgYSrLJ9IHzdC8CDZvaxpN0IpmfvS7CPysdm1ldSd+DiSP8hXFrwwiMzFE8Zh6DmMYSgOfG/mIWGxxOsDSleO7ITwf4YnYAXLdj46DtJH5aSfntgfHFa5ayG7QrsFzMVfMdwrU0noEf43pGSqmIioEsxLzwyw+bdvYqFv8AlV4teYWbvlXhdpbfNK0cW0D7cGqBkLG47430e1cd7wGUK9gRB0l6S6hCsgzk77BNpBnQu5b3/BTpJahm+t3g1bMlVpO8TnAJI+LriAi12FemJ/HrZvKuGvPCoPp4k6M/4QsEmwU8Q1CzfINh57GvgGYINeLZiZssIzmodLulLtmwu9A5wWnGHKXAl0C7skP2aLaM+dxAUPtMJmi8LI/oZXRrxGabOuYR4zcM5lxAvPJxzCfHCwzmXEC88nHMJ8cLDOZcQLzyccwnxwsM5l5D/ByBmrlh0C0hwAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<Figure size 288x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "       Agree       0.41      0.47      0.44        70\n",
            "    Disagree       0.68      0.61      0.64        31\n",
            "     Discuss       0.70      0.70      0.70       166\n",
            "   Unrelated       0.67      0.62      0.64       139\n",
            "\n",
            "    accuracy                           0.63       406\n",
            "   macro avg       0.61      0.60      0.61       406\n",
            "weighted avg       0.64      0.63      0.63       406\n",
            "\n",
            "accuracy :  0.6280788177339901\n",
            "weighted f1 score :  0.630715479326273\n",
            "With the features : similarity_important_words_more_than2_parts_root_distance_bow_\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vt28l1ESXCf6"
      },
      "source": [
        "### Logistic Regression"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OkIzueGpT0Kh"
      },
      "source": [
        "# with \"l1_ratio\": ['None']\n",
        "model = LogisticRegression(C=1, class_weight='balanced', dual=False, fit_intercept=True,\n",
        "                   intercept_scaling=1, l1_ratio=None, max_iter=1000,\n",
        "                   multi_class='ovr', n_jobs=None, penalty='l1',\n",
        "                   random_state=None, solver='saga', tol=0.0001, verbose=0,\n",
        "                   warm_start=False, l1_ratio= 0.1)\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o-gKJG86XHiB"
      },
      "source": [
        "### Gussian Naive Bays"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "58Q68YeOT1MO"
      },
      "source": [
        "model = GaussianNB()\n",
        "result = common_train_test(model = model, X=features, Y=labels, test_size = 0.2\n",
        "                           , additional_description = 'With the features : '+ features_name\n",
        "                           , save_datasets = True, save_path = train_test_sets_save_path\n",
        "                           , load_if_exist = True, load_path = train_test_sets_load_path\n",
        "                           , features_name = features_name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "usb6QBbfJUmq"
      },
      "source": [
        "# function ClickConnect(){\n",
        "# console.log(\"Clicking\");\n",
        "# document.querySelector(\"colab-connect-button\").click()\n",
        "# }\n",
        "# setInterval(ClickConnect,60000)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zgjC9hU0JXHL"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}