1. Language features.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "\n",
    "tqdm.pandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Morphosyntactic and discourse parsing "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "data = pd.read_csv('data/train_all.tsv', sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of classes: 4\n",
      "class weights:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.166, 0.324, 0.844, 1.   ])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# label1_weights\n",
    "counts = data.masks_stance.value_counts(normalize=False).values\n",
    "NUMBER_CLASSES = len(counts)\n",
    "print(\"number of classes:\", NUMBER_CLASSES)\n",
    "print(\"class weights:\")\n",
    "np.round(counts.min() / counts, decimals=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of classes: 4\n",
      "class weights:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.095, 0.138, 0.997, 1.   ])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# label2_weights\n",
    "counts = data.masks_argument.value_counts(normalize=False).values\n",
    "NUMBER_CLASSES = len(counts)\n",
    "print(\"number of classes:\", NUMBER_CLASSES)\n",
    "print(\"class weights:\")\n",
    "np.round(counts.min() / counts, decimals=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of classes: 4\n",
      "class weights:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.074, 0.432, 0.895, 1.   ])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# label1_weights\n",
    "counts = data.vaccines_stance.value_counts(normalize=False).values\n",
    "NUMBER_CLASSES = len(counts)\n",
    "print(\"number of classes:\", NUMBER_CLASSES)\n",
    "print(\"class weights:\")\n",
    "np.round(counts.min() / counts, decimals=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of classes: 4\n",
      "class weights:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.029, 0.12 , 0.55 , 1.   ])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# label2_weights\n",
    "counts = data.vaccines_argument.value_counts(normalize=False).values\n",
    "NUMBER_CLASSES = len(counts)\n",
    "print(\"number of classes:\", NUMBER_CLASSES)\n",
    "print(\"class weights:\")\n",
    "np.round(counts.min() / counts, decimals=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of classes: 4\n",
      "class weights:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.037, 0.128, 0.293, 1.   ])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# label1_weights\n",
    "counts = data.quarantine_stance.value_counts(normalize=False).values\n",
    "NUMBER_CLASSES = len(counts)\n",
    "print(\"number of classes:\", NUMBER_CLASSES)\n",
    "print(\"class weights:\")\n",
    "np.round(counts.min() / counts, decimals=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of classes: 4\n",
      "class weights:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0.028, 0.072, 0.585, 1.   ])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# label2_weights\n",
    "counts = data.quarantine_argument.value_counts(normalize=False).values\n",
    "NUMBER_CLASSES = len(counts)\n",
    "print(\"number of classes:\", NUMBER_CLASSES)\n",
    "print(\"class weights:\")\n",
    "np.round(counts.min() / counts, decimals=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from isanlp import PipelineCommon\n",
    "from isanlp.processor_remote import ProcessorRemote\n",
    "from isanlp.ru.processor_mystem import ProcessorMystem\n",
    "from isanlp.ru.converter_mystem_to_ud import ConverterMystemToUd\n",
    "from isanlp.processor_razdel import ProcessorRazdel\n",
    "from isanlp.annotation_rst import ForestExporter\n",
    "\n",
    "SERVER0 = ''  # <- server address\n",
    "address_syntax = (SERVER0, 3144)  # <- address of the syntax parser\n",
    "address_rst = (SERVER0, 3335)  # <- address of the rst parser\n",
    "\n",
    "ppl_tok = PipelineCommon([\n",
    "    (ProcessorRazdel(), ['text'],\n",
    "    {'tokens': 'tokens',\n",
    "     'sentences': 'sentences'})])\n",
    "\n",
    "def tokenize(text):\n",
    "    return ' '.join([tok.text for tok in ppl_tok(text)['tokens']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "ppl = PipelineCommon([\n",
    "    (ProcessorRazdel(), ['text'],\n",
    "    {'tokens': 'tokens',\n",
    "     'sentences': 'sentences'}),\n",
    "    (ProcessorRemote(address_syntax[0], address_syntax[1], '0'),\n",
    "     ['tokens', 'sentences'],\n",
    "     {'lemma': 'lemma',\n",
    "      'syntax_dep_tree': 'syntax_dep_tree',\n",
    "      'postag': 'ud_postag'}),\n",
    "    (ProcessorMystem(delay_init=False),\n",
    "     ['tokens', 'sentences'],\n",
    "     {'postag': 'postag'}),\n",
    "    (ConverterMystemToUd(),\n",
    "     ['postag'],\n",
    "     {'morph': 'morph',\n",
    "      'postag': 'postag'}),\n",
    "    (ProcessorRemote(address_rst[0], address_rst[1], 'default'),\n",
    "     ['text', 'tokens', 'sentences', 'postag', 'morph', 'lemma', 'syntax_dep_tree'],\n",
    "     {'rst': 'rst'})\n",
    "])\n",
    "\n",
    "rs3exp = ForestExporter('utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": [],
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "res = ppl(tokenize(data.text.iloc[0].replace('[USER],', '').replace('[USER]', '').replace(' -', ' - ').replace('  ', ' ')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id: 4\n",
      "text: согласно предписаниям Роспотребнадзора , все транзитные пассажиры , следующие через Москву , должны пройти 14-дневный карантин у себя по месту жительства .\n",
      "proba: 1.0\n",
      "relation: attribution\n",
      "nuclearity: SN\n",
      "left: согласно предписаниям Роспотребнадзора ,\n",
      "right: все транзитные пассажиры , следующие через Москву , должны пройти 14-дневный карантин у себя по месту жительства .\n",
      "start: 0\n",
      "end: 155\n"
     ]
    }
   ],
   "source": [
    "print(res['rst'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 87%|████████▋ | 5870/6717 [2:32:35<24:42,  1.75s/it]   "
     ]
    }
   ],
   "source": [
    "data['annot'] = data.text.progress_map(lambda row: ppl(tokenize(row.replace('[USER],', '').replace(\n",
    "    '[USER]', '').replace(' -', ' - ').replace('  ', ' '))))\n",
    "data.to_pickle('data/train.annotated.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1431/1431 [37:49<00:00,  1.59s/it] \n"
     ]
    }
   ],
   "source": [
    "dev = pd.read_csv('data/val_empty.tsv', sep='\\t')\n",
    "dev['annot'] = dev.text.progress_map(lambda row: ppl(tokenize(row.replace('[USER],', '').replace(\n",
    "    '[USER]', '').replace(' -', ' - ').replace('  ', ' '))))\n",
    "dev.to_pickle('data/dev.annotated.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1402/1402 [32:56<00:00,  1.41s/it] \n"
     ]
    }
   ],
   "source": [
    "test = pd.read_csv('data/test-no_labels.tsv', sep='\\t')\n",
    "test['annot'] = test.text.progress_map(lambda row: ppl(tokenize(row.replace('[USER],', '').replace(\n",
    "    '[USER]', '').replace(' -', ' - ').replace('  ', ' '))))\n",
    "test.to_pickle('data/test.annotated.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### RST exploration "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train = pd.read_pickle('data/train.annotated.pkl')\n",
    "dev = pd.read_pickle('data/dev.annotated.pkl')\n",
    "test = pd.read_pickle('data/test.annotated.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train['tokens'] = train.annot.map(lambda row: ' '.join([tok.text for tok in row['tokens']]))\n",
    "dev['tokens'] = dev.annot.map(lambda row: ' '.join([tok.text for tok in row['tokens']]))\n",
    "test['tokens'] = test.annot.map(lambda row: ' '.join([tok.text for tok in row['tokens']]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def count_edus(tree):\n",
    "    if tree.relation == 'elementary':\n",
    "        return 1\n",
    "    return count_edus(tree.left) + count_edus(tree.right)\n",
    "\n",
    "train['length_edu'] = train.annot.map(lambda row: count_edus(row['rst'][0]))\n",
    "dev['length_edu'] = dev.annot.map(lambda row: count_edus(row['rst'][0]))\n",
    "test['length_edu'] = test.annot.map(lambda row: count_edus(row['rst'][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true,
    "tags": [],
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/.pyenv/versions/3.7.4/lib/python3.7/site-packages/numpy/core/fromnumeric.py:3208: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  return asarray(a).size\n",
      "/opt/.pyenv/versions/3.7.4/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:1426: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  X = np.atleast_1d(X.T if isinstance(X, np.ndarray) else np.asarray(X))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use('seaborn-deep')\n",
    "f = plt.figure(figsize=(8,3))\n",
    "\n",
    "col = 'length_edu'\n",
    "bins = np.linspace(1, 20, 20)\n",
    "\n",
    "w_train = np.ones_like(train[col])/float(len(train[col]))\n",
    "w_dev = np.ones_like(dev[col])/float(len(dev[col]))\n",
    "w_test = np.ones_like(test[col])/float(len(test[col]))\n",
    "\n",
    "plt.hist([train[col], dev[col], test[col]], \n",
    "         bins, density=False, alpha=.9, stacked=False, \n",
    "         weights=[w_train, w_dev, w_test], #rwidth=2.,\n",
    "         label=['train', 'dev', 'test'], align='mid')\n",
    "plt.legend(loc='upper right')\n",
    "plt.xticks(range(1, 20))\n",
    "plt.xlabel('Number of elementary discourse units')\n",
    "plt.gca().set_yticklabels(['{:.1f}'.format(x*100) for x in plt.gca().get_yticks()]) \n",
    "plt.ylabel('Percentage of subset, %')\n",
    "\n",
    "f.savefig(\"length distribution.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train = train[train[col] < 10]\n",
    "\n",
    "train_for = train[(train.masks_stance == 2) | (train.vaccines_stance == 2) | (train.quarantine_stance == 2)]\n",
    "train_against = train[(train.masks_stance == 0) | (train.vaccines_stance == 0) | (train.quarantine_stance == 0)]\n",
    "train_other = train[(train.masks_stance == 1) | (train.vaccines_stance == 1) | (train.quarantine_stance == 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/.pyenv/versions/3.7.4/lib/python3.7/site-packages/numpy/core/fromnumeric.py:3208: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  return asarray(a).size\n",
      "/opt/.pyenv/versions/3.7.4/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:1426: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  X = np.atleast_1d(X.T if isinstance(X, np.ndarray) else np.asarray(X))\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVAAAACgCAYAAABaDTR0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3deZwU1bn/8c8XBEcWEcTkCohgZAmyOwpoNCxqvJGgMeCSECHGoOjPiDFEMUYU9f7whij5eUVURIkxKrjiCi7gftnGYUCQIIoRIaJoQCAiy/P745wZm2GWmp7pWZ/369Wv6aquqvN0z8zpU3XqPEdmhnPOubKrV9UBOOdcTeUVqHPOpckrUOecS5NXoM45lyavQJ1zLk1egTrnXJq8AnXOuTR5Beqcc2lKXIFK6ivpeUnzJZ2RyaCcc64mUHEjkST9h5n9M2V5JjACELDAzLpVTojOOVc97VfCa1Ml5QD/bWZfAf8ChgJ7gC2VEZxzzlVnxZ7Cm9kZwNvA05LOA8YA+wMHA34K75yr84o9hS/YQKoPXAwMBm4ys1crI7CyatmypbVr166qw3DO1TJLliz5zMwOKeq1Yk/hJQ0BLgd2Af8F3A/8QdLFwO/NbE0mgk1Xu3btWLx4cVWH4ZyrZSR9WNxrJV0DvRE4FjgAmGNmxwJXSOoA3AScU6FROudcDVNSBboZOBNoBGzMX2lmq/HK0znnSrwP9MeEDqP9gJ9WTjjOOVdzFNsCNbPPgNsqMZZardWfWu21vP6K9Skv7v0a69fjapadO3eybt06vvrqq6oOxaUpKyuLNm3a0KBBg8T7lHQK75xLaN26dTRt2pR27dohqarDcWVkZmzatIl169bRvn37xPt5BVpFZs+eXfB8SBXG4SrGV1995ZVnDSaJgw8+mE8//bRM+3kyEecqiFeeNVs6v78yV6CSXpT0nKTBZS7NOedqkXRO4c8DDgX6VnAsztUahTsNy2uvTseEJk+ezKhRo2jUqFGFxpKuHTt2cNppp/HZZ58xbtw4zj777KoOqdxKbYFKuix12czWA98zs9szFpVzrtwmT57M9u3bqzqMAm+//TYAubm5iSvP3bt3ZzKkcktyCj+iiHUjS9tJUpakhZKWSnpH0vVxfXtJCyS9J+lhSQ2L2X9c3GaVpB8kiNO5Omvbtm2cdtpp9OjRg65du3L99dezfv16BgwYwIABAwAYPXo02dnZHHXUUYwfP75g33bt2jF+/Hh69+5Nt27dePfddwHYunUrv/jFL+jWrRvdu3fn0UcfBWDu3Ln069eP3r17M2zYMLZu3VpqfBs3bmT48OEsWrSInj17smbNGl566SV69epFt27dOP/889mxY0dBPFdeeSW9e/dm1qxZFf1RVahiK1BJ50p6CmgvaXbKYx7weYJj7wAGmlkPoCdwqqS+wM3ArWZ2JPAF8Msiyu5CGO10FHAqMCUmNXHOFeH555+nVatWLF26lOXLlzNmzBhatWrFvHnzmDdvHgA33XQTixcvJi8vj1deeYW8vLyC/Vu2bElOTg6jR49m0qRJANxwww00a9aMZcuWkZeXx8CBA/nss8+48cYbefHFF8nJySE7O5tbbrkFgMsvv5yePXvu85g4cSLf+ta3mDZtGieccAK5ubm0bt2akSNH8vDDD7Ns2TJ27drFHXfcURDPwQcfTE5ODuecU70HPZZ0DfRNYAPQEvhTyvovgbwi90hhIc1T/ldTg/gwYCDfjGyaAVwH3FFo99OBh8xsB/CBpPcI4/LfKq1c5+qibt26ccUVV3DllVcyePBgTjjhhH22mTlzJnfddRe7du1iw4YNrFixgu7duwNw5plnAnD00Ufz2GOPAfDiiy/y0EMPFezfvHlznn76aVasWMHxxx8PwNdff02/fv0AuPXWWxPHu2rVKtq3b0/Hjh0BGDFiBLfffjtjxowBqDHXR0saifQh8CHQT9LhQAcze1HSAYQEI1+WdvDYalwCHAncDqwB/mVmu+Im64DWRezaGvjflOXitnPOAR07diQnJ4dnn32Wa665hkGDBu31+gcffMCkSZNYtGgRzZs3Z+TIkXuNmtp///0BqF+/Prt27aI4ZsbJJ5/Mgw8+uM9rl19+eUFrN9U555zDVVddVab307hx4zJtX1VK7YWX9CtgFNAC+A7QBpgKDCppPwAz2w30lHQQ8DjQuVzR7hvbqBgbbdu2rchDO1ejrF+/nhYtWjB8+HAOOuggpk2bRtOmTfnyyy9p2bIlW7ZsoXHjxjRr1oxPPvmE5557jv79+5d4zJNPPpnbb7+dyZMnA/DFF1/Qt29fLrnkEt577z2OPPJItm3bxscff0zHjh3L1ALt1KkTa9euLTjO/fffz/e///3yfARVIsltTJcQTp8XQMjGJOlbZSnEzP4Vr532Aw6StF9shbYBPi5il4+Bw1KWi9zOzO4C7gLIzs4uOTO0c5UonduOymPZsmWMHTuWevXq0aBBA+644w7eeustTj311IJrob169aJz584cdthhBafgJbnmmmu45JJL6Nq1K/Xr12f8+PGceeaZ3HfffZx77rkFnT433nhjwal4UllZWdx7770MGzaMXbt2ccwxx3DRRRel9d6rUpKM9AvMrI+kt82sl6T9gBwz617KfocAO2PleQAwl9CBNAJ41MwekjQVyDOzKYX2PQr4G6HibgW8RLiEUOw9DdnZ2VbehMp7Da8cUrEDLAvfFzi1w9Rvyir8h+PJRGqclStX8t3vfreqw3DlVNTvUdISM8suavskLdBXJF0NHCDpZML0Hk8l2O9QYEa8DloPmGlmT0taATwk6UbCnEv3xCCHANlmdq2ZvRNnAV1ByIh/SUmVp3POVYUkFehVhFuNlgEXAs8C00rbyczygF5FrH+f0LIsvH42MDtl+SZC5nvnnKuWSq1AzWwPcDdwt6QWQBsr7bzfOefqgCRDOedLOjBWnksIFWny7jbnnKulkgzlbGZmWwjzI/3FzPqQ4BYm55yr7ZJUoPtJOhQ4C3g6w/E451yNkaQTaQIwB3jDzBZJOgJYndmwnKvZUm+Jqwjp3FZX3dLZFWf+/Pk0bNiQ4447DoCRI0cyePBghg4dWsWRla7UFqiZzTKz7mY2Oi6/b2Y/yXxozrnyqG7p7Iozf/583nzzzQo5lpmxZ8+eCjlWEkk6kY6Q9JSkTyVtlPRkbIU656qJ6p7ODuDzzz/njDPOoHv37vTt25e8vDzWrl3L1KlTufXWW+nZsyevvfYaAK+++irHHXccRxxxBI888kjBMf74xz9yzDHH0L1794L3sHbtWjp16sR5551H165d+eijj8r/gSaU5BT+b4REID+Oy+cADwJ9MhWUc65s8tPZPfPMMwBs3ryZe++9l3nz5tGyZUsgpLNr0aIFu3fvZtCgQeTl5RVkY8pPZzdlyhQmTZrEtGnT9kpnB2EsfGo6u8aNG3PzzTdzyy23cO2115aaTGT8+PH06tWLJ554gpdffpnzzjuP3NxcLrroIpo0acJvf/tbAO655x42bNjA66+/zrvvvsuQIUMYOnQoc+fOZfXq1SxcuBAzY8iQIbz66qu0bduW1atXM2PGDPr2rdyJMpJUoI3M7P6U5b9KGpupgJxzZVcT0tm9/vrrBa3YgQMHsmnTJrZs2VLktmeccQb16tWjS5cufPLJJ0Bo+c6dO5devcL4nK1bt7J69Wratm3L4YcfXumVJ5RQgcb7PgGek3QV8BAhn+fZhNFIzrlqorals8uPJ7/M/J/jxo3jwgsv3GvbtWvXVln6u5KugS4BFhNuX7oQmAfMB0YTKlHnXDWxfv16GjVqxPDhwxk7diw5OTkF6eyAItPZlSY/nV2+/HR2b7zxBu+99x4Qrr3+/e9/B0ILNDc3d59HfuV5wgkn8MADDwCh46hly5YceOCBe8VZkh/84AdMnz694Jrrxx9/zMaNG8vwKVW8khIqt6/MQJyrTSo6m1dpakI6u+uuu47zzz+f7t2706hRI2bMmAHAj370I4YOHcqTTz7JbbfdVuz+p5xyCitXriy4ZNCkSRP++te/Ur9+1c32kySd3XlFrTezv2QkojR5OjtXlTydXe2QiXR2x6Q8zyIM48wBqlUF6pxzlS1JNqZLU5fj9BwPFbN57dFq7xajtwqdc4UlGQtf2DbAr4865+q8JJPKPUW4fQlChdsFmJnJoFz5FL7eWtnz8zhXVyS5Bjop5fku4EMzW5eheJxzrsZIUoEuBv5tZnskdQR6S/rEzHZmODbnnKvWklSgrwInSGpOmFlzEeFG+p9lMjDnarTCnZDllUYnZk1JZ5eOCy64gN/85jd06dKlTPvl5uayfv16fvjDH1ZIHEk6kWRm2wkZ6aeY2TDgqAop3TmXMTUlnV06pk2bVubKE0IF+uyzFTcSPVEFKqkfocX5TFxXdbf+O+f2URPS2S1cuJB+/frRq1cvjjvuOFatWgXA9u3bOeuss+jSpQs//vGP6dOnD/mDYoqLuX///gXbNGnShN///vf06NGDvn37FiQfmTVrFl27dqVHjx6ceOKJfP3111x77bU8/PDD9OzZk4cffrg8HzmQrAK9DBgHPB7naz+CMC6+RJIOkzRP0gpJ70i6LK5vIekFSavjz+bF7D8ibrNa0oiyvCnn6pr8dHZLly5l+fLljBkzpmAIZ36Cj5tuuonFixeTl5fHK6+8Ql5eXsH++ensRo8ezaRJod84NZ1dXl4eAwcO3CudXU5ODtnZ2dxyyy1ASCbSs2fPfR4TJ04EoHPnzrz22mu8/fbbTJgwgauvvhqAKVOm0Lx5c1asWMENN9zAkiVLCuIqKeZ827Zto2/fvixdupQTTzyRu+++G4AJEyYwZ84cli5dyuzZs2nYsCETJkzg7LPPJjc3l7PPLn9KjyQ30r9KuA6av/w+8OsEx94FXGFmOZKaAkskvQCMBF4ys4kxy9NVwJWpO8ZMUOOBbMItVEskzTazL5K9LefqlpqQzm7z5s2MGDGC1atXI4mdO0M/9Ouvv85ll10GQNeuXQtiKi3mfA0bNmTw4MEF8b/wwgsAHH/88YwcOZKzzjqr4P1VtCSdSGkxsw3Ahvj8S0krgdbA6UD/uNkMQoanKwvt/gPgBTP7HCBWvKcSEjk75wqpCens/vCHPzBgwAAef/xx1q5dS//+/Ut8T6XFnK9BgwZI2if+qVOnsmDBAp555hmOPvrovVq2FSWdkUhlJqkd0AtYAHw7Vq4A/wS+XcQurYHUvPzr4jrnXBFqQjq7zZs307p1+De+7777Co57/PHHM3NmGJuzYsWKggz46cScas2aNfTp04cJEyZwyCGH8NFHHyVOnZdUSQmVbzazKyUNM7NZ6RYgqQnwKDDGzLbkf1MAmJlJKjkdVMnHHgWMAmjbtm26h3Gu4lVy7oSakM7ud7/7HSNGjODGG2/ktNNOK1h/8cUXM2LECLp06ULnzp056qijaNasGR06dChzzKnGjh3L6tWrMTMGDRpEjx49aNu2LRMnTqRnz56MGzeu3NdBi01nJ2kZ0B1YYma90zq41IAwl/wcM7slrlsF9DezDXG++flm1qnQfufGbS6My3fG7Yo9ha/wdHYVnGKuMtPZ+VDOyufp7NK3e/dudu7cSVZWFmvWrOGkk05i1apVNGzYsNJjqch0ds8DXwBNJG0BROjQEaHxeGBJgSg0Ne8BVuZXntFsYAQwMf58sojd5wD/ldJDfwrhTgDnXC2zfft2BgwYwM6dOzEzpkyZUiWVZzpKykg/Fhgr6UkzOz2NYx8P/BxYJik3rruaUHHOlPRL4EPClCFIygYuMrMLzOxzSTcQRj0BTMjvUHLl5Gn6XDXTtGlTynv2WFWS3MZ0uqRv801i5QVm9mmC/V4ntFaLMqjwCjNbDFyQsjwdmF5aOa50e12aqMI4ajszI/Uav6tZSpudoyil9sJLGgYsBIYRWosLJQ0tc0nO1WJZWVls2rQprX9CV/XMjE2bNpGVlVWm/ZLcB3oNcIyZbQSQdAjwIvBImaN0rpZq06YN69at49NPSz05c9VUVlYWbdq0KdM+SSrQevmVZ7SJSrp/1LmaokGDBrRv7xM11DVJKtDnJc3hm1FAZwMVl86kCpV0a5FzzpUmSSfSWElnAt+Lq+4ys8czG5ZzzlV/icbCm9ljwGMZjsU552oUv5bpnHNp8grUOefSlKgClXSApE6lb+mcc3VHkhvpfwTkEsbGI6mnpNkl7+Wcc7VfkhbodcCxwL8AzCwX8BvenHN1XpIKdKeZbS60zserOefqvCS3Mb0j6adAfUkdCPMhvZnZsJxzrvpL0gK9lDAP/A7CaKQtwJhMBuWcczVBkpFI24Hfx4dzzrmo1ApU0lPse81zM7AYuNPM9p0mzznn6oAkp/DvA1uBu+NjC/Al0DEuO+dcnZSkE+k4MzsmZfkpSYvM7BhJ72QqMOecq+6SVKBNJLU1s38ASGoLNImvfZ2xyFyN4DOAurosSQV6BfC6pDWEOY7aAxdLagzMyGRwzjlXnSXphX823v/ZOa5aldJxNDljkTnnXDWXKB8o0AHoBGQBPSRhZn/JXFjOOVf9JUkmMh64LT4GAP9NgtlxJU2XtFHS8pR1LSS9IGl1/Nm8mH1HxG1WSxqR+N0451wlSnIb01DCPO7/NLNfAD2AZgn2uw84tdC6q4CXzKwD8FJc3oukFsB4oA8hicn44ipa55yrSkkq0H+b2R5gl6QDgY3AYaXtZGavAp8XWn0633Q8zQDOKGLXHwAvmNnnZvYF8AL7VsSuJmjVau+Hc7VMkmugiyUdRLhpfgnhpvq30izv22a2IT7/J/DtIrZpDXyUsrwurnPOuWolSS/8xfHpVEnPAweaWV55CzYzk1SutHiSRgGjANq2bVvekJxzrkySjIV/ycwGAZjZ2sLryugTSYea2QZJhxIuBxT2MdA/ZbkNML+og5nZXcBdANnZ2Z6jtBqYPfubyQpK7Wl0roYr9hqopKzYodNSUvPYg95CUjvSP6WeDeT3qo8AniximznAKbHM5sApcZ1zzlUrJbVALyTk/WxFuPapuH4L8D+lHVjSg4SWZEtJ6wg96xOBmZJ+CXwInBW3zQYuMrMLzOxzSTcAi+KhJphZ4c4o55yrcsVWoGb2Z+DPki41s9vKemAzO7eYl/Y59TezxcAFKcvTgellLdM55ypTkk6k2yQdB7RL3d5HIjnn6roknUj3A98hTG28O642wCtQ51ydluQ+0Gygi5l5L7dzzqVIMhJpOfAfmQ7EOedqmiQt0JbACkkLCTNzAmBmfpufc65OS1KBXpfpIJxzriZK0gv/iqTDgQ5m9qKkRkD9zIfm3N58+hBX3STJB/or4BHgzriqNfBEJoNyzrmaIMkp/CWEvJwLAMxstaRvZTQq58qqcLq89d46dZmXpBd+h5kVzL4paT/CfaDOOVenJalAX5F0NXCApJOBWcBTmQ3LOeeqvyQV6FXAp8AyQoKRZ4FrMhmUc87VBEmugR4ATDezuwEk1Y/rtmcyMOdK47lHXVVL0gJ9iVBh5jsAeDEz4TjnXM2RpALNMrOt+QvxeaPMheScczVDklP4bZJ6m1kOgKSjgX9nNiznqjG/ZcpFSSrQy4BZktYTstL/B3B2RqNyror5qCeXRIkVqKR6QEOgM9Aprl5lZjszHZhzzlV3JVagZrZH0u1m1ouQ1s65Osl7/F1REvXCS/qJJJW+qXPO1R1JroFeCPwG2C3p34TroGZmB2Y0MufqiBKvt3qHVbWWJJ1d08oIxDmXeamVtXeMlV+SSeUE/Axob2Y3SDoMONTMFqZbqKRTgT8T8opOM7OJhV7fnzBp3dHAJuBsM1ubbnnO1SRVdr3VW7tlluQUfgqwBxgI3ABsBW4HjkmnwDgU9HbgZGAdsEjSbDNbkbLZL4EvzOxISecAN+O3TjlXoVIraqj4yrrE1m4tqayTdCL1MbNLgK8AzOwLwq1N6ToWeM/M3o9p8h4CTi+0zenAjPj8EWCQd2I556qbJC3QnbHVaACSDiG0SNPVGvgoZXkd0Ke4bcxsl6TNwMHAZ+Uo1zlXRTLd2q0qKm26d0k/I5w+9ya0CocC15jZrLQKlIYCp5rZBXH554RW7v9J2WZ53GZdXF4Tt/ms0LFGAaPiYidgVRlCaUnlVsiVXV5VlOnvsXaUWRfeY1kcbmaHFPVCkl74ByQtAQYRbmE6w8xWliOYj4HDUpbbxHVFbbMuZsBvRuhMKhzbXcBd6QQhabGZZaezb00oryrK9PdYO8qsC++xohRbgUrKAi4CjiQkU77TzHZVQJmLgA6S2hMqynOAnxbaZjYwAniL0OJ92UprKjvnXCUrqQU6A9gJvAb8J/BdYEx5C4zXNP8PMIdwG9N0M3tH0gRgsZnNBu4B7pf0HvA5oZJ1zrlqpaQKtIuZdQOQdA+Q9n2fhZnZs4SpQVLXXZvy/CtgWEWVV4y0Tv1rUHlVUaa/x9pRZl14jxWi2E4kSTlm1ru4Zeecq+tKqkB3A9vyF/lmHiQfC++cc5RwI72Z1TezA+OjqZntl/K8xlaekqZL2hhvlaqM8g6TNE/SCknvSLosw+VlSVooaWks7/pMlpdSbn1Jb0t6upLKWytpmaRcSYsrqcyDJD0i6V1JKyX1y2BZneJ7y39skVTuPogE5V4e/26WS3owdiZnsrzLYlnvVMb7q2il3gda20g6kTAc9S9m1rUSyjuUkDsgR1JTYAnhVrAVpeyabnkCGpvZVkkNgNeBy8zsfzNRXkq5vwGygQPNbHAmy4rlrQWyC98bnOEyZwCvmdk0SQ2BRmb2r0ootz7hjpU+ZvZhBstpTfh76WJm/5Y0E3jWzO7LUHldCSMRjwW+Bp4HLjKz9zJRXiYkGcpZq5jZq4Se/coqb0P+fFJm9iWwkjDSKlPlWcokgA3iI6PfkpLaAKcB0zJZTlWS1Aw4kXCHCGb2dWVUntEgYE0mK88U+wEHxPuvGwGZHKT+XWCBmW2Pt0i+ApyZwfIqXJ2rQKuSpHZAL2BBhsupLykX2Ai8YGYZLQ+YDPyO8g3xLSsD5kpaEkekZVp74FPg3nipYpqkxpVQLoTb+B7MdCFm9jEwCfgHsAHYbGZzM1jkcuAESQdLagT8kL0H2VR7XoFWEklNgEeBMWa2JZNlmdluM+tJGOV1bDxVyghJg4GNZrYkU2UU43vxrpD/BC6Jl2YyaT/CcOY74hQ324CrMlwm8VLBECCtodNlLKs5IZFPe6AV0FjS8EyVF0c03gzMJZy+5wK7M1VeJngFWgnitchHgQfM7LHKKjeeYs4DTs1gMccDQ+I1yYeAgZL+msHygILWEma2EXiccB0tk9YB61Ja848QKtRM+08gx8w+qYSyTgI+MLNP48SRjwHHZbJAM7vHzI42sxOBL4C/Z7K8iuYVaIbFTp17gJVmdksllHeIpIPi8wMIeVffzVR5ZjbOzNqYWTvCqebLZpaxVguApMaxQ454Gn0KGZ700Mz+CXwkKX922kFARjoCCzmXSjh9j/4B9JXUKP7dDiJcs88YSd+KP9sSrn/+LZPlVbQk6exqFUkPAv2BlpLWAePN7J4MFnk88HNgWbwuCXB1HI2VCYcCM2LPbT1gpplVyq1FlejbwOMxRex+wN/M7PlKKPdS4IF4Wv0+8ItMFha/HE4mzEuWcWa2QNIjQA6wC3ibzI8QelTSwYRh45dUYsdchahztzE551xF8VN455xLk1egzjmXJq9AnXMuTV6BOudcmrwCdc65NHkFWoUkmaQ/pSz/VtJ1FXTs+xQm8MsoScNiZqJ5Zdhna+lbZYakqyupnP75makkDZGU8VFLVU3Sm/FnO0mFp+mplbwCrVo7gDMltazqQFLFRBJJ/RL4lZkNyFQ8FazMFWi8pzZtZjbbzCaW5xhlVcbfYYUws/xRS+3Yd56zWskr0Kq1i3Cj8uWFXyjcgsxvtcWWzSuSnpT0vqSJkn4Wc4Auk/SdlMOcJGmxpL/HMev5iUb+KGmRpDxJF6Yc9zVJsylihI2kc+Pxl0u6Oa67FvgecI+kPxaxz9iUcorMS1rUNrEF8278DP4u6QFJJ0l6Q9JqScfG7Ror5HddGBN8nB7Xj5T0mKTn4/b/HddPJGQaypX0QFz3RExI8k5qUhJJWyX9SdJS4PeSnkh57WRJjxfxXk6NceeQklUoxvM/8fmw+BkulfRqyu9kUlyfJ+nSuH5QfF/L4vvcP65fm/+lKylb0vz4/DpJ90t6gzCn2FHxs8mNx+0Qtxuesv7Oor4gSiljuqT58e/v16mfWXw6kZAkJFchv2iRcdQKZuaPKnoQ8pIeCKwlTN38W+C6+Np9wNDUbePP/sC/CCOO9ifkibw+vnYZMDll/+cJX5IdCGO5s4BRwDVxm/2BxYTkEf0JCTLaFxFnK8Iwv0MII39eJuQ0BZhPyMtZeJ9TCF8OijE8DZxY6L0UuQ2hBbML6BbXLwGmx+1OB56I+/8XMDw+P4gwjroxMJIwUqhZfM8fAoellp0SZ4v48wDCcNCD47IBZ8XnIgyHPSQu/w34UaHjZAEfxc9awEzg6fjaSOB/4vNlQOv8mOPP0YSx9fvlx5RyvI5x3V8IiWgg/L20jM+zgfnx+XXxszogLt8G/Cw+bxjf43eBp4AGcf0U4Lwifn8llfEm4W+nJWG68Qapny3hb+nplGPtE0dV/+9V1MNboFXMQmamvwC/Lm3bFIss5BndAawhZLOB8M/ZLmW7mWa2x8xWEyqUzoRK6zyFYaULgIMJ//QAC83sgyLKO4bwD/SphbyNDxAqupKcEh9vE4YGdk4pJ8k2H5jZMjPbA7wDvGThPzD1PZ4CXBXfy3xCpdM2vvaSmW22MEHhCuDwYuL8dWxl/i8hlVp++bsJCWCI5d4PDFfIM9APeK7QcTrHmFfH7YtLqPIGcJ+kXxFmpYWQxKNg2nAz+xzoFI+Xn1xjBqV/5gCzzezf8flbwNWSrgQOj+sHAUcDi+LnNgg4IsFxUz1jZjssJLPeSBhaW5Ki4qgV6txY+GpqMqECuTdl3S7iJRZJ9Qjf3Pl2pDzfk7K8h71/p4XH6RqhdXSpmc1JfUFSf76ZA6siCPi/ZnZnWbdRyO1/ORsAAAJOSURBVJua5D0K+ImZrSq0f59C+++miL/1+J5PAvqZ2fZ4mpo/hcVXZpaaWu1eQsvtK2BWfmVXVmZ2UYzvNGCJpKPTOEzB30ZKvPkKfodm9jdJC2JZz8bLNQJmmNm4cpRR6mebqqg4zOzlUsqvEbwFWg3EFsdMQodMvrWElgKEfJAN0jj0MEn1FK6LHgGsAuYAoxVS7CGpo0pPDLwQ+L6klvF62bmE7OElmQOcr5AHFUmtFTPvlHGb0sq4VApZRST1SrDPzvz3TjjF/yJWnp2BvsXtZGbrCdnZr2HvL7p87wLt9M016HOLOo6k75jZAgvTeH9KaPW+AFyo2PEjqQXhd9VO0pFx15/zzWe+lm/+Nn5SXMySjgDeN7P/BzwJdAdeAobqmyxILSQV1TpPVEYxvgSalhJHreAVaPXxJ8I1pXx3EyqtpYRTxnRah/8gVH7PEeaa+Yow7cYKIEdhYr07Kb0FsYGQPHgesBRYYmZPlrLPXMK1wrckLSNc42ta1m1KcQPhiyVP0jtxuTR3xe0fIFwj3k/SSkLHR2nzRj0AfGQhEfBe4mc7CngmdiJtLOYYf4ydQssJ1xKXEn4n/4hxLQV+Go/3C2BW/Gz2AFPjMa4H/qwwmV5JCYjPApbHU/WuhHnAVhC+BOZKyiNU3ocWsW/SMoqSB+yOHWWXFxVHGY9XbXk2JucSij3pb1tm0x+6GsQrUOcSkLSEcBZwcuy8c84rUOecS5dfA3XOuTR5Beqcc2nyCtQ559LkFahzzqXJK1DnnEuTV6DOOZem/w9tBPSZunFD+QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 360x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use('seaborn-deep')\n",
    "f = plt.figure(figsize=(5,2))\n",
    "\n",
    "col = 'length_edu'\n",
    "bins = np.linspace(1, 10, 20)\n",
    "\n",
    "w_train_for = np.ones_like(train_for[col])/float(len(train_for[col]))\n",
    "w_train_against = np.ones_like(train_against[col])/float(len(train_against[col]))\n",
    "w_train_other = np.ones_like(train_other[col])/float(len(train_other[col]))\n",
    "\n",
    "plt.hist([train_for[col], train_other[col], train_against[col]], \n",
    "         bins, density=False, alpha=.9, stacked=False, \n",
    "         weights=[w_train_for, w_train_other, w_train_against],\n",
    "         label=['stance=for', 'stance=other', 'stance=against'], align='mid', color=['green', 'darkgrey', 'red'])\n",
    "plt.legend(loc='upper right')\n",
    "plt.xticks(range(1, 10))\n",
    "plt.xlabel('Number of elementary discourse units')\n",
    "plt.gca().set_yticklabels(['{:.1f}'.format(x*100) for x in plt.gca().get_yticks()]) \n",
    "plt.ylabel('Percentage of subset, %')\n",
    "\n",
    "f.savefig(\"length distribution by stance.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train_for = train[(train.masks_argument == 2) | (train.vaccines_argument == 2) | (train.quarantine_argument == 2)]\n",
    "train_against = train[(train.masks_argument == 0) | (train.vaccines_argument == 0) | (train.quarantine_argument == 0)]\n",
    "train_other = train[(train.masks_argument == 1) | (train.vaccines_argument == 1) | (train.quarantine_argument == 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/.pyenv/versions/3.7.4/lib/python3.7/site-packages/numpy/core/fromnumeric.py:3208: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  return asarray(a).size\n",
      "/opt/.pyenv/versions/3.7.4/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:1426: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  X = np.atleast_1d(X.T if isinstance(X, np.ndarray) else np.asarray(X))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x144 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.style.use('seaborn-deep')\n",
    "f = plt.figure(figsize=(5,2))\n",
    "\n",
    "col = 'length_edu'\n",
    "bins = np.linspace(1, 10, 20)\n",
    "\n",
    "w_train_for = np.ones_like(train_for[col])/float(len(train_for[col]))\n",
    "w_train_against = np.ones_like(train_against[col])/float(len(train_against[col]))\n",
    "w_train_other = np.ones_like(train_other[col])/float(len(train_other[col]))\n",
    "\n",
    "plt.hist([train_for[col], train_other[col], train_against[col]], \n",
    "         bins, density=False, alpha=.9, stacked=False, \n",
    "         weights=[w_train_for, w_train_other, w_train_against],\n",
    "         label=['premise=for', 'premise=other', 'premise=against'], align='mid', color=['green', 'darkgrey', 'red'])\n",
    "plt.legend(loc='upper right')\n",
    "plt.xticks(range(1, 10))\n",
    "plt.xlabel('Number of elementary discourse units')\n",
    "plt.gca().set_yticklabels(['{:.1f}'.format(x*100) for x in plt.gca().get_yticks()]) \n",
    "plt.ylabel('Percentage of subset, %')\n",
    "\n",
    "f.savefig(\"length distribution by argument.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "labels = ['attribution_NS', 'attribution_SN', 'background_NS',\n",
    "          'cause-effect_NS', 'cause-effect_SN',\n",
    "          'comparison_NN', 'concession_NS', 'condition_NS', 'condition_SN',\n",
    "          'contrast_NN', 'elaboration_NS', 'evidence_NS',\n",
    "          'interpretation-evaluation_NS', 'interpretation-evaluation_SN',\n",
    "          'joint_NN', 'preparation_SN', 'purpose_NS', 'purpose_SN',\n",
    "          'restatement_NN', 'same-unit_NN', 'sequence_NN', 'solutionhood_SN']\n",
    "\n",
    "\n",
    "def extract_pairs(tree):\n",
    "    result = []\n",
    "    if tree.relation != 'elementary':\n",
    "        result = [[tree.left.text, tree.right.text, tree.relation, tree.nuclearity]]\n",
    "        result += extract_pairs(tree.left)\n",
    "        result += extract_pairs(tree.right)\n",
    "    return result\n",
    "\n",
    "def discourse_relations(tree):\n",
    "    pairs = extract_pairs(tree)\n",
    "    result = dict()\n",
    "    if pairs:\n",
    "        for label in labels:\n",
    "            relation = label.split('_')[0]\n",
    "            if not relation + '_N' in result:\n",
    "                for pair in pairs:\n",
    "                    if pair[2] == relation:\n",
    "                        if pair[3] == 'SN':\n",
    "                            result[relation + '_S'] = pair[0]\n",
    "                            result[relation + '_N'] = pair[1]\n",
    "                        elif pair[3] == 'NS':\n",
    "                            result[relation + '_S'] = pair[1]\n",
    "                            result[relation + '_N'] = pair[0]\n",
    "                        else:\n",
    "                            result[relation + '_N'] = pair[0] + ' ' + pair[1]\n",
    "    else:\n",
    "        result['EDU'] = tree.text \n",
    "                    \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6717/6717 [00:00<00:00, 82738.80it/s]\n"
     ]
    }
   ],
   "source": [
    "train['rst_relations'] = train.annot.progress_map(lambda row: discourse_relations(row['rst'][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9550/9550 [00:00<00:00, 87121.15it/s]\n"
     ]
    }
   ],
   "source": [
    "_all['rst_relations'] = _all.annot.progress_map(lambda row: discourse_relations(row['rst'][0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[USER], надеемся, что в других регионах не придется вводить настолько жесткие меры по карантину\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'EDU': 'надеемся , что в других регионах не придется вводить настолько жесткие меры по карантину'}"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 7\n",
    "print(train.iloc[n]['text'])\n",
    "train.iloc[n]['rst_relations']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from isanlp.annotation_rst import ForestExporter\n",
    "\n",
    "rs3exp = ForestExporter('utf8')\n",
    "rs3exp(train.iloc[n]['annot']['rst'], 'вот_и_выходит.rs3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6717/6717 [00:00<00:00, 209376.99it/s]\n"
     ]
    }
   ],
   "source": [
    "def extract_pairs_forest(trees):\n",
    "    result = []\n",
    "    for tree in trees:\n",
    "        result += extract_pairs(tree)\n",
    "    return result\n",
    "\n",
    "train['all_pairs'] = train.annot.progress_map(lambda row: extract_pairs_forest(row['rst']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "ar = [value for row in train['all_pairs'] for value in row]\n",
    "all_relations = sorted(list(set([row[2] for row in ar])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "relations = train[train.masks_stance == 0].all_pairs.map(lambda row: [value[2] for value in row])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x320 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "\n",
    "f = figure(figsize=(8, 4), dpi=80)\n",
    "\n",
    "relations = train[train.masks_stance == 0].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_0 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_0)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_0 = [value / len(masks_stance_0) for value in values]\n",
    "\n",
    "relations = train[train.masks_stance == 1].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_1 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_1)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_1 = [value / len(masks_stance_1) for value in values]\n",
    "\n",
    "relations = train[train.masks_stance == 2].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_2 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_2)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_2 = [value / len(masks_stance_2) for value in values]\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "indexes = np.arange(len(all_relations))\n",
    "b0 = ax.bar(indexes-0.2, y_0, width=0.2, color='tab:red', align='center')\n",
    "b1 = ax.bar(indexes, y_1, width=0.2, color='silver', align='center')\n",
    "b2 = ax.bar(indexes+0.2, y_2, width=0.2, color='green', align='center')\n",
    "\n",
    "ax.legend((b0, b1, b2), ('mask:stance=against', 'mask:stance=other', 'mask:stance=for'))\n",
    "plt.xticks(indexes, all_relations, rotation=90)\n",
    "plt.show()\n",
    "f.savefig(\"disgraph_mask_stance.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x320 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "\n",
    "f = figure(figsize=(8, 4), dpi=80)\n",
    "\n",
    "relations = train[train.masks_argument == 0].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_0 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_0)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_0 = [value / len(masks_stance_0) for value in values]\n",
    "\n",
    "relations = train[train.masks_argument == 1].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_1 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_1)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_1 = [value / len(masks_stance_1) for value in values]\n",
    "\n",
    "relations = train[train.masks_argument == 2].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_2 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_2)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_2 = [value / len(masks_stance_2) for value in values]\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "indexes = np.arange(len(all_relations))\n",
    "b0 = ax.bar(indexes-0.2, y_0, width=0.2, color='tab:red', align='center')\n",
    "b1 = ax.bar(indexes, y_1, width=0.2, color='silver', align='center')\n",
    "b2 = ax.bar(indexes+0.2, y_2, width=0.2, color='green', align='center')\n",
    "\n",
    "ax.legend((b0, b1, b2), ('mask:argument=against', 'mask:argument=other', 'mask:argument=for'))\n",
    "plt.xticks(indexes, all_relations, rotation=90)\n",
    "plt.show()\n",
    "f.savefig(\"disgraph_mask_argument.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x320 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "\n",
    "f = figure(figsize=(8, 4), dpi=80)\n",
    "\n",
    "relations = train[train.quarantine_stance == 0].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_0 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_0)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_0 = [value / len(masks_stance_0) for value in values]\n",
    "\n",
    "relations = train[train.quarantine_stance == 1].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_1 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_1)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_1 = [value / len(masks_stance_1) for value in values]\n",
    "\n",
    "relations = train[train.quarantine_stance == 2].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_2 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_2)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_2 = [value / len(masks_stance_2) for value in values]\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "indexes = np.arange(len(all_relations))\n",
    "b0 = ax.bar(indexes-0.2, y_0, width=0.2, color='tab:red', align='center')\n",
    "b1 = ax.bar(indexes, y_1, width=0.2, color='silver', align='center')\n",
    "b2 = ax.bar(indexes+0.2, y_2, width=0.2, color='green', align='center')\n",
    "\n",
    "ax.legend((b0, b1, b2), ('quarantine:stance=against', 'quarantine:stance=other', 'quarantine:stance=for'))\n",
    "plt.xticks(indexes, all_relations, rotation=90)\n",
    "plt.show()\n",
    "f.savefig(\"disgraph_quarantine_stance.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x320 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "\n",
    "f = figure(figsize=(8, 4), dpi=80)\n",
    "\n",
    "relations = train[train.quarantine_argument == 0].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_0 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_0)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_0 = [value / len(masks_stance_0) for value in values]\n",
    "\n",
    "relations = train[train.quarantine_argument == 1].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_1 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_1)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_1 = [value / len(masks_stance_1) for value in values]\n",
    "\n",
    "relations = train[train.quarantine_argument == 2].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_2 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_2)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_2 = [value / len(masks_stance_2) for value in values]\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "indexes = np.arange(len(all_relations))\n",
    "b0 = ax.bar(indexes-0.2, y_0, width=0.2, color='tab:red', align='center')\n",
    "b1 = ax.bar(indexes, y_1, width=0.2, color='silver', align='center')\n",
    "b2 = ax.bar(indexes+0.2, y_2, width=0.2, color='green', align='center')\n",
    "\n",
    "ax.legend((b0, b1, b2), ('quarantine:argument=against', 'quarantine:argument=other', 'quarantine:argument=for'))\n",
    "plt.xticks(indexes, all_relations, rotation=90)\n",
    "plt.show()\n",
    "f.savefig(\"disgraph_quarantine_argument.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x320 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "\n",
    "f = figure(figsize=(8, 4), dpi=80)\n",
    "\n",
    "relations = train[train.vaccines_stance == 0].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_0 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_0)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_0 = [value / len(masks_stance_0) for value in values]\n",
    "\n",
    "relations = train[train.vaccines_stance == 1].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_1 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_1)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_1 = [value / len(masks_stance_1) for value in values]\n",
    "\n",
    "relations = train[train.vaccines_stance == 2].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_2 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_2)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_2 = [value / len(masks_stance_2) for value in values]\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "indexes = np.arange(len(all_relations))\n",
    "b0 = ax.bar(indexes-0.2, y_0, width=0.2, color='tab:red', align='center')\n",
    "b1 = ax.bar(indexes, y_1, width=0.2, color='silver', align='center')\n",
    "b2 = ax.bar(indexes+0.2, y_2, width=0.2, color='green', align='center')\n",
    "\n",
    "ax.legend((b0, b1, b2), ('vaccines:stance=against', 'vaccines:stance=other', 'vaccines:stance=for'))\n",
    "plt.xticks(indexes, all_relations, rotation=90)\n",
    "plt.show()\n",
    "f.savefig(\"disgraph_vaccines_stance.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiAAAAGVCAYAAADHZkpHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAMTQAADE0B0s6tTgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzde3xU5bX/8c+CIFgDUS4tWkCsEatcEiBBpAqWWtT+KFVUtOcIoqjw41erR8zBo1i0hSLSghYrWK2AtdaKcDgcpFqx4NGCikpqW5U7RaQ9WOQqiSGwfn/sPcMkTCDA7J0L3/frNS+YPXvP2nPJzJrnWc/zmLsjIiIiEqcGNX0CIiIicvxRAiIiIiKxUwIiIiIisVMCIiIiIrFTAiIiIiKxUwIiIiIiscuq6ROojsaNG3urVq1q+jRERETkCHz88cdl7t443W11IgFp1aoVmzZtqunTEBERkSNgZp9UdZu6YERERCR2SkBEREQkdkpAREREJHZ1ogbkUPbv34/Ws5HjnZnRoIF+T4hI3VHtBMTMzgJmAS2BHcBQd/9rpX3OB6aFVxsBrwPfd/fPw9uHAXcRtLz8ARjp7nuP5sTLysrYuHEje/ce1eEi9U6jRo1o164dJ5xwQk2fiojIYVl1Ww/M7A/AU+4+08yuAka7e2Glfb4A7HX3vWbWAJgD/I+7TzGzM4A/At2A/wX+C3jJ3X9+uNht2rTxyqNg1qxZQ9OmTWnRogVmVq3HIFJfuTtbt25l165d5Obm1vTpiIgAYGYfu3ubdLdVqwXEzL4IFAD9wk1zgEfMLNfd1yT2c/c9KYedAJwIJDKcq4D57v6P8D6nA3cDh01AKtu/fz979+6lRYsWZGXV+V4kkYxo0aIFn376Kfv371d3jIjUetX9lGoL/N3dywE8aDbZCLSrvKOZtTezPwH/JOiqeTS8qR3wt5RdN6Q7PryPO8xsU+Kye/fuCrcnWm3U8iFyQOLvQTVRIlIXZPxnkrtvcPc8oDXQGBh4FPcx2d3bJC7Z2dmZPk0RERGpQdXtv/gIONXMsty93IKfWu0IWkHScvfdZvYs8K/As+G+Z6bs0v5Qxx+ND756TibvLumcDz+I5H6P1Ntvv82kSZP47W9/W9OnUmds376d6dOnc9ddd9X0qTB9+nR27dpFUVHRUR2/ZMkSSktLufTSSzN8ZiIi8atWAuLuW8zsXeA6YCZwJbAptf4DwMxygb+FRagnAFcA74U3zwFeN7P7CIpQRxAkJlJNBQUFtS75KC8vr9V1ONu3b+eBBx6oFQnIiBEjjun4JUuWsH37diUgdZDdf3B3sY9VV5kc346kC2Y4MNzMVhEMpb0BwMyeMLMB4T59gRVhDcgKgkTjRwDuvg4YSzASZg3wCfBYJh5EbTB+/Hi+973vJa/v3r2b5s2b89prr3HBBRfQrVs3zj33XMaNG5fcp6ysjKKiIjp16kReXl6FL5aJEyfSuXNn8vLy6NmzJ3v27GHJkiXk5+cDsGHDBk4++WTGjh1L9+7dyc3NZeHChcnjly9fTt++fSkoKKBr167Mnj0bgE8++YR+/frRuXNnunTpwg033JD28UyePJnCwkLy8/MpLCxk2bJlydvat2/P6NGj6dGjB9dffz0AY8eOJTc3l8LCQsaMGUP79u0rnGfq85Jau2NmjB8/nvPOO4/27dszb948JkyYQEFBAWeddRZLlixJ7vvSSy9xwQUX0L17d3r06MHixYuB4Iu5U6dOjBw5kry8PDp27Mjbb78NBF/6u3btIj8/n4KCgmq8koE///nPVb5uu3bt4pprruGrX/0qF154IcOHD2fo0KGHPe6+++7j9ttvB2DmzJlcfPHFfPe736Vz584UFBSwbt06AFavXs3XvvY18vLy6Ny5M2PGjKG4uJjp06fz61//mvz8fH74wx9W+7GIiNRK7l7rL1/+8pc9VXl5ub///vteXl5eYfv7Z381kkt1bNy40Vu1auWlpaXu7v7kk0/6wIEDfefOnclte/bs8fz8fF+2bJm7u993330+YMCA5O1btmxxd/eZM2d6YWGhb9++3d3dP/30Uy8vL/fFixd7Xl6eu7uvX7/eAX/++efd3f13v/udd+jQwd3dt23b5vn5+b5582Z3d//kk0+8bdu2vmnTJp88ebLfcsstyfPeunWru7t//PHHyftOPRd392XLlvnZZ5+dvH766af7sGHDfP/+/e7uvmDBAu/YsaPv3LnT9+/f70OHDvXTTz89eZ45OTnJY3ft2uXB2y4A+EMPPeTu7osWLfKTTjrJZ8yY4e7uzz33nBcUFLi7+9q1a71nz56+Y8cOd3dfvXq1t27d2ktLS33x4sXesGFDf+ONN9zdfdq0ad6vX7+08d3dH3zwQc/Ly0t7mTt3rrv7IV+3O++806+//nrfv3+/79y50zt16uTXX3/9YY8bO3as33bbbe7uPmPGDG/WrJmvW7fO3d1Hjx6dfF2+//3v+49//OODXqPU49Op6u9Cah73cdBF5HhA0FuS9ru99rad1zFt27ala9euzJ8/n6uvvpqZM2dSVFRESUkJI0eOpLi4mAYNGvDRRx9RXFxMz549WbBgARMnTqRx42Cl4latWgGwYMECRowYQU5ODgCnnHJK2phNmjRh4MCgxvf8889n7dq1ACxdupR169Zx2WWXVdh/5cqV9OzZkylTpjBq1Ch69+6dbHU57bTTKC4uTu67YsUKxo8fz9atW8nKymLlypWUlJRw4oknAjB06NBkS8Yrr7zC1VdfTdOmTQEYNmxYsnWiOq655hog6GL67LPPuPbaawHo0aMHq1evBuDFF19kzZo19O7dO3lcgwYN2LgxKCPKzc3lvPPOSz4XP/nJT6qMV1RUdNg6jEO9bq+88gpTpkzBzGjatCnXXHMNa9asOexxlZ1//vmcccYZyf9PnToVgN69e1NUVMTu3bvp06cPF1988eGfRBGROkYJSAbdeOONzJgxg+7du7NmzRouvfRSRowYQcuWLVmxYgVZWVkMHDiQ0tLSjMRr3LhxMglo2LAh+/btA4JWrY4dO7J06dK0xxUXF7No0SLmzp3Lvffey4oVK2jYsGHy9rKyMgYOHMjixYspLCxk586d5OTk8PnnnycTkEONTErtYsnKykqeF5D2sTdp0iT5GCpfLy8vTz6mb37zmzzzzDMHHf/xxx8nj6l8XDqTJk3i17/+ddrbxo4dyxVXXMHdd99d7dct9fEeyXFVnfOVV15Jr169ePnll3nkkUd46KGHKnSviYjUB5qtKIMuv/xyli9fzoQJE7juuuvIyspi27ZttGnTJtmK8PLLLyf3HzBgAA8//DCff/45ENRnJLZPnz6dHTt2AEEhZeqX+OH06tWL9evXs2jRouS24uJiysrKWL9+PdnZ2QwaNIipU6eyatUqKs+zUlpaSllZGe3aBdO0JH6ZV6Vv377MmTOH3bt34+48+eSTydtat26Nu/P+++8D8NRTT1X7caS65JJLWLRoEe+9915y21tvvXXY45o1a0ZJSQllZWXJbUVFRRQXF6e9XHHFFQCHfN369u3LrFmzcHd2797Nc889l7ztUMdV1+rVq/nSl77EkCFDePDBB3njjTeSjyXxnhARqevqVQtITQ+Xbdy4MYMGDeLRRx/lgw+CcxkzZgyDBw9m1qxZnHnmmfTt2ze5/+jRo7nnnnvo1q0bjRo14rTTTmPhwoUMHjyYzZs306tXL7KysjjppJMqJBOHc8opp/DCCy9w5513MmrUKPbu3Uu7du2YN28eS5YsYfLkyclf3JMmTSInJ4fNmzfzrW99i+LiYpo1a8a4cePo0aMHLVu2THaJVKV///68+eab5Ofnc/LJJ9OnT59k4WlWVhZTp06lf//+tGjRgquuuuoontmgi+WZZ55h+PDh7Nmzh7KyMrp27Zq2RSRV8+bNGTJkCF26dCE7OztZnHo4h3rdfvCDHzBs2DDOOeccWrZsSV5eXvLxHuq46nr++ed5+umnOeGEE9i/fz/Tp08H4IorruBXv/oV+fn5DBw4kB/84AdHfN8iIrVFtdeCqUmV14LZt28fq1atokOHDhW6DqTm7Nq1i6ZNm+LujBo1ipKSEqZNm3b4A+ugvXv3sm/fPpo0acJnn33GJZdcwq233pqsZakp+ruovTQMV45Xx7wWjMjhDBkyhA0bNlBaWkrHjh2Tv9rro23btnHZZZexb98+SktL+c53vsOgQYNq+rREROoUJSCSEf/5n/9Z06cQmy9+8Yu88847NX0aIiJ1mopQRUREJHZKQERERCR2SkBEREQkdkpAREREJHb1qgj11VdfjeR++/TpE8n9ioiIHK/UAlKHvP322zU+10Rds337dh544IGM3ue8efOSs5MCFVYpFhGR6lECUocUFBTw29/+tqZPo4JDrblSG8SRgGRKbX8uRUQySQlIhowfP57vfe97yeu7d++mefPmvPbaa1xwwQV069aNc889l3HjxiX3KSsro6ioiE6dOpGXl5dcmRZg4sSJdO7cmby8PHr27MmePXsq/NLesGEDJ598MmPHjqV79+7k5uZWWLBs+fLl9O3bl4KCArp27crs2bOBYL2Zfv360blzZ7p06cINN9yQ9vFMnjyZwsJC8vPzKSwsZNmyZcnb2rdvz+jRo+nRowfXX389ECzilpubS2FhIWPGjKF9+/YVzjP1eUldvM3MGD9+POeddx7t27dn3rx5TJgwgYKCAs466yyWLFmS3Pell17iggsuoHv37vTo0SO54u6SJUvo1KkTI0eOJC8vj44dOyanXB8xYgS7du0iPz+fgoKCarySgX379iVfm06dOnHrrbdSVlbGwoULmT9/PpMmTSI/P58nnngCCJKHdPEPd94dO3Zk2LBh5OfnH1dzqYiI4O61/vLlL3/ZU5WXl/v777/v5eXlFbYvWbIkkkt1bNy40Vu1auWlpaXu7v7kk0/6wIEDfefOnclte/bs8fz8fF+2bJm7u993330+YMCA5O1btmxxd/eZM2d6YWGhb9++3d3dP/30Uy8vL/fFixd7Xl6eu7uvX7/eAX/++efd3f13v/udd+jQwd3dt23b5vn5+b5582Z3d//kk0+8bdu2vmnTJp88ebLfcsstyfPeunWru7t//PHHyftOPRd392XLlvnZZ5+dvH766af7sGHDfP/+/e7uvmDBAu/YsaPv3LnT9+/f70OHDvXTTz89eZ45OTnJY3ft2uXB2y4A+EMPPeTu7osWLfKTTjrJZ8yY4e7uzz33nBcUFLi7+9q1a71nz56+Y8cOd3dfvXq1t27d2ktLS33x4sXesGFDf+ONN9zdfdq0ad6vX7+08d3dH3zwQc/Ly0t7mTt3rru7P/roo96nTx8vLS31vXv3+mWXXeYPPPCAu7tff/31PmXKlOT9HSr+4c7bzKr9Hjucqv4upOZxHwddRI4HwCav4ru9XhWh1qS2bdvStWtX5s+fz9VXX83MmTMpKiqipKSEkSNHUlxcTIMGDfjoo48oLi6mZ8+eLFiwgIkTJ9K4cWMAWrVqBcCCBQsYMWIEOTk5QLC4XDpNmjRh4MCBAJx//vmsXbsWgKVLl7Ju3Touu+yyCvuvXLmSnj17MmXKFEaNGkXv3r2TrS6nnXYaxcXFyX1XrFjB+PHj2bp1a3Jl15KSEk488UQAhg4dmmzJeOWVV7j66qtp2rQpAMOGDUv+yq+ORF1LQUEBn332WXLxux49erB69WoAXnzxRdasWUPv3r2TxzVo0ICNGzcCwWJ15513XvK5+MlPflJlvKKiIoqKig55TosWLWLo0KHJ1+bmm2/m5z//OaNHj067f1XxD3feX/nKV1TkLCLHJSUgGXTjjTcyY8YMunfvzpo1a7j00ksZMWIELVu2ZMWKFWRlZTFw4EBKS0szEq9x48bJJKBhw4bs27cPCFq1OnbsyNKlS9MeV1xczKJFi5g7dy733nsvK1asqLB4WVlZGQMHDmTx4sUUFhayc+dOcnJy+Pzzz5MJSHZ2dpXnldrFkpWVlTwvIO1jb9KkSfIxVL6eqItwd775zW+mXf32448/Th5T+bh0Jk2axK9//eu0t40dO5YrrrjikI8pnariH+68D/U8iojUZ6oByaDLL7+c5cuXM2HCBK677jqysrLYtm0bbdq0SbYivPzyy8n9BwwYwMMPP8znn38OBPUZie3Tp09nx44dQFBImfolfji9evVi/fr1LFq0KLmtuLiYsrIy1q9fT3Z2NoMGDWLq1KmsWrWK3bt3Vzi+tLSUsrIy2rVrB8DUqVMPGa9v377MmTOH3bt34+48+eSTydtat26Nu/P+++8D8NRTT1X7caS65JJLWLRoEe+9915y21tvvXXY45o1a0ZJSQllZWXJbUVFRRQXF6e9JJKPiy++mKeeeoqysjLKy8t54okn6NevX/I+E69NVOctIlLf1asWkJpuym7cuDGDBg3i0Ucf5YMPPgBgzJgxDB48mFmzZnHmmWfSt2/f5P6jR4/mnnvuoVu3bjRq1IjTTjuNhQsXMnjwYDZv3kyvXr3IysripJNOqpBMHM4pp5zCCy+8wJ133smoUaPYu3cv7dq1Y968eSxZsoTJkycnf6VPmjSJnJwcNm/ezLe+9S2Ki4tp1qwZ48aNo0ePHrRs2TLZJVKV/v378+abb5Kfn8/JJ59Mnz59koWnWVlZTJ06lf79+9OiRQuuuuqqo3hmgy6OZ555huHDh7Nnzx7Kysro2rVr2paFVM2bN2fIkCF06dKF7OzsCsWhh3LLLbewdu1aunXrBsBFF13E7bffDsDgwYMZOnQo8+bN4//9v/9Hbm5uxs9bRKS+s6BGpHZr06aNb9q0KXl93759rFq1ig4dOlToOpCas2vXLpo2bYq7M2rUKEpKSpg2bVpNn9ZxRX8XtZfdf3AXno+t/Z+9IsfKzD529zbpbqtXLSBSc4YMGcKGDRsoLS2lY8eOTJ8+vaZPSUREajElIJIRmsNCRESOhIpQRUREJHZKQERERCR2SkBEREQkdkpAREREJHb1qgg13VC3TKgtw+XefvttJk2aVOtWxK3Ntm/fzvTp07nrrruO+Nhhw4axbNkyzj77bBXZiohkWL1KQOq7goKCWpd8lJeXk5VVe99G27dv54EHHjjiBOR///d/efbZZ9m5c+cRzalR258Pidarr75a06cgUmeoCyZDxo8fz/e+973k9d27d9O8eXNee+01LrjgArp168a5557LuHHjkvuUlZUll3zPy8tLLgwHMHHiRDp37kxeXh49e/Zkz549LFmyhPz8fODAMvdjx46le/fu5ObmsnDhwuTxy5cvp2/fvhQUFNC1a1dmz54NBNO99+vXj86dO9OlSxduuOGGtI9n8uTJFBYWkp+fT2FhIcuWLUve1r59e0aPHk2PHj24/vrrgWANldzcXAoLCxkzZgzt27evcJ6pz0vquipmxvjx4znvvPNo37498+bNY8KECRQUFHDWWWexZMmS5L6HWta+U6dOjBw5kry8PDp27Jic8XTEiBHs2rWL/Px8CgoKqvFKBknL17/+dUpLS+nevTsPPPAA+/btS75WnTp14tZbb01O7z506FBuvPFGevfuTadOnaoVQ0TkeFftn2pmdhYwC2gJ7ACGuvtfK+3TF3gAyAYceAG4y933m1l7YC3w55RDrnT3tcfyAGqLIUOG0L17d37605/SuHFjZs+ezde//nXy8/N55ZVXaNy4MSUlJfTq1YuLL76Ynj17MmHCBFatWsU777xD48aNk2vBzJo1izlz5vD666+Tk5PDtm3bkquyptqxYwddunTh/vvv58UXX+S2227jW9/6Ftu3b+eWW25h4cKFnHrqqfzzn/+kW7du9OrVi+eee44zzjiD3//+9wB8+umnABWmYodguvE77rgDgDfeeIOhQ4fy4YcfJmNv3bqVN998EzPjhRdeYM6cOaxYsYLs7GxuvPHGI3rusrOzefPNN3nllVf4zne+wyOPPMLbb7/N7NmzKSoqYvny5axbt4777ruPl156iWbNmrFmzRouvPBCNmzYAMCHH37IL3/5Sx599FGmT5/OPffcw0svvcT06dPJz8+vsNJvdRajW7hwYYXjpk2bxvLly3nnnXdo2LAhAwYMYMqUKcnVcd955x1ef/315IrAIiJyaEfSVvwY8At3n2lmVwEzgcJK+2wDrnX3dWbWBFgEDAn3Bdjl7vnHdsq1U9u2benatSvz58/n6quvZubMmRQVFVFSUsLIkSMpLi6mQYMGfPTRRxQXF9OzZ08WLFjAxIkTk8lFq1atAFiwYAEjRowgJycHCNZ2SadJkyYMHDgQCJaAX7s2yOWWLl3KunXruOyyyyrsv3LlSnr27MmUKVMYNWoUvXv3Tra6nHbaaRW+pFesWMH48ePZunVrciG9kpKS5Gq4Q4cOTbZkvPLKK1x99dXJL99hw4YlWyeq45prrgGCLqbPPvssufZMjx49WL16NXD4Ze1zc3M577zzks/FT37ykyrjFRUVUVRUVO3zA1i0aBFDhw5NvlY333wzP//5z5MJSOrjFxGRw6tWAmJmXwQKgH7hpjnAI2aW6+5rEvu5+4qU/5eaWTHQPnOnW7vdeOONzJgxg+7du7NmzRouvfRSRowYQcuWLVmxYgVZWVkMHDgw7ZL0R6Nx48bJJKBhw4bJFXPdnY4dO7J06dK0xxUXF7No0SLmzp3Lvffey4oVKyrUOZSVlTFw4EAWL15MYWEhO3fuJCcnh88//zyZgBxqGfnULpasrKwKK/mme+yJpewT55B6vbrL2ieOqXxcOtVpATmc1McIh34+RETkYNWtAWkL/N3dywE8WMFuI9CuqgPMrDVwFbAgZfNJZrbczN41sx+YWdrqPjO7w8w2JS6Vl4uvrS6//HKWL1/OhAkTuO6668jKymLbtm20adMm2Yrw8ssvJ/cfMGAADz/8MJ9//jlAsgtmwIABTJ8+Pbnk+/bt2yt8iR9Or169WL9+fYUVdIuLiykrK2P9+vVkZ2czaNAgpk6dyqpVq6j8/JaWllJWVka7dsHLO3Xq1EPG69u3L3PmzGH37t24O08++WTyttatW+PuvP/++wA89dRT1X4cqY52WftmzZpRUlKSrNeAoAWkuLg47aWq5OPiiy/mqaeeoqysjPLycp544gn69euXdl8RETm8SMr1zawZ8N/Ag+6eWP/878CX3X2LmTUHfguMAh6sfLy7TwYmJ663adOmdoyDPYzGjRszaNAgHn30UT744AMAxowZw+DBg5k1axZnnnkmffv2Te4/evRo7rnnHrp160ajRo047bTTWLhwIYMHD2bz5s306tWLrKwsTjrppArJxOGccsopvPDCC9x5552MGjWKvXv30q5dO+bNm8eSJUuYPHlyspVg0qRJ5OTkVKgBadasGePGjaNHjx60bNky2SVSlf79+/Pmm2+Sn5/PySefTJ8+fZKFp1lZWUydOpX+/fvTokULrrrqqqN4Zo9+WfvmzZszZMgQunTpQnZ2drI49UjdcsstrF27lm7dugFw0UUXcfvttx/VfYmICFjQmHGYnYIumDVAc3cvt6D9+e/ABaldMOG+TYGXgIXuPu7ge0vu913gX9z924eL36ZNG9+0aVPyupYdr3127dpF06ZNcXdGjRpFSUkJ06ZNq+nTOq7o76LmVTUM96IlFx20rbbMLyQSJTP72N3bpLutWi0gYavFu8B1BAWlVwKb0iQf2cCLwIuVk48widnm7nvNrDEwEFiB1AtDhgxhw4YNlJaW0rFjR6ZPn17Tp1SnlPzlLwdtO1FDemu1D756zsEbH9P7XqS6jqQLZjgw08zuBnYCNwCY2RPAfHefD9wG9CCo9RgYHjfb3ccDFwA/NLN9Ydw/AOMz8zCkpmmmUBERORLVTkDcfSVwfprtN6X8fzxVJBXuPheYexTnKCIiIvVMnZwJNTEEsjr1KyLHi8TfQ+UhwiIitVGdXLSiQYMGNGrUiK1bt9KiRQt94Eqdtz9NMn0kQ6/dna1bt9KoUSMaNKiTvytE5DhTJxMQgHbt2rFx48bkVOIiddneLVsO2tboCBe1a9SoUXLuFhGR2q7OJiAnnHACubm57N+/X10xUuetvPa7B23r8O471T7ezNTyISJ1Sp1NQBL0oSv1gYWz4abSXB4iUp/p21tERERipwREREREYqcERERERGJX52tARI43dv/Bw861roiI1DVqAREREZHYKQERERGR2CkBERERkdgpAREREZHYKQERERGR2CkBERERkdgpAREREZHYKQERERGR2CkBERERkdgpAREREZHYKQERERGR2CkBERERkdgpAREREZHYKQERERGR2CkBERERkdgpAREREZHYKQERERGR2CkBERERkdgpAREREZHYKQERERGR2FU7ATGzs8xsqZmtMrPlZtYxzT59zewtM3vfzP5qZg+aWYOU2/ub2YdmttrM5ppZs0w9EBEREak7jqQF5DHgF+7eAZgIzEyzzzbgWnc/F+gO9AKGAJhZNvBL4HJ3PwvYDNx79KcuIiIidVVWdXYysy8CBUC/cNMc4BEzy3X3NYn93H1Fyv9LzawYaB9uugxY4e4fhtcfBX4PFB3TIxCpp1599dWaPgURkchUtwWkLfB3dy8HcHcHNgLtqjrAzFoDVwELwk3tgL+l7LIBONXMqpUEiYiISP0RSRFqWNvx38CD7v72URx/h5ltSlx2796d+ZMUERGRGlPdBOQjUlorzMwIWjQ2Vt7RzJoCLwL/5e6TU27aCJyecr09Ka0qqdx9sru3SVyys7OreZoiIiJSF1QrAXH3LcC7wHXhpiuBTan1H5AsNH0ReNHdx1W6mxeBbmb21fD6SODZoz1xERERqbuOpAtmODDczFYBdwE3AJjZE2Y2INznNqAHMNDMisPLPQDuvgu4CZhnZmuANsCPMvQ4REREpA6pdgGou68Ezk+z/aaU/48Hxh/iPuYD84/wHEVERKSe0UyoIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISOzh0AXwAACAASURBVCUgIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISu2onIGZ2lpktNbNVZrbczDqm2ae9mS0xsx1mVlzptovMrMTMilMuJ2biQYiIiEjdciQtII8Bv3D3DsBEYGaafXYCY4B/qeI+Vrp7fsql5IjOVkREROqFaiUgZvZFoAB4Otw0B2hrZrmp+7n7p+7+OvBZRs9SRERE6pXqtoC0Bf7u7uUA7u7ARqDdEcY708zeDbtwRh7hsSIiIlJPZMUY612gjbvvMLM2wEIz+6e7P1d5RzO7A7gjcT0nJyfG0xQREZGoVbcF5CPgVDPLAjAzI2j92FjdQO6+0913hP/fBPwGuLCKfSe7e5vEJTs7u7phREREpA6oVgLi7lsIWjCuCzddCWxy9zXVDWRmp5pZg/D/TYH+wIojO10RERGpD45kFMxwYLiZrQLuAm4AMLMnzGxA+P8vmNkmYDZwrpltMrMJ4fFXAn82sz8BbwAvAzMy9DhERESkDql2DYi7rwTOT7P9ppT/7wHaVHH8I8AjR3GOIiIiUs/EWYQqUue9+uqrabf36dMn5jMREanbNBW7iIiIxE4JiIiIiMROCYiIiIjETgmIiIiIxE4JiIiIiMROCYiIiIjETgmIiIiIxE4JiIiIiMROCYiIiIjETjOhilThg6+ec/DGx6bHfyIiIvWQWkBEREQkdkpAREREJHZKQERERCR2SkBEREQkdkpAREREJHZKQERERCR2SkBEREQkdkpAREREJHZKQERERCR2SkBEREQkdkpAREREJHZaC0YkA+x+O2ibj/UaOBMRkbpBLSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7JSAiIiISu2onIGZ2lpktNbNVZrbczDqm2ae9mS0xsx1mVpzm9mFmttrM1prZ42bW6FgfgIiIiNQ9R9IC8hjwC3fvAEwEZqbZZycwBviXyjeY2RnAj4ALgVzgS8AtR3i+IiIiUg9UKwExsy8CBcDT4aY5QFszy03dz90/dffXgc/S3M1VwHx3/4e7OzAd+O5Rn7mIiIjUWdVtAWkL/N3dywHCBGIj0O4IYrUD/pZyfUNVx5vZHWa2KXHZvXv3EYQRERGR2q5WFqG6+2R3b5O4ZGdn1/QpiYiISAZVNwH5CDjVzLIAzMwIWi82HkGsjcDpKdfbH+HxIiIiUk9UKwFx9y3Au8B14aYrgU3uvuYIYs0BBphZ6zCBGQE8eyQnKyIiIvXDkXTBDAeGm9kq4C7gBgAze8LMBoT//4KZbQJmA+eGNRwTANx9HTAW+COwBviEYGSNiIiIHGeyqruju68Ezk+z/aaU/+8B2hziPh4HHj/CcxQREZF6plYWoYqIiEj9pgREREREYqcERERERGKnBERERERipwREREREYqcERERERGKnBERERERipwREREREYqcERERERGKnBERERERipwREREREYqcERERERGKnBERERERipwREREREYqcERERERGKnBERERERipwREREREYpdV0ycgNcvut7TbfazHfCYiInI8UQuIiIiIxE4tICLHmQ++ek7a7ed8+EHMZyJ1XboWVLWeSnUpAUnj1VdfPWhbnz59auBMROKj972IxEldMCIiIhI7tYCISJVUpCwiUVELiIiIiMROCYiIiIjETl0w9ZBGOYiISG2nFhARERGJnRIQERERid1x3QVTVVcFj02P90Rikm6eBxGR44G6pmsftYCIiIhI7KqdgJjZWWa21MxWmdlyM+tYxX7DzGy1ma01s8fNrFG4/SIzKzGz4pTLiZl6ICIiIlJ3HEkLyGPAL9y9AzARmFl5BzM7A/gRcCGQC3wJuCVll5Xunp9yKTnqMxcREZE6q1oJiJl9ESgAng43zQHamllupV2vAua7+z/c3YHpwHczdbIiIiJSP1S3BaQt8Hd3LwcIk4uNQLtK+7UD/pZyfUOlfc40s3fDLpyRVQUzszvMbFPisnv37mqepoiIiNQFcY6CeRdo4+47zKwNsNDM/unuz1Xe0d0nA5MT19u0aaOFJ0REROqR6iYgHwGnmlmWu5ebmRG0bGystN9G4MyU6+0T+7j7zsRGd99kZr8hqBU5KAEREZHaoz4P4U/32Pr06VMDZ3L8qVYXjLtvIWjBuC7cdCWwyd3XVNp1DjDAzFqHScoI4FkAMzvVzBqE/28K9AdWHPtDEBERkbrmSLpghgMzzexuYCdwA4CZPUFQeDrf3deZ2Vjgj+ExSwhGz0CQtPxfMysP484GZhz7QxARkUxJO2FXPZ2cUWpWtRMQd18JnJ9m+02Vrj8OPJ5mv0eAR47iHEVERKSeOa6nYj8Sdr8dtM3HqjZWRKS+Sfd5D/rMzzRNxS4iIiKxUwIiIiIisVMCIiIiIrFTAiIiIiKxUxGqiIhIhqUbznzOhx/UwJnUXkpAREREYqBZVytSF4yIiIjETgmIiIiIxE5dMCJSr6nZW6R2UguIiIiIxE4JiIiIiMROCYiIiIjETgmIiIiIxE4JiIiIiMROo2BEpN5IN/skj02P/0RE5LCUgIjIccfut7TbfazHfCYixy91wYiIiEjslICIiIhI7JSAiIiISOyUgIiIiEjslICIiIhI7DQKRkREar10I5c0aqluUwuIiIiIxE4tIBIJLYEuIkcr3eeH1D9KQERERGrI8TwpnhIQOWaa/lpERI6UEhCp86pqrlWXj9QX6ZL8LVUk+XrfS12hBERiE3dTo6rm5Xik973UFUpApE5Rd49I/ZH27xn0N32cqHYCYmZnAbOAlsAOYKi7/zXNfsOAuwiG+P4BGOnuew932/FKo0VEROR4dCTzgDwG/MLdOwATgZmVdzCzM4AfARcCucCXgFsOd5uIiIgcX6rVAmJmXwQKgH7hpjnAI2aW6+5rUna9Cpjv7v8Ij5sO3A38/DC31XtqahQ5QC1/IplTV4uUzf3wxUlm1h14xt3PTtn2FnCXu/8hZdtUYLO7Twivnwu86O7tDnVbmnh3AHekbGoN/ONoHuAxygZ218NYccdTLMWqLfEUS7FqS7z6GquyVu7eON0NtbII1d0nA5Nr+jzMbJO7t6lvseKOp1iKVVviKZZi1ZZ49TXWkahuDchHwKlmlgVgZga0AzZW2m8jcHrK9fYp+xzqNhERETmOVCsBcfctwLvAdeGmK4FNleo/IKgNGWBmrcMkZQTwbDVuExERkePIkYyCGQ4MN7NVBENpbwAwsyfMbACAu68DxgJ/BNYAnxCMnjnkbbVYnN1AcXc51dfHplh1K1bc8RRLsWpLvPoaq9qqVYQqIiIikklH0gIiIiIikhFKQERERCR2SkBEREQkdkpAREQywMy6VGebiASUgBwnzOzR6myT2qM+v2Zm1sjMzqzp88iwmdXcJodQz9/3p5rZReH/s8zshBo+pRpVK2dCrUlm1g34MfAVUp4fd/9KBmMMOdTt7v5UpmKl6JlmW68I4mBmlwIPETyHDQED3N0bRhAri2BemjOp+Hr9MNOxwngnEwxJrxzvxgjCxfmaxfY8hh/AzwDlQDszKwRuc/frDnngscVsQLCkQ+pjy8hEiOFaWa2BE82sM8H7HSAHOCkTMQ4R+1TgDCo+rv+JKNaVwNnu/mMz+zLQ3N3/HEGoON/389z98sNty1Csq4CfAk4wEWdHYALwrQzGWB/ef1qZ/B7LBCUgB5sFPAIsA/ZFFOPb4b/NgD7A6wRvmguAV4GMJSBmdg1wLXCGmc1NuSmH6NYG+BlwK9E+hwnPEnz4vxVDLIDnCeawieyx1dBrFufz+ADBqtjPA7j7cjPrGlUwMxtK8J7cC+wPNzvwxQyF+C5wO3AaMD9l+w7gwQzFOIiZ3QMUAes48Jo50COCWD8ECgkS1B8TPI+PkcHEoIbe9wetRUbwwykK/wF0AxYBuPufzOz0Qx9yxPqH/15LkOQk5tq6GfhbhmMdMyUgB9vn7pFOkObuVwOY2X8CBe7+l/B6RyDTvzg/BP6L4I3/XynbdwKvZDhW8r7d/aWI7ruyzsBXPb4JbU5194sjjlETr1mcz2NDd18bTIicVBZhvHuBQndfGcWdu/vDwMNmdq+7/yiKGFW4ETjT3bfGEOs7BO/HtwHc/e9mlp3hGLG9781sOMFs3B3M7N2Um3KAv2YyVop97r41yve9u/8VglZody9MbDezPxL8uPhBJuMdKyUgB/ujmRW4+9sxxMpNJB8QvHnM7KxMBnD3PwF/MrMX3P2TTN73ISwws8vdfV4MsT4CTgA+jyEWwFozO9ndt0cVIN1rFi5fkO3uuyIKG+fzWBp+eTlA2G1REmG8f0aVfKRy9x9F2dWTxv/GlHwAlLj7vkpfnlbVzkcj5s+qF4GVwDTg31K27wTeiyjmLjP7Egfe998APo0oVo6ZneTun4XXTyJIrmoVJSAH6w3cbGZrgNLERnfvFkGsnWHz8Kzw+vVE19Q4y8wGJz6wzKwlMNPd+x/muKNxG8EfQAnBF1qiBqR5BLHWAEvC1qTU1+tnEcQC2AO8a2YvVop3RwSxHjCzUWHM5cBZZnanu0dRkBfn8/gj4PfAl83saeBi4F8iiJMwz8xuJ6g7SX1sOzMZxMyuB6YSXVdPZS+b2UMc/Lii+AL9m5ldCLiZNQLuBoojiAOw18xGE2Gdlbv/jaBL4pxM3Wc1jAZ+B3zFzF4nqN35PxHFegZ4w8yeC69fDTwdUayjpqnYKzGzPum2u/urEcQ6G/gVkE/wQbUCuD6KX2tmVuzu+ZW2vRtFYlVVv2b4R5/pWDPSh4qkKBQzG5tuu7vfH0GsYnfPD9daGgh8H3jd3TM+tLMGnsczgEsJktOX3H1tFHHCWPvTbM54UbSZrQW+FUdrSxhvfZrNHkWhYfjLfRbwDYLPqsXAv7r7PyOItYg0dVbu/vMMxvipu48KE+6DvgTdfWCmYlWKm0NQN2PA0ihbUs3s/wB9w6uL3P13UcU6WkpAqmBmpwG4++YYYjUNY0XVvI6Z/Rno6u7l4fUTgHfdvVNE8b5AkFgBFLv7niji1Gdm9id3zzOzScCb7v68ma1w98gKNuNgZu2ALe5eGl4/EWjp7h/V7JkdGzN7093Pq+nziFL4d20pTftRxPiru3eM6v7DGN929/8OW60O4u6z0m0/xpiFwIeJz3kzawZ0iLK7P87vsaOhBKQSMzuHoDr/tHDTJuBqd/8wonixDKMzsweBs4CHw023Aavd/d8jiNULmAP8I9z0JeBKd18WQawsgj7cb4abXgIeTiRaEcRrSjCKIzXe3VEkj2b2EsEIh8sIkrnPgHciagGJ7Xk0s7eA3pUSkCVRfnmbWVuCkTcAr7r7xxHE+A+CWpZIu3oqxexB0IUF8PuovszM7NsEz9tOM7uTYKjsfak1bBmMNR8YEmXrQE0Ii10L3X1feD0LeMPdCyKIlfgeOzXc9DERfo8dLSUglZjZYuBxd38mvH4tMNzdvx5BrLTD6Nw9imF0iX7bRJ/jfGCiu++NINYbwCh3/2N4vRcw2d3Tje8/1lg/I+grfpygKfUmYL27fz/TscJ4vyKoyZgWxhsONHX3wRHEaglcR/Ah9YaZtQcucveZEcSK7XmsojvwoG0ZjPcd4JccGO7+NWCYu/93huOkdvU4Ec5/E8a7BRgDzA3jDQR+5O5PRBDrPXfvYmZ5BF0x04Dr3P3Cwxx6NLGeJRhKHHmdlcU4r0+c7/s4v8eOhRKQSmJ+k6wFesRYyR6LRNdBpW1RPYfvAfnuvj+8nkXQtRTJFNhVPLaDttU1cT6PZrYCuMTdt4TXWxPUgUTyHIa/PAe5+5rwei7wXESF5bEJX7Nv+IGRUq2AVyJ6zd51925mVgR85u6PRlhDFmedVeT1Jimx3iKom1kdXu8A/NpThstmMFasSf7R0iiYg+0zs3Pd/X0AMzuX6CZmim0YXdgEPQ1oExY25gNfd/cpEYTbbWYXu/uiMPY3CLoPomAESwrsT7me0eGBlTQ0s6Yp/bjZBLO9ZpwFM2zeR9D90iSxPaIvzjifx58By8LWJAhaeTL+5ZKiYSL5AHD3NRYMl63zPGW4qrt/YhbZW7+hmZ1HMFvuDeG2RlEEiiLROIQ45vVJuB943cwSxaCXcOC5zLQ4v8eOmhKQg90N/E/46wKCCZr+NaJYcQ6jeyyMUxRe/wvBCJwoEpDbgDlmto8DX2SRVJUTNNP+3sxmhteHEAx1i8osguFtvw2vDwLSjSDJhES3wcXAKIKm4hURxYrteXT3GeEIjsQU1De4+2tRxAptMbObgCcT8Qh+9WaEmb3q7n3MbBsVR1REOfwcYLWZjafibJerI4o1Jozzirt/YMEIvlVRBIr5x1Lk8/okuPsLFgxlTiQ8P/LoRn+lfo8Z0InovseOmrpg0gh/eSbqMN6IYqhZGCfOYXRvu3tB6iiKKEdUhDUnZ4dXV0ZRaxLGaUDwxfyNcNMi4BeJroSIYl6WGs/dX4woTmIY7p/dvXM4culVdz8/glixP49xsWDRu18TzLDpwLsE9QsZ+fA3s1M9mBk0tuHnYdxWBPOOJL7QXiZYU2dLFPHiYmYLCX8seTAKLAtY4e6dI4gVW71J3ML3R6KwO7LvsWOhBOQ4ERaGnk/Qr9/VzE4BFkdUl1EI/NXd95jZIII/8MleS4eC1VZm9pa79zCz5QRzZmwjSOYyOltu3MJi2nQTTfWt4pBMxc0O40Q12V+9HX6eZvTX74H/8GhGf8X2YynmepPIFzqtFC/ykV/HSl0woZpoRrVgPoSDeDRTN88maEJtFjZHjwAyXi0fegLoZsG08uMJhoPNIOjzzAgzG+XuPzWzKaSfSCijv2CsZiYuWmVmLQhmMHyTYJrodzIZIO7nMfQcwdoejxBhv7SZneXuq82sS6XtQOa7Oi3N8HMzy/jwczPr4+6vWjBB3UHcfX667cfoUYLRX4M4MPrrUSDjo7+AckspZgl/LEVS3BJzvUkcC50CFUZ+Jbo2HzKzjI/8OlZKQA64Nvw3zirhdzgwXK8J8AVgKxFM3Rx+yXyXYD2AfgQtEs9kOk5onwfrRlwGTHP3yeHIh0xK/IqNa66AJeG/caxvA4AfWJ7+YTN7GziFoKk4k+J+HgGauPt/xBBnCsHqoP+V5jYn86ueTgau8orDz6eQfnn5Y3EdwarZ/5bmNqfiiryZ0qXSKKWRZvanCOJAjD+WzCzt4mzunulFQSGGhU5TjAV6Vh75BSgBqY3c/e/hfwe7+7jU28xsDDDu4KOOOWarSnEGAhkdimhmc9z9SjP7d3d/EPhNJu+/Co0tmLr52wRN7ZDhkSKJP+S4fsGk/HL438o1H2Z2aabjmVlD4M/ufm4Y/4+ZjhHeb+ID8T8rtwhUbjnIoL+YWbuIWvqSPFznyN3PiDJOihNTXyd3X2pmTQ51wNFw95vDf+Oc0yG20V8x/1hqmvL/JgSF0RmfMDEU50KndWLkV607oVogXVN6VCM4KnD3uWR+caKzw+bMaw+7Z+ZMIVhpcoe7vxsWAW6LIpCZ/dDMTrbAC2b2TzO7MopYoR9Xc9sx8WC2xE/CmoI4zKzmtkxoRbDq6UIzm5u4RBQLMzuo1SrdtgzYbWbJIZ0W7fDzxLwSh92WIYnRXz8IWw3eILrRX7j7b9z9GncfFGHygbsXpVxuJahXi2rV2N7AUjN738zeTVwiirXFzG4yswbhZRgZHPmVKWoBCZnZJQSFfl82s8kpN0W2hLEFawEkNCSoWG5Wxe5H601gF0GrROrSz5HVtngwE2Nqk+l6DhSvZdp33P0HZvZNoJxglstnCfriM8aCSYO+SrDKb2rfew5B11kU1hD8appNyirJnsEVasMRX62BE82sMwf62nMIlvCOwtPEuzJnulqrMyOIk274eZTJcIXP73DkWdMq9j0m7j7JzP7CgVFSd0Y4+utU4HaCpSNSizXT1rxkkrtvNbNIikKB70V0v+mMIBj59SgpI79ijF8tSkAOKCXoB98P7EjZ/hHB8uFR2M6BGpB9BGP4Mzr1tbsPM7O7gT9wYN6FSByuOI5o+qYTw0T7ALPdfaWZRTG063xgKEF9Tmrf+06COTqi0IBgyfPUUS+ZfmzfJfiwP42Kr88O4MEMxwIOLPRlZo3d/fMoYoT3P5zgg7hDpV+aOcBfMxjnJA8WZ1sFFBAMP3eCVsCMPz4Llqq/C8iu9KPiROCpTMdLcPffWbCopUc8omIuQX3cPKIv1kz9vG1I0ALyjyp2PybhZ2MjoF2E838kYq0FesYx8utYaBhuJWaW5+5RFVfFLqUGZLS7T4w41uPufrMF6xBU5lEMszSz1wkKq24maP3YQlA7EdUqv8Pc/ZdR3HeaWC0rj91Pty1Dse5196gS7cqxOhPUIp3s7m3MrDtwjWd4YUQL5uU4g2BSqxEpN+0E3gu7uTIRJzFN+X4OThCNIAkZG9ZgZSJeDkFB8kGPy92j6urMI2hZ/FK46R/Ad6P4rLRw3ZlM328VsVK7kcoJWh1/EcXzaGYXEcxvUu7u7SyYruC2lGLzTMeLZaHTY6EEpJKYq6IjH6sdNpt2JlhFNfK1L8JCpx7u/kbUscJ4uQRNm//j7nPD61e5+wMZjpN2SGdCpod0hjEPWmsj3bYMx2wMNE5c9whWcjWzJQQza071YE4aA/7iES/BXlPCbq5l7h5Ft08sLJiL5kF3nx1evwoY7dGsYzID+LGHa6bUFxbMxfSvwPN+YH6Tv0bxvrcYFzo9FuqCOVhsVdF28CqdUYzVjrUGxN33m9ljZHg0zyHirSHoQkj8MmyS6eQjFNuQTgtmPG1COPKAGOoyLFjnYybQodJNUYx0yHb31+3AfBxuZmURxAHAzE4EbuXgNXXiKi7fYmbXZPp+w8TmfoK/tajXCmqSSD7CGM9X9WMtAyYTFGuupuLspFFPVDfH3aOs2Wno7mut4no9Ub3vbwTO9Fq+0KkSkErcvSj1upndR3SjASIfqx1nDUiK1WaWmzoMLCpm9iLBCJ9y4E/htqfcPaMfjjEP6fwPgveGU7EeaSfw04hi/oygxmU6QbX+90n58M+w8rAv3CHZChhlX//jBM9dL4LnbygQa1N0REMvEz9evkH0awW9a2YXufsSCOq9yPCkeCmeJuheept4F1CL+m+7NKzJSLzvOwMlEcWKbaHTY6EumGqIsJkszmXrc9x9R9SFf2GsPxAUcy2l4uiNjP/itHCKZgumfP8acCfBdPMZXTfCqpi1NsEjmNPCzKa5+//N9P1WEStRx/DnxHNnZssjamK/jqD4tQvB8M7rgH939+cyHSuMl1hL5z137xK2Kr3g7r2jiBcXi3etoD8D5wIbwk3tgfeBvZDZVpd0n4txsAjXxgrvvx/B6tZnEqzbczHwL+7+hwzGSHQRX0nQYhrHQqdHTS0glcRZFU3Eq3RW0s7MfgOcDERW+BeaFV7ikFgSvDfworvvNbPyCOIkZq0FaEH4wRvGj2r22liSj1DiOdtqwZoVHxHM15Fx7v60ma0DvgOcQLAw3OtRxAolfmWWhyNWdlmwUFddl2i+L7Vgyv5tQMuIYsU5hPSPZpbv7sUxxgS4KMo7d/ffh91KlxJ0q46NYDRM5S7i76SeApmf/feYKAE5WGoGXE4wDPIXEcVKjNX+eXj9XaJbMnlqGG9qSqyngIwnIIlhljH5i5n9DjgH+HeLaOIuD2etNbOJBJXyiZEwNxLNnBKJGVYfIvjQaMiBup0o6jJ+E36J/Zhgmu9GBIWikXD3pQQtZHH41IL1RBYCL5nZP4FNMcWOUuRrBUFyVt6b3D2KdV/SuRC4yczWUPHXe8ZrW8K6sfFAe3fvb2bnAnnuHsmM0e6+nqB7KRIxdRFnjLpgakg4WqTQ3d+MY6y2xbjCZHjfgzi46C/jC5tZMNX1pcCf3H29mX0Z6OzRTZJ0UBdZVM+jma0iKJ6ssHiVB3NOZDJO8r0YXm9EUHSY0ZVOLRieXeUHTlRFhmbW0IO1iYwgwT8ZeCqKET41xcy+RrhWkLtnvAXQzN509/MOv2dGYvVJt93dX40g1rPAX4Br3b1TWLC8LKJu8PWkX/AxqtVwGxBMMpg6DDfS5Q+OlFpAKgmHIf4bQf+cE/TVPZzpuolwtMgvCLLtOCaJia3wz8x+RlDQ1Z1gvoerCZ7HjHP3UjP7CLiAYMbVPYTFqBE5wczOdveVkJwhtfFhjjlaO939pYjuOyn1vRhe38uBLqZM+kn479eBbgRdj07Q9RhV8WRiWns8+LUV5wyskbGY1gpKsTh8j8ykYl1XxmsKPMYJu4AO7n6thcs3uHuJVRqmkkH9U/7fhGAl4UgKRc1sKEFh+V4OTNboRNBVfCyUgBxsOkEff6Kr4gaCKbhvjCBWbKNFCJaBnge0MrNxhIV/EcX6OsGX2QoPlrCfREQ1IWY2kqD6Pxv4FdCcYBr4qBbquougjzqR5HQhmvcGwAIzu9zd41iBN/L3oru/AMGkZ8AFiV/qFkw1H9molLh/ecYhbNH5xMy+4O57YgiZGEacuqRCJDUFljJhF0HtWpQTdlUYBhu2gESSgLh75dl33zGzpUQz0/a9BK2aKyO474xRAnKw84Fzwl9LmNkCMjhtcyXNgeLwTRjpaJGYC/9Kw1/VbmaN3P0fZnZaRLFuIVjufCkEUxBHWWDo7vPDfuJEc/Qyj2Bm0tBtBGvPlBDMphnZ+j3E+F4MY6UmBPvDbVGJ7ZdnzCJfKyjlPuOsLXiAoA7k+TD2cjOLanTKYgsm7WpiwUKC/0YwFXzkwvqd1hHd/T9re/IBSkDS2UqwpkLiV0VjIKovmDhHiyQL/8ysY5psPJN294TBfgAAGHNJREFUhcWgrwNPm9k/OPB8ZtrnYbNp6rYoRsEkufsWMjhXyyFkvB/6EOJ8Ly4CXjSzxLol1xFRFx3E/sszTnGsFQRUPQw9opqCOCfsupdgxtCdBAXY84BIlqwwsxUceH0aAqcT0XpLwDwzu52Dh+HWqronFaGGUobf5hEMvU3MSXAVsNzdb6qRE4uART+d95cIFtprANxBUBz3sLt/FEGsBWGMZ8N5LIYCAz2ilTNjHplCmMglEpHiqJvbE/3fHuEHg5llEXSbJYpOFwGPR1E8WUX8FgR/03W2CyZuZvYJBxbObEKwAvRWd894TYGZvQZcRrC8QjcLJux6zN17ZTpWnCoV15YD69z97xHF2p9mc2SfU0dLCUjIKi5KVJm7e8b7+c3syTSbtxM0689Oc1um4kY64U5KnDZEvHKmBbPH/gboSNB6tRPoHw53iyJeLCNTwli9gDkcmIfmS8CV7p7xpQEsWLjqlxyonXkFuDmqD8g4VfXL091/XHNnlRlh12YnKo42i2LV6cpxBxIU0I+N4L4jn7ArJdYXgOsJWpFSR4tkdFVySU8JSA0ys+kE00P/luADchBBk+qZwGvufndEcR9299uiuO/w/hMrZ7YmeFyRrZwZxmtAsAS6ASs9Q6ucVhHrbXcviOr+K8V6AxiVGOEQJiST3b1nBLH+myCpejTcNAL4mrt/O4MxRrn7T81sCumLQjM+TDuMG9svzziZ2Y3ADwjqZ1YTtN6+4e4XxBQ/sr8FMzuDAxN2vRTVaBgLlnLYCyyn4g+K8RHEinUYukW80GkmqAYkZGZ9wuFfaZvuI/pVcQ7QKzEMNxy+uhC4hGAdhIwmIClD2yJLPkJPAD/wiitnPgFEMa33twmStQ/C66eYWa/EiIsIxDky5cTU4ZXuvtSCeU+i0LZSsvGAmWV6JspEoeT2DN/vIUUxf0Qt8W8EEyf+wd27m1lvgnVuMs7MmqVcbUhQhN2sit2PNdYYdx9HyoRdKdsyrV1iKHMM3iH98PMlmQ5k8Sx0eszUAhIys8fd/eYwS63MM52dhjHfr/zmT2zLdDdJ6tA2d490aJulrCeSsu09d0+7lP0xxqowMVhYw/BOVDUuZraNYI2FyEem2P9v786D/azqO46/P0QwU4UAklSKIIsEQVlkiQQsRaHV0boVRsFCSy0VtRMdxYiiBRFXBhALilRQ1EwMo0JcwICCEkAWIUCIWygCI1oZBtDEBTHh2z/OeXJ/d0kiyXPOc+9zP6+ZO8nvucs5F26ee55zvot0A6lc83fz68OAD0bEwQXGuhN4aUT8Or9+JunJs/WeHMqFwdr+umOMcxnrfuKs0g23FEm35YXHYP+eIvFdOaagiQFZTdpxeWcUKPg31vdQ8Pu6FHhTwUy2wbFuYnj6+WakOJcSO5pLgNfFiEanJWP/NoR3QLK8+NgEeG9E3FRp2KU5DqSJP/lX4C6lYmht36BrprbV7Jw5TESEUpGmUmpmprwNuFRS87OwCVDql+aZwO1KZe0hbX/PXcfHb4wHJH0J+Hyzc1VIjV2qLv0pL7iX54yH+0n1cFoXEZuU+LqDJL2U9HO3naSzB941reCw7wNulPRDhmeLlKjtUzP9fEoM1PSJiP/Nv9/GFS9ABkSqXXEBuSJkBceTznDPya+vIW2rriZFgbepZmrbvsAxku7Lr3cEfpxX5W33dFiZj1x+AGtKUrdaQnxQRNxfMTPlb4D9ScGnAA+SMrRaFxFfysGah+ZLZ42RvtqW2aSjgstzdsXngC+3nSIYdXsSdeH9pGOQd5MKKG4JvLXUYDkV9xDSL9HFBbLaHiMdzz0B/Hbg+i8olzL9WVLs060Uqgw9oGb6ec1GpxvMRzAjSPoq8J6oUJ1U0tSIeGzEtRmR6ky0PVa11DatpZdDo80zeUmzgcuAn+ZLuwKvjYhb2hpjxHg1M1NqHy89jRRTEKSFVeuZPWOMeSgp4PWVEfG0guNU6U3UV5LeQKoO3VSsfREwJyIWFBhr71IB62OM9aOIeF6lsaqln0vahdTodF/Sv+clpOKTpUvbPyneARmtZkXIBZJeG7Gm6urWwJUM78jbltOBq0jbm/PIqW0Fxqka9BcRN0ranfRUDfCDiCgZ5Hg2cOSIzJRPkKqxFlXyeCnHl8wHfkk6599W0tERMVZMVFtj7kfqE/QSoOQ41XoT1aTU4fdjwGEM9a16X0Q8WmC4U4D9I6e3S9oRWETKdmtVRNwpaRajF4ytV3gF7pS0XY0MkbzQ+JSkC6Pl3mJjjHUPcKAqNDrdGF6AjFazIuTPSA2D5kjanJQB86kSA0XEVZLuZii17dSCqW17AKcyOre+9SDU/HUfJf23q6FmZkrN46VzgFfFUEfcWaQo+j3X+VkbQNKJpCOYKaT4p70Lp8VW601U2cXAA8AR+fXx+dqrC4z1hxiorRMR90kqcvQo6WRSAcgdgGtJ/WeuJt0r2zYdWCbpRobHgLT+wClpL9Iif0vgWXkB/vqIaK0nl6RdI+LuPNbgdaBM88CN4QXIaA+OjOxWqn7Zuog4SdKXlXoR/D3pHPzCEmNJ2izfQM6XtDOwh6T7CmUjLAC+SFpMFT1XVeXKpMDvJB0+IjOl1FHFu4HLJA07Xio01hPN4gMgIm4ZCH5t226kHj5PjYjvS3pK/vksFZNUszdRTTMjYnCxMUdSqaDeyyV9gJROL1JMwTeV03Nbjt95Ayn26aaIOELSbqQy6SXMo16H5P8mHTc2jU6XkO6TbTYF/QSp99HXx3hfkeaBG8MxICPUSAHT8Jz6qcC3SAGoH4Ey9fpzlPdLSI3olgL3kdp5v7nAWFUqreaxqlUmzePtR2pWNSwzJSKWFBpvKyocL+VdgR8xtDNwLPD8Np/OBsY6EjiLtOjZSalw3Ucj4uVtj5XHu4Z0Uz6D9MT7a+DAiHjhOj9xnJN0NXBURDyUX08nPcQcXmCssUp7N1pd8CsXOJO0lLQ7FiPjoSaige9rzf2x5r1yPPIOSCZpJvBcUvfRwWJk00h9D9r0G4Zy6ps/9yethIP0JN+2p0TESkn/AnwhIk6WdFeBcSB1mDwkIoq1WB+wIiKurDBOo1pmCpQ/XlKqa9L8DE4DLsjv2pT0c9r6AgR4Lyk47ruw5sz/2QXGaRxNWjDOZag30ZEFx6vlUVLaflN07+XAdU0Ka5tBtjXScAf8Ualo4h3AmZIeoMw9EagaoLwqf19NzN/2FNohlrQwIl6zvmtd8wJkSJMaOIOUCttYAZzY5kCV/zE3Nst/Hko6h4RyxyNfBa6UtJJ0rtoci5TY/qtZmRTg9Pwk1jx1ihTgW6ryamldPFWujoiHK6WEA8yIiAfz31svsd2hu/Jb4zNdTaRlbyHdr04k7QofTEpZbV3lAOXzSLVppkv6EOl7KrHAhxQ/M9IuhcbaYF6AZLlmwBeUytVeVGNMpWqkP42Ilfn15sBuEXFrgeG+J+nHpCeJE/LWfqnuo58H3k6d3Pq3k3atilcmHUvJzJQaIuL+DoZdqdQxuXkSPAx4pOB4CyU9Qvq5nF84S6qaiDit6zkU8qyIWEaKrfoPWBPrVSI1t1qAckTMk/RzUpDwdODYiLiuzTEknUCKM5mpXHcpm0Y6Yh1XHAMygqRbImLW+q61NNYS4IAmEDTnid8UBRo85Sf1vUmNuFZI2obU/+P2AmPdFhH7tf111zLWmFv3pX6xKtVTOWlEZsrHo1IDsFIkzQBOI/2MDG5Flyh/vT/wP6SAuGWkJ9BXRETbvWcGxzyUtMP5j6Qn3M9FxIROxc1b+OeTfmHvI2kf4MUR8YmOp7ZRasThDXzdH0bEAUp9jw6IiD9rjFYSLY21CDiK9OC3LF/+YkSc0uIYzyb9ezqftBBprACWFko62GDeARlt2H+TfGa3eaGxNhn8gYiIVXkRUsL2pKfMLSVtma89XGisyyW9Mio0Poq6lUmhbmZKTU3jqsNIW98nkBpltS4ibpX0YlInaFG+dguR2gJ8X6nY2pmkGhYTducqu4B0nNqUzF8GfImUCTHhVI7Da6zM94/rgXmSfg2Uun/8dUT8JsecLCT9f1tCqrHSivzgdT+p0em45wVIJukk4D3A0/N2LaSb41RSqlQJjzd523kOM0mtoUu4jaFgw6mkf9APk2Je2jaHSsciGqMyqaQilUmhk8JntWwfER+XdExEfFPSlaQaDP9VYrCI+C3w7fV+YEvyDs+xpPRRASfVGrugGXlb/0RY8wBT6li1hmpxeAOOJu1IzM1jvIChuipt2zT/eQiwKO+2FPn/pdRUddTxRhRoqroxvAAZ8hngEtLW1QmkmxSkLIsSlQUhbXlfr6EGYC8l3SBbFxHTB19L+ifK9bypGdhYvTJp6cyUjjRBoI9JegYpw2KbDufTGknfJLWP/xrwxihUpr8DqzQQyZvjurSOjx/XuojDI8V7NMcix5P++72JFnclBizL9/rdgXfnnZdSzhz4+1RSbZXlBcfbII4BGSEHx53K6LSsUv03ZpLKokNqf16tVn+Tl17oa1c5FpF0Z4xoGd+HmgG1KZXnfzspMn8O6alzeUQc1enEWqDUx+TSGNF3aaLLOx+7kY7NPko68784Is7rdGIbSdIrgWtzrNq7SA8TH8iBqW2PdXtEvCAfixxEPhYpFAMylVSJ+s6IuFfSdsCeMaLwZQn5aP+aiDik9FhPhndARruQdB54OIXPwgEiYjkVVqYaXvxsCumJcIu1fPjGjlXzWKRmZdLeiogmzfGTkm4jlYsufmOsISLmSzpC0m4R8ZF84986IkrVwakiIs6SdDQpRuIfgLMjYv56Pm0i+HBE7KVUoO4Y0q70+cDfFhhrrGORIoGaeQG8cOD1L0m9l2qYQqphNK54B2SE5um5iYSWtBlpNT57vZ/85MeqmXnwBEMxIKuBu4F3llh9S7oJOHHEscjZEdH6sYgqVya1iUfSB4EDgF0iYqakbYGvRYFO0LXk1O+PREQfYlmGaTJeJM0Ffh8Rny6YBbOAtIDbHdgjX74hJnh1UkmXMRQDMgXYC7giIv6zu1mN5h2Q0WqehdfMPKhZ/Kxmw7aqlUn7RkOVUEe9i4r1VAp7Nany6q0AEfF/yl1CJ6qIWJ0zifpoiqQXkoJBm5i4Tdfx8RvjOIaORf6Qd8feW2ismgYLM64iLVZvXtsHd8ULkNGW54XHPOBm0ln4bYXGqpp5UFHNY5G+VSatbTBWZjtSTME1pEqUXVTsLeGP+Rf24LUJG6w54AqlRpafB9a0W48CvaQqez8pxfjqiPiJUjO6IsfUHR+LFJMDesc9H8GsQy4ytRXpbLD1dKmmwJlSo7iXkXZbfhYRuxYYa1dSN8aRxz0lUmOrHYuMFXA6VmCqrZukI0gZRVUaxNUk6RJSGexPkmKfTgaeExHHdjqxjaSxG8RFlOsEbeOcch+gtYkyPW42mHdA1mHwGKGQmrstnyUFcp1CSjubQ+qIW0LNY5GVkg4aUZl0ZaGx+uxk6jaIq+ltpHTLPUk7cd8D/rnTGbWg8rFqNX2t8FrJb7uewJPhHZBxosJuSxPY1QTXCrg5ypSYH7Yrkce6rVAQ2WzgMmBYZdIe1XqoYmA3rretwnNquCKiN1lSknYgZXAEsDgiftHxlDaapCvIFV4jYu+cQnp7idRY61YvV9ATiaQdJB0D7Eiq1V+qkmFTYXWlpB2Bp1Kp0FSkVW6RbeGc2rs7cEZ+e54XHxukdoO46nItmo91PY+25Pomt5OCNY8Elkia8HVbyBVegScgVXilXOPMXpK0uaRPSVqe385VanY6rvgIpkP5BnIusDhfOkfSnIhYUGC4xfm45zzSMc/jQIlxoPKxSE8rk9Z2Eqk0+s6Sric3iOt2SkUc3PUEWnQKsH9E3AuQHywWUe7fdS29qvDakU+Tetq8jvRQcUK+Nq7inrwA6VbNG8hiYHUuynQd6RdMqRVxXxu29VZ00CCuI336RfaH5t4BEBH3SSrZiLGWr5CyYLaQdDypwuuF3U5pwtlrRCD+WyXd2dls1sIxIB0aq7hOwYI71eIy8tffiv41bLMJTtLuEfGTrufRBkmnkzLNLiQtrP6NdNR5FkzsdNxc4fU1pO9rYU8qvFYjaRkwOyJW5tebAzdGxPO7ndlwXoB0YKAs+lzGuIFExKkFxnS6qk1aufrpTgzs+kbE4rV/xvi3ljTcxoRMx+1zhdeachXZ40gNViEdxVwcEWeu9ZM64AVIB0aURR+pyI0jH7ucNCIu4+MR8aK2xzIbT3KxrrnAzxmqTRMlMsBs4zUZWV3PY6KT9DJST7NppASHczue0ihegEwSTle1yUrSPcCsiHi467nY+kn6AClrr28VXquRtIhU72kV0HQR/mJEnNLdrEbzAmQScVyGTUaSfjCRG89NNiOOlpqd4gl5pNSVpoaPpNeRAsvnAkvGWy0VZ8FMIk5XtUnqO5LOIRW3eqy5GBFLu5uSrU1fK7xW1jTvO4RU3PLPksZdLRXvgJhZr0m6d4zLERE7V5+MWQWSFpBiP3YH9siXbxhvlY29ADEzM+sRSVNJDU7vjIh7JW0H7BkRizqe2jBegJhZ70maRcoIALgqIm7tcj5m5l4wZtZzkt4EfBWYAUwHvpYrbJpZh7wDYma9JmkpcFhEPJRfTweujoi9up2Z2eTmHRAz671m8THy72bWHS9AzKzv7pb0YUk75LfTgbu7npTZZOcFiJn13ZuBXYAl+e05wFs6nZGZOQbEzMzM6nMlVDPrJUl/FxHXSnrVWO+PiG/UnpOZDfECxMz66hjgWuAdY7wvAC9AzDrkIxgzMzOrzkGoZtZrkm75S66ZWV1egJhZ3w07apa0KbB5R3Mxs8wLEDPrJUknSXoU2FPSI80bsAJY3PH0zCY9x4CYWS9JmgZsBZxPqgXSWBERj3YzKzNreAFiZmZm1TkN18x6TdIM4DRgb2Bqcz0i9u1sUmbmGBAz672LgPuAbYBTgV8Bl3c5ITPzEYyZ9ZykOyJiH0l3RcSekjYDro2I2V3PzWwy8w6ImfXd4/nPxyQ9A1hF2g0xsw45BsTM+m55XnjMA24mpeHe1u2UzMxHMGY2aUg6mJSa++2IWN31fMwmMx/BmFmvSfp08/eIuCEivgWc2+GUzAwvQMys/w4c49pB1WdhZsM4BsTMeknS64GjgJ0kXTrwrmnA77qZlZk1vAAxs776KfB1YN/8Z2MFcHUnMzKzNRyEama9Jml6RDwk6akR8aeu52NmiWNAzKzvnilpGXAPgKT9JJ3R8ZzMJj0vQMys784ldcN9KL9eAryiu+mYGXgBYmb99/SIuL55Eenc+fF1fLyZVeAFiJn13SpJmwIBIGl7wEXIzDrmBYiZ9d15wEJguqQPAdcBjgEx65izYMys9yQdBLwaEPCNwSMZM+uGFyBm1luSpgAXR8SxXc/FzIbzEYyZ9VZuODez63mY2WjeATGzXpP0MWBr4GIGSrBHxNKu5mRmXoCYWc9JuneMyxERO1efjJmt4QWImZmZVedmdGbWe5IOBA4n1QL5bkTc3PGUzCY9B6GaWa9JehdwCfAMYBvgEknv7HZWZuYjGDPrNUnLgdkR8XB+vTVwU0Q4O8asQ94BMbO+W9EsPgAi4hFgRYfzMTO8A2JmPSfpDGAGcFG+dBypM+58cDquWVe8ADGzXltLGm7D6bhmHfECxMx6S5KAbSPiV13PxcyGcwyImfXdVV1PwMxG8wLEzHor0hbvA5K26XouZjacC5GZWd/9DrhD0hUM7wXjWiBmHfICxMz67q78ZmbjiINQzczMrDrHgJhZr0naXtK3JN2RX+8j6R1dz8tssvMCxMz67gJgAaD8ehnwxu6mY2bgBYiZ9d+MiJgHPAEQEauAVd1Oycy8ADGzvluVC5IBIGkrhnZDzKwjXoCYWd99hXQMs4Wk44HvABd2OyUzcxaMmfWepKOB15B2PhZGxPyOp2Q26XkBYma9JullEbFofdfMrC4vQMys1yQtiYh913fNzOpyJVQz6yVJM4HnAtMkvWrgXdOAv+pmVmbW8ALEzPpqNnAcMAMYLDy2AjixiwmZ2RAfwZhZr0n694i4qOt5mNlwXoCYWe9J2hbYiYFd34hY3N2MzMxHMGbWa5LeB8wFfg6szpcDmNXZpMzMOyBm1m+S7gFmRcTDXc/FzIa4EqqZ9d2DXnyYjT/eATGzXpN0Gin1dj7wWHM9IpZ2Nikz8wLEzPpN0r1jXI6I2Ln6ZMxsDS9AzMzMrDpnwZhZL0l6WkT8XtIWY70/IlbUnpOZDfEOiJn1UtPvRdITpLRbDbw7ImJKR1MzM7wAMTMzsw44DdfMzMyq8wLEzMzMqvMCxMzMzKrzAsTMzMyq8wLEzMzMqvt/0atIqO/KaQgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x320 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from collections import Counter\n",
    "from matplotlib.pyplot import figure\n",
    "\n",
    "\n",
    "f = figure(figsize=(8, 4), dpi=80)\n",
    "\n",
    "relations = train[train.vaccines_argument == 0].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_0 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_0)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_0 = [value / len(masks_stance_0) for value in values]\n",
    "\n",
    "relations = train[train.vaccines_argument == 1].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_1 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_1)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_1 = [value / len(masks_stance_1) for value in values]\n",
    "\n",
    "relations = train[train.vaccines_argument == 2].all_pairs.map(\n",
    "    lambda row: [value[2] for value in row])\n",
    "masks_stance_2 = [value for row in relations.values for value in row]\n",
    "cntr = Counter(masks_stance_2)\n",
    "values = [cntr.get(rel, 0) for rel in all_relations]\n",
    "y_2 = [value / len(masks_stance_2) for value in values]\n",
    "\n",
    "ax = plt.subplot(111)\n",
    "indexes = np.arange(len(all_relations))\n",
    "b0 = ax.bar(indexes-0.2, y_0, width=0.2, color='tab:red', align='center')\n",
    "b1 = ax.bar(indexes, y_1, width=0.2, color='silver', align='center')\n",
    "b2 = ax.bar(indexes+0.2, y_2, width=0.2, color='green', align='center')\n",
    "\n",
    "ax.legend((b0, b1, b2), ('vaccines:argument=against', 'vaccines:argument=other', 'vaccines:argument=for'))\n",
    "plt.xticks(indexes, all_relations, rotation=90)\n",
    "plt.show()\n",
    "f.savefig(\"disgraph_vaccines_argument.pdf\", bbox_inches='tight')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Actual statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train['rst_relations'] = train.all_pairs.map(lambda row: ' '.join([val[2] for val in row]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "import numpy as np\n",
    "\n",
    "relations_bow = CountVectorizer(tokenizer=lambda row: row.split(), ngram_range=(1,1))\n",
    "\n",
    "relations_freq = relations_bow.fit_transform(train['rst_relations']).toarray()\n",
    "X = pd.DataFrame(data=relations_freq, columns=relations_bow.get_feature_names())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/.pyenv/versions/3.7.4/lib/python3.7/site-packages/ipykernel_launcher.py:1: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version.  Convert to a numpy array before indexing instead.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "X = X / X.sum(axis=1)[:,None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "scrolled": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.290067e-01\n",
      "4.496092e-01\n",
      "9.282537e-04\n",
      "9.239274e-01\n",
      "9.046907e-01\n",
      "4.757876e-08\n",
      "5.689361e-01\n",
      "5.864945e-01\n",
      "6.273123e-01\n",
      "7.972416e-01\n",
      "4.584164e-01\n",
      "4.833212e-01\n",
      "4.026860e-05\n",
      "4.536836e-01\n",
      "7.857519e-01\n",
      "5.111001e-01\n",
      "8.532170e-01\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'condition': 4.7578757563551366e-08,\n",
       " 'purpose': 4.026859939730019e-05,\n",
       " 'cause-effect': 0.0009282536991755733,\n",
       " 'background': 0.44960921614962,\n",
       " 'restatement': 0.45368361971757387,\n",
       " 'joint': 0.4584163766191064,\n",
       " 'preparation': 0.48332123304764096,\n",
       " 'sequence': 0.5111000947577249,\n",
       " 'attribution': 0.5290067061812824,\n",
       " 'contrast': 0.5689361000103201,\n",
       " 'elaboration': 0.5864945085285749,\n",
       " 'evidence': 0.6273122788679732,\n",
       " 'same-unit': 0.7857519249266336,\n",
       " 'interpretation-evaluation': 0.7972415553041148,\n",
       " 'solutionhood': 0.8532169597419509,\n",
       " 'concession': 0.9046907240119558,\n",
       " 'comparison': 0.9239273692595534}"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.feature_selection import chi2\n",
    "\n",
    "X = X.fillna(0).astype('float64')\n",
    "scores, pvalues = chi2(X, train.masks_argument.values)\n",
    "p_values = dict(zip(X.keys(), pvalues))\n",
    "p_values = {k: v for k, v in sorted(p_values.items(), key=lambda item: item[0])}\n",
    "print('\\n'.join(map(lambda x: '{:e}'.format(x), p_values.values())))\n",
    "{k: v for k, v in sorted(p_values.items(), key=lambda item: item[1])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.482537e-01\n",
      "4.058508e-01\n",
      "1.998747e-04\n",
      "9.418320e-01\n",
      "8.554066e-01\n",
      "1.921699e-03\n",
      "8.014754e-01\n",
      "8.017153e-01\n",
      "7.206419e-01\n",
      "9.199794e-01\n",
      "9.737347e-02\n",
      "5.240888e-01\n",
      "3.180201e-01\n",
      "4.824476e-01\n",
      "9.414478e-01\n",
      "4.601998e-01\n",
      "5.857219e-01\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'cause-effect': 0.00019987467749799244,\n",
       " 'condition': 0.0019216987935382146,\n",
       " 'joint': 0.09737347177770427,\n",
       " 'purpose': 0.3180201357934089,\n",
       " 'background': 0.40585080132488105,\n",
       " 'sequence': 0.4601997588528599,\n",
       " 'restatement': 0.4824476342211288,\n",
       " 'preparation': 0.524088785609476,\n",
       " 'attribution': 0.548253674888763,\n",
       " 'solutionhood': 0.5857219193813552,\n",
       " 'evidence': 0.7206419091655306,\n",
       " 'contrast': 0.8014754247520969,\n",
       " 'elaboration': 0.8017153136696208,\n",
       " 'concession': 0.8554066175990572,\n",
       " 'interpretation-evaluation': 0.919979352998915,\n",
       " 'same-unit': 0.9414478407829785,\n",
       " 'comparison': 0.9418320156495421}"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores, pvalues = chi2(X, train.masks_stance.values)\n",
    "p_values = dict(zip(X.keys(), pvalues))\n",
    "p_values = {k: v for k, v in sorted(p_values.items(), key=lambda item: item[0])}\n",
    "print('\\n'.join(map(lambda x: '{:e}'.format(x), p_values.values())))\n",
    "{k: v for k, v in sorted(p_values.items(), key=lambda item: item[1])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "scrolled": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.459632e-02\n",
      "8.604987e-01\n",
      "3.554938e-01\n",
      "9.086999e-01\n",
      "5.331101e-01\n",
      "8.945119e-01\n",
      "3.101080e-01\n",
      "8.503746e-01\n",
      "6.681316e-01\n",
      "9.376474e-01\n",
      "2.385963e-02\n",
      "9.215031e-01\n",
      "5.674246e-02\n",
      "3.096501e-02\n",
      "7.759935e-01\n",
      "6.840089e-01\n",
      "9.325653e-01\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'joint': 0.023859626129013402,\n",
       " 'attribution': 0.024596320843970104,\n",
       " 'restatement': 0.03096501098325558,\n",
       " 'purpose': 0.05674246395485286,\n",
       " 'contrast': 0.3101079622978623,\n",
       " 'cause-effect': 0.35549378255813124,\n",
       " 'concession': 0.5331101362269999,\n",
       " 'evidence': 0.6681316386898062,\n",
       " 'sequence': 0.6840088841537251,\n",
       " 'same-unit': 0.7759934734790395,\n",
       " 'elaboration': 0.8503746159017148,\n",
       " 'background': 0.8604987169591678,\n",
       " 'condition': 0.8945118657743383,\n",
       " 'comparison': 0.9086998958111526,\n",
       " 'preparation': 0.9215030615739671,\n",
       " 'solutionhood': 0.932565296457302,\n",
       " 'interpretation-evaluation': 0.9376473921912701}"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores, pvalues = chi2(X, train.vaccines_argument.values)\n",
    "p_values = dict(zip(X.keys(), pvalues))\n",
    "print('\\n'.join(map(lambda x: '{:e}'.format(x), p_values.values())))\n",
    "{k: v for k, v in sorted(p_values.items(), key=lambda item: item[1])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "train.to_pickle('data/train_all_about_rst.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Export discourse trees examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from isanlp.annotation_rst import ForestExporter\n",
    "import os\n",
    "\n",
    "rs3exp = ForestExporter(encoding='utf8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "! rm -r rst_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "! mkdir rst_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['text_id', 'text', 'masks_stance', 'masks_argument',\n",
       "       'quarantine_stance', 'quarantine_argument', 'vaccines_stance',\n",
       "       'vaccines_argument', 'annot', 'tokens', 'rst_relations', 'all_pairs'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "! rm -r  rst_result/vaccines_stance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  1  -1  2\n"
     ]
    }
   ],
   "source": [
    "! ls rst_result/vaccines_argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5059, 12)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = pd.read_pickle('data/train_all_about_rst.pkl')\n",
    "data = data[data.vaccines_argument == -1]\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mkdir: cannot create directory ‘rst_result/vaccines_argument’: File exists\n"
     ]
    }
   ],
   "source": [
    "! mkdir rst_result/vaccines_argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "pathname = 'rst_result/vaccines_argument/-1'\n",
    "if not os.path.isdir(pathname):\n",
    "    os.mkdir(pathname)\n",
    "    \n",
    "for idx, annot in data.annot.iteritems():\n",
    "    rs3exp(annot['rst'], os.path.join(pathname, f'{idx}.rs3'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  1  -1  2\n"
     ]
    }
   ],
   "source": [
    "! ls rst_result/quarantine_argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# ! zip -r rst_result.zip rst_result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "lengths = data.annot.map(lambda row: len(row['rst']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    6717.0\n",
       "mean        1.0\n",
       "std         0.0\n",
       "min         1.0\n",
       "25%         1.0\n",
       "50%         1.0\n",
       "75%         1.0\n",
       "max         1.0\n",
       "Name: annot, dtype: float64"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lengths.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id: 4\n",
      "text: согласно предписаниям Роспотребнадзора , все транзитные пассажиры , следующие через Москву , должны пройти 14-дневный карантин у себя по месту жительства .\n",
      "proba: 1.0\n",
      "relation: attribution\n",
      "nuclearity: SN\n",
      "left: согласно предписаниям Роспотребнадзора ,\n",
      "right: все транзитные пассажиры , следующие через Москву , должны пройти 14-дневный карантин у себя по месту жительства .\n",
      "start: 0\n",
      "end: 155\n"
     ]
    }
   ],
   "source": [
    "print(data.annot.iloc[0]['rst'][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "155"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data.annot.iloc[0]['rst'][0].text)"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}