notebook - warmup.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "45f41fdc-8c69-4448-9ad8-04c1874e1725",
   "metadata": {},
   "source": [
    "---\n",
    "### **<p style=\"text-align: center; text-decoration: underline;\">Natural Language Processing</p>**\n",
    "# **<p style=\"text-align: center;\">Practical: A bit of Morphological Warm up</p>**\n",
    "---\n",
    "\n",
    "> Realized by: *Zakaria Boulkhir* & *Omar Iken*.\n",
    "\n",
    "> Master 2, Data Science, Lille University.\n",
    "\n",
    "---\n",
    "\n",
    "### ■ __Overview__\n",
    "The objective of this part is to write down a very simple system that predict morphological attributes. To do so, we will use the data available [here](https://github.com/sigmorphon2020/task0-data). Then, we will pick a language we do not speak, for instance *Swahili (swa)*, and we explore the data.\n",
    "\n",
    "### ■ **<a name=\"content\">Contents</a>**\n",
    "\n",
    "- [1. Dataset](#section1)\n",
    "\n",
    "- [2. Simple baseline](#section2)\n",
    "\n",
    "- [3. Prefix-based approach](#section3)\n",
    "\n",
    "\n",
    "### ■ **Libraries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "be7a0775-1e53-4c08-bf31-bc8e23cdd395",
   "metadata": {},
   "outputs": [],
   "source": [
    "## numpy to handle arrays & matices\n",
    "import numpy as np\n",
    "\n",
    "## matplotlib & Seaborn to plot figures\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "## pandas to handle dataframes\n",
    "import pandas as pd\n",
    "from scipy import stats\n",
    "from tqdm import tqdm\n",
    "import codecs\n",
    "import os\n",
    "from utils.utils import *\n",
    "import unidecode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e89771db-6da9-4372-a65d-c762f0c13f4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy version : 1.20.1\n",
      "pandas version: 1.2.4\n"
     ]
    }
   ],
   "source": [
    "#-----------< Setting >------------#\n",
    "## set plots text font size & style\n",
    "sns.set(font_scale=1.2, style='whitegrid')\n",
    "plt.rcParams['figure.figsize'] = (12, 8)\n",
    "\n",
    "print(f'numpy version : {np.__version__}')\n",
    "print(f'pandas version: {pd.__version__}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bfeed2f-02e6-492e-9986-4124a0a62325",
   "metadata": {},
   "source": [
    "### ■ **<a name=\"section1\">1. Dataset</a>** [(&#8593;)](#content)\n",
    "\n",
    "\n",
    "#### **1.1. Load data**\n",
    "Let's start by laoding our dataset, and then pick a random language from the set of languages. For instance, the *swahli (swa)* language. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3eef3190-ac67-40a2-9675-c5655e3d613f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of training samples: 3374\n",
      "Number of testing samples : 910\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lemma</th>\n",
       "      <th>form</th>\n",
       "      <th>attributes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>V;PRF;FIN;IND;SG;3;PST</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>kamilisha</td>\n",
       "      <td>wangekamilisha</td>\n",
       "      <td>V;FIN;COND;PL;3;PRS</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>fuata</td>\n",
       "      <td>walifuata</td>\n",
       "      <td>V;FIN;IND;PL;3;PST</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>tengeneza</td>\n",
       "      <td>nitatengeneza</td>\n",
       "      <td>V;FIN;IND;SG;1;FUT</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>uwa</td>\n",
       "      <td>anauwa</td>\n",
       "      <td>V;DEF;FIN;IND;SG;3;PRS</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       lemma            form              attributes\n",
       "0       piga         amepiga  V;PRF;FIN;IND;SG;3;PST\n",
       "1  kamilisha  wangekamilisha     V;FIN;COND;PL;3;PRS\n",
       "2      fuata       walifuata      V;FIN;IND;PL;3;PST\n",
       "3  tengeneza   nitatengeneza      V;FIN;IND;SG;1;FUT\n",
       "4        uwa          anauwa  V;DEF;FIN;IND;SG;3;PRS"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## file path\n",
    "train_file = 'data/DEVELOPMENT-LANGUAGES/niger-congo/swa.trn'\n",
    "test_file = 'data/GOLD-TEST/swa.tst'\n",
    "\n",
    "## dataframe\n",
    "df_train = read_file(train_file)\n",
    "df_test = read_file(test_file)\n",
    "\n",
    "## number of training & testing samples\n",
    "n_train = df_train.shape[0]\n",
    "n_test = df_test.shape[0]\n",
    "print(f'Number of training samples: {n_train}')\n",
    "print(f'Number of testing samples : {n_test}')\n",
    "\n",
    "## dispaly some samples\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26278ef5-5e5d-47ef-a130-30c737de290b",
   "metadata": {},
   "source": [
    "#### **1.2. Unzip attributes:** \n",
    "Now, we will extract the individual attributes for each form. For instance, the attributes for *amepiga* are *{V;PRF;FIN;IND;SG;3;PST}*, so unziping means creating a new sample for each of the morphological attributes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e91dee13-b793-4d94-9dc7-0dcc8298fe84",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lemma</th>\n",
       "      <th>form</th>\n",
       "      <th>attributes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>V</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>PRF</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>FIN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>IND</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>SG</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  lemma     form attributes\n",
       "0  piga  amepiga          V\n",
       "1  piga  amepiga        PRF\n",
       "2  piga  amepiga        FIN\n",
       "3  piga  amepiga        IND\n",
       "4  piga  amepiga         SG"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def unzip_attrs(df):\n",
    "    \"\"\"\"\"\"\n",
    "    ## unzip attributes\n",
    "    df_unzip = []\n",
    "\n",
    "    for idx in df.index:\n",
    "        lemma, form, attrs = df.iloc[idx].to_list()\n",
    "\n",
    "        for attr in attrs.split(';'):\n",
    "            df_unzip.append([lemma, form, attr])\n",
    "        \n",
    "    ## create a new dataframe  \n",
    "    df_unzip = pd.DataFrame(df_unzip, columns=df.columns)\n",
    "        \n",
    "    return df_unzip\n",
    "\n",
    "## unzip attributes\n",
    "df_train_unzip = unzip_attrs(df_train)\n",
    "df_train_unzip.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff459d10-3dc1-4848-a07b-66380bdade20",
   "metadata": {},
   "source": [
    "#### **1.3. Data exploration**\n",
    "Let's do a bit of data exploration: count the number of characters, n-grams, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5f38e05-5936-4c53-b126-af5117890a8f",
   "metadata": {},
   "source": [
    "##### **1.3.1. Unique Characters:**\n",
    "Get the unique the characters of the language."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f6fa0fe2-ad89-4460-9e22-7364e5ffc5d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Number of unique characters: 24\n",
      "> Characters: a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, r, s, t, u, v, w, y, z\n"
     ]
    }
   ],
   "source": [
    "## get the number of unique characters\n",
    "text = ''.join(df_train[['lemma', 'form']].to_numpy().flatten())\n",
    "\n",
    "## get (number of) unique characters\n",
    "unique_chars = sorted(set(text))\n",
    "n_chars = len(unique_chars)\n",
    "\n",
    "print(f\"> Number of unique characters: {n_chars}\\n> Characters: {', '.join(unique_chars)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1cb2368-1c9f-48e4-a921-eee51aca90f5",
   "metadata": {},
   "source": [
    "##### **1.3.2. Morphological attributes:** \n",
    "histogram of different attributes, this will allow us to see which one is dominating."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d73fca13-83fd-40a8-8f58-da71b84270c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Number of unique morphological attributes: 16\n",
      "> Morphological attributes: 1, 2, 3, COND, DEF, FIN, FUT, HAB, IND, INDF, PL, PRF, PRS, PST, SG, V\n"
     ]
    }
   ],
   "source": [
    "## get unique morphological attributes\n",
    "morph_attrs = ';'.join(df_train['attributes'].to_list()).split(';')\n",
    "morph_attrs = np.asarray(morph_attrs)\n",
    "unique_attrs = sorted(set(morph_attrs)) ## sort to keep same order\n",
    "n_attrs = len(unique_attrs)\n",
    "\n",
    "print(f\"> Number of unique morphological attributes: {n_attrs}\\n> Morphological attributes: {', '.join(unique_attrs)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ea890535-16d1-4d7b-8c21-054222fc24b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1gAAAEtCAYAAAAV78HzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABJ30lEQVR4nO3de1iU1fr/8c+AoALmASy3Ih7ziAOippRZ2nZXKp7CryapWUlhWrGNnWaJEpjuLM0IEw+Rbi2/W/MA1c4yf20ppdQCNUsl0zylgqIgCsj8/vByvo2KDDgMM/B+XZfX5TxrzZr7Bgaee9bzrGUwmUwmAQAAAABumUtlBwAAAAAAVQUFFgAAAADYCAUWAAAAANgIBRYAAAAA2AgFFgAAAADYCAUWAAAAANgIBRYAAAAA2EgNe77Y/Pnz9cknn+j48ePy8vJScHCwJk+erIYNGyotLU2jR4+26N+uXTutX7/e/DgvL0+vvfaaNm7cKDc3Nw0ZMkRRUVFydXU191mzZo3effddnT59WgEBAYqNjVWzZs2siq+4uFh5eXlyc3OTwWCwTdIAAAAAqgyTyaTCwkJ5enrKxeX6+Sq7FlgtW7bUjBkz5Ovrq+zsbM2aNUuTJ0/WkiVLzH1SU1P/L7galuHFxMRo9+7dSkpKUl5enqKiouTl5aUJEyZIkrZu3aro6GhFR0crICBACQkJCg8P1yeffHLdWDeSl5enffv22ShbAAAAAFVVmzZtVKdOneuO27XAGjBggPn/vr6+euqppzRp0iSLPg0bNrzhc3NycpScnKylS5fKaDRKkl544QW99dZbGj9+vFxcXLRixQr1799fw4YNkyTNnDlTwcHB2rJli3r37l1qfG5ubpKufLHc3d3LlaM1du/eLX9//wobv6I5e/wSOTgKcnAMzp6Ds8cvkYOjIAfH4Ow5OHv8EjmUpqCgQPv27TPXDteya4H1Z+fPn1dKSoqCgoIsjvfp00fFxcXq3LmzoqKi1LhxY0nSnj17ZDAY1K1bN3Pf4OBgZWVl6ciRI/Lz81NGRoYiIyPN7R4eHjIajUpPT7eqwLp6WaC7u7tq1qxpizRLVNHjVzRnj18iB0dBDo7B2XNw9vglcnAU5OAYnD0HZ49fIgdrlHRLkcFkMpkq9JWvsWHDBkVHR+vChQsKCAhQYmKi6tWrp19//VU7d+6Uv7+/zp49q4SEBB07dkwpKSmqVauWkpOT9frrr+vbb781j5Wfn6/AwEB99NFH6ty5s/z9/fXuu+/qvvvuM/d5/vnnVbduXcXExJQa26VLl7R79+4KyRsAAABA1eHv73/DIs7uM1h9+vSR0WjU8ePH9c4772jatGmaP3++WrZsqZYtW5r7+fv7q3fv3tq8ebMefvhh3agOrKiFKEr6YtnKjh071KVLlwobv6I5e/wSOTgKcnAMzp6Ds8cvkYOjIAfH4Ow5OHv8EjmUprRJGbsXWF5eXvLy8lLz5s3VsmVL9erVSwcOHFDr1q2v6+fn56ejR49Kknx8fJSTk6PLly+bVw3MysqSJHl7e0uSGjRooOzsbItxsrOz1aJFi4pOCwAAAAAqdx+sq7NSN1re8OLFizpy5Ij5HqwOHTrIZDJp+/bt5j7btm2Tt7e3fH19JUlGo1FpaWnm9vz8fGVkZCggIKAi0wAAAAAASXacwSosLFR8fLweeOABeXt76/jx43r77bfVsWNHNW/eXKtWrZKPj4/uvPNOnTt3TvHx8fLw8DDfT1WvXj0NGDBAsbGxiouL04ULFzRv3jyNHDnSXKCFhYVp3Lhx6tq1q3mZ9kaNGqlnz572ShMAAABANWa3AstgMCgzM1Nr1qzR2bNn1bBhQ91zzz167rnn5OLioqKiIs2aNUsnTpxQnTp1FBQUpKSkJHl6eprHiI6OVkxMjMaMGWPeaDgiIsLcHhwcrOnTpyshIUGnTp1SYGCgFi5cWOISigAAAABgS3YrsGrUqKH4+PgS28PCwhQWFnbTMTw9PTV79mzNnj27xD6hoaEKDQ0td5wAAAAAUF6Veg8WAAAAAFQlFFi3qKDwcpmfU9YlI8vzGhU5fnmWvKzoHAAAAABHYPdl2qsadzdXhUxaX6GvkfzmoAodvyrkAAAAADgCZrAAAAAAwEYosAAAAADARiiwAAAAAMBGKLAAAAAAwEYosAAAAADARiiwAAAAAMBGKLAAAAAAwEYosAAAAADARiiwAAAAAMBGKLAAAAAAwEYosAAAAADARiiwAAAAAMBGKLAAAAAAwEYosAAAAADARiiwAAAAAMBGKLAAAAAAwEYosAAAAADARuxaYM2fP18PPvigjEaj7r77bk2aNEmnTp0yt6enp2vo0KHq1KmT+vXrp6+//tri+Xl5eZo8ebKCgoLUvXt3zZo1S5cvX7bos2bNGvXp00dGo1GjRo3SoUOH7JIbAAAAANi1wGrZsqVmzJihTz/9VO+9956OHz+uyZMnS5LOnDmjcePGKSgoSGvXrtWgQYM0YcIE/fbbb+bnx8TEaNeuXUpKStK8efOUkpKiBQsWmNu3bt2q6OhoRUREaPXq1fL29lZ4eLiKiorsmSYAAACAasquBdaAAQPUo0cP+fr6ymg06qmnntLOnTslScnJyfLy8tLUqVPVunVrPf300zIajVq1apUkKScnR8nJyXr11VdlNBoVHBysF154QStXrlRxcbEkacWKFerfv7+GDRumNm3aaObMmTpx4oS2bNlizzQBAAAAVFOVdg/W+fPnlZKSoqCgIElSRkaGunfvLoPBYO4THBys9PR0SdKePXtkMBjUrVs3i/asrCwdOXLEPEaPHj3M7R4eHjIajeYxAAAAAKAi1bD3C27YsEHR0dG6cOGCAgIClJiYKEnKzs5W+/btLfrWr19fWVlZkqSsrCzVrVtXrq6u5vYGDRqY2/z8/JSdnW0+9uc+2dnZZYpx9+7dVvft0qVLmcYurx07dlTY2FUhh/JwtHjKgxwcAzlUPmePXyIHR0EOjsHZc3D2+CVyuBV2L7CuLkBx/PhxvfPOO5o2bZrmz58vk8l00+fdqP3Ps1225O/vr5o1a1bI2OVlryKoIjlSDjt27HCoeMqDHBwDOVQ+Z49fIgdHQQ6OwdlzcPb4JXIozaVLl246IWP3AsvLy0teXl5q3ry5WrZsqV69eunAgQPy9va+bqbpzJkz8vb2liT5+PgoJydHly9fNs9iXZ3dutrnRrNV2dnZatGiRUWnBQAAAACVuw/W1VkpFxcXGY1GpaWlWbRv27ZNAQEBkqQOHTrIZDJp+/btFu3e3t7y9fWVpOvGyM/PV0ZGhnkMAAAAAKhIdiuwCgsLNXfuXGVkZOjo0aPavn27oqKi1LFjRzVv3lwhISHKzc1VXFycMjMzlZiYqPT0dA0fPlySVK9ePQ0YMECxsbHKyMjQtm3bNG/ePI0cOVIuLlfSCAsLU0pKilavXq39+/fr5ZdfVqNGjdSzZ097pQkAAACgGrPbJYIGg0GZmZlas2aNzp49q4YNG+qee+7Rc889JxcXF9WvX1+JiYmKiYnRhx9+qKZNmyo+Pl7Nmzc3jxEdHa2YmBiNGTNGbm5uGjJkiCIiIsztwcHBmj59uhISEnTq1CkFBgZq4cKFcnNzs1eaAAAAAKoxuxVYNWrUUHx8/E37BAYG6uOPPy6x3dPTU7Nnz9bs2bNL7BMaGqrQ0NByxwkAAAAA5VWp92ABAAAAQFVCgQUAAAAANkKBBQAAAAA2QoEFAAAAADZCgQUAAAAANkKBBQAAAAA2QoEFAAAAADZCgQUAAAAANkKBBQAAAAA2QoEFAAAAADZCgQUAAAAANkKBBQAAAAA2QoEFAAAAADZCgQUAAAAANkKBBQAAAAA2QoEFAAAAADZCgQUAAAAANkKBBQAAAAA2QoEFAAAAADZCgQUAAAAANmK3AmvBggUaNGiQAgMD1atXL8XGxiovL8/cnpaWprZt21r8GzRokMUYeXl5mjx5soKCgtS9e3fNmjVLly9ftuizZs0a9enTR0ajUaNGjdKhQ4fskh8AAAAA1LDXC/3www966qmn1LFjR2VlZenVV19VXl6eXn/9dYt+qamp/xdcDcvwYmJitHv3biUlJSkvL09RUVHy8vLShAkTJElbt25VdHS0oqOjFRAQoISEBIWHh+uTTz65biwAAAAAsDW7VR2JiYnm/7ds2VLPP/+8oqOjr+vXsGHDGz4/JydHycnJWrp0qYxGoyTphRde0FtvvaXx48fLxcVFK1asUP/+/TVs2DBJ0syZMxUcHKwtW7aod+/eFZAVAAAAAPyfSpvWOXPmjOrUqXPd8T59+qi4uFidO3dWVFSUGjduLEnas2ePDAaDunXrZu4bHBysrKwsHTlyRH5+fsrIyFBkZKS53cPDQ0ajUenp6WUqsHbv3m113y5duljd91bs2LGjwsauCjmUh6PFUx7k4BjIofI5e/wSOTgKcnAMzp6Ds8cvkcOtqJQC6/z581q6dKkeeeQR87GGDRsqLi5O/v7+Onv2rBISEjR69GilpKSoVq1aysrKUt26deXq6mp+ToMGDSRJWVlZ8vPzU3Z2tvnYn/tkZ2eXKT5/f3/VrFnzFjK0PXsVQRXJkXLYsWOHQ8VTHuTgGMih8jl7/BI5OApycAzOnoOzxy+RQ2kuXbp00wkZuxdYBQUFmjhxopo2barw8HDz8ZYtW6ply5bmx/7+/urdu7c2b96shx9+WCaT6bqxDAaDXWIGAAAAAGvYdZn2oqIiRUZGKi8vT/Hx8TddeMLLy0t+fn46evSoJMnHx0c5OTkWqwZmZWVJkry9vSXdeLbqRrNaqHoKCi+X3ulPyvqJRlnHBwAAQPVktxms4uJivfTSSzp8+LCWL18uT0/Pm/a/ePGijhw5Yr4Hq0OHDjKZTNq+fbu6d+8uSdq2bZu8vb3l6+srSTIajUpLS9OQIUMkSfn5+crIyNATTzxRgZnBEbi7uSpk0voKGz/5zUGldwIAAEC1Z7cC69VXX1VaWpoWLVqkwsJCnTp1StKVWSdXV1etWrVKPj4+uvPOO3Xu3DnFx8fLw8ND9913nySpXr16GjBggGJjYxUXF6cLFy5o3rx5GjlypFxcrkzEhYWFady4ceratat5mfZGjRqpZ8+e9koTAAAAQDVmtwJr9erVkqTBgwdbHN+0aZN8fX1VVFSkWbNm6cSJE6pTp46CgoKUlJRkMdMVHR2tmJgYjRkzRm5ubhoyZIgiIiLM7cHBwZo+fboSEhJ06tQpBQYGauHChXJzc7NLjgAAAACqN7sVWL/88stN28PCwhQWFnbTPp6enpo9e7Zmz55dYp/Q0FCFhoaWK0YAAAAAuBV2XeQCAAAAAKoyCiwAAAAAsBEKLAAAAACwEQosAAAAALARCiwAAAAAsBEKLAAAAACwEQosAAAAALARCiwAAAAAsBEKLAAAAACwEQosAAAAALARCiwAAAAAsBEKLAAAAACwEQosAAAAALARCiwAAAAAsBEKLAAAAACwEQosAAAAALCRchdYeXl5+n//7//pt99+s2E4AAAAAOC8rC6wJk2apGXLlkmSCgsL9T//8z965plnNGDAAG3evLnCAgQAAAAAZ2F1gZWWlqagoCBJ0ubNm5WXl6fU1FRNmDBBCQkJFRYgAAAAADgLqwusnJwc+fj4SJK++eYb9e3bVz4+PhowYIAyMzNLff6CBQs0aNAgBQYGqlevXoqNjVVeXp5Fn/T0dA0dOlSdOnVSv3799PXXX1u05+XlafLkyQoKClL37t01a9YsXb582aLPmjVr1KdPHxmNRo0aNUqHDh2yNkUAAAAAuCVWF1gNGjTQkSNHJEnffvutunfvLkm6ePGiXFxKH+aHH37QU089pY8//lhvvvmmUlNTFRsba24/c+aMxo0bp6CgIK1du1aDBg3ShAkTLO7xiomJ0a5du5SUlKR58+YpJSVFCxYsMLdv3bpV0dHRioiI0OrVq+Xt7a3w8HAVFRVZmyYAAAAAlJvVBdZDDz2kF198UY8//rhyc3N1zz33SJL27t0rPz+/Up+fmJiokJAQtWzZUt26ddPzzz+vTZs2mduTk5Pl5eWlqVOnqnXr1nr66adlNBq1atUqSVdm0JKTk/Xqq6/KaDQqODhYL7zwglauXKni4mJJ0ooVK9S/f38NGzZMbdq00cyZM3XixAlt2bKlTF8UAAAAACgPqwusqKgojRkzRnfeeafef/991a5dW5J08uRJDR8+vMwvfObMGdWpU8f8OCMjQ927d5fBYDAfCw4OVnp6uiRpz549MhgM6tatm0V7VlaWeWYtIyNDPXr0MLd7eHjIaDSaxwAAAACAilTD2o4nT57UmDFjrrsc8IknntDx48fL9KLnz5/X0qVL9cgjj5iPZWdnq3379hb96tevr6ysLElSVlaW6tatK1dXV3N7gwYNzG1+fn7Kzs42H/tzn+zs7DLFt3v3bqv7dunSpUxjl9eOHTsqbGxysE5Fxl9ejhhTWZGDY3D2HJw9fokcHAU5OAZnz8HZ45fI4VZYXWA98MADSk1Nlbe3t8Xxs2fP6oEHHtDevXutGqegoEATJ05U06ZNFR4ebj5uMplu+rwbtf95tsuW/P39VbNmzQoZu7zsVQRVJGfPwdHi37Fjh8PFVFbk4BicPQdnj18iB0dBDo7B2XNw9vglcijNpUuXbjohY/UlgiUVQBcvXpS7u7tVYxQVFSkyMlJ5eXmKj49XjRr/V995e3tfN9N05swZc0Hn4+OjnJwci1UDr85uXe1zo9mqG81qAQAAAEBFKHUGKz4+XtKV2aIlS5bIw8PD3FZcXKydO3eqdevWpb5QcXGxXnrpJR0+fFjLly+Xp6enRbvRaFRSUpLFsW3btikgIECS1KFDB5lMJm3fvt28guG2bdvk7e0tX19f8xhpaWkaMmSIJCk/P18ZGRl64oknSo0PAAAAAG5VqQXWhg0bJF2Zwfr8888t7oFyc3OTr6+vXnzxxVJf6NVXX1VaWpoWLVqkwsJCnTp1StKVWSdXV1eFhIQoPj5ecXFxGjFihDZt2qT09HTzUu716tXTgAEDFBsbq7i4OF24cEHz5s3TyJEjzfeFhYWFady4ceratasCAgKUkJCgRo0aqWfPnmX/ygAAAABAGZVaYG3cuFGSNGrUKMXHx6tu3brleqHVq1dLkgYPHmxxfNOmTfL19VX9+vWVmJiomJgYffjhh2ratKni4+PVvHlzc9/o6GjFxMRozJgxcnNz05AhQxQREWFuDw4O1vTp05WQkKBTp04pMDBQCxculJubW7liBgAAAICysHqRi+XLl9/SC/3yyy+l9gkMDNTHH39cYrunp6dmz56t2bNnl9gnNDRUoaGh5YoRAAAAAG6F1QWWJH333Xf65ptvdPr0afPmvle9/vrrNg0MAAAAAJyN1QXW4sWLNWfOHLVo0UJ33HFHhS2RDgAAAADOyuoC61//+pemTp2qUaNGVWQ8AAAAAOC0rN4H69y5c7r//vsrMBQAAAAAcG5WF1h//etftW3btoqMBQAAAACcmtWXCAYGBurtt9/W/v371a5du+uWPg8JCbF5cAAAAADgTKwusGJiYiRJy5Ytu67NYDBQYAEAAACo9qwusH7++eeKjAMAAAAAnJ7V92ABAAAAAG7O6hms+Pj4m7ZPmDDhloMBAAAAAGdmdYG1YcMGi8dFRUX6448/5O7urttvv50CCwAAAEC1Z3WBtXHjxuuOZWVl6aWXXtKIESNsGhQAAAAAOKNbugfL29tbL7zwgt544w1bxQMAAAAATuuWF7moUaOGTp48aYtYgGqtoPBymfp36dKlQscHAABA2Vl9ieDOnTstHptMJp08eVKLFy+Wv7+/zQMDqht3N1eFTFpfYeMnvzmowsYGAADAFVYXWCNHjpTBYJDJZLI4HhQUpNjYWJsHBsD5FBRelrubq9X9yzMLV5bxAQAA7M3qAmvTpk0Wj11cXNSgQQPVrFnT5kEBcE5VYRaOIhEAANwKqwusJk2aVGQcAOAQqkKRCAAAKo/VBZYkHTx4UIsXL9aBAwdkMBjUunVrPfnkk2rRokVFxQcAAAAATsPqVQS/+eYbhYSEaO/evQoICFCnTp30008/aeDAgdq6dWtFxggAAAAATsHqGay33npLjz76qKZOnWpxPDY2Vm+++aZWr15d6hgbN27UihUrtHv3buXm5uqXX34xt6WlpWn06NEW/du1a6f16//vUp28vDy99tpr2rhxo9zc3DRkyBBFRUXJ1fX/7mdYs2aN3n33XZ0+fVoBAQGKjY1Vs2bNrE0TAAAAAMrN6hms/fv369FHH73u+MiRI7Vv3z6rxsjPz1ePHj0UHh5eYp/U1FTzv6SkJIu2mJgY7dq1S0lJSZo3b55SUlK0YMECc/vWrVsVHR2tiIgIrV69Wt7e3goPD1dRUZF1SQIAAADALbB6BsvT01MnTpxQy5YtLY4fO3ZMXl5eVo0xaNCVm7vT0tJK7NOwYcMbHs/JyVFycrKWLl0qo9EoSXrhhRf01ltvafz48XJxcdGKFSvUv39/DRs2TJI0c+ZMBQcHa8uWLerdu7dVMQIAAABAeVk9g9W3b1+9+uqr2rJli/Lz85Wfn6///ve/io6OVt++fW0WUJ8+fXT//fcrMjJSx44dMx/fs2ePDAaDunXrZj4WHBysrKwsHTlyRJKUkZGhHj16mNs9PDxkNBqVnp5us/gAAAAAoCRWz2C99NJLmjJlisaNGyeDwWA+/uCDDyoqKuqWA2nYsKHi4uLk7++vs2fPKiEhQaNHj1ZKSopq1aqlrKws1a1b1+J+qwYNGkiSsrKy5Ofnp+zsbPOxP/fJzs4uUyy7d++2um9Z98Aprx07dlTY2ORgnYqMXyIHa5FDxXDEmMrC2eOXyMFRkINjcPYcnD1+iRxuRZkuEZw/f74OHz6sAwcOSJLuvPNONW3a1CaBtGzZ0uLyQ39/f/Xu3VubN2/Www8/LJPJdN1z/lzo2ZK/v7/DbaBsryKoIjl7Ds4ev0QOjsLRctixY4fDxVQWzh6/RA6Oghwcg7Pn4OzxS+RQmkuXLt10QsbqAuv5559X+/bt9cwzz8jPz898PDExUT/99JPmzZt3S4Fey8vLS35+fjp69KgkycfHRzk5Obp8+bJ5FisrK0uS5O3tLenGs1XZ2dns0wUAAADALqy+B+v777/Xfffdd93xXr16afv27TYNSpIuXryoI0eOqHHjxpKkDh06yGQyWbzWtm3b5O3tLV9fX0mS0Wi0WEAjPz9fGRkZCggIsHl8AAAAAHAtq2ewzp8/Lw8Pj+uO16pVSzk5OVaNcfbsWR0/flyHDx+WJO3du1eS1KpVK61du1Y+Pj668847de7cOcXHx8vDw8Nc1NWrV08DBgxQbGys4uLidOHCBc2bN08jR46Ui8uVOjEsLEzjxo1T165dFRAQoISEBDVq1Eg9e/a0Nk0AAAAAKDerCyw/Pz998803123a+80335hnkErz1VdfacqUKebHgwcPliRt2rRJRUVFmjVrlk6cOKE6deooKChISUlJ8vT0NPePjo5WTEyMxowZY95oOCIiwtweHBys6dOnKyEhQadOnVJgYKAWLlwoNzc3a9MEAAAAgHKzusAaOXKk5syZo4KCAt19990yGAxKTU3VO++8o8jISKvGGDp0qIYOHXrDtrCwMIWFhd30+Z6enpo9e7Zmz55dYp/Q0FCFhoZaFQ8AAAAA2JLVBVZYWJiysrI0d+5cc4Hj7u6usWPHatSoURUWIAAAAAA4C6sLLEl67rnnNG7cOO3fv1+S1Lp16xvelwUAAAAA1VGZCixJql27toxGY0XEAgAAAABOzepl2gEAAAAAN0eBBQAAAAA2QoEFAAAAADZCgQUAAAAANkKBBQAAAAA2QoEFAFVIQeHlMj+nS5cuFf4aAABUF2Veph0A4Ljc3VwVMml9hb5G8puDKnR8AACcGTNYAAAAAGAjFFgAAAAAYCMUWAAAAABgIxRYAAAAAGAjFFgAAAAAYCMUWAAAh1LWZeDLusx8eV4DAABrsUw7AMChsNQ8AMCZMYMFAICNVfQsHDNwAOC4mMECAMDGKnoWjhk4AHBczGABAIDrMAsHAOVj1xmsjRs3asWKFdq9e7dyc3P1yy+/WLSnp6drxowZ2r9/v5o2baqXXnpJ9913n7k9Ly9Pr732mjZu3Cg3NzcNGTJEUVFRcnV1NfdZs2aN3n33XZ0+fVoBAQGKjY1Vs2bN7JYjAABVAbNwAFA+dp3Bys/PV48ePRQeHn5d25kzZzRu3DgFBQVp7dq1GjRokCZMmKDffvvN3CcmJka7du1SUlKS5s2bp5SUFC1YsMDcvnXrVkVHRysiIkKrV6+Wt7e3wsPDVVRUZI/0AAAAAFRzdi2wBg0apIiICAUGBl7XlpycLC8vL02dOlWtW7fW008/LaPRqFWrVkmScnJylJycrFdffVVGo1HBwcF64YUXtHLlShUXF0uSVqxYof79+2vYsGFq06aNZs6cqRMnTmjLli32TBMAAABANeUwi1xkZGSoe/fuMhgM5mPBwcH69ttvJUl79uyRwWBQt27dLNqzsrJ05MgR+fn5KSMjQ5GRkeZ2Dw8PGY1Gpaenq3fv3lbHsnv3bqv7lmf/lfLYsWNHhY1NDtapyPglcrAWOdwc72frOXsOvBcqhiPGVFbkUPmcPX6JHG6FwxRY2dnZat++vcWx+vXrKysrS5KUlZWlunXrWtxv1aBBA3Obn5+fsrOzzcf+3Cc7O7tMsfj7+6tmzZrlSaPC2OuEoyI5ew7OHr9EDo6CHByDs+fg7PFLjpfDjh07HC6msiKHyufs8UvkUJpLly7ddELGYVYRNJlMZW7/82wXAAAAAFQ2hymwvL29r5tpOnPmjLy9vSVJPj4+ysnJ0eXL/7es69XZrat9bjRbdaNZLQAAAACoCA5TYBmNRqWlpVkc27ZtmwICAiRJHTp0kMlk0vbt2y3avb295evre8Mx8vPzlZGRYR4DAAAAACqSXQuss2fPau/evTp8+LAkae/evdq7d68KCgoUEhKi3NxcxcXFKTMzU4mJiUpPT9fw4cMlSfXq1dOAAQMUGxurjIwMbdu2TfPmzdPIkSPl4nIljbCwMKWkpGj16tXav3+/Xn75ZTVq1Eg9e/a0Z5oAAAAAqim7LnLx1VdfacqUKebHgwcPliRt2rRJvr6+SkxMVExMjD788EM1bdpU8fHxat68ubl/dHS0YmJiNGbMGPNGwxEREeb24OBgTZ8+XQkJCTp16pQCAwO1cOFCubm52StFAAAAANWYXQusoUOHaujQoSW2BwYG6uOPPy6x3dPTU7Nnz9bs2bNL7BMaGqrQ0NBbihMAAAAAysNh7sECAAAAAGdHgQUAAAAANkKBBQAAqqSCwsuld/qTsm5KWtbxAVQPdr0HCwAAwF7c3VwVMml9hY2f/OagChsbgPNiBgsAAAAAbIQCCwAAAABshAILAAAAAGyEAgsAAAAAbIQCCwAAAABshAILAAAAAGyEAgsAAAAAbIQCCwAAAABshAILAAAAAGyEAgsAAAAAbIQCCwAAAABshAILAAAAAGyEAgsAAAAAbIQCCwAAAABshAILAAAAAGzEoQqsyZMnq23bthb/kpKSLPqkp6dr6NCh6tSpk/r166evv/7aoj0vL0+TJ09WUFCQunfvrlmzZuny5ct2zAIAAABAdVWjsgO41sMPP6ypU6eaH3t5eZn/f+bMGY0bN04DBw7UP//5T23atEkTJkxQcnKymjdvLkmKiYnR7t27lZSUpLy8PEVFRcnLy0sTJkywdyoAAAAAqhmHmsGSpFq1aqlhw4bmf7Vr1za3JScny8vLS1OnTlXr1q319NNPy2g0atWqVZKknJwcJScn69VXX5XRaFRwcLBeeOEFrVy5UsXFxZWVEgAAAIBqwuEKrK+++ko9evRQSEiIFi5cqKKiInNbRkaGunfvLoPBYD4WHBys9PR0SdKePXtkMBjUrVs3i/asrCwdOXLEfkkAAAAAqJYc6hLBXr16qV+/frrjjju0Z88e/fOf/1ReXp7+/ve/S5Kys7PVvn17i+fUr19fWVlZkqSsrCzVrVtXrq6u5vYGDRqY2/z8/KyKY/fu3VbH3KVLF6v73oodO3ZU2NjkYJ2KjF8iB2uRw83xfraes+fAe6F0VSGH8nDEmMrK2XNw9vglcrgVDlVg9evXz/z/tm3bysXFRTNmzFBkZKQMBoNMJtNNn3+j9j/PdlnL399fNWvWLPPzKpK9TjgqkrPn4OzxS+TgKMjBMTh7Ds4ev0QOFWHHjh0OF1NZOXsOzh6/RA6luXTp0k0nZBzuEsE/69ixoy5cuKAzZ85Ikry9vZWdnW3R58yZM/L29pYk+fj4KCcnx2LVwKuzW1f7AAAAAEBFcegCa//+/apdu7bq168vSTIajUpLS7Pos23bNgUEBEiSOnToIJPJpO3bt1u0e3t7y9fX136BAwAAAKiWHKrAev3115Wenq4jR45o48aNev311zV8+HDzZX4hISHKzc1VXFycMjMzlZiYqPT0dA0fPlySVK9ePQ0YMECxsbHKyMjQtm3bNG/ePI0cOVIuLg6VKgAAAIAqyKHuwTpw4ICefvpp5ebmqnHjxho+fLjCw8PN7fXr11diYqJiYmL04YcfqmnTpoqPjzfvgSVJ0dHRiomJ0ZgxY+Tm5qYhQ4YoIiKiErIBAAAov4LCy3J3cy2945+U9Z6T8rwGgJtzqAJryZIlpfYJDAzUxx9/XGK7p6enZs+erdmzZ9syNAAAALtyd3NVyKT1FfoayW8OqtDxq0KRWNbxy7OwgrPnYI9C3ZlycKgCCwAAAFVHVSgSyaF0FR2/5Fw5cGMSAAAAANgIBRYAAAAA2AgFFgAAAADYCAUWAAAAANgIBRYAAAAA2AgFFgAAAADYCAUWAAAAANgIBRYAAAAA2AgFFgAAAADYCAUWAAAAANgIBRYAAAAA2AgFFgAAAADYCAUWAAAAANgIBRYAAAAA2AgFFgAAAADYCAUWAAAAANgIBRYAAAAA2AgFFgAAAADYCAUWAAAAANhIlSywFi5cqJ49eyogIEDjx49XVlZWZYcEAAAAoBqocgXWmjVr9N577yk6OlofffSRzp8/r7///e+VHRYAAACAaqDKFVj/+te/NHbsWPXt21ft27fXzJkztW3bNu3bt6+yQwMAAABQxdWo7ABsqaCgQD///LOmTJliPta0aVM1adJE6enpatOmzU2fbzKZzOOURT1P17IHWwaXLl2q0PElciiNPeKXyKE05GAd3s+lc/YceC9Yz9lz4L1QOnKwjrO/FyTHyeFqrXC1driWwVRSixP6448/1KtXL3366adq1aqV+XhoaKj69u2rp59++qbPP3/+PDNdAAAAAErVpk0b1alT57rjVWoG61Z5enqqTZs2cnNzk8FgqOxwAAAAADgYk8mkwsJCeXp63rC9ShVY9evXl4uLi7KysixmsLKzs9WgQYNSn+/i4nLDKhQAAAAArqpVq1aJbVVqkQt3d3e1a9dOaWlp5mO///67jh49qoCAgEqMDAAAAEB1UKVmsCQpLCxMM2fOVPv27eXr66uZM2eqe/fupS5wAQAAAAC3qkotcnHVwoULtXz5cp0/f1533323XnvtNfn4+FR2WAAAAACquCpZYAEAAABAZahS92ABAAAAQGWiwAIAAAAAG6HAAgAAAAAbocACAAAAABuhwEKJxo0bp08++USXLl2q7FAAoErLzMzUb7/9VtlhAABsgAILJfLx8VF0dLTuvvtuTZkyRd99911lhwQ4rEuXLunnn3+u7DCqteLiYh07dqyyw7ip06dP66mnnlJQUJDGjRunc+fO6fnnn1f//v318MMPKzQ0VKdPn67sMG9JUVGRw38fAFQd33//vYqKiio7DAss046bunTpkr788kslJycrNTVVt99+u0JCQjRo0CC1bNmyssOrFgoKCrRz50716NFDkpSYmKiCggJzu6urq5588km5u7tXVoiQ9PPPP2vIkCHau3dvZYdSovj4eD355JOqXbt2ZYdSLhcuXFBsbKw2bdqk2267TaGhoRo3bpxcXK58Vnj69Gnde++9Dv09ePHFF3X8+HE99dRTSklJ0dGjR1WjRg29+eabMplM+sc//qHmzZsrJiamskMtN2d4L1y1ZcsWffXVVzp69KgMBoOaNGmiBx54QPfcc09lhwYn8emnn+qvf/2r0/4NzsrKkre3d2WHcUvat2+v1NRUh8qjRmUHUJWNGjVKBoPhpn0MBoM++OADO0VUdjVr1lT//v3Vv39/ZWdnKyUlRcnJyUpMTFTHjh01ZMgQhYWFVXaYpSoqKtLq1atv+Id06NChqlHDcd8Ka9eu1aZNm8wF1oIFC3TnnXeqZs2akqSDBw/Kw8NDY8aMqcwwbyo7O1v5+flq0qSJ+djPP/+spKQkXbhwQX369NHgwYMrL8Bq4t1339Wjjz7qtAXWW2+9pR9++EEzZsxQdna23n//fX333XeKj4835+Tonxlu3bpV7733njp16qSuXbuqW7du+uCDD3THHXdIkp577jn94x//qOQoq4dJkybpk08+Ufv27dWyZUuZTCbt3LlTK1eu1IABAzRnzpzKDvGm+vXrp5UrV6pevXqSpA8//FAhISHy8vKq3MDK6ODBg9q3b5/at28vPz8/bdq0SUuXLlV+fr569+6t8ePHy9XVtbLDLNGkSZMsTu7vv/9+rVixwuLvnSPr2bOnRfyTJk3Syy+/7FDFSmkc8fe+455VVgHdu3cvse3UqVNat26dxUyEo2vQoIFGjx6t0aNH6/PPP9err76q2NhYhy+wioqKNHbsWKWnp6tXr1564IEHZDKZ9Ouvvyo2NlYpKSlaunSpwxZZ69at0xNPPGFx7M0331TTpk0lScnJyVq2bJlDF1gzZsxQkyZNzCeOx48fV1hYmBo3bqymTZvqlVde0cWLFzVixIhKjrRqc8Q/QmXx5Zdfas6cOerataskKSQkRBMnTtTjjz+uxYsXS1KpH2pVttzcXPOJS506dVS7dm395S9/Mbc3btzY4S8RbN++fWWHcMvWrVun//73v1qxYoW6dOli0bZ9+3ZFRERo3bp1Dv3Bz6+//qrLly+bH7/xxhvq2bOnUxVYn376qaKiolSnTh3l5eVpypQpmjt3rvr3768aNWpo2bJlMplMeu655yo71BJd+3s1JydHxcXFlRRN2V0b/1dffaUXXnjBqQosyfF+9zvmGWUVMWHChOuOnTlzRomJiVq/fr2MRqOef/75SoisfE6ePKmUlBRt2LBBv/zyiwICAjRkyJDKDqtUH374oQ4dOqRPPvnEXJRcdejQIY0aNUoffvihRo0aVUkR3tzBgwfVqlUr8+MmTZpYFINGo1EHDhyojNCslp6ertGjR5sfr127Vg0bNtS6devk6uqqZcuW6aOPPqLAsoMTJ06UunBN48aN7RRN2eTk5MjHx8f8uE6dOkpMTFRkZKQee+wxzZ49uxKjs06jRo105MgR89c4JibGIqesrCzVrVu3ssKziqenp8LDwxUYGHjD9kOHDmnatGn2DaqM1q9fr/Hjx19XXElS165d9cwzz2j9+vUOXWBdyxk/QFmwYIFefPFFjR07Vl999ZWee+45zZw5UwMHDpR05YPqf/7znw5dYMExPPLII+bLxUuyadMmO0VDgWU3586d05IlS7R8+XK1a9dOCxYsUHBwcGWHVaoLFy5o48aNSk5O1rZt2/SXv/xFAwcO1Pz58+Xn51fZ4Vnls88+07PPPntdcSVJzZo10/jx47VhwwaHLbAuXrxocfNmSkqKRfulS5cc/tOy7Oxsi0/pt27dqoceesh82cf999+vt99+u7LCs0p8fPxN20+dOmWnSG5NaGhoiW0mk0kGg8Fh751p1qyZfvrpJzVv3tx8zN3dXfPnz9c//vEPhYeHV15wVhowYIDFDFVISIhF+5dfflli4eIo/P39ZTKZdNddd92w/bbbbnP4k/2ff/5ZkydPLrG9Z8+e5llRR2UwGBzuU/uyOnTokP72t79Jkvr06SPpys/XVZ06ddLx48crJbayuPaDqz/++OO6yxod9YOra3+OnPVnauzYsapTp05lh2FGgVXBcnNztXTpUi1btkwtWrTQ22+/rXvvvbeyw7LKiy++qE2bNqlGjRp68MEH9cEHH5gvzXEmmZmZN427W7dumjt3rh0jKptmzZopIyNDbdq0uWH7Dz/8oGbNmtk5qrLx9vbWsWPH1LhxYxUUFGjXrl0WJ8MXL1506GvsJSktLa3UPs7w/vjf//1fNWjQoLLDKJcHH3xQGzZsUL9+/SyOu7q6as6cOXrllVe0Zs2aSorOOhMnTiy13dFPcMLCwpSfn19i+1/+8he9/vrrdoyo7M6dO3fT90H9+vV1/vx5O0ZUdiaTSbGxseb7cQsLC/XGG2/I09PTop8jfy8KCgpUq1Yt82M3Nze5ubmZH9eoUcPiMkhH9ecPrkwmkx577DHz+9jRP7gymUwWsz/5+fkaNWrUdX+T7Tn7Ux79+/d3qMsaKbAq0Hvvvaf3339fTZo00Zw5c3T//fdXdkhlcu7cOcXFxTn16jiSdP78+ZtecnPbbbcpNzfXjhGVzcCBAzV37lwFBQVdt3LjgQMH9Pbbb193j5aj6d27t2bOnKmJEydq8+bNql27tsU9ij/99JPDF4nLly/X4cOHtXXrVhUWFqpr165q165dZYdVJgaDQY0bN3aoP0JlERERUWKbwWBQXFyc4uLi7BiR7TnqvaB/1rdv35u2161b1+EvHy8uLr7phzouLi4Of2J/7df42tlQZ/HDDz+Y/0abTCZlZGToxIkTkq5cFuzoHL3wKI0jF+DOjGXaK1C7du1Us2ZNGY3Gm34iuWzZMjtGVf20b99e33zzTYmfVjr60s6XL19WRESEvv32W/Xs2dNciPz2229KTU1VcHCwFi5c6NAzQLm5uZo2bZr++9//ytvb27y/2lWjR49WcHDwTU+gK1tqaqqeffZZubi4qEaNGsrLy1N0dLSGDx9e2aFZrV27dvrmm2+ctsACbKVdu3b6y1/+UuI9G5cvX9Yff/zhsH8XqgprP6Rij0HcTJ8+fbRmzRrVr1+/skMxo8CqQO+8845Vl3rcaDEM2E67du1u+n1w9Ol76UqM69ev13/+8x8dPnxYJpNJzZo100MPPaSBAweWemMnbt2wYcPUoUMHTZs2Ta6urkpMTNSSJUusunTQUUyZMkVTp051qlXGgIqwdu1aq/o5+kzczWRlZen999/Xiy++WNmhVHnOvBXMqlWrNGTIEPOVSj///LNatWplvlTzwoULWrRokVMtyuYIKLBQ5X333XdW9Svphu3KVlRUpOLiYovLNP/44w+tWrVK+fn5uv/++2+6JYAzcIYTgc6dO2vdunXmGcTCwkIFBgaaZ+WcQWFhoUwmk8XP0smTJ7Vq1SpduHChSvwsAdXJL7/8ou+++041atTQQw89pPr16ysrK0sJCQlavXq1mjdvrvXr11d2mOX2xx9/aP369Q69gM21W8Fc3VPt119/1ZYtWxQYGOjQW8Fcu0lvUFCQ1q9fb14YzNGv8pFK/iDd09NTzZs31+jRo80rU9qLY363ARty1MLJWi+//LI8PDw0ffp0SdLZs2cVGhqqy5cvq2HDhvrggw80b94880pMjsqaEwFHLrAuXrxosUKRm5ub3N3ddeHCBacpsKZOnXrdz9IjjzzidD9LwK06duyYVf0cdeU3SfrPf/6jSZMmycvLS+fOnVNiYqKio6M1efJk3XXXXUpMTHTKD0zy8/P1+eefa/369UpLS1Pz5s0dusBy9q1grp1nccZ5l5JutTl//rz27Nmj2NhYFRYW6pFHHrFbTBRYFai0S9OucuRPBaqC77//3qp+3bp1q+BIymfnzp167bXXzI8//vhjubi46LPPPpOXl5fmzZunJUuWOPRJcVU4ETCZTFq8eLE8PDzMxwoLC7Vs2TKLRVQc+ZLfqvCzBNhCnz59rvv7fPXE8upxg8Ggn376ye6xWeu9995TZGSknnrqKW3cuFHPPfec3n33Xa1cufK6BZEcnclk0rfffqv169friy++0MWLFzVu3DhNmzZNLVq0qOzwbsrZt4KpCm72QfoDDzwgPz8/JSUlUWBVFSxe4Rhu9kvNGf6Qnjx50mLPsW+++Ub9+vUz30czaNAgrVy5srLCs0pVOBHo1q2bdu3aZXGsc+fOFjdfO/ry2lXhZwmwhZJWfrt06ZJWrVqljz76yGLvPkd06NAhPfzww5KurOxYo0YNTZ482Wl+p0rSvn37tHbtWqWkpKhevXrq16+f1q5dq/79+2vgwIEOX1xJzr8VTFXYT600Xbp00YwZM+z6mhRYFWjRokV66623zJcVff311+revbvFng+oeCWtPpSVlaXExER99NFH6ty5s52jst5tt92m7OxsNWnSRMXFxfrxxx/16KOPmttNJpPDLydcFU4Eli9fXtkh3LKq8LME2EKTJk0sHhcVFenf//63Fi5cKDc3N02fPl2DBg2qpOisc/HiRfP5hMFgkJubm26//fZKjqpsBg8erJEjRyopKUmtWrWq7HDKxdm3giltP7U/b6DsrE6dOmX3FQYpsCpQamqqCgoKzI8jIyMtbhxE5Th79qwWL16sFStWyN/fX4sWLXLo+7SCg4M1b948vfTSS/riiy9UXFys4OBgc/u+ffvk6+tbiRGWriqcCFQFVeFnCbCl4uJiffzxx0pISJAkPfvssxo6dKhDb3txlclk0pIlS8yXLd/okmXJsS9bfvDBB7V+/XodO3ZM/fv3V58+fVS7du3KDqtMTCbTTVfyNRgMKi4utmNEZVPafmo1a9bU4MGD7RiRbR07dkxvvvmmevbsadfXpcCqQFXhxsGq5Pz581qyZImWLVumNm3a6N1337XYi8lRRUVFaeLEiRo4cKBq166tGTNmmD9ZkqR///vfdv/FUVZV4USgKrj2ZykmJsbpfpYAW7i69cW7776rgoIChYeH63/+53/MS1M7g2svW772kmXJ8S9bnjt3rnJzc/XZZ5/pww8/1CuvvKJevXrJZDI5dFHyZyaTSffcc89N2x35+3B1o+HLly9rz549FsvMd+zY0Sm2gbnRPZXSlT04z507p65du+rvf/+7XWNimfYKdO2mnp07d9aGDRuYwbKzvLw8JSUl6YMPPpCfn58mTpyo++67r7LDKrNz587Jw8PjuqVes7Ky5OXlZZ7ed0TW3NxrMBi4b9EODh8+rP/85z+qXbu2unXrZrHRpzP8LAG28PDDD+v48eMaPny4RowYUeLPvCOvIihdeT9v3bpVhYWF6tq1q9Ub9zqqI0eOaN26dUpOTtbJkyd177336oEHHnDoyzWdfSsYSfp//+//afr06frjjz8sFntp1KiRpk+f7vDnTCXta+fl5SU/Pz+1bdvWzhFRYFWodu3a6YknnjB/av/ee+/p0Ucf5VN7O+vRo4cuXryo4cOH669//WuJ/Rx1FcGqoqqdCDij1NRUPfvss3JxcVGNGjWUl5en6OhoDR8+vLJDA+zqz79/rn7y/eeZBmfYgL6qv59/+OEHrVu3Tv/5z3+cakN3Z/Pzzz8rNDRUgwcP1mOPPWa+NzozM1PLly9XcnKy/v3vfzv03+xx48Y53JoHFFgViE/tHYM1vxQc/Q+ps6vqJwLOYtiwYerQoYOmTZsmV1dXJSYmasmSJZy8oNo5evSoVf2uXQzDkVSF93N8fHypfQoLCxUZGWmHaMrH2beCmTJligoLCzVnzpwbtk+aNEnu7u7mSwkdUWmbJVcGCiwAFa4qnAhUBZ07d9a6devUrFkzSVdOXAIDA/Xf//7XaTZLBnBFVXg/X/tB9M6dO9WxY0eLSzYd/YPom32I6wxbwfTt21dxcXElXsKYlpamV155RV988YWdI7OeI96SwyIXqPKs+YTMYDDo2WeftUM01dOBAwc0Z84c88pcY8eO1dtvv62srCynORGoCi5evGi+hEKS3Nzc5O7urgsXLvB9QLW0bt06bdy4UYcPH5Yk+fn56cEHH3Toe36uqgrv52u3v+jcubPefPNNp7pX3dm3grl2f8Rr+fn56eTJk3aMqGqgwEKVZ80sCQVWxaoKJwJVgclk0uLFi833hUo3XtGR+0JR1RUUFOiZZ57Rtm3bdPfdd+vuu++WyWTSwYMHNWXKFG3YsEELFiyQu7t7ZYdaIt7PjsnZtoK5dOnSTVfPdHNzs9hyyFE52krFFFio8qrCBrHOjhMBx3Dtss7S9Us7O/JywoCtJCQk6Pfff1dycvJ1G9xmZmYqIiJCCxYs0PPPP19JEZaO97NjcdatYCTL4uRaFy5csHM0ZeeIWxZwDxaACseCLwAcSd++fTV16lTdf//9N2zfvHmz4uLi9OWXX9o3sGrOEe6dKStn3wrGmr/PEh9WlxUFFgAAqFY6deqkL774Qo0aNbph+4kTJ9S3b9/rZohgW9feI+2M29mwFQxuhEsEAQBAteLt7a3Dhw+XWGD99ttvatCggZ2jqn6uvUfaES7tKquzZ89Kkj744AN98MEHN+zDVjDVDzNYAACgWomNjdUPP/ygpUuXXjdbcvbsWT355JPq3LmzXnnllUqKEIAzo8ACAADVyrlz5xQWFqbjx48rJCRELVq0kMFgUGZmplJSUtSoUSOtXLlSt912W2WHCgfHVjC4EQosAABQ7eTn52vx4sXX7YP1t7/9TU899ZRq165dyRHCGbCIE26EAgsAAFQrWVlZ+uijjzRmzBh5eXlZtOXm5mrZsmUaMWIE92EBKBeXyg4AAADAnhYvXqyjR49eV1xJkpeXl44dO6alS5dWQmQAqgIKLAAAUK18/fXXCg0NLbF96NCh2rRpkx0jAlCVUGABAIBq5ejRo2rcuHGJ7XfccYeOHTtmx4gAVCUUWAAAoFqpU6eOjh8/XmL74cOHVadOHTtGBKAqocACAADVyj333KNFixaV2L5o0SLdfffddowIQFXCKoIAAKBa+f333xUaGqoWLVro8ccfV/PmzSVJBw8e1AcffKCDBw9q9erVatq0aeUGCsApUWABAIBqJzMzUzNmzND3339vPmYymXTXXXdp2rRpat26dSVGB8CZUWABAIBq68yZM/r9998lSU2bNlX9+vUrOSIAzo4CCwAAAABshEUuAAAAAMBGKLAAAAAAwEYosAAAFSItLU1t27bViRMnHGIce4z7zjvvqG/fvjYb71b06dNHCQkJJT4GAFQMCiwAQLXUuXNnpaam6vbbb6/sUCycOHFCbdu2VVpamsXxhIQE9enTx+pxVq9erccff9zG0UmPP/64Jk+ebPNxAaCqoMACAJRJQUFBZYdgE+7u7mrYsKFcXKrWn8Kr358GDRrIw8OjkqMBgOqnav1VAYBqatSoUXr55Zc1d+5cBQcHq2vXrpo7d66Ki4sVHx+vu+++Wz169NDcuXMtnpebm6tp06apR48e6tSpk4YOHarU1FRz+5EjR9S2bVtt2LBB48aNU2BgoObOnWu+vO6rr75SaGioOnXqpP79++ubb765LrbMzEyFhYUpICBA/fr105YtWyzaf/31V4WHh6tz587q3LmznnnmGR06dOim+f74448KCwuT0WhUt27dNGnSJGVlZVn0SUpKUq9evRQQEKAnn3xS69ats7gk8EaXCB4+fFjPPfec7rrrLgUEBCgkJESbN2+WJOXk5OjFF1/U/fffL6PRqAcffFBLly5VWRfjTU5O1rBhw9SlSxd1795d4eHhOnjwoLn9vvvukySNHj1abdu2VZ8+ffTxxx/r7bff1tGjR9W2bVu1bdtW77zzjqQrl/7NnTtX06dPV/fu3fXoo4+aj197SeClS5c0depUBQUFqXv37nrjjTdUXFxsbr/Rc6ZOnapRo0ZJkiZPnqytW7dq7dq15jiuzrSdPn1akydPVo8ePdS5c2eNGDHCYo+pwsJCvf766+rVq5f8/f3Vs2dPRUZGlulrBwDOoEZlBwAAsI3PP/9cI0aM0MqVK7Vjxw5NnTpVP/30k+68806tWLFCP/74oyZPnqygoCDzSfzLL7+s3bt364033lDjxo314Ycf6plnntH69evVqlUr89hz5szRpEmTNG3aNEnSsWPHJEmzZs3SlClT5OfnpyVLligiIkJffPGF7rjjDvNzZ8+erRdffFF+fn5KSEhQZGSkvvrqK9122226ePGinnzySfn5+Wn58uXm/k899ZQ++eQTubu7X5fnqVOn9MQTT6h3796aNm2azp8/rxkzZmjixIlauXKlJGnjxo365z//qZdeekn33Xefdu7cqTlz5tz063fq1CmNGDFCbdq0UUJCgm6//Xbt27fPPMNVUFCgNm3aaOzYsbrtttu0c+dOTZ8+XXXr1tUjjzxi9fepoKBA48ePV6tWrZSbm6v58+fr6aefVkpKitzd3bV27VoNGTJE77zzjjp37ixXV1d5eHjo119/VXJyslavXi1JFrNTy5cv19ixY/XRRx/p8uXLJb728uXLNWbMGK1evVoZGRmaPn26fHx8NHbsWKtinzp1qn7//Xc1bNhQU6dOlSTVrVtXFy9e1OjRo9WqVSstWrRIt912mz799FONHTvW/LP0r3/9S5999pneeOMNNW3aVKdPn9bOnTut/roBgLOgwAKAKsLX11dRUVGSpBYtWuj999/XiRMntGjRIotj27Zt03333adDhw7p888/V2Jiou69915J0iuvvKIdO3Zo8eLFev31181jDx8+XIMGDTI/vlpgjRs3Tr1795YkxcTEaOvWrVq5cqXFzMSECRPUq1cvSVJUVJTWr1+v9PR03XvvvUpOTlZ2drbWrFmjBg0aSJLmzp2rPn366NNPP9XgwYOvy3PFihXy8vLS66+/bi7A3njjDQ0aNEjff/+9unXrpqVLl6p///4aM2aMJKl58+b69ddfzV+LG1mxYoUMBoMSEhLMxYufn5+5vWHDhgoPDzc/btq0qXbt2qWUlJQyFVjX9p01a5a6d++uXbt2qUuXLuavQ926ddWwYUNzPw8PD7m6ulocu6pTp06aOHFiqa/drl07Pf/885Kkli1b6tdff9X7779vdYFVp04dubm5qVatWhZxfPzxx8rNzdXcuXNVo8aVU4uIiAht3bpVH330kaZOnaqjR4+qefPmuuuuu2QwGNS4cWMZjUarXhcAnAkFFgBUEe3atbN47OPjIx8fH4tjDRs2NF9Kd+DAAUlS165dLfp07dpVP/74o8Wxkk6EO3fubP5/jRo11KlTJ2VmZlr0ad++vcXru7q6WsTQqlUrc1FxNe4WLVpo//79N3zNAwcOKDAw0GJ2q127dqpTp47279+vbt26KTMzUyEhIRbPCwwMvOF4V+3Zs0edO3cu8b6l4uJiLV68WJ988olOnDihgoICFRYWqkmTJjcd91p79+5VfHy89u7dqzNnzpiPHzt2TF26dCnTWFdZW6hc+zUICgrSwoULlZubKy8vr3K9tiTt2rVLp0+fVrdu3SyOFxQUqFatWpKuFJZjx45V3759dffdd+uee+5R7969bzhLCQDOjAILAKqIqzMHVxkMBrm5uV3X78/33NyIyWSSwWCwOFa7du1yx1VaDNe+VkkxWKM8z7H2+UuXLtXChQs1efJkdezYUZ6enkpKStLXX39t9fj5+fl64okn1KVLF82cOdM8C9S/f38VFhaWO+7yfn+uvX/MYDBcd6yoqKjUcYqLi9WqVSvFx8df13a1wGrfvr02bdqkb7/9VmlpaYqLi9Pbb7+t//3f/72l4g4AHA2LXABANXXnnXdKkrZv325xfMeOHWrdurVVY/x5pquoqEi7du2yuHerNK1bt9aBAweUnZ1tPnb69Gn99ttvJcbQunVr/fjjjxarGf788886f/68OadWrVpdNwuXnp5+01g6duyonTt36sKFCzds3759u+69914NGzZMHTp0ULNmzUpdjONamZmZys7OVmRkpHr06KFWrVopJyfHoqi5WpBeWwi7ubnd9P4qa1z7Nfjxxx91++23mwscb29vnTx50qLPTz/9VGoc/v7++v333+Xl5aVmzZpZ/Pvz/Xienp7q27evXnnlFa1Zs0aZmZn67rvvbiknAHA0FFgAUE35+fnpoYce0owZM7RlyxZlZmYqNjZW+/fv15NPPmnVGIsWLdLXX3+tzMxMTZ8+XadPnzavYmeNkJAQNWjQQJGRkdqzZ492796tyMhI3XHHHerXr98Nn/PYY48pNzdXU6ZM0b59+7R9+3ZFRUWpS5cu5ssdn3jiCX366adavny5Dh06pHXr1mndunWSSp6lGjlypIqLizV+/Hjt2LFDv//+uzZv3myeoWrRooW+++47bdu2TQcPHtTcuXNLLdqu1bhxY7m7u2v58uU6fPiwtm7dqri4OIuY6tevLw8PD6WmpurUqVPKycmRdOUeu9OnT+uHH35Qdna28vPzy/Ta0pXLE9955x0dPHhQycnJWrZsmcVeWcHBwfrss8+UmpqqX3/9VTNnzjTfb3eVr6+v9uzZo8OHDys7O1uFhYUaOHCgfH19FR4ertTUVB05ckTp6elauHChvvzyS0nS4sWLtWHDBu3fv1+///671qxZI1dXVzVv3rzMeQCAI6PAAoBqLC4uTj179lRUVJQGDRqknTt36r333rN6Fuof//iH3n77bfNzExIS1KhRI6tfv1atWlqyZInc3d312GOPadSoUfLw8NDixYtLvDfHx8dHS5cu1YkTJxQaGqpnnnlGbdq0MS9bLkl/+9vfFBUVpcTERIWEhCg5OVkTJkyQpBLHvf3227Vy5Up5enoqPDxcAwYMsFjWfvz48erWrZvGjx+vESNG6Ny5c+bly63VoEEDvfHGG/r222/Vv39/zZ49Wy+99JLFXlwuLi6Kjo7WZ599pvvvv19DhgyRJP31r3/VQw89pKefflrBwcFavHhxmV5burKc/7Fjx/TII4/otdde04gRIywKrHHjxum+++5TZGSkwsLCVKdOHT300EMWYzzxxBOqX7++Bg0apODgYO3cuVM1a9bU8uXL5e/vrylTpuihhx7ShAkTlJGRocaNG0uSvLy8lJSUpOHDh2vgwIH64osvNH/+fLVs2bLMeQCAIzOYyrqBBwCg2ktLS9Po0aP19ddfl6mgqkzx8fFavny5ed8mAAAqAotcAACqnMLCQr3//vvq1auXPDw8lJaWpiVLligsLKyyQwMAVHEUWACAKsdgMCgtLU1Lly5VXl6efH199cwzz1h9bxkAAOXFJYIAAAAAYCMscgEAAAAANkKBBQAAAAA2QoEFAAAAADZCgQUAAAAANkKBBQAAAAA28v8BRvmlbjEEH9gAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## plot attributes count\n",
    "fig, ax = plt.subplots(figsize=(14, 4))\n",
    "df_train_unzip['attributes'].value_counts().plot.bar(ax=ax)\n",
    "ax.set_xlabel('morphological attributes')\n",
    "ax.set_ylabel('counts')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f1afbcb-9d82-423a-8fb9-f2ed993cc303",
   "metadata": {},
   "source": [
    "##### **Train & Test sets**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "967d27d3-4f07-4780-b934-99cdba0f37d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "## get features & labels for training data\n",
    "X_train, y_train = df_train_unzip[['lemma', 'form']].to_numpy(), df_train_unzip['attributes'].to_numpy()\n",
    "X_test, y_test = df_train_unzip[['lemma', 'form']].to_numpy(), df_test['attributes'].to_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64aacb58-2432-464e-9d6b-0425feb317b2",
   "metadata": {},
   "source": [
    "### ■ **<a name=\"section2\">2. Simple baseline</a>** [(&#8593;)](#content)\n",
    "Now we will write a super simple baseline using 5 rules to predict morphological attributes. This baseline consists of predicting the morphological attribute of a given form and lemma using one of the five rules:\n",
    "- *Mode*: predict returns the mode of the training labels.\n",
    "- *prior*: predict returns the prior element of the training labels.\n",
    "- *stratified* : predict returns an attribute of the training labels in a uniform way.\n",
    "- *uniform*: predict returns an attribute in a uniform way from unique attributes.\n",
    "- *constant*: predict returns a constant attribute from the learning labels.\n",
    "\n",
    "#### **2.1. Simple baseline to predict morphological attributes**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1e5c0e81-2918-4462-a309-dea76166711c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleBaseline:\n",
    "    \n",
    "    \"\"\"Simple Baseline to predict the morphological attribute of a given lemma and form\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    rule: str,\n",
    "        The rule to use to predict the attribute.\n",
    "        \n",
    "    Attributes\n",
    "    ----------\n",
    "    rules: set,\n",
    "        The set of available rules.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, rule='mode'):\n",
    "        self.rule = rule\n",
    "        self.rules = {\"mode\", \"prior\", \"stratified\", \"uniform\", \"constant\"}\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        \"\"\"fit the model\"\"\"\n",
    "        self.y = y\n",
    "        \n",
    "        return self\n",
    "        \n",
    "    def predict(self, x):\n",
    "        \"\"\"predict the attribute from x\"\"\"\n",
    "        \n",
    "        if self.rule not in self.rules:\n",
    "            raise Exception(f'rule should be in {self.rules}')\n",
    "            \n",
    "        if self.rule in ['mode', 'prior']:\n",
    "            y = stats.mode(self.y)[0][0]\n",
    "            \n",
    "        elif self.rule == 'uniform':\n",
    "            y = np.random.choice(np.unique(self.y))\n",
    "            \n",
    "        elif self.rule == 'stratified':\n",
    "            size = np.random.choice(len(set(self.y)))\n",
    "            y = np.random.choice(self.y, size=size)\n",
    "            \n",
    "        elif self.rule == 'constant':\n",
    "            y = self.y[0]\n",
    "        \n",
    "        return y\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return 'SimpleBaseline'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f95a4f72-ecc6-4391-b533-7e27c186b7a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['SG', 'IND', 'COND', 'V', 'V', 'IND', 'V', '1', 'IND', '1', 'COND',\n",
       "       'PST', 'IND'], dtype=object)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## create a simple baseline\n",
    "baseline = SimpleBaseline(rule='stratified')\n",
    "\n",
    "## fir the baseline model\n",
    "baseline.fit(X_train, y_train)\n",
    "\n",
    "## test the baseline\n",
    "baseline.predict(['piga', 'amepiga'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ffdc732-db67-4566-9b6b-0a81c3576c2c",
   "metadata": {},
   "source": [
    "### ■ **<a name=\"section3\">3. Prefix-based approach</a>** [(&#8593;)](#content)\n",
    "\n",
    "This new very simple approach relies on extracting the prefix of form and lemma and use it to make preidctions. \n",
    "#### **3.1. Overview** \n",
    "Extract the prefix of each lemma from each form will allow us to see which prefix are most correlated with different attributes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f56a6964-c359-450a-9081-23a84a7951ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_prefix(lemma, form):\n",
    "    \"\"\"returns the prefix from the given lemma & form\"\"\"\n",
    "    \n",
    "    if lemma in form:\n",
    "        return form.replace(lemma, '')\n",
    "    return ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "37559021-dc97-48e2-93fb-d205681d7fc5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>lemma</th>\n",
       "      <th>form</th>\n",
       "      <th>attributes</th>\n",
       "      <th>prefix</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>V</td>\n",
       "      <td>ame</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>PRF</td>\n",
       "      <td>ame</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>FIN</td>\n",
       "      <td>ame</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>IND</td>\n",
       "      <td>ame</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>piga</td>\n",
       "      <td>amepiga</td>\n",
       "      <td>SG</td>\n",
       "      <td>ame</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  lemma     form attributes prefix\n",
       "0  piga  amepiga          V    ame\n",
       "1  piga  amepiga        PRF    ame\n",
       "2  piga  amepiga        FIN    ame\n",
       "3  piga  amepiga        IND    ame\n",
       "4  piga  amepiga         SG    ame"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## add prefix column to dataframe\n",
    "df_train_unzip['prefix'] = df_train_unzip.apply(lambda x: get_prefix(x.lemma, x.form), axis=1)\n",
    "df_train_unzip.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "35a5dc8d-df1d-4f72-ab8c-263efc7d2e83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## count number of prefix per attributes\n",
    "corr = pd.crosstab(index=df_train_unzip['prefix'], columns=df_train_unzip['attributes'])\n",
    "\n",
    "## display\n",
    "fig, ax = plt.subplots()\n",
    "sns.heatmap(corr, ax=ax, cmap='Blues')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f614d044-764d-417a-9f3f-d7528529b77b",
   "metadata": {},
   "source": [
    ">**Idea:** one can use this correlation matrix to predict the mophological attributes of a given form & lemma"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e0cedc9-e61f-4f9a-ad3c-535350b0d57a",
   "metadata": {},
   "source": [
    "#### **3.2. Prefix-based model**\n",
    "One can predict using the prefix rule given above, for instance, get the prefix from the given form and lemma, and return the attribute which is most correlated with the prefix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "54c35f53-2be2-47a3-8f7e-e44ffc13e39a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PrefixRule:\n",
    "    \"\"\"PrefixRule\"\"\"\n",
    "    \n",
    "    def __init__(self):\n",
    "        ...\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        \"\"\"to fit the model\"\"\"\n",
    "        ## get prefixes\n",
    "        prefixes = [get_prefix(lemma, form) for lemma, form in X]\n",
    "        ## unique prefixes\n",
    "        self.prefixes = set(prefixes)\n",
    "        ## compute correlation\n",
    "        df = pd.DataFrame([prefixes, y], index=['prefix', 'attribute']).T\n",
    "        self.corr = pd.crosstab(df['prefix'], df['attribute'])\n",
    "        \n",
    "        return self\n",
    "        \n",
    "    def predict(self, x):\n",
    "        ## get prefix\n",
    "        lemma, form = x\n",
    "        prefix = get_prefix(lemma, form)\n",
    "        \n",
    "        ## check that prefix is included in the list of prefix\n",
    "        if prefix not in self.prefixes:\n",
    "            raise Exception(f'prefix should be in {self.prefixes}')\n",
    "            \n",
    "        ## get attributes which are most correlated with prefix\n",
    "        max_val = self.corr.loc[prefix].max()\n",
    "        pred_attrs = self.corr.loc[prefix][self.corr.loc[prefix] == max_val].index.to_numpy()\n",
    "        \n",
    "        return pred_attrs\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return 'PrefixRule'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "37a99f50-9f48-404f-b96c-fd26f79ff287",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PrefixRule"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## create & fit the model\n",
    "prefix_rule = PrefixRule()\n",
    "prefix_rule.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "db397adf-b855-473c-b1c0-177c4e99891b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> The predicted attributes for (pea, anapea):\t 3, DEF, FIN, IND, PRS, SG, V\n",
      "> The true attributes for (pea, anapea)\t:\t V, DEF, FIN, IND, SG, 3, PRS\n"
     ]
    }
   ],
   "source": [
    "## pick random lemma & form\n",
    "lemma, form = X_train[np.random.randint(len(X_train))]\n",
    "\n",
    "## make predictions\n",
    "pred_attrs = prefix_rule.predict([lemma, form])\n",
    "\n",
    "print(f\"> The predicted attributes for ({lemma}, {form}):\\t {', '.join(pred_attrs)}\")\n",
    "\n",
    "## get true attributes\n",
    "true_attrs = df_train_unzip[(df_train_unzip['lemma'] == lemma) & (df_train_unzip['form'] == form)]['attributes']\n",
    "print(f\"> The true attributes for ({lemma}, {form})\\t:\\t {', '.join(true_attrs)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b21a8f54-dab1-4f38-8b49-fdf546304e8e",
   "metadata": {},
   "source": [
    ">**Comments:** \n",
    ">- This new model is more interesting because it can predict more than one attribute for a given lemma and form.\n",
    ">- But one of its main drawbacks is that it only takes into account prefixes that are in the training set."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc61fca1-1148-4455-8837-fd0d5a8763b5",
   "metadata": {},
   "source": [
    "### **References** \n",
    "@article{vylomova2020sigmorphon, title={SIGMORPHON 2020 Shared Task 0: Typologically Diverse Morphological Inflection}, author={Vylomova, Ekaterina and White, Jennifer and Salesky, Elizabeth and Mielke, Sabrina J and Wu, Shijie and Ponti, Edoardo and Maudslay, Rowan Hall and Zmigrod, Ran and Valvoda, Josef and Toldova, Svetlana and others}, journal={SIGMORPHON 2020}, pages={1}, year={2020} }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e60003da-2427-461a-96de-870555fa362e",
   "metadata": {},
   "source": [
    "---\n",
    "<p style=\"text-align: center;\">Copyright © 2021 Omar Ikne & Zakaria Boulkhir</p>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}