predict_SP500_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Experiment of Recurrent Neural Network in predicting the price movements of SP500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "import pandas as pd\n",
    "from pandas_datareader import data as pdr\n",
    "import fix_yahoo_finance as yf\n",
    "from tqdm import tqdm_notebook\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "# import quandl\n",
    "import nltk\n",
    "import itertools\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "import collections\n",
    "from sklearn.manifold import Isomap,MDS\n",
    "from matplotlib import pyplot\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import sklearn\n",
    "import statsmodels\n",
    "yf.pdr_override()\n",
    "import scipy.stats as scs\n",
    "import statsmodels.api as sm\n",
    "import seaborn as sns\n",
    "from sklearn.metrics import classification,confusion_matrix,matthews_corrcoef,accuracy_score,classification_report\n",
    "from models.ffn_classifier import FFNClassifier\n",
    "import scipy.stats as stats\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Price Data Preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reset_seed(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    np.random.seed(seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "lmap=lambda fun,it:list(map(lambda x:fun(x),it))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*********************100%***********************]  1 of 1 downloaded\n"
     ]
    }
   ],
   "source": [
    "securities = pdr.get_data_yahoo([\"SPY\"], start=\"2005-01-01\", end=\"2018-05-30\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_number=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=securities['Adj Close'].fillna(method='ffill')\n",
    "diff=(data.shift(-1)/data-1).fillna(0)\n",
    "real_diff=data.shift(-1)-data.fillna(0)\n",
    "labels=pd.qcut(diff,q=class_number,labels=range(class_number)).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.\n",
      "  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f5fe36b8cf8>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.distplot(diff,fit=stats.t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f5fe36b5828>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels.plot(kind='kde')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Test Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(x,y,model,test_size=15,train_size=128,epoch=100, log_interval=10):\n",
    "    train_loss=[]\n",
    "    train_acc=[]\n",
    "    train_mcc=[]\n",
    "    dev_loss=[]\n",
    "    dev_acc=[]\n",
    "    dev_mcc=[]\n",
    "    best_result=None\n",
    "    best_score=0\n",
    "    global_step=0\n",
    "    best_result_epoch=0\n",
    "    for e in tqdm_notebook(range(epoch)):\n",
    "        pointer=0\n",
    "        \n",
    "        chunk_train_loss=0\n",
    "        chunk_train_acc=0\n",
    "        chunk_train_mcc=0\n",
    "        train_count=0\n",
    "        \n",
    "        chunk_test_loss=0\n",
    "        chunk_test_acc=0\n",
    "        chunk_test_mcc=0\n",
    "        test_count=0\n",
    "        test_yhat=[]\n",
    "        y_true=[]\n",
    "        \n",
    "        while pointer<len(x):\n",
    "            \n",
    "            train_x=x[pointer:pointer+train_size]\n",
    "            train_y=y[pointer:pointer+train_size]\n",
    "            train_length=len(train_x)\n",
    "            b_pointer=0\n",
    "            while b_pointer<train_length:\n",
    "                random_batch_size=np.random.randint(low=32,high=128)\n",
    "                batch_x=train_x[b_pointer:b_pointer+random_batch_size]\n",
    "                batch_y=train_y[b_pointer:b_pointer+random_batch_size]\n",
    "                loss,acc,mcc,_=model.train(X=batch_x,y=batch_y)\n",
    "                chunk_train_loss+=loss\n",
    "                chunk_train_acc+=acc\n",
    "                chunk_train_mcc+=mcc\n",
    "                b_pointer+=len(batch_x)\n",
    "                pointer+=len(batch_x)\n",
    "                global_step+=1\n",
    "                train_count+=1\n",
    "            if pointer>=len(x):\n",
    "                break\n",
    "            test_x=x[pointer:pointer+test_size]\n",
    "            test_y=y[pointer:pointer+test_size]\n",
    "            loss,acc,mcc,y_hat=model.test(X=test_x,y=test_y)\n",
    "            test_yhat.append(y_hat)\n",
    "            y_true.append(test_y)\n",
    "            chunk_test_loss+=loss\n",
    "            chunk_test_acc+=acc\n",
    "            chunk_test_mcc+=mcc\n",
    "            test_count+=1\n",
    "            pointer+=len(test_x)\n",
    "        chunk_train_loss=chunk_train_loss/train_count\n",
    "        chunk_train_acc=chunk_train_acc/train_count\n",
    "        chunk_train_mcc=chunk_train_mcc/train_count\n",
    "        \n",
    "        train_loss.append(chunk_train_loss)\n",
    "        train_acc.append(chunk_train_acc)\n",
    "        train_mcc.append(chunk_train_mcc)\n",
    "        \n",
    "        test_yhat=np.concatenate(test_yhat)\n",
    "        y_true=np.concatenate(y_true)\n",
    "        chunk_test_loss=chunk_test_loss/test_count\n",
    "        chunk_test_acc=accuracy_score(y_pred=test_yhat,y_true=y_true)\n",
    "        chunk_test_mcc=matthews_corrcoef(y_pred=test_yhat,y_true=y_true)\n",
    "        \n",
    "        if chunk_test_mcc+chunk_test_acc>best_score:\n",
    "            best_result=test_yhat.copy()\n",
    "            best_score=chunk_test_mcc+chunk_test_acc\n",
    "            best_result_epoch=e\n",
    "        \n",
    "        \n",
    "        dev_loss.append(chunk_test_loss)\n",
    "        dev_acc.append(chunk_test_acc)\n",
    "        dev_mcc.append(chunk_test_mcc)\n",
    "        model.reset_model()\n",
    "        if e%log_interval==0:\n",
    "            print('test loss',dev_loss[-1],'test acc',dev_acc[-1],'test mcc',dev_mcc[-1],'epoch:',e)\n",
    "            print('best_result_epoch',best_result_epoch,'acc',dev_acc[best_result_epoch],'mcc',dev_mcc[best_result_epoch])\n",
    "    return np.array(train_loss),np.array(train_acc),np.array(train_mcc),np.array(dev_loss),np.array(dev_acc), np.array(dev_mcc), best_result,y_true.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trade(a,price_diff,initial_price,test_size=15,train_size=128):\n",
    "    pointer=0\n",
    "    test_r=initial_price\n",
    "    bnh_r=initial_price\n",
    "    while pointer<len(x):\n",
    "        pointer+=train_size\n",
    "        if pointer>=len(x):\n",
    "            break\n",
    "        test_a=a[pointer:pointer+test_size]\n",
    "        test_a=test_a*2-1\n",
    "        test_p=price_diff[pointer:pointer+test_size]\n",
    "        test_r+=(test_p*test_a).sum()\n",
    "        bnh_r+=test_p.sum()\n",
    "        pointer+=len(test_p)\n",
    "    return test_r,bnh_r,test_r/initial_price,bnh_r/initial_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding:utf-8 -*-\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "import sklearn\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "\n",
    "class RNN(nn.Module):\n",
    "    def __init__(self, d_x, d_h, d_o, cell=nn.GRU, rnn_layers=2, ffn_layers=5, dp=0.5):\n",
    "        super(RNN, self).__init__()\n",
    "        self.dropout = nn.Dropout(p=dp)\n",
    "        self.rnn_layers = rnn_layers\n",
    "        self.rnn = cell(input_size=d_x, hidden_size=d_h, num_layers=rnn_layers, batch_first=True, dropout=dp)\n",
    "        self.hiddens = nn.ModuleList([nn.Linear(in_features=d_h, out_features=d_h) for _ in range(ffn_layers)])\n",
    "        self.lms = nn.ModuleList([nn.LayerNorm(d_h) for _ in range(ffn_layers)])\n",
    "        self.f_out = nn.Linear(in_features=d_h, out_features=d_o)\n",
    "        for p in self.rnn.parameters():\n",
    "            if p.dim() > 1:\n",
    "                nn.init.xavier_uniform_(p)\n",
    "    \n",
    "    def forward(self, x, hidden):\n",
    "        x_in, hidden = self.rnn(x, hidden)\n",
    "        output = x_in\n",
    "        for hl, lm in zip(self.hiddens, self.lms):\n",
    "            output = self.dropout(lm(F.leaky_relu(hl(output))))\n",
    "        output = self.f_out(x_in + output)\n",
    "        return output, hidden\n",
    "\n",
    "\n",
    "class RNNClassifier(object):\n",
    "    def __init__(self, d_x, d_h, d_o, rnn_layers=2, ffn_layers=5, lr=1e-3, cell=nn.GRU, dp=0.5):\n",
    "        super(RNNClassifier, self).__init__()\n",
    "        self.d_h = d_h\n",
    "        self.rnn_layers = rnn_layers\n",
    "        self.cell = cell\n",
    "        self.rnn = RNN(d_x=d_x, d_h=d_h, d_o=d_o, rnn_layers=rnn_layers, ffn_layers=ffn_layers, cell=cell, dp=dp)\n",
    "        self.loss_func = nn.CrossEntropyLoss()\n",
    "        self.optimizer = optim.Adam(self.rnn.parameters(), lr=lr)\n",
    "        if self.cell == nn.GRU:\n",
    "            self.tmp_hidden = torch.zeros(self.rnn_layers, 1, d_h)\n",
    "        elif self.cell == nn.LSTM:\n",
    "            self.tmp_hidden = (torch.zeros(self.rnn_layers, 1, d_h), torch.zeros(self.rnn_layers, 1, d_h))\n",
    "    \n",
    "    def reset_model(self):\n",
    "        if self.cell == nn.GRU:\n",
    "            self.tmp_hidden = torch.zeros(self.rnn_layers, 1, self.d_h)\n",
    "        elif self.cell == nn.LSTM:\n",
    "            self.tmp_hidden = (torch.zeros(self.rnn_layers, 1, self.d_h), torch.zeros(self.rnn_layers, 1, self.d_h))\n",
    "    \n",
    "    def train(self, X, y):\n",
    "        x = torch.tensor(X[None, :, :], dtype=torch.float32)\n",
    "        y_true = torch.tensor(y, dtype=torch.long)\n",
    "        self.rnn.train(True)\n",
    "        self.optimizer.zero_grad()\n",
    "        y_hat, self.tmp_hidden = self.rnn(x, hidden=self.tmp_hidden)\n",
    "        y_hat=y_hat.squeeze(0)\n",
    "        loss = self.loss_func(y_hat, y_true)\n",
    "        loss.backward()\n",
    "        clip_grad_norm_(self.rnn.parameters(), 1)\n",
    "        self.optimizer.step()\n",
    "        topv, topi = y_hat.topk(1)\n",
    "        y_hat = topi.view(-1).detach()\n",
    "        if type(self.tmp_hidden) == tuple:\n",
    "            self.tmp_hidden = tuple([h.detach() for h in self.tmp_hidden])\n",
    "        else:\n",
    "            self.tmp_hidden= self.tmp_hidden.detach()\n",
    "        acc = sklearn.metrics.accuracy_score(y_true=y.flatten(), y_pred=y_hat)\n",
    "        mcc = sklearn.metrics.matthews_corrcoef(y_true=y.flatten(), y_pred=y_hat)\n",
    "        return loss.item(), acc, mcc, y_hat.numpy().flatten()\n",
    "    \n",
    "    def test(self, X, y):\n",
    "        self.rnn.eval()\n",
    "        with torch.no_grad():\n",
    "            x = torch.tensor(X[None, :, :], dtype=torch.float32)\n",
    "            y_true = torch.tensor(y, dtype=torch.long)\n",
    "            y_hat, self.tmp_hidden = self.rnn(x, hidden=self.tmp_hidden)\n",
    "            y_hat=y_hat.squeeze(0)\n",
    "            loss = self.loss_func(y_hat, y_true)\n",
    "            topv, topi = y_hat.topk(1)\n",
    "            y_hat = topi.view(-1)\n",
    "            acc = sklearn.metrics.accuracy_score(y_true=y.flatten(), y_pred=y_hat)\n",
    "            mcc = sklearn.metrics.matthews_corrcoef(y_true=y.flatten(), y_pred=y_hat)\n",
    "            return loss.item(), acc, mcc, y_hat.numpy().flatten()\n",
    "    \n",
    "    def inference(self, X):\n",
    "        self.rnn.eval()\n",
    "        with torch.no_grad():\n",
    "            x = torch.tensor(X[None, :, :], dtype=torch.float32)\n",
    "            y_hat, self.tmp_hidden = self.rnn(x, hidden=self.tmp_hidden)\n",
    "            y_hat=y_hat.squeeze(0)\n",
    "            y_hat = y_hat.topk(1)[1].view(-1)\n",
    "            return y_hat.numpy().flatten()\n",
    "    \n",
    "    def load_model(self, model_path='./RNNModel'):\n",
    "        self.rnn = torch.load(model_path + '/model.pkl')\n",
    "    \n",
    "    def save_model(self, model_path='./RNNModel'):\n",
    "        if not os.path.exists(model_path):\n",
    "            os.mkdir(model_path)\n",
    "        torch.save(self.rnn, model_path + '/model.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experiment of pre-trained elmo encoded title, (mean with date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each news title is a vector produced by mean of Elmo representation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_index=np.load('data/title_elmo_index.npy')\n",
    "content=np.load('data/title_elmo.npy')\n",
    "content=pd.DataFrame(content,index=date_index)\n",
    "content=content.groupby(content.index).mean()\n",
    "content=content.join(labels).fillna(method='bfill').dropna()['2010-06':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=content.iloc[:,:-1].values\n",
    "y=content.iloc[:,-1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf=RNNClassifier(d_x=x.shape[-1],d_h=300,d_o=class_number,dp=0.5,ffn_layers=5,lr=1e-3,cell=nn.GRU,rnn_layers=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/sklearn/metrics/classification.py:543: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  mcc = cov_ytyp / np.sqrt(cov_ytyt * cov_ypyp)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test loss 0.8025929717456594 test acc 0.5411764705882353 test mcc 0.07709015273959047 epoch: 0\n",
      "best_result_epoch 0 acc 0.5411764705882353 mcc 0.07709015273959047\n",
      "test loss 0.694995171883527 test acc 0.5411764705882353 test mcc 0.07398404914154026 epoch: 5\n",
      "best_result_epoch 0 acc 0.5411764705882353 mcc 0.07709015273959047\n",
      "test loss 0.6940658618422115 test acc 0.5137254901960784 test mcc 0.024074074074074074 epoch: 10\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.6979085943278145 test acc 0.5333333333333333 test mcc 0.05728267726493279 epoch: 15\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.7138184694682851 test acc 0.4549019607843137 test mcc -0.08703703703703704 epoch: 20\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.6998851965455448 test acc 0.4980392156862745 test mcc -0.022243256038783615 epoch: 25\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.6973393278963426 test acc 0.4980392156862745 test mcc -0.022243256038783615 epoch: 30\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.7006353104815763 test acc 0.5058823529411764 test mcc 0.007415192869751505 epoch: 35\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.6985968491610359 test acc 0.5058823529411764 test mcc 0.008333333333333333 epoch: 40\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.6953685248599333 test acc 0.4745098039215686 test mcc -0.096968533484991 epoch: 45\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.6902153491973877 test acc 0.5450980392156862 test mcc 0.06973018138246544 epoch: 50\n",
      "best_result_epoch 9 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.6924103217966416 test acc 0.5098039215686274 test mcc 0.01849000654084097 epoch: 55\n",
      "best_result_epoch 52 acc 0.5647058823529412 mcc 0.12113877651108738\n",
      "test loss 0.6893454719992245 test acc 0.5843137254901961 test mcc 0.16236882817719775 epoch: 60\n",
      "best_result_epoch 60 acc 0.5843137254901961 mcc 0.16236882817719775\n",
      "test loss 0.690767319763408 test acc 0.5137254901960784 test mcc 0.024074074074074074 epoch: 65\n",
      "best_result_epoch 60 acc 0.5843137254901961 mcc 0.16236882817719775\n",
      "test loss 0.6904236954801223 test acc 0.5254901960784314 test mcc 0.03254950752160671 epoch: 70\n",
      "best_result_epoch 60 acc 0.5843137254901961 mcc 0.16236882817719775\n",
      "test loss 0.6968986988067627 test acc 0.47843137254901963 test mcc -0.0555706346991605 epoch: 75\n",
      "best_result_epoch 60 acc 0.5843137254901961 mcc 0.16236882817719775\n",
      "test loss 0.6926608260940103 test acc 0.5333333333333333 test mcc 0.06474291815950262 epoch: 80\n",
      "best_result_epoch 60 acc 0.5843137254901961 mcc 0.16236882817719775\n",
      "test loss 0.6995910546358894 test acc 0.49411764705882355 test mcc -0.022537446792760443 epoch: 85\n",
      "best_result_epoch 60 acc 0.5843137254901961 mcc 0.16236882817719775\n",
      "test loss 0.6927402405177846 test acc 0.5176470588235295 test mcc 0.02622219463244465 epoch: 90\n",
      "best_result_epoch 60 acc 0.5843137254901961 mcc 0.16236882817719775\n",
      "test loss 0.6902854933458216 test acc 0.5176470588235295 test mcc 0.01031087841966562 epoch: 95\n",
      "best_result_epoch 60 acc 0.5843137254901961 mcc 0.16236882817719775\n",
      "\n"
     ]
    }
   ],
   "source": [
    "train_loss,train_acc,train_mcc,dev_loss,dev_acc,dev_mcc,best_result,test_y=test(model=clf,x=x,y=y,test_size=15,train_size=150,epoch=100,log_interval=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fddd6f1d0>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_loss)\n",
    "plt.plot(dev_loss)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fddcda278>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_acc)\n",
    "plt.plot(dev_acc)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "elmo_cr=classification_report(y_pred=best_result,y_true=test_y)\n",
    "elmo_c=confusion_matrix(y_pred=best_result,y_true=test_y)\n",
    "elmo_acc=accuracy_score(y_pred=best_result,y_true=test_y)\n",
    "elmo_mcc=matthews_corrcoef(y_pred=best_result,y_true=test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5843137254901961"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elmo_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.16236882817719775"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elmo_mcc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[87, 48],\n",
       "       [58, 62]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "elmo_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.60      0.64      0.62       135\n",
      "         1.0       0.56      0.52      0.54       120\n",
      "\n",
      "   micro avg       0.58      0.58      0.58       255\n",
      "   macro avg       0.58      0.58      0.58       255\n",
      "weighted avg       0.58      0.58      0.58       255\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(elmo_cr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experiment of d2v encoded title, (mean with date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_index=np.load('data/title_d2v_index.npy')\n",
    "content=np.load('data/title_d2v.npy')\n",
    "content=pd.DataFrame(content,index=date_index)\n",
    "content=content.groupby(content.index).mean()\n",
    "content=content.join(labels).fillna(method='bfill').dropna()['2010-06':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=content.iloc[:,:-1].values\n",
    "y=content.iloc[:,-1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf=RNNClassifier(d_x=x.shape[-1],d_h=300,d_o=class_number,dp=0.5,ffn_layers=5,lr=1e-3,cell=nn.GRU,rnn_layers=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test loss 0.8002231997602126 test acc 0.4745098039215686 test mcc -0.041318652453394146 epoch: 0\n",
      "best_result_epoch 0 acc 0.4745098039215686 mcc -0.041318652453394146\n",
      "test loss 0.6897053052397335 test acc 0.5176470588235295 test mcc 0.02796483563391768 epoch: 5\n",
      "best_result_epoch 4 acc 0.5215686274509804 mcc 0.027078746481997443\n",
      "test loss 0.6998213739956126 test acc 0.47843137254901963 test mcc -0.04344349577349724 epoch: 10\n",
      "best_result_epoch 9 acc 0.5215686274509804 mcc 0.04724555912615341\n",
      "test loss 0.7020938852254082 test acc 0.5176470588235295 test mcc 0.02622219463244465 epoch: 15\n",
      "best_result_epoch 9 acc 0.5215686274509804 mcc 0.04724555912615341\n",
      "test loss 0.7722635304226595 test acc 0.4627450980392157 test mcc -0.06878654392272061 epoch: 20\n",
      "best_result_epoch 17 acc 0.5294117647058824 mcc 0.04129955231527934\n",
      "test loss 0.7073346937403959 test acc 0.5058823529411764 test mcc 0.007415192869751505 epoch: 25\n",
      "best_result_epoch 22 acc 0.5215686274509804 mcc 0.04922624211082283\n",
      "test loss 0.7581918975886177 test acc 0.49411764705882355 test mcc -0.018607171201297453 epoch: 30\n",
      "best_result_epoch 22 acc 0.5215686274509804 mcc 0.04922624211082283\n",
      "test loss 0.7846827156403485 test acc 0.5333333333333333 test mcc 0.05965831601902438 epoch: 35\n",
      "best_result_epoch 34 acc 0.5647058823529412 mcc 0.12373768848862807\n",
      "test loss 0.7889420214821311 test acc 0.5647058823529412 test mcc 0.12373768848862807 epoch: 40\n",
      "best_result_epoch 34 acc 0.5647058823529412 mcc 0.12373768848862807\n",
      "test loss 0.8241191839470583 test acc 0.5137254901960784 test mcc 0.01335449927278921 epoch: 45\n",
      "best_result_epoch 34 acc 0.5647058823529412 mcc 0.12373768848862807\n",
      "test loss 0.8832641839981079 test acc 0.5215686274509804 test mcc 0.0354598590272041 epoch: 50\n",
      "best_result_epoch 47 acc 0.5725490196078431 mcc 0.14024835016479711\n",
      "test loss 0.9146806299686432 test acc 0.5803921568627451 test mcc 0.1547387571743445 epoch: 60\n",
      "best_result_epoch 53 acc 0.592156862745098 mcc 0.1814814814814815\n",
      "test loss 1.008345761719872 test acc 0.5529411764705883 test mcc 0.09752613745962792 epoch: 65\n",
      "best_result_epoch 53 acc 0.592156862745098 mcc 0.1814814814814815\n",
      "test loss 1.1036077089169447 test acc 0.4823529411764706 test mcc -0.04385824669154192 epoch: 70\n",
      "best_result_epoch 53 acc 0.592156862745098 mcc 0.1814814814814815\n",
      "test loss 1.1443455832846023 test acc 0.49019607843137253 test mcc -0.023148148148148147 epoch: 75\n",
      "best_result_epoch 53 acc 0.592156862745098 mcc 0.1814814814814815\n",
      "test loss 1.1963050225201775 test acc 0.5098039215686274 test mcc 0.013025019840908217 epoch: 80\n",
      "best_result_epoch 53 acc 0.592156862745098 mcc 0.1814814814814815\n",
      "test loss 1.1747151069781359 test acc 0.4980392156862745 test mcc -0.007407407407407408 epoch: 85\n",
      "best_result_epoch 53 acc 0.592156862745098 mcc 0.1814814814814815\n",
      "test loss 1.3830535622204052 test acc 0.49411764705882355 test mcc -0.02055259932676348 epoch: 90\n",
      "best_result_epoch 53 acc 0.592156862745098 mcc 0.1814814814814815\n",
      "test loss 1.4111923014416414 test acc 0.5176470588235295 test mcc 0.027092062748915496 epoch: 95\n",
      "best_result_epoch 53 acc 0.592156862745098 mcc 0.1814814814814815\n",
      "\n"
     ]
    }
   ],
   "source": [
    "train_loss,train_acc,train_mcc,dev_loss,dev_acc,dev_mcc,best_result,test_y=test(model=clf,x=x,y=y,test_size=15,train_size=150,epoch=100,log_interval=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fdf3339b0>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_loss)\n",
    "plt.plot(dev_loss)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fdf29e2e8>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_acc)\n",
    "plt.plot(dev_acc)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "d2vc_cr=classification_report(y_pred=best_result,y_true=test_y)\n",
    "d2vc_c=confusion_matrix(y_pred=best_result,y_true=test_y)\n",
    "d2vc_acc=accuracy_score(y_pred=best_result,y_true=test_y)\n",
    "d2vc_mcc=matthews_corrcoef(y_pred=best_result,y_true=test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.592156862745098"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2vc_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1814814814814815"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2vc_mcc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[83, 52],\n",
       "       [52, 68]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2vc_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.61      0.61      0.61       135\n",
      "         1.0       0.57      0.57      0.57       120\n",
      "\n",
      "   micro avg       0.59      0.59      0.59       255\n",
      "   macro avg       0.59      0.59      0.59       255\n",
      "weighted avg       0.59      0.59      0.59       255\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(d2vc_cr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experiment of d2v encoded content, (mean with date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_index=np.load('data/content_d2v_index.npy')\n",
    "content=np.load('data/content_d2v.npy')\n",
    "content=pd.DataFrame(content,index=date_index)\n",
    "content=content.groupby(content.index).mean()\n",
    "content=content.join(labels).fillna(method='bfill').dropna()['2010-06':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=content.iloc[:,:-1].values\n",
    "y=content.iloc[:,-1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf=RNNClassifier(d_x=x.shape[-1],d_h=300,d_o=class_number,dp=0.5,ffn_layers=5,lr=1e-3,cell=nn.GRU,rnn_layers=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test loss 0.7979823666460374 test acc 0.4627450980392157 test mcc -0.0955050477812663 epoch: 0\n",
      "best_result_epoch 0 acc 0.4627450980392157 mcc -0.0955050477812663\n",
      "test loss 0.6938078263226677 test acc 0.5215686274509804 test mcc 0.027078746481997443 epoch: 5\n",
      "best_result_epoch 5 acc 0.5215686274509804 mcc 0.027078746481997443\n",
      "test loss 0.7009051722638747 test acc 0.4549019607843137 test mcc -0.09248988308500374 epoch: 10\n",
      "best_result_epoch 8 acc 0.5372549019607843 mcc 0.0712962962962963\n",
      "test loss 0.6993202567100525 test acc 0.5372549019607843 test mcc 0.06488998880388966 epoch: 15\n",
      "best_result_epoch 8 acc 0.5372549019607843 mcc 0.0712962962962963\n",
      "test loss 0.704559838070589 test acc 0.49411764705882355 test mcc -0.029905621022416718 epoch: 20\n",
      "best_result_epoch 8 acc 0.5372549019607843 mcc 0.0712962962962963\n",
      "test loss 0.6925613599665025 test acc 0.5372549019607843 test mcc 0.06488998880388966 epoch: 25\n",
      "best_result_epoch 8 acc 0.5372549019607843 mcc 0.0712962962962963\n",
      "test loss 0.7097901456496295 test acc 0.4980392156862745 test mcc -0.007407407407407408 epoch: 30\n",
      "best_result_epoch 27 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.7175583173246944 test acc 0.5254901960784314 test mcc 0.04724555912615341 epoch: 35\n",
      "best_result_epoch 27 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.7625822459950167 test acc 0.5254901960784314 test mcc 0.04812735686763539 epoch: 40\n",
      "best_result_epoch 27 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.8406630403855267 test acc 0.5372549019607843 test mcc 0.0712962962962963 epoch: 45\n",
      "best_result_epoch 27 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.803748632178587 test acc 0.5333333333333333 test mcc 0.058063430971841724 epoch: 50\n",
      "best_result_epoch 27 acc 0.5450980392156862 mcc 0.08703703703703704\n",
      "test loss 0.823214532697902 test acc 0.6039215686274509 test mcc 0.21980171108311994 epoch: 55\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "test loss 0.9327855197822347 test acc 0.5725490196078431 test mcc 0.14511976247742694 epoch: 60\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "test loss 1.203159312991535 test acc 0.5607843137254902 test mcc 0.11771618680730514 epoch: 65\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "test loss 1.0795426123282488 test acc 0.5803921568627451 test mcc 0.15826496200703177 epoch: 70\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "test loss 1.2974323805640726 test acc 0.5137254901960784 test mcc 0.028659510138303503 epoch: 75\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "test loss 1.2746578016701866 test acc 0.5568627450980392 test mcc 0.11106313123300475 epoch: 80\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "test loss 1.6185338549754198 test acc 0.5176470588235295 test mcc 0.02622219463244465 epoch: 85\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "test loss 1.5495933925404268 test acc 0.5529411764705883 test mcc 0.11129676054902964 epoch: 90\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "test loss 1.738401051829843 test acc 0.5098039215686274 test mcc 0.013025019840908217 epoch: 95\n",
      "best_result_epoch 55 acc 0.6039215686274509 mcc 0.21980171108311994\n",
      "\n"
     ]
    }
   ],
   "source": [
    "train_loss,train_acc,train_mcc,dev_loss,dev_acc,dev_mcc,best_result,test_y=test(model=clf,x=x,y=y,test_size=15,train_size=150,epoch=100,log_interval=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fdf14d0b8>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xd8VFXawPHfSa8kpAIJIQFCCb0KIoLYKAqoKKKsZVXWtW3zXetr29ddV91dsbJY1wbWBVQEKYKCtNBDKAkQSAKkkkJIz3n/OAlJSELaTCYzeb6fD5/J3Hvm3nMdfDh57rnPUVprhBBCOBYnW3dACCGE5UlwF0IIByTBXQghHJAEdyGEcEAS3IUQwgFJcBdCCAckwV0IIRyQBHchhHBAEtyFEMIBudjqxEFBQToyMtJWpxdCCLu0ffv2TK11cGPtbBbcIyMjiY2NtdXphRDCLimljjWlnaRlhBDCAUlwF0IIByTBXQghHJDNcu71KS0tJSUlhaKiIlt3xeo8PDwIDw/H1dXV1l0RQjigdhXcU1JS8PX1JTIyEqWUrbtjNVprsrKySElJISoqytbdEUI4oHaVlikqKiIwMNChAzuAUorAwMAO8RuKEMI2Gg3uSqn3lFLpSqm4Bvb7KaW+UUrtVkrtU0rd2ZoOOXpgr9JRrlMIYRtNGbl/AEy+wP77gXit9RBgIvAPpZRb67smhBAOaN0LcPRnq5+m0eCutf4JyL5QE8BXmaGoT2XbMst0r23l5OTw5ptvNvtzU6dOJScnxwo9EkI4lLwTsO5vcHyz1U9liZz760B/4ASwF/id1rrCAsdtcw0F97KyC/9btXz5cvz9/a3VLSGEo4hfal4HzLT6qSwR3K8GdgHdgKHA60qpTvU1VErNU0rFKqViMzIyLHBqy3r00Uc5fPgwQ4cOZdSoUYwfP57p06cTExMDwMyZMxkxYgQDBgxg4cKF5z4XGRlJZmYmSUlJ9O/fn3vuuYcBAwZw1VVXUVhYaKvLEUK0N/v+C6EDISja6qeyxFTIO4EXtNYaSFRKHQX6AVvPb6i1XggsBBg5cqS+0EGf/WYf8SfyLNC9ajHdOvH0tQMa3P/CCy8QFxfHrl27WLduHdOmTSMuLu7cdMX33nuPgIAACgsLGTVqFDfccAOBgYG1jpGQkMCiRYt4++23uemmm/jqq6+YO3euRa9DCGGHclMheQtMerJNTmeJkftx4HIApVQo0Bc4YoHj2tzo0aNrzUN/9dVXGTJkCGPGjCE5OZmEhIQ6n4mKimLo0KEAjBgxgqSkpLbqrhCiPatKycRc1yana3TkrpRahJkFE6SUSgGeBlwBtNYLgL8AHyil9gIKeERrndnajl1ohN1WvL29z/28bt06Vq9ezaZNm/Dy8mLixIn1zlN3d3c/97Ozs7OkZYQQxr7/QuggCOrdJqdrNLhrrec0sv8EcJXFemRDvr6+5Ofn17svNzeXzp074+XlxYEDB9i82fp3u4UQDiInGVK2wqT/bbNTtqvyA7YWGBjIuHHjGDhwIJ6enoSGhp7bN3nyZBYsWED//v3p27cvY8aMsWFPhRB25dwsmbZJyQAocx+07Y0cOVKfv1jH/v376d+/v036Ywsd7XqFcDhaw4mdEDb8wu3euQLKiuHe1j+8pJTarrUe2Vi7dlVbRggh7MqRH+Hty+DIuobb5KZCyjaImdFm3QIJ7kII0XIpldmHQz803ObgcvPaf7r1+1ODBHchhGipk7vN6+E1Dbc58B0E9obgPm3Tp0oS3IUQoqVO7gEnF8g4ALkpdfcX5kDSz9BvWpt3TYK7EEK0xNlsyD0Og2407w+vrdsmcTVUlEG/a9q2b0hwF0KIlqlKyQyeDb7dILGe1MyBb8E7BMIandxicRLcG/HMM8/w8ssv27obQoj2piq4dx0CvSaZGTMV5dX7y4ohYTX0nQJObR9qJbgLIURLnNwNfhHgFQC9LoOiHDPnvcrRn6Ek3yYpGZDgXq/nn3+ePn36cMkll3Dw4EEADh8+zOTJkxkxYgTjx4/nwIED5Obm0qNHDyoqTPn6goICunfvTmlpqS27L4RoC6f2QNfB5udekwBVOzVz8Dtw9YaoS23SvfZbfuD7R+HUXsses8sgmPLCBZts376dxYsXs2vXLsrKyhg+fDgjRoxg3rx5LFiwgOjoaLZs2cJ9993H2rVrGTp0KOvXr+eyyy7j22+/5eqrr8bV1dWy/RZCtC9FeZCVCINvNu+9AqDbMDMlcuIj5mbrgeUQfQW4etiki+03uNvIzz//zHXXXYeXlxcA06dPp6ioiF9++YUbb7zxXLvi4mIAZs+ezWeffcZll13G4sWLue+++2zSbyFEG0qLM69dh1Rv6305/PwP+OpuiF8G5cUw5Bbb9I/2HNwbGWG3pYqKCvz9/dm1a1edfdOnT+fxxx8nOzub7du3M2nSJBv0UAjRpmreTK0SfTX89BIcWgnDb4ORd0Ko7UqXS879PJdeeilLliyhsLCQ/Px8vvnmG7y8vIiKiuKLL74AQGvN7t3my/Xx8WHUqFH87ne/45prrsHZ2dmW3RdCtIWTu8GnC/hWV46l+yiYtw7+dACmvWzTwA4S3OsYPnw4s2fPZsiQIUyZMoVRo0YB8Mknn/Duu+8yZMgQBgwYwNKlS899Zvbs2Xz88cfMnj3bVt0WQrSlk3tqj9qrdBsGbt51t9tAU1Zieg+4BkjXWg9soM1E4BXMCk2ZWusJluxkW3viiSd44okn6mxfsWJFve1nzZqFrUonC9HhlZdByRnw9G+b85UWmnID/aa2zflaqCk59w+A14EP69uplPIH3gQma62PK6VCLNc9IYSoR1kxfHANZB6Eolyzbdo/YNTd1j93Wjzo8vpH7u1Io2kZrfVPQPYFmtwCfK21Pl7ZPt1CfRNCiPplJZpl6yIuhgmPgmdAdflda6qogPUvgLM7hI+y/vlawRKzZfoArkqpdYAvMF9rXe8ovym01iilLNCt9k3SOEK0QvZR8zrhz2YVpOObIDPB+ufd8hYk/ABTXwbfLtY/XytY4oaqCzACmAZcDfyvUqrewsVKqXlKqVilVGxGRkad/R4eHmRlZTl84NNak5WVhYeHbR5uEMLunU4yr50jzWtQtAnu1owdJ3bBqqeh77S2Sf+0kiVG7ilAlta6AChQSv0EDAEOnd9Qa70QWAhmDdXz94eHh5OSkkJ9gd/ReHh4EB4ebutuCGGfTieBux94djbvg/pAcS4UZICPFW77FefDl782x57xOthBdsESwX0p8LpSygVwAy4C/tWSA7m6uhIVFWWBLgkhHNrpoxAQWR1kA3ub18xD1gnu6/8O2Ufgjm9NqQE70JSpkIuAiUCQUioFeBoz5RGt9QKt9X6l1ApgD1ABvKO1jrNel4UQHd7ppNoPCQVVZoIzEyDyEsueKzcVtiyEITdb/thW1Ghw11rPaUKbl4CXLNIjIYS4kIpyyDlee+m6TmHg4mmdm6rr/w66AiY+ZvljW1H7rS0jhBD1yTsB5SXQuUYK18kJgnqbtExz5Z8yS+QV5Zncuk8IDL0VnF3MPxY7P4bR90DnHpa7hjYgwV0IYV/OnylTJagPpG5v/vFWPQ17FtfeFvsezHwT1r8Irp4w/uGW9NSmJLgLIexLVXAPOG/yRWA0xH0NpUXNq6Gecwy6XwRzFoObDxxcDssfhn9faha3nvAo+ARbrPttRQqHCSHsy+mjoJyh03lTiYOiAW1mtTRHXqr5LcArAFzcYMBMuH8rDJwFwf1h7P2W6nmbkpG7EMK+nE4C/+4mJ15TULR5zTwEoTFNO1ZFBeSdhE7dam/3CoDr/93qrtqSjNyFEPbldFLtm6lVqua6ZzVjxkxBBlSUmtk2DkaCuxDCvmQfrXszFUwd9U7hzZsOmZdqXs8fuTsACe5CCPtRlAuF2fUHd6iuMdNUeSfMqwR3IYSwodPHzOv5M2WqNLeA2LngLmkZIYSwndOVpX4bHLn3gZJ882ASmCBfUdHw8fJSwckVvIIs2s32QIK7EMJ+NPQAU5WaM2Z2LYKXo2Hl4w0fL+8EdOpqnnB1MI53RUIIx3U6yay65OFX//7AyuD+1V2w5F5TTmDPZ2ad1frknXDIlAxIcBdC2JOGZspU6dQNvAKhvBSueQVmvmVuwCZvqb99XqpD3kwFeYhJCGFPTidBt2EN71cK7l5jRvZeAWbk7uwOB76DyHG122ptRu79r7Fql21FRu5CCPtQXga5yQ3PlKkSEFW9oIa7L/ScAAe+rTuD5mw2lBdLWkYIIWwqL8UU8rpQWqY+/aaZ4mDp8ecdz3EfYAIJ7kIIe5G+37wG92ve5/pMAZRJzdTkwHPcoQnBXSn1nlIqXSl1waXzlFKjlFJlSqlZluueEEJUOlUZgkL6N+9zvqEQPqqe4C4j9w+AyRdqoJRyBv4O/GCBPgkhRF1pe03BMHff5n+23zQ4uQtyU6q35Z0wpYN9Qi3Xx3ak0eCutf4JyG6k2YPAV0C6JTolhBB1nIqDLgNb9tmq9VYPLK/elncCfLuAk3Pr+9YOtTrnrpQKA64D3mpC23lKqVilVGxGRkZrTy2E6ChKCswiHKGDWvb5oGhTmmD/suptDjzHHSxzQ/UV4BGt9QUKOBha64Va65Fa65HBwfa3bJUQwkbS4gHd8pE7QMxMOLYR8tPM+7wTEtwbMRJYrJRKAmYBbyqlZlrguEIIYaTtNa+hrQjuA28AXQHxS6sfYHLQmTJggeCutY7SWkdqrSOBL4H7tNZLWt0zIUTHlLodXoquvRbqqThw9wP/iJYfN6QfhAyAuK9MXfjSgo49cldKLQI2AX2VUilKqbuUUvcqpe61fveEEB3Oge+gIB12L67elhYHoQNMeYHWGHg9JG+G5K3mvQMH90Zry2it5zT1YFrrO1rVGyGESNpoXvd+CRMfMymUtH0w9JbWH3vg9bD2L7DpdfPegdMyUjhMCNF+lBaatEynMMg+DCd2gqc/lJxpXb69SkBP6DYcjq437x145C7lB4QQ7UfKNqgohcufNiskxX1V/WRqa2bK1DTwhsofFPh0scwx2yEJ7kKI9uPYL4CCPldD7ysg7ms4tQeUE4TEWOYcA64zrz4h4OJmmWO2QxLchRDtR9IG6DLIpGIGzYL8E7DzYwjsDa6eljmHXxhEXVq9apODkpy7EKJ9KCs2aZmRvzbv+04BVy/IPwkRYy17rps+vPDC2Q5ARu5CiPbhxE4oK4IeF5v3bt4mwIPl8u1VPDuDd6Blj9nOSHAXQlhG9lGTI9+3BOKXQdbhum0O/QCLb61/X9IG8xpxcfW2wbPN64WW1hP1krSMEMIy/vub2gtRd46Ch3bWfvBoywI4vAaOrIOpL8GQOdX7j/0Cwf1rj6ijr4J71prpi6JZZOQuhGi98jI4uRuGzoXfboKJj8Ppo5CZUN2mtNAU7hp4A3QdCkt+C5/fBsnboLzU/MNw/iLWSkHYiNY/mdoBychdCNF6WYkmXx41HkJjwN0H1v0VEn6A4D6mzfFNps2QOdBrEmz4F/z8D1OG1y/CPKjUY9yFzyOaTEbuQojWO1VZtbFLZb11/wiz1mniquo2h9eCs5u5YerkDJc+DA8fgumvmUUzPPzNFEVhETJyF0K03qk94OxuFsSoEn0lbF4AxWfMSP7wjxAxxsyCqeLuC8NvM3+0lvSLBcnIXQh7l30EDq6wbR9O7TELVzu7Vm/rfaUpJXB0PeSfMpUde13e8DEksFuUBHch7N2Pf4XFc2rfvGxLWpu0TJfzlsCLGAtuPpCwyozaweTaRZuQ4C6EvUvealYYWv+ibc6fdwLOZkHXIbW3u7hBz4mVwX0NeAdbprKjaBIJ7kLYszPpkHMMvEMg7kvIONT2fTj/ZmpN0VdBXop5qKnnZeAkIaetNGUlpveUUulKqbgG9t+qlNqjlNqrlPpFKTWkvnZCCCtI2WZer/kXuHjC+r+3fR9O7QGUWSnpfL2vMK/lxZKSaWNN+Wf0A2DyBfYfBSZorQcBfwEWWqBfQoimSNkGTi7Q+3IYfY+pf55xsG37cGqPWQTD3bfuPr+w6lRMr8vatl8dXKPBXWv9E5B9gf2/aK1PV77dDIRbqG9CiMakxEKXwaYc7sUPmSqKbT16P7kHug5ueP9F95onV30dd2GM9sjSCbC7gO8tfEwhRH3Ky8ySdOGjzHvvQLjoN2b0nrytbfpQmGNy/vXl26sM/xXMfKNt+iPOsVhwV0pdhgnuj1ygzTylVKxSKjYjI8NSpxaiY0qPh9Kz0H109bbxfwTfbvDtH0zwt7a0qiXwLjByFzZhkeCulBoMvAPM0FpnNdROa71Qaz1Saz0yODjYEqcWouNK2Wpew0dWb3P3hcl/g7S9sLUNbn+dmykjwb29aXVwV0pFAF8Dv9Ja22AelhAdVEqsmTvu36P29pgZ5unQH5+H3FTr9uHUXjMN0zfUuucRzdaUqZCLgE1AX6VUilLqLqXUvUqpeyubPAUEAm8qpXYppWKt2F8hRJWUbRA+uu5j+0qZWukVZbDiEfMEaXOVl8GS+01O/0JSt1/4ZqqwmUYLh2mt5zSy/27gbov1SAjRuLPZpszu0Fvr3x8QBRP+DGuegy/vNJUX65uq2JDU7bDrYyjKgZs/qb9N1mHIOGCKfol2R6pCCmGPUip/Qa55M/V8l/wRlDOseRbS9sHsjyG4b9OOf3iNeT200vxD4hVQt83+Zea1//Sm91u0GXkWWAh7lLLVBO4LrS2qFFzye7htGRSehrcvh/y0ph0/cQ34hJqqjvv+W3+b+KVm+Tv/7s3vv7A6Ce5C2KOjP5tcd83a6A2JGg+3fAYl+XDkx9r7ystg69um5nqVs9lwYgeMuNOsabrns7rHzDkOJ3ZCjIza2ysJ7kLYm7PZZuTe+8qmf6brMPDsbP5RqOnQClj+MGyq8ZDRkXWmymTvy2HIbLO2afaR2p/b/415lZRMuyXBXQh7c3itCb59rm76Z5yczPqkST/V3p7wg3ndutAsYA0m3+7hZ1Iug24CFOz5vPbn4pdB6CAI7NXiyxDWJcFdCHuT8AN4BV44316fqEtNOuX0MfNea1Nr3b8HnM006RetIXGtqcPu7GIKf0WNh92Lq6dU5p2E5M2SkmnnJLgLYU8qyk1A7n2lWWS6OSLHm9ekytRM2j7IP2EWqu4y2KRm0vebbTWXwxt8M5w+av5RqaiAA9+a7ZKSaddkKqQQ9iR1BxRmm8WnmyukP3gFmbz7sLnVKZneV4KLB3x9D6x8zGyrWXs9ZjqsfBw+vcmka5SzWQg7pF/rr0dYjYzchbAnCStBOZmbnc2lFEReYkbuVSmZLoOhU1cYcB10CjM3U4P61J7e6O4Lv90I01837Tr3gIsftNglCeuQkbsQ9iThB+h+kZn50hJR4yF+iZnGmLwFLvmD2e7sasoFr3qqdkqmil+4Kd07/Fct77toUzJyF8Je5J+Ck7vNuqQtFXmpeV3zLOjy2scacQf0mWxSNsLuychdCHuRsMq8tia4B0WbJ0+PrDOj/5rlgj38zMNOwiHIyF0IexG/1CzEUd9C1E2lVPWsmV6XN3/GjbAbEtyFsAdHf4LEVTDqrrolfpsrqjK4t+Y3ANHuSVpGiPauohxWPA5+ETD2/tYfb+ANkHcC+l/b+mOJdkuCuxDt3c6PzbJ5s94HV8/WH8/dFy57vPXHEe2apGWEaM+K8mDtX6D7GDPHXIgmasoye+8ppdKVUnEN7FdKqVeVUolKqT1KqeGW76YQHdTP/4CCDLPodWtz7aJDacrI/QNg8gX2TwGiK//MA95qfbeEEFSUw44PzYLXYTJmEs3TaHDXWv8EZF+gyQzgQ21sBvyVUl0t1UEhOqzU7aaOjBToEi1giRuqYUByjfcpldtOnt9QKTUPM7onIiLCAqcWwk5VlMNHM81Tpx7+5oGiix+snqYIptSAcqpdxEuIJmrTG6pa64Va65Fa65HBwcFteWoh2pfTSWbuuruvmQGTvMXUdanp0EpTR6a+xamFaIQlgnsqUHOF3PDKbUKIhqTvN69TX4Lbl8HEx8y6pSd3m+15J+HUnpaV9hUCywT3ZcBtlbNmxgC5Wus6KRkhRA3p8eY1uLIm+pDZpqZ67PvmfWJVHZlmLKUnRA1NmQq5CNgE9FVKpSil7lJK3auUureyyXLgCJAIvA3cZ7XeCuEo0uOhcyS4eZv3np1hwPWw9wsozjcpmU5hrasjIzq0Rm+oaq3nNLJfAxZ4JlqIDiR9P4TE1N428k7Y/SnsWmSqNg6aJXPbRYvJE6pCtLWyYshKNMve1RQ+CkIGwJrnoOSMpGREq0hwF6KtZSVCRVndkbtSZvRekg/O7tBzgm36JxyCBHch2lrVTJnzgzvA4JvA1cusdVqVjxeiBaQqpBBtLW0fOLlAYO+6+zz8YO7X4BPS9v0SDkWCuxBtLX0/BEaDi1v9+3uMbdv+CIckaRkhrCnvBPxzABz9uXpbenzdm6lCWJgEdyGs6eByyEuBn14y74vPQM6x+vPtQliQpGWEsKbENeb16Ho4tRfKSsx7GbkLK5ORuxDWUlYMR9bDwFlmBszmt6rLDoTKyF1Yl4zchbCW45uhtMA8aeoVYOrGlBWBiyf4R9q6d8LBychdCGtJXAXObhA5Hi661zy4FPcVhPQDJ/lfT1iX/A0TwloSVkPEWHD3gcBe0G+a2S43U0UbkOBuC8Vn4ONZkH7A1j0RlpJ9BLb/p/qGaW4KZOyvXY99bGV9Pan0KNqA3eXcC0vK2Z2Sw6jIAJyd7LRi3sld5lf2HhebX9GF5ZUWQtJGU0q362BwdoXCHNj5McS+a1Y4mvlW7aqLeSehrBACejb9PKnbYeN82P8N6ApTzfGGdyBxtdnf+4rqtj0uhlu/hIgxFrlEIS7E7oL793En+ePnu1nx+/H069LJ1t1pmYyD5rWqxoiwjKJcSFgF+5eZ19KzZruLpwnwp+LMDc7AaNi9CLoMqh5NZx2G966G8lK4fyv4hlYfV2tzrPNrvez/Fj67Fdz9YNzvTLGv9S+Yf1DOpEGn8OrFOKrIykqijdhdcB/RozMAsUmn7Te4Zx4yrxLcLWP3YvMnaQNUlIJPKAyZA/2mmhRY8hZIiYWYGTDmXugyGD6bCz/8L3QbBv494MOZZtHq0kL47o8w+2Mzqi8vgy9uNyP0h3aBq0f1eXd9ahbUuH+LWQsVzMh/43zz8/DbpR67sJkmBXel1GRgPuAMvKO1fuG8/RHAfwD/yjaPaq2XW7ivAEQEeBHk4872Y6eZO6aHNU5hfVXBPfOgCR7OdvdvbPtxbBP89zcmlTL2Pug7zdRFrzkbZcDMup+b+SYsvAy+uAM8/KHwNNzxjZmXvvpp2PdfGHAdLH8YDnxrPpPwA8RMNz+XFMDhNTD8turADnDFs3A2G3Z+BH0mW+2yhWhMo1FFKeUMvAFcCaQA25RSy7TW8TWaPQl8rrV+SykVg1l6L9IK/UUpxcgendl+7LQ1Dt82Mg6Z9TLLisyNuOA+tu6R/dr7hUm7/OZnMyulqTz8YPZH8PblJhf/q6/NKD50EMQvNUH95C7Y/j5c/KD5zSDuy+rgfnit+f76XVP7uErBtfPNqD18pOWuU4hmaspsmdFAotb6iNa6BFgMzDivjQaqciR+wAnLdbGui8LcOZ59lvT8ImuexjqKz5haI1W51/T4C7cXDSsvhfgl0Hdy8wJ7ldABcMe38OvvTf10ML9FzXgDivJMemXQTXDFc2YUf2il2Q4m3+7hDz3G1T2ukzN0HyUpGWFTTQnuYUByjfcpldtqegaYq5RKwYzaH7RI7+qzbwm3/XIl3chke5Idjt6zEsxrv2sBJXn35tC69vuj6+Fslnm8v6XCR0LYiNrbQmNg2j9g6K0m0Ds5mXOUFZlCYOWlcOh76DtFUmqi3bLUPPc5wAda63BgKvCRUqrOsZVS85RSsUqp2IyMjJadKWwETuXF3Om2yj5TM5mVwb3rEJMnlpF70+z9El7qZaY3ntv2lZmpYo0ZKCNuN3n5qprr3UeDX4TpR9IGMzPn/JSMEO1IU4J7KtC9xvvwym013QV8DqC13gR4AEHnH0hrvVBrPVJrPTI4OLhlPfbvjoqZzi3Oa4lLsmr2xzoyDoJyNoE9pL+M3Jvi+GZY8lszSl9yLxTnQ2mRudHZ/1pwcbd+H5SCgdfDkR9hx4cmz99rkvXPK0QLNSW4bwOilVJRSik34GZg2XltjgOXAyil+mOCewuH5k0w5n68dQH9076hqLTcaqexisxDEBBlRoQhMZB92AQqUb/sI7D4FvDrDnMWQ04yrHzczFwpzoNBN7RdXwbNMvVh9n0NvS8HN6+2O7cQzdRocNdalwEPACuB/ZhZMfuUUs8ppSqnDvAn4B6l1G5gEXCH1ucnSC2o+yhyA4Zwm/qe3cezrXYaq8g8BEF92Z2cQ1lQP/NUY1Ue3p5VlENFhWWPmb4fPrnJ/De69QuT4x73kBk5r34GvIMh8lLLnvNCQgdCUF/zs6RkRDvXpJy71nq51rqP1rqX1vr5ym1Paa2XVf4cr7Uep7UeorUeqrX+wZqdBnAedz9RTmlk7Tz/l4h2rLwMsg5z3CmMGW9sZEF8ZT7X3lMzuanw2nBY+Vjrj1V8Bra+DQsnwptjTI2Wmz81hbcALnui+jeemJlte0NTKRh2K7h6Q5+r2+68QrSA3RYO8xl6A2kqiKjED23dlaY7nQQVpSxNNdP2XtlVQYWTq33fVC3KhU9mmWvb/oF5gKclKipg5yfmH4nlD5v0x9V/g9/vNTVZqri4w3X/NvcsRtxuiStonrEPmD55BbT9uYVoBrsN7ji7EBsyi/5Fu6iI/8bWvWmayidT12T48+iUfnTp7EsS3Sg/ZafBvawYFt9qruvqv5qpgrs+rb+t1rDu7/Ddw3WnNGYchLcvg6X3mdz6r3+AezeYJ0596rnx3nUwPLTT1IZpa07O4B3Y9ucVopnsN7gDRUPvYFdFTyo+v50nn/8L419cyw/7Ttm6Ww3LNAXDcr0juePiSP52/SDiSruRn7zHxh1rAa1h6QOQ9DPMeNMU4Oo+xlRcPD/3rjWs+l9Y91fY9rZZsKJbq8SeAAAcLElEQVRKWTF8fjvkJsP178DdqyHiora9FiEckF0H98sG9+Kj3q+S5NGf50r/ybVs4L5PdjQ5wCem55N7ttTKvayWeXQvadqfWycMwsPVmfHRwbh1HYB/8Uke+/QXHv1qD08vjSM2yco3iSssMMNo9yLY+7nJgQ+ZbbaNutvMbjnyY3U7rU2tll9eM/u7DYMVj5lH/gF+esnUPZ/5Fgy+UZ7qFMJC7Dq4B3i78Y/bxtP7DytxirqE/zn7Tx7pvI77P93Bqvg0SssrOHgqn2/3nGBVfBq7k3M4nnWWjzcf49rXNnDFP3/i2tc3cCyroE36m5u8j2MqnFsuiji3bfwlZrZHZtIe1h5I54vtKdz47038bfn+Bqd5FhSXkZx9lqwzxZwtKaNZE5N+/ic83xW++Z0JxC2RkwzfPwIRF8P4P1Vvj5kOXkGw7V3zvrTItNs4H0beBVNfhmtegbOZsOY5OLnb9GfIHLlBKYSFOcaz0+4+cMvnqK/u5p4D/6Zrp5Pc93EFKCdKy+sPfONCSvg+4gsOpBfy3JuT+MOdv2JguD/J2Wf5akcKBcVljOgRwKjIzgT61H5I5nDGGd788TDJ2Wf5/RXRXNy7+nktrTW5haV4uDrj4epMUWk5q+LT+Hp7MvOLj3E27Bq83Kr/s3uHm7zx255vQFA0pT7dWJvmyTcbNvGnfZFMGdWf8CA/wgI7se+0C1/uOsWq+DSKy6pTH85Ois5ebgR6u9E7xIfrh4cxoU8wLs7n/du9ezGseRa6DELv+hR2fEhB+AS8nUtROcch/5SpSe7uY2qXu3iYG5iuXjDwBhg21zyAtfR+M/qf+abJQVdxcTdVEje+AvHLYO3/mVTUmPvgqufNqLzbUBj9G9iywCxo4R1k8vVCCItS1pyOfiEjR47UsbGxlj1oRTmsego2vc4hv4s5FHgFYb7OhPo4U+gbxTHP/qQVuTDu7Bq6b3kGVVZChXLCqbSAo7orx7wGkJZfhlaKw3Tn09IJFOBJRIAXMSFuzHDaiG/WHuKyoMDJBMCcwjIGh/sxroc3mSmJFKQn4VOSjjdFeKtiXCkjSYeS5hLGlIr1lF71d1wvvre6z1rDzy+bUWxuivlTUP/zXwXanXjVm7Mhw/Ho2o8C5cUZvMgrdaLgbCEFhUXkpycRXbKf0S6H8XMt5ye/6fzgMZmwgngeP/0ke10G8HvnJynOz+QOp+Vc7bSNIvdAgsKiCQ6LNHVTivNNSduyYnOTNP+kmdET0NPMXNn5MVzzCsejZpNXVEp4Z0/8PF1RSkHOcXhlMKBNrfPpr9ZejQjM8V8fDfknzDTHqrVFhRCNUkpt11o3WnLUsYJ7la1vw/d/Ng+/1KScwD/CTNvrPsaMPH1Cydn+BcfXvENIRRrerk54uVTgfDaDMrdO7O4yi2Nn3Rmf9TnBOotc7Y23Uwkuum6uPl97ku0aCp3CKHb24SzulGtFb+dTdMpLQBWehnvWQtjwC/e/+AycTqI86yinT2eRmVdATt4ZupUlE14Qh1PaXjNVsAGlrp044NKXsqIChul4zihvnNBkuYTwcth8nDz9CfP3JLyzJ0Wl5fz7pyOczC1ibM9A7hgXyaR+IbjWHPVrDYdWwJq/QPo+6H0lPwx9jfs+3UlZhfn74+PuwtUDuvDY1H4EbX7BPD16+VOmtG59UneYkrojf33h/xZCiFo6dnAHOJNhllRzdsNUX9wHx7eYgBI1Acb8tlZKQWttRp5VUrab9ML+bwANkeMpu/j3lEdNxN3F2azYU1IASpGUVUBs8hnG9I8kPMC7TlcqT2BGwjVX8mmp0kKTQinKNUG0vAScXM06oV5BENi7erGK1O2w8VXISoRbPgO/8DqHKyot59Mtx1mw/jDp+cWE+Lpz3fAwegX70MnDBT9PN4Z098PLxQmOruPH/AjmfXGIAd38+M2lPUnNKSQx/Qxf7UjB09WZR6b0Y86oCJzsdY1bIdoxCe6Wkn0ESs5Cl4G27onVlZVX8OPBDD7bdpy1B9KpqPFXw8vNmStjQhnYzY8XVx4gpmsnPrr7Ijp5uJ5rk5h+hieX7GXzkWzGRwexYO4IvN2r7y9sTMwkt7CUqYO6tuVlCeFQJLiLVikoLuP02RLyCstIzy/ih/g0lu89Sc7ZUgaH+/HRXRfh5+la53Naaz7ZcpynlsYxpLs/H9wxGl8PF+avSWD+mgSUgv/cOZpL+7SwKqgQHZwEd2FxJWUVbD92mkHhfvi4X3ii1Yq4kzy4aCe9gn0I8/dkzYF0rh8Wxr4TeWScKWb5Q+Pp4meBFJUQHUxTg7tdz3MXbcvNxYmxvQIbDewAkwd25d3bR3Es6yzrD2Xw7PQB/OOmIbxx63CKSst5aNFOysotXEVSCHGOjNyFVSWk5VNaronp1unctiU7U/n9Z7u465IonpjaX268CtEMTR25O8ZDTKLdig71rbNt5rAwtiVl8+6Go+xJyeFv1w+md0gLFrgWQjRI0jLCJv5v5kBemjWYQ2lnmDr/Z15fm0BFhW1+ixTCETUpuCulJiulDiqlEpVSjzbQ5ialVLxSap9SqoG6r0IYSiluHNmd1X+cwJUDQnn5h0Pc/+kOCkvsbNlEIdqpRoO7UsoZeAOYAsQAc5RSMee1iQYeA8ZprQcAv7dCX4UDCvZ15/U5w3hyWn9W7DvFzQs3kZ4va8oK0VpNybmPBhK11kcAlFKLgRlAzRUm7gHe0FqfBtBap1u6o8JxKaW4e3xPIgK8+N3iXUx4cR0erqbom6ebM/dO6MVtY3vULolQ6WhmAVuOZHHNkG5NmsUjREfRlP8bwoDkGu9TgPNXU+gDoJTaCDgDz2itV1ikh6LDuGpAF7787VgWbT2OQuHq7MShtHz+8m08n245xp+u6ounqzMZ+cUcyy5gdXw6B9PyAUjNKeRPV/Wt97i/HM7kif/GMWVgF/48uV9bXpIQNmOpoY4LEA1MBMKBn5RSg7TWOTUbKaXmAfMAIiIizj+GEAzo5sf/zaxePk9rzY8H0/nLt/u575Md57YrBaMiA3jqmhjWHEhj8bZkHpwUjZtL9ei+qLScF1cc5L2NR/FwdeKt9Ye5vH8oI3p0btNrEsIWmhLcU4HuNd6HV26rKQXYorUuBY4qpQ5hgv22mo201guBhWDmube006LjUEoxqV8ol/QOZsvRLLzdXQj2cSfY1x0PV1P4LSrImzs/2MYP8ae4ZnA3AApLyrn+rV/YfzKP28f24IFJ0cx4fQOPfrWHbx+6xBR/E8KBNWW2zDYgWikVpZRyA24Glp3XZglm1I5SKgiTpmnhMj9C1OXm4sT46GCGR3Sme4DXucAOcGmfYLoHePLx5mPntr26NoH9J/NYMHcEz84YSLCvO89fP4iEdLPQSpXCknIyzxRTLtMwhYNpdOSutS5TSj0ArMTk09/TWu9TSj0HxGqtl1Xuu0opFQ+UA/+jtc6yZseFqOLspLhldA/+vuIACWn5lGvN2z8dYdaIcCYP7HKu3WV9Q5g5tBtvrkvE1Vmx5Wg2W45kU1JegVLg7+lKn1BfZo0IZ+qgrrUqWjbH0l2pzF+dwKtzhjEwrIF69kJYmZQfEA4h60wxY/+2lptHd2dvai7Hss6y5o8T6OztVqtddkEJV/xzPdkFJfQM8mZSvxDCO3uSfbaUrDPFbDqcxZHMArzdnJk2uCvXDw9ndGRAk0okaK351+oEXl2TAMDoqAA+mzem9joBQrSSlB8QHUqgjztTB3Xho83H0Br+edOQOoEdzKLq3zx4CaVlFUQG1V1YRWvN9mOn+Tw2meV7T/F5bAph/p7MHdOD31zas8EgX1xWzh8/3813e05y44hwYrp14tlv4lkVn8ZVA7rU+xkhrEnKDwiHMXdMD7SGcb0DuW5YWIPtwvw96w3sYG7gjowM4MVZQ9j2xBXMv3koUUHe/H3FAf74+S5KG6hkOX91At/tOcmjU/rx4qzB/GpMD3oFe/PCigMNfkYIa5LgLhzGiB6deXHWYP5101CLpEI83ZyZMTSMj+4azZ8n92XJrhPM+zC2TomEhLR83v75CDcMD+feCb1QSuHi7MRjU/pzJKOAxduSGziDENYjwV04DKUUN43sTkgnyy4CopTivom9+et1g1h3KIO57245VyJBa82TS+LwcnPh8am1H5C6vH8IF0UF8MqqQ+QX1V1QXQhrkuAuRBPdclEEb94ynH0ncpn26ga2HMni6x2pbDmazaNT+hHo416rvVKKJ6b1J/tsCfNXJ9io16KjkhuqQjTDlEFdiQr25r6Pd3DLO1vwdHVmeIQ/s0d2r7f94HB/5oyO4P1fkrhueBgDusnUSNE2ZOQuRDP169KJpQ+MY/KALpSWV/B/MwddcKrkI1f3o7OXK0/8N+7cw1Jaa7YcyWLZ7hMs3ZXK0l2p7E3JbfXDVHGpucxfnYCtpjiL9kNG7kK0gK+HK2/cOpzCknI83S5cysDPy5Unp8Xw+892sWjrcSb0CeappXH8eDCjTttOHi5c1DOQOaO7M6lfaK19FRUajXloqz5aax77ei97U3O5vH+IPEDVwUlwF6IVGgvsVWYM7cbnscn8bfl+/u+7eJyU4slp/ZnYNxhQgGbfiTw2Hc7i54RMfv1BLNcPC+Ppawfg5e7M57HJvLYmkZLyCu68OJLbxkbi5+Va6xyr96ezNzUXgK93pEpw7+DkCVUh2siRjDPMeH0jY3oF8sz0AYT5e9bbrqSsgtd/TOSNHxMJ8nHD3cWZ49lnGR7hj5+nKz8ezMC7ss79A5N6o5SiokIz7bUNFJaU0TvEl13JOWx+bBIu9dTAF/ZNnlAVop3pGezDzqeubDTgurk48ccr+3BVTChPLolDA89Mj+GyviEopdh/Mo/5qxP4x6pDZJ4p5pnpA1i57xT7T+bxr9lD8HR1YfX+NDYkZjKxb0iT+5dztoR5H27n0an9GB4hZZHtnQR3IdpQc0bSA8P8WHL/uDrb+3ftxFtzh/PX5ft5++ejlFVotiVl0yvYm+lDwiirqMDP05X/7kxtVnD/dOtxtiZl88baRN69Y1STPyfaJwnuQtghpRSPT+2Pk5Pi3+tNde3X5gzD2Unh7OTMNYO78tWOFM4UlzVp+cHS8go+2nQMFyfF2oPpJGefpXuAl7UvQ1iRJOSEsFNKKR6d3I+Hr+rDtEFdmTao67l91w0Lo6i0gpVxp5p0rBVxpziZW8Qz0wfgpBQfbznW+IdEuyYjdyHsmFKKByZF19k+okdnugd48unW42hM/Zv0/GJ6BXsT060TA8P8CPGtLtPw/saj9Aj04pbREWxMzOSzbcn84Yo+tRZFEfZFgrsQDkgpxfXDwpm/JoHtx07j5uxEkI8b/92ZWrkf7pvYiz9c0Ye4E3nsOJ7D09fG4OSk+NXYHnwfd4pvdp/gxpHdKa/QfLP7BBn5xbg6K9xcnJnQN7jB2T6ifZDgLoSDundCL4ZG+BMR4EWPAC9cnJ3ILyrlwKl8Pt+WzBs/Hmbr0Wy83V3wdXfhxsoSCmN7BhId4sOHm47Rv2uncw9G1RTo7cb7d45icLi/LS5NNEGT5rkrpSYD8zHL7L2jtX6hgXY3AF8Co7TWF5zELvPchbCtpbtSefzrvRSUlPPrcVE8dW3MuX0fbUrif5fuQykI9Hbn6WtjuKxfCKVlFaTmFHLvx9s5XVDCv381kkuig2x3ER1QU+e5NxrclVLOwCHgSiAFs2D2HK11/HntfIHvADfgAQnuQrR/RzMLeH/jUR6Y1LtWDv5McRk3LdjE0Ah/HpncDz/P2k/DpuUVcft7WzmccYbX5gyvtVatsC5LBvexwDNa66sr3z8GoLX+23ntXgFWAf8DPCzBXQjHlltYyh3vb+XgqXy+efASegX71Nsu52wJJ3KK6N/VV9aTtYCmBvemTIUMA2ouJZNSua3myYYD3bXW3zXSqXlKqVilVGxGRt2iSUII++Hn6cpbt47A3cWJBz/dSXFZeZ02RzLOcM1rG5j66s9c9a+fWLD+8LmFToR1tXqeu1LKCfgn8KfG2mqtF2qtR2qtRwYHB7f21EIIG+vi58FLs4YQfzKPvy0/UGvfruQcZi3YRGFJOY9O6UcnT1de+P4AV/3rJzLPFNuoxx1HU2bLpAI1VyIIr9xWxRcYCKyr/JWrC7BMKTW9sdSMEML+XRETyp3jInl/YxK+Hi74uLuQV1TKexuSCPZ158NfjyYyyJt7J/RiT0oO17/5Cy+vPMgLNwyu93i/HM7kL9/u576Jvbh2SLc2vhrH0ZTgvg2IVkpFYYL6zcAtVTu11rnAudvlSql1NCHnLoRwHI9O6ceu5BxeW5t4btvwCH8W/GpErRu1g8P9uePiSN7deJRbL+rBoPDaZYmPZ53lvk92cKaojAcX7WRVfBrPzRiAv5dbq/pXVl7Byn1pdPP3YFgHKYrWaHDXWpcppR4AVmKmQr6ntd6nlHoOiNVaL7N2J4UQ7Zu7izNf3nsx2QUleLk54+Hq3OCiIg9dEc2SXak8+80+vrh37LmbrAXFZcz7KBatYeUfLmX5npPMX5PA1qPZfHz3aHqH+NY6TkFxGa7OTri5VGeX0/KK2HI0GxcnRWSgN90DPFkVn8ZraxM5mllANz8PfvrzZR2iFLLUcxdCtLnPth3nka/2Mv/mocwYGkZhSTl/+mIXK+JO8Z9fj2Z8tLkntzcllzs/2IqvhytL7h93bkrmmv1p/PaTHVRUaCKDvOkZ5M3hjDMcziio93wxXTtxaZ9gFqw/zGtzhtl1usdiUyGtRYK7EB1XeYVmxhsbOHTqDE5OUFRaAcATU/tzz6U9a7XdlpTNnIWbuSQ6iHdvH8XGxEzu/k8sfbr4MKFPMIfSznA44wzdO3sxrncgY3sGoRQkZRVwLOssfUJ9uaJ/CFrD5f9cTydPV5bcd7HdTsuUxTqEEO2Ws5PipVlDeH/jUfw8XQnwdqdnsDdXxYTWaTsqMoBnpg/gySVxPLRoJ2sOpNEz2JuP77rogrn485cZVAruHBfJU0v3seP4aUb0CLD4dbUnEtyFEDbRv2snXpw1pEltb70ogn0nclm0NZnoEB8+ufvCgb0hs0aE848fDvHuhqMS3IUQwtaUUjwzfQD9u3ZiysCuBPq4t+g4Xm4uzBkdwcKfDjv8giSOf8tYCOEQ3F2cuW1sJMG+LQvsVW6/uAdOSvHmukRsdc+xLUhwF0J0KF39PJkzOoJFW5O5/9Md5BWV2rpLViHBXQjR4Tw7fQCPTO7Hyn1pXPPqBvak5Ni6SxYnwV0I0eE4OSl+O7EXn80bQ2l5BTPf2MgjX+4hLa95Rc1KyyvYfCSLsvKKWtuLSstZtPU4pwtKLNntZpHgLoTosEZGBrDid5fy63FRfL0zhYkvras3F38yt5B3fj7Csazqh6R2Jedw7WsbuHnhZq5/6xcOnMoDIP5EHte+toHHvt7L/3y522Z5fXmISQghMHVtnl8ez8p9aTx8VZ9zC49nnSnmxgWbOJJpAvvoyAAig7z4YnsKIb7u3HpRD/7zSxJ5RaVMHdSV7/eewt/LlYl9g/k8NuXcU7iWIg8xCSFEM0QEevHWrSN4+IvdvPzDIUJ8PZg6uCt3frCN1JxCFswdzuGMAr7ansLWpGzmjongz5P70cnDlbljevDsN/tYuusEV8aE8vcbBuPn6UpC+hmeXraPi3sFtXqWT3PJyF0IIWooLa/grv/EsjExk35dfDlwKp9/zx3BFZVPz2qtKSgpx8e97tj4ZG4hXTp5nCttkJiez9RXN3B5vxDemjvCIv2T2jJCCNFCBcVlzHl7M3tScnlp1mBuHNm98Q814M11iby44iARAV6UlVdQUq65fWwPHrw8ukXHk7SMEEK0kLe7C5/cfRGHMwoY2t2/VceaN74n+UVlpJ4uxM3FCVdnJ6JDfRv/YCtJcBdCiHr4eri2OrADuDg78cjkfhboUfPIVEghhHBATQruSqnJSqmDSqlEpdSj9ez/o1IqXim1Rym1RinVw/JdFUII0VSNBnellDPwBjAFiAHmKKVizmu2ExiptR4MfAm8aOmOCiGEaLqmjNxHA4la6yNa6xJgMTCjZgOt9Y9a67OVbzcD4ZbtphBCiOZoSnAPA5JrvE+p3NaQu4DvW9MpIYQQrWPR2TJKqbnASGBCA/vnAfMAIiIiLHlqIYQQNTRl5J4K1JzBH165rRal1BXAE8B0rXVxfQfSWi/UWo/UWo8MDg5uSX+FEEI0QVOC+zYgWikVpZRyA24GltVsoJQaBvwbE9jTLd9NIYQQzdGk8gNKqanAK4Az8J7W+nml1HNArNZ6mVJqNTAIOFn5keNa6+mNHDMDONbCfgcBmS38rD3riNfdEa8ZOuZ1d8RrhuZfdw+tdaOpD5vVlmkNpVRsU2orOJqOeN0d8ZqhY153R7xmsN51yxOqQgjhgCS4CyGEA7LX4L7Q1h2wkY543R3xmqFjXndHvGaw0nXbZc5dCCHEhdnryF0IIcQF2F1wb6xCpSNQSnVXSv1YWWlzn1Lqd5XbA5RSq5RSCZWvnW3dV2tQSjkrpXYqpb6tfB+llNpS+Z1/Vvm8hcNQSvkrpb5USh1QSu1XSo3tCN+1UuoPlX+/45RSi5RSHo74XSul3lNKpSul4mpsq/f7Vcarlde/Ryk1vKXntavg3sQKlY6gDPiT1joGGAPcX3mdjwJrtNbRwJrK947od8D+Gu//DvxLa90bOI2pX+RI5gMrtNb9gCGYa3fo71opFQY8hKkmOxDzDM3NOOZ3/QEw+bxtDX2/U4Doyj/zgLdaelK7Cu40oUKlI9Ban9Ra76j8OR/zP3sY5lr/U9nsP8BM2/TQepRS4cA04J3K9wqYhCklDQ523UopP+BS4F0ArXWJ1jqHDvBdY2pbeSqlXAAvzEOQDvdda61/ArLP29zQ9zsD+FAbmwF/pVTXlpzX3oJ7cytU2j2lVCQwDNgChGqtq54CPgWE2qhb1vQK8GegovJ9IJCjtS6rfO9o33kUkAG8X5mKekcp5Y2Df9da61TgZeA4JqjnAttx7O+6poa+X4vFOHsL7h2KUsoH+Ar4vdY6r+Y+baY5OdRUJ6XUNUC61nq7rfvShlyA4cBbWuthQAHnpWAc9LvujBmlRgHdAG/qpi46BGt9v/YW3JtUodIRKKVcMYH9E63115Wb06p+Rat8dbQibeOA6UqpJEzKbRImH+1f+as7ON53ngKkaK23VL7/EhPsHf27vgI4qrXO0FqXAl9jvn9H/q5rauj7tViMs7fg3miFSkdQmWd+F9ivtf5njV3LgNsrf74dWNrWfbMmrfVjWutwrXUk5rtdq7W+FfgRmFXZzKGuW2t9CkhWSvWt3HQ5EI+Df9eYdMwYpZRX5d/3qut22O/6PA19v8uA2ypnzYwBcmukb5pHa21Xf4CpwCHgMPCErftjpWu8BPNr2h5gV+WfqZj88xogAVgNBNi6r1b8bzAR+Lby557AViAR+AJwt3X/LHytQ4HYyu97CdC5I3zXwLPAASAO+Ahwd8TvGliEua9QivlN7a6Gvl9AYWYEHgb2YmYTtei88oSqEEI4IHtLywghhGgCCe5CCOGAJLgLIYQDkuAuhBAOSIK7EEI4IAnuQgjhgCS4CyGEA5LgLoQQDuj/AbjqGnDL1fAnAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_loss)\n",
    "plt.plot(dev_loss)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fdf132860>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_acc)\n",
    "plt.plot(dev_acc)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "d2vt_cr=classification_report(y_pred=best_result,y_true=test_y)\n",
    "d2vt_c=confusion_matrix(y_pred=best_result,y_true=test_y)\n",
    "d2vt_acc=accuracy_score(y_pred=best_result,y_true=test_y)\n",
    "d2vt_mcc=matthews_corrcoef(y_pred=best_result,y_true=test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.66      0.53      0.58       135\n",
      "         1.0       0.56      0.69      0.62       120\n",
      "\n",
      "   micro avg       0.60      0.60      0.60       255\n",
      "   macro avg       0.61      0.61      0.60       255\n",
      "weighted avg       0.61      0.60      0.60       255\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(d2vt_cr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[71, 64],\n",
       "       [37, 83]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2vt_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6039215686274509"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2vt_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.21980171108311994"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d2vt_mcc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experiment of RNN auto-encoder encoded title, (mean with date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_index=np.load('data/title_ae_index.npy')\n",
    "content=np.load('data/title_ae.npy')\n",
    "content=pd.DataFrame(content,index=date_index)\n",
    "content=content.groupby(content.index).mean()\n",
    "content=content.join(labels).fillna(method='bfill').dropna()['2010-06':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=content.iloc[:,:-1].values\n",
    "y=content.iloc[:,-1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf=RNNClassifier(d_x=x.shape[-1],d_h=300,d_o=class_number,dp=0.5,ffn_layers=5,lr=1e-3,cell=nn.GRU,rnn_layers=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test loss 0.830781473832972 test acc 0.4627450980392157 test mcc -0.0656425925209034 epoch: 0\n",
      "best_result_epoch 0 acc 0.4627450980392157 mcc -0.0656425925209034\n",
      "test loss 0.6936220526695251 test acc 0.5137254901960784 test mcc 0.024074074074074074 epoch: 5\n",
      "best_result_epoch 3 acc 0.5450980392156862 mcc 0.06973018138246544\n",
      "test loss 0.6993326544761658 test acc 0.5019607843137255 test mcc -0.006573421981221796 epoch: 10\n",
      "best_result_epoch 3 acc 0.5450980392156862 mcc 0.06973018138246544\n",
      "test loss 0.6960625858867869 test acc 0.5098039215686274 test mcc 0.010301576462746112 epoch: 15\n",
      "best_result_epoch 3 acc 0.5450980392156862 mcc 0.06973018138246544\n",
      "test loss 0.7103335997637581 test acc 0.4745098039215686 test mcc -0.05462962962962963 epoch: 20\n",
      "best_result_epoch 3 acc 0.5450980392156862 mcc 0.06973018138246544\n",
      "test loss 0.6998115252046024 test acc 0.5137254901960784 test mcc 0.010638078975070424 epoch: 25\n",
      "best_result_epoch 3 acc 0.5450980392156862 mcc 0.06973018138246544\n",
      "test loss 0.6959061692742741 test acc 0.48627450980392156 test mcc -0.03850147160429909 epoch: 30\n",
      "best_result_epoch 28 acc 0.5450980392156862 mcc 0.08018753738744802\n",
      "test loss 0.6966145880082074 test acc 0.5137254901960784 test mcc 0.024074074074074074 epoch: 35\n",
      "best_result_epoch 28 acc 0.5450980392156862 mcc 0.08018753738744802\n",
      "test loss 0.6989109866759357 test acc 0.49019607843137253 test mcc -0.03868392354571063 epoch: 45\n",
      "best_result_epoch 28 acc 0.5450980392156862 mcc 0.08018753738744802\n",
      "test loss 0.6950575639219845 test acc 0.5058823529411764 test mcc -0.02288021576612147 epoch: 50\n",
      "best_result_epoch 28 acc 0.5450980392156862 mcc 0.08018753738744802\n",
      "test loss 0.6964061716023613 test acc 0.4627450980392157 test mcc -0.10853021046861624 epoch: 55\n",
      "best_result_epoch 28 acc 0.5450980392156862 mcc 0.08018753738744802\n",
      "test loss 0.6887227016336778 test acc 0.5490196078431373 test mcc 0.08921072688801009 epoch: 60\n",
      "best_result_epoch 59 acc 0.5568627450980392 mcc 0.0983872001444465\n",
      "test loss 0.6924463685821084 test acc 0.5176470588235295 test mcc 0.012171612389003692 epoch: 65\n",
      "best_result_epoch 59 acc 0.5568627450980392 mcc 0.0983872001444465\n",
      "test loss 0.6900279732311473 test acc 0.5019607843137255 test mcc -0.022314622713173433 epoch: 70\n",
      "best_result_epoch 59 acc 0.5568627450980392 mcc 0.0983872001444465\n",
      "test loss 0.6948661944445442 test acc 0.49019607843137253 test mcc -0.03868392354571063 epoch: 75\n",
      "best_result_epoch 59 acc 0.5568627450980392 mcc 0.0983872001444465\n",
      "test loss 0.6909525359378141 test acc 0.4980392156862745 test mcc -0.007407407407407408 epoch: 80\n",
      "best_result_epoch 59 acc 0.5568627450980392 mcc 0.0983872001444465\n",
      "test loss 0.7023933003930485 test acc 0.5137254901960784 test mcc 0.010638078975070424 epoch: 85\n",
      "best_result_epoch 59 acc 0.5568627450980392 mcc 0.0983872001444465\n",
      "test loss 0.6934138326083913 test acc 0.5294117647058824 test mcc 0.032686022523030676 epoch: 90\n",
      "best_result_epoch 59 acc 0.5568627450980392 mcc 0.0983872001444465\n",
      "test loss 0.6884156851207509 test acc 0.5294117647058824 test mcc 0.032686022523030676 epoch: 95\n",
      "best_result_epoch 59 acc 0.5568627450980392 mcc 0.0983872001444465\n",
      "\n"
     ]
    }
   ],
   "source": [
    "train_loss,train_acc,train_mcc,dev_loss,dev_acc,dev_mcc,best_result,test_y=test(model=clf,x=x,y=y,test_size=15,train_size=150,epoch=100,log_interval=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fdefef320>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_loss)\n",
    "plt.plot(dev_loss)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fdef555f8>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_acc)\n",
    "plt.plot(dev_acc)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "aet_cr=classification_report(y_pred=best_result,y_true=test_y)\n",
    "aet_c=confusion_matrix(y_pred=best_result,y_true=test_y)\n",
    "aet_acc=accuracy_score(y_pred=best_result,y_true=test_y)\n",
    "aet_mcc=matthews_corrcoef(y_pred=best_result,y_true=test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.56      0.75      0.64       135\n",
      "         1.0       0.55      0.34      0.42       120\n",
      "\n",
      "   micro avg       0.56      0.56      0.56       255\n",
      "   macro avg       0.55      0.54      0.53       255\n",
      "weighted avg       0.55      0.56      0.54       255\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(aet_cr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[101,  34],\n",
       "       [ 79,  41]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aet_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5568627450980392"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aet_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0983872001444465"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aet_mcc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_result=[]\n",
    "for _ in range(50):\n",
    "    random_y=np.random.randint(low=0,high=2,size=test_y.shape[0])\n",
    "    random_result.append([accuracy_score(y_pred=random_y,y_true=test_y),matthews_corrcoef(y_pred=random_y,y_true=test_y)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('results/ci_random',np.array(random_result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Experiment of pure Glove word embedding titles (mean with each title, mean with date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "reset_seed(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "date_index=np.load('data/title_glove_index.npy')\n",
    "content=np.load('data/title_glove.npy')\n",
    "content=pd.DataFrame(content,index=date_index)\n",
    "content=content.groupby(content.index).mean()\n",
    "content=content.join(labels).fillna(method='bfill').dropna()['2010-06':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=content.iloc[:,:-1].values\n",
    "y=content.iloc[:,-1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf=RNNClassifier(d_x=x.shape[-1],d_h=300,d_o=class_number,dp=0.5,ffn_layers=5,lr=1e-3,cell=nn.GRU,rnn_layers=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HBox(children=(IntProgress(value=0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test loss 0.7653453279944027 test acc 0.49411764705882355 test mcc -0.039557740264261995 epoch: 0\n",
      "best_result_epoch 0 acc 0.49411764705882355 mcc -0.039557740264261995\n",
      "test loss 0.6928008374045876 test acc 0.5137254901960784 test mcc 0.01154854529249894 epoch: 5\n",
      "best_result_epoch 4 acc 0.5137254901960784 mcc 0.024074074074074074\n",
      "test loss 0.7061117887496948 test acc 0.4196078431372549 test mcc -0.1749208393843982 epoch: 10\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.707423045354731 test acc 0.47843137254901963 test mcc -0.05669750589755439 epoch: 15\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.7593716979026794 test acc 0.40784313725490196 test mcc -0.1830848681582802 epoch: 20\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.7043640192817239 test acc 0.5254901960784314 test mcc 0.06415002990995841 epoch: 25\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.7314502842286054 test acc 0.47843137254901963 test mcc -0.06666666666666667 epoch: 30\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.7833739238626817 test acc 0.49019607843137253 test mcc -0.03313110699774545 epoch: 35\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.7914743984446806 test acc 0.49411764705882355 test mcc -0.015748519708717802 epoch: 40\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.8242267790962668 test acc 0.5176470588235295 test mcc 0.022759624733297297 epoch: 45\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.8541981753181008 test acc 0.4980392156862745 test mcc -0.011174753906691854 epoch: 50\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.8700811617514667 test acc 0.5137254901960784 test mcc 0.0195962378834549 epoch: 55\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.9866222949589 test acc 0.4980392156862745 test mcc -0.005548026307826672 epoch: 60\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 1.028484079767676 test acc 0.49411764705882355 test mcc -0.01109263876066203 epoch: 65\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 0.9774618885096382 test acc 0.5137254901960784 test mcc 0.023172477717973455 epoch: 70\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 1.1023257409825045 test acc 0.49411764705882355 test mcc -0.018607171201297453 epoch: 75\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 1.2459887792082394 test acc 0.5058823529411764 test mcc 0.0009404346203462269 epoch: 80\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 1.2654476972187267 test acc 0.4980392156862745 test mcc -0.014066269825907873 epoch: 85\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 1.3142495400765364 test acc 0.4745098039215686 test mcc -0.05462962962962963 epoch: 90\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "test loss 1.51344294758404 test acc 0.5058823529411764 test mcc 0.001875502643454383 epoch: 95\n",
      "best_result_epoch 9 acc 0.5607843137254902 mcc 0.10928208401663254\n",
      "\n"
     ]
    }
   ],
   "source": [
    "train_loss,train_acc,train_mcc,dev_loss,dev_acc,dev_mcc,best_result,test_y=test(model=clf,x=x,y=y,test_size=15,train_size=150,epoch=100,log_interval=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fdee06f60>"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_loss)\n",
    "plt.plot(dev_loss)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f5fdedf1898>"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_acc)\n",
    "plt.plot(dev_acc)\n",
    "plt.legend(('train','dev'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "w2vt_cr=classification_report(y_pred=best_result,y_true=test_y)\n",
    "w2vt_c=confusion_matrix(y_pred=best_result,y_true=test_y)\n",
    "w2vt_acc=accuracy_score(y_pred=best_result,y_true=test_y)\n",
    "w2vt_mcc=matthews_corrcoef(y_pred=best_result,y_true=test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.57      0.70      0.63       135\n",
      "         1.0       0.54      0.41      0.47       120\n",
      "\n",
      "   micro avg       0.56      0.56      0.56       255\n",
      "   macro avg       0.56      0.55      0.55       255\n",
      "weighted avg       0.56      0.56      0.55       255\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(w2vt_cr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[94, 41],\n",
       "       [71, 49]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w2vt_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5607843137254902"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w2vt_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.10928208401663254"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w2vt_mcc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues,use_xlable=False):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    print(cm)\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    yticks_axes=plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 1.2\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    if use_xlable:\n",
    "        plt.xlabel('Predicted label')\n",
    "    y_lable_axis=plt.ylabel('True label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix, without normalization\n",
      "[[71 64]\n",
      " [37 83]]\n",
      "Confusion matrix, without normalization\n",
      "[[83 52]\n",
      " [52 68]]\n",
      "Confusion matrix, without normalization\n",
      "[[101  34]\n",
      " [ 79  41]]\n",
      "Confusion matrix, without normalization\n",
      "[[94 41]\n",
      " [71 49]]\n",
      "Confusion matrix, without normalization\n",
      "[[87 48]\n",
      " [58 62]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x216 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(13,3))\n",
    "plt.title('Confusion Matrix for DNN Classifier')\n",
    "ax1=plt.subplot2grid(shape=(1,5), loc=(0,0), colspan=1)\n",
    "ax1.set_xlabel('')\n",
    "plot_confusion_matrix(d2vt_c,classes=[-1,1],title='Doc2vec encoded title')\n",
    "ax2=plt.subplot2grid((1,5), (0,1), colspan=1)\n",
    "ax2.set_ylabel('')\n",
    "ax2.yaxis.set_visible(False)\n",
    "plot_confusion_matrix(d2vc_c,classes=[-1,1],title='Doc2vec encoded content')\n",
    "ax3=plt.subplot2grid((1,5), (0,2), colspan=1)\n",
    "ax3.set_ylabel('')\n",
    "ax3.yaxis.set_visible(False)\n",
    "plot_confusion_matrix(aet_c,classes=[-1,1],title='RNNAE encoded title',use_xlable=True)\n",
    "ax4=plt.subplot2grid((1,5), (0,3), colspan=1)\n",
    "ax4.set_ylabel('')\n",
    "ax4.yaxis.set_visible(False)\n",
    "plot_confusion_matrix(w2vt_c,classes=[-1,1],title='GloVe encoded title')\n",
    "ax5 = plt.subplot2grid((1,5), (0,4), colspan=1)\n",
    "ax5.set_ylabel('')\n",
    "ax5.yaxis.set_visible(False)\n",
    "plot_confusion_matrix(elmo_c,classes=[-1,1],title='Elmo encoded title')\n",
    "# plt.colorbar()\n",
    "plt.tight_layout()\n",
    "plt.savefig('results/RNN_perf.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}