splitting.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Early Attempt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "\n",
    "import spacy\n",
    "\n",
    "nlp = spacy.load('en_core_web_sm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from allennlp.commands.elmo import ElmoEmbedder\n",
    "elmo = ElmoEmbedder()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "similes = pd.read_table('similes.txt', header=None, names=['simile'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(similes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Component():\n",
    "    \n",
    "    SUBJECT = 0\n",
    "    OBJECT = 1\n",
    "    TENOR = 2\n",
    "    VEHICLE = 3\n",
    "    GROUND = 4\n",
    "    EVENT = 5\n",
    "    \n",
    "    _type = ''\n",
    "    _phrase = []\n",
    "    def __init__(self, type_, phrase):\n",
    "        if type_ == self.SUBJECT:\n",
    "            self._type = 'subject'\n",
    "        elif type_ == self.OBJECT:\n",
    "            self._type = 'object'\n",
    "        elif type_ == self.TENOR:\n",
    "            self._type = 'tenor'\n",
    "        elif type_ == self.VEHICLE:\n",
    "            self._type = 'vehicle'\n",
    "        elif type_ == self.GROUND:\n",
    "            self._type = 'ground'\n",
    "        elif type_ == self.EVENT:\n",
    "            self._type = 'event'\n",
    "        else:\n",
    "            raise ValueError('Unknown component type')\n",
    "        \n",
    "        if isinstance(phrase, list):\n",
    "            self._phrase = phrase\n",
    "        elif isinstance(phrase, Component):\n",
    "            self._phrase = phrase._phrase\n",
    "                \n",
    "    def get_chain(self, index, reverse=False):\n",
    "        if reverse:\n",
    "            reverse = -1\n",
    "        else:\n",
    "            reverse = 1\n",
    "            \n",
    "        for item in self._phrase[::reverse]:\n",
    "            yield item[index]\n",
    "    \n",
    "    def get_phrase(self, start, stop=None):\n",
    "        if stop:\n",
    "            return self._phrase[start:stop]\n",
    "        \n",
    "        return self._phrase[start]\n",
    "            \n",
    "    def slice(self, index):\n",
    "        return self._phrase[:index], self._phrase[index:]\n",
    "    \n",
    "    def stitch(self):\n",
    "        return ' '.join(list(self.get_chain(0)))\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'{self._type}: {self._phrase}'\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'{self._type}: {self._phrase}'\n",
    "    \n",
    "class Tenor(Component):\n",
    "    def __init__(self, phrase):\n",
    "        super().__init__(Component.TENOR, phrase)\n",
    "        \n",
    "class Vehicle(Component):\n",
    "    def __init__(self, phrase):\n",
    "        super().__init__(Component.VEHICLE, phrase)\n",
    "        \n",
    "class Ground(Component):\n",
    "    def __init__(self, phrase):\n",
    "        super().__init__(Component.GROUND, phrase)\n",
    "        \n",
    "class Event(Component):\n",
    "    def __init__(self, phrase):\n",
    "        super().__init__(Component.EVENT, phrase)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Simile():\n",
    "    \n",
    "    MAX_LENGTH = 25\n",
    "    \n",
    "    _original = ''\n",
    "    _word_tensor = None\n",
    "    _comparator = ''\n",
    "    _subject = None\n",
    "    _object = None\n",
    "    \n",
    "    def __init__(self, text):\n",
    "        self._original = text\n",
    "\n",
    "    def build_tokens(self):\n",
    "        n = nlp(self._original)\n",
    "        tokens = [w.text for w in n][:self.MAX_LENGTH]\n",
    "        poss = [w.pos_ for w in n][:self.MAX_LENGTH]\n",
    "\n",
    "        empty_tensor = np.zeros((len(tokens), 1024))\n",
    "        s = elmo.embed_sentence(tokens)[1]\n",
    "        empty_tensor[:len(s), :] += s\n",
    "        \n",
    "        self._word_tensor = list(zip(tokens, poss, empty_tensor))\n",
    "        return self\n",
    "    \n",
    "    \n",
    "    \n",
    "    def split_subject_object(self):\n",
    "        _sub_obj_split = -1\n",
    "        for i, elm in enumerate(self._word_tensor):\n",
    "            if elm[0] == 'like':\n",
    "                self._comparator = 'like'\n",
    "                _sub_obj_split = i\n",
    "\n",
    "            if elm[0] == 'as' and self._comparator == 'as':\n",
    "                self._comparator = 'as...as'\n",
    "\n",
    "            if elm[0] == 'as' and self._comparator == '':\n",
    "                self._comparator = 'as'\n",
    "                _sub_obj_split = i\n",
    "                \n",
    "        self._subject = Component(Component.SUBJECT, self._word_tensor[:_sub_obj_split])\n",
    "        self._object = Component(Component.OBJECT, self._word_tensor[_sub_obj_split+1:])\n",
    "        return self._subject, self._object\n",
    "    \n",
    "    def extract_components(self):\n",
    "        tenor = Tenor([])\n",
    "        vehicle = Vehicle([])\n",
    "        ground = Ground([])\n",
    "        event = Event([])\n",
    "        \n",
    "        if self._comparator == 'like':\n",
    "            index = 1\n",
    "            for p in self._subject.get_chain(1, reverse=True):\n",
    "                if p == 'VERB':\n",
    "                    tenor, event = self._subject.slice(-index)\n",
    "                    break\n",
    "                index += 1\n",
    "                \n",
    "            tenor = Tenor(tenor)\n",
    "            vehicle = Vehicle(self._object)\n",
    "            event = Event(event)\n",
    "            \n",
    "#             print(list(self._subject.get_chain(1)))\n",
    "#             print(list(self._object.get_chain(1)))\n",
    "            \n",
    "        elif self._comparator == 'as':\n",
    "            index = 0\n",
    "            prev = ''\n",
    "            for p in self._subject.get_chain(1, reverse=True):\n",
    "                if index > 0 and p in ['NOUN', 'PUNCT'] and prev in ['ADJ', 'ADV']:\n",
    "                    nnp = index\n",
    "                    break\n",
    "                prev = p\n",
    "                index += 1\n",
    "\n",
    "            if index > 0:\n",
    "                ground, tenor = self._subject.slice(-index)\n",
    "                ground, tenor = Ground(ground), Tenor(tenor)\n",
    "            else:\n",
    "                tenor = Tenor(self._subject)\n",
    "\n",
    "            if tenor.get_phrase(0)[1] == 'VERB':\n",
    "                event, tenor = tenor.slice(1)\n",
    "                event, tenor = Event(event), Tenor(tenor)\n",
    "            elif tenor.get_phrase(-1)[1] == 'VERB':\n",
    "                tenor, event = tenor.slice(-1)\n",
    "                tenor, event = Tenor(tenor), Event(event)\n",
    "                \n",
    "            vehicle = Vehicle(self._object)\n",
    "            \n",
    "        elif self._comparator == 'as...as':\n",
    "        \n",
    "            text_parts = {'ground': [], 'vehicle': []}\n",
    "\n",
    "            index = 0\n",
    "            for w in self._object.get_chain(0):\n",
    "                if w == 'as':\n",
    "                    ground, vehicle = self._object.slice(index)\n",
    "                index += 1\n",
    "\n",
    "            if self._subject.get_phrase(-1)[1] == 'VERB':\n",
    "                tenor, event = self._subject.slice(-1)\n",
    "                tenor, event = Tenor(tenor), Event(event)\n",
    "            else:\n",
    "                tenor = Tenor(self._subject)\n",
    "\n",
    "            ground = Ground(ground)\n",
    "            vehicle = Vehicle(vehicle[1:])\n",
    "    \n",
    "        return tenor, vehicle, ground, event\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'{self._original}\\n{self._comparator}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def chunk(simile):\n",
    "#     s = Simile(simile).build_tokens()\n",
    "#     s.split_subject_object()\n",
    "#     comps = s.extract_components()\n",
    "        \n",
    "#     return {\n",
    "#         'tenor': comps[0].stitch(),\n",
    "#         'vehicle': comps[1].stitch(),\n",
    "#         'ground': comps[2].stitch(),\n",
    "#         'event': comps[3].stitch(),\n",
    "#     }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'A shadow of melancholy touched her lithe fancies, as a cloud dims the waving of golden grain'\n",
    "\n",
    "Simile(s).build_tokens()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = pd.DataFrame().from_records(similes['simile'].apply(lambda r: chunk(r)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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>comparator</th>\n",
       "      <th>event</th>\n",
       "      <th>ground</th>\n",
       "      <th>tenor</th>\n",
       "      <th>vehicle</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>54</th>\n",
       "      <td>as...as</td>\n",
       "      <td>None</td>\n",
       "      <td>pale</td>\n",
       "      <td>A stooping girl</td>\n",
       "      <td>a pearl</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>115</th>\n",
       "      <td>like</td>\n",
       "      <td>maddens the soul</td>\n",
       "      <td>None</td>\n",
       "      <td>Beauty</td>\n",
       "      <td>wine</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>303</th>\n",
       "      <td>like</td>\n",
       "      <td>turned on me</td>\n",
       "      <td>None</td>\n",
       "      <td>He</td>\n",
       "      <td>a thunder cloud</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>437</th>\n",
       "      <td>as</td>\n",
       "      <td>was</td>\n",
       "      <td>None</td>\n",
       "      <td>It</td>\n",
       "      <td>if a door had been opened into a furnace so th...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>875</th>\n",
       "      <td>like</td>\n",
       "      <td>felt I</td>\n",
       "      <td>None</td>\n",
       "      <td>Then</td>\n",
       "      <td>some watcher of the skies</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    comparator             event ground            tenor  \\\n",
       "54     as...as              None   pale  A stooping girl   \n",
       "115       like  maddens the soul   None           Beauty   \n",
       "303       like      turned on me   None               He   \n",
       "437         as               was   None               It   \n",
       "875       like            felt I   None             Then   \n",
       "\n",
       "                                               vehicle  \n",
       "54                                             a pearl  \n",
       "115                                               wine  \n",
       "303                                    a thunder cloud  \n",
       "437  if a door had been opened into a furnace so th...  \n",
       "875                          some watcher of the skies  "
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.sample(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Measures of Similarity\n",
    "\n",
    "Making use of ELMO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1024,), (1024,), (1024,))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chnk = chunk('The car is as clean as a washed slate')\n",
    "\n",
    "tenor_vec = np.array([w['vec'] for w in chnk['subject'][:-1]]).mean(axis=0)\n",
    "ground_vec = np.array([chnk['subject'][-1]['vec']]).mean(axis=0)\n",
    "vehicle_vec = np.array([w['vec'] for w in chnk['object'][1:]]).mean(axis=0)\n",
    "\n",
    "tenor_vec.shape, ground_vec.shape, vehicle_vec.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1024,), (1024,), (1024,))"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chnk = chunk('She is as burnt as a blue whale')\n",
    "\n",
    "tenor_vec2 = np.array([w['vec'] for w in chnk['subject'][:-1]]).mean(axis=0)\n",
    "ground_vec2 = np.array([chnk['subject'][-1]['vec']]).mean(axis=0)\n",
    "vehicle_vec2 = np.array([w['vec'] for w in chnk['object'][1:]]).mean(axis=0)\n",
    "\n",
    "tenor_vec2.shape, ground_vec2.shape, vehicle_vec2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.54225752]), array([0.78717851]), array([0.69348162]))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1-pdist([tenor_vec, tenor_vec2], 'cosine'), 1-pdist([ground_vec, ground_vec2], 'cosine'), 1-pdist([vehicle_vec, vehicle_vec2], 'cosine')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, 1024)\n",
      "(15, 1024)\n",
      "(6, 1024)\n",
      "(15, 1024)\n"
     ]
    }
   ],
   "source": [
    "tokens1 = [w.text for w in nlp('Her battle against cancer raged on')]\n",
    "tokens2 = [w.text for w in nlp('The journey through cancer was long')]\n",
    "\n",
    "sents = [tokens1, tokens2]\n",
    "\n",
    "ws_d0 = []\n",
    "ws_d1 = []\n",
    "ws_d2 = []\n",
    "\n",
    "\n",
    "for v in elmo.embed_sentences(sents):\n",
    "    empty_tensor = np.zeros((15, 1024))\n",
    "#     ws_d0.append(v[0][:6])\n",
    "#     ws_d1.append(v[1][:6])\n",
    "#     ws_d2.append(v[2][:6])\n",
    "    print(v[1].shape)\n",
    "    empty_tensor[:len(v[1]), :] += v[1]\n",
    "    print(empty_tensor.shape)\n",
    "    \n",
    "ws_d0, ws_d1, ws_d2 = np.array(ws_d0), np.array(ws_d1), np.array(ws_d2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.spatial.distance import cdist, pdist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1a4abdfa90>"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9MAAAE2CAYAAABiG8FdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3XmcZGdd6P/PdyYJ2fcokgUCBjBIIBCCgCiLaAAFlYCgqCzXUQQERbi4XBB+cu8VBAVEMAqaIBcUr0rQKIpC2CJk2CHANUTIAhLJTkKWmf7+/qjq0Jmp6T6n61Sf5+nn886rXpmqru7+dmbmk3pOnSUyE0mSJEmS1N2WsQeQJEmSJKk2LqYlSZIkSerJxbQkSZIkST25mJYkSZIkqScX05IkSZIk9eRiWpIkSZKknlxMS9oQEfGmiLg8Ij6zh49HRLwmIi6MiE9FxH02ekZJKpkdlaT1W0RDXUxL2ih/Bpy2yscfCZwwvW0DXr8BM0lSTf4MOypJ6/VnDNxQF9OSNkRmvg+4cpWnPBY4Kyf+DTg0Ir5jY6aTpPLZUUlav0U01MW0pFIcDVyy4v6l08ckSd3YUUlav94N3Wuh4wB/cOyTc9Hfo6/nfu09Y48w095bF/7b0dsR+x009ggz3bTzlrFH2M1V3/zG2CPMtOPmy2I9n3fL1y/q9Xd3n6Pu8vNMdolZdkZmnrGe761vue5Zjyquoae/o7iRANga6/qjvlBbKG8mgG8s3TT2CLv5xs7yZgLY/tX3b0hDwY4uyvW/8fjiovXYs64de4TdHLFlv7FHmOmKpW+OPcJubl7aMfYIM22NMt8nfc+l/7xpX4uWt3qTVIalnb2ePo3VPMG6DDh2xf1jpo9JUn16NhTsqCTdRgWvRcvcfCFpfLnU7za/s4GfmZ5J8XuAazLzq0N8YUnacH0bakcl6bYqaKjvTEuabWmQKN0qIt4KPAQ4MiIuBV4M7A2QmW8AzgEeBVwI3AA8ddABJGkjDdxQsKOSGlPBa1EX05JmymG28K34evmkNT6ewDMH/aaSNJKhGzr5mnZUUjtqeC3qYlrSbAt4V0WSmmFDJWk+FXTUxbSk2RbwrookNcOGStJ8Kuioi2lJs63jTLSSpCkbKknzqaCjLqYlzVbB1kBJKpYNlaT5VNBRF9OSZqvgOBVJKpYNlaT5VNBRF9OSZlrEmWglqRU2VJLmU0NHXUxLmq2CrYGSVCwbKknzqaCjLqYlzVbB1kBJKpYNlaT5VNBRF9OSZqvgDIqSVCwbKknzqaCjLqYlzVbB1kBJKpYNlaT5VNBRF9OSZqvgOBVJKpYNlaT5VNBRF9OSZqtga6AkFcuGStJ8Kuioi2lJs1WwNVCSimVDJWk+FXR0y1pPiIitEfGWjRhGUjkyd/a6aTYbKrWpb0Pt6J7ZUalNNTR0zXemM3NnRNwxIvbJzJs3YihJBahg15oa2FCpUTZ0MHZUalQFHe26m/dFwAcj4mzg+uUHM/NVs54cEduAbQBPPPRUHnTgCfPOKWmjVbBrTUXW3dBXP+QePPUex23IkJIGZEOHtu6OvuaR9+FpJ995Q4aUNKAKOtp1Mf3F6W0LcNBaT87MM4AzAP7g2CfnuqeTNJ6dt4w9wWay7oZe96xH2VCpRjZ0aOvu6PW/8Xg7KtWogo52Wkxn5ksAImL/zLxhsSNJKkIFu9bUwoZKDbKhg7KjUoMq6OiaJyADiIgHRMQFwOen9+8VEX+40MkkjWtpqd9Ne2RDpQb1bagdXZUdlRpUQUM7LaaB3wd+CLgCIDM/CXzfooaSVIBc6nfTamyo1Jq+DbWja7GjUmsqaGjn60xn5iURsfIhr+EgbWa+SzIoGyo1xoYOzo5Kjamgo10X05dExAOBjIi9gecAn1vcWJJGV0HAKmJDpdbY0KHZUak1FXS062L6F4BXA0cDlwH/BDxzUUNJGl+mG/wHZEOlxtjQwdlRqTE1dLTr2by/DvzUgmeRVJIKtgbWwoZKDbKhg7KjUoMq6Oiqi+mIeC2wx2vzZeYvDT6RpDJ4Mpy52VCpYTZ0EHZUalgFHV3rnentK379EuDFC5xFUkkq2BpYARsqtcqGDsWOSq2qoKOrLqYz88zlX0fEc1fel7TJVbA1sHQ2VGqYDR2EHZUaVkFHO18ai1V2sZG0CVWwNbAyNlRqiQ1dBDsqtaSCjvZZTEtqSQVbAyWpWDZUkuZTQUfXOgHZdXxrK+D+EXHt8oeAzMyDFzmcpBFVsDWwdDZUapgNHYQdlRpWQUfXOmb6oI0aRFJhKghY6Wyo1DAbOgg7KjWsgo66m7ek2SrYtUaSimVDJWk+FXTUxbSk2SrYGihJxbKhkjSfCjrqYlrSbBVsDZSkYtlQSZpPBR11MS1ptgq2BkpSsWyoJM2ngo4ufDH93K+9Z9HforcHHHX3sUeY6bz/+vzYI+zm6huvH3uEmW7ccfPYI2x+FWwNbMET3lHeZVVfcHOZJ889Y9+bxh5hN4fG3mOPMNOXCvz7fdFNXxt7hGEV+N+4VY8+86qxR9jN/zlu59gj7GbbpWW+x/aUnUeNPcJu/ii+OvYIM125o8zX7etWQUfL/FsjaXwVbA2UpGLZUEmaTwUddTEtabYKAiZJxbKhkjSfCjrqYlrSbFne7sWSVA0bKknzqaCjLqYlzbZjx9gTSFK9bKgkzaeCjm4ZewBJhcqlfrcOIuK0iPhCRFwYES+c8fHjIuI9EfHxiPhURDxq8J9LkjZC34Z26KgNldSUCl6L+s60pNkGPk4lIrYCrwMeAVwKnB8RZ2fmBSue9pvAX2bm6yPiROAc4E6DDiJJG8GGStJ8Kuio70xLmi2z321tpwIXZuZFmXkz8Dbgsbt+V2D5ukuHAF8Z7OeRpI3Ut6Frd9SGSmpLBa9FfWda0mzDn0HxaOCSFfcvBe6/y3N+C/iniHg2cADwA0MPIUkbwoZK0nwq6KjvTEuabWmp1y0itkXE9hW3bev4rk8C/iwzjwEeBbw5IuyUpPr0bOhAHbWhkjaPCl6L+s60pNk6nsjh1qdnngGcscpTLgOOXXH/mOljKz0dOG369c6LiH2BI4HLew0jSWPr2VBYs6M2VFJbKngt6tZKSTPlUva6dXA+cEJEHB8R+wBPBM7e5TkXAw8HiIjvAvYF/mvAH0uSNkTfhnboqA2V1JQaXov6zrSk2QY+TiUzd0TEs4B3AVuBN2XmZyPipcD2zDwbeB7wxxHxy0xOAPGUzG5nlJCkothQSZpPBR11MS1ptnXsorjml8w8h8klBlY+9qIVv74AeNDg31iSNpoNlaT5VNBRF9OSZuu2u4wkaRYbKknzqaCjLqYlzTb85QgkqR02VJLmU0FHXUxLmq2CgElSsWyoJM2ngo66mJY0m+eskaT1s6GSNJ8KOupiWtJsFWwNlKRi2VBJmk8FHXUxLWm2Ck76IEnFsqGSNJ8KOrqly5Ni4skR8aLp/eMi4tTFjiZpVLnU76Y9sqFSg/o21I6uyo5KDaqgoZ0W08AfAg8AnjS9fx3wuj09OSK2RcT2iNi+tHT9nCNKGsVS9rtpNetu6CXfuGQj5pM0tL4NtaNrWXdHv3L9ZRsxn6ShVdDQrovp+2fmM4EbATLzKmCfPT05M8/IzFMy85QtWw4YYExJGy2XlnrdtKp1N/TYA4/dqBklDahvQ+3omtbd0TsccPRGzShpQDU0tOsx07dExFYgASLiKMDqS5uZ75IMyYZKrbGhQ7OjUmsq6GjXxfRrgL8Bvi0iXgacDvzmwqaSND6P3xuSDZVaY0OHZkel1lTQ0U6L6cx8S0R8FHg4EMCPZubnFjqZpHFVsDWwFjZUapANHZQdlRpUQUdXXUxHxOEr7l4OvHXlxzLzykUNJmlkHr83NxsqNcyGDsKOSg2roKNrvTP9USbHpsT0/vLmgZj++s4LmkvS2HbuHHuCzcCGSq2yoUOxo1KrKujoqovpzDx+owaRVJgKdq0pnQ2VGmZDB2FHpYZV0NFOl8aKiH/p8pikzaOGyxHUwoZK7fHSWMOyo1J7amjoWsdM7wscABwZEYfxrV1sDga8aJ+0mVWwNbB0NlRqmA0dhB2VGlZBR9c6ZvrngecCd2ByzMpywK4F/mCBc0kaWwUBq4ANlVplQ4diR6VWVdDRtY6ZfjXw6oj4pcx8zcqPRcTtFjqZpHFVcG2/0tlQqWE2dBB2VGpYBR3tdMw08JQZj5034BySSrOU/W5azVNmPGZDpc2sb0Pt6FqeMuMxOyptZhU0dK1jpm/P5HiU/SLiZG57nMr+C55N0ojSF3Zzs6FSu2zoMOyo1K4aOrrWMdM/xGRL4DHAq1Y8fh3w6wuaSVIJKghYBWyo1CobOhQ7KrWqgo6udcz0mcCZEfG4zPy/GzSTpBJ4mZa52VCpYTZ0EHZUalgFHV3rnWkAMvP/RsSjgXsA+654/KWLGkzSyCrYGlgLGyo1yIYOyo5KDaqgo50W0xHxBibHpTwU+BPgdOAjC5xL0tgqCFgtbKjUIBs6KDsqNaiCjnY9m/cDM/NngKsy8yXAA4C7Lm4sSWPLzF43rcqGSo3p21A7uiY7KjWmhoZ2emca+Ob03zdExB2AK4DvWMxIkopQwdbAithQqTU2dGh2VGpNBR3tupj+u4g4FHg58NHpY3/S5RO3bun65vfGOe+/Pj/2CDPd+ZDy/p9w8XWXjz2CxlJBwCqy7obeQnkn33jRXv819ggzPWXnHcYeYTcf2uubaz9pBAds2XvsEXYTEWs/qSY2dGjr7uhesXVhQ63XY/7jprFH2M2zthw29ggz/e3e1449wm5uz4FjjzDTVTuuH3uEYVXQ0a6L6d8FngE8GDgPeD/w+kUNJWl8NVzbryI2VGqMDR2cHZUaU0NHuy6mz2RyPb/XTO//JHAW8IRFDCWpABUErCI2VGqNDR2aHZVaU0FHuy6mvzszT1xx/z0RccEiBpJUiPL2Lq6ZDZVaY0OHZkel1lTQ0a4HNH8sIr5n+U5E3B/YvpiRJJUgl7LXTauyoVJj+jbUjq7JjkqNqaGhq74zHRGfBhLYG/hQRFw8vX9HoMyzeEkahi/s5mZDpYbZ0EHYUalhFXR0rd28f3hDppBUngp2ramADZVaZUOHYkelVlXQ0VUX05n55Y0aRFJZ3OVwfjZUapcNHYYdldpVQ0e7noBMUmsq2BooScWyoZI0nwo66mJa0kw1bA2UpFLZUEmaTw0ddTEtaabcMfYEklQvGypJ86mhoy6mJc1Wwa41klQsGypJ86mgoy6mJc2UFQRMkkplQyVpPjV0dMvYA0gq1FLPWwcRcVpEfCEiLoyIF+7hOU+IiAsi4rMR8X/m/jkkaQx9G9qhozZUUlMqeC3qO9OSZhp6a2BEbAVeBzwCuBQ4PyLOzswLVjznBODXgAdl5lUR8W3DTiFJG8OGStJ8auio70xLmimX+t06OBW4MDMvysybgbcBj93lOT8HvC4zrwLIzMuH/JkkaaP0bWiHjtpQSU2p4bWoi2lJMy0gYEcDl6y4f+n0sZXuCtw1Ij4YEf8WEacN89NI0sZawGLahkpqSg2vRd3NW9JsGb2eHhHbgG0rHjojM8/o+V33Ak4AHgIcA7wvIu6ZmVf3/DqSNK6eDYVBOmpDJW0eFbwWdTEtaaa+x6lMY7VasC4Djl1x/5jpYytdCnw4M28B/iMi/h+ToJ3fbxpJGtd6jvVbo6M2VFJTangt2mk374h4c5fHJG0euRS9bh2cD5wQEcdHxD7AE4Gzd3nO3zLZEkhEHMlkV5uLhvupxmFDpfb0bWiHjtrQNR6TtLnU8Fq06zvT91h5Z3omtPt2/FxJFRr6DIqZuSMingW8C9gKvCkzPxsRLwW2Z+bZ04/9YERcAOwEnp+ZVww7yShsqNQYGzooGyo1qIaOrrqYjohfA34d2C8irl1+GLiZVd5CX7m/+ta9DmXr1gO7/oySCpHrON5v7a+Z5wDn7PLYi1b8OoFfmd6qN0RD737oiRx94DGLHlXSwGzo/Nbb0Onn2lGpcjV0dNXdvDPzf2XmQcArMvPg6e2gzDwiM39tlc87IzNPycxTXEhLdVrAGRSbM0RDfQEo1WkBZ/NuznobOv1cOypVroaGdr001t9FxAEAEfHkiHhVRNxxgXNJGtkCjlNpmQ2VGrOAY6ZbZkOlBtXQ0K6L6dcDN0TEvYDnAV8EzlrYVJJGl9nvplXZUKkxfRtqR1dlQ6UG1dDQrovpHdP9xx8L/EFmvg44aHFjSRpbDVsDK2JDpcb4zvSgbKjUoBoa2vVs3tdNTwLxZOD7ImILsPfixpI0Nl/YDcqGSo2xoYOyoVKDauho13emfwK4CXh6Zv4nkwtcv2JhU0kaXQ271lTEhkqNcTfvQdlQqUE1NLTTO9PTcL1qxf2L8VgVaVOrYWtgLWyo1B4bOhwbKrWpho52emc6In48Iv49Iq6JiGsj4roV1/uTtAllRq+b9syGSu3p21A7umc2VGpTDQ3tesz0y4EfyczPLXIYSeXwmqeDsqFSY2zooGyo1KAaOtp1Mf01Aya1Zcl3SYZkQ6XG2NBB2VCpQTV0tOtientE/AXwt0xOAAFAZv71QqaSNDp3ORyUDZUaY0MHZUOlBtXQ0a6L6YOBG4AfXPFYAkZM2qSWdpYfsIrYUKkxNnRQNlRqUA0d7Xo276cuehBJZanhDIq1sKFSe2zocGyo1KYaOrrqYjoiXpCZL4+I1zLZAngbmflLC5tM0qhqOE6ldDZUapcNnZ8NldpWQ0fXemd6+WQP2xc9iKSy1HCcSgVsqNQoGzoIGyo1rIaOrrqYzsx3Tv995saMI6kUudt7AOrLhkrtsqHzs6FS22roaKdjpiPiKOC/AycC+y4/npkPW9BckkZWw641tbChUnts6HBsqNSmGjq6pePz3sJkV5vjgZcAXwLOX9BMkgqQGb1uWpUNlRrTt6F2dFU2VGpQDQ3tupg+IjPfCNySmedm5tMAtwZKm1hmv5tWZUOlxvRtqB1dlQ2VGlRDQ7teZ/qW6b+/GhGPBr4CHN7lE3cuLa1nroU6Yr+Dxh5hpouu+erYI+zmm195/9gjzLTfHR489gibXg271lRk3Q3dN7pmeuMcv/fBY48w0z/ldWOPsJuzXv/wsUeYadsvvHfsEXZzx32PGnuEQdnQQa27oQCX3XTVQoaax2/uddexR9jNP+x1w9gjzHTWrx0/9gi7ec7//srYI8z0gP2OHXuEQdXQ0a6v0n47Ig4Bnge8FjgY+OWFTSVpdO5yOCgbKjXGhg7KhkoNqqGjnRbTmfl3019eAzx0ceNIKkUNWwNrYUOl9tjQ4dhQqU01dLTr2bxfM+Pha4DtmfmOYUeSVAIP3xuODZXaY0OHY0OlNtXQ0a4nINsXuDfw79PbScAxwNMj4vcXNJukES1l9LppVTZUakzfhtrRVdlQqUE1NLTrMdMnAQ/KzJ0AEfF64P3A9wKfXtBskkZUw3EqFbGhUmNs6KBsqNSgGjradTF9GHAgk11qAA4ADs/MnRFx00ImkzSq8s7DXzUbKjXGhg7KhkoNqqGjXRfTLwc+ERHvBQL4PuB/RsQBwLsXNJukESXlbw2siA2VGmNDB2VDpQbV0NGuZ/N+Y0T8A/DTwOeAfwIuzczrgecvcD5JI1mq4awPlbChUnts6HBsqNSmGjra9Wze/w14DpOTPXwC+B7gPOBhixtN0piWKtgaWAsbKrXHhg7HhkptqqGjXc/m/RzgfsCXM/OhwMnA1QubStLokuh106psqNSYvg21o6uyoVKDamho12Omb8zMGyOCiLhdZn4+Iu620MkkjaqGkz5UxIZKjbGhg7KhUoNq6GjXxfSlEXEo8LfAP0fEVcCXFzeWpLH5LsmgbKjUGBs6KBsqNaiGjnY9AdmPTX/5WxHxHuAQ4B8XNpWk0dWwNbAWNlRqjw0djg2V2lRDR7u+M32rzDx3EYNIKksNAauRDZXaYEMXw4ZK7aiho70X05LasDPK37VGkkplQyVpPjV01MW0pJlquByBJJXKhkrSfGroqItpSTPl2ANIUsVsqCTNp4aOupiWNFMNx6lIUqlsqCTNp4aOblnrCRGxNSLeshHDSCrHUkSvm2azoVKb+jbUjs5mQ6V21dDQNRfTmbkTuGNE7LMB80gqRPa8aTYbKrWpb0Pt6Gw2VGpXDQ1dczE9dRHwwYj4HxHxK8u3PT05IrZFxPaI2L60dP0wk0raUEs9b11ExGkR8YWIuDAiXrjK8x4XERkRp8zzMxRk3Q29+BsXb+CYkobSt6FdOmpDuzUUbtvRq795+QaNKWlINbwW7XrM9Benty3AQWs9OTPPAM4A2Gufo93YKlVoaeC9ZSJiK/A64BHApcD5EXF2Zl6wy/MOAp4DfHjYCUa17ob+8HGPtqFShWzooHo1FG7b0e/6tlPtqFShGjraaTGdmS+ZfuH9M/OGvoNLqs8CLkdwKnBhZl4EEBFvAx4LXLDL8/4/4HeA5w89wFhsqNQeGzocGyq1qYaOdtrNOyIeEBEXAJ+f3r9XRPxhj8ElVWYBx6kcDVyy4v6l08duFRH3AY7NzL+fa/jC2FCpPQs4ZtqG2lCpKTW8Fu16zPTvAz8EXAGQmZ8Evq/j50qq0FL0u608Pm1629bn+0XEFuBVwPMW8xONyoZKjenb0Hk7akMlbTY1vBbtfJ3pzLwkbnvK8Z3dR5NUm77X9lt5fNoeXAYcu+L+MdPHlh0EfDfw3mlrbg+cHRGPycztPccpjg2V2rKe66Ou0VEbakOlptTwWrTrYvqSiHggkBGxN5MDsj/X8XMlVWgBZ2s5HzghIo5nEq4nAj956/fLvAY4cvl+RLwX+NXN8CIQGyo1x4YOyoZKDaqho1138/4F4JlM9im/DLj39L6kTarvrjVrycwdwLOAdzF5EfSXmfnZiHhpRDxmsT/N6Gyo1Jj17Oa9GhtqQ6XW1PBatOvZvL8O/NR6voGkOq1nF8W1ZOY5wDm7PPaiPTz3IQsYYRQ2VGqPDR2ODZXaVENHu57N+8yIOHTF/cMi4k1dPldSnZZ63rRnNlRqT9+G2tE9s6FSm2poaNdjpk/KzKuX72TmVRFx8oJmklSAHPzSfk2zoVJjbOigbKjUoBo62nUxvSUiDsvMqwAi4vAenyupQr5LMigbKjXGhg7KhkoNqqGjXUP0SuC8iHg7EMDpwMsWNpWk0dUQsIrYUKkxNnRQNlRqUA0d7XoCsrMi4qPAQ6cP/XhmXrC4sSSNbQGXI2iWDZXaY0OHY0OlNtXQ0T67yHweuGr5cyLiuMy8eCFTSRpdl0sMqBcbKjXEhg7OhkqNqaGjnRbTEfFs4MXA14CdTHaxSeCkxY0maUw17FpTCxsqtceGDseGSm2qoaNd35l+DnC3zLxikcNIKkcNAauIDZUaY0MHZUOlBtXQ0a6L6UuAaxY5iKSy7Kxg15qK2FCpMTZ0UDZUalANHe26mL4IeG9E/D1w0/KDmfmqhUwlaXQ1bA2siA2VGmNDB2VDpQbV0NGui+mLp7d9pjdJm1wNZ1CsiA2VGmNDB2VDpQbV0NGul8Z6yaIH2Uj773W7sUeY6QquG3uE3ex3hwePPcJMpxx5wtgj7ObjV35x7BEGtVRFwuowT0Ov2XnjkKMM4qDYe+wRZrp26eaxR9jNj2z7+7FHmOnpO48ce4Td/PM+W8YeYVA2dDjzvg7dkTuHGmUwb9py+dgj7OYw9h17hJke97L/N/YIu3nS0hFjjzDThXtvru7U0NGuZ/M+CngBcA/41t+0zHzYguaSNLIadq2phQ2V2mNDh2NDpTbV0NGum4HfwuT6fscDLwG+BJy/oJkkFSB73rQqGyo1pm9D7eiqbKjUoBoa2nUxfURmvhG4JTPPzcynAW4NlDaxpZ43rcqGSo3p21A7uiobKjWohoZ2PQHZLdN/fzUiHg18BTh8MSNJKsFSBZcjqIgNlRpjQwdlQ6UG1dDRrovp346IQ4DnAa8FDgaeu7CpJI2uhpM+VMSGSo2xoYOyoVKDauho1928Hw9EZn4mMx8KPAL4scWNJWlsNRynUhEbKjXGY6YHZUOlBtXQ0K7vTJ+UmVcv38nMKyPi5AXNJKkAHr83KBsqNcaGDsqGSg2qoaNdF9NbIuKwzLwKICIO7/G5kipUw641FbGhUmNs6KBsqNSgGjraNUSvBM6LiLdP7z8eeNliRpJUgvLzVRUbKjXGhg7KhkoNqqGjnRbTmXlWRGznW5ch+PHMvGBxY0kaWw271tTChkrtsaHDsaFSm2roaOddZKbRMlxSI2rYtaYmNlRqiw0dlg2V2lNDRz3eRNJM5edLksplQyVpPjV01MW0pJlq2LVGkkplQyVpPjV01MW0pJmyiu2BklQmGypJ86mhoy6mJc1Uw9ZASSqVDZWk+dTQURfTkmaq4aQPklQqGypJ86mhoy6mJc1Ufr4kqVw2VJLmU0NHXUxLmqmGrYGSVCobKknzqaGjqy6mI+I+q308Mz827DiSSlHDcSqls6FSu2zoMOyo1K4aOrrWO9OvnP57X+AU4JNAACcB24EHLG40SWPaWcHWwArYUKlRNnQwdlRqVA0d3bLaBzPzoZn5UOCrwH0y85TMvC9wMnDZnj4vIrZFxPaI2L60dP2wE0vaENnzH+1uiIb+5/V7fJqkgvVtqB2dbYiOXnPj1zdqXEkDqqGhqy6mV7hbZn56+U5mfgb4rj09OTPPmMbulC1bDph3RkkjWOp506rW3dDbH3D0hgwoaVh9G2pH17Tujh6y75EbMqCkYdXQ0K4nIPtURPwJ8OfT+z8FfGoxI0kqwVL6LsmAbKjUGBs6ODsqNaaGjnZdTD8VeAbwnOn99wGvX8hEkopQfr6qYkOlxtjQwdlRqTE1dLTTYjozb4yINwDnZOYXFjyTpALUcDmCWthQqT02dFh2VGpPDR3tdMx0RDwG+ATwj9P7946Isxc5mKRx1XDSh1rYUKk9noBsWHZUak8NDe16ArIXA6cCVwNk5ieA4xc1lKTx1XDSh4rYUKkxnoBscHZUakwNDe16zPQtmXlNRKx8zE2o0iZWw641FbGhUmNs6ODsqNSYGjradTH92Yj4SWBrRJwA/BLwocWNJWls7nI4KBsqNcbwo2IKAAAWw0lEQVSGDs6OSo2poaNdd/N+NnAP4CbgrcC1wHMXNZSk8S1i15qIOC0ivhARF0bEC2d8/Fci4oKI+FRE/EtE3HGIn6UANlRqzCJ28264oWBHpebU8Fq069m8bwB+Y3qT1IAc+Np+EbEVeB3wCOBS4PyIODszL1jxtI8Dp2TmDRHxDODlwE8MOsgIbKjUHhs6LDsqtaeGjnZaTEfEO9n9uJRrgO3AH2Xmjd1/DEk1WMBxKqcCF2bmRQAR8TbgscCtAcvM96x4/r8BTx56iDHYUKk9NnRYdlRqTw0d7bqb90XAN4A/nt6uBa4D7jq9L2mT6btrTURsi4jtK27bdvmSRwOXrLh/6fSxPXk68A9D/CwFsKFSY9azm/caHW25oWBHpebU8Fq06wnIHpiZ91tx/50RcX5m3i8iPtvxa0iqSN+TPmTmGcAZQ3zviHgycArw/UN8vQLYUKkx6zlxzlAd3YQNBTsqNaeG16JdF9MHRsRxmXnx9IsfBxw4/djN655SUrEWsGvNZcCxK+4fM33sNiLiB5gcE/f9mXnT0EOMxIZKjbGhg7OjUmNq6GjXxfTzgA9ExBeBAI4HfjEiDgDO7Pg1JFVk6JM+AOcDJ0TE8UzC9UTgJ1c+ISJOBv4IOC0zLx96gBHZUKkxNnRwdlRqTA0d7Xo273Om1/S7+/ShL6w40cPvdxxeUkW6XmKgq8zcERHPAt4FbAXelJmfjYiXAtsz82zgFUzeaXh7RABcnJmPGXiUDWdDpfbY0GHZUak9NXS06zvTACcAdwP2Be4VEWTmWev8WSQVbj3H+635NTPPAc7Z5bEXrfj1Dwz+TcthQ6WG2NCFsKNSQ2roaNdLY70YeAhw4vSbPxL4AGDApE1qAcepNMuGSu2xocOyo1J7auho10tjnQ48HPjPzHwqcC/gkIVNJWl0mdnrplXZUKkxfRtqR9dkR6XG1NDQrrt535iZSxGxIyIOBi7ntmdCq8ol13197BFmOvnIu4w9wm4+/vUvjj3CTNu//u9jj7Cb/fe+3dgjDKqGrYEVWXdDv32vAxY72TpctuO6sUeY6S57Hzr2CLv54i1Xjz3CTF/Ye+wJdnfPpX3HHmFQNnRw6+7o0bc7bLGTrcOVO64fe4Td3HevI8YeYabPRXn/z7li69gTzPadt8TYIwyqho6uuZiOyZHXn4qIQ4E/Bj4KfAM4b8GzSRrRIo5TaZENldpkQ4djR6U21dDRNRfTmZkRcWpmXg28ISL+ETg4Mz+1+PEkjWWnuxwOwoZKbbKhw7GjUptq6GjX3bw/FhH3y8zzM/NLixxIUhlq2LWmIjZUaowNHZwdlRpTQ0e7LqbvD/xURHwZuB4IJhsKT1rYZJJGVUPAKmJDpcbY0MHZUakxNXS062L6hxY6haTieGbZQdlQqTE2dHB2VGpMDR3ttJjOzC8vehBJZalha2AtbKjUHhs6LDsqtaeGjnZ9Z1pSY2o4g6IklcqGStJ8auioi2lJM9Wwa40klcqGStJ8auioi2lJM9Wwa40klcqGStJ8auioi2lJM9WwNVCSSmVDJWk+NXTUxbSkmWrYGihJpbKhkjSfGjrqYlrSTDWc9EGSSmVDJWk+NXTUxbSkmZYq2LVGkkplQyVpPjV01MW0pJlq2BooSaWyoZI0nxo66mJa0kw1bA2UpFLZUEmaTw0ddTEtaaYatgZKUqlsqCTNp4aOupiWNFMNWwMlqVQ2VJLmU0NHXUxLmqmGrYGSVCobKknzqaGjLqYlzVTD1kBJKpUNlaT51NDRTovpiLgd8DjgTis/JzNfupixJI2thq2BtbChUnts6HBsqNSmGjra9Z3pdwDXAB8FblrryRGxDdgGEFsPYcuWA9Y9oKRxZC6NPcJmsu6Gnnz4Sdz5wDsudjpJg7Ohg+rVULhtR0849O7c4YCjFzedpIWooaNdF9PHZOZpXb9oZp4BnAGw1z5Hl79JQdJulirYGliRdTf09Ds+xt8IqUI2dFC9Ggq37ehDjvkBfzOkCtXQ0S0dn/ehiLjnQieRVJTM7HXTqmyo1Ji+DbWjq7KhUoNqaGjXd6a/F3hqRFzEZPeaADIzT1rYZJJGVcPWwIrYUKkxNnRQNlRqUA0d7bqYfiRwGPDg6f33AVcvZCJJRfBdkkHZUKkxNnRQNlRqUA0d7bqb948CbwaOBI6a/voxixpK0vh25lKvm1ZlQ6XG9G2oHV2VDZUaVENDu74z/XTgezLzeoCI+B3gPOC1ixpM0rhq2BpYERsqNcaGDsqGSg2qoaNdF9MB7Fxxf+f0MUmbVA3HqVTEhkqNsaGDsqFSg2roaNfF9J8CH46Iv5ne/1HgjYsZSVIJatgaWBEbKjXGhg7KhkoNqqGjnRbTmfmqiHgvk7MpAjw1Mz++sKkkjW6pgoDVwoZK7bGhw7GhUptq6GjXd6bJzI8BH1vgLJIKUsPWwJrYUKktNnRYNlRqTw0d7byYltSWGo5TkaRS2VBJmk8NHXUxLWmmGrYGSlKpbKgkzaeGjrqYljRTDcepSFKpbKgkzaeGjrqYljRTVrBrjSSVyoZK0nxq6KiLaUkz1bA1UJJKZUMlaT41dNTFtKSZajhORZJKZUMlaT41dHTL2ANIKlP2/KeLiDgtIr4QERdGxAtnfPx2EfEX049/OCLuNPCPJUkbom9Du3TUhkpqSQ2vRV1MS5opM3vd1hIRW4HXAY8ETgSeFBEn7vK0pwNXZeZ3Ar8H/M7AP5YkbYi+DV2rozZUUmtqeC3qYlrSTEMHDDgVuDAzL8rMm4G3AY/d5TmPBc6c/vqvgIdHRAz2Q0nSBhl6MY0NldSYGl6LLvyY6R03XzZYxCNiW2aeMdTXG0KJM0GZc5U4E5Q5Vwkz3dLz725EbAO2rXjojF1+hqOBS1bcvxS4/y5f5tbnZOaOiLgGOAL4ep9ZNpO/+vLZm7qhUOZcJc4EZc5V4kww/lx9GwprdtSGrtN7L333IB0d+8/UnpQ4V4kzQZlzlTgTlDFXDa9Fa3tnetvaT9lwJc4EZc5V4kxQ5lwlzrSqzDwjM09ZcSvufwwq9s9ViXOVOBOUOVeJM0G5c+2RHS1eqX+mSpyrxJmgzLlKnAnKnWuPxmhobYtpSfW6DDh2xf1jpo/NfE5E7AUcAlyxIdNJUtlsqCTNZ/COupiWtFHOB06IiOMjYh/gicDZuzznbOBnp78+HfjXrOG6CJK0eDZUkuYzeEdru850ibs7lTgTlDlXiTNBmXOVONNcpsedPAt4F7AVeFNmfjYiXgpsz8yzgTcCb46IC4ErmUROwyn1z1WJc5U4E5Q5V4kzQblzrYsNLUKpf6ZKnKvEmaDMuUqcCcqda90W0dFwg6UkSZIkSf24m7ckSZIkST25mJYkSZIkqScX0z1FxI9EhP/dJGmd7KgkrZ8NlcpR9F/EiLhrRPxLRHxmev+kiPjNkcf6CeDfI+LlEXH3kWcpWkRsjYi3jD2H1KpCGwp2tBMbKo3LhtbNhmojFH0Csog4F3g+8EeZefL0sc9k5nePPNfBwJOApwIJ/Cnw1sy8bsSZjgJ+DrgTK87SnplPG2smgIj4APCwzLx5zDlWioiXA78NfBP4R+Ak4Jcz889HnuudTP48rXQNsJ3J34EbN34q1azUhk7nKKqjNrQfO6oW2NDeMxXXURvaey4b2lPR70wD+2fmR3Z5bMcok6yQmdcCfwW8DfgO4MeAj0XEs0cc6x1MLir+buDvV9zGdhHwwYj4HxHxK8u3kWf6wenv4Q8DXwK+k8n/LMd2EfAN4I+nt2uB64C7Tu9LfRXZUCiyoza0HzuqFtjQfkrsqA3tx4b2VPp1pr8eEXdhuoUkIk4HvjrmQBHxGCZbAb8TOAs4NTMvj4j9gQuA14402v6Z+d9H+t6r+eL0tgU4aORZli3/uX808PbMvCYixpxn2QMz834r7r8zIs7PzPtFxGdHm0o1K66h0zlK7KgN7ceOqgU2tJ8SO2pD+7GhPZW+mH4mkwuG3z0iLgP+A3jyuCPxOOD3MvN9Kx/MzBsi4ukjzQTwdxHxqMw8Z8QZdpOZLwGIiP0z84ax55n6u4j4PJNda54x3S2phN1WDoyI4zLzYoCIOA44cPqxonZPUjVKbCiU2VEb2o8dVQtsaD/FddSG9mZDeyr6mOllEXEAsGXM40BWiog7Aidk5rsjYj9grxGP87uOyRbTAA4AbgJumd7PzDx4jLmWRcQDgDcCB2bmcRFxL+DnM/MXR57rcOCazNw53ZJ7cGb+58gzPQp4A5MtqAEcD/wi8F7g5zLz98ebTjUrraFQTkdt6PrZUbXChq45S7EdtaG9Z7KhPRW9mI6I2zHZ+nYnbnsig5eOONPPAduAwzPzLhFxAvCGzHz4WDOVLCI+DJwOnF3SyTsi4ruBE4F9lx/LzLPGm2hi+md++cycX/BED5pHiQ0FO9pHqQ2dzmFHtanZ0PrZ0P5saD+l7+b9DiZnkPsok61cJXgmcCrwYYDM/PeI+LZxR4KIuM+Mh68BvpyZo54sIzMv2eU4kJ1jzQIQES8GHsIkYOcAjwQ+wOS4o7Hdl2/9T/teEVFEWFWtEhsKBXbUhvZjR9UIG9pDqR21ob3Z0B5KX0wfk5mnjT3ELm7KzJuX/1JGxF7sfgr5MfwhcB/g09P79wQ+AxwSEc/IzH8aaa5LIuKBQEbE3sBzgM+NNMuy04F7AR/PzKdGxLcDo16KACAi3gzcBfgE3wp9UkZYVacSGwpldtSG9mNH1QIb2k+JHbWhPdjQ/kpfTH8oIu6ZmZ9e+6kb5tyI+HVgv4h4BJPjCN458kwAXwGenpmfBYiIE4GXAi8A/hoY64XgLwCvBo4GLpvO8cyRZll2Y2YuRcSOmFyn8XLg2JFnAjgFODFLPvZCtSmxoVBmR21oP3ZULbCh/ZTYURvajw3tqcjFdER8BlhiMt9TI+IiJrvXLJ/I4KQRx3sh8HQmW91+nsmuGX8y4jzL7rocL4DMvCAi7p6ZF8WIp9rPzK8DPzXaALOdHxGHMrle3keZXE/vvHFHAiZbb29PAZfdUN0KbyiU2VEb2o8d1aZlQ9etuI7a0N5saE9FnoAsIq4C7r2nj2fmlzdwnCpExF8AVwJvmz70E8CRwE8DH8jbXjNuI+c6E3hOZl49vX8Y8MrMfNoY80xn+HPgXOD9TC5DcHBmfmqseZZFxHuY/Ln/CCuOzcrMx4w2lKpkQ/uzob3nsqPatGzo+pTYURvajw3tr9TF9Mcyc9ZJDEYXEQ8Cfgu4I5MtlstbKe888lz7MdnN53unD32QybErNwL7Z+Y3Rprr48tnT1ztsQ2e6aHAg6e3uwAfB96Xma8ea6bpXN8/6/HMPHejZ1HdSm4olNlRG9qPHdVmZkPXPVdxHbWhveeyoT2Vupi+FHjVnj6emXv82KLF5ALrv8xkl4xbzwaYmVeMNVPJIuKTwEMy86rp/cOBczPzniPPtRW4H/BQJsfTfDMz7776Zy3e9AQUy1tuP5KZl485j+pUckPBjvZRakOns9hRbUo2dPOwof3Z0H6KPGYa2AocyGRLW2muycx/GHuIXUXEfzDjTI5jb6UEXgmcFxFvZ/L7eTrwsjEHioh/AQ5gcmzK+4H7lRCKiHgC8ArgvUz+W702Ip6fmX816mCqUckNhQI7akP7saPa5GzoOhTaURvagw3tr9R3povdvSYi/jeTyP41tz2W4GOjDQVExBEr7u4LPB44PDNfNNJIt4qIezDZ6gbwr5l5wcjz/B6Ta+jdxGQXpPcB52XmN0ee65PAI5ZjGhFHAe/OzHuNOZfqU3JDocyO2tB+7Kg2Mxu6PqV21Ib2msuG9lTqYnr0Yxn2ZHpg/q4yMx+24cOsISI+mpn3LWCOrcC3s2JPiMy8eLyJJiLiIOApwK8Ct8/M2408z6dX7nYUEVuAT5awK5LqUnJDoZ6O2tC12VFtRjZ0OCV01Ib2mseG9lTqbt4PH3uAWaZ/oF6fmX859iy7ioiVW1C3MLlO3Oi/vxHxbODFwNeYHNcTTHYBGu2yEhHxLCYnfLgv8CXgTUx2sRnbP0bEu4C3Tu//BJPLXUh9FdlQKLejNrT3XHZUm5kNXYcSO2pDe7OhPRX5znTJImJ7Zp4y9hy72mUr5Q4mfzF/NzO/MM5EExFxIXD/kk6KERG/yiRYH83MHWPPs1JEPA540PTu+zPzb8acR1qEEjtqQ/uxo9J4SmwolNlRG9qfDe3HxXRP0+NUvg78BXD98uOZeeVoQxVsGtZHlBYKSeOxo93ZUEm7sqHd2VAtmovpnqZnKtxVCdf2O4TJbizfN33oXOClmXnNeFNBRLwRuBvw99z2JBmjXlaiJBFxHTPOfgm3Xjfy4A0eSVqoEjtqQ+tmR9WSEhsKZXbUhnZjQ9dv9OPBapOZx489wx68CfgM8ITp/Z8G/hT48dEmmrh4ettnetMuMvOgsWeQNlKhHbWhFbOjakmhDYUyO2pDO7Ch6+c70z1FxM/Mejwzz9roWVaKiE9k5r3XekySxlZiR22opFqU2FCwo2qT70z3d78Vv96XyRkfPwaMGjDgmxHxvZn5AYCIeBAw6rXqpnMcBbwAuAeT/14AlHj5BkkbpsSO2lBJtSixoVBgR22oFs3FdE+Z+eyV9yPiUOBtI42z0i8AZ02PVwG4CvjZEedZ9hYmJ8j4YSYz/izwX6NOJGlUhXbUhkqqQqENhTI7akO1UC6m53c9MOqxK9NrDt4tM+8VEQcDZOa1Y860whGZ+caIeE5mngucGxHnjz2UpKKM2lEbKqlyvhbdMxuqhXIx3VNEvJNvne1uK/BdwF+ONxFk5lJEvAD4y0LCtdIt039/NSIeDXwFOHzEeSSNrLSO2lBJNSmtoVB0R22oFsoTkPUUEd+/4u4O4MuZeelY8ywr9ZqDEfHDTC5KfyzwWuBg4Lcy851jziVpPCV21IZKqkWJDYUyO2pDtWguptchIr6db5384SOZefmY80DR1xw8E3hOZl49vX848LuZ+bQx55I0rtI6akMl1aS0hkKZHbWhWjQX0z1FxBOAVwDvZXIh8wcDz8/MvxpzrlJFxMcz8+S1HpPUDjvanQ2VtCsb2p0N1aJ5zHR/vwHcb3kL4PSU++8GRg9YRDwQuBMrfl/HvuYgsCUiDsvMq+DWLYL+uZPaVmRHbaikShTZ0OkspXXUhmqh/MPU35ZddqW5Atgy1jDLIuLNwF2ATwA7pw8n419z8JXAeRHx9un9xwMvG3EeSeMrrqM2VFJFimsoFNtRG6qFcjfvniLiFcBJwFunDz0R+FRmvmC8qSAiPgecmAX+hkbEicDDpnf/NTMvGHMeSeMqsaM2VFItSmwolNtRG6pFcjG9DhHx48CDpnffn5l/O+Y8ANMtbr+UmV8dexZJWktpHbWhkmpSWkPBjqpNLqY7iogPZOb3RsR1THZZiRUfXgKuBF6RmX+4wXMtX2vwIODewEeAm5Y/npmP2ch5JGlPSuyoDZVUixIbOp3LjqpZLqYHEhFHAB/KzLtt8Pf9fiYx/R1g5e49AfxOZt5/I+eRpPUao6M2VNJm4WtRaeN5ArKBZOYVEfGQEb7vuQARsffyr5dFxH4bPY8krdcYHbWhkjYLX4tKG8/F9IDGOEYkIp4B/CJw54j41IoPHQR8cKPnkaR5bHRHbaikzcTXotLGcjfvykXEIcBhwP8CXrjiQ9dl5pXjTCVJdbChkjQfO6qWuZiWJEmSJKmn0S/wLkmSJElSbVxMS5IkSZLUk4tpSZIkSZJ6cjEtSZIkSVJPLqYlSZIkSerp/wciXguzOUZ5QAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1008x288 with 6 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplots(figsize=(14,4))\n",
    "plt.tight_layout()\n",
    "plt.subplot(131)\n",
    "sns.heatmap(1-cdist(ws_d0[0], ws_d0[1], 'cosine'), yticklabels=tokens1[:6], xticklabels=tokens2[:6], vmin=0, vmax=1)\n",
    "\n",
    "plt.subplot(132)\n",
    "sns.heatmap(1-cdist(ws_d1[0], ws_d1[1], 'cosine'), yticklabels=tokens1[:6], xticklabels=tokens2[:6], vmin=0, vmax=1)\n",
    "\n",
    "plt.subplot(133)\n",
    "sns.heatmap(1-cdist(ws_d2[0], ws_d2[1], 'cosine'), yticklabels=tokens1[:6], xticklabels=tokens2[:6], vmin=0, vmax=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.03195305364545267, 0.25118495995725143)"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1-cdist(ws_d0[0], ws_d0[1], 'cosine')).mean(), (1-cdist(ws_d2[0], ws_d2[1], 'cosine')).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Early Rule-based solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_text(phrase):\n",
    "    return ' '.join([w['text'].text for w in phrase if w['pos'] != 'PUNCT'])\n",
    "\n",
    "def chunk(simile):\n",
    "        \n",
    "    # determine the subject and the object of the simile\n",
    "    syntax = {'subject': [], 'object': []}\n",
    "    \n",
    "    key = 'subject'\n",
    "    comparator = ''\n",
    "    tokens = []\n",
    "    \n",
    "    for w, vec in zip(n, empty_tensor):\n",
    "        if w.text == 'like':\n",
    "            comparator = 'like'\n",
    "            key = 'object'\n",
    "            \n",
    "        if w.text == 'as' and comparator == 'as':\n",
    "            comparator = 'as...as'\n",
    "            \n",
    "        if w.text == 'as' and comparator == '':\n",
    "            comparator = 'as'\n",
    "            key = 'object'\n",
    "        \n",
    "        # store the word text, its POS, and its vector\n",
    "        syntax[key].append({'text': w, 'pos': w.pos_, 'vec': vec})\n",
    "                    \n",
    "    tenor = None\n",
    "    ground = None\n",
    "    vehicle = None\n",
    "    event = None\n",
    "    tenor_vec = None\n",
    "    ground_vec = None\n",
    "    vehicle_vec = None\n",
    "    event_vec = None\n",
    "    \n",
    "#     return syntax\n",
    "    \n",
    "    if comparator == 'as...as':\n",
    "        \n",
    "        text_parts = {'ground': [], 'vehicle': []}\n",
    "        vec_parts = {'ground': [], 'vehicle': []}\n",
    "        \n",
    "        key = 'ground'\n",
    "        for w in syntax['object'][1:]:\n",
    "            if w['text'].text == 'as':\n",
    "                key = 'vehicle'\n",
    "                continue\n",
    "                \n",
    "            text_parts[key].append(w)\n",
    "            vec_parts[key].append()\n",
    "        \n",
    "        \n",
    "        if syntax['subject'][-1]['pos'] == 'VERB':\n",
    "            event = syntax['subject'][-1]['text']\n",
    "            tenor = get_text(syntax['subject'][:-1])\n",
    "        else:\n",
    "            tenor = get_text(syntax['subject'])\n",
    "            \n",
    "        ground = get_text(parts['ground']) # good\n",
    "        vehicle = get_text(parts['vehicle']) # good\n",
    "                \n",
    "    elif comparator == 'like':\n",
    "        parts = {'tenor': [], 'event': []}\n",
    "        \n",
    "        key = 'event'\n",
    "        for w in syntax['subject'][::-1]:\n",
    "            parts[key].append(w)\n",
    "            if w['pos'] == 'VERB':\n",
    "                key = 'tenor'\n",
    "                \n",
    "        if not parts['tenor']:\n",
    "            event_verbs = [1 for e in parts['event'] if e['pos'] == 'VERB']\n",
    "            if sum(event_verbs) == 0:\n",
    "                parts['tenor'] = parts['event']\n",
    "                parts['event'] = []\n",
    "        \n",
    "        tenor = get_text(parts['tenor'][::-1])\n",
    "        event = get_text(parts['event'][::-1])\n",
    "        vehicle = get_text(syntax['object'][1:])\n",
    "            \n",
    "    elif comparator == 'as':\n",
    "        \n",
    "        nnp = 0\n",
    "        for i, w in enumerate(syntax['subject'][::-1]):\n",
    "            if i > 0 and w['pos'] in ['NOUN', 'PUNCT'] and syntax['subject'][-i]['pos'] in ['ADJ', 'ADV']:\n",
    "                nnp = i\n",
    "                                \n",
    "        if nnp > 0:\n",
    "            ground = get_text(syntax['subject'][-nnp:])\n",
    "            tenor = syntax['subject'][:-nnp]\n",
    "        else:\n",
    "            tenor = syntax['subject']\n",
    "            \n",
    "        if tenor[0]['pos'] == 'VERB':\n",
    "            event = tenor[0]['text']\n",
    "            tenor = tenor[1:]\n",
    "        elif tenor[-1]['pos'] == 'VERB':\n",
    "            event = tenor[-1]['text']\n",
    "            tenor = tenor[:-1]\n",
    "            \n",
    "        tenor = get_text(tenor)\n",
    "            \n",
    "        vehicle = get_text(syntax['object'][1:])\n",
    "        \n",
    "    return {'tenor': tenor, 'ground': ground, 'vehicle': vehicle, 'event': event, 'comparator': comparator}"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}