3.multi_head_attention.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "98401197-5502-4471-9814-c1d21912922b",
   "metadata": {},
   "source": [
    "# Attention intuition - Multihead attention\n",
    "\n",
    "The lecture notes on Deep Learning from [Francois Fleuret](https://fleuret.org/dlc/materials/dlc-handout-13-2-attention-mechanisms.pdf) contain a very nice intuition on why and where the attention mechanism works better than conv nets.\n",
    "\n",
    "In this example we will use the same toy sequence-to-sequence problem, but this time we will use multihead attention instead of the simple attention mechanism.\n",
    "\n",
    "\n",
    "![](images/data2_example.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1f324fd-ecee-4d11-860b-f631986709ad",
   "metadata": {},
   "source": [
    "## Dataset\n",
    "\n",
    "Follow below one example of the dataset with the input and its corresponding target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d795d803-ad0f-4266-a664-a2712a6c7213",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/tpereira/miniconda3/envs/attention-intuition/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe2c1407a30>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1m0lEQVR4nO3deXwTdfoH8M9Mjl6UchRKgQIFuUHEogiIeKJ4Hz9B3VVRQNkqyqKrIqsLrCvuqoiugqIisl54oOuBYl0BOUQBCwrIISCtUCjlaqE013x/f0xmkjRJm5kOTYqf9+tVpdNJOmmSyTPP83y/X0kIIUBEREQUJ3K8D4CIiIh+3xiMEBERUVwxGCEiIqK4YjBCREREccVghIiIiOKKwQgRERHFFYMRIiIiiisGI0RERBRX9ngfQCwURcGePXuQnp4OSZLifThEREQUAyEEKioq0Lp1a8hy9PxHgwhG9uzZg5ycnHgfBhEREZlQXFyMtm3bRv15gwhG0tPTAagPpnHjxnE+GiIiIopFeXk5cnJy9M/xaBpEMKKVZho3bsxghIiIqIGprcWCDaxEREQUVwxGiIiIKK4YjBAREVFcNYieESIiIiOEEPB6vfD5fPE+lJOazWaD3W6v87QbDEaIiOik4na7UVJSgsrKyngfyu9CamoqsrOz4XQ6Td8HgxEiIjppKIqCnTt3wmazoXXr1nA6nZws8wQRQsDtdmP//v3YuXMnOnfuXOPEZjVhMEJERCcNt9sNRVGQk5OD1NTUeB/OSS8lJQUOhwO7du2C2+1GcnKyqfthAysREZ10zF6hk3FW/K35bBEREVFcMRghIiJKAOeeey7Gjx8f78OIC/aMEBERJYAFCxbA4XDU6++cPHkyPvroI6xbt65ef291pjIjM2fORG5uLpKTk5GXl4dly5bVuP+bb76JPn366MN/brvtNhw4cMDUARMREZ2MmjVrVuuCcicrw8HI/PnzMX78eEyaNAmFhYUYPHgwhg0bhqKiooj7L1++HLfccgtGjRqFjRs34r333sPq1asxevToOh88ERElpkq3F6+t2IlXl+9EYdEhuL1KvA8p4QWXaTp06IDHH38ct99+O9LT09GuXTvMnj1b3/fXX3+FJEl45513MHDgQCQnJ6Nnz55YsmSJvs/cuXPRpEmTkN/x0Ucf6UOd586diylTpmD9+vWQJAmSJGHu3Lkn+FFGZrhMM336dIwaNUoPJmbMmIFFixZh1qxZmDZtWtj+q1atQocOHXDPPfcAAHJzc3HnnXfiX//6Vx0PnYiIEtH3Ow/i/vfWo+hgYNKxDs1T8eWfh8Bpr/9WRSEEjnviMxNrisNmep6Tp59+Gn//+9/x8MMP4/3338ef/vQnnHPOOejWrZu+z1/+8hfMmDEDPXr0wPTp03HllVdi586daN68ea33P2LECGzYsAFffPEFvvrqKwBARkaGqWOtK0PBiNvtxtq1a/HQQw+FbB86dChWrlwZ8TYDBw7EpEmTsHDhQgwbNgylpaV4//33cdlll0X9PS6XCy6XS/++vLzcyGESEVGcvLR0O574YjOEAFpnJKNbdmN8vbkUvx6oxP6jLrRpklLvx3Tc40OPRxfV++8FgE1TL0aq01x75qWXXor8/HwAwIMPPohnnnkGS5YsCQlG7r77blx33XUAgFmzZuGLL77Aq6++igceeKDW+09JSUGjRo1gt9vRqlUrU8doFUN/obKyMvh8PmRlZYVsz8rKwt69eyPeZuDAgXjzzTcxYsQIVFVVwev14sorr8S///3vqL9n2rRpmDJlipFDIyKierK/woWrX1iBoy4vWqYnoWurdFx9Whus/vUgXvpmBwDg+ry2eOSKHmic7EC3Rz5HlUeBECLOR96wnHrqqfq/JUlCq1atUFpaGrLPgAED9H/b7Xb069cPP//8c70do1VMhWvVU05CiKhpqE2bNuGee+7Bo48+iosvvhglJSX4y1/+grFjx+LVV1+NeJuJEydiwoQJ+vfl5eXIyckxc6hERGSxdcWHsfvwcQDAkeMebCs9ik9/LNF/PnFYN9w5pJP+vQT18yFesUiKw4ZNUy+O2+82q/rIGkmSoCi1995on8eyLIcFgB6Px/TxnEiGgpHMzEzYbLawLEhpaWlYtkQzbdo0DBo0CH/5y18AqJFeWloaBg8ejMceewzZ2dlht0lKSkJSUpKRQyMionqi+D/gurVKx6TLumPJlv3477rdOFzpwePX9MbwM0IvHmUp9Hb1TZIk06WSRLdq1Sqcc845AACv14u1a9fi7rvvBgC0aNECFRUVOHbsGNLS0gAgbAiv0+lMiJWNDT07TqcTeXl5KCgowDXXXKNvLygowFVXXRXxNpWVlbDbQ3+NzaZGikzZERE1PNq5u1GSHYM7t8Dgzi0wcVg3HHP7kJESPk+G7L9SV3jKt9wLL7yAzp07o3v37njmmWdw6NAh3H777QCA/v37IzU1FQ8//DDGjRuH77//Pmy0TIcOHbBz506sW7cObdu2RXp6elySAYbbmidMmIBXXnkFc+bMwc8//4w///nPKCoqwtixYwGoJZZbbrlF3/+KK67AggULMGvWLOzYsQMrVqzAPffcgzPPPBOtW7e27pEQEVG90IKK4Oq83SZHDESC9+MFqPWeeOIJ/POf/0SfPn2wbNky/Pe//0VmZiYAdd6SN954AwsXLkTv3r3x9ttvY/LkySG3v+6663DJJZfgvPPOQ4sWLfD222/H4VGY6BkZMWIEDhw4gKlTp6KkpAS9evXCwoUL0b59ewBASUlJyJwjI0eOREVFBZ5//nncd999aNKkCc4//3z885//tO5REBFRvRF6MBLbkFWJmZGYBM8R8uuvv4b9PNIsqd27d8eqVaui3ufVV1+Nq6++OmTbmDFj9H8nJSXh/fffN3qoljNVRMvPz9eHG1UXacKUcePGYdy4cWZ+FRERJRit90OOcfoMmZkRqgUXyiMiIkMCwUhs0Yi2H0MRiubkbC8mIqITRkToGamJFOfRNCejDh06nFSZJmZGiIjIEKOZEb1nhMvTUBQMRoiIyBCjDazxnmeEEh+DESIiMsR4A6u5heLo94PBCBERGaIlOGIu0/j/z8wIRcNghIiIDNGCiljzHZxnhGrDYISIiAzRYoqYe0b8nzTMjFA0DEaIiMgQsz0jjEUoGgYjRERkiGKyZ+RkmhfjRDj33HMxfvz4eB+Grj6Ph8EIEREZogUVsQ6S4aq99cftdsf7EExhMEJERIYYHk3DeUZqNXLkSCxduhTPPvssJEmCJEnYvn07Ro0ahdzcXKSkpKBr16549tlnw2539dVXY9q0aWjdujW6dOkCAFi5ciVOO+00JCcno1+/fvjoo48gSVLIYnubNm3CpZdeikaNGiErKws333wzysrKoh5PpMX7rMLp4ImIyBDFZGYkbrGIEICnMj6/25Ea0x/q2WefxdatW9GrVy9MnToVANC0aVO0bdsW7777LjIzM7Fy5UrccccdyM7OxvDhw/Xb/u9//0Pjxo1RUFAAIQQqKipwxRVX4NJLL8Vbb72FXbt2hZVbSkpKMGTIEIwZMwbTp0/H8ePH8eCDD2L48OH4+uuvIx5PixYtrPu7VMNghIiIDDHcMxLvVXs9lcDjrePzux/eAzjTat0tIyMDTqcTqampaNWqlb59ypQp+r9zc3OxcuVKvPvuuyHBSFpaGl555RU4nU4AwIsvvghJkvDyyy8jOTkZPXr0wO7duzFmzBj9NrNmzcLpp5+Oxx9/XN82Z84c5OTkYOvWrejSpUvE4zlRGIwQEZEh7BmpPy+++CJeeeUV7Nq1C8ePH4fb7cZpp50Wsk/v3r31QAQAtmzZglNPPRXJycn6tjPPPDPkNmvXrsXixYvRqFGjsN+5fft2vdxTXxiMEBGRIcZ7RrRgJE7RiCNVzVDE63eb9O677+LPf/4znn76aQwYMADp6el48skn8d1334Xsl5YWmnkRQoTNAVM9K6UoCq644gr885//DPu92dnZpo/ZLAYjRERkiPGeEfX/cUuMSFJMpZJ4czqd8Pl8+vfLli3DwIEDkZ+fr2/bvn17rffTrVs3vPnmm3C5XEhKSgIArFmzJmSf008/HR988AE6dOgAuz1yKFD9eE4kjqYhIiJDzPaMcDRNzTp06IDvvvsOv/76K8rKynDKKadgzZo1WLRoEbZu3YpHHnkEq1evrvV+brrpJiiKgjvuuAM///wzFi1ahKeeegpAIEt111134eDBg7jxxhvx/fffY8eOHfjyyy9x++236wFI9eNRFOWEPXYGI0REZIjRtWkCo2kYjNTk/vvvh81mQ48ePdCiRQtccskluPbaazFixAj0798fBw4cCMmSRNO4cWN88sknWLduHU477TRMmjQJjz76KADofSStW7fGihUr4PP5cPHFF6NXr1649957kZGRAdk/f3/14ykqKjphj51lGiIiMsVwz8iJu7A+KXTp0gXffvttyLbXXnsNr732Wsi2adOm6f+eO3duxPsaOHAg1q9fr3//5ptvwuFwoF27dvq2zp07Y8GCBYaO50RhMEJERIYo/jqNHGNuPe49I79D8+bNQ8eOHdGmTRusX79en0MkJSUl3ocWEYMRIiIyROsZiXXVXm0v9ozUn7179+LRRx/F3r17kZ2djeuvvx7/+Mc/4n1YUTEYISIiQ9gzkvgeeOABPPDAA/E+jJixgZWIiAzRQopYe0bSRCWa40j8poOnhMfMCBERhXJXAs7ok3VpGQ45llik7Bc8V3Y7pCQ3VnhWWnSAdLJhZoSIiAJK1gP/bA/8b2rUXQKTnkWIRg5sBz6dAPz4HnC4CHjjGmQoR9BYOg6H6+CJOuowLAnVHyv+1syMEBFRwN6fAJ8b2L026i5RJz3btxGYdxVwbD+w5lWoXSWBD6oTOWmWxuFwAAAqKysTduTIyaayUl0RWfvbm8FghIiIAnxu//89UXdRFAXnyOvRskoA6KEuVrNzKfDeSOD4IaB5Z8B9DKjYA6S1hPfYQdjhhYQTH4zYbDY0adIEpaWlAIDU1NSYR/2QMUIIVFZWorS0FE2aNIHNZjN9XwxGiIgoQAtCtKAkgjYVP2Ki85/ARgDlZwE+F7Cn0P/DfsAf3wec6cCuFUBmZ3ieyYNdeCGU+lnnRFvyXgtI6MRq0qSJ/jc3i8EIEREF6JmR6MFIiudw4JviVer/bUnAaTcCQx8DktLVbR2HAAAU/yBgodRPH4ckScjOzkbLli3h8UTP8FDdORyOOmVENKaCkZkzZ+LJJ59ESUkJevbsiRkzZmDw4MER9x05ciRef/31sO09evTAxo0bzfx6IiI6UfTMiDfqLkKo5ZbSlE5oefZIdSW8PjcCaZmR95dkQABC1E9mRGOz2Sz5oKQTz/Bomvnz52P8+PGYNGkSCgsLMXjwYAwbNizqAjrPPvssSkpK9K/i4mI0a9YM119/fZ0PnoiILBZDmQb+YMRlbwQMugcYOC5qIAIAQpsejSNcKArDwcj06dMxatQojB49Gt27d8eMGTOQk5ODWbNmRdw/IyMDrVq10r/WrFmDQ4cO4bbbbqvzwRMRkcViKNMEgorYPkKEfz8to0JUnaFgxO12Y+3atRg6dGjI9qFDh2Llytgms3n11Vdx4YUXon379lH3cblcKC8vD/kiIqJ6EMNoGvjLLUKKMRjRpoPnsr0UhaFgpKysDD6fD1lZWSHbs7KysHfv3lpvX1JSgs8//xyjR4+ucb9p06YhIyND/8rJyTFymEREZFZMZRp9pbyY7pKZEaqNqRlYq4/ZFkLENI577ty5aNKkCa6++uoa95s4cSKOHDmifxUXF5s5TCIiMkoLQpSaMiNqUCFiLtNoPSMMRigyQ6NpMjMzYbPZwrIgpaWlYdmS6oQQmDNnDm6++WY4nc4a901KSkJSUpKRQyMiIitoQUiNZRp/UBFzmca/H8s0FIWhzIjT6UReXh4KCgpCthcUFGDgwIE13nbp0qX45ZdfMGrUKONHSURE9SOGMo1kNBjR5hlhZoSiMDzPyIQJE3DzzTejX79+GDBgAGbPno2ioiKMHTsWgFpi2b17N+bNmxdyu1dffRX9+/dHr169rDlyIiKynl6m8aqZDDlCwKGVaWLtGZHYM0I1MxyMjBgxAgcOHMDUqVNRUlKCXr16YeHChfromJKSkrA5R44cOYIPPvgAzz77rDVHTUREJ0ZwRkTxAHJ4yVyY7RlhmYaiMDUDa35+PvLz8yP+bO7cuWHbMjIy9FX9iIgogQX3ivg8gD08GJH00TTG5hlhAytFY2o0DRERnaSCMyNR+0ZMNrAyGKEoGIwQEVFA9cxIJHoDa6zzjHDSM6oZgxEiIgoICUaiZEb06eBjC0YCGRQGIxQZgxEiIgqIpUyjj6aJtWfE/3+WaSgKBiNERBQQnBlRvJH34aRnZDEGI0REFBBDZsToaBpwNA3VgsEIEREFGCjTxNzAqu2n95oQhWIwQkREATGMppFgtGeEM7BSzRiMEBFRgBLLaBpzPSMMRigaBiNERBQQUqaJNs+IWm6RYu4ZUcs0EoMRioLBCBERBRia9IwzsJI1GIwQEVFALKNpYHChPJZpqBYMRoiISCXECRlNA67aS7VgMEJERKrqk5xFG01jdNVeTgdPtWAwQkREqurBhxKlZ0QLKuQYP0L8wYjEeUYoCgYjRESkql6WiToDq5bhiHWeEW3VXp/ZI6OTHIMRIiJSVc+MRC3TGBtNo+/HzAhFwWCEiIhUMWZG9HV42TNCFmEwQkREqliDEX9mRIq1ZwRazwiDEYqMwQgREanCyjTeiLtpQUWsa9NAXyePwQhFxmCEiIhU1UfPRJ30zNh08PrkaAxGKAoGI0REpIq5TGOsZyQwtJfBCEXGYISIiFQxjqbRG1FjnIE1MB08R9NQZAxGiIhIdYLmGdGDFmZGKAoGI0REpKoefESZgVXvGZFjXJuGq/ZSLRiMEBGRyvCkZ7aY7laA08FTzRiMEBGRKiwYsbaBlZkRiobBCBERqcJ6RqKVaYxOB8+eEaoZgxEiIlJVCz6EN3JmRDY4zwgzI1QbBiNERKSqlhlRfK7I+xmcDl4b2qs1vhJVx2CEiIhU1YIR4bWoTMMZWKkWpoKRmTNnIjc3F8nJycjLy8OyZctq3N/lcmHSpElo3749kpKS0KlTJ8yZM8fUARMR0QniL9NUCQcAQESdZ8RkAytX7aUo7EZvMH/+fIwfPx4zZ87EoEGD8NJLL2HYsGHYtGkT2rVrF/E2w4cPx759+/Dqq6/ilFNOQWlpKbzeyAswERFRnPjnFTmGZCTDE7VnxHBmROZ08FQzw8HI9OnTMWrUKIwePRoAMGPGDCxatAizZs3CtGnTwvb/4osvsHTpUuzYsQPNmjUDAHTo0KFuR01ERNbzZ0KOIwlARQ3zjGiTnhltYGXPCEVmqEzjdruxdu1aDB06NGT70KFDsXLlyoi3+fjjj9GvXz/861//Qps2bdClSxfcf//9OH78eNTf43K5UF5eHvJFREQnmD/4qBRJ/u+tyYwIqEN7mRmhaAxlRsrKyuDz+ZCVlRWyPSsrC3v37o14mx07dmD58uVITk7Ghx9+iLKyMuTn5+PgwYNR+0amTZuGKVOmGDk0IiKqK3/wUYlk//c1z8Aa69BeifOMUC1MNbBK1VZqFEKEbdMoigJJkvDmm2/izDPPxKWXXorp06dj7ty5UbMjEydOxJEjR/Sv4uJiM4dJRERG+IORY8IfjNSyNg2Mlmk4tJeiMJQZyczMhM1mC8uClJaWhmVLNNnZ2WjTpg0yMjL0bd27d4cQAr/99hs6d+4cdpukpCQkJSUZOTQiIqorrUzjz4xItZRpjE56xjINRWMoM+J0OpGXl4eCgoKQ7QUFBRg4cGDE2wwaNAh79uzB0aNH9W1bt26FLMto27atiUMmIqITQg9G1ItBKVpmxHQDK4MRisxwmWbChAl45ZVXMGfOHPz888/485//jKKiIowdOxaAWmK55ZZb9P1vuukmNG/eHLfddhs2bdqEb775Bn/5y19w++23IyUlxbpHQkREdaOXafzBiGVr07BMQzUzPLR3xIgROHDgAKZOnYqSkhL06tULCxcuRPv27QEAJSUlKCoq0vdv1KgRCgoKMG7cOPTr1w/NmzfH8OHD8dhjj1n3KIiIqO78wcdxrUyj1DIflOEyDYMRisxwMAIA+fn5yM/Pj/izuXPnhm3r1q1bWGmHiIgSjJYZ8ZdpZOFR5wapNkBBhrG1abTbS5yBlaLg2jRERAQgMP17pTaaBog4vFfvGeGqvWQRBiNERAQA+vTvWgMrgIgTnwVG00Se0iH8Bjb1fwxGKAoGI0REBABQqg3tBRAlGNEWyrPFdsd60MJghCJjMEJERAACmZEq4YQi/AFEhCZWyXDPCBtYqWYMRoiICECgZ8QDOzza+IYImRHZYM+IxEnPqBYMRoiISOXPjLhhh7uGYCSQGYm1TMN5RqhmDEaIiAgAIPw9Ix7Y4YU/0Ig0mgZaZiTGBlaZmRGqGYMRIiJSaWUaUXOZRp8vxGjPCBtYKQoGI0REpFK0zIgtqEwTnhkJ9IzEVqaR2MBKtWAwQkREAAJr0bhhh0fUXqaRY8yMSJyBlWrBYISIiFT+koy3ttE0JhfKY88IRcNghIiIAABSUJnGW2PPiL9MY7BnhCgavkKIiAhAIBhRh/ZGLtMIISAbDUZkrk1DNWMwQkREAABZG9obPJpGqR6MBK9NY7CBlfOMUBQMRoiICBACsgjMM+IRkcs0SlBmJNYGVg7tpdowGCEiopA1aEKng6+WGQH0YIQNrGQVBiNERBSSAfHABo/eMxIpM2JsoTyWaag2DEaIiCgk6LA7kqIO7Q2etyzWtWkkTgdPtWAwQkREIeWYJKczKBjxhuwWnBmJuWdEZmaEamaP9wGcTIQQeHdNMTbtKcf+oy7kNE3FXeefgsbJjngfGhFRzfwZEJewIy3ZAY87embEcM+Iv+TDzAhFw2DEQj/+dgQPfvBTyLZPfyzB9OF90L9jcwBAlceHV5fvxCktG+Hinq0AAEddXvxcUo68dk0hyzGugklEZCVtkTzYkea0wx3DaBopxmBEkrXp4JkZocgYjFiovEpNc2Y2SsKd53TEf1btQtHBStzw8ipcn9cWN/Vvj79+9BM27C4HAEwc1g3ndm2JMfPWoOhgJWb+4XRc2js7ng+BiH6v/OUYD+xolGSHN8qkZ4oAJMno2jT+zAiH9lIUDEYs5FPUN2hW4ySMOacjbuzfDo99ugnvrC7Gu2t+w7trfgMApDhsOO7xYdrnm/H0l1vh9qlv0H3lVXE7diL6ndPXpbEhLclWQwOr+dE0MlftpSjYwGohxf9Gk/0rVDZKsuOJ607FB38aiD5tMwAAfdpm4Kv7huChYd0AAG6fAv/uejBDRFTv/EGHG3akJdnhjjIDqxLUMxJrmSbQwMrMCEXGzIiFFP/7rHrfR177pvgwfxB+3luOLlnpcNhkjB3SCZ1bNsJvh45j7a5D+Hj9HvCigYjiJmgq+EZJNUx6VqcZWHmSo8gYjFjI548mbBF6UGVZQs/WGSHbLuieBQD4afeRkNsTEdW74AbWpMB08MLrRvApTQlemybWeUYkrYGVmRGKjGUaC4lqZZpYySzTEFG8hYymsekNrCJiz4ixob2BSc94jqPIGIxYyBelTFMbm39/wTcqEcWLf20aN2whPSOKxxW6m4l5RjgdPNWGwYiFfHpmxNjttBSmjxlMIoqX6mUaLRgJWygvMJrGcGaEZRqKgsGIhbTMhs1oZkQLRpgZIaJ40Yb2CjuSHTZ4tWDEW33Ss6AMR8yr9mrzjPAcR5GZCkZmzpyJ3NxcJCcnIy8vD8uWLYu675IlSyBJUtjX5s2bTR90otJ6Poz2jLBMQ0Rxp42mgQ0OmwRhU5exENWDESW4ZyS2c12ggZXnOIrMcDAyf/58jB8/HpMmTUJhYSEGDx6MYcOGoaioqMbbbdmyBSUlJfpX586dTR90otL6T40GI5xnhIjiLmiekSS7DCH7R9NYsDaNNupG5to0FIXhYGT69OkYNWoURo8eje7du2PGjBnIycnBrFmzarxdy5Yt0apVK/3LZottSFhDoigs0xBRAxXUM+KwyRCyU91eLTNiqmeEDaxUC0PBiNvtxtq1azF06NCQ7UOHDsXKlStrvG3fvn2RnZ2NCy64AIsXL65xX5fLhfLy8pCvhsBncmhvoExj+SEREcUmaG0aNRjxl2kirU1jcmivzAZWisJQMFJWVgafz4esrKyQ7VlZWdi7d2/E22RnZ2P27Nn44IMPsGDBAnTt2hUXXHABvvnmm6i/Z9q0acjIyNC/cnJyjBxm3Ch1Hk3DaISI4iQoM+K0y3rPSPh08MbnGeEMrFQbUzOwStWu/IUQYds0Xbt2RdeuXfXvBwwYgOLiYjz11FM455xzIt5m4sSJmDBhgv59eXl5gwhITJdp/O9nhakRIooXLRgRNjhsMmBzhmzXBC+UZ7RnhMEIRWMoM5KZmQmbzRaWBSktLQ3LltTkrLPOwrZt26L+PCkpCY0bNw75aghMj6bx768wM0JE8aKPprHDaZMBf5lGClubBrBJxjIj2ho2bGClaAwFI06nE3l5eSgoKAjZXlBQgIEDB8Z8P4WFhcjOzjbyqxsEfTSNwcyIxAZWIoq3amUa2CNnRkIumow2sEo8x1Fkhss0EyZMwM0334x+/fphwIABmD17NoqKijB27FgAaoll9+7dmDdvHgBgxowZ6NChA3r27Am324033ngDH3zwAT744ANrH0kCUGpYKK8mWlmHiREiipugob0OmwTJX6aRwnpGgrIbsfaMMDNCtTAcjIwYMQIHDhzA1KlTUVJSgl69emHhwoVo3749AKCkpCRkzhG32437778fu3fvRkpKCnr27InPPvsMl156qXWPIkEodRxNwzINEcWNEjqaRrL7yzTVgxHFF/gm1knP5EADa009hvT7ZaqBNT8/H/n5+RF/Nnfu3JDvH3jgATzwwANmfk2DY3ahPE56RkRxpzewqpOeaZkRuVowAsV4ZkT2TwcvQ0CImGMY+h3h2jQWMju0V29gZSxCRHGirUHjhTqaRrJFzoyI4GAEsWZG1P1kKBxPQxExGLGQ+aG9WjDCtykRxYcWjLj9DayyPQlAeGbETM+IpGVGJMHzHEXEYMRCZmdg5aRnRBRvitcFINAzIvtH09iEN2R6aBHSMxJrA2vgnMhghCJhMGIhswvlaaNv+CYlonjRVuf1+EfTyA5n4If+5lYAECYyI7K2UB4ULntBETEYsZDZMo3MMg0RxZm2Bo0iOSBJkl6mARA614iJBtbA2jSCwQhFxGDEQmbLNDLLNEQUZ1pmRJHVQZZamQZASDBSp54RsGeEImMwYiHTo2k46RkRxZsWcPhH0dj984yoPws0sQqf8Z4RrS9OgsJghCJiMGIh02UarWeE0QgRxYlWphH+NWmcdhku4Z+KKjgzElKmiXVob9A8IxYcK518GIxYSJv0zOjsgjLXpiGiePMHHEJWyzNOuwyPNi9myGJ5iv+/UszBiBzcM8IZ4SkCBiMW0temMfhXZZmGiOJOC0b8ZRqHLUow4s+MiBgnPAOCMyMs01BkDEYsFFgoz1xmhGUaIoobn3/4ri2QGfHC5v9ZcAOr2jOiGPj4kIPWpmEwQpEwGLGQ9iYzXKaROZqGiOJLUkIbWB02GW6E94wI/3nKUGZECirTWHCsdPJhMGIhrWfE8HTwEucZIaL4krRSjC3QwOoRkco0xjMjCApGeJ6jSBiMWEgrsxgd2itzBlYiijNtQTxttV5ncM9I0Po02gysRjIjgWCEM7BSZAxGLKTPM2JyBlaWaYgoXvRgxF5zz4i2aq8wUo6W2DNCNWMwYiGfyQbWQJnG8kMiIoqJXC0zEtozEpwZUU9UZss0jEUoEgYjFtLeZIang/c/C7xiIKJ40TIjsj3SPCNBmRH/aBqzZRqe5ygSBiMW0soshss0bGAlongSAjahDu2V/AvkOWxSUANrpNE0RjIj2nTwYGaEImIwYiFfHdem8XFmQiKKh6AyjJYZSbLL8Og9I97AvlpmxETPiCyJ0OnkifwYjFhI6DOwctIzImpAgjIfNkekGVgjNLCa6BkBAudJomAMRiykl2nMzsDKNykRxUNQsFF7z0jQ2jSxCjonKoqvhh3p94rBiIW0MovRYEQv0zAYIaJ48JdpFCHBHrI2jS3k50AgGIGJBlYALNNQRAxGLCRMLpSnT3rGMg0RxYM/8+GBHQ6HGoA4o0wHry27a6ZnBIA+gytRMAYjFgo0sJqb9IyxCBHFhX9Yrxt2OPxXUyHTwQfPwKpoQ3vZM0LWYTBiIcXsPCMSZ2Alojjyl2E8sCHJrn4sOGyBGVgVb3BmxPhCeSFlGsHMCIVjMGIhrczChfKIqEHxl2G8sMPuP38FN7AqnkjTwZvMjHAOA4qAwYiFtMyGwcQIZ2AlovjyByNu2OHUMyOS3jPi87r0XesyAyvA0TQUGYMRCyl1nGeEFwxEFBdamUbY9GAkeNXe0DJN3eYZkXjRRREwGLGQYnahPJllGiKKo6DRNE5/A6skSfBJEYKROpZp2DNCkTAYsZDWfypx0jMiakj0BtZAmQYAhKTOOSK84av2GivTBPYVnGeEIjAVjMycORO5ublITk5GXl4eli1bFtPtVqxYAbvdjtNOO83Mr014PpMNrNruHE1DRHERHIwETZSk+CdAU4J6RgJr0xj7+PD5P27YM0KRGA5G5s+fj/Hjx2PSpEkoLCzE4MGDMWzYMBQVFdV4uyNHjuCWW27BBRdcYPpgE51Sx4XyOOkZEcWFXqax6fOMAICiZ0YilGmMZEaC92cGmCIwHIxMnz4do0aNwujRo9G9e3fMmDEDOTk5mDVrVo23u/POO3HTTTdhwIABpg820enBiNmF8vgeJaJ40IIRUa1MI/uDkQhr0xjNjGhr2QhmRigCQ68mt9uNtWvXYujQoSHbhw4dipUrV0a93WuvvYbt27fjb3/7m7mjbCC00TBGG1hlrk1DRPEUrWfE5gz5ubrRXGZEW8uGM7BSJHYjO5eVlcHn8yErKytke1ZWFvbu3RvxNtu2bcNDDz2EZcuWwW6P7de5XC64XIEaZXl5uZHDjBvF5Kq9+qRnTI0QUTwEzTPSKHhxLVk9ZwtfhAZW05kRNrBSOFMNrNVHiwghIo4g8fl8uOmmmzBlyhR06dIl5vufNm0aMjIy9K+cnBwzh1nvAmUaY7fjpGdEFFdKIDOSFDEzEqFMY/DjQ9ufwQhFYujVlJmZCZvNFpYFKS0tDcuWAEBFRQXWrFmDu+++G3a7HXa7HVOnTsX69etht9vx9ddfR/w9EydOxJEjR/Sv4uJiI4cZN6YXygvqGWEKk4jqXVCZJriBFf7RNCGr9urBhLHznJ4Z4TwjFIGhMo3T6UReXh4KCgpwzTXX6NsLCgpw1VVXhe3fuHFj/PTTTyHbZs6cia+//hrvv/8+cnNzI/6epKQkJCUlGTm0hKDFEWbXpgHUgMRmtBRLRFQX+to0tpCeES0YkYJ7RmCugZWZEaqJoWAEACZMmICbb74Z/fr1w4ABAzB79mwUFRVh7NixANSsxu7duzFv3jzIsoxevXqF3L5ly5ZITk4O234y8JnsGQkefaMIAZvhxjAiojrQekaEHY7gqyGtTKPUcTp4AEKSAAFowQxRMMPByIgRI3DgwAFMnToVJSUl6NWrFxYuXIj27dsDAEpKSmqdc+RkFQhGjN0ueH+fIuCwWXhQRES1EF43JISPppG1zIjiDeyrTwdvtEzDzAhFZzgYAYD8/Hzk5+dH/NncuXNrvO3kyZMxefJkM7824QmTC+XZqmVGiIjqU3AwkmQLuhryZ0aCyzSSPzMCw2UarTeOwQiF49o0FqprAyvAic+IqP75ghtY7UHnL7sajMhK+DwjRhtY9XlJOOkZRcBgxEJaIFGXYITr0xBRfVM86rxObthC1qaR7epAAllEmmfEYDCiZVJYpqEIGIxYSDG5UF7w/hzaS0T1TfFqo2nsIecjyRYpM+JfKM/gx4fCGVipBgxGLOQzuVBe9QZWIqL6pAUjiuQImcDS5lAbWOXgBlYtmDA7tJfzjFAEDEYspE8HbzAakSQJ2vuf69MQUX3TVuXVFsbT6JkREd7AarhMw+ngqQYMRiykJTWMLpQXfBvGIkRU3/TMSLVgxOZQgxG78AROTnoDq9F5RuRqtycKYDBiIbOTngXfhmUaIqpv2kJ4whYajMiOoJmwtVKNMDsDKzMjFB2DEQuZXSgv+DYMRoio3vmiZUaSwvYRpucZ0XpGGIxQOAYjFlJMzjMCsExDRPGj9Yzo07/72e1B3/uzJ3rPiNF5RvRzHIMRCsdgxEKKyYXygKAyDaMRIqpvSuQGVrsjPBhBHWdglXiOowgYjFioTj0jMntGiChOtECjWs+Iw26DW/inh/eXacz3jHBoL0XHYMQiSlAQYSIxomdTOCEQEdU3SQs0qgUjTpsMj7aEmR6MaPOMmCzTsIGVImAwYpHgBe7MlWnU/7NMQ0T1zj9SRqrWM+KwBwcjoWUaozOwCq7aSzVgMGKR4CDC6KRnAIf2ElH86KvyVgtG1MyIv0yjTQlvdgZWPZPCYITCMRixSHBCw9RoGpmjaYgoPiR/A2v1zIjTLkUo02gNrEZnYOVCeRQdgxGLBGc0zMzAyswIEcWLthCeZK/eM2KDR1Qr06CuDawMRigcgxGLBJdpTMQigUnPmBohonqmBSNy9Z4RWw2ZEaMfH9qJkcEIRcBgxCLB7y8zDayBSc8YjBBR/dKDEUdNDazVR9OYy4wwGKFIGIxYJDijUbcyjWWHREQUE1moo2lke1LI9pAGVp9/xI3ZSc+08yJ7RigCBiMWCe71MFemYc8IEcWHLLSekeoNrJEyI+wZIesxGLGI0NelAaQ6rU3DYISI6pGiwOafFTVkYTxEm/TM5Gga9oxQDRiMWMRXh0XygMD7mg2sRFSvtPlDAMj28J4Rd7XRNJLJGVjBnhGqAYMRi2jVFTMTngGBpleWaYioXmkZD1RbGA+hmRHhc6kbTfeMcAZWio7BiEW0tWnMNK8CgYwKEyNEVK98gcyILUIw4vU3sCre0HlGjH58BMo0PMlROAYjFgms2Gvu9mxgJaK48AcjPiHBUX3Ss6AGVp9HzYyYHU0DcDp4io7BiEW0hfJMl2nYM0JE8eAv03hgh9NuC/mRwybBrQcjWjmnbvOMcDQNRcJgxCJKHRtYZY6mIaJ48AcjbtjhsIWev+w2GV4tGPFWz4xwNA1Zh8GIRbTqipnZV4HgMo1VR0REFAN/mcYLG5z28I8En1QtM2K2TKPtzwsuisAe7wM4WQR6RiT1zbZ8OuA6ClzwqHoF4fMCmz8B3MfUG7TuC2T11G+vNb4qfKPSyWbrl8DeHwHPcaBRFnDG6MBiTBR/wWUaW/jzosjaaBptaK8WjNjC9q1JYNVen8kDpZMZgxGLhDSwFv4H+N9U9QfZfYCeVwNLHgeWPR16o1MuAk6/BWjUEplKKQAbgxFKfBX71Ndy10uATuer2w4XA65yoGWP0PT9zm+At64Pvb2rHDjn/vo7XqqZP8hQe0YiBCOSAxCA4m9gDazaa7RMw8wIRcdgxCLa+6szioCFDwd+8PVjQKvewMp/q9/nnqPuvGsF8EuB+gXgWUg4IE+ET+lTz0dOZNDGBcD3L6lffW9W0/br31b/3/p0YNA9QPerAOEDPvMHHe0GAI3bABveBxY/DnQ4G0hpBhTOA7pdAbTrH9/H9Hum9YwIOxwRMyMOwAco/v20Sc8kw2Ua9oxQdKZypTNnzkRubi6Sk5ORl5eHZcuWRd13+fLlGDRoEJo3b46UlBR069YNzzzzjOkDTlQ+IeCEB495pwPe40DuEPVke2AbMPdy9Q3f8Vzglo+BkZ8C49aq6ersPoAzHTIEukrF4MheSnhaqRFQs4Dr3lQ/YGQHsOcH4L2RwBvXqtnBsi1AaiZw49vAda8AvYerQcqbw4GZ/dUgfcnjcXsoBH0G1hozIwAUb91W7QVH01ANDGdG5s+fj/Hjx2PmzJkYNGgQXnrpJQwbNgybNm1Cu3btwvZPS0vD3XffjVNPPRVpaWlYvnw57rzzTqSlpeGOO+6w5EEkAp8i0Ff6BbmiGEhuAlz3KvDjO8CXfwUq9qj11YunBa4OmnUELvOXbRbcAfw4HzYo+uRpRAlLq/m3G+DvA2kJDHkQaNIeWP0ysOI5YMdi9QsALpoKpDRV/335dGD3WuDg9sD9uSvr9/gpVMjQ3gjBiM0BeAFowQjqNgOrxGCEIjCcGZk+fTpGjRqF0aNHo3v37pgxYwZycnIwa9asiPv37dsXN954I3r27IkOHTrgj3/8Iy6++OIasykNkRACyZL/zdqkHdCohZr5SG+tbut3O5DVI/KNZfXKwwEf5xmhxKetZdLqVODOpcAf3gPa9lNf8+c9DIxdpjZoA2rA0ufGwG2T0oE/vg8MGg+c91f//Xnr9fCpmuCekQhlGuE/P4U3sLJMQ9Yx9Gpyu91Yu3Ythg4dGrJ96NChWLlyZUz3UVhYiJUrV2LIkCFR93G5XCgvLw/5SnQ+RcAO/0nV330ORwow/HVg4D3qqJpoZLUr3QYfG1gp8WnTh8tREquZnYFRBcAfP1ADleojZ5p1BC6aArQ5Xf0+aKE2igM9MxJ5aG8gGAntGTE76RmDEYrEUJmmrKwMPp8PWVlZIduzsrKwd+/eGm/btm1b7N+/H16vF5MnT8bo0aOj7jtt2jRMmTLFyKHFnSIAu5a+tAVNqZxzpvpVE//+DsnHMg0lPi2TYavh9GFzAKdcWPP9aMGMj5mRuNIyI1EaWPXzWfUyjdHh2RxNQzUw1cAqVRvSJYQI21bdsmXLsGbNGrz44ouYMWMG3n777aj7Tpw4EUeOHNG/iouLzRxmvVKEgB3+WrrsqHnn6vwnZRt8XJuGEp9SLQNolvYhxzJNfNXSMyJk/+J5epnG3GiawFBgzjNC4QydTTIzM2Gz2cKyIKWlpWHZkupyc3MBAL1798a+ffswefJk3HjjjRH3TUpKQlJSkpFDi7vQMo2xyYC0k7odPo6mocSnByMGg+7qtGCGZZq4Ej4PJETvGQkEjf4yDcxNB8/MCNXEUGjrdDqRl5eHgoKCkO0FBQUYOHBgzPcjhIDL5ap9xwZEzYxEKNPEwn9SdrBnhBqC2npGYqUHI7xSjifFv+aMG7YagxFJe97NzsCqBSMKe0YonOGzyYQJE3DzzTejX79+GDBgAGbPno2ioiKMHTsWgFpi2b17N+bNmwcAeOGFF9CuXTt069YNgDrvyFNPPYVx48ZZ+DDiTxECdslkmcb/ZrfBBxdTI5TotOChpp6RWOg9I8yMxJPX7YYN0cs0sPnLNEr10TRG1+HS7pvnOApn+GwyYsQIHDhwAFOnTkVJSQl69eqFhQsXon379gCAkpISFBUV6fsrioKJEydi586dsNvt6NSpE5544gnceeed1j2KBKAogMN0mSYwtPc436eU6BSLMiPsGUkIWmbEG2HVXgCQ/MGIlhmRoPWMGDzPcWgv1cDU2SQ/Px/5+fkRfzZ37tyQ78eNG3fSZUEi8QkBm+kyDYf2UgNiWc+IFowwMxJPPv+aMx7YYI9QptGCETksM2L0N3HSM4qOS2daRIk0z0isgob2cjQNJTy9Z8TglXF12u05tDeutGnefVLk4FKy+3tGlNDMiNGeEWZGqCYMRiwSMs9IHYb2MjNCCU/vGaljZoRlmoTg86pBhhLlvCXbQzMj2jwjtU3nUB1X7aWaMBixiC94nhGjjX3+k4AdnPSMGgC9Z4RDe08Gwp8ZUaJmRvzBiFCDxsAMrEYzI9rHDTMjFI7BiEUURcAhmSzT+NPVdihcm4YSn1WTnmnBjFA43DOOtDJNrJkRbZ4RSTY7zwifawrHYMQiSnADq8mhvXZ4OekZJT6tZ6TOQ3uDrqxZqokb4R9NI6IEl7JdnYDSJqo3sJrrGWEDK0XCYMQiPkXAAZO19OBJzxiNUKKzejr44PukeqctgKdo075XY3NoZZrqDaycgZWsw2DEIkKgDtPBByY942gaSnhWD+0F2DcSR8LfwCpqKdPY9J4RrUxjrmeEmRGKhMGIRXx1KtP4MyMS16ahBsDq6eABDu+NJ//zKaJkdG0OrUzjBYQImvTM6EJ57Bmh6BiMWEQt05htYNWG9ioc2kuJz7Lp4OVA6p5lmrjRyjSIUqax+3tGZAhA8QUtlGfw44OjaagGDEYsIkJmYDU7tNfLMg0lPqumgw++D5Zp4kcLRqJlRpzO0H21CybZ2MeHpJdpeI6jcAxGLOJTBBxmF8rzn5DtzIxQQ2BVz0jwfTAzEjfazKpRgxF/mQYA4HObL9Po88czM0LhGIxYRAlpYDU6HbwWjHAGVmoArOoZCb4P9ozETy2ZEbs9ODPiCZpnxFyZhg2sFAmDEYsoQgSmgzc5tFedgdXiAyOymlU9I8H3wcxI3AQyI5F7RpwOGzzCP3JG8UDWZ2A12TPCYIQiYDBiEZ8SNB284QbWwHTwnIGVEp6lPSNcuTfeJH+mS7JHCUZsMjzaAu8+dyAzYjQY8WdSDC/2S78LDEYsUqcyjZYZkTjpGTUAlvaMaB9yDEbiRZ/mPVowYpfhgbbCsicw6ZnRBlZw1V6KjsGIRepUpmHPCDUkPotmYAWCyjS+ut8XmaKVaaQoZRqHTYY7ODOiTXpmcDp4zjNCNWEwYhG1TGM2MxJcprH4wIispmVGrOgZ4dDeuNOmeZej9YzYZXhDyjTmekb0ob0cTUMRMBixiCIE7JI2A6vJMg3XpqGGQO8Z4dDek4FepnFEz4zoDaw+rx5MyKZH0/AcR+EYjFhECW5gZZmGTmZWLZQXfB/sGYkbm//5tEXpGUmyhzawyiYzIxxNQzVhMGIRSxpYuVAeJTpFCXyYGA26I2HPSNzJ/gXwZHtSxJ+H94z4Jz0zmhmRWaah6BiMWMQX3MBqeAbWQM8IMyOU0IJ7O4yu2hoJe0bizubvGYmWGXEGZUYUb/DQXoODdPXMCM9xFI7BiEVCyzRmh/Yq7BmhxBbc22FlzwjLNHGjByPOaJkRCV7/0F6vx6WXaYyOpmEDK9WEwYhFFFGHVXuDgxc28lEiCw4aLB3ay9d9XCg+fYHPaGWa4MyILzgzIhvNjKj7s4GVImEwYhGfgsCqvSYXygPAkzIltuDeDktX7eXrPi6Cgkt7tNE0sgy3UJ8nr9sVNLTXYJnOvz8zIxQJgxGLqEN7zZZpAsGLNuafKCFpvR2SbHgGzog4tDe+tEXyANiiBCOyLMEnBXpGZLML5ckcTUPRMRixiDoDq8m1aYJHJfCkTInMyqngAQ7tjbeg843DGTkYAQCvpD7fPo/L9GiaQM8IyzQUjsGIRUIXyjN4og4ary/5OMSREpjPwkXyAPaMxJs/M+IVMhz26OctxZ8Z8XkCM7AaXigP2qRnzIxQOAYjFlEEzDewShIU/5WHxDINJTLFZCkyGvaMxJc/GPHADqc9+seBT8uMBJVpZINDuyXOM0I1YDBiEUURgQZWEydqob2xBTMjlMAUizMjHNobX/6/uwd2OG01BCP+51t43UAdZ2CVWKWhCBiMWMQnBBxmyzQAhP/NLnPyJ0pkVveMsEwTX3pmxAZHDZkRLXOrNrCanIFVD16YGaFwpoKRmTNnIjc3F8nJycjLy8OyZcui7rtgwQJcdNFFaNGiBRo3bowBAwZg0aJFpg84UakNrObX7BD+mqzEabEpkVndM8IyTXwFl2lqyIwoshaMuMwHI1qZhvOMUASGg5H58+dj/PjxmDRpEgoLCzF48GAMGzYMRUVFEff/5ptvcNFFF2HhwoVYu3YtzjvvPFxxxRUoLCys88EnEuHzwablH02s2aFlRiSelCmRWd4zwqG9ceVT/+4eUXPPiAgq00hme0bgn/SMmRGKwHAwMn36dIwaNQqjR49G9+7dMWPGDOTk5GDWrFkR958xYwYeeOABnHHGGejcuTMef/xxdO7cGZ988kmdDz6hiLpNBqVlRrRFq4gSkt4zwqG9JwV/ZsQda2bE5wlatdfYDKxsYKWaGApG3G431q5di6FDh4ZsHzp0KFauXBnTfSiKgoqKCjRr1izqPi6XC+Xl5SFfiU6ErNlhpoGVwQg1ABzae3KJcTSNkNU5SNTMiLm1aQINrCzTUDhDwUhZWRl8Ph+ysrJCtmdlZWHv3r0x3cfTTz+NY8eOYfjw4VH3mTZtGjIyMvSvnJwcI4cZF1LwlZ2pMo1/qmSelCmRaa9PDu09KYjgBtYaMiNCO6f5gof2muwZYWaEIjDVwFp96WghREzLSb/99tuYPHky5s+fj5YtW0bdb+LEiThy5Ij+VVxcbOYw65Uk6pYZ0dLeEof2UiJTzDdpR8ShvXHl9bjU/9eSGdGeJ+ELHk1jctVeZkYoAkNnlMzMTNhstrAsSGlpaVi2pLr58+dj1KhReO+993DhhRfWuG9SUhKSkiKvIJmw/DOnCkiG36RAoExjA68QKYFZPrSXDazx5PO44UDtPSP68+QN9IzIBucZ0YIRmZkRisDQq8npdCIvLw8FBQUh2wsKCjBw4MCot3v77bcxcuRIvPXWW7jsssvMHWmC0xa4U8xeMXI0DTUElg/t9QfunF8nLrwef5lG2GrOjNj8PSM+T2BtGdPzjDAzQuEMn1EmTJiAm2++Gf369cOAAQMwe/ZsFBUVYezYsQDUEsvu3bsxb948AGogcsstt+DZZ5/FWWedpWdVUlJSkJGRYeFDiS8tiNBGxRgl/FeaNpZpKJFZ3jOiZUb4uo8HJahMY5NrKLX7g5HgnhHjC+WpgSczIxSJ4TPKiBEjcODAAUydOhUlJSXo1asXFi5ciPbt2wMASkpKQuYceemll+D1enHXXXfhrrvu0rffeuutmDt3bt0fQaLwn6QVk8GIdoXInhFKaJb3jHBobzzpPSO1ld38ZRpJCSrTGF6bxj/PCHtGKAJTZ5T8/Hzk5+dH/Fn1AGPJkiVmfkWDow3JFabLNI6Q+yFKSCesZ4TBSDwoXrVM46vlIkqyq5kRKaiB1XDPiHbBxcwIRcC1aayil2mMN68C0K8QGYxQQjthPSPMCMaDz58ZqS2jKwdlRvRgoqayTiSSNgMrMyMUjsGIRWQtGDF7xWhjMEINwInqGWGZJi60zIi2EF40kl0d3SgHlWmML5SnlaKZGaFwDEYsopdp6pgZsTEYoUR2onpGOIosLhSvmhnx1XIRJWtlGuGtQ8+INukZMyMUjsGIVRSrekZ41UAJjD0jJxXF65+SoNbMiBqM2BQ3ZMlkMCIxGKHoGIxYJNDAarZMow3t5RUiJTDLe0a0zAh7RuJBmw5eiTEzYgsKGiXDDawMRig6BiMWCQQjZss0HNpLDcCJWpuGPSNxIbyxBSM2fzBiF259m/F5RvwzsDL7SxEwGLGI5L+yM5sZkfyZETung6dExjLNSUULRmpb3NPmUBtY7aIumRGOpqHoGIxYpO7zjGijaZgZoQR2wob2MgiPC//zWdtFlJYZcQQFIzC8Ng3nGaHoGIxYRC+vmJyBVcuMcKE8SmgnbGgvX/fxoPWMCG269yhsTjUz4kSgTGM0GNHWspGZGaEIGIxYxOa/YhBmT9L6qr0KBKdLpkTFob0nFz3TVVtmxF+mQVDm1mAwInM0DdWAwYhFJG0UTB0zIw744FP4ZqUExZ6Rk4tP6xmpOTPicEb4uenRNCzTUDgGIxaRtaGJtTSCRSP5Myp2eOFjZoQSFYf2nlQkLQisrUzjb2ANvbHRMo22ai/PbxSOwYhFbEIbTVPXnhEFjEUoYXFo70lF0v7u9povouzOugcjErTRNMyMUDgGIxbR15SpYzDigJdlGkpcVveMsEwTX4pappFqKbs5rQhGtMwIr7YoAgYjFtGDEZNXjFqZxgaFZRpKXFb3jLCBNa5kfxCoTfcejT1imcbYqr3a9PFsYKVIGIxYRB+SW8dJzxySD5ygkBLWieoZ4dDeuJD8QWBtwYjTYYdXBD4uFEiGgxFtf5llGoqAwYhF9GWxzZZp9KG9PmZGKHGdqJ4RZkbiQs+M1NLA6rTL8CDwnCswGIiAa9NQzRiMWMTuL9NIJkfTaAtRcWgvJTT2jJxUtGBEri0zYgsNRoSJjw6Jo2moBgxGLBJoYK3bQnk2+DjpGSUuy3tG/PcjFEBh+r6+yf7JGiMO3Q3itMlw1zEzIuvBCJ9nCsdgxCIy6jbPiHZStrNMQ4nsRK1NA7BUEwc2PTNSy2gae/XMiIkyjdEeE/pdYTBiEb1MY/aKUdYmPfOBVRpKWFb3jAQH7yzV1Dub/7wl15YZscvwikDgaCYYCaxNw8wIhWMwYhF9tV2zV4y2QGZEYTRCiepErU0TfN9Ub7Tycm09IzZZqnMDq8yeEaoBgxGL2PxlGrMNrNpJ2SGxgZUSWIwLq8Us+H44vLfe2f09IxHnEanGK9WtgVVbKE+GYF8chWEwYhF9npE6BiM2+KDwjUqJyvKhvTKgXWUzM1LvtDKNzVFzZgQIDUbMZEYgBRbK4/UWVcdgxCLa2jSS2ZN00Kq9DEYoYVldpgE4vDeO7P6LqJgyIwhcaJnpGZHlQGaE5ziqjsGIRawq09jgg4/9XZSorB7aC3Dis3hRfLD5m0ljCUaUOpZpJBuDEYqOwYgFFEXAAW00jckrxpDRNHyjUoKyemgvEAhs2DNSv3xu/Z+xlGl8dSzT6JOeSQKCdRqqhsGIBRQh9CsMqZbx+lHpwYjCBlZKXIo2n46VZRotM8IyTb3yBf7ejkir8lbfPSgbJgyu2AsAUtDHDRtYqToGIxbwCQGHNumZ2fS1PrTXy8wIJS7lRGRGWKaJi6BgJJYyjU+qa89IYJ4SRQtqifwYjFhAUQKNYLK9rmUadppTAjshPSNamYaZkXrlL9N4hA1JjtrPW4ocXKYxszZN0Kq/DEaoGgYjFggu08i1rH4ZlRaMcJ4RSmQnpGfEf8XMD6j6pQUjsMNpr/2jQNQ5MxJcpmGXPoUyFYzMnDkTubm5SE5ORl5eHpYtWxZ135KSEtx0003o2rUrZFnG+PHjzR5rwgop05itpeuZEZZpKIGdkJ4RDu2NC39g6YUNDlvtHwVKSM+ImQbWoGCEQwapGsPByPz58zF+/HhMmjQJhYWFGDx4MIYNG4aioqKI+7tcLrRo0QKTJk1Cnz596nzAiUhRBGySepKWzQ7t1XtGFE4HT4mLPSMnDeFzAQDcMWZGQoIRMzOwsmeEamD4FTV9+nSMGjUKo0ePRvfu3TFjxgzk5ORg1qxZEffv0KEDnn32Wdxyyy3IyMio8wEnIkVAz4yYDkaChvZy1V5KWFZPBx98X+wZqVdej/r39sAeU2ZEBJ3bzK1NE5QZUZgZoVCGghG32421a9di6NChIduHDh2KlStXWnZQLpcL5eXlIV+JzKcIvYHV9AyswfOM8H1KiUgIoK4LQkZiY2YkHjzuKvX/woakGDIjkAP9cKYmPZODV/3lBReFMvSKKisrg8/nQ1ZWVsj2rKws7N2717KDmjZtGjIyMvSvnJwcy+77RBBCwK7NM1LnMg0nPaMEFRwsWNkzwjJNXPg8apkm9sxI0AysJnpGIHE0DUVnqoFVqvZCFEKEbauLiRMn4siRI/pXcXGxZfd9IviEgL2u84yErNrL1AgloOBgoVpmZPHmUsxash2HjrlhGMs0ceENCkZscgznb1vdMiPBwQjLNFSdocubzMxM2Gy2sCxIaWlpWLakLpKSkpCUVPskPIkiuExjOn0ddDvBabEpEQUFC0dcQIb/Lbr3SBXu/M9auH0KZi75BbcMaA+bLONIpRt5HZrhkp6tam6Q1If28nVfn7xuNRjxSjFeQMl1G9qLoAtWwcwIVWPok9PpdCIvLw8FBQW45ppr9O0FBQW46qqrLD+4hkII6GUa1LGBFeAblRJUULDQ9/ElGDmoEx69ogdmf7MDbp8CuyyhosqLFxZv1/d7/dtdyGzkRP+OzZHqsKF5oySc1bEZ2jdPw8fr9uDzDSWYY/OhdbX7pxPP61GzWD7JVsuefvagzIiJ6eABQBES16ahiAxfxk+YMAE333wz+vXrhwEDBmD27NkoKirC2LFjAagllt27d2PevHn6bdatWwcAOHr0KPbv349169bB6XSiR48e1jyKOPMpAklSHRv7gjvVvSZS3UQnWlCwoEDCnBU70bVVI7z1/S4AwCu39sOhSje+3rwfjZPV4aILfyrBvnIXPvuxRL/ti0u3h9ztnsYeBiNx4POfZ7yI8QIqpExjriyvQPKv2ssLLgpl+JNzxIgROHDgAKZOnYqSkhL06tULCxcuRPv27QGok5xVn3Okb9+++r/Xrl2Lt956C+3bt8evv/5at6NPEEpIz0jdyzSc/IkSkj9YUFdvVT+MHvzgJwBAn5wmGNKlBSRJwjV92+o3efjS7li6ZT+KDlaiyuvDr2XHsOKXA9h9+Dg6ZqZhR9kxuBT/VTZ7RuqV4u8ZCV6NtybB0xbUJRhR/8GeEQpl6pMzPz8f+fn5EX82d+7csG0n+wqNIcGIFWUa9oxQIvIHCz6Ep/XHnXdKxCZ2h03GhT1C+8mEEHB5FfxSehSX/3s5qnz+YISZkXrl08o0MTbdSxaUadTGVx8bWCkM16axgE9B3TMjkgSv/yQveIVIiUjLjPivYW4Z0B7pyXac2aEZLujeMua7kSQJyQ4b0pPV+6lStKtlBiP1SfFqmZEYgxGLyjQAoDAYoWosnCzg98uSMg0ABTaoVw08KVMC8r8uvf5rmLz2TfHQsG5w2GRTQ/vTk9UPwSpFhvrSZxBen7TeNMVMZsTkdaw2P4lgzwhVw2DEAurQ3jqWaeCv3Qo3T8qUmPRgRM3gNU5xINVp/hSiZUZ8gkN740ELRkSsPSP2wHQLpkfT+IMYZkaoOpZpLKAoChx1HU2DwBA7ZkYoIfm0tUz8wUhy3dancdhkJDtkPbhhMFK/FK/6fMaaGbHZ697Aqt1OYmaEqmEwYoGQqY3rEoz4T8oSMyOUiPyvc49QTxsZKXVPrKYnOxiMxIm2am+swYi1mZGTe1ADGcdgxALaFQaAOpVpFC0z4uNVAyUg/5Bzj38obnodMyPqfdgDwQiD8PrlP2+JWIMRhzPou7plRtgzQtUxGLGCL2iSsro0sPprt4LzjFAi8gWWnAfqXqYBgPSkoGCEr/t6pfjPW7EGIzaHFZkRfzDiY88IhWIwYgEleF4QswvlIdAzIvGkTIkoaDSNwyYh2VH300domYZXy/VKa2C1OWvZUWUPDkZMZ0Zk//8ZjFAoBiMWCJkXRI5xnYcI9MwIJz2jRBQ0mqZxssOSlbrTk+16QyzLNPVM8Wd0Y86MBDew1jEzwp4RqobBiBWChzzW4QStBSNMV1NC0ic9C0xYVlfpyXYO7Y0TrVFexNjnZregTMOeEYqGwYgFtAZWb4Rpsg3djzaahulqSkRBQ3sbp9S9XwSoXqZhEF6ftIyuZCIYMXvRpY2m4XTwVB2DESv4T6JKHYMRHzMjlMi0DKCwW9K8CmijabS1aRiE1yd9CoEYe0YczmT933WfgZXBCIViMGIB7QrDG+NMhlHvR+akZ5TAghpYrSvTOODVJoJmz0i9krSekRiDEZuz7gvlQe8ZYTBCoRiMWEBrOPXVcXZ9rWdEZjBCiahaA6sVQjMjDEbqkzZqL3jNmZo4HNYtlAcGI1QNgxEraGUa01cL/ruRtFEFTFdTAvIFeqMaWzD7KgA0TrYHMiMs09Qr2X/eku2xBZZOZ0rgG9MNrP6eEZZpqBoGIxbQMiPeOmdG/CcFwStESkAnJDPi4NDeONEzI7H2jCQFl2nqOAMrA0+qhsGIBbSeEV9de0b0Sc9YpqEEdMKG9mplGr7u65NWDg6d5j06Z/BoGrPzjEhaZoTzjFAoBiNW8Ef5epnF7N34p5JnMEIJyf+6tH5oL0eRxYMstMxIUi17quwOB7z+wLGu84ywJEfVMRixgp4ZqWMwwqG9lMi01/kJamDlzMP1y6b3jMSWGQECcymZD0bYM0KRMRixgkXzjGhDeyXOTkiJSFu1V1hbptE+4HxeBuH1yebPjMiO2DIjAODxXzCZnWda7zVhMELVMBixgD60t849I+rVpsQrREpE/tS6D7JlZZokuw2wqe8bxeuuZW+ykk2o5xlbjKNpAMALdV9mRshqDEYsIOlDey1qYBUMRigB6dPB2y0LRoBAY6TCILxeaZkRu4HMiN7fU9e1aTjPCFXDYMQK/sY+qxpYOekZJSKvV+sZkdHYojINADidWjDCMk19svnLwTYjwYi2srjp6eD9t2MpmqphMGIFPRip63Tw/tszM0IJyO12AVCvjtOc1gUjSf75KwSDkXpl92dGjAQjeim6rvOMcGgvVcNgxAJamabuPSMc2kuJy+32f3jZ7ZBlsy2M4Zzamics09QrO/w9IzHOMwIEZUZMlmn0VXsZjFA1DEYsoDWwijqWaeAfTSMzhUkJyONRMyM2A0NBY5HsL9Nwgcj6pQUjdqeRzIjWK2Tyo0PiDKwUGYMRC2iZjDpnRmT/aBrOM0IJyOPRMiMWByNJ6ochX/f1SAg4/MGIw1CZxprRNGBmhKphMGIBLRipa2ZE6JkRXiFS4vF61KG3dod1I2kAIDlZC0b4uq83ig8y1IDA4Yw9uNSa7M33jLCBlSJjMGIFixpY4b/qYJmGEpE2KZnDQI9BLFK0zAiD8PoTlIVyOJNjvpk2F5Lpob36nGfMjFAoBiNW0OYZket2xShsWpmGJ2WrlRw5jioPg7y68PknJbM8GElRPww5pD2gvMqDI8dPXNlKeF36v830jJge2svMCEVh6hU1c+ZM5ObmIjk5GXl5eVi2bFmN+y9duhR5eXlITk5Gx44d8eKLL5o62ESllVXqXKaRAg2sv5RW4JP1e/DWd0X438/72H1eB19sKMGgJ77GmHlrrP87el3ArpV6DVwIgfmri/DFhr2x3d5dCRzadWJr6N/NBt67Dag6Uqe70TMjBtL6sUj1l2lqzQgqPvXvnSiEANzHrLs/TxXw/ctYt3oF+v/jfxg245uYApIqjw9b91UYem1rw7SBwDwvsdAumMxmRvTyjoFjPe72YdzbhXjkow3w+MInSzvm8kKpp0xLeZUHx93xC6SiPc7Fm0tx7zuF2LSnXH2PBP19C4sO4dXlOyP+7RKJ4VfU/PnzMX78eEyaNAmFhYUYPHgwhg0bhqKiooj779y5E5deeikGDx6MwsJCPPzww7jnnnvwwQcf1Png40EIgdLyKlRUBZ0ktFV75TqWafzTYh86egwXPfMNxr1diIc//AmjXl+DcW8X6m+CI8c98EV6UVbsA4q/r5cVMT0+BR+v34Pdh4+rGw7tAj79M/Cfa4BDvwbeNJ4qSz9o95VX4bdDlepjLN9T886uCpR+8yqee28RFAEs21aGJVv3B37s9f+dqspr/8WKgs17yzH+nUJM/3JL4I394VjgtWHAqpkAgDdW7cKDH/yEsW+sxec/lYTdzXG3T/3blG0DPrsPeLor8OypwLN9gEWTgIM7wn/3dy8BswYBZb/Ufpw+D7DxI+Boqfp92S8QXzwEbFwAZfETtd++Boo/GEmyPBhRMyM2BL1uS38GPh4H7Fiifr97rfo3eq4vcOhXfbf9Fa7I74UNCyBeuUi9n2qOHPdgX3lVTMf26Y97cOH0pfh0/W5g17fqewwAFAV4/zbg8TbAa5cBa18Hjh+O6T6j+vwvwML70eXTa5DnW4c9R6rwwuLQ57y8yoNnCrZi5fYyAOpreOILb+DH52/C5ieGwP38QGDJE7W+pr3+kVFuYYPTHvtFlJ79rXMDa+znqMkfb8Qn6/fgP6t24S/vrQ/5QF5XfBh9/16AsW+sjSkgWby5FJ/+uMfURcmmPeU4+4n/4czHC/Dc/7aFfgbEQgj19WPy/LzylzL0/XsBHnz/R/384/Up+NcXm3Hb3NX477o9+OfsOVCmtQNeHAxsX4zig5W45dXv8fdPN+HFJdv1+6r+nhFC4Kff6naxUleGPz2nT5+OUaNGYfTo0QCAGTNmYNGiRZg1axamTZsWtv+LL76Idu3aYcaMGQCA7t27Y82aNXjqqadw3XXX1e3o62jet79i5S8H0LddE5zevil6ZyUjeV8hDm//Dr/+9C1cHg+6DRuLjJ4Xo7TiOGZ8uByLi7woOSbgtMu4qk9rjBzUAZlHtwIAvHLsVxgR+YOZLN8+tMF+NM/pjGapDizbVoZPf9wDT/EP6OXdiBbHd6DQfioOdLgSV57aEldUzIf0wzzgSDEAoCpvLEbvuxZur4KLkzYgJ80LpftV6JadgQ6ZaVF//aFjbvxQdAhnd85Ekt2G424f5qzYieZpTgzvl6PPLSEqD+Hz/zyDVru/wGHZh+bZzZC87we9d6b8xaEYcfQB3NlyA64sfxNyu7OAG96C25aGV5bvwPriw/jrZT2Q0yw19AB8HqD4O2Djh8D+LUCn84DuV+K3beuwr/Bz7DzsxedHT0Fz+RgmN/sSqeU74D3tVrzWJB8b9hxD871L0aR5K9xy/f+hSYoD3ndvR8vtX2KhBBQmdcE/PcPx5BeNcWaHZhj3diF+2L4bCzr8Fx2LF0D0ug6Ffabih71ubNlbgRSnDTec0Q7dm0so+3QKMjbMwzrvQCz0jIQbDqzcfgAvneNC840L1GNfPgOb2vwfnvq0EK84noUXdjz53kic0vIqtDv0LQ58Px8vui7BGztScWvHo3i0dDwkT6X/gUvA4V3At89DrJqF/yVfhJ+75uPuq86BtP1r4PMHAQhg8T9w+LKX8MmPJfhq0z50y/BgXNdyNGrSEmibp97VFw8Bq18BmuYCdyzB/v9OQgv/iV989xJ8p98KW1a3kD97eZUHk/+7ESu2l6Fbq8bo37EZbjqzHZq4SoD1bwM/vguU70Fn/xB2I1fSsUhL8WdGoKDwl9+wadsvuHHDGMjHSoEf5uF4+/OR/NsKSD7/1fxbNwCjvsTL35fhHwt/RuNkO87q2BxX922DYb1aoar8IMSH9yDVV4FfXhmJFUPeRtNGyUja/xOKf9mA5b/58JvSHH+56VJc3Cs78kFVlWPTxnWYsOAY3D4Fa99/EpfbXgNSmgE3LwC2faW+TgFg13Jg13KIz+6H1PViYOA9QM6ZAAC3V8GOsqPompUOScsKeKrU4OrX5QAEfus4AutXfoHLNs8DAKRKLrzmfBJvec9D61WHcexgK6Rd9DCKHR0w6vXV2LrvKOyLJcz6Yx7Wb9yIvx2aiCa2Y4AL6teSjcB3L8Iz5K+YUnImDh/34l//dypSnXb8XFKOJz7fjGtyPbga6tT+KbbYAwuhByMmG1il0LVphBD44IfdaNMkBQM6NQ/b/6PC3Zi/phiSBMiShI/W7UHTNCcevbwHJEnC019ugdur4MtN+zB72Q7cMbgj5qzYicLiw/jrZd2RnZECQA3a/vnR9+i5/jE0xVG8vnU8br3uarz3/U4sXPIN2uW0x4ghfdGzTRMAQGlFFV5ZthOF23fjjj5JOCP9IHZ+8hqWie+wRzTHhK/y8Z+VnbBg4K/I+XUBlKOlqKqswLEu16DFNU+o0zRsXqi+RnwuwFUBlKwHKg8ATTsAV70AdDg78ED3bwWWPoHjp1yOj9z90CUrHXntmwKHi4FlT0Ep/h5FBzujSdUQzF/jwYFjLlzdtw1eX/ITftuzD0BztMtw4OHjL0NGFbDvJ+A/V6PEeRYcrpEAGuPfX/+CYb2zsWdvCX5ZMBX70nthyFWjkOK04YnPN+O7nQexIH8gTm/X1NRzW1eSMBAiut1upKam4r333sM111yjb7/33nuxbt06LF26NOw255xzDvr27Ytnn31W3/bhhx9i+PDhqKyshCNCZ77L5YLLFUgjlpeXIycnB0eOHEHjxo1jfnC1uX3uaizevBfnyevwR9tXOEv+GalSeBrYl94GroqDSMVxuIQDP4qO+MJ3Bub6LsZQeQ1mOZ+FV8iY3fVV5N90renjWf3Zqzhj9YTAhs5DgSv/jTUlXpS/dRvOx/ch+y/y9UMT6Sj6y5v9WyQAAgpkXOb6B5pJ5fiP4wnIksAiXz886hmJ+3J34hrnWjh8lWrwkNkF6HEV1jn7Yuw7m3Cs/CDubLwK16VvwNKK1ni6/ALsR1Oc2aEZnri6Gzr+/CK8y56BXQn/O4mO56Fs9w60cO2CIiTIUuClVZR2Ku6SH8ZP+9WTUNumKXhv7ABkH1oLfPlXNVPgPmrq7/a90hWNUYlucjG8QsYk54O4qGMyLtzyN3iEDbIkYIOCYyIZl7inQTTpAOfh7ZjpeBbd5GL9fjYq7THWMx7FIguAwFB5Df7unIcsHND32ZLUG2Oq7sVvrmR87Pwresm/6j972j4amVW7cKu9AABwRKRiPbrgHGkdAOCQaIRxnnGYZn8FOfJ+oO2ZwPmTgDb9gO1fw7N6Lhw7/wcAOCaSsL7drRhw4ANIlerv90HGha6nUC5S8JLzGfSTt+q/23fW3ZDbnA7pg9v1bfsb90CL8k1QhIQfRS5Ok3dgc9oZaHfP50hNckAIgcKig3jp7Q/QrWIVmkoVeM83BFtEDv6avhC3et+LuIL04gGv4byLzb/Oq1u/cy+6z+0Bp+RDkWgJCIF28n64U7JgP74fMtTXzN6sIcg6tgXS0b0oazUYk4v7wiNk9JF34HR5G35QOmNx6zvxf0fmYIQrkHl90DMGDnjxmOO1kN+7TzSFre3pyPTthzj0K5S822EbOgXuqkooLw5G8uFfMMd7CRbZz8U88VckSf5yrLMR4D4GCQLP2W7B8So3rrYtR1f5N/WOZQdw3cs4mnsxFrwwEadWLEOjjObo1D4HUtk2NVsT1EB6XDjhg4xGUhVe8l6G0zMqcMaxb0KO1SfZ8R9cjiqPD93kYqzxdcbr4lK8ZHsSA22bcLBxN8y3X4Xt+w5jrO0TnCKrWcN3vUPwiPc2XHJaB0y5sidufe5jDDv6Ec6SN+I0eQeOiDRkTKklwxhk4ws3oef+z7Cu3a047fbnYn+S/dY/cSH6VK3G/mb90OLM6zFnTw6mfi8gSRIeu7oX/tA3EygvAUo3Yc+aT1C1fTnme4cg+dwJ6JCZitff/QA95F3oNWwMuua0wrhZH2OM/TNsEu3xX3EOTstpDkfxNzhF2oPvm1yGeWPPRdlRF/49/1Pcd3AqOslqtlIREtY7TkUHz3Y0ldTzzmGRhu9tffFBo5uw7aAX90lvYJi8OuQ8pnHDju1KNroHnT80P2acB0ezdui+8/Ua/xbLml2LaZ6bcLSiHO/bHkZLn1rane89F6vQGxM7F6Nl0ULAF7qA5JfKGXjK8384Vd6Bh+1vIgPHsPG0SejWIhXOrx7GQdEIn/gG4A/2r2GHD/vQFC81/QteK2mHs5oexd8rp+IUSX3OX/Rejn95b4ACGU67jClX9sSNZ7Yz/LzWpLy8HBkZGbV+fhsKRvbs2YM2bdpgxYoVGDhwoL798ccfx+uvv44tW7aE3aZLly4YOXIkHn74YX3bypUrMWjQIOzZswfZ2eFXJpMnT8aUKVPCtlsdjOz66iU0/mEmmlb+qm/bLxpjjdIVFU16wFtRiivFYjSSIqd0dyT3ROPjxciUyvGc92ocPPMBTL6yp+njqXK5Ufjx8+hzuACpe1apy2yntQAaZQH7NsAnOXA4exAategAx09vQvaf0CpECl5rfCf+MHIcUj6/F6m/fIp1Skd0TjqCNM+BWn5rQLlIhQNepEiBF78bdiwTp2G9twPOt/2A02S1jPCzkoM9nUagYE8SjlUcwU5kY4vUERm+w3jD+Ti6ycU4ZsvATPeluEP+LzKkSuxSWuInW3eU2Npg33EJp6fsw6Xer0KOQSRnYGfmefhsfyb6Va7EANsmFIuW+CVjIDo2c6LN4dUoKz+OOa7z8JtogX85ZuvPjyLZIAsfXMIBF+xoLB3HTNsfcfb19+DUFfcAxauwRumCJz0jMNs5HRnSMewXGXjeezXG2T9EplQOH2zY3PISKMcOofexlQCAYtESa1pcjSuPvA2bpwKKIxUbRSf09v6EcpGKV7yXYoLjfRwWaWgiqT0E3ubdYD+gBoleIWOv1AJtsU9/nL8qWVh8znxkNGsBt1dBerIDb39fhKrtyzEpaT76IvBe2qB0wCHRCINtGzDfey66J5fhVO8GAECR0gLtZLX0pECCDIGPfQMwVF6DZEl9faxsdBGODbgP53x5BZIkDw6KdEg2O+yKC6niOGzVTrb70QwtcBAAsN5+Kl6rPBuF4hQ0RzlaNWuMR8bciOwm1bJadbB9/1FMeeY5POF4Ga0l9ffuUlri/9yT0Uo6iHvsC1CodMYs3xW4skUpnjr6EBwi8gq/n/vOwHnyOiRLHuzLPg9ZJYvhkpKQJNTguSS1C5omAfLhX+GMcB/5vr+gl9iCfPvH+jZhc0LyufE/X1+kSVU4S1ZLP294L8BfvaPQJNWBZJuMpke34tH0TzDAvRICEvbZWqGVL7xUBwDu5Ez873gXtBKl6CurpZj9Gb2x//r/ont2BqTVr+BQ8SY8t15goLQBF9l+CLuPIyIVGVIl3HIynPkrIJp3wpOLtuClJVtxu+1zPGR/GzZJYLOSg/d8Q5CWmoLR7jfRWKrU72OR6I+Lp3wZy9OkHveCu+H88T9wnXUvki6ZGvPt9N/39G24uGJByLYS0QxHRBqypQPICDq2YMp5f4Wclgnl0/sgw4cS0Qwrks7BMNfnSPNfQG5T2qASSejjP0f9orTGM8470bNqLW61LUKa5EJVajb2Nu6NDnsDj9ktp8CuVOlDnRUhwQObHnweE8nYLZqjUO6FIVfcilZb3wC2LAQAHBXJeN57NdYoXdDduR+PYDacUiCAf8N7AbaKtnDBiS1KDopES9xvfxc32b8GoL63jyIFZ8k/44BIR1McDQt+KlqdhSf2nIYLxbc41/YjJET5yJYdgOLB57kP4b7tfdHOsxPPO57TA9NykQpAoLF0HJVyOlKVCgDAZiUHrianoFPHjmh0xh+ANnk1P4kGndBgZOXKlRgwYIC+/R//+Af+85//YPPmzWG36dKlC2677TZMnDhR37ZixQqcffbZKCkpQatWrcJuU1+ZEbzzB2Dzp0BSY4i821Da4UqsrWqN7CYp6NuuKb7dfgD5cxajt9iKg7aWeHzUlTi1UTnwy1fA4n8ALrUu+4vUDpce/zvuurAn7r2wszXHtn8L8P7twD71QwepmcANbwHt+qvfl/wIfDYBh90S/lj6R2yoykSnFmk4vUklphSNDGR4WvYELnsa+PAO4HARdsvZmOs6D7+KVpAh0F/+GcNs3yPb/yEAAPuTc/Gfyv64KnUDOlVtCDmsIyIVj3huR1recDx+7an47dBx/PHV77DrgHoSSbLLmHFVBwyz/wB0HorDcgY2rFmK05fejlRf5Dr2W97z8bLvMrgcGaiyNcLB4+qVcEaKA6MHtMVNAzqieXpg+GFpRRWuen4FSo5U4ez0fXgp+xOkdegH9L8Tno/GwbFNPVGUNe6J9LsXI8mZBBzaBfHiIEiuisAvbnsm3un4OB7/5iCuO0XCg67nkFwcaMYWsgPF3ceg2bCJaNSoMVC6GXjvVmB/4HV+aNDfUHzKTejyziAku9Q6Ps68A7j4cVR8/TSOF62DfO4DaN6mE6Q3hwPFq+CWU3D58cnYKnLC/hYpDhveu7M/di2eg/6/zICAhJuUKRhzWiqG/3RHYEdnOly3fo7nNzpxaNWbeMT3ApIkL9aKrvik72ycevBLXFv0D3glB3x3rUFSZgdsf+9RdNr4bNjvrJJTIZ9yvlp+2fgRIHyokNIwyXUbPlYGwmmTMax3K9x4Zjv0z20WKDdYpLSiCmf+439ohEr8s+knuKDZfjzkGY2PipLRPbsxplzZE9/vPIB/f/0LXF4FA+SNuM32BXJS3Oia6YDcsgeQ0QZi2dP6SDR3mwFw3v4J8NIQoHSj+osG3QtcOAWQJLirKjFjzn9QuXsDfhMtMFj+EbfaC3BEpCINVbBLChalXoGhrkWQfG5409tgdPIzWLunCg9Kr8MpKfj6lAdxdV4uzu/WErsPH8c1M1egvNKFJ5LnYjjUIPugSMcPHe/EF1sr0BQVUDLawd62L17Z4INPAfq1a4Kn+uxBh/K1wKB7gMatQ/42Ly3djk/X78GNqd/jXNf/0LLNKbBn5kJ8NxtShfoh47tsBmxn3BZym2mfb8ZlqZvxrONZ2F2hvQDHMk/FHPdF+GB/axxKysH6yRfH/mR9dj+w+mVg8H3ABY8afapxz1trsH/D18iTtuJMeTPOlDfrQbPmqEjGbpGJb0UvdGvTHGftfTPk58flVKQogaDF1bIPnOVFkKoOAQAUezKEoxFsx8tCbudqOxBJN8wDGrXA0v8tROnGJeg78CKc0vc8QPGgfOcPUFY+hya/fgEAELnnQLr4cRQ7O2H+6mIM690KPVtnqL0f69+Gp2QjJvx2Nj7ZrmBw50xMH34aDvz4Bdp/dQeEkLCs51R4u16Bd1YXYdm2MnTMTMNZnZqjWaoTrcuW4+qdU5HqPQwA8NhSMKfrbJyRBZy26Un8dqACC6t6osCXh7WiKwDgzA7NMP/aJpCWTAM2/RfCngLpvIlqefvrv6sPMrsPMGYxDh734a3vdiEr2Yfry2YC699Ry0UA9qZ1RdadH0Eq+hbiw3xIvqCL7eteBXr/n+HntSYnJBiprzKN2Qdj2G9rgeJVQN+bgeTI9/vZjyWY/c12TBjaFUO6tAj84HCR2mC3byMqrp+Pb8pb49yuLZCWZN0CYvAcB75+DCjbClz6pFprjGDH/qP4wyvfoeSI+qL6k+1jPOh4B3CkAXcsAVp0AVxHgbIt8GT1wfLtB3G40o1Ktw/H3T5Uub3omO7BsFw7JMUHtOwORUDtEdm9FihaBZT8CI+chB098lEmZ+Ksjs1h8/eQeH0KDla64fEJZKQ40CjS36DyILBrhZqiPrwLxyqPY9v+Y1jd5FLsadoPS7bsx84yNavQtmkKbhnQHjee2Q7pyZFfH7+WHcN/1+3BDWfmIKtx0DwJnipgwWhg9w/AH94HsnoEfrZ+vhqUAUDXS9U3njMVQojAB+xva4FVL6h/+wsnAy26hv5iIYDf1gAb/GWAi6YCdiew8t9qualZJ2DscsAZIXPgOgp8Pxve9mfjr6uT8fPeCjROtsNpk1Fe5YEECfdc0Blnd86EoghM/2IjysqP4a6hvZHTNAWYc7HaUwOogWm3ywCozWibV38FafNnaHnxBGS28qdZN30MpDYL1KaFgDi8C3tKD2LT7gNonpGBHrltkJyRpTdP4+BOYOsiHOs0DP9ecxyZjZy49vS2aJZmbdNqMEUR+MMr38GrKHj5ln5okuqETxHYsrcCXbIawe7vadh7pArf7TyALXsrUOn24c8XdkFGatDrY8vnwLu3qmntUQVAzhnq6+C/dwE9rwXOuT+k10EIgU0l5Uhx2NAiVULKvEtg3/ej+rMeV0Ma/rratLr2NWDgOKBVbyiKQGmFCylOGzJSQl+bq3YcwO1zV6PS7cVI2yJ0sB9EnxunoG+3UzB/dRH++tEGeHyB0+21fdtg2nW9kWSggVTnOgp8NwuwJanHVi1A3LavAi3Tk5GhHILYsADbv3kLScdKcKj3bTj12gdxoNKL8fPXoU/bJrj/4q5RfkkEWg/Tlf8G2p1l+LD3HD6OV5fvxDdb92Nb6VHc3r8VHjm1ApLwoWC3DYuKbKiypSE92Y5bB3ZAt1aNgW+eVM+DAHDeJFT2+xPe/fdDyKtcji1trsP/jfkr4CqH+O5FdRm+M0YDkoyj7+ej0Y7PcbRpDzS6+K/qez6WQHrfJrW3o8PZte7vUwS27z+KU1o0CqzXdKxMbfBNbRayn636ek5HdgMLxqjnk+teAXpcqf+oosqD/Dd/wPJfytAs1Ym2TVPw9PDTcErLRuoOB7YDzkZAepb6/caP1IDjwr8BLbtHOFAPsH8zfOX7YMsdBDjUXhocLgZ++15teD9aCvS5IfycV0cnJBgBgP79+yMvLw8zZ87Ut/Xo0QNXXXVVxAbWBx98EJ988gk2bdqkb/vTn/6EdevW4dtvv43pd56wYMQKQphu5rJS8cFKPUNxaY9MzOy0Su1F6DAo3ocWEyEEfig6BJdHQf+gQMc0RQHkao15QgDfvwx4jwNn3RX4ALaC4lNPBh2HABltrbvfYLtWAvP/CAwar15FU7iDO9RRLW1ON37bsl+Al88DbE4g/1ugUUvDd3HkuAclR9QRZm2apIQE02VHXVjxSxm+3X4AnbPScfugDpZnmWpSUeWJGtzHQ6Xbi9RYV3/evFC9YPQH1qXlVfjvuj0YcWYOGkd7TEIAFSVAenZCnKOjcldGvnhBlCCmgTlhwcj8+fNx880348UXX8SAAQMwe/ZsvPzyy9i4cSPat2+PiRMnYvfu3Zg3T+0M37lzJ3r16oU777wTY8aMwbfffouxY8fi7bffjnk0TUIHIwmk7KgLX27chyv6ZCfUSYeowajYp46ESMuM95EQnRRi/fw2fGk4YsQIHDhwAFOnTkVJSQl69eqFhQsXon379gCAkpKSkDlHcnNzsXDhQvz5z3/GCy+8gNatW+O5556L+7Dek1FmoyTc1N/aTmii3xUt7U1E9cpwZiQemBkhIiJqeGL9/ObaNERERBRXDEaIiIgorhiMEBERUVwxGCEiIqK4YjBCREREccVghIiIiOKKwQgRERHFFYMRIiIiiisGI0RERBRXDEaIiIgorhiMEBERUVwxGCEiIqK4Mrxqbzxoa/mVl5fH+UiIiIgoVtrndm1r8jaIYKSiogIAkJOTE+cjISIiIqMqKiqQkZER9eeSqC1cSQCKomDPnj1IT0+HJEmW3W95eTlycnJQXFxc49LGDRkfY8N3sj8+gI/xZHCyPz6Aj9EMIQQqKirQunVryHL0zpAGkRmRZRlt27Y9YfffuHHjk/aFpeFjbPhO9scH8DGeDE72xwfwMRpVU0ZEwwZWIiIiiisGI0RERBRXv+tgJCkpCX/729+QlJQU70M5YfgYG76T/fEBfIwng5P98QF8jCdSg2hgJSIiopPX7zozQkRERPHHYISIiIjiisEIERERxRWDESIiIoqr33UwMnPmTOTm5iI5ORl5eXlYtmxZvA/JlGnTpuGMM85Aeno6WrZsiauvvhpbtmwJ2WfkyJGQJCnk66yzzorTERs3efLksONv1aqV/nMhBCZPnozWrVsjJSUF5557LjZu3BjHIzauQ4cOYY9RkiTcddddABrec/jNN9/giiuuQOvWrSFJEj766KOQn8fynLlcLowbNw6ZmZlIS0vDlVdeid9++60eH0XNanqMHo8HDz74IHr37o20tDS0bt0at9xyC/bs2RNyH+eee27Y83rDDTfU8yOJrrbnMZbXZSI/j7U9vkjvSUmS8OSTT+r7JPJzGMvnQyK8F3+3wcj8+fMxfvx4TJo0CYWFhRg8eDCGDRuGoqKieB+aYUuXLsVdd92FVatWoaCgAF6vF0OHDsWxY8dC9rvkkktQUlKify1cuDBOR2xOz549Q47/p59+0n/2r3/9C9OnT8fzzz+P1atXo1WrVrjooov0dY0agtWrV4c8voKCAgDA9ddfr+/TkJ7DY8eOoU+fPnj++ecj/jyW52z8+PH48MMP8c4772D58uU4evQoLr/8cvh8vvp6GDWq6TFWVlbihx9+wCOPPIIffvgBCxYswNatW3HllVeG7TtmzJiQ5/Wll16qj8OPSW3PI1D76zKRn8faHl/w4yopKcGcOXMgSRKuu+66kP0S9TmM5fMhId6L4nfqzDPPFGPHjg3Z1q1bN/HQQw/F6YisU1paKgCIpUuX6ttuvfVWcdVVV8XvoOrob3/7m+jTp0/EnymKIlq1aiWeeOIJfVtVVZXIyMgQL774Yj0dofXuvfde0alTJ6EoihCiYT+HAMSHH36ofx/Lc3b48GHhcDjEO++8o++ze/duIcuy+OKLL+rt2GNV/TFG8v333wsAYteuXfq2IUOGiHvvvffEHpxFIj3G2l6XDel5jOU5vOqqq8T5558fsq0hPYfVPx8S5b34u8yMuN1urF27FkOHDg3ZPnToUKxcuTJOR2WdI0eOAACaNWsWsn3JkiVo2bIlunTpgjFjxqC0tDQeh2fatm3b0Lp1a+Tm5uKGG27Ajh07AAA7d+7E3r17Q57PpKQkDBkypME+n263G2+88QZuv/32kMUhG/pzqInlOVu7di08Hk/IPq1bt0avXr0a7PN65MgRSJKEJk2ahGx/8803kZmZiZ49e+L+++9vUBk9oObX5cn0PO7btw+fffYZRo0aFfazhvIcVv98SJT3YoNYKM9qZWVl8Pl8yMrKCtmelZWFvXv3xumorCGEwIQJE3D22WejV69e+vZhw4bh+uuvR/v27bFz50488sgjOP/887F27doGMZtg//79MW/ePHTp0gX79u3DY489hoEDB2Ljxo36cxbp+dy1a1c8DrfOPvroIxw+fBgjR47UtzX05zBYLM/Z3r174XQ60bRp07B9GuL7tKqqCg899BBuuummkAXI/vCHPyA3NxetWrXChg0bMHHiRKxfv14v0yW62l6XJ9Pz+PrrryM9PR3XXnttyPaG8hxG+nxIlPfi7zIY0QRfcQLqE1V9W0Nz991348cff8Ty5ctDto8YMUL/d69evdCvXz+0b98en332WdgbKxENGzZM/3fv3r0xYMAAdOrUCa+//rreLHcyPZ+vvvoqhg0bhtatW+vbGvpzGImZ56whPq8ejwc33HADFEXBzJkzQ342ZswY/d+9evVC586d0a9fP/zwww84/fTT6/tQDTP7umyIz+OcOXPwhz/8AcnJySHbG8pzGO3zAYj/e/F3WabJzMyEzWYLi+hKS0vDosOGZNy4cfj444+xePFitG3btsZ9s7Oz0b59e2zbtq2ejs5aaWlp6N27N7Zt26aPqjlZns9du3bhq6++wujRo2vcryE/h7E8Z61atYLb7cahQ4ei7tMQeDweDB8+HDt37kRBQUGty7KffvrpcDgcDfJ5BcJflyfL87hs2TJs2bKl1vclkJjPYbTPh0R5L/4ugxGn04m8vLywFFpBQQEGDhwYp6MyTwiBu+++GwsWLMDXX3+N3NzcWm9z4MABFBcXIzs7ux6O0Houlws///wzsrOz9fRo8PPpdruxdOnSBvl8vvbaa2jZsiUuu+yyGvdryM9hLM9ZXl4eHA5HyD4lJSXYsGFDg3letUBk27Zt+Oqrr9C8efNab7Nx40Z4PJ4G+bwC4a/Lk+F5BNRsZV5eHvr06VPrvon0HNb2+ZAw70VL2mAboHfeeUc4HA7x6quvik2bNonx48eLtLQ08euvv8b70Az705/+JDIyMsSSJUtESUmJ/lVZWSmEEKKiokLcd999YuXKlWLnzp1i8eLFYsCAAaJNmzaivLw8zkcfm/vuu08sWbJE7NixQ6xatUpcfvnlIj09XX++nnjiCZGRkSEWLFggfvrpJ3HjjTeK7OzsBvP4ND6fT7Rr1048+OCDIdsb4nNYUVEhCgsLRWFhoQAgpk+fLgoLC/WRJLE8Z2PHjhVt27YVX331lfjhhx/E+eefL/r06SO8Xm+8HlaImh6jx+MRV155pWjbtq1Yt25dyHvT5XIJIYT45ZdfxJQpU8Tq1avFzp07xWeffSa6desm+vbt2yAeY6yvy0R+Hmt7nQohxJEjR0RqaqqYNWtW2O0T/Tms7fNBiMR4L/5ugxEhhHjhhRdE+/bthdPpFKeffnrIUNiGBEDEr9dee00IIURlZaUYOnSoaNGihXA4HKJdu3bi1ltvFUVFRfE9cANGjBghsrOzhcPhEK1btxbXXnut2Lhxo/5zRVHE3/72N9GqVSuRlJQkzjnnHPHTTz/F8YjNWbRokQAgtmzZErK9IT6Hixcvjvi6vPXWW4UQsT1nx48fF3fffbdo1qyZSElJEZdffnlCPeaaHuPOnTujvjcXL14shBCiqKhInHPOOaJZs2bC6XSKTp06iXvuuUccOHAgvg8sSE2PMdbXZSI/j7W9ToUQ4qWXXhIpKSni8OHDYbdP9Oewts8HIRLjvSj5D5aIiIgoLn6XPSNERESUOBiMEBERUVwxGCEiIqK4YjBCREREccVghIiIiOKKwQgRERHFFYMRIiIiiisGI0RERBRXDEaIiIgorhiMEBERUVwxGCEiIqK4YjBCREREcfX//KNgQPKJadYAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from dataclasses import dataclass\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Please, set the device according to your setup\n",
    "DEVICE = \"cuda\"\n",
    "SIZE = 200\n",
    "\n",
    "np.random.seed(39)\n",
    "\n",
    "\n",
    "def norm_0_1(X):\n",
    "    return (X - X.min()) / (X.max() - X.min())\n",
    "\n",
    "def norm_height(X, max_height):\n",
    "    #return (X - X.min()) / (X.max() - X.min())\n",
    "    return X / max_height\n",
    "\n",
    "\n",
    "def positional_encoding(max_position, d_model, min_freq=1e-4):\n",
    "    # With sinusoidal positional encoding\n",
    "    position = np.arange(max_position)\n",
    "    freqs = min_freq**(2*(np.arange(d_model)//2)/d_model)\n",
    "    pos_enc = position.reshape(-1,1)*freqs.reshape(1,-1)\n",
    "    pos_enc[:, ::2] = np.cos(pos_enc[:, ::2])\n",
    "    pos_enc[:, 1::2] = np.sin(pos_enc[:, 1::2])\n",
    "    return pos_enc\n",
    "\n",
    "\n",
    "def positional_encoding_simple(max_position, d_model, min_freq=1e-4):\n",
    "    # With sinusoidal positional encoding\n",
    "    pos_enc = np.expand_dims(np.arange(max_position)/max_position, axis=1)\n",
    "    return pos_enc\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class ShapeLog:\n",
    "    \"\"\"\n",
    "    A class to store the information about the shapes in the image\n",
    "    \"\"\"\n",
    "\n",
    "    shape_type: str\n",
    "    base_point: int\n",
    "    width: int\n",
    "    height: int\n",
    "\n",
    "\n",
    "def generate_pair(size: int = 100, max_height: int = 50, noise_std: float = 0.3, num_shapes:int = 4, positional_encoding_fn = positional_encoding):\n",
    "    \"\"\"\n",
    "    Generate a pair of images. One with the randomly generated sequence of triangles and/or rectangles\n",
    "    and the other one with the average hights of the shapes in the first image.\n",
    "\n",
    "    Args:\n",
    "        size: The size of the image on the x axis\n",
    "        max_height: The maximum hight of the shapes\n",
    "\n",
    "    Returns:\n",
    "        A tuple of two images. The first one is the image with the shapes and the second one is the image with the average hight of the shapes\n",
    "    \"\"\"\n",
    "\n",
    "    min_height = 5\n",
    "    base_size_range = [3, 10]\n",
    "\n",
    "    shape_choices = [\"triangle\", \"rectangle\"]\n",
    "    # shape_choices = [\"triangle\"]\n",
    "    #convert_to_bin = lambda decimal: [int(s) for s in str(bin(decimal).replace(\"0b\", \"\")).zfill(7)]\n",
    "    shape_logs = []\n",
    "\n",
    "    input = np.zeros(size)\n",
    "\n",
    "    def draw(input, shape_log):\n",
    "        if shape_log.shape_type == \"triangle\":\n",
    "            pick_point = (shape_log.base_point + (shape_log.base_point + shape_log.width)) // 2\n",
    "            input[pick_point] = shape_log.height\n",
    "\n",
    "            # Computing the triangle's first ramp\n",
    "            num_points = pick_point - shape_log.base_point\n",
    "            values = np.linspace(0, shape_log.height, num=num_points, endpoint=False, dtype=int)\n",
    "            input[shape_log.base_point : (shape_log.base_point + shape_log.width // 2)] = values\n",
    "\n",
    "            # Computing the triangle's second ramp\n",
    "            num_points = (shape_log.base_point + shape_log.width) - pick_point\n",
    "            values = np.linspace(shape_log.height, 0, num=num_points, endpoint=False, dtype=int)\n",
    "            \n",
    "            word_size = min(size, shape_log.base_point + shape_log.width) - (\n",
    "                shape_log.base_point + shape_log.width // 2\n",
    "            )\n",
    "            input[\n",
    "                (shape_log.base_point + shape_log.width // 2) : min(size, shape_log.base_point + shape_log.width)\n",
    "            ] = values[0:word_size]\n",
    "\n",
    "\n",
    "        else:\n",
    "            # Rectangle\n",
    "            input[shape_log.base_point : (shape_log.base_point + shape_log.width)] = shape_log.height\n",
    "\n",
    "        return input\n",
    "\n",
    "    def average_shapelogs(shape_logs):\n",
    "        # Average the two left most and the two right most        \n",
    "        half_way = len(shape_logs) // 2        \n",
    "        mean_0 = np.mean([shape_logs[i].height for i in range(half_way)])        \n",
    "        mean_1 = np.mean([shape_logs[i].height for i in range(half_way,len(shape_logs))])\n",
    "        \n",
    "        for i in range(half_way):\n",
    "            shape_logs[i].height = mean_0\n",
    "\n",
    "        for i in range(half_way,len(shape_logs)):\n",
    "            shape_logs[i].height = mean_1\n",
    "\n",
    "        input_averages = np.zeros(size)\n",
    "        for shape in shape_logs:\n",
    "            input_averages = draw(input_averages, shape)\n",
    "\n",
    "        return input_averages\n",
    "    \n",
    "    def remove_overlaps(shape_logs):\n",
    "        # Removing basic overlaps (it has some flaws, but f*** *t)\n",
    "        \n",
    "        for i in range(len(shape_logs)-1):            \n",
    "            \n",
    "            # Check overlap\n",
    "            if shape_logs[i].base_point+shape_logs[i].width > shape_logs[i+1].base_point:\n",
    "                if i<num_shapes//2:\n",
    "                    shape_logs[i].base_point -= max(0,shape_logs[i].base_point+shape_logs[i].width)-shape_logs[i+1].base_point-1\n",
    "                else:\n",
    "                    shape_logs[i].base_point += min(size,shape_logs[i].base_point+shape_logs[i].width)-shape_logs[i+1].base_point+1\n",
    "        \n",
    "        # Treating the last one\n",
    "        if shape_logs[-1].base_point+shape_logs[-1].width > shape_logs[-2].base_point:\n",
    "            shape_logs[-1].base_point = min(size,shape_logs[-2].base_point+shape_logs[-2].width)+1\n",
    "\n",
    "        return shape_logs\n",
    "            \n",
    "    \n",
    "    \n",
    "    # Picking the middle points\n",
    "    #base_points = sorted(np.random.uniform(0,100, size=num_shapes).astype(\"uint\"))                \n",
    "    seeds = [(i*(size//num_shapes), i*(size//num_shapes) + size//num_shapes) for i in range(num_shapes)]    \n",
    "    base_points = [np.random.randint(mi, ma) for mi,ma in seeds]        \n",
    "    widths = np.random.randint(base_size_range[0], base_size_range[1], size=num_shapes)\n",
    "    heights = np.random.randint(min_height, max_height, size=num_shapes)                       \n",
    "    shapes = np.random.choice(shape_choices, num_shapes)\n",
    "    \n",
    "    shape_logs = [\n",
    "        ShapeLog(shape_type, base_point, width, height)\n",
    "        for shape_type, base_point, width, height in zip(shapes, base_points, widths, heights)\n",
    "    ]\n",
    "    \n",
    "    shape_logs = remove_overlaps(shape_logs)\n",
    "\n",
    "    for shape in shape_logs:\n",
    "        input = draw(input, shape)\n",
    "                         \n",
    "    input += np.random.normal(0, noise_std, size)\n",
    "\n",
    "    target = average_shapelogs(shape_logs) + np.random.normal(0, noise_std, size)\n",
    "\n",
    "    input = norm_height(input, max_height) \n",
    "    target = norm_height(target, max_height)\n",
    "\n",
    "    \n",
    "    # Creating the absolute position encoding\n",
    "    pe = positional_encoding_fn(size, 1).T[0]        \n",
    "        \n",
    "\n",
    "    input = np.expand_dims(input, axis=0).astype(np.float32)\n",
    "    pe = np.expand_dims(pe, axis=0).astype(np.float32)\n",
    "    target = np.expand_dims(target, axis=0).astype(np.float32)\n",
    "\n",
    "    return input, target, pe\n",
    "\n",
    "\n",
    "\n",
    "class ShapeDataset(Dataset):\n",
    "    def __init__(self, max_samples=1000, size=100, max_height=50, noise_std=0.3, positional_encoding_fn=positional_encoding_simple):\n",
    "        \"\"\"\n",
    "        Shape dataset.\n",
    "        It generates a pair of images. One with the randomly generated sequence of triangles and/or rectangles\n",
    "        and the other one with the average hights of the shapes in the first image.\n",
    "\n",
    "        Args:\n",
    "            max_samples: The number of samples to generate\n",
    "            size: The size of the image on the x axis\n",
    "            max_hight: The maximum hight of the shapes\n",
    "            noise_std: The standard deviation of the noise to add to the images\n",
    "\n",
    "        \"\"\"\n",
    "        self.images = [generate_pair(size=size, max_height=max_height, noise_std=noise_std, positional_encoding_fn=positional_encoding_fn) for _ in range(max_samples)]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.images)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.images[idx][0], self.images[idx][1], self.images[idx][2]\n",
    "\n",
    "\n",
    "\n",
    "positional_encoding_fn = positional_encoding_simple\n",
    "#positional_encoding_fn = positional_encoding\n",
    "original, target, pe = generate_pair(max_height=100, size=SIZE, positional_encoding_fn=positional_encoding_fn)\n",
    "\n",
    "# Plotting the dataset\n",
    "fig = plt.figure()\n",
    "#pe = positional_encoding_fn(SIZE, 1).T[0]\n",
    "plt.plot(range(len(original[0])), original[0], label=\"input\")\n",
    "plt.plot(range(len(target[0])), target[0], label=\"target\")\n",
    "plt.legend()    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eea1cd90-1498-4abd-9cbf-6f44cf18085c",
   "metadata": {},
   "source": [
    "## Training the models, with scale dot product vs multi-headed\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3f805d4c-6f43-422d-a78c-85fad782bb10",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training with attention model WITH positional encoding\n",
      "Epoch: 0, Loss: 0.0025489674881100655\n",
      "Epoch: 10, Loss: 0.0004774421395268291\n",
      "Epoch: 20, Loss: 0.00025424413615837693\n",
      "Epoch: 30, Loss: 0.00011633028771029785\n",
      "Epoch: 40, Loss: 0.00011109076149296016\n",
      "Training with attention model WITH positional encoding, MultiHead\n",
      "Epoch: 0, Loss: 0.003206545952707529\n",
      "Epoch: 10, Loss: 0.001617422909475863\n",
      "Epoch: 20, Loss: 0.001959992805495858\n",
      "Epoch: 30, Loss: 0.0008267311495728791\n",
      "Epoch: 40, Loss: 0.0009060478769242764\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fe2b917e890>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import math\n",
    "class NewGELU(nn.Module):\n",
    "    \"\"\"\n",
    "    Implementation of the GELU activation function currently in Google BERT repo (identical to OpenAI GPT).\n",
    "    Reference: Gaussian Error Linear Units (GELU) paper: https://arxiv.org/abs/1606.08415\n",
    "    \"\"\"\n",
    "    def forward(self, x):\n",
    "        return 0.5 * x * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (x + 0.044715 * torch.pow(x, 3.0))))\n",
    "\n",
    "# Implementation of the self attention layer\n",
    "class SelfAttentionLayer(nn.Module):\n",
    "    def __init__(self, in_dim, out_dim, key_dim):\n",
    "        super().__init__()\n",
    "        self.conv_Q = nn.Conv1d(in_dim, key_dim, kernel_size=1, bias=False)\n",
    "        self.conv_K = nn.Conv1d(in_dim, key_dim, kernel_size=1, bias=False)\n",
    "        self.conv_V = nn.Conv1d(in_dim, out_dim, kernel_size=1, bias=False)\n",
    "\n",
    "    def forward(self, x):\n",
    "        Q = self.conv_Q(x)\n",
    "        K = self.conv_K(x)\n",
    "        V = self.conv_V(x)\n",
    "        A = (Q.transpose(1, 2) @ K) / np.sqrt(K.shape[1])\n",
    "        A = F.softmax(A, dim=2)        \n",
    "        y = (A@(V.transpose(1, 2))).transpose(1, 2)\n",
    "        return y\n",
    "    \n",
    "    def forward_attention(self, x):\n",
    "        Q = self.conv_Q(x)\n",
    "        K = self.conv_K(x)        \n",
    "        A = F.softmax(Q.transpose(1, 2)@K, 2)\n",
    "        return A\n",
    "\n",
    "\n",
    "\n",
    "class MultiHeadSelfAttention(nn.Module):\n",
    "    \"\"\"\n",
    "    A vanilla multi-head masked self-attention layer\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, in_dim, out_dim, key_dim, n_heads):\n",
    "        super().__init__()\n",
    "\n",
    "        self.in_dim = in_dim\n",
    "        self.out_dim = out_dim\n",
    "        self.key_dim = key_dim\n",
    "        self.n_heads = n_heads\n",
    "\n",
    "        self.conv_Q = nn.Conv1d(in_dim, key_dim, kernel_size=1, bias=False)\n",
    "        self.conv_K = nn.Conv1d(in_dim, key_dim, kernel_size=1, bias=False)\n",
    "        self.conv_V = nn.Conv1d(in_dim, out_dim, kernel_size=1, bias=False)\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        B, T, C = x.size()  # batch size, sequence length, embedding dimensionality (n_embd)\n",
    "\n",
    "        # calculate query, key, values for all heads in batch and move head forward to be the batch dim\n",
    "        q = self.conv_Q(x)\n",
    "        k = self.conv_K(x)\n",
    "        v = self.conv_V(x)\n",
    "\n",
    "        k = k.view(B, T, self.n_heads, C // self.n_heads).transpose(1, 2)  # (B, nh, T, hs)\n",
    "        q = q.view(B, T, self.n_heads, C // self.n_heads).transpose(1, 2)  # (B, nh, T, hs)\n",
    "        v = v.view(B, T, self.n_heads, C // self.n_heads).transpose(1, 2)  # (B, nh, T, hs)\n",
    "\n",
    "        # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T)\n",
    "        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))\n",
    "        att = F.softmax(att, dim=-1)\n",
    "        y = att @ v  # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)\n",
    "        y = y.transpose(1, 2).contiguous().view(B, T, C)  # re-assemble all head outputs side by side\n",
    "\n",
    "        return y\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "def train_model(model, epochs=20, device=\"cuda\", positional_encoding_fn=positional_encoding):\n",
    "    train_loader = torch.utils.data.DataLoader(\n",
    "        dataset=ShapeDataset(size=100, max_height=50, noise_std=0.3, max_samples=10000, positional_encoding_fn=positional_encoding_fn),\n",
    "        batch_size=32,\n",
    "        shuffle=True,\n",
    "        num_workers=4,\n",
    "        pin_memory=True,\n",
    "    )\n",
    "\n",
    "    model.train()\n",
    "    model.to(device)\n",
    "\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "    criterion = torch.nn.MSELoss()\n",
    "    loss_per_epoch = []    \n",
    "    for epoch in range(epochs):\n",
    "        for i, (input, target, pe) in enumerate(train_loader):\n",
    "            input = input.to(device)\n",
    "            target = target.to(device)\n",
    "            pe = pe.to(device)\n",
    "            optimizer.zero_grad()\n",
    "            output = model([input, pe])\n",
    "            loss = criterion(output, target)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        if epoch%10==0:\n",
    "            print(f\"Epoch: {epoch}, Loss: {loss.item()}\")\n",
    "        loss_per_epoch.append(loss.item())\n",
    "\n",
    "    return loss_per_epoch\n",
    "\n",
    "\n",
    "class ModelWithPE(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "        self.conv1_pe = nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "        self.conv2_no_pe = nn.Sequential(    \n",
    "            NewGELU(),\n",
    "            nn.Conv1d(64, 64, kernel_size=(5,), padding=\"same\"),\n",
    "            NewGELU(),\n",
    "            SelfAttentionLayer(in_dim=64, out_dim=64, key_dim=64),\n",
    "            nn.Conv1d(64, 64, kernel_size=(5,), padding=\"same\"),\n",
    "            NewGELU(),\n",
    "            nn.Conv1d(64, 1, kernel_size=(5,), padding=\"same\")\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        data, pe = x\n",
    "\n",
    "        data = self.conv1(data)\n",
    "        pe = self.conv1_pe(pe)\n",
    "\n",
    "        return self.conv2_no_pe(data + pe)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self.conv2_no_pe)\n",
    "\n",
    "\n",
    "\n",
    "class ModelWithMultiHeadPE(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.conv1 = nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "        self.conv1_pe = nn.Conv1d(1, 64, kernel_size=(5,), padding=\"same\")\n",
    "\n",
    "        self.conv2_no_pe = nn.Sequential(\n",
    "            NewGELU(),\n",
    "            nn.Conv1d(64, 64, kernel_size=(5,), padding=\"same\"),\n",
    "            NewGELU(),\n",
    "            MultiHeadSelfAttention(in_dim=64, out_dim=64, key_dim=64, n_heads=4),\n",
    "            nn.Conv1d(64, 64, kernel_size=(5,), padding=\"same\"),\n",
    "            NewGELU(),\n",
    "            nn.Conv1d(64, 1, kernel_size=(5,), padding=\"same\"),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        data, pe = x\n",
    "\n",
    "        data = self.conv1(data)\n",
    "        pe = self.conv1_pe(pe)\n",
    "\n",
    "        return self.conv2_no_pe(data + pe)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self.conv2_no_pe)\n",
    "\n",
    "\n",
    "\n",
    "print(\"Training with attention model WITH positional encoding\")\n",
    "attention_model_pe = ModelWithPE()\n",
    "loss_per_epoch_attention_pe = train_model(attention_model_pe, epochs=50, device=DEVICE, positional_encoding_fn=positional_encoding_fn)\n",
    "\n",
    "\n",
    "print(\"Training with attention model WITH positional encoding, MultiHead\")\n",
    "attention_model_multihead_pe = ModelWithMultiHeadPE()\n",
    "loss_per_epoch_multihead_pe = train_model(attention_model_multihead_pe, epochs=50, device=DEVICE, positional_encoding_fn=positional_encoding_fn)\n",
    "\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(loss_per_epoch_attention_pe, label=\"With Attention, WITH PE\")\n",
    "plt.plot(loss_per_epoch_multihead_pe, label=\"With Attention, WITH PE, MultiHead\")\n",
    "plt.legend()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.0 ('attention-intuition')",
   "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.10.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "2f9d9e6eb49d62606f5e03e9ead32f50f14df44f9930d8630da1fdfce2c5ab4e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}