SIMAH_transformer_7mach.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import warnings\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    warnings.simplefilter(\"ignore\")\n",
    "    \n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from collections import Counter\n",
    "import math, copy, time\n",
    "from torch.autograd import Variable\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.utils import class_weight\n",
    "sns.set_context(context=\"talk\")\n",
    "%matplotlib inline\n",
    "\n",
    "from keras import backend as K\n",
    "import keras\n",
    "import os, re, sys\n",
    "import pandas as pd\n",
    "from keras.utils import to_categorical\n",
    "import ast\n",
    "from sklearn.utils import class_weight\n",
    "from keras.preprocessing import sequence\n",
    "from keras.models import load_model\n",
    "import torch.nn.functional as F\n",
    "from sklearn.metrics import accuracy_score, f1_score\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.metrics import accuracy_score,f1_score, confusion_matrix\n",
    "from sklearn.preprocessing import normalize\n",
    "import time\n",
    "from keras.models import load_model\n",
    "from keras import backend as K\n",
    "import keras\n",
    "'''\n",
    "Compatible with tensorflow backend\n",
    "gamma entre más alto más tolerante (queremos un gamma chico pero no demasiado! 0.25 - 5)\n",
    "alpha pesos por clase (weights)\n",
    "'''\n",
    "def focal_loss(gamma=2., weights=1):   #weights np.asarray()\n",
    "    weights= K.variable(weights)\n",
    "    def focal_loss_fixed(y_true, y_pred):\n",
    "        y_true = K.clip(y_true, K.epsilon(),1)\n",
    "        y_pred = K.clip(y_pred,K.epsilon(),1)\n",
    "        return - K.sum(weights* K.pow(1. - y_pred, gamma)* y_true * K.log(y_pred), axis=-1) \n",
    "    return focal_loss_fixed\n",
    "\n",
    "keras.losses.focal_loss=keras.losses.MSE\n",
    "keras.losses.focal_loss_fixed=keras.losses.MSE\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nh\t\t| IH\t\t| PH\t\t| SH\t\t| F-Macro\n",
      "0.92792793 \t 0.0 \t\t 0.0 \t\t 0.84057971 \t 0.4421269095182139\n",
      "0.78674791 \t 0.13793103 \t 0.09756098 \t 0.56389987 \t 0.396534945974999\n",
      "0.9197861 \t 0.10884354 \t 0.0729927 \t 0.78439425 \t 0.47150414622873116\n",
      "0.92418033 \t 0.14876033 \t 0.17073171 \t 0.85254692 \t 0.5240548206636296\n",
      "0.9054658 \t 0.13714286 \t 0.10909091 \t 0.74418605 \t 0.47397140213787825\n",
      "0.78454333 \t 0.10327022 \t 0.10362694 \t 0.71553611 \t 0.42674414932927196\n",
      "0.91473851 \t 0.0 \t\t 0.09386282 \t 0.52150538 \t 0.38252667563241805\n"
     ]
    }
   ],
   "source": [
    "#'baselines_4/cnn1_ce10_100.h5'\n",
    "print (\"Nh\\t\\t| IH\\t\\t| PH\\t\\t| SH\\t\\t| F-Macro\")\n",
    "print (0.92792793 ,'\\t',0. ,'\\t\\t',        0.,'\\t\\t',         0.84057971,'\\t',    0.4421269095182139)\n",
    "#('baselines_4/cnn1_focal10_100.h5')\n",
    "print (0.78674791,'\\t', 0.13793103 ,'\\t',0.09756098 ,'\\t',0.56389987,'\\t',   0.396534945974999  )\n",
    "#('baselines_4/rnn_simple_100_focal15.h5')\n",
    "print (0.9197861  ,'\\t',0.10884354 ,'\\t',0.0729927  ,'\\t',0.78439425,'\\t',  0.47150414622873116)\n",
    "#('baselines_4/rnn1_100_focal15.h5')\n",
    "print (0.92418033,'\\t', 0.14876033 ,'\\t',0.17073171 ,'\\t',0.85254692,'\\t',  0.5240548206636296)\n",
    "#('baselines_4/rnn2_100_focal15.h5')\n",
    "print (0.9054658 ,'\\t', 0.13714286 ,'\\t',0.10909091 ,'\\t',0.74418605,'\\t',  0.47397140213787825)\n",
    "#('baselines_4/rnn3_100_focal15.h5')\n",
    "print (0.78454333 ,'\\t',0.10327022,'\\t', 0.10362694 ,'\\t',0.71553611,'\\t', 0.42674414932927196)\n",
    "#('baselines_4/cnn1_focal10_100_g3_100.h5')\n",
    "print (0.91473851 ,'\\t',0. ,'\\t\\t',   0.09386282 ,'\\t',0.52150538,'\\t',    0.38252667563241805)\n",
    "\n",
    "#pasan a transformer: 1,2,7,8,9,10,12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cnn_100_c = load_model('baselines_4/cnn1_ce10_100.h5')\n",
    "cnn_100_f = load_model('baselines_4/cnn1_focal10_100.h5')\n",
    "gru_s = load_model('baselines_4/rnn_simple_100_focal15.h5')\n",
    "gru1 = load_model('baselines_4/rnn1_100_focal15.h5')\n",
    "gru2 = load_model('baselines_4/rnn2_100_focal15.h5')\n",
    "gru3 = load_model('baselines_4/rnn3_100_focal15.h5')\n",
    "cnn_100_f3 = load_model('baselines_4/cnn1_focal10_100_g3_100.h5')\n",
    "\n",
    "\n",
    "list_models=['cnn_100_c', 'cnn_100_f', 'gru_s', 'gru1', 'gru2', 'gru3', 'cnn_100_f3']\n",
    "index_models=np.arange(7)\n",
    "dict_models=dict((key, value) for (key, value) in zip(index_models,list_models))\n",
    "modelos=[cnn_100_c, cnn_100_f, gru_s, gru1, gru2, gru3, cnn_100_f3]\n",
    "ind=np.arange(7)\n",
    "dict_trainingModel=dict((key, value) for (key, value) in zip(ind,modelos))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agregando predicciones del modelo cnn_100_c\n",
      "Agregando predicciones del modelo cnn_100_f\n",
      "Agregando predicciones del modelo gru_s\n",
      "Agregando predicciones del modelo gru1\n",
      "Agregando predicciones del modelo gru2\n",
      "Agregando predicciones del modelo gru3\n",
      "Agregando predicciones del modelo cnn_100_f3\n",
      "Agregando predicciones val del modelo cnn_100_c\n",
      "Agregando predicciones val del modelo cnn_100_f\n",
      "Agregando predicciones val del modelo gru_s\n",
      "Agregando predicciones val del modelo gru1\n",
      "Agregando predicciones val del modelo gru2\n",
      "Agregando predicciones val del modelo gru3\n",
      "Agregando predicciones val del modelo cnn_100_f3\n"
     ]
    }
   ],
   "source": [
    "predicciones_all=[]\n",
    "X_train=np.load(\"matrices/X_train_4.npy\")\n",
    "X_train_rnn=np.load(\"matrices/X_train_rnn_4.npy\")\n",
    "\n",
    "bs=32\n",
    "for i in dict_trainingModel.keys(): \n",
    "    print (\"Agregando predicciones del modelo\", dict_models[i])\n",
    "    a_evaluar=dict_models[i]\n",
    "    if a_evaluar[:3]!='gru':\n",
    "        predicciones_all.append(dict_trainingModel[i].predict(X_train, batch_size=bs))\n",
    "    else:\n",
    "        predicciones_all.append(dict_trainingModel[i].predict(X_train_rnn, batch_size=bs))\n",
    "        \n",
    "predicciones_all_val=[]\n",
    "X_val=np.load(\"matrices/X_val_ig_4.npy\")\n",
    "X_val_rnn=np.load(\"matrices/X_val_rnn_ig_4.npy\")\n",
    "\n",
    "bs=32\n",
    "for i in dict_trainingModel.keys(): \n",
    "    print (\"Agregando predicciones val del modelo\", dict_models[i])\n",
    "    a_evaluar=dict_models[i]\n",
    "    if a_evaluar[:3]!='gru':\n",
    "        predicciones_all_val.append(dict_trainingModel[i].predict(X_val, batch_size=bs))\n",
    "    else:\n",
    "        predicciones_all_val.append(dict_trainingModel[i].predict(X_val_rnn, batch_size=bs))\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Agregando predicciones test del modelo cnn_100_c\n",
      "Agregando predicciones test del modelo cnn_100_f\n",
      "Agregando predicciones test del modelo gru_s\n",
      "Agregando predicciones test del modelo gru1\n",
      "Agregando predicciones test del modelo gru2\n",
      "Agregando predicciones test del modelo gru3\n",
      "Agregando predicciones test del modelo cnn_100_f3\n"
     ]
    }
   ],
   "source": [
    "predicciones_all_test=[]\n",
    "X_test=np.load(\"matrices/X_test_ig_4.npy\")\n",
    "X_test_rnn=np.load(\"matrices/X_test_rnn_4.npy\")\n",
    "\n",
    "bs=32\n",
    "for i in dict_trainingModel.keys(): \n",
    "    print (\"Agregando predicciones test del modelo\", dict_models[i])\n",
    "    a_evaluar=dict_models[i]\n",
    "    if a_evaluar[:3]!='gru':\n",
    "        predicciones_all_test.append(dict_trainingModel[i].predict(X_test, batch_size=bs))\n",
    "    else:\n",
    "        predicciones_all_test.append(dict_trainingModel[i].predict(X_test_rnn, batch_size=bs))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(7, 6374, 4)\n",
      "(7, 2125, 4)\n",
      "(7, 2123, 4)\n"
     ]
    }
   ],
   "source": [
    "matrix=np.asarray(predicciones_all)\n",
    "print (matrix.shape)\n",
    "matrix_val=np.asarray(predicciones_all_val)\n",
    "print (matrix_val.shape)\n",
    "matrix_test=np.asarray(predicciones_all_test)\n",
    "print (matrix_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7, 10622, 4)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_matrix=np.concatenate([matrix,matrix_val,matrix_test], axis=1)\n",
    "new_matrix.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Dummy_Embeddings(nn.Module):\n",
    "    def __init__(self, d_model, dummy_vectors): \n",
    "        super(Dummy_Embeddings, self).__init__()\n",
    "        aux = torch.from_numpy(dummy_vectors)#, dtype='float32'))\n",
    "        self.index2dummy = nn.Embedding(aux.size()[0], d_model)\n",
    "        self.index2dummy.weigth=nn.Parameter(aux)\n",
    "        self.index2dummy.weigth.requires_grad=False\n",
    "        self.d_model = d_model\n",
    "        \n",
    "    def forward(self, x):\n",
    "        aux=x.numpy()\n",
    "        #print (\"aux_size en dummy emb\", aux.shape, aux)\n",
    "        new_x= aux - np.ones(aux.shape)#cambiar aqui! (ver hojita de cuaderno)\n",
    "        new_x= torch.from_numpy(new_x)\n",
    "        #print (\"nuevo aux con el menos 1s (clase 1 en ind 0 y los ids desde 5 ind)\", aux)\n",
    "        return self.index2dummy(new_x.long()) * math.sqrt(self.d_model) #debiese retornar matriz de batch_size x [ind_tw, k1,k2,k3,k4,k5,k6] (si son 6 modelos)\n",
    "    \n",
    "def match(objetos,ejemplo):\n",
    "    i=0\n",
    "    for obj in objetos:\n",
    "        if obj==ejemplo:\n",
    "            return i\n",
    "        i+=1\n",
    "        \n",
    "class EncoderDecoderLogSoft(nn.Module):\n",
    "    def __init__(self, encoder, src_embed, sequential):\n",
    "        super(EncoderDecoderLogSoft, self).__init__()\n",
    "        self.encoder = encoder\n",
    "        self.linearSoft = sequential\n",
    "        self.src_embed = src_embed\n",
    "        \n",
    "    def forward(self, src, src_mask):\n",
    "        out=self.encode(src, src_mask)\n",
    "        retorno=self.toSoftmax(out)\n",
    "        return retorno\n",
    "    \n",
    "    def encode(self, src, src_mask):\n",
    "        return self.encoder(self.src_embed(src), src_mask)\n",
    "    \n",
    "    def toSoftmax(self, tensor):\n",
    "        a=tensor.size()[0]\n",
    "        b=tensor.size()[-1]\n",
    "        c=tensor.size()[-2]\n",
    "        new_tensor= np.zeros((a, b))\n",
    "        ini=True\n",
    "        for ai in range(a):\n",
    "            for ci in range(c):\n",
    "                if ini:\n",
    "                    new_tensor[ai]=tensor.data[ai][ci].numpy()\n",
    "                    ini=False\n",
    "                else: \n",
    "                    new_tensor[ai]*=tensor.data[ai][ci].numpy()\n",
    "            ini=True\n",
    "        new_tensor=torch.from_numpy(new_tensor)\n",
    "        lineal=self.linearSoft(new_tensor.float())\n",
    "        return F.log_softmax(lineal, dim = -1)\n",
    "    \n",
    "    def decode(self, memory, src_mask, tgt, tgt_mask):\n",
    "        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)\n",
    "    \n",
    "def clones(module, N):\n",
    "    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])\n",
    "\n",
    "\n",
    "class EncoderDecoderSoft(nn.Module):\n",
    "    def __init__(self, encoder, src_embed, sequential):\n",
    "        super(EncoderDecoderSoft, self).__init__()\n",
    "        self.encoder = encoder\n",
    "        self.linearSoft = sequential\n",
    "        self.src_embed = src_embed\n",
    "        \n",
    "    def forward(self, src, src_mask):\n",
    "        out=self.encode(src, src_mask)\n",
    "        retorno=self.toSoftmax(out)\n",
    "        return retorno\n",
    "    \n",
    "    def encode(self, src, src_mask):\n",
    "        return self.encoder(self.src_embed(src), src_mask)\n",
    "    \n",
    "    def toSoftmax(self, tensor):\n",
    "        a=tensor.size()[0]\n",
    "        b=tensor.size()[-1]\n",
    "        c=tensor.size()[-2]\n",
    "        new_tensor= np.zeros((a, b))\n",
    "        ini=True\n",
    "        for ai in range(a):\n",
    "            for ci in range(c):\n",
    "                if ini:\n",
    "                    new_tensor[ai]=tensor.data[ai][ci].numpy()\n",
    "                    ini=False\n",
    "                else: \n",
    "                    new_tensor[ai]*=tensor.data[ai][ci].numpy()\n",
    "            ini=True\n",
    "            \n",
    "        new_tensor=torch.from_numpy(new_tensor)\n",
    "        lineal=self.linearSoft(new_tensor.float())\n",
    "        return F.softmax(lineal, dim = -1)\n",
    "    \n",
    "    def decode(self, memory, src_mask, tgt, tgt_mask):\n",
    "        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)\n",
    "    \n",
    "def clones(module, N):\n",
    "    return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])\n",
    "\n",
    "class EncoderDecoder(nn.Module):\n",
    "    def __init__(self, encoder, src_embed, generator):\n",
    "        super(EncoderDecoder, self).__init__()\n",
    "        self.encoder = encoder\n",
    "        self.src_embed = src_embed\n",
    "        self.generator = generator\n",
    "        \n",
    "    def forward(self, src, src_mask):\n",
    "        return  self.encode(src, src_mask)\n",
    "\n",
    "    def encode(self, src, src_mask):\n",
    "        return self.encoder(self.src_embed(src), src_mask)\n",
    "    \n",
    "    def decode(self, memory, src_mask, tgt, tgt_mask):\n",
    "        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)\n",
    "    \n",
    "class Encoder(nn.Module):\n",
    "    def __init__(self, layer, N):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.layers = clones(layer, N)\n",
    "        self.norm = LayerNorm(layer.size)\n",
    "        \n",
    "    def forward(self, x, mask):\n",
    "        for layer in self.layers:\n",
    "            x = layer(x, mask)\n",
    "        return self.norm(x)\n",
    "    \n",
    "class LayerNorm(nn.Module):\n",
    "    def __init__(self, features, eps=1e-6):\n",
    "        super(LayerNorm, self).__init__()\n",
    "        self.a_2 = nn.Parameter(torch.ones(features))\n",
    "        self.b_2 = nn.Parameter(torch.zeros(features))\n",
    "        self.eps = eps\n",
    "\n",
    "    def forward(self, x):\n",
    "        mean = x.mean(-1, keepdim=True)\n",
    "        std = x.std(-1, keepdim=True)\n",
    "        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2\n",
    "    \n",
    "class SublayerConnection(nn.Module):\n",
    "    def __init__(self, size, dropout):\n",
    "        super(SublayerConnection, self).__init__()\n",
    "        self.norm = LayerNorm(size)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, x, sublayer):\n",
    "        return x + self.dropout(sublayer(self.norm(x)))    \n",
    "    \n",
    "class EncoderLayer(nn.Module):\n",
    "    def __init__(self, size, self_attn, feed_forward, dropout):\n",
    "        super(EncoderLayer, self).__init__()\n",
    "        self.self_attn = self_attn\n",
    "        self.feed_forward = feed_forward\n",
    "        self.sublayer = clones(SublayerConnection(size, dropout), 2)\n",
    "        self.size = size\n",
    "\n",
    "    def forward(self, x, mask):\n",
    "        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))\n",
    "        return self.sublayer[1](x, self.feed_forward)\n",
    "    \n",
    "def subsequent_mask(size):\n",
    "    attn_shape = (1, size, size)\n",
    "    subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')\n",
    "    return torch.from_numpy(subsequent_mask) == 0\n",
    "\n",
    "class Generator(nn.Module):\n",
    "    def __init__(self, d_model, vocab):\n",
    "        super(Generator, self).__init__()\n",
    "        self.proj = nn.Linear(d_model, vocab)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return F.log_softmax(self.proj(x), dim=-1)\n",
    "    \n",
    "def attention(query, key, value, mask=None, dropout=None):\n",
    "    d_k = query.size(-1)\n",
    "    scores = torch.matmul(query, key.transpose(-2, -1)) \\\n",
    "             / math.sqrt(d_k)\n",
    "    if mask is not None:\n",
    "        scores = scores.masked_fill(mask == 0, -1e9)\n",
    "    p_attn = F.softmax(scores, dim = -1)\n",
    "    if dropout is not None:\n",
    "        p_attn = dropout(p_attn)\n",
    "    return torch.matmul(p_attn, value), p_attn\n",
    "\n",
    "class MultiHeadedAttention(nn.Module):\n",
    "    def __init__(self, h, d_model, dropout=0.1):\n",
    "        super(MultiHeadedAttention, self).__init__()\n",
    "        assert d_model % h == 0\n",
    "        self.d_k = d_model // h\n",
    "        self.h = h\n",
    "        self.linears = clones(nn.Linear(d_model, d_model), 4)\n",
    "        self.attn = None\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "        \n",
    "    def forward(self, query, key, value, mask=None):\n",
    "        if mask is not None:\n",
    "            mask = mask.unsqueeze(1)\n",
    "        nbatches = query.size(0)\n",
    "        \n",
    "        query, key, value = \\\n",
    "            [l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)\n",
    "             for l, x in zip(self.linears, (query, key, value))]\n",
    "         \n",
    "        x, self.attn = attention(query, key, value, mask=mask, \n",
    "                                 dropout=self.dropout)\n",
    "        \n",
    "        x = x.transpose(1, 2).contiguous() \\\n",
    "             .view(nbatches, -1, self.h * self.d_k)\n",
    "        return self.linears[-1](x)\n",
    "    \n",
    "class PositionalText(nn.Module):\n",
    "    def __init__(self, d_model, dropout, max_len=5):\n",
    "        super(PositionalText, self).__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x_text=x.data[:,0][:,None,:]\n",
    "        x_machines=x.data[:,1:]\n",
    "        \n",
    "        x_return = x_machines* x_text\n",
    "        return self.dropout(x_return)\n",
    "    \n",
    "class PositionalText_concat(nn.Module):\n",
    "    def __init__(self, d_model, dropout, max_len=5):\n",
    "        super(PositionalText_concat, self).__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.dropout(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def data_gen(batch_size,mode,n_machines,new_matrix):  \n",
    "    \"\"\"ESTA FUNCION DEBERÁ RETORNAR MATRICES DE TAMAÑO BATCH_SIZE * TW,M1,M2,M3,M4,M5,M6\n",
    "    CADA EJEMPLO DEBERÁ SER ESTILO [ID_T, 1,2,1,2,1,2] SIENDO 1 CUANDO LA CLASE PREDICHA ES LA 0\n",
    "    2 PARA CLASE PREDICHA 1, ETC. ID_T DEBEŔA INICIAR EN 5 PARA REFERIRSE AL PRIMER TW (EL PRIMERO DE TRAIN)\"\"\"\n",
    "    x_data=[] \n",
    "    y_data=[]\n",
    "    if mode=='Train':\n",
    "        max_objs=matrix.shape[1]\n",
    "        x_list=np.arange(max_objs)\n",
    "        np.random.shuffle(x_list)\n",
    "        objs=df_train['Unnamed: 0'].values\n",
    "        objs=[obj+5 for obj in objs]\n",
    "        labels=np.load(\"../../forSIMAH/y_train_num_4.npy\")\n",
    "        labels=labels+ np.ones(labels.shape)       \n",
    "    if mode=='Val':\n",
    "        max_objs=matrix_val.shape[1] \n",
    "        x_list=np.arange(max_objs)\n",
    "        x_list=[x+matrix.shape[1] for x in x_list]\n",
    "        np.random.shuffle(x_list)\n",
    "        objs=df_val['Unnamed: 0'].values        \n",
    "        objs=[obj+5 for obj in objs]\n",
    "        labels=np.load(\"../../forSIMAH/y_val_num_4.npy\")\n",
    "        labels=labels+ np.ones(labels.shape) \n",
    "    if mode=='Test':\n",
    "        max_objs=matrix_test.shape[1] \n",
    "        x_list=np.arange(max_objs)\n",
    "        x_list=[x+matrix.shape[1]+matrix_val.shape[1] for x in x_list]\n",
    "        #np.random.shuffle(x_list)\n",
    "        #print (\"X LIST SIN SHUFFLE\", x_list)\n",
    "        total=matrix.shape[1]+matrix_val.shape[1]\n",
    "        objs=np.arange(total, total+max_objs)\n",
    "        objs=[obj+5 for obj in objs]\n",
    "        \n",
    "    if len(x_list)%batch_size==0:\n",
    "        n_batches=len(x_list)/batch_size\n",
    "        for nb in range(n_batches): \n",
    "            x_data.append(x_list[nb*batch_size:(nb+1)*batch_size])\n",
    "    else:\n",
    "        n_batches=int(len(x_list)/batch_size)\n",
    "        resto=int(len(x_list)-n_batches*batch_size)\n",
    "        to_repeat=batch_size-resto        \n",
    "        for nb in range(n_batches): \n",
    "            x_data.append(x_list[nb*batch_size:(nb+1)*batch_size])\n",
    "        cola=list(x_list[(nb+1)*batch_size:])\n",
    "        for i in range(to_repeat):\n",
    "            indice= np.random.randint(len(x_list))\n",
    "            cola.append(x_list[indice])\n",
    "        x_data.append(np.asarray(cola))\n",
    "        if mode=='Test':\n",
    "            print (\"SE TUVIERON QUE REPETIR\", to_repeat, \"EJEMPLOS\")\n",
    "    \n",
    "    new_x_data=[] \n",
    "    for batch in x_data:\n",
    "        temp=[]\n",
    "        for exam in batch:\n",
    "            if mode=='Train':\n",
    "                temp2=[objs[exam]] ### obj evaluado en maquinas\n",
    "            elif mode=='Val':\n",
    "                temp2=[objs[exam-matrix.shape[1]]] \n",
    "            else:\n",
    "                temp2=[objs[exam-matrix.shape[1]-matrix_val.shape[1]]]                \n",
    "            for m in range(n_machines): \n",
    "                temp2= temp2 + [np.argmax(new_matrix[m][exam])+1] \n",
    "            temp.append(temp2)\n",
    "        new_x_data.append(temp)   \n",
    "\n",
    "    if mode=='Train' or mode=='Val':    \n",
    "        y_data=[]\n",
    "        for batch in new_x_data:\n",
    "            temp_y=[]\n",
    "            for exam in batch:\n",
    "                q=exam[0]\n",
    "                indice=match(objs, q)    \n",
    "                temp_y.append([labels[indice]])       \n",
    "            y_data.append(temp_y)\n",
    "        y_data=np.asarray(y_data)\n",
    "        \n",
    "    new_x_data=np.asarray(new_x_data)\n",
    "    \n",
    "    if mode=='Train' or mode=='Val':\n",
    "        for x,y in zip(new_x_data, y_data):\n",
    "            src = Variable(torch.from_numpy(np.asarray(x)), requires_grad=False)\n",
    "            har = Variable(torch.from_numpy(np.asarray(y)), requires_grad=False)\n",
    "            yield Batch(src, har, 0)\n",
    "    else:\n",
    "        for x in new_x_data:\n",
    "            src = Variable(torch.from_numpy(np.asarray(x)), requires_grad=False)\n",
    "            yield Batch(src, None, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Unnamed: 0</th>\n",
       "      <th>tweet_content</th>\n",
       "      <th>harassment</th>\n",
       "      <th>IndirectH</th>\n",
       "      <th>PhysicalH</th>\n",
       "      <th>SexualH</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>pics mexican school girl naked melanie safka f...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>RT shereiqns Having curly hair is a gotdamn ch...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>BreakingNews 7 Unexplained Prisoners Deaths M...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>girl dirty quarterback latino pokemon young h...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>miliondollameat sexting n ngirl daddy n nme l...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Unnamed: 0                                      tweet_content  harassment  \\\n",
       "0           0  pics mexican school girl naked melanie safka f...           1   \n",
       "1           1  RT shereiqns Having curly hair is a gotdamn ch...           0   \n",
       "2           2   BreakingNews 7 Unexplained Prisoners Deaths M...           0   \n",
       "3           3   girl dirty quarterback latino pokemon young h...           1   \n",
       "4           4   miliondollameat sexting n ngirl daddy n nme l...           1   \n",
       "\n",
       "   IndirectH  PhysicalH  SexualH  \n",
       "0          0          0        1  \n",
       "1          0          0        0  \n",
       "2          0          0        0  \n",
       "3          0          0        1  \n",
       "4          0          0        1  "
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train=pd.read_csv(\"../Train_data_compeition.csv\")\n",
    "df_val=pd.read_csv(\"../Validation_data_competition.csv\")\n",
    "df_test=pd.read_csv(\"../testset-competition.csv\")\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(768, 768)\n",
      "(4, 768)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ks=np.load(\"../Orthogonals_768.npy\")\n",
    "print (Ks.shape)\n",
    "random=np.random.randint(Ks.shape[0], size=4)\n",
    "K_list=[Ks[k] for k in random]\n",
    "print (np.asarray(K_list).shape)\n",
    "len(K_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# por qué parte en 5?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6374,)\n",
      "(2125,)\n",
      "2123\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10622"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K_list_ext=K_list\n",
    "objs_train=df_train['Unnamed: 0'].values\n",
    "objs_val=df_val['Unnamed: 0'].values\n",
    "objs_test=np.arange(df_test.shape[0])\n",
    "tope=len(objs_train)+len(objs_val)\n",
    "objs_test=[elem+tope for elem in objs_test]\n",
    "print (objs_train.shape)\n",
    "print (objs_val.shape)\n",
    "print (len(objs_test))\n",
    "#print (objs_test.shape)\n",
    "llaves=np.concatenate([objs_train,objs_val,objs_test])\n",
    "#valores=np.arange(5, len(objs_train)+len(objs_val)+len(objs_test)+5)\n",
    "len(llaves)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#dict_IDObj=dict((key, value) for (key, value) in zip(llaves,valores))\n",
    "#dict_ObjID=dict((key, value) for (key, value) in zip(valores,llaves))\n",
    "#len(dict_ObjID)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "largo de lista de vectores bert (considerando dummy clases) 10626\n"
     ]
    }
   ],
   "source": [
    "contador=0\n",
    "for i in range(tope):\n",
    "    vector=np.load(\"../../vectors/\"+str(i)+\".npy\")\n",
    "    K_list_ext.append(vector[0])\n",
    "for i in range(len(objs_test)):\n",
    "    vector=np.load(\"../../test_vectors/\"+str(i)+\".npy\")\n",
    "    K_list_ext.append(vector[0])\n",
    "print (\"largo de lista de vectores bert (considerando dummy clases)\", len(K_list_ext))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10626"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(K_list_ext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10626, 768)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "K_list_new= np.asarray(K_list_ext, dtype='float32')\n",
    "K_list_new.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def make_model_concat(target, N=2, d_model=768, d_ff=1024, h=4, dropout=0.3, soft=True):  #recibir src_vocab si lo utiliza dummy_Emb\n",
    "    c = copy.deepcopy\n",
    "    attn = MultiHeadedAttention(h, d_model)\n",
    "    ff = PositionwiseFeedForward(d_model, d_ff, dropout)\n",
    "    position = PositionalText_concat(d_model, dropout)\n",
    "    if soft:\n",
    "        print (\"Creando modelo con salida Softmax\")\n",
    "        model = EncoderDecoderSoft(\n",
    "            Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),\n",
    "            nn.Sequential(Dummy_Embeddings(768, K_list_new), c(position)),\n",
    "            nn.Linear(d_model, 4))\n",
    "    else:\n",
    "        print (\"\")\n",
    "        print (\"Creando modelo con salida Log_softmax\")\n",
    "        model = EncoderDecoderLogSoft(\n",
    "            Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),\n",
    "            nn.Sequential(Dummy_Embeddings(768, K_list_new), c(position)),\n",
    "            nn.Linear(d_model, 4))\n",
    "\n",
    "    for p in model.parameters():\n",
    "        if p.dim() > 1:\n",
    "            nn.init.xavier_uniform(p)\n",
    "    return model\n",
    "\n",
    "class Batch:\n",
    "    def __init__(self, src, trg=None, pad=0):\n",
    "        self.src = src\n",
    "        self.src_mask = (src != pad).unsqueeze(-2)\n",
    "        if trg is not None:\n",
    "            self.trg = trg[:, :]\n",
    "            self.trg_y = trg[:, 0:]\n",
    "            self.trg_mask = \\\n",
    "                self.make_std_mask(self.trg, pad)\n",
    "            self.ntokens = (self.trg_y != pad).data.sum()\n",
    "            \n",
    "    @staticmethod\n",
    "    def make_std_mask(tgt, pad):\n",
    "        tgt_mask = (tgt != pad).unsqueeze(-2)\n",
    "        tgt_mask = tgt_mask & Variable(\n",
    "            subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data))\n",
    "        return tgt_mask\n",
    "    \n",
    "def run_epoch(data_iter, model, loss_compute, mode):\n",
    "    if mode=='Test':\n",
    "        with torch.no_grad():\n",
    "            start = time.time()\n",
    "            total_datos = 0\n",
    "            total_loss = 0\n",
    "            total_acc=0\n",
    "            total_fm1=0\n",
    "            total_fs=0\n",
    "            n_batches = 0\n",
    "            cm_last=np.zeros((4,4))\n",
    "            pred_classes=[]\n",
    "            for i, batch in enumerate(data_iter):\n",
    "                out = model.forward(batch.src, batch.src_mask)\n",
    "                pred_classes.append(out.argmax(dim=-1).numpy())\n",
    "                #la loss del batch es sobre todos los ejemplos o es promedio en batch?\n",
    "                \n",
    "            return pred_classes\n",
    "    \n",
    "    else:\n",
    "        start = time.time()\n",
    "        total_learners = 0\n",
    "        total_datos = 0\n",
    "        total_loss = 0\n",
    "        total_acc=0\n",
    "        total_fm1=0\n",
    "        total_fs=0\n",
    "        n_batches = 0\n",
    "        cm_last=np.zeros((4,4))\n",
    "        for i, batch in enumerate(data_iter):\n",
    "            out = model.forward(batch.src, batch.src_mask)\n",
    "            loss,acc,f1,cm = loss_compute(out, batch.trg_y, batch.ntokens, mode)\n",
    "            cm_last+=cm\n",
    "            f_ma=np.mean(f1)\n",
    "            total_loss += loss\n",
    "            total_acc += np.array(acc)\n",
    "            total_fm1 += np.sum(f1)/4.0\n",
    "            total_fs += f1  \n",
    "            total_datos += batch.ntokens\n",
    "            n_batches += 1\n",
    "        return total_loss/n_batches, torch.from_numpy(np.array(total_acc))/n_batches, torch.from_numpy(np.array(total_fm1))/n_batches, torch.from_numpy(np.array(total_fs))/n_batches, cm_last"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "global max_src_in_batch, max_tgt_in_batch\n",
    "def batch_size_fn(new, count, sofar):\n",
    "    \"Keep augmenting batch and calculate total number of learners + padding.\"\n",
    "    global max_src_in_batch, max_tgt_in_batch\n",
    "    if count == 1:\n",
    "        max_src_in_batch = 0\n",
    "        max_tgt_in_batch = 0\n",
    "    max_src_in_batch = max(max_src_in_batch,  len(new.src))\n",
    "    max_tgt_in_batch = max(max_tgt_in_batch,  len(new.trg) + 2)\n",
    "    src_elements = count * max_src_in_batch\n",
    "    tgt_elements = count * max_tgt_in_batch\n",
    "    maximo=max(src_elements, tgt_elements)\n",
    "    return maximo\n",
    "\n",
    "class NoamOpt:\n",
    "    \"Optim wrapper that implements rate.\"\n",
    "    def __init__(self, model_size, factor, warmup, optimizer):\n",
    "        self.optimizer = optimizer\n",
    "        self._step = 0\n",
    "        self.warmup = warmup\n",
    "        self.factor = factor\n",
    "        self.model_size = model_size\n",
    "        self._rate = 0\n",
    "        \n",
    "    def step(self):\n",
    "        \"Update parameters and rate\"\n",
    "        self._step += 1\n",
    "        rate = self.rate()\n",
    "        for p in self.optimizer.param_groups:\n",
    "            p['lr'] = rate\n",
    "        self._rate = rate\n",
    "        #print (\"Rate de Noam_opt\", self._rate, self._step)\n",
    "        self.optimizer.step()\n",
    "        \n",
    "    def rate(self, step = None):\n",
    "        \"Implement `lrate` above\"\n",
    "        if step is None:\n",
    "            step = self._step\n",
    "        return self.factor * \\\n",
    "            (self.model_size ** (-0.5) *\n",
    "            min(step ** (-0.5), step * self.warmup ** (-1.5)))\n",
    "        \n",
    "def get_std_opt(model):\n",
    "    return NoamOpt(model.src_embed[0].d_model, 2, 4000,\n",
    "            torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9))\n",
    "\n",
    "class LabelSmoothing(nn.Module):\n",
    "    \"Implement label smoothing.\"\n",
    "    def __init__(self, size, padding_idx, smoothing=0.0):\n",
    "        super(LabelSmoothing, self).__init__()\n",
    "        self.criterion = nn.KLDivLoss(size_average=False)\n",
    "        self.padding_idx = padding_idx\n",
    "        self.confidence = 1.0 - smoothing\n",
    "        self.smoothing = smoothing\n",
    "        self.size = size\n",
    "        self.true_dist = None\n",
    "        \n",
    "    def forward(self, x, target):\n",
    "        assert x.size(1) == self.size\n",
    "        true_dist = x.data.clone()\n",
    "        true_dist.fill_(self.smoothing / (self.size - 2))\n",
    "        true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)\n",
    "        mask = torch.nonzero(target.data == self.padding_idx)\n",
    "        self.true_dist = true_dist\n",
    "        return self.criterion(x, Variable(true_dist, requires_grad=False))\n",
    "    \n",
    "class LabelCCE(nn.Module):\n",
    "    def __init__(self, class_weights):\n",
    "        super(LabelCCE, self).__init__()\n",
    "        self.criterion = nn.CrossEntropyLoss(weight=class_weights)\n",
    "                       \n",
    "    def forward(self, x, target):\n",
    "        return self.criterion(x, target)\n",
    "    \n",
    "class FocalLoss(nn.Module):\n",
    "    def __init__(self, weights, gamma=2.0, reduce=True):#, logits=False, reduce=True):\n",
    "        super(FocalLoss, self).__init__()\n",
    "        self.weights = weights\n",
    "        self.gamma = gamma\n",
    "        #self.logits = logits\n",
    "        self.reduce = reduce\n",
    "\n",
    "    def forward(self, x, y):\n",
    "        tensors = []\n",
    "        for l in y:\n",
    "            tensors.append(torch.zeros(4).scatter_(0, torch.tensor(l), 1))\n",
    "        result = torch.stack(tensors, 0)\n",
    "        \n",
    "        CCE_loss = F.cross_entropy(x, result.long().argmax(dim=-1), reduction='none', weight=self.weights.float())\n",
    "        pt = torch.exp(-CCE_loss)\n",
    "        factor= (1-pt)**self.gamma * CCE_loss\n",
    "        \n",
    "        F_loss = factor  #*self.weights.float()-- peso esta dentro de la funcion\n",
    "\n",
    "        if self.reduce:\n",
    "            return torch.mean(F_loss)\n",
    "        else:\n",
    "            return F_loss\n",
    "        \n",
    "class SimpleLossComputeFL:\n",
    "    \"A simple loss compute and train function.\"\n",
    "    def __init__(self, criterion, opt=None):\n",
    "        self.criterion = criterion\n",
    "        self.opt = opt\n",
    "        \n",
    "    def __call__(self, x, y, norm, mode):        \n",
    "        y_new=(y.float()-torch.ones((y.shape[0],y.shape[1]))).int()\n",
    "        ac=accuracy_scorer(x, y_new)\n",
    "        f1=f_scorer(x, y_new)\n",
    "        cm=compute_confusion_matrix(x, y_new)\n",
    "        tempa= x.contiguous().view(-1, x.size(-1))\n",
    "        tempb= y_new.long().contiguous().view(-1)\n",
    "        loss = self.criterion(tempa, tempb) #/ norm\n",
    "        if mode!='Test':\n",
    "            loss.backward()\n",
    "        if self.opt is not None:\n",
    "            self.opt.step()\n",
    "            self.opt.optimizer.zero_grad()\n",
    "        return [loss.data, ac ,f1, cm] #*norm #[0] * norm\n",
    "    \n",
    "class PositionwiseFeedForward(nn.Module):\n",
    "    \"Implements FFN equation.\"\n",
    "    def __init__(self, d_model, d_ff, dropout=0.1):\n",
    "        super(PositionwiseFeedForward, self).__init__()\n",
    "        self.w_1 = nn.Linear(d_model, d_ff)\n",
    "        self.w_2 = nn.Linear(d_ff, d_model)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.w_2(self.dropout(F.relu(self.w_1(x))))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DESDE ACA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 0 0 3 3 0 3 3 0 0]\n",
      "[ 0.43526359 28.97272727 20.96710526  0.61715724]\n"
     ]
    }
   ],
   "source": [
    "def accuracy_scorer(predicho, target):\n",
    "    predicho= torch.argmax(predicho, dim=1)\n",
    "    return accuracy_score(target.numpy(),predicho.numpy())\n",
    "\n",
    "def f_scorer(predicho, target):\n",
    "    predicho= torch.argmax(predicho, dim=1)\n",
    "    return f1_score(target.numpy(),predicho.numpy(), average=None, labels=[0,1,2,3])\n",
    "\n",
    "def compute_confusion_matrix(predicho, target):\n",
    "    predicho= torch.argmax(predicho, dim=1)\n",
    "    return confusion_matrix(target.numpy(), predicho.numpy(), labels=[0,1,2,3])\n",
    "\n",
    "y_train_har=np.load(\"matrices/y_train_num_4.npy\")\n",
    "print (y_train_har[:10])\n",
    "class_weights = class_weight.compute_class_weight('balanced', np.unique(y_train_har), y_train_har)\n",
    "print (class_weights)\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    warnings.simplefilter(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modelos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "### Mejor caso a superar: \n",
    "print (\"Nh\\t\\t| IH\\t\\t| PH\\t\\t| SH\\t\\t| F-Macro\")\n",
    "#('baselines_4/rnn1_100_focal15.h5')\n",
    "print (0.92418033,'\\t', 0.14876033 ,'\\t',0.17073171 ,'\\t',0.85254692,'\\t',  0.5240548206636296)\n",
    "#('baselines_4/rnn2_100_focal15.h5')\n",
    "print (0.9054658 ,'\\t', 0.13714286 ,'\\t',0.10909091 ,'\\t',0.74418605,'\\t',  0.47397140213787825)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 0.4353, 28.9727, 20.9671,  0.6172])\n",
      "Creando modelo con salida Softmax\n",
      "\n",
      "\n",
      "Validando Epoch 0\n",
      "loss_val: tensor(2.1057)\n",
      "Acc_val: tensor(0.6459, dtype=torch.float64)\n",
      "f_score_val: tensor(0.3720, dtype=torch.float64)\n",
      "f_score_val: tensor([0.7519, 0.0977, 0.0109, 0.6275], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 1\n",
      "loss_val: tensor(2.2617)\n",
      "Acc_val: tensor(0.8511, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4461, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9099, 0.0650, 0.0000, 0.8095], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 2\n",
      "loss_val: tensor(2.2568)\n",
      "Acc_val: tensor(0.8679, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4519, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9213, 0.0675, 0.0000, 0.8189], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 3\n",
      "loss_val: tensor(2.2170)\n",
      "Acc_val: tensor(0.8614, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4629, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9172, 0.1049, 0.0000, 0.8294], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 4\n",
      "loss_val: tensor(2.1896)\n",
      "Acc_val: tensor(0.8632, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4618, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9192, 0.0962, 0.0000, 0.8318], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 5\n",
      "loss_val: tensor(2.1529)\n",
      "Acc_val: tensor(0.8604, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4716, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9175, 0.1339, 0.0000, 0.8352], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 6\n",
      "loss_val: tensor(2.1676)\n",
      "Acc_val: tensor(0.8628, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4691, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9190, 0.1251, 0.0000, 0.8323], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 7\n",
      "loss_val: tensor(1.9968)\n",
      "Acc_val: tensor(0.8370, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4752, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9002, 0.1541, 0.0082, 0.8382], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 8\n",
      "loss_val: tensor(2.0099)\n",
      "Acc_val: tensor(0.8365, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4761, dtype=torch.float64)\n",
      "f_score_val: tensor([0.8985, 0.1594, 0.0109, 0.8356], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 9\n",
      "loss_val: tensor(2.0707)\n",
      "Acc_val: tensor(0.8515, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4741, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9089, 0.1262, 0.0164, 0.8449], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 10\n",
      "loss_val: tensor(2.1955)\n",
      "Acc_val: tensor(0.8642, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4690, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9187, 0.1109, 0.0082, 0.8384], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 11\n",
      "loss_val: tensor(2.1216)\n",
      "Acc_val: tensor(0.8679, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4862, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9209, 0.1574, 0.0164, 0.8499], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 12\n",
      "loss_val: tensor(2.1285)\n",
      "Acc_val: tensor(0.8689, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4760, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9215, 0.1262, 0.0109, 0.8455], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 13\n",
      "loss_val: tensor(2.1551)\n",
      "Acc_val: tensor(0.8754, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4795, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9253, 0.1197, 0.0328, 0.8401], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 14\n",
      "loss_val: tensor(2.1426)\n",
      "Acc_val: tensor(0.8693, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4907, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9235, 0.1791, 0.0219, 0.8385], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 15\n",
      "loss_val: tensor(2.1387)\n",
      "Acc_val: tensor(0.8712, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4806, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9241, 0.1460, 0.0131, 0.8392], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 16\n",
      "loss_val: tensor(2.1161)\n",
      "Acc_val: tensor(0.8698, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4845, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9255, 0.1301, 0.0328, 0.8496], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 17\n",
      "loss_val: tensor(2.1762)\n",
      "Acc_val: tensor(0.8726, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4848, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9263, 0.1085, 0.0492, 0.8553], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 18\n",
      "loss_val: tensor(2.1296)\n",
      "Acc_val: tensor(0.8703, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4870, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9238, 0.1328, 0.0437, 0.8476], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 19\n",
      "loss_val: tensor(2.1296)\n",
      "Acc_val: tensor(0.8731, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4849, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9276, 0.1162, 0.0464, 0.8494], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 20\n",
      "loss_val: tensor(2.1200)\n",
      "Acc_val: tensor(0.8698, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4846, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9255, 0.1284, 0.0355, 0.8489], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 21\n",
      "loss_val: tensor(2.1163)\n",
      "Acc_val: tensor(0.8689, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4785, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9255, 0.1230, 0.0240, 0.8416], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 22\n",
      "loss_val: tensor(2.0858)\n",
      "Acc_val: tensor(0.8731, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4973, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9260, 0.1457, 0.0628, 0.8547], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 23\n",
      "loss_val: tensor(2.1526)\n",
      "Acc_val: tensor(0.8712, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4857, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9259, 0.1383, 0.0355, 0.8432], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 24\n",
      "loss_val: tensor(2.1596)\n",
      "Acc_val: tensor(0.8749, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4806, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9268, 0.1235, 0.0230, 0.8493], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 25\n",
      "loss_val: tensor(2.1390)\n",
      "Acc_val: tensor(0.8707, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4842, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9254, 0.1354, 0.0328, 0.8431], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 26\n",
      "loss_val: tensor(2.1625)\n",
      "Acc_val: tensor(0.8712, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4827, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9258, 0.1332, 0.0246, 0.8471], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 27\n",
      "loss_val: tensor(2.1149)\n",
      "Acc_val: tensor(0.8731, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4888, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9262, 0.1454, 0.0273, 0.8563], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 28\n",
      "loss_val: tensor(2.1148)\n",
      "Acc_val: tensor(0.8731, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4832, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9267, 0.1427, 0.0175, 0.8458], dtype=torch.float64)\n",
      "\n",
      "\n",
      "Validando Epoch 29\n",
      "loss_val: tensor(2.1150)\n",
      "Acc_val: tensor(0.8745, dtype=torch.float64)\n",
      "f_score_val: tensor(0.4902, dtype=torch.float64)\n",
      "f_score_val: tensor([0.9265, 0.1407, 0.0410, 0.8525], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "V = 4\n",
    "pesos = torch.from_numpy(class_weights).float()\n",
    "print (pesos)\n",
    "criterion = FocalLoss(weights=pesos)\n",
    "model = make_model_concat(4, N=2,d_model=768, d_ff=128, h=4, dropout=0.3)\n",
    "model_opt = NoamOpt(model.src_embed[0].d_model, 1, 500, torch.optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-5))\n",
    "\n",
    "hist_train_loss=[]\n",
    "hist_train_acc=[]\n",
    "hist_train_fma=[]\n",
    "hist_val_loss=[]\n",
    "hist_val_acc=[]\n",
    "hist_val_fma=[]\n",
    "\n",
    "for epoch in range(30):\n",
    "    print (\"\")\n",
    "    print (\"\")\n",
    "    model.train()\n",
    "    DATA=data_gen(35, 'Train', 7, new_matrix)\n",
    "    loss_train, acc_train,fma_train, f_none, cm_train=run_epoch(DATA, model, SimpleLossComputeFL(criterion, model_opt), 'Train')\n",
    "    hist_train_loss.append(loss_train)\n",
    "    hist_train_acc.append(acc_train)\n",
    "    hist_train_fma.append(fma_train)\n",
    "\n",
    "    model.eval()\n",
    "    loss_val, acc_val,fma_val, f_val_none, cm_val=run_epoch(data_gen(35, 'Val', 7, new_matrix), model, SimpleLossComputeFL(criterion, None),'Val')\n",
    "    print (\"Validando Epoch\",epoch)\n",
    "    print (\"loss_val:\",loss_val)\n",
    "    print (\"Acc_val:\",acc_val)\n",
    "    print (\"f_score_val:\",fma_val)\n",
    "    print (\"f_score_val:\",f_val_none)\n",
    "    hist_val_loss.append(loss_val)\n",
    "    hist_val_acc.append(acc_val)\n",
    "    hist_val_fma.append(fma_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f849690c940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f848ca85198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f848c7ff470>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(hist_train_loss, label='loss train')\n",
    "plt.plot(hist_val_loss,label='loss val')\n",
    "plt.legend(loc='upper left')\n",
    "plt.title(\"Loss vs epoch\")\n",
    "plt.show()\n",
    "\n",
    "plt.plot(hist_train_acc, label='Acc train')\n",
    "plt.plot(hist_val_acc, label='Acc val')\n",
    "plt.legend(loc='upper left')\n",
    "plt.title(\"Accuracy vs epoch\")\n",
    "plt.show()\n",
    "\n",
    "plt.plot(hist_train_fma, label='f_ma train')\n",
    "plt.plot(hist_val_fma, label='f_ma val')\n",
    "plt.legend(loc='upper left')\n",
    "plt.title(\"F-score macro vs epoch\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "probar factor 5000 con 50 epochs y 0.4 dropout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing\n",
      "SE TUVIERON QUE REPETIR 12 EJEMPLOS\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "print (\"Testing\")\n",
    "predicciones = run_epoch(data_gen(35, 'Test', 5, new_matrix), model, SimpleLossComputeFL(criterion, None),'Test')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "61"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(predicciones)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(61, 35)"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.asarray(predicciones).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2135,)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "todo=np.concatenate(predicciones, axis=-1)\n",
    "todo.shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2135"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2123 + 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({0: 1674, 3: 376, 1: 51, 2: 34})\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f8481ccb518>"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f8496e25fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print (Counter(todo))\n",
    "sns.countplot(todo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({0: 3661, 3: 2582, 2: 76, 1: 55})\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f84821f1ba8>"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f848c0d1b70>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print (Counter(y_train_har))\n",
    "sns.countplot(y_train_har)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({0: 1493, 3: 525, 1: 71, 2: 36})\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f848c7b97b8>"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f848225cba8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_val_har=np.load(\"matrices/y_val_num_4.npy\")\n",
    "print (Counter(y_val_har))\n",
    "sns.countplot(y_val_har)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}