[FINAL]Synonyms_Equivalence_Classifier.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mbyRbWHQD3GZ",
    "outputId": "5daf657b-4de6-4d37-d2f3-9fb8a5a65b3f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[K     |████████████████████████████████| 4.9 MB 4.8 MB/s \n",
      "\u001b[K     |████████████████████████████████| 462 kB 49.1 MB/s \n",
      "\u001b[K     |████████████████████████████████| 1.8 MB 9.2 MB/s \n",
      "\u001b[K     |████████████████████████████████| 43 kB 2.1 MB/s \n",
      "\u001b[K     |████████████████████████████████| 99 kB 10.5 MB/s \n",
      "\u001b[K     |████████████████████████████████| 596 kB 44.8 MB/s \n",
      "\u001b[K     |████████████████████████████████| 90 kB 9.8 MB/s \n",
      "\u001b[K     |████████████████████████████████| 234 kB 49.0 MB/s \n",
      "\u001b[K     |████████████████████████████████| 352 kB 64.7 MB/s \n",
      "\u001b[K     |████████████████████████████████| 1.2 MB 53.2 MB/s \n",
      "\u001b[K     |████████████████████████████████| 47.7 MB 77 kB/s \n",
      "\u001b[K     |████████████████████████████████| 1.1 MB 40.2 MB/s \n",
      "\u001b[?25h  Building wheel for py-cpuinfo (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
      "  Building wheel for seqeval (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
     ]
    }
   ],
   "source": [
    "# A dependency of the preprocessing for BERT inputs\n",
    "!pip install -q -U \"tensorflow-text==2.8.*\"\n",
    "!pip install -q tf-models-official==2.7.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WN1zdlhjM7wP",
    "outputId": "34a4ea59-ed54-40c4-8de6-d2517abfe8e6"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
      "[nltk_data]   Unzipping tokenizers/punkt.zip.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download('punkt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "TfaiCXmzEETm"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "\n",
    "import tensorflow as tf\n",
    "import tensorflow_hub as hub\n",
    "import tensorflow_text as text\n",
    "from official.nlp import optimization  # to create AdamW optimizer\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "from keras.utils import np_utils\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "tf.get_logger().setLevel('ERROR')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "p6CSlmw0EHsQ",
    "outputId": "30b9563a-af3b-43ef-d2b7-779b081d5e88"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mounted at /content/drive\n"
     ]
    }
   ],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3gcNfxVmEZIm",
    "outputId": "cb589006-a5d1-43a9-8085-9658862c8338"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/content/drive/MyDrive/Colab Notebooks/AdvancedNLP\n"
     ]
    }
   ],
   "source": [
    "%cd drive/MyDrive/Colab Notebooks/AdvancedNLP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "xIxKktG-EbA0",
    "outputId": "8b4aa768-fd7f-4ca3-9bcf-7e48c34690e9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.47058823529411764\n"
     ]
    }
   ],
   "source": [
    "synonyms_corpus = pd.read_csv('train.csv')\n",
    "\n",
    "synonyms_corpus.head()\n",
    "\n",
    "# [8] checking the percentage of majority class and selecting accuracy as evaluation metric\n",
    "label, count = np.unique(synonyms_corpus['LABEL'].values, return_counts=True)\n",
    "print(max(count)/sum(count))\n",
    "\n",
    "synonyms_corpus = synonyms_corpus.fillna('none')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FL9f64ECCBQe",
    "outputId": "82077299-fcfb-4a19-c6eb-4a45ff358fa4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      LEMMA 1  ... LABEL\n",
      "0  peripteral  ...   NaN\n",
      "1  peripteral  ...   NaN\n",
      "2      manual  ...   NaN\n",
      "3   following  ...   NaN\n",
      "4      better  ...   NaN\n",
      "\n",
      "[5 rows x 8 columns]\n",
      "0.32038834951456313\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array(['equivalent', 'less intense', 'less specific', 'more intense',\n",
       "        'more specific', 'related'], dtype=object),\n",
       " array([22,  4,  5, 18, 33, 21]))"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_corpus = pd.read_csv('eval.csv')\n",
    "\n",
    "print(test_corpus.head())\n",
    "\n",
    "# [8] checking the percentage of majority class and selecting accuracy as evaluation metric\n",
    "label, count = np.unique(test_corpus['ANNOTATED'].values, return_counts=True)\n",
    "print(max(count)/sum(count))\n",
    "\n",
    "test_corpus = test_corpus.fillna('none')\n",
    "\n",
    "np.unique(test_corpus['ANNOTATED'].values, return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CoNn9df5ElzU",
    "outputId": "ff379e5c-dea3-4a18-861b-fb9750aa1de4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BERT model selected           : https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1\n",
      "Preprocess model auto-selected: https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3\n"
     ]
    }
   ],
   "source": [
    "tfhub_handle_encoder = 'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1'\n",
    "tfhub_handle_preprocess = 'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3'\n",
    "\n",
    "print(f'BERT model selected           : {tfhub_handle_encoder}')\n",
    "print(f'Preprocess model auto-selected: {tfhub_handle_preprocess}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "FOuNNuN7E7Uj"
   },
   "outputs": [],
   "source": [
    "bert_preprocess_model = hub.KerasLayer(tfhub_handle_preprocess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "uYSzk8AKE-QL"
   },
   "outputs": [],
   "source": [
    "def1_preprocessed = bert_preprocess_model(synonyms_corpus['DEFINITION 1'])\n",
    "def2_preprocessed = bert_preprocess_model(synonyms_corpus['DEFINITION 2'])\n",
    "ex1_preprocessed = bert_preprocess_model(synonyms_corpus['EXAMPLE 1'])\n",
    "ex2_preprocessed = bert_preprocess_model(synonyms_corpus['EXAMPLE 2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "id": "zd5RgPS9Cocm"
   },
   "outputs": [],
   "source": [
    "#test\n",
    "test_def1_preprocessed = bert_preprocess_model(test_corpus['DEFINITION 1'])\n",
    "test_def2_preprocessed = bert_preprocess_model(test_corpus['DEFINITION 2'])\n",
    "test_ex1_preprocessed = bert_preprocess_model(test_corpus['EXAMPLE 1'])\n",
    "test_ex2_preprocessed = bert_preprocess_model(test_corpus['EXAMPLE 2'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "T8LmJD9gFCtl"
   },
   "outputs": [],
   "source": [
    "bert_model = hub.KerasLayer(tfhub_handle_encoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "1OwLU3WxFEm_",
    "outputId": "78e7b89a-a4ef-4b79-cb12-73b319070d64"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded BERT: https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1\n"
     ]
    }
   ],
   "source": [
    "def1 = bert_model(def1_preprocessed)\n",
    "def2 = bert_model(def2_preprocessed)\n",
    "ex1 = bert_model(ex1_preprocessed)\n",
    "ex2 = bert_model(ex2_preprocessed)\n",
    "\n",
    "print(f'Loaded BERT: {tfhub_handle_encoder}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "id": "zHDWcE4cDMb4"
   },
   "outputs": [],
   "source": [
    "test_def1 = bert_model(test_def1_preprocessed)\n",
    "test_def2 = bert_model(test_def2_preprocessed)\n",
    "test_ex1 = bert_model(test_ex1_preprocessed)\n",
    "test_ex2 = bert_model(test_ex2_preprocessed)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vgq6PpPqGU6f",
    "outputId": "c97052cb-09a4-414f-d818-634c3955e056"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[==================================================] 100.0% 66.0/66.0MB downloaded\n"
     ]
    }
   ],
   "source": [
    "import gensim.downloader as api\n",
    "word_vectors = api.load(\"glove-wiki-gigaword-50\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "iPOiWexCMK9I"
   },
   "outputs": [],
   "source": [
    "from nltk import word_tokenize\n",
    "from nltk.corpus import stopwords\n",
    "import string\n",
    "\n",
    "exclusions = [list(string.punctuation), '``', \"''\"]\n",
    "\n",
    "def preprocess_sent(sentence):\n",
    "    words = []\n",
    "    if not sentence != sentence:\n",
    "        for word in word_tokenize(sentence):\n",
    "            word = word.lower()\n",
    "            if word not in exclusions and word not in words:\n",
    "                words.append(word)   \n",
    "    return words\n",
    "\n",
    "\n",
    "def common_occurences(words1, words2):    \n",
    "    return len(set(words1) & set(words2))\n",
    "        \n",
    "def extract_features(X):\n",
    "    X_features = []\n",
    "    for i in range(X.shape[0]):\n",
    "        features = []\n",
    "        example1 = preprocess_sent(X['EXAMPLE 1'][i])\n",
    "        example2 = preprocess_sent(X['EXAMPLE 2'][i])\n",
    "        features.append(common_occurences(example1, example2))\n",
    "        \n",
    "        definition1 = preprocess_sent(X['DEFINITION 1'][i])\n",
    "        definition2 = preprocess_sent(X['DEFINITION 2'][i])\n",
    "        features.append(common_occurences(definition1, definition2))\n",
    "        \n",
    "        X_features.append(features)\n",
    "        \n",
    "    return np.array(X_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "jvtBFhJETVvA"
   },
   "outputs": [],
   "source": [
    "corpus_features = extract_features(synonyms_corpus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "id": "wzoU-m0DB28V"
   },
   "outputs": [],
   "source": [
    "test_corpus_features = extract_features(test_corpus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "id": "9bznwnO8MYk2"
   },
   "outputs": [],
   "source": [
    "wmd_similarities = []\n",
    "for i in range(len(synonyms_corpus)):  \n",
    "  definition1 = preprocess_sent(synonyms_corpus['DEFINITION 1'][i])\n",
    "  definition2 = preprocess_sent(synonyms_corpus['DEFINITION 2'][i])\n",
    "  wmd_similarities.append(word_vectors.wmdistance(definition1, definition2))\n",
    "\n",
    "wmd_similarities_ex = []\n",
    "for i in range(len(synonyms_corpus)):  \n",
    "  example1 = preprocess_sent(synonyms_corpus['EXAMPLE 1'][i])\n",
    "  example2 = preprocess_sent(synonyms_corpus['EXAMPLE 2'][i])\n",
    "  wmd_similarities_ex.append(word_vectors.wmdistance(example1, example2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "id": "4zD97Iu3DiGh"
   },
   "outputs": [],
   "source": [
    "test_wmd_similarities = []\n",
    "for i in range(len(test_corpus)):  \n",
    "  definition1 = preprocess_sent(test_corpus['DEFINITION 1'][i])\n",
    "  definition2 = preprocess_sent(test_corpus['DEFINITION 2'][i])\n",
    "  test_wmd_similarities.append(word_vectors.wmdistance(definition1, definition2))\n",
    "\n",
    "test_wmd_similarities_ex = []\n",
    "for i in range(len(test_corpus)):  \n",
    "  example1 = preprocess_sent(test_corpus['EXAMPLE 1'][i])\n",
    "  example2 = preprocess_sent(test_corpus['EXAMPLE 2'][i])\n",
    "  test_wmd_similarities_ex.append(word_vectors.wmdistance(example1, example2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "id": "AIAehWp9OBq2"
   },
   "outputs": [],
   "source": [
    "wmd_similarities = np.array(wmd_similarities).reshape(len(wmd_similarities), 1)\n",
    "wmd_similarities_ex = np.array(wmd_similarities_ex).reshape(len(wmd_similarities_ex), 1)\n",
    "# wmd_similarities_develop = np.array(wmd_similarities_develop).reshape(len(wmd_similarities_develop), 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "id": "hy4ESTNpD2Fd"
   },
   "outputs": [],
   "source": [
    "test_wmd_similarities = np.array(test_wmd_similarities).reshape(len(test_wmd_similarities), 1)\n",
    "test_wmd_similarities_ex = np.array(test_wmd_similarities_ex).reshape(len(test_wmd_similarities_ex), 1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4Lmy6f4l0KnM",
    "outputId": "c3ea4a5c-3bfd-4c08-dd57-0af08f285d28"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
      "[nltk_data]   Unzipping corpora/wordnet.zip.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.download('wordnet')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "Ri0S19od0sFR"
   },
   "outputs": [],
   "source": [
    "from nltk.corpus import wordnet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_m_VW6ED8dcw",
    "outputId": "758f23fb-8693-4d71-88b4-ecf31a181fa3"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py:3441: RuntimeWarning: Mean of empty slice.\n",
      "  out=out, **kwargs)\n",
      "/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py:189: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "from nltk.corpus import wordnet\n",
    "\n",
    "w_similarities = []\n",
    "for i in range(len(synonyms_corpus)):  \n",
    "  # print(i)\n",
    "  w_sim = []\n",
    "  for one, two in itertools.product(synonyms_corpus['LEMMA 1'][i].split(','), synonyms_corpus['LEMMA 2'][i].split(',')):\n",
    "    \n",
    "    first_word = wordnet.synsets(one.strip())\n",
    "    # print(first_word)\n",
    "    second_word = wordnet.synsets(two.strip())\n",
    "    # print(first_word[0].wup_similarity(second_word[0]))\n",
    "    if len(first_word) != 0 and len(second_word) != 0:  \n",
    "      sim = first_word[0].wup_similarity(second_word[0])\n",
    "      if sim != None:\n",
    "        w_sim.append(first_word[0].wup_similarity(second_word[0]))\n",
    "    # print(w_sim)\n",
    "  # print(f\"{i}: {np.mean(np.array(w_sim))}\")\n",
    "  w_similarities.append(np.mean(np.array(w_sim)))\n",
    "\n",
    "wordnet_sim = np.nan_to_num(w_similarities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "B2ITKZ-IEJdN",
    "outputId": "dcddc7fb-040d-4db6-e466-4183f3c0806a"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py:3441: RuntimeWarning: Mean of empty slice.\n",
      "  out=out, **kwargs)\n",
      "/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py:189: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    }
   ],
   "source": [
    "test_w_similarities = []\n",
    "for i in range(len(test_corpus)):  \n",
    "  # print(i)\n",
    "  w_sim = []\n",
    "  for one, two in itertools.product(test_corpus['LEMMA 1'][i].split(','), test_corpus['LEMMA 2'][i].split(',')):\n",
    "    \n",
    "    first_word = wordnet.synsets(one.strip())\n",
    "    # print(first_word)\n",
    "    second_word = wordnet.synsets(two.strip())\n",
    "    # print(first_word[0].wup_similarity(second_word[0]))\n",
    "    if len(first_word) != 0 and len(second_word) != 0:  \n",
    "      sim = first_word[0].wup_similarity(second_word[0])\n",
    "      if sim != None:\n",
    "        w_sim.append(first_word[0].wup_similarity(second_word[0]))\n",
    "    # print(w_sim)\n",
    "  # print(f\"{i}: {np.mean(np.array(w_sim))}\")\n",
    "  test_w_similarities.append(np.mean(np.array(w_sim)))\n",
    "\n",
    "test_wordnet_sim = np.nan_to_num(test_w_similarities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "id": "B97S_SKf6rLx"
   },
   "outputs": [],
   "source": [
    "# label processing\n",
    "# Fit LabelEncoder with our list of classes\n",
    "label_encoder = LabelEncoder()\n",
    "y = synonyms_corpus['LABEL'].values\n",
    "label_encoder.fit(y)\n",
    "# Encode class values as integers\n",
    "y_encoded = label_encoder.transform(y)\n",
    "y_encoded_cat = np_utils.to_categorical(y_encoded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "id": "G3ilI2H6EXVU"
   },
   "outputs": [],
   "source": [
    "# label processing\n",
    "# Fit LabelEncoder with our list of classes\n",
    "label_encoder = LabelEncoder()\n",
    "test_y = test_corpus['ANNOTATED'].values\n",
    "label_encoder.fit(test_y)\n",
    "# Encode class values as integers\n",
    "test_y_encoded = label_encoder.transform(test_y)\n",
    "# y_encoded_cat = np_utils.to_categorical(y_encoded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "id": "wUlGH32jQexN"
   },
   "outputs": [],
   "source": [
    "corpus_pooled = np.concatenate((\n",
    "                             def1['pooled_output'], \n",
    "                             def2['pooled_output'],\n",
    "                            #  ex1['pooled_output'], \n",
    "                            #  ex2['pooled_output'],\n",
    "                             corpus_features,\n",
    "                            #  wordnet_sim.reshape(len(synonyms_corpus), 1),\n",
    "                             wmd_similarities,\n",
    "                            #  wmd_similarities_ex,\n",
    "                            #  y_encoded_cat,\n",
    "                             y_encoded.reshape(len(y_encoded), 1)\n",
    "                             ), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "id": "K-ccZbB8Ei9g"
   },
   "outputs": [],
   "source": [
    "test_corpus_pooled = np.concatenate((\n",
    "                             test_def1['pooled_output'], \n",
    "                             test_def2['pooled_output'],\n",
    "                            #  test_ex1['pooled_output'], \n",
    "                            #  test_ex2['pooled_output'],\n",
    "                             test_corpus_features,\n",
    "                            #  wordnet_sim.reshape(len(synonyms_corpus), 1),\n",
    "                             test_wmd_similarities,\n",
    "                            #  test_wmd_similarities_ex,\n",
    "                            #  y_encoded_cat,\n",
    "                             ), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FkadIr4FWEw5",
    "outputId": "2802bc9f-17ee-47c3-baf2-ff2db3b346d1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(794, 260)"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splits = []\n",
    "corpus_len = len(corpus_pooled)\n",
    "develop_size = int(corpus_len / 3)\n",
    "for i in range(10):\n",
    "  copy = np.copy(corpus_pooled)\n",
    "  np.random.shuffle(copy)  \n",
    "  splits.append({'train': copy[:(corpus_len - develop_size), :], 'develop': copy[(corpus_len - develop_size):, :]})\n",
    "\n",
    "splits[0]['train'].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "id": "q1PaL1OIWKqC"
   },
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC, LinearSVC\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "# classifier = DecisionTreeClassifier()\n",
    "# classifier = LinearSVC(C=0.1)\n",
    "classifier = RandomForestClassifier(n_estimators=10, max_depth=4, criterion='entropy')\n",
    "# classifier = MLPClassifier(solver='adam', max_iter=500, batch_size=10, learning_rate='adaptive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "4vfLquFNYGPb",
    "outputId": "64d58e89-ee64-4191-a959-b45b30af7cad"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.5088161209068011\n",
      "DEVELOP ACCURACY: 0.48737373737373735\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU5fXH8c9JWMIOssm+KMqaBIggRJSCda0gVaooilq3uuBStWrVorWtVVt/2tpaa1ur1aLiUrVUaxUUAZFFdgEREYKACIKAAlnO7497M0xCliFmMpPk+3695sXce59758w4zslz77nPY+6OiIhIsklJdAAiIiIlUYISEZGkpAQlIiJJSQlKRESSkhKUiIgkJSUoERFJSkpQIlXEzIaZ2cpExyFSXShBSa1gZmvN7PhExuDuM9z9yHgd38xONLN3zGynmW0xs7fNbFS8Xk8k3pSgRCqJmaUm8LXPBJ4DngA6Am2BO4DTKnAsMzP9NkjC6UsotZqZpZjZzWb2sZltNbNnzeyQqO3PmdkmM9sR9k76RG173Mz+aGZTzWw38J2wp3aDmS0O93nGzNLC9sPNLCdq/1LbhttvMrONZvaZmV1sZm5mh5fwHgz4LfBzd3/M3Xe4e4G7v+3ul4RtJpnZP6L26Roer064PN3MfmFmM4GvgRvNbF6x17nOzF4On9c3s/vNbJ2ZbTazR8yswbf8zyFShBKU1HZXA6cDxwHtgS+Bh6O2/wfoAbQBFgBPFdv/HOAXQBPg3XDdD4CTgG5AOnBBGa9fYlszOwm4HjgeOBwYXsYxjgQ6AVPKaBOL84BLCd7LI8CRZtYjavs5wNPh83uAI4DMML4OBD02kUqjBCW13eXAT909x933ApOAMwt7Fu7+V3ffGbUtw8yaRe3/L3efGfZY9oTrHnL3z9x9G/AKwY94aUpr+wPgb+6+zN2/Dl+7NC3DfzfG+qZL8Xj4ennuvgP4FzAOIExUPYGXwx7bpcB17r7N3XcCvwTO/pavL1KEEpTUdl2AF81su5ltBz4E8oG2ZpZqZveEp/++AtaG+7SK2n99CcfcFPX8a6BxGa9fWtv2xY5d0usU2hr+266MNrEo/hpPEyYogt7TS2GybA00BOZHfW6vhetFKo0SlNR264GT3b151CPN3TcQ/CiPJjjN1gzoGu5jUfvHazqAjQTFDoU6ldF2JcH7OKOMNrsJkkqhQ0toU/y9vAG0NrNMgkRVeHrvC+AboE/UZ9bM3ctKxCIHTQlKapO6ZpYW9ahDcK3lF2bWBcDMWpvZ6LB9E2AvQQ+lIcFprKryLHChmfUys4bA7aU19GDOnOuB283sQjNrGhZ/HGNmj4bNFgLHmlnn8BTlLeUF4O65BJWB9wGHECQs3L0A+DPwgJm1ATCzDmZ2YoXfrUgJlKCkNplK8Jd/4WMS8CDwMvBfM9sJvAcMDts/AXwKbACWh9uqhLv/B3gImAasjnrtvaW0nwKcBVwEfAZsBu4muI6Eu78BPAMsBuYDr8YYytMEPcjn3D0vav1PCuMKT3/+j6BYQ6TSmCYsFEl+ZtYLWArUL5YoRGos9aBEkpSZjQnvN2oB/Bp4RclJahMlKJHkdRnwOfAxQWXhjxIbjkjV0ik+ERFJSupBiYhIUqqT6AAOVqtWrbxr166JDkNERCrJ/Pnzv3D3A270jmuCCscTexBIBR5z93uKbe8C/JXgDvRtwHh3zzngQFG6du3KvHnzymoiIiLViJl9WtL6uJ3iC6ceeBg4GegNjDOz3sWa3Q884e7pwF3Ar+IVj4iIVC/xvAY1CFjt7mvcfR8wmWDYmGi9gbfC59NK2C4iIrVUPBNUB4oOPpkTrou2CPh++HwM0MTMWhZrg5ldambzzGzeli1b4hKsiIgkl0QXSdwA/N7MLgDeIRhSJr94I3d/FHgUICsrS3XxIgmQm5tLTk4Oe/bsKb+xSAnS0tLo2LEjdevWjal9PBPUBoqOwNwxXBfh7p8R9qDMrDFwhrtvj2NMIlJBOTk5NGnShK5duxJMCSUSO3dn69at5OTk0K1bt5j2iecpvrlADzPrZmb1CCYzezm6gZm1MrPCGG4hqOgTkSS0Z88eWrZsqeQkFWJmtGzZ8qB64HFLUOGYYVcBrxNMAvesuy8zs7vMbFTYbDiw0sxWAW0Jps4WkSSl5CTfxsF+f+J6DcrdpxJMcRC97o6o51OAKfGM4QDbPoBvNkKHU6r0ZUVE5ODUrqGO3OGDH8PMH8CXixIdjYgchK1bt5KZmUlmZiaHHnooHTp0iCzv27evzH3nzZvHxIkTy32NoUOHVla4Ugmq3WCxWVlZ/q1GkvhmI7x2FFgKnDgXGrStvOBEarAPP/yQXr16JToMACZNmkTjxo254YYbIuvy8vKoUyfRhcnxUZPeW0nfIzOb7+5ZxdvWrh4UQIN2cNzLsPcLmDEG8lUyK1JdXXDBBVx++eUMHjyYm266iffff58hQ4bQv39/hg4dysqVKwGYPn063/ve94AguV100UUMHz6c7t2789BDD0WO17hx40j74cOHc+aZZ9KzZ0/OPfdcCv+Ynzp1Kj179mTgwIFMnDgxctxoy5YtY9CgQWRmZpKens5HH30EwBNPPEF6ejoZGRmcd955AKxdu5YRI0aQnp7OyJEjWbduXYnv7eOPP+akk05i4MCBDBs2jBUrVsTpU00eNSMlH6xDBsCQJ+HdM2HOJTDkCdDFX5HYzb8WvlxYucdskQkD/++gd8vJyWHWrFmkpqby1VdfMWPGDOrUqcP//vc/br31Vp5//vkD9lmxYgXTpk1j586dHHnkkfzoRz864N6cDz74gGXLltG+fXuys7OZOXMmWVlZXHbZZbzzzjt069aNcePGlRjTI488wjXXXMO5557Lvn37yM/PZ9myZdx9993MmjWLVq1asW3bNgCuvvpqJkyYwIQJE/jrX//KxIkTeemllw54byNHjuSRRx6hR48ezJkzhyuuuIK33nqrxNevKWpnggLofAak/xwW3w7N+kCfmxMdkYhUwNixY0lNTQVgx44dTJgwgY8++ggzIzc3t8R9Tj31VOrXr0/9+vVp06YNmzdvpmPHjkXaDBo0KLIuMzOTtWvX0rhxY7p37x65j2fcuHE8+uijBxx/yJAh/OIXvyAnJ4fvf//79OjRg7feeouxY8fSqlUrAA455BAAZs+ezQsvvADAeeedx0033XTAe9u1axezZs1i7NixkW179+6t0OdVndTeBAXQ56ewYzksugWa9oROpyc6IpHqoQI9nXhp1KhR5Pntt9/Od77zHV588UXWrl3L8OHDS9ynfv36keepqank5eVVqE1pzjnnHAYPHsy///1vTjnlFP70pz/FvG+0wvdWUFBA8+bNWbiwknutSa72XYOKZgaD/wItB8Hs8ZV/ykJEqtSOHTvo0CEY8vPxxx+v9OMfeeSRrFmzhrVr1wLwzDPPlNhuzZo1dO/enYkTJzJ69GgWL17MiBEjeO6559i6dStA5BTf0KFDmTx5MgBPPfUUw4YNO+B4TZs2pVu3bjz33HNAMCrDokU1vxK5dicogDoN4NiXoF4LeHsUfLMp0RGJSAXddNNN3HLLLfTv3/+gejyxatCgAX/4wx8ixQpNmjShWbNmB7R79tln6du3L5mZmSxdupTzzz+fPn368NOf/pTjjjuOjIwMrr/+egB+97vf8be//Y309HSefPJJHnzwwRJf+6mnnuIvf/kLGRkZ9OnTh3/961+V/v6STe0rMy/Ntg/gjWOgeTocPw1S0yr/NUSqsWQqM0+kXbt20bhxY9ydK6+8kh49enDdddclOqxqQ2XmFXFIfxj6JGx9D+ZcHNzUKyJSzJ///GcyMzPp06cPO3bs4LLLLkt0SDVW7S6SKK7T9yH9blh8W1jZd0uiIxKRJHPdddepx1RFlKCK63NrWNl3a1jZNybREYmI1Eo6xVecGQx+DFoOhlnjg2tTIiJS5ZSgSlJY2Vf/EHhHlX0iIomgBFWaBofCsS/D3m3wzukas09EpIopQZUlUtk3B977oSr7RBJs06ZNnH322Rx22GEMHDiQU045hVWrViU6rAM8/vjjXHXVVUAwLt8TTzxxQJu1a9fSt2/fMo+zdu1ann766chyrNOG1BQqkihPdGVf8z5BEYWIVDl3Z8yYMUyYMCEy8sKiRYvYvHkzRxxxRKRdsk1Ncfnll1d438IEdc455wCQlZVFVtYBtwslXLw+c/WgYtHnVuhyDiz6Kax/IdHRiNRK06ZNo27dukV+8DMyMhg2bBjTp09n2LBhjBo1it69e7Nnzx4uvPBC+vXrR//+/Zk2bRpQ8jQYu3fv5tRTTyUjI4O+ffseMHxRQUEBXbt2Zfv27ZF1PXr0YPPmzbzyyisMHjyY/v37c/zxx7N58+YD4p40aRL3338/APPnzycjI4OMjAwefvjhSJu1a9cybNgwBgwYwIABA5g1axYAN998MzNmzCAzM5MHHnigyLQh27Zt4/TTTyc9PZ2jjz6axYsXR16vtOlECuXn53PBBRfQt29f+vXrxwMPPADA6tWrOf7448nIyGDAgAF8/PHHuDs33nhjpG3h51P8M8/Pz+fGG2/kqKOOIj09vcLjD0ZLnj8zkpkZHP0X2PUxzDoPvtstOP0nUktd+9q1LNxUuWNXZh6ayf+dVPogtEuXLmXgwIGlbl+wYAFLly6lW7du/OY3v8HMWLJkCStWrOCEE05g1apVJU6DMXXqVNq3b8+///1vIBjPL1pKSgqjR4/mxRdf5MILL2TOnDl06dKFtm3bcswxx/Dee+9hZjz22GPce++9/OY3vyk1xgsvvJDf//73HHvssdx4442R9W3atOGNN94gLS2Njz76iHHjxjFv3jzuuece7r//fl599VUgSAqFfvazn9G/f39eeukl3nrrLc4///zIYLLlTSeycOFCNmzYwNKlSwEiyffcc8/l5ptvZsyYMezZs4eCggJeeOEFFi5cyKJFi/jiiy846qijOPbYYw/4zB999FGaNWvG3Llz2bt3L9nZ2ZxwwgmRkd8rQj2oWKWmhZV9LcPKvo2JjkhEogwaNCjyY/juu+8yfvx4AHr27EmXLl1YtWoVQ4YM4Ze//CW//vWv+fTTT2nQoAH9+vXjjTfe4Cc/+QkzZswocWy9s846K9JzmDx5MmeddRYQzNd04okn0q9fP+677z6WLVtWanzbt29n+/btkR/3wgkLAXJzc7nkkkvo168fY8eOZfny5eW+33fffTdyjBEjRrB161a++uorYP90Iq1atYpMJxKte/furFmzhquvvprXXnuNpk2bsnPnTjZs2MCYMcG9n2lpaTRs2JB3332XcePGkZqaStu2bTnuuOOYO3fuAZ/5f//7X5544gkyMzMZPHgwW7dujUzUWFHqQR2MBocGs/H+NxveGQMjpwUl6SK1TFk9nXjp06cPU6ZMKXV79LQbpSlpGowRI0awYMECpk6dym233cbIkSM58cQTI0MY3XXXXZx22mmsXr2aLVu28NJLL3HbbbcBwWSD119/PaNGjWL69OlMmjSpQu/tgQceoG3btixatIiCggLS0r7dWKDlTRXSokULFi1axOuvv84jjzzCs88+W+ogtWWJ/szdnd/97neceOKJFQ+8GPWgDlaLTBj6j6Cyb44q+0SqyogRI9i7d2+RCQIXL17MjBkzDmg7bNgwnnrqKQBWrVrFunXrIlNlFJ8G47PPPqNhw4aMHz+eG2+8kQULFjB48GAWLlzIwoULGTVqFGbGmDFjuP766+nVqxctW7YEik7v8fe//73M+Js3b07z5s159913ASLxFR6nXbt2pKSk8OSTT5Kfnw9AkyZN2LlzZ4nHi36P06dPp1WrVjRt2jSmz/KLL76goKCAM844g7vvvpsFCxbQpEkTOnbsGJnNd+/evXz99dcMGzaMZ555hvz8fLZs2cI777zDoEGDDjjmiSeeyB//+MfIJJGrVq1i9+7dMcVTGiWoiug0BjJ+AZ/+E5b9MtHRiNQKZsaLL77I//73Pw477DD69OnDLbfcwqGHHnpA2yuuuIKCggL69evHWWedxeOPP079+vVLnAZjyZIlkcKJO++8M9I7Ku6ss87iH//4R+T0HgQFCWPHjmXgwIGRmXLL8re//Y0rr7ySzMxMomeSuOKKK/j73/9ORkYGK1asiPRM0tPTSU1NJSMjI1LIEP3a8+fPJz09nZtvvrncBBltw4YNDB8+nMzMTMaPH8+vfvUrAJ588kkeeugh0tPTGTp0KJs2bWLMmDGkp6eTkZHBiBEjuPfee0v8zC+++GJ69+7NgAED6Nu3L5dddtm3nvJE021UlDvMPg/WPgXHTAmmkBepwTTdhlQGTbdRFSJj9h0Ns8/XmH0iIpVMCerbSE2DY19UZZ+ISBwoQX1bhZV9hWP25X2T6IhE4qa6XRKQ5HKw3x8lqMrQIhOGPgVb31dln9RYaWlpbN26VUlKKsTd2bp160GV0Os+qMrS6XTI+GUw0WGz3tC35EogkeqqY8eO5OTksGXLlkSHItVUWloaHTt2jLm9ElRl6n1zMBvv4tuhaS9V9kmNUrdu3W81bI3IwdIpvspkBoP/HFb2nQfbFiQ6IhGRaksJqrJFxuxrBW+rsk9EpKKUoOKhQVs47hXI3Q5vj1Zln4hIBcQ1QZnZSWa20sxWm9nNJWzvbGbTzOwDM1tsZqfEM54q1SIDhvwDts2DORepsk9E5CDFLUGZWSrwMHAy0BsYZ2a9izW7DXjW3fsDZwN/iFc8CVFY2ffpZFh6d6KjERGpVuLZgxoErHb3Ne6+D5gMjC7WxoHC4XebAZ/FMZ7E6P0T6HoeLLkD1pU+VYCIiBQVzwTVAVgftZwTros2CRhvZjnAVODqkg5kZpea2Twzm1ft7sEwg8GPQqsh4Zh98xMdkYhItZDoIolxwOPu3hE4BXjSzA6Iyd0fdfcsd89q3bp1lQf5raWmwbAXoX7roGji65rXURQRqWzxTFAbgE5Ryx3DddF+CDwL4O6zgTSg/ElVqqPoyj6N2SciUq54Jqi5QA8z62Zm9QiKIF4u1mYdMBLAzHoRJKhqdg7vILRID8bs2zYP3rtQlX0iImWIW4Jy9zzgKuB14EOCar1lZnaXmY0Km/0YuMTMFgH/BC7wmj4SZcfRkPkrWPcMLP15oqMREUlacR2Lz92nEhQ/RK+7I+r5ciA7njEkpV43BWP2LfkZNOsFnccmOiIRkaST6CKJ2skMBj0KrYbC7Amq7BMRKYESVKKk1g9n420djNmnyj4RkSKUoBIprU1Y2bcD3hkNeV8nOiIRkaShBJVoLdJh6NPBaT5V9omIRChBJYOOoyDzHlj3LCy9K9HRiIgkBc2omyx63Qg7lsGSScFsvF1+kOiIREQSSj2oZFFY2dc6G96bAFvnJToiEZGEUoJKJqn1YdgLkNY2KJr4uvjIUCIitYcSVLJJawPHvgy5X6myT0RqNSWoZBSp7Fugyj4RqbWUoJJVx9Mg89eq7BORWktVfMms1w2q7BORWks9qGRmBoP+FFXZNzfREYmIVBklqGSnyj4RqaWUoKqDyJh9O1XZJyK1hhJUddG8H2T/M6zsuwC8INERiYjElRJUddLhe9D/Xlj3HCxRZZ+I1Gyq4qtuev44mI136Z3BbLxdzkp0RCIicaEeVHVjBkf9EVofE5zqU2WfiNRQSlDVUaSy71BV9olIjaUEVV2ltd5f2ff2KFX2iUiNE3OCMrOG8QxEKqB536Cy78sPYPYEVfaJSI1SboIys6FmthxYES5nmNkf4h6ZxKawsm/9FFhyZ6KjERGpNLH0oB4ATgS2Arj7IuDYeAYlB6nnj6H7hcGgsmsnJzoaEZFKEdMpPndfX2xVfhxikYqKruybcyF88X6iIxIR+dZiSVDrzWwo4GZW18xuAD6Mc1xysA6o7MtJdEQiIt9KLAnqcuBKoAOwAcgMlyXZFFb25e2Ct0dD3u5ERyQiUmFlJigzSwUedPdz3b2tu7dx9/HuvrWK4pOD1bwvZE9WZZ+IVHtlJih3zwe6mFm9KopHKkOHU6H/fbD++WCyQxGRaiiWsfjWADPN7GUgcs7I3X8bt6jk2+t5fThm38+D2Xi7jkt0RCIiByWWBPVx+EgBmsQ3HKk0hZV9Oz+C9y6Ext2h1eBERyUiErNyE5S73wlgZo3D5V3xDkoqSWo9GPY8vD4Y3jkdTnwfGnVKdFQiIjGJZSSJvmb2AbAMWGZm882sT/xDk0oRqezbHc7Gq8o+EakeYikzfxS43t27uHsX4MfAn2M5uJmdZGYrzWy1md1cwvYHzGxh+FhlZtsPLnyJSfM+QWXf9kUw+3xV9olItRBLgmrk7tMKF9x9OtCovJ3CEvWHgZOB3sA4M+sd3cbdr3P3THfPBH4HvHAQscvB6HAKZN4H61+AxT9LdDQiIuWKJUGtMbPbzaxr+LiNoLKvPIOA1e6+xt33AZOB0WW0Hwf8M4bjSkX1vA4O+yEsuxvWPp3oaEREyhRLgroIaE3Qu3keaBWuK08HIHoMv5xw3QHMrAvQDXirlO2Xmtk8M5u3ZcuWGF5aSmQGWX+ANsfCexfBF3MSHZGISKnKTVDu/qW7T3T3Ae4+0N2vdfcvKzmOs4Ep4Y3BJcXwqLtnuXtW69atK/mla5nUenDM89CgfVDZt7v4OMAiIskhliq+N8ysedRyCzN7PYZjbwCia5o7hutKcjY6vVd10lpFVfaNUmWfiCSlWE7xtXL3SHVd2HtqE8N+c4EeZtYtHCrpbODl4o3MrCfQApgdW8hSKZr3gWOege2LVdknIkkplgRVYGadCxfC60Ve3k7ungdcBbxOMD3Hs+6+zMzuMrNRUU3PBia7e7nHlErW/mTof39Y2XdHoqMRESkilqGOfgq8a2ZvAwYMAy6N5eDuPhWYWmzdHcWWJ8UUqcTHkdcGY/Yt+wU06w1dz0l0RCIiQGxDHb1mZgOAowl6Tte6+xdxj0yqhhlkPRyO2XcRND5MY/aJSFIo9RSfmXUxs2YAYULaDZwAnK/pN2qY1HpwzBRo2CEYDkmVfSKSBMq6BvUs4YgRZpYJPAesAzKAP8Q/NKlShZV9+d+osk9EkkJZCaqBu38WPh8P/NXdfwNcSDBKhNQ0zXqHY/YthlnnqbJPRBKqrARlUc9HAG8CuOtXq0ZrfzL0/w3kvAiLb090NCJSi5VVJPGWmT0LbCS4T+ktADNrB+yrgtgkUY68BnYsg2W/hKa9odu5iY5IRGqhsnpQ1xKMv7cWOMbdc8P1hxKUnktNVVjZ1+Y4mPND+OK9REckIrVQqT2o8MbZySWs/yCuEUlyiMzGOyhqNt7O5e8nIlJJYhlJQmqr+i33V/a9PQpydyU6IhGpRZSgpGzNekP2M7BjCcxWZZ+IVJ1YRjM/zcyUyGqz9idB/99Czkuw6LZERyMitUQsiecs4CMzuzcceVxqoyMnwmGXwPJfwSf/SHQ0IlILxDJh4XigP/Ax8LiZzQ5nuG0S9+gkeZhB1u+hzfCgsm+LZkcRkfiK6dSdu38FTCGo6msHjAEWmNnVcYxNkk1qPRg2BRp2ghmnw+5PEx2RiNRgsVyDGmVmLwLTgbrAIHc/mWBMvh/HNzxJOpHKvj2q7BORuIqlB3UG8IC793P3+9z9cwB3/xr4YVyjk+TUrFdY2bcUZo9XZZ+IxEUsCWoS8H7hgpk1MLOuAO7+ZlyikuTX/iQY8ADk/AsWaWAREal8sSSo54DoP5Hzw3VS2x1xNRx+KSy/B5beDXnfJDoiEalBYklQddw9Mjhs+FwTFsr+yr5OZwQjn796BHz8FyjIS3RkIlIDxJKgtpjZqMIFMxsNaMp3CaTUDSr7Rr4FDTrAnIthal9YNwXcEx2diFRjsSSoy4FbzWydma0HfgJcFt+wpNpp+x04YTYMexEsFd4dGww0u+l/iY5MRKqpWG7U/djdjwZ6A73cfai7r45/aFLtmEGn0+HkxXD047Dnc3jru/DmSPji/XJ3FxGJVtaEhRFmdirQB0gzCybadfe74hiXVGcpqdB9AnQ5Gz56BJb9Av47GDp9H9LvDsrURUTKEcuNuo8QjMd3NcE08GOBLnGOS2qC1PrQ8xoY9TH0uxM2vhFcn3rvIti9LtHRiUiSi+Ua1FB3Px/40t3vBIYAR8Q3LKlR6jaBfncEieqIa2DtU/BKD5h/PezZkujoRCRJxZKg9oT/fm1m7YFcgvH4RA5OWmsY+Fs47SPoOh5WPQgvHwZL7oTcnYmOTkSSTCwJ6hUzaw7cBywA1gJPxzMoqeEadYaj/wKnLIV234Ulk+Dl7rDiQcjfm+joRCRJlJmgwokK33T37e7+PMG1p57ufkeVRCc1W7NeMOx5OGEONE+HBdfCK0fAmsehID/R0YlIgpWZoNy9AHg4anmvu++Ie1RSu7QaBCPfhBFvBKcB37sQ/pMO61/Szb4itVgsp/jeNLMzrLC+XCReDj0eTpwLx0wBz4cZY+C/Q2DztERHJiIJEEuCuoxgcNi9ZvaVme00s6/iHJfUVmbQ+Yzg+tTgx+CbDfDmCHjrRNg2P9HRiUgVimUkiSbunuLu9dy9abjctCqCk1ospQ4c9kP43irofz9smwevZcG7Z8FXqxIdnYhUgXJHkjCzY0ta7+7vVH44IsXUaQC9fgyHXQwrfgMrfgvrn4fuFwX3VjXsmOgIRSROYjnFd2PU43bgFYJJDMtlZieZ2UozW21mN5fS5gdmttzMlpmZytelZPWaQfpdcNrH0ONK+OTx4GbfD26CvVsTHZ2IxIH5QVZJmVkn4P/c/Yxy2qUCq4DvAjnAXGCcuy+PatMDeBYY4e5fmlmbwinlS5OVleXz5s07qJilBtq1Fpb8DD55MhipotdN0PNaqNMo0ZGJyEEys/nunlV8fSw9qOJygFhG+xwErHb3NeEkh5OB0cXaXAI87O5fApSXnEQiGneFIX+HUxZDm+Gw+LZgVIpVD0P+vvL2FpFqIJbBYn9nZg+Fj98DMwhGlChPB2B91HJOuC7aEcARZjbTzN4zs5NKieFSM5tnZvO2bNHYbRKleV847l/w3VnQ9EiYdxW82hM++Ydu9hWp5lOkBFkAABagSURBVGLpQc0D5oeP2cBP3H18Jb1+HaAHMBwYB/w5HFapCHd/1N2z3D2rdevWlfTSUqO0HgIjp8Pw/0C95jD7PHitP2x4VTf7ilRTscwHNQXY4+75EFxbMrOG7v51OfttADpFLXcM10XLAea4ey7wiZmtIkhYc2OKXiSaGbQ/CdqdAOueg0W3wdunQetsyPgVtBmW6AhF5CDENJIE0CBquQEQyzzec4EeZtbNzOoBZwMvF2vzEkHvCTNrRXDKb00MxxYpnaVAl7Pge8vhqEdg1xr437Ew/VT4clGioxORGMWSoNLcfVfhQvi8YXk7uXsecBXwOvAh8Ky7LzOzu8xsVNjsdWCrmS0HpgE3urtqhqVypNSFHpfBaash89ewZRb8JxNmngs7P050dCJSjnLLzM1sJnC1uy8IlwcCv3f3IVUQ3wFUZi4Vtu9LWH4frPw/KMiFwy+BvrdDA01vJpJI36bM/FrgOTObYWbvAs8Q9IxEqpd6LSDzl8HMvodfCqv/HJSmL7wV9m1PdHQiUkxMN+qaWV3gyHBxZVjUkBDqQUml2fkxLL4DPn0a6jaHPjfDEVdDnXLPYItIJapwD8rMrgQauftSd18KNDazK+IRpEiVanIYZD8FJy8MKv0W3gyvHA4f/Sk4BSgiCRXLKb5L3D1y/iMc9eGS+IUkUsVaZMDwV+H4d6Bxd5h7ObzaG9ZOBi9IdHQitVYsCSo1erLCcIy9evELSSRB2gyD42fAca8Go6jPGgevDYTPXtPNviIJEEuCeg14xsxGmtlI4J/hOpGaxww6nAonfQBD/gH7dsD0k+HN4UGZuohUmVgS1E+At4AfhY83CabeEKm5UlKh27nwvRWQ9Xv4aiW8kQ1vj4btSxMdnUitEMuMugXu/oi7n+nuZwLLgd/FPzSRJJBaD464MihNz/gFfD4dpqbD7AnBlB8iEjcxTbdhZv3N7F4zWwvcBayIa1QiyaZOI+hzK4xaA71ugHXPwqtHwLyJ8M3mREcnUiOVmqDM7Agz+5mZrSDoMa0nuG/qO+6uHpTUTvVbQv97g+GTul8IH/0BXjkMFt0eXK8SkUpTVg9qBTAC+J67HxMmJU2wIwLQsAMM+hOcuhzanwrL7oaXu8OHv4G8bxIdnUiNUFaC+j6wEZhmZn8OK/isjPYitU/TI+CYZ+Ck+dDyKPjghuDU38d/gYK8REcnUq2VmqDc/SV3PxvoSTDS+LVAGzP7o5mdUFUBilQLhwyA77wGI9+CBh1gzsUwtS+sm6J7qEQqKJYqvt3u/rS7n0Yw6eAHBKXnIlJc2+/ACbNh2ItgqfDuWHh9EGyKZQo1EYkWUxVfIXf/Mpx+fWS8AhKp9syg0+lw8mI4+nHY8zm89V14cyR88X6ioxOpNg4qQYnIQUhJhe4T4LRVMPBB2L4E/jsYZpwBOz5MdHQiSU8JSiTeUuvDkRODm3373Qkb3wiuT713Eexel+joRJKWEpRIVanbBPrdESSqI66BtU/BKz1g/vWwZ0uioxNJOkpQIlUtrTUM/C2c9hF0HQ+rHgxm9l1yF+TuTHR0IklDCUokURp1hqP/AqcshXYnwJKfBYlqxYOQvzfR0YkkXJ1EByBS6zXrBcOmBBV+i26BBdfCit/CoSOhyeHQ+PDw38OgXrNERytSZZSgRJJFq0Ew8s3gnqnl98LG12DNxqJt6reOSlqH7U9eTQ6HeocEJe4iNYQSlEiyOfT44AGQuwt2rYFdq2Fn+Ni1Opj2Y+2TRfer23x/sopOXI0Ph7Q2Sl5S7ShBiSSzuo2hRXrwKC7vG9j9SdHEtfNj2Pp+MB2IF+xvW6fxgacLCxNYg/ZguhwtyUcJSqS6qtMAmvUOHsXl74Pdnx7Y89q+GDb8Cwpy97dNTdufsIr3vBp2Cm44FkkAJSiRmii1HjTtETyKK8iDr9dH9bqiHhtfh/w9+9um1IXG3aN6XlHXvhp3DbaLxIkSlEhtk1IHGncLHny36DYvgG8+K3baMHx8Ph3ydu9va6nQqMuBva4mhwfHTk2rynclNZASlIjsZynQsGPwaDu86DZ32LP5wMS1azWsnQO50TMKW3B6sEkJPa8mh0GdRlX5rqSaUoISkdiYQYNDg0ebY4puc4d920ruea1/AfZ+UbR9g3Yl97yaHA51m1bde5KkpgQlIt+eGdRvGTxaDT5w+77tsOvjAxPYZ/+BPZuKti1yr1exBFb/kKp5P5IUlKBEJP7qNYdDBgaP4nSvl5RCCUpEEuug7/VaDV/MKf9er+jnDdrpXq9qSAlKRJJXRe/1ynkJPG9/29Q0aNQ16IHVbRwkszpNSnjeJFiuW8r21Ea6L6wKxTVBmdlJwINAKvCYu99TbPsFwH3AhnDV7939sXjGJCI1xMHe67X702A6k7ydQTVi7q7ged6uovd+lfu6DUtOZmU+D/8t6XlqA52aLEXcEpSZpQIPE9xokQPMNbOX3X15sabPuPtV8YpDRGqhsu71KklBbnCPV96uMIntKvq8pHXRz/dtCxJgZN1O8PwYg7WiiausZFb8eWnbU+t/m08vacSzBzUIWO3uawDMbDIwGiieoEREEiulblDIUa955RzPHQr2lZLYdoa9t3Kef7MRdq4K9w3X47G/nwMSV0mnNGM81VmnUZD0q1g8X7EDsD5qOQcoof6UM8zsWGAVcJ27ry/ewMwuBS4F6Ny5cxxCFRGpRGZBLya1PtCqco7pBZD/TdFTk+X17Iqv27ul6Pr8b2J//dS0kk9f9roB2sXQS62ARBdJvAL80933mtllwN+BEcUbufujwKMAWVlZMf4JISJSg1hK0JOp0whoWznHLMgvO8GV1/PL3VF04OFKFs8EtQHoFLXckf3FEAC4+9aoxceAe+MYj4iIREtJDWZpTtKZmuN5Y8BcoIeZdTOzesDZwMvRDcysXdTiKODDOMYjIiLVSNx6UO6eZ2ZXAa8TlJn/1d2XmdldwDx3fxmYaGajgDxgG3BBvOIREZHqxdyr1yWdrKwsnzdvXqLDEBGRSmJm8909q/h6jf0hIiJJSQlKRESSkhKUiIgkJSUoERFJSkpQIiKSlBI9koSIiJTC3XGcAi+IPPIL8ossF3/ke9nbK/sYR3U4iq7Nu8bl/StBiUilcg9+UPMK8sgtyCWvIC/yyM0vthy1vaxtlbKv51X4BzuWH+14HMNjHRw2gR4f/ThdM7vG5dhKUCJJYF/+Pnbt2xV57N63m9yC3Er7QS/tBzteiSNRUiyFOil1qJNSh7opdSPPCx+pKamkWEqJj1QrfVuKpVA3pW6Z+8dyjFjalPcayXaMDk07xO2/pxKUyEHIzc8NEkju7iLJpEhyKWlbbtnt8gryyn/xCij8YY3+ka6bWmy5lO31UuvRsG7D0ve32I8Vj+3Ft9VJqUOKpnWvUZSgpEbKK8iLJIToRFA8oRyQTHLLbrcvf1/MMdRJqUPjeo2LPBrVbcShjQ+NPC+yrV6jIu3qpdar0A914bbCv4BFqislKEmo/IJ8vs79usSEUVYyKa8Xszd/b8wxpFhKiYmkVcNWdG3e9YBkEp1IytpWL7VeHD85kZpPCUq+lR17dvD+hvfZuGtj2ae6Skk83+TFPmGaYSX2NFqktaBT004x9UpK2lY/tT5mFsdPSUQqQglKYuburN2+lpnrZzJz3Uxm5cxiyeYlJVYaNarb6ICeRpN6TWjXuF25iaS0XkmDOg2USERqESUoKdW+/H18sPEDZq6fyaz1s5i5fiabdm0CoEm9JgzpNITv9/w+QzsNpXuL7pFk0rBuQ137EJFvTQlKIrZ+vZVZ62dFktHcz+ayJ28PAN2ad2Nkt5Fkd8omu3M2fVr3ITUlNcERi0hNpgRVS7k7K7euDJLRupnMXD+TlVtXAkH12YB2A/hR1o/I7pTN0E5DadekXTlHFBGpXEpQtcQ3ud8w77N5wfWj9TOZvX42W7/ZCsAhDQ5haKehXJB5AUM7DeWo9kfRoG6DBEcsIrWdElQNtWnXpkjPaNb6WSzYuCByh/+RLY9k9JGjGdppKNmdszmi5RG6ZiQiSUcJqgbIL8hn2ZZlkcq6metm8sn2TwBIq5PGUe2P4voh15PdKZshnYbQqmGrBEcsIlI+JahqaOfenczZMCdSzPBeznt8tfcrANo2akt252yuGnQVQzsNZUC7AbphVESqJSWoJOfurNuxLpKMZq2fxaLNiyjwAgyjb5u+nNP3nMjpum7Nu+leIRGpEZSgkkxufi6LNi8qcv1ow84NQHDz69Edj+anw35Kdqdsju54NM3SmiU4YhGR+FCCSrAvv/mS2TmzI9eP3t/wPl/nfg1A52adGdZlWHDvUads+rXtR50U/ScTkdpBv3ZVyN1ZvW11kZEZlm9ZDkCqpZJ5aCYX97+Y7M7BvUcdm3ZMcMQiIomjBBVHe/L2MP+z+UWuH235egsAzdOaM6TjkMj1o0EdBtGoXqMERywikjyUoCrR57s/LzIyw/yN8yPzBx1+yOGc0uOUoJihUza9WvfSvUciImVQgqqgAi/gwy0fFjldt3rbagDqpdYjq30WEwdNJLtzNkM6DqFt47YJjlhEpHpRgorR7n27eX/D+5GENDtnNtv3bAegdcPWDO00lEsHXMrQTkMZ2H4gaXXSEhyxiEj1pgRVipyvcoLKurB3tHDTQvI9H4DerXsztvfYyOm6ww85XPceiYhUMiUoIK8gj8WbFxcpZli3Yx0ADeo0YHDHwfwk+yeR03UtGrRIcMQiIjVfrUxQO/bs4L2c9yLJaM6GOezatwuA9k3ak90pm+uPvp7sztlktM2gbmrdBEcsIlL71LoEdc7z5zB56WQcJ8VSSG+bzoSMCZF5jzo366zTdSIiSaDWJajjuhxHz1Y9GdppKIM7DKZJ/SaJDklEREoQ1wRlZicBDwKpwGPufk8p7c4ApgBHufu8eMZ0WdZl8Ty8iIhUkrjdKWpmqcDDwMlAb2CcmfUuoV0T4BpgTrxiERGR6ieeQxkMAla7+xp33wdMBkaX0O7nwK+BPXGMRUREqpl4JqgOwPqo5ZxwXYSZDQA6ufu/yzqQmV1qZvPMbN6WLVsqP1IREUk6CRsMzsxSgN8CPy6vrbs/6u5Z7p7VunXr+AcnIiIJF88EtQHoFLXcMVxXqAnQF5huZmuBo4GXzSwrjjGJiEg1Ec8ENRfoYWbdzKwecDbwcuFGd9/h7q3cvau7dwXeA0bFu4pPRESqh7glKHfPA64CXgc+BJ5192VmdpeZjYrX64qISM0Q1/ug3H0qMLXYujtKaTs8nrGIiEj1Yu6e6BgOipltAT5NdBxVpBXwRaKDqKb02VWcPruK02dXMV3c/YAKuGqXoGoTM5vn7ioaqQB9dhWnz67i9NlVLs05LiIiSUkJSkREkpISVHJ7NNEBVGP67CpOn13F6bOrRLoGJSIiSUk9KBERSUpKUCIikpSUoBLEzDqZ2TQzW25my8zsmnD9IWb2hpl9FP7bIlxvZvaQma02s8XhSPC1mpmlmtkHZvZquNzNzOaEn9Ez4RBbmFn9cHl1uL1rIuNONDNrbmZTzGyFmX1oZkP0vYudmV0X/j+71Mz+aWZp+u7FhxJU4uQBP3b33gQD5V4ZTuh4M/Cmu/cA3gyXIZj4sUf4uBT4Y9WHnHSuIRhGq9CvgQfc/XDgS+CH4fofAl+G6x8I29VmDwKvuXtPIIPgM9T3LgZm1gGYCGS5e1+C2cLPRt+9+HB3PZLgAfwL+C6wEmgXrmsHrAyf/wkYF9U+0q42PghGx38TGAG8ChjBHfx1wu1DgNfD568DQ8LndcJ2luj3kKDPrRnwSfH3r+9dzJ9f4Tx3h4TfpVeBE/Xdi89DPagkEHb7+xNMe9/W3TeGmzYBbcPn5U4AWcv8H3ATUBAutwS2ezBIMRT9fCKfXbh9R9i+NuoGbAH+Fp4efczMGqHvXUzcfQNwP7AO2EjwXZqPvntxoQSVYGbWGHgeuNbdv4re5sGfXboPoBgz+x7wubvPT3Qs1VAdYADwR3fvD+xm/+k8QN+7soTX5kYTJPr2QCPgpIQGVYMpQSWQmdUlSE5PufsL4erNZtYu3N4O+DxcX94EkLVJNjAqnOhyMsFpvgeB5mZWOEJ/9OcT+ezC7c2ArVUZcBLJAXLcfU64PIUgYel7F5vjgU/cfYu75wIvEHwf9d2LAyWoBDEzA/4CfOjuv43a9DIwIXw+geDaVOH688OqqqOBHVGnZGoVd7/F3Tt6MNHl2cBb7n4uMA04M2xW/LMr/EzPDNvXyh6Cu28C1pvZkeGqkcBy9L2L1TrgaDNrGP4/XPj56bsXBxpJIkHM7BhgBrCE/ddRbiW4DvUs0JlgWpEfuPu28H+G3xOcTvgauNA1+zBmNhy4wd2/Z2bdCXpUhwAfAOPdfa+ZpQFPElzn2wac7e5rEhVzoplZJvAYUA9YA1xI8MeqvncxMLM7gbMIKnE/AC4muNak714lU4ISEZGkpFN8IiKSlJSgREQkKSlBiYhIUlKCEhGRpKQEJSIiSUkJSmodM2tpZgvDxyYz2xC1XK+cfbPM7KEYXmNWJcXa0MyeMrMl4ejZ74ajj5S1z61lbLsoPNbi8Hijw/V3mdnxlRGzSGVRmbnUamY2Cdjl7vdHrasTNa5aQpnZLUBrd78+XD4SWOvue8vYZ5e7H5DEzKwj8DYwwN13hImutbt/EqfwRb4V9aBEADN73MweMbM5wL1mNsjMZocDqs4qHHnBzIbb/vmnJpnZX81supmtMbOJUcfbFdV+uu2ff+mp8OZXzOyUcN38cM6lV0sIrR1RQwu5+8rC5GRm483s/bDn9ycL5se6B2gQrnuq2LHaADuBXeGxdhUmp/D9nxn2EAt7k0vMzMPth5nZa2GsM8ysZyV87CJlqlN+E5FaoyMw1N3zzawpMMzd88JTX78Ezihhn57Ad4AmwEoz+2M4Rlu0/kAf4DNgJpBtZvMIprI41t0/MbN/lhLTX4H/mtmZBNOL/N3dPzKzXgSjGWS7e66Z/QE4191vNrOr3D2zhGMtAjYDn5jZm8AL7v5KdINwlIhMADO7D3gt3PQocHn42oOBPxCMgSgSN0pQIvs95+754fNmwN/NrAfByN51S9nn32GPZq+ZfU4wTUVOsTbvu3sOgJktBLoS9GLWRJ1e+yfBhIBFuPvCcAinEwgGKp1rZkMIxoAbGC4DNGD/AK8lChPvScBR4f4PmNlAd59UvK2ZnUUwiOwJ4anAocBz4WsB1C/rtUQqgxKUyH67o57/HJjm7mMsmK9rein7RF8Lyqfk/6diaVMqd99FMGr2C2ZWAJwC7CPoTd1ykMdy4H3gfTN7A/gbMCm6jZn1DdcdGya1FIL5jkrqlYnEja5BiZSsGfuv/VwQh+OvBLqHyQ+C03UHMLNsC+YgIqww7E0wmOubwJlm1ibcdoiZdQl3y7VgKpfix2pvZgOiVmWGx4pu05ygN3e+u28BCOcp+8TMxoZtzMwyDv4tixwcJSiRkt0L/MrMPiAOZxrc/RvgCuA1M5tPULywo4SmhwFvm9kSglGy5wHPu/ty4DaC61OLgTcICioguF60uIQiibrA/WFhxkKCpHhNsTajgS7AnwuLJcL15wI/NLNFwLKwnUhcqcxcJEHMrLG77wqr+h4GPnL3BxIdl0iyUA9KJHEuCXsoywhOKf4pwfGIJBX1oEREJCmpByUiIklJCUpERJKSEpSIiCQlJSgREUlKSlAiIpKU/h+VbCppXKBccgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.5075566750629723\n",
      "DEVELOP ACCURACY: 0.4671717171717172\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.5088161209068011\n",
      "DEVELOP ACCURACY: 0.4823232323232323\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.49622166246851385\n",
      "DEVELOP ACCURACY: 0.5176767676767676\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.5050377833753149\n",
      "DEVELOP ACCURACY: 0.45707070707070707\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.4987405541561713\n",
      "DEVELOP ACCURACY: 0.4671717171717172\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.49370277078085645\n",
      "DEVELOP ACCURACY: 0.4671717171717172\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.5100755667506297\n",
      "DEVELOP ACCURACY: 0.45202020202020204\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXwV1fnH8c+TBBL2HQSCLIogWwLEICBK0Z9rFbFaRHFr61K3VqtWW9tSa1urtlatda1r3a0LLtW6gIooEFYBARGjBARZZBcIyfP7YybxkgUukJu5Sb7v1+u+uDNzZua5w+U+nDlnzjF3R0REJNmkRB2AiIhIRZSgREQkKSlBiYhIUlKCEhGRpKQEJSIiSUkJSkREkpISlEg1MbNhZrYw6jhEagolKKkTzCzfzI6KMgZ3f9/deyTq+GZ2jJm9Z2YbzWyVmb1rZicl6nwiiaYEJVJFzCw1wnOfCjwLPApkAu2A3wIn7sWxzMz02yCR05dQ6jQzSzGza83sMzNbY2bPmFnLmO3PmtkKM1sf1k56x2x72MzuNrPXzGwz8L2wpnaVmc0J93nazDLC8sPNrCBm/0rLhtuvMbOvzGy5mf3EzNzMDqzgMxjwN+AP7v6Au69392J3f9fdzw/LjDOzf8fs0yU8Xlq4PNHM/mhmHwBbgKvNLK/Mea4ws/Hh+3Qzu9XMvjSzlWZ2j5k12Me/DpGdKEFJXXcZcDJwBNAB+Aa4K2b7f4HuQFtgBvB4mf3PAP4INAEmhet+CBwLdAX6Aefu4vwVljWzY4ErgaOAA4HhuzhGD6AT8NwuysTjLOACgs9yD9DDzLrHbD8DeCJ8fxNwEJAdxteRoMYmUmWUoKSuuwj4tbsXuPs2YBxwaknNwt0fdPeNMduyzKxZzP4vufsHYY1la7juDndf7u5rgZcJfsQrU1nZHwIPufs8d98SnrsyrcI/v4r3Q1fi4fB8O9x9PfASMAYgTFQ9gfFhje0C4Ap3X+vuG4E/Aafv4/lFdqIEJXVdZ+AFM1tnZuuAT4AioJ2ZpZrZTeHtvw1AfrhP65j9l1ZwzBUx77cAjXdx/srKdihz7IrOU2JN+Gf7XZSJR9lzPEGYoAhqTy+GybIN0BCYHnPdXg/Xi1QZJSip65YCx7l785hXhrsvI/hRHklwm60Z0CXcx2L2T9R0AF8RdHYo0WkXZRcSfI4f7KLMZoKkUmK/CsqU/SxvAm3MLJsgUZXc3lsNfAv0jrlmzdx9V4lYZI8pQUldUs/MMmJeaQRtLX80s84AZtbGzEaG5ZsA2whqKA0JbmNVl2eA88zsYDNrCPymsoIezJlzJfAbMzvPzJqGnT8OM7P7wmKzgMPNbP/wFuV1uwvA3QsJegbeArQkSFi4ezFwP3CbmbUFMLOOZnbMXn9akQooQUld8hrB//xLXuOA24HxwP/MbCPwETAoLP8o8AWwDJgfbqsW7v5f4A5gArA45tzbKin/HDAa+BGwHFgJ3EjQjoS7vwk8DcwBpgOvxBnKEwQ1yGfdfUfM+l+WxBXe/nyLoLOGSJUxTVgokvzM7GBgLpBeJlGI1FqqQYkkKTMbFT5v1AL4C/CykpPUJUpQIsnrQuBr4DOCnoU/jTYckeqlW3wiIpKUVIMSEZGklBZ1AHuqdevW3qVLl6jDEBGRKjJ9+vTV7l7uQe8al6C6dOlCXl7e7guKiEiNYGZfVLRet/hERCQpKUGJiEhSUoISEZGkVOPaoEQkGoWFhRQUFLB169bdFxapQEZGBpmZmdSrVy+u8kpQIhKXgoICmjRpQpcuXQimhBKJn7uzZs0aCgoK6Nq1a1z7JPQWn5kda2YLzWyxmV1bwfbOZvZ2OOX1RDPLrOg4IhK9rVu30qpVKyUn2StmRqtWrfaoBp6wBGVmqQRTZx8H9ALGmFmvMsVuBR51937ADcCfExWPiOw7JSfZF3v6/UlkDSoXWOzuS9x9O/AUweRvsXoB74TvJ1Swvep9MwuWvZrw04iIyL5JZILqyM5TSBeE62LNBk4J348CmphZq7IHMrMLzCzPzPJWrVq1b1HNuBI+GAMbF+/bcUSkWq1Zs4bs7Gyys7PZb7/96NixY+ny9u3bd7lvXl4el19++W7PMWTIkKoKV6pA1J0krgL+YWbnAu8RTAxXVLaQu98H3AeQk5Ozb6PbHvow/DcbJv0Qjp4MqRn7dDgRqR6tWrVi1qxZAIwbN47GjRtz1VVXlW7fsWMHaWkV/6Tl5OSQk5Oz23NMnjy5aoKtYrv6bLVZImtQy4BOMcuZ4bpS7r7c3U9x9/7Ar8N16xIYEzTaHw59BL6ZCTOu2n15EUla5557LhdddBGDBg3immuuYerUqQwePJj+/fszZMgQFi5cCMDEiRP5/ve/DwTJ7Uc/+hHDhw+nW7du3HHHHaXHa9y4cWn54cOHc+qpp9KzZ0/OPPNMSmZ+eO211+jZsycDBw7k8ssvLz1urHnz5pGbm0t2djb9+vXj008/BeDRRx+lX79+ZGVlcdZZZwGQn5/PiBEj6NevH0ceeSRffvllhZ/ts88+49hjj2XgwIEMGzaMBQsWJOiqJo9EpuRpQHcz60qQmE4HzogtYGatgbXuXgxcBzyYwHi+k3ki9PwFLPgrtBsO+59aLacVqTWm/zxoz61KLbJh4N/3eLeCggImT55MamoqGzZs4P333yctLY233nqLX/3qV/znP/8pt8+CBQuYMGECGzdupEePHvz0pz8t92zOzJkzmTdvHh06dGDo0KF88MEH5OTkcOGFF/Lee+/RtWtXxowZU2FM99xzDz/72c8488wz2b59O0VFRcybN48bb7yRyZMn07p1a9auXQvAZZddxjnnnMM555zDgw8+yOWXX86LL75Y7rMdeeSR3HPPPXTv3p0pU6Zw8cUX884771R4/toiYQnK3XeY2aXAG0Aq8KC7zzOzG4A8dx8PDAf+bGZOcIvvkkTFU072n2HVJJjyY2jRH5ocUG2nFpGqc9ppp5GamgrA+vXrOeecc/j0008xMwoLCyvc54QTTiA9PZ309HTatm3LypUryczc+SmX3Nzc0nXZ2dnk5+fTuHFjunXrVvocz5gxY7jvvvvKHX/w4MH88Y9/pKCggFNOOYXu3bvzzjvvcNppp9G6dWsAWrZsCcCHH37I888/D8BZZ53FNddcU+6zbdq0icmTJ3PaaaeVbtu2bdteXa+aJKE3Nd39NeC1Mut+G/P+OeC5RMZQqZR6MPQp+G9/+GA0/N8HkJoeSSgiNc5e1HQSpVGjRqXvf/Ob3/C9732PF154gfz8fIYPH17hPunp3/1bT01NZceOHXtVpjJnnHEGgwYN4tVXX+X444/n3nvvjXvfWCWfrbi4mObNm5e2wdUVdXssvsZdYPDDsHY6zLxmd6VFJMmtX7+ejh2DzsIPP/xwlR+/R48eLFmyhPz8fACefvrpCsstWbKEbt26cfnllzNy5EjmzJnDiBEjePbZZ1mzZg1A6S2+IUOG8NRTTwHw+OOPM2zYsHLHa9q0KV27duXZZ58FglEZZs+eXdUfL+nU7QQFkDkSevwcFt0BS5+POhoR2QfXXHMN1113Hf3799+jGk+8GjRowD//+c/SzgpNmjShWbNm5co988wz9OnTh+zsbObOncvZZ59N7969+fWvf80RRxxBVlYWV155JQB33nknDz30EP369eOxxx7j9ttvr/Dcjz/+OP/617/Iysqid+/evPTSS1X++ZKNlfRMqSlycnK8yicsLNoObx4GGxfBcTOhcXzjRInUJZ988gkHH3xw1GFEbtOmTTRu3Bh355JLLqF79+5cccUVUYdVY1T0PTKz6e5e7jkA1aAAUuvDYWFVfdLoIGGJiFTg/vvvJzs7m969e7N+/XouvPDCqEOqtZSgSjTuCoc+BGunwaxfRh2NiCSpK664glmzZjF//nwef/xxGjZsGHVItZYSVKxOo+Cgy2Hh32Hpi1FHIyJSpylBldX/Zmg5ED46DzblRx2NiEidpQRVVmo6HPYMUAwfnK72KBGRiChBVaRxNxj0IKyZArOvizoaEZE6SQmqMvv/AA66FBb8DQrGRx2NiAArVqzg9NNP54ADDmDgwIEcf/zxLFq0KOqwynn44Ye59NJLgWBcvkcffbRcmfz8fPr06bPL4+Tn5/PEE0+ULsc7bUhtUffGb98T/W+FVZPho3OD56MadY46IpE6y90ZNWoU55xzTunIC7Nnz2blypUcdNBBpeWSbWqKiy66aK/3LUlQZ5wRjLMd77Qh1S1R11w1qF1JTQ+ejyreAZNOh+KKB54UkcSbMGEC9erV2+kHPysri2HDhjFx4kSGDRvGSSedRK9evdi6dSvnnXceffv2pX///kyYMAGoeBqMzZs3c8IJJ5CVlUWfPn3KDV9UXFxMly5dWLfuu5mAunfvzsqVK3n55ZcZNGgQ/fv356ijjmLlypXl4h43bhy33norANOnTycrK4usrCzuuuuu0jL5+fkMGzaMAQMGMGDAgNJ5qa699lref/99srOzue2223aaNmTt2rWcfPLJ9OvXj0MPPZQ5c+aUnq+y6URKFBUVce6559KnTx/69u3LbbfdBsDixYs56qijyMrKYsCAAXz22We4O1dffXVp2ZLrU/aaFxUVcfXVV3PIIYfQr1+/vR5/MFby/DcjWTU5EAY9EAwoO/tX0P+WqCMSidzPX/85s1ZU7cCl2ftl8/djKx+Edu7cuQwcOLDS7TNmzGDu3Ll07dqVv/71r5gZH3/8MQsWLODoo49m0aJFFU6D8dprr9GhQwdeffVVIBjPL1ZKSgojR47khRde4LzzzmPKlCl07tyZdu3acdhhh/HRRx9hZjzwwAPcfPPN/PWvf600xvPOO49//OMfHH744Vx99dWl69u2bcubb75JRkYGn376KWPGjCEvL4+bbrqJW2+9lVdeeQUIkkKJ3/3ud/Tv358XX3yRd955h7PPPrt0MNndTScya9Ysli1bxty5cwFKk++ZZ57Jtddey6hRo9i6dSvFxcU8//zzzJo1i9mzZ7N69WoOOeQQDj/88HLX/L777qNZs2ZMmzaNbdu2MXToUI4++ujSkd/3hmpQ8ej8Q+j+U/jkVlj2atTRiEgFcnNzS38MJ02axNixYwHo2bMnnTt3ZtGiRQwePJg//elP/OUvf+GLL76gQYMG9O3blzfffJNf/vKXvP/++xWOrTd69OjSmsNTTz3F6NGjgWC+pmOOOYa+fftyyy23MG/evErjW7duHevWrSv9cS+ZsBCgsLCQ888/n759+3Laaacxf/783X7eSZMmlR5jxIgRrFmzhg0bNgDfTSfSunXr0ulEYnXr1o0lS5Zw2WWX8frrr9O0aVM2btzIsmXLGDVqFAAZGRk0bNiQSZMmMWbMGFJTU2nXrh1HHHEE06ZNK3fN//e///Hoo4+SnZ3NoEGDWLNmTelEjXtLNah4DfgbrP4QPjwbjpsFjTrtfh+RWmpXNZ1E6d27N889V/nsPLHTblSmomkwRowYwYwZM3jttde4/vrrOfLIIznmmGNKhzC64YYbOPHEE1m8eDGrVq3ixRdf5PrrrweCyQavvPJKTjrpJCZOnMi4ceP26rPddttttGvXjtmzZ1NcXExGRsZeHafE7qYKadGiBbNnz+aNN97gnnvu4Zlnnql0kNpdib3m7s6dd97JMcccs/eBl6EaVLxSM2DoM1C8PXg+Su1RItVqxIgRbNu2bacJAufMmcP7779fruywYcN4/PHHAVi0aBFffvll6VQZZafBWL58OQ0bNmTs2LFcffXVzJgxg0GDBjFr1ixmzZrFSSedhJkxatQorrzySg4++GBatWoF7Dy9xyOPPLLL+Js3b07z5s2ZNGkSQGl8Jcdp3749KSkpPPbYYxQVFQHQpEkTNm7cWOHxYj/jxIkTad26NU2bNo3rWq5evZri4mJ+8IMfcOONNzJjxgyaNGlCZmZm6Wy+27ZtY8uWLQwbNoynn36aoqIiVq1axXvvvUdubm65Yx5zzDHcfffdpZNELlq0iM2bN8cVT2WUoPZE0+6Qez+sngxzfhN1NCJ1ipnxwgsv8NZbb3HAAQfQu3dvrrvuOvbbb79yZS+++GKKi4vp27cvo0eP5uGHHyY9Pb3CaTA+/vjj0o4Tv//970trR2WNHj2af//736W39yDokHDaaacxcODA0plyd+Whhx7ikksuITs7m9iZJC6++GIeeeQRsrKyWLBgQWnNpF+/fqSmppKVlVXakSH23NOnT6dfv35ce+21u02QsZYtW8bw4cPJzs5m7Nix/PnPfwbgscce44477qBfv34MGTKEFStWMGrUKPr160dWVhYjRozg5ptvrvCa/+QnP6FXr14MGDCAPn36cOGFF+7zlCeabmNvTL0IFt8LR7wKHY+PNhaRaqLpNqQqaLqNRBtwGzTvBx+dDVsKoo5GRKRWUoLaG2kNgvH6irbBB2OC56RERKRKKUHtraY9IPdeWDUJ5vw26mhEqkVNaxKQ5LKn3x8lqH3R5Qw44HyY/2dY/kbU0YgkVEZGBmvWrFGSkr3i7qxZs2aPutDrOah9NfB2WPMRfDg2eD6qYceoIxJJiMzMTAoKCli1alXUoUgNlZGRQWZmZtzllaD2VVqD4PmoN3Jg8hkw4m1I0WWV2qdevXr7NGyNyJ7SLb6q0KwnHHIPfP0efDwu6mhERGoFJaiq0nUsdPsRzPsTfPW/qKMREanxlKCqUs6d0KwXTB4LW5ZHHY2ISI2mBFWV0hrCYc/Cjs0w+UwoLoo6IhGRGksJqqo1OxgOuRu+nghzb4g6GhGRGksJKhG6nQ3dzoW5f4AVb0UdjYhIjaQElSg5/whqU5PHwrcroo5GRKTGUYJKlLRGwfNRhRuC56PUHiUiskeUoBKpeW/IuQtWToB5N0YdjYhIjZLQBGVmx5rZQjNbbGbXVrB9fzObYGYzzWyOmdW+yZW6nQtdz4aPfw8r3ok6GhGRGiNhCcrMUoG7gOOAXsAYM+tVptj1wDPu3h84HfhnouKJjFlQi2raI+h6/u3KqCMSEakRElmDygUWu/sSd98OPAWMLFPGgabh+2ZA7Xy6tV7j4PmowvXBoLJqjxIR2a1EJqiOwNKY5YJwXaxxwFgzKwBeAy6r6EBmdoGZ5ZlZXo0dSbl5n2CkiRVvBcMhiYjILkXdSWIM8LC7ZwLHA4+ZWbmY3P0+d89x95w2bdpUe5BVptuPoMuZMHccrJwYdTQiIkktkQlqGdApZjkzXBfrx8AzAO7+IZABtE5gTNEyC0Y9b9I96Hq+9euoIxIRSVqJTFDTgO5m1tXM6hN0ghhfpsyXwJEAZnYwQYKqoffw4lSvcfB81PZvYPJZ4MVRRyQikpQSlqDcfQdwKfAG8AlBb715ZnaDmZ0UFvsFcL6ZzQaeBM71ujCfdIt+MPAOWPE/mH9T1NGIiCQlq2n5ICcnx/Py8qIOY9+5B93Ov3wajpwAbQ+POiIRkUiY2XR3zym7PupOEnWXGeTeC40PgA/GwNbafWdTRGRPKUFFqV6T4PmobWvgQ7VHiYjEUoKKWossGPh3+OoNmH9z1NGIiCQNJahkcOCFsP9omHM9fD0p6mhERJKCElQyMINB90GjrvDB6bB1ddQRiYhETgkqWdRrCoc9A9tWwUfnqD1KROo8Jahk0rI/DLgNlr8Gn9wadTQiIpFSgko23X8KnU6F2b+CVZOjjkZEJDJKUMnGDAY9AI06wwejgy7oIiJ1kBJUMqrfLGiP2vo1fKj2KBGpm5SgklXLgdD/r7D8VVjwt6ijERGpdkpQyeygS6DTKTDrOlj9UdTRiIhUKyWoZGYGg/4FDTvBpNGwbW3UEYmIVBslqGRXv3nYHvUVfHReMAq6iEgdoARVE7TKgexbYNl4WPj3qKMREakWcScoM2uYyEBkN3pcDpknw8xrYPWUqKMREUm43SYoMxtiZvOBBeFylpn9M+GRyc7M4NAHoWFm8HzU9m+ijkhEJKHiqUHdBhwDrAFw99mApn+NQv0WMPRp+Ha52qNEpNaL6xafuy8ts6ooAbFIPFrnQvZfoOAlWHhH1NGIiCRMPAlqqZkNAdzM6pnZVcAnCY5LdqXHz6HjSTDralgzLepoREQSIp4EdRFwCdARWAZkh8sSFTM49CHIaA+Tfgjb10UdkYhIldtlgjKzVOB2dz/T3du5e1t3H+vuGsE0aukt4bCnYUsBTPmx2qNEpNbZZYJy9yKgs5nVr6Z4ZE+0PhSyb4Klz8Oif0QdjYhIlUqLo8wS4AMzGw9sLlnp7hrBNBn0vBJWToSZV0HrwcFDvSIitUA8bVCfAa+EZZvEvCQZmMHghyGjXfh81PqoIxIRqRK7rUG5++8BzKxxuLwp0UHJHkpvBUOfgrcOhyk/CcbuM4s6KhGRfRLPSBJ9zGwmMA+YZ2bTzax34kOTPdJmCGT9CZY+B5/eHXU0IiL7LJ5bfPcBV7p7Z3fvDPwCuD+xYcleOfgq6HA8zLgC1s6IOhoRkX0ST4Jq5O4TShbcfSLQKGERyd6zFDj0EUhvEzwfVbgh6ohERPZaPAlqiZn9xsy6hK/rCXr2STLKaB20R23Ohynn6/koEamx4klQPwLaAM8D/wFah+skWbU9DPrdCF8+A4vvjToaEZG9Ek8vvm+Ay6shFqlKva6Br9+F6T8PHuhtkR11RCIieySeXnxvmlnzmOUWZvZGYsOSfWYpMPjRoAv6pB9C4caoIxIR2SPx3OJr7e6lo5GGNaq28RzczI41s4VmttjMrq1g+21mNit8LTIzjXpalTLawNAnYdNnMPVCtUeJSI0ST4IqNrP9SxbMrDOw21+6cKDZu4DjgF7AGDPrFVvG3a9w92x3zwbuJGjnkqrU9nDo9wf44kn4TE8HiEjNEc9YfL8GJpnZu4ABw4AL4tgvF1js7ksAzOwpYCQwv5LyY4DfxXFc2VO9roWV70Le5dBqELTIijoiEZHd2m0Nyt1fBwYATwNPAgPdPZ42qI5A7Ey8BeG6csJaWVfgnUq2X2BmeWaWt2rVqjhOLTuxFBjyWDBFh9qjRKSGqDRBmVlnM2sG4O6rCUYyPxo4OwHTb5wOPBdO71GOu9/n7jnuntOmTZsqPnUdkdEWhjwJmxbD1IvUHiUiSW9XNahnCEeMMLNs4FngSyAL+Gccx14GdIpZzgzXVeR0gtqZJFK7I6Dv7+GLJ+Czf0UdjYjILu0qQTVw9+Xh+7HAg+7+V+A8gval3ZkGdDezrmGN63RgfNlCZtYTaAF8uEeRy97pdR3sdxRMvwzWfRx1NCIildpVgoqdr2EE8DaAuxfHc2B33wFcCrwBfAI84+7zzOwGMzsppujpwFPuuudULVJSYfC/oV7zsD1Ks6eISHLaVS++d8zsGeArghrOOwBm1h7YHs/B3f014LUy635bZnncHsQrVaFBOxj6BLxzFEy7GAY/ovmjRCTp7KoG9XOC55LygcPcvTBcvx9B13Opydp9D/r8FvIfgyUPRx2NiEg5ldagwltuT1WwfmZCI5Lq0/t6+Po9yLsEWuVCc81DKSLJI56RJKS2SkmFIY9DvaYw6TTYsTnqiERESilB1XUN9guS1IYFMO2SqKMRESkVz2jmJ5qZEllttt+R0Oc38PkjsOSRqKMREQHiq0GNBj41s5vDZ5akNurzW2g7POjVt76y4RJFRKpPPGPxjQX6A58BD5vZh+HYeE0SHp1Un5TUoOt5vcbB81E7tkQdkYjUcXHdunP3DcBzBL362gOjgBlmdlkCY5Pq1qB98BDv+vmQp79aEYlWPG1QJ5nZC8BEoB6Q6+7HEYzJ94vEhifVrv3/Qe9fw5IH4fPHoo5GROqweOaD+gFwm7u/F7vS3beY2Y8TE5ZEqu/vYNV7wajnLXOg2cFRRyQidVA8t/jGAVNLFsysgZl1AXD3txMSlUQrJQ2GPAFpDdUeJSKRiSdBPQvEDhBbFK6T2qxhx7A9ai5M/1nU0YhIHRRPgkpz99LBYcP3VT1hoSSjDscE03N89gB8/njU0YhIHRNPgloVOz2GmY0EVicuJEkq/W6ANofBtAthw8KooxGROiSeBHUR8Csz+9LMlgK/BC5MbFiSNFLSYOiTkJoRtkd9G3VEIlJHxPOg7mfufijQCzjY3Ye4++LEhyZJo2EmDH4M1s2BGT+POhoRqSPi6WaOmZ0A9AYyLJzYzt1vSGBckmw6HAe9fgnz/xIMidRlTNQRiUgtF8+DuvcQjMd3GcE08KcBnRMclySjfn+A1kNg6gWwYVHU0YhILRdPG9QQdz8b+Mbdfw8MBg5KbFiSlFLqwdCnIKV+0B5VtDXqiESkFosnQZX8Cm0xsw5AIcF4fFIXNeoEgx+FdbNhxpVRRyMitVg8CeplM2sO3ALMAPKBJxIZlCS5jifAwVfDp3fDF89EHY2I1FK77CQRTlT4truvA/5jZq8AGe6+vlqik+SV9UdYNQmm/ARaDoAmB0YdkYjUMrusQbl7MXBXzPI2JScBYtqj0tQeJSIJEc8tvrfN7AdW0r9cpESj/eHQR+CbmfDWEfDls1BcGHVUIlJLxJOgLiQYHHabmW0ws41mtiHBcUlNkXkiHPoQbFsd1KTGd4N5f4atGg1LRPZNPCNJNHH3FHev7+5Nw+Wm1RGc1BDdzoXvL4LDx0PTnjD7V/BSp6B96pvZUUcnIjXUbkeSMLPDK1pfdgJDqeNSUoPaVOaJwZTxC++Ezx+Fz/4FbY+AHpdDx5OCNisRkTiYu++6gNnLMYsZQC4w3d1HJDKwyuTk5HheXl4Up5Y9tf2bIEEt+gds/gIadYbul8ABP4b0llFHJyJJwsymu3tO2fXx3OI7Meb1f0Af4JtEBCm1TP0WcPBVcOJnMOwFaNQVZl0DL2bC1Ath3byoIxSRJBZPJ4myCoCDqzoQqcVSUqHTyXDUBDhuNnQ5M7j991ofePsoKBgPxUVRRykiSSaeNqg7gZL7gClANsGIEiJ7rkU/GHQ/ZN8UzNS76C54b2RQuzroUjjgR1C/edRRikgSiKcN6pyYxR1Avrt/kNCodkFtULVM8Q4oeBEW3gGr3oe0RtD1HDjoMmjWM+roRKQaVNYGFU+CagRsdfeicJ3St+gAABcBSURBVDkVSHf3LQmJdDeUoGqxtTNh0R2Q/wQUb4f9jg56/3U4Dmxv7kaLSE2w150kgLeBBjHLDYC34jzpsWa20MwWm9m1lZT5oZnNN7N5ZqZBaOuylv2Dh35PXgr9boT1c+Hd78PLPYIaVqGeDxepS+JJUBnuvqlkIXzfcHc7hTWtu4DjCKaLH2NmvcqU6Q5cBwx1996A5hMXyGgLfX4NI/NhyJOQ0Qam/wxe6Ah5l8OGT6OOUESqQTwJarOZDShZMLOBwLdx7JcLLHb3Je6+HXgKGFmmzPnAXe7+DYC7fx1f2FInpNSDLqfD0ZPhmKmQOQoW3wOvHAQTT4Dlb4AXRx2liCRIPAnq58CzZva+mU0CngYujWO/jsDSmOWCcF2sg4CDzOwDM/vIzI6t6EBmdoGZ5ZlZ3qpVq+I4tdQ6rQ6BIY/CyC+h7zhYOx0mHguv9oZF/4TCTbs9hIjULPE8qDsN6An8FLgIONjdp1fR+dOA7sBwYAxwfzg5YtkY7nP3HHfPadOmTRWdWmqkBvtB398FiWrwvyGtCeRdAi92hOlXwqYlUUcoIlVktwnKzC4BGrn7XHefCzQ2s4vjOPYyoFPMcma4LlYBMN7dC939c2ARQcIS2bXU+tD1TDh2Khz9IXQ4ARbdCeMPhHdHwoq3YTc9VEUkucVzi+/8cEZdAML2ovPj2G8a0N3MuppZfeB0YHyZMi8S1J4ws9YEt/z0X2DZM60PhaFPwMgvoM/1sPpDeOeoYKSKT++FHZujjlBE9kI8CSo1drLCsHde/d3t5O47CNqq3gA+AZ5x93lmdoOZnRQWewNYY2bzgQnA1e6+Zk8/hAgADTtAvxvg5C/h0IchJR2mXQQvdoKZ18Cm/KgjFJE9EM+DurcAnYF7w1UXAkvd/RcJjq1CelBX4uYOqyfDwtth6fOAQ8eRwcO/bY8ATRItkhQqe1A3nsl5fglcQNBJAuBN4P4qjE0kMcygzdDgtXkpfHo3fHYfFLwAzfsFiarzGZDWYPfHEpFqt9saVLkdzIYBp7v7JYkJaddUg5J9suNb+OKJYGSKdXOgfks48ALofjE06rT7/UWkyu3LUEeYWX8zu9nM8oEbgAVVHJ9I9UhrEEyYeNwsOHIitBsOn9wM47vCpB/C15PU+08kSVR6i8/MDiJ4NmkMsJrgAV1z9+9VU2wiiWMG7Y4IXpvy4dN/wuL74ctnoUX/8Pbf6ZCaEXWkInXWrmpQC4ARwPfd/TB3vxPQrHJS+zTuAv1vhlEFkHtvMJL6R+fBi/vD7N/AluVRRyhSJ+0qQZ0CfAVMMLP7zexIQN2epPZKaxS0Rx3/MYx4C1oPhnl/hJc6wwdjYNWHuv0nUo0qTVDu/qK7n04wzNEEgjH52prZ3WZ2dHUFKFLtzGC/I+GIl+CkxcHtvuX/hTeHwBuD4PN/Q9G2qKMUqfXiGYtvs7s/4e4nEgxXNJOg67lI7de4Gwz4K5xcADl3wY4N8OFZQa3q49/DtyuijlCk1trjbuZRUzdziZQXw4q3gm7qy18NpgTZf3RQy2p1SNTRidRI+9TNXERClgLtj4bhr8D3F8GBP4WCl+CNXHhjMOQ/CcWFUUcpUisoQYnsrabdIef2oPffwDtg+xqYfAa81AXm3ghbNf+myL5QghLZV/WaQo/L4PsL4IhXoXlfmPObYJDaD8+FtTOjjlCkRlKCEqkqlgIdj4fvvQ4nfAIHnA9Ln4PXB8Cbw4KHgIt3RB2lSI2hBCWSCM16wiH/CHr/DfgbbFkWDKU0vivMuwm2ro46QpGkpwQlkkj1m0PPK+DET+Hw8dCkB8y+Dl7qBFN+At/MiTpCkaSlBCVSHVJSIfNEOPItOH4udD0H8p+A/2bBW8Nh6QtQrJHERGIpQYlUt+a9Ifee4PZf9s2w6XN4/xR4+QCYfwtsWxt1hCJJQQ/qikSteAcsezl4+PfriZDaALqMDSZabNQZGnWBhpmQEs/8oiI1z77MqCsiiZSSBp1GBa9vZsOiOyH/MfgsZuJqS4EGmd8lrEadg1fjLtCwMzTaH1LTo/oEIgmhBCWSTFpkwaAHgnH/Nn8JW74I5qva/EX4yoev34VvC4Jhl2I1aB8kq8ZdyieyRp2D0dpFahAlKJFklJoejFTRtHvF24sLg67rJUkr9s8102Dpf8oPuZTeOiZpdYlJXuH7+s0S+pFE9pQSlEhNlFIvqCk17gIcUX57cRFsXRGTvGIS2Pq5wUC3RVt33qde8/JJq6Q21rAzpLcKpiIRqSZKUCK1UUoqNOwYvNoMLb/dHbatCm4f7nQbMR82LYGV78COTTvvk9aoTO2ry84JLaOdEphUKSUokbrIDDLaBi9yy293h+3flLmFGPN+9YfB9lgp6Tu3eZVNZA06BIlTJE5KUCJSnhmktwxeLftXXKZwY8VtYJu/gGXjy4/mbmnQsFOZ3oextxE7BbcuRUJKUCKyd+o1geZ9gldFdmwJeiJu/qL8bcSv3oRvlwMxz2FaSlDLqqgDR6MuYVf6jER/KkkiSlAikhhpDYNBc5v1rHh70XbYsrTiWtiqD+CLp8DLDP+U0W7XPRHrNU7oR5LqpQQlItFIrQ9NDgheFSneEdSyKmoDWzsDCl6E4u0775Pe6rtbh2V7IjbqEgzeKzWGEpSIJKeUtOC2XqP9K97uxbB15c63DksS2YYF8NUbULRl533qNd11T8T01uqJmESUoESkZrKUYPSMBu2hzeDy291h2+ryta+SP79+Fwo37LxPasMwKXapOIE12C84r1QLJSgRqZ3MIKNN8GpVbhzSwPZ1lXelXzsNtq3ZuXxKfWi4f+UPNDfoqEF9q5CupIjUXfWbB68WWRVvL9wEW76s4IHmL2D5a8FoHbEsNRh5vrJOHA07aVDfPaAEJSJSmXqNoVmv4FWRoq3fdaUvextx5QT4dlmZQX0tuCVZaTtY56D3owAJTlBmdixwO5AKPODuN5XZfi5wC7AsXPUPd38gkTGJiFSZ1AxoelDwqkhxIWwpqPg24pop8OWz4Dt23ie9TcW1r5LbiPWaJvQjJZOEJSgzSwXuAv4PKACmmdl4d59fpujT7n5pouIQEYlMSj1o3DV4VaS4CLZ+FSStsrcR138My1+peFDfCqdUCd/Xb1lreiImsgaVCyx29yUAZvYUMBIom6BEROqmlLDNqmFm5YP6bv264k4cGxfDircrGNS3cQUjccS8r0GD+iYyQXUElsYsFwCDKij3AzM7HFgEXOHuS8sWMLMLgAsA9t+/kmciRERqGzNo0C54ta7g57N0UN/8itvBKhrUNzUjpidil/KJLIkG9Y26k8TLwJPuvs3MLgQeAUaULeTu9wH3AeTk5HjZ7SIiddJOg/oOqLhM4YbvklfJbcSS9+teqnxQ39i5wGJvKTbMrLZBfROZoJYBnWKWM/muMwQA7h77kMEDwM0JjEdEpO6p1xSa9w1eFYkd1Lfsw8zxDOp74EXQ9rCEhJ7IBDUN6G5mXQkS0+nAGbEFzKy9u38VLp4EfJLAeEREpKy4B/XNL38bcdUk6HRK4kJL1IHdfYeZXQq8QdDN/EF3n2dmNwB57j4euNzMTgJ2AGuBcxMVj4iI7IXdDeqbQOZes5p0cnJyPC8vL+owRESkipjZdHcvNx6VRj0UEZGkpAQlIiJJSQlKRESSkhKUiIgkJSUoERFJSkpQIiKyV9ydRPYEj3qoI6nFir2YouIiiryIHcU7St8XFYfL4fvqWlc2hrjWRXHO4iKKvZi0lDTqp9YnPS2d+qn1g/ep6Xu2LjVmXdru18V73Pqp9bEaMuBoTebuFBYXsr1oO9t2bGN70fbgfdG2Stftcdl9PNYjJz/CWVlnJeTzK0HJHtu0fRMzvprBlIIpTF0+lWnLprH227XlfqRrgrSUNFItldSU1J3+TEtJ26t19VPrk5qSWuFxy62r5Jglf+4o3hHXD8nG7Rt3+yNSWFxY5deuXkq9uBNfpev2NOHuYl3sceNNoMVeTGFRYYU/yLv7kd7jsnEmgth124u2V/nfW8l/fHZ3XRukNaB5RvPd/qenT9s+VR5jaawJO7LUCjuKdzB/1fwgGS2bypRlU5i3ah7F4Syh3Vp049DMQ+nQpEOV/MBX+mO+B+viPVeK1Z073CU/xLv7odyXdZVt37h9426Pk6gEGvvDWy+lHoXFhTslgh3FO3Z/oH08b0VJun5qfRrXb0zL1JaVl40z4e9J2Xop9UhNkpHK46EEJaXcnaUblu6UjKZ/NZ0thVsAaNmgJbkdcznl4FPI7ZjLIR0OoU2jNhFHLfFIsRTS09JJT0unCU2iDqccd9+nW1XxrCssLqR+StX+4O9tzU3iowRVh63buo5py6aVJqOpy6aycvNKANJT0+nfvj/nDzif3I655HbM5YAWB+gfnySEmSV1ApVoKEHVEduLtjN7xeydktHCNQtLt/ds3ZNjDzy2NBn1a9eP+qn1I4xYROo6JahayN1ZvHbxTslo5oqZpQ2u+zXej0EdB3F21tkM6jiInA45NMtoFnHUIiI7U4KqBb7e/DVTl03d6fXN1mCa50b1GpHTIYefDfoZgzoOIrdjLplNM3WrTkSSnhJUDbOlcAszvpqxU+0of10+EDSE923bl1N7nVqajHq16VWjeu2IiJRQgkpiRcVFfLL6kyAZhc8cfbzy49JnjDo368ygzEFcesil5HbMZUD7ATSq3yjiqEVEqoYSVBIp2FCwUzLKW57Hpu2bAGie0Zzcjrlcd9h1pR0Z2jVuF3HEIiKJowQVkQ3bNpC3PK80GU1dNpXlG5cDUD+1Ptn7ZXNu1rnkdsxlUOYgDmx5YJ16sFRERAmqGhQWFfLx1x+XJqMpBVNYsHoBTjDI4kGtDmJE1xGl7UZZ7bJIT0uPOGoRkWgpQVUxd+fzdZ/vNBrDzBUz2bpjKwBtGrZhUOYgzuh7Brkdc8npkEPLBi0jjlpEJPkoQe2j1VtWlxuNYc23awBokNaAgR0Gcskhl5S2G3Vu1lldvEVE4qAEtQe+LfyWWStmlSaiqcum8tk3nwFgGL3b9ubknicH7UYdB9G7bW/SUnSJRUT2hn49K1HsxSxcvXCnZDR75ezS0Y87Ne1EbsdcLhh4AYM6DmJA+wE0SdcYYiIiVUUJKvTVxq92SkbTlk9jw7YNADRNb8ohHQ7h6iFXl3ZkaN+kfcQRi4jUbnUyQW3avom85Xk7tRsVbCgAgsm8stplMbbv2NJ2ox6te6iLt4hINatzCerM58/kqblPlU64d0CLAzi88+HkdgiSUf/2/clIy4g4ShERqXMJ6vD9D+eglgeV1o5aNWwVdUgiIlKBOpegLsy5MOoQREQkDmpYERGRpKQEJSIiSUkJSkREkpISlIiIJCUlKBERSUpKUCIikpSUoEREJCkpQYmISFIyd486hj1iZquAL6KOo5q0BlZHHUQNpWu393Tt9p6u3d7p7O5tyq6scQmqLjGzPHfPiTqOmkjXbu/p2u09XbuqpVt8IiKSlJSgREQkKSlBJbf7og6gBtO123u6dntP164KqQ1KRESSkmpQIiKSlJSgREQkKSlBRcTMOpnZBDObb2bzzOxn4fqWZvammX0a/tkiXG9mdoeZLTazOWY2INpPED0zSzWzmWb2Srjc1cymhNfoaTOrH65PD5cXh9u7RBl31MysuZk9Z2YLzOwTMxus7138zOyK8N/sXDN70swy9N1LDCWo6OwAfuHuvYBDgUvMrBdwLfC2u3cH3g6XAY4DuoevC4C7qz/kpPMz4JOY5b8At7n7gcA3wI/D9T8GvgnX3xaWq8tuB153955AFsE11PcuDmbWEbgcyHH3PkAqcDr67iWGu+uVBC/gJeD/gIVA+3Bde2Bh+P5eYExM+dJydfEFZBL8kI4AXgGM4An+tHD7YOCN8P0bwODwfVpYzqL+DBFdt2bA52U/v753cV+/jsBSoGX4XXoFOEbfvcS8VINKAmG1vz8wBWjn7l+Fm1YA7cL3Jf8wShSE6+qqvwPXAMXhcitgnbvvCJdjr0/ptQu3rw/L10VdgVXAQ+Ht0QfMrBH63sXF3ZcBtwJfAl8RfJemo+9eQihBRczMGgP/AX7u7htit3nw3y49B1CGmX0f+Nrdp0cdSw2UBgwA7nb3/sBmvrudB+h7tyth29xIgkTfAWgEHBtpULWYElSEzKweQXJ63N2fD1evNLP24fb2wNfh+mVAp5jdM8N1ddFQ4CQzyweeIrjNdzvQ3MzSwjKx16f02oXbmwFrqjPgJFIAFLj7lHD5OYKEpe9dfI4CPnf3Ve5eCDxP8H3Udy8BlKAiYmYG/Av4xN3/FrNpPHBO+P4cgrapkvVnh72qDgXWx9ySqVPc/Tp3z3T3LgQN1O+4+5nABODUsFjZa1dyTU8Ny9fJGoK7rwCWmlmPcNWRwHz0vYvXl8ChZtYw/Ddccv303UsAjSQRETM7DHgf+Jjv2lF+RdAO9QywP8G0Ij9097XhP4Z/ENxO2AKc5+551R54kjGz4cBV7v59M+tGUKNqCcwExrr7NjPLAB4jaOdbC5zu7kuiijlqZpYNPADUB5YA5xH8Z1XfuziY2e+B0QQ9cWcCPyFoa9J3r4opQYmISFLSLT4REUlKSlAiIpKUlKBERCQpKUGJiEhSUoISEZGkpAQldY6ZtTKzWeFrhZkti1muv5t9c8zsjjjOMbmKYm1oZo+b2cfh6NmTwtFHdrXPr3ax7UfhseaExxsZrr/BzI6qiphFqoq6mUudZmbjgE3ufmvMurSYcdUiZWbXAW3c/cpwuQeQ7+7bdrHPJncvl8TMLBN4Fxjg7uvDRNfG3T9PUPgi+0Q1KBHAzB42s3vMbApws5nlmtmH4YCqk0tGXjCz4fbd/FPjzOxBM5toZkvM7PKY422KKT/Rvpt/6fHw4VfM7Phw3fRwzqVXKgitPTFDC7n7wpLkZGZjzWxqWPO714L5sW4CGoTrHi9zrLbARmBTeKxNJckp/PynhjXEktrkx2bm4fYDzOz1MNb3zaxnFVx2kV1K230RkTojExji7kVm1hQY5u47wltffwJ+UME+PYHvAU2AhWZ2dzhGW6z+QG9gOfABMNTM8gimsjjc3T83sycrielB4H9mdirB9CKPuPunZnYwwWgGQ9290Mz+CZzp7tea2aXunl3BsWYDK4HPzext4Hl3fzm2QDhKRDaAmd0CvB5uug+4KDz3IOCfBGMgiiSMEpTId55196LwfTPgETPrTjCyd71K9nk1rNFsM7OvCaapKChTZqq7FwCY2SygC0EtZknM7bUnCSYE3Im7zwqHcDqaYKDSaWY2mGAMuIHhMkADvhvgtUJh4j0WOCTc/zYzG+ju48qWNbPRBIPIHh3eChwCPBueCyB9V+cSqQpKUCLf2Rzz/g/ABHcfZcF8XRMr2Se2LaiIiv9NxVOmUu6+iWDU7OfNrBg4HthOUJu6bg+P5cBUYKqZvQk8BIyLLWNmfcJ1h4dJLYVgvqOKamUiCaM2KJGKNeO7tp9zE3D8hUC3MPlBcLuuHDMbasEcRIQ9DHsRDOb6NnCqmbUNt7U0s87hboUWTOVS9lgdzGxAzKrs8FixZZoT1ObOdvdVAOE8ZZ+b2WlhGTOzrD3/yCJ7RglKpGI3A382s5kk4E6Du38LXAy8bmbTCTovrK+g6AHAu2b2McEo2XnAf9x9PnA9QfvUHOBNgg4VELQXzamgk0Q94NawY8YsgqT4szJlRgKdgftLOkuE688Efmxms4F5YTmRhFI3c5GImFljd98U9uq7C/jU3W+LOi6RZKEalEh0zg9rKPMIbineG3E8IklFNSgREUlKqkGJiEhSUoISEZGkpAQlIiJJSQlKRESSkhKUiIgkpf8HY2/OeK6QkT0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.5088161209068011\n",
      "DEVELOP ACCURACY: 0.4444444444444444\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "TRAIN ACCURACY: 0.5302267002518891\n",
      "DEVELOP ACCURACY: 0.4595959595959596\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import learning_curve\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "predictions = []\n",
    "avg_acc_train = []\n",
    "avg_acc_develop = []\n",
    "\n",
    "for split in splits:\n",
    "  y_split_train = split['train'][:, -1]\n",
    "  y_split_develop = split['develop'][:, -1]\n",
    "  train = split['train'][:, :-1]\n",
    "  develop = split['develop'][:, :-1]\n",
    "\n",
    "  classifier = classifier.fit(train, y_split_train)\n",
    "  develop_predictions = classifier.predict(develop)\n",
    "  predictions.append(develop_predictions)\n",
    "  evaluate = classifier.score(train, y_split_train)\n",
    "  predict = accuracy_score(develop_predictions, y_split_develop)\n",
    "  print('\\n\\n')\n",
    "  print(\"TRAIN ACCURACY:\", evaluate)\n",
    "  avg_acc_train.append(evaluate)\n",
    "  print(\"DEVELOP ACCURACY:\", predict)\n",
    "  avg_acc_develop.append(predict)\n",
    "  # if evaluate > predict:\n",
    "      \n",
    "  #     if evaluate-predict < 0.1:\n",
    "  #         print(\"okay\")\n",
    "  #     else:\n",
    "  #         print(\"maybe overfit\", evaluate-predict)\n",
    "  # else:\n",
    "  #     print(\"may not be overfit\", predict-evaluate)\n",
    "\n",
    "      \n",
    "\n",
    "  train_sizes, train_scores, valid_scores = learning_curve(\n",
    "      RandomForestClassifier(n_estimators=10, max_depth=4, criterion='entropy'),\n",
    "      np.concatenate((train,develop)), np.concatenate((y_split_train,y_split_develop)), cv=5)\n",
    "\n",
    "\n",
    "  train_mean = np.mean(train_scores, axis=1)\n",
    "  train_std = np.std(train_scores, axis=1)\n",
    "\n",
    "  test_mean = np.mean(valid_scores, axis=1)\n",
    "  test_std = np.std(valid_scores, axis=1)\n",
    "\n",
    "\n",
    "  plt.subplots(1)\n",
    "  plt.plot(train_sizes, train_mean, color=\"orange\",  label=\"Training score\")\n",
    "  plt.plot(train_sizes, test_mean, color=\"g\", label=\"Cross-validation score\")\n",
    "\n",
    "  # plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color=\"#DDDDDD\")\n",
    "  # plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color=\"#DDDDDD\")\n",
    "\n",
    "  plt.title(\"Learning Curve\")\n",
    "  plt.xlabel(\"Training Set Size\"), plt.ylabel(\"Accuracy Score\"), plt.legend(loc=\"best\")\n",
    "  plt.tight_layout()\n",
    "  plt.show()\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IkBiFx7-YJew",
    "outputId": "fbf5934b-041a-489b-d472-10e1bf02ad1d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean TRAIN 0.5068010075566751\n",
      "Mean DEVELOP 0.4702020202020202\n",
      "(array([0., 3., 4., 5.]), array([  3,   2, 388,   3]))\n",
      "(array([0., 3., 4., 5.]), array([ 12,   3, 377,   4]))\n",
      "(array([0., 4., 5.]), array([ 10, 381,   5]))\n",
      "(array([0., 3., 4., 5.]), array([  5,   4, 386,   1]))\n",
      "(array([0., 3., 4., 5.]), array([  2,   3, 390,   1]))\n",
      "(array([0., 3., 4., 5.]), array([  1,   2, 388,   5]))\n",
      "(array([0., 4., 5.]), array([  1, 394,   1]))\n",
      "(array([4.]), array([396]))\n",
      "(array([0., 4., 5.]), array([  6, 388,   2]))\n",
      "(array([0., 3., 4., 5.]), array([  3,   6, 386,   1]))\n"
     ]
    }
   ],
   "source": [
    "print(\"Mean TRAIN\", np.mean(avg_acc_train))\n",
    "print(\"Mean DEVELOP\", np.mean(avg_acc_develop))\n",
    "\n",
    "# a = ['equivalent', 'less intense', 'less specific', 'more intense', 'more specific', 'related']\n",
    "# prediction_labels = []\n",
    "# for pred in predictions:\n",
    "#   prediction_labels.append(pred.argmax(1))\n",
    "\n",
    "for pred in predictions:\n",
    "  print(np.unique(pred, return_counts=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "id": "CsMYrvQXy0ff"
   },
   "outputs": [],
   "source": [
    "test_predictions = classifier.predict(test_corpus_pooled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fZX5Ub63FUSG",
    "outputId": "86b20894-6293-4eec-8342-22105532f124"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4., 4., 4., 4., 0., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "       4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "       4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "       4., 4., 4., 4., 4., 4., 4., 3., 3., 4., 3., 4., 4., 4., 4., 4., 4.,\n",
       "       4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "       4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4., 4.,\n",
       "       4.])"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7MCMoYQmFE5F",
    "outputId": "f2cd4b21-589c-45fa-ecbe-9b7c8bb9aad0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.32038834951456313"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(test_predictions, test_y_encoded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OeSZ-54VFiFU",
    "outputId": "57d9d1ab-5fe6-4d39-ac07-1299abe56151"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 4, 0, 3, 4, 5, 0, 4, 0, 0, 3, 4, 3, 3, 4, 2, 0, 4, 5, 4, 1, 5,\n",
       "       4, 1, 4, 4, 0, 4, 5, 4, 4, 3, 3, 0, 5, 4, 0, 3, 0, 4, 5, 2, 5, 4,\n",
       "       3, 3, 0, 1, 4, 5, 5, 0, 4, 3, 0, 1, 0, 3, 3, 5, 4, 0, 4, 4, 5, 3,\n",
       "       0, 5, 0, 2, 3, 0, 4, 4, 5, 0, 0, 4, 2, 5, 5, 4, 4, 4, 0, 0, 2, 3,\n",
       "       5, 4, 5, 5, 4, 4, 5, 5, 3, 4, 0, 3, 4, 3, 5])"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_y_encoded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VWiN-tskF8dK"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "[Task4]Synonyms_Equivalence_Classifier.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}