NLP 4 - CNN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classificação de Texto utilizando Convolutional Neural Network\n",
    "Autor: Lucas Kenji Sudo\n",
    "\n",
    "E-mail: lucaskenjis@gmail.com\n",
    "\n",
    "Linkedin : linkedin.com/in/lucas-sudo-701647121/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import nltk\n",
    "import re\n",
    "import numpy as np\n",
    "import time\n",
    "\n",
    "# Imports para NLP\n",
    "#from nltk import word_tokenize\n",
    "from bs4 import BeautifulSoup\n",
    "from nltk import regexp_tokenize\n",
    "from nltk.corpus import stopwords\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "\n",
    "start_time = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('IMDB Dataset.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "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>review</th>\n",
       "      <th>sentiment</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>One of the other reviewers has mentioned that ...</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>A wonderful little production. &lt;br /&gt;&lt;br /&gt;The...</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>I thought this was a wonderful way to spend ti...</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Basically there's a family where a little boy ...</td>\n",
       "      <td>negative</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Petter Mattei's \"Love in the Time of Money\" is...</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              review sentiment\n",
       "0  One of the other reviewers has mentioned that ...  positive\n",
       "1  A wonderful little production. <br /><br />The...  positive\n",
       "2  I thought this was a wonderful way to spend ti...  positive\n",
       "3  Basically there's a family where a little boy ...  negative\n",
       "4  Petter Mattei's \"Love in the Time of Money\" is...  positive"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "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>review</th>\n",
       "      <th>sentiment</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>50000</td>\n",
       "      <td>50000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>unique</th>\n",
       "      <td>49582</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>top</th>\n",
       "      <td>Loved today's show!!! It was a variety and not...</td>\n",
       "      <td>positive</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>freq</th>\n",
       "      <td>5</td>\n",
       "      <td>25000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                   review sentiment\n",
       "count                                               50000     50000\n",
       "unique                                              49582         2\n",
       "top     Loved today's show!!! It was a variety and not...  positive\n",
       "freq                                                    5     25000"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Remover review duplicadas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[~df.review.duplicated()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Remover colunas null"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=df[~df.review.isnull()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Limpeza"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Método para limpeza de texto aplicando:\n",
    "    - replace para um caractere específico\n",
    "    - isdigit para verificar se a palavra é um digito e assim, remove-la.\n",
    "    - limpeza de tag html usando BeautifulSoup\n",
    "    - regexp_tokenize para transformar textos em tokens, e coletar apenas palavras através do regex [\\w]+. Ignorando acentos.\n",
    "    - .lower() para deixar as palavras minusculas\n",
    "    - stopwords para remover palavras que não agregam informações"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#nltk.download('stopwords')\n",
    "eng_stpw = set(stopwords.words('english'))\n",
    "\n",
    "def padronizardados(text):\n",
    "    # remover caractere especifico\n",
    "    text = text.replace('\\ ','')\n",
    "    # remover digitos\n",
    "    text = ''.join([i for i in text if not i.isdigit()])\n",
    "    # remover tags html\n",
    "    soup = BeautifulSoup(text, \"html.parser\")\n",
    "    #tokenization e lower case\n",
    "    text = regexp_tokenize(soup.get_text().lower(),\"[\\w]+\")\n",
    "    #remover stopwords\n",
    "    temp = []\n",
    "    for t in text:\n",
    "        if t not in eng_stpw:\n",
    "            temp.append(t)\n",
    "    new_text = (' '.join(temp))\n",
    "    \n",
    "    return new_text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Texto antes do método"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Taut and organically gripping, Edward Dmytryk\\'s Crossfire is a distinctive suspense thriller, an unlikely \"message\" movie using the look and devices of the noir cycle.<br /><br />Bivouacked in Washington, DC, a company of soldiers cope with their restlessness by hanging out in bars. Three of them end up at a stranger\\'s apartment where Robert Ryan, drunk and belligerent, beats their host (Sam Levene) to death because he happens to be Jewish. Police detective Robert Young investigates with the help of Robert Mitchum, who\\'s assigned to Ryan\\'s outfit. Suspicion falls on the second of the three (George Cooper), who has vanished. Ryan slays the third buddy (Steve Brodie) to insure his silence before Young closes in.<br /><br />Abetted by a superior script by John Paxton, Dmytryk draws precise performances from his three starring Bobs. Ryan, naturally, does his prototypical Angry White Male (and to the hilt), while Mitchum underplays with his characteristic alert nonchalance (his role, however, is not central); Young may never have been better. Gloria Grahame gives her first fully-fledged rendition of the smart-mouthed, vulnerable tramp, and, as a sad sack who\\'s leeched into her life, Paul Kelly haunts us in a small, peripheral role that he makes memorable.<br /><br />The politically engaged Dmytryk perhaps inevitably succumbs to sermonizing, but it\\'s pretty much confined to Young\\'s reminiscence of how his Irish grandfather died at the hands of bigots a century earlier (thus, incidentally, stretching chronology to the limit). At least there\\'s no attempt to render an explanation, however glib, of why Ryan hates Jews (and hillbillies and...).<br /><br />Curiously, Crossfire survives even the major change wrought upon it -- the novel it\\'s based on (Richard Brooks\\' The Brick Foxhole) dealt with a gay-bashing murder. But homosexuality in 1947 was still Beyond The Pale. News of the Holocaust had, however, begun to emerge from the ashes of Europe, so Hollywood felt emboldened to register its protest against anti-Semitism (the studios always quaked at the prospect of offending any potential ticket buyer).<br /><br />But while the change from homophobia to anti-Semitism works in general, the specifics don\\'t fit so smoothly. The victim\\'s chatting up a lonesome, drunk young soldier then inviting him back home looks odd, even though (or especially since) there\\'s a girlfriend in tow. It raises the question whether this scenario was retained inadvertently or left in as a discreet tip-off to the original engine generating Ryan\\'s murderous rage.'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.review[30]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Aplicando método de limpeza aos textos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.review = df.review.apply(padronizardados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Texto depois do método"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'taut organically gripping edward dmytryk crossfire distinctive suspense thriller unlikely message movie using look devices noir cycle bivouacked washington dc company soldiers cope restlessness hanging bars three end stranger apartment robert ryan drunk belligerent beats host sam levene death happens jewish police detective robert young investigates help robert mitchum assigned ryan outfit suspicion falls second three george cooper vanished ryan slays third buddy steve brodie insure silence young closes abetted superior script john paxton dmytryk draws precise performances three starring bobs ryan naturally prototypical angry white male hilt mitchum underplays characteristic alert nonchalance role however central young may never better gloria grahame gives first fully fledged rendition smart mouthed vulnerable tramp sad sack leeched life paul kelly haunts us small peripheral role makes memorable politically engaged dmytryk perhaps inevitably succumbs sermonizing pretty much confined young reminiscence irish grandfather died hands bigots century earlier thus incidentally stretching chronology limit least attempt render explanation however glib ryan hates jews hillbillies curiously crossfire survives even major change wrought upon novel based richard brooks brick foxhole dealt gay bashing murder homosexuality still beyond pale news holocaust however begun emerge ashes europe hollywood felt emboldened register protest anti semitism studios always quaked prospect offending potential ticket buyer change homophobia anti semitism works general specifics fit smoothly victim chatting lonesome drunk young soldier inviting back home looks odd even though especially since girlfriend tow raises question whether scenario retained inadvertently left discreet tip original engine generating ryan murderous rage'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.review[30]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Transformar sentiments em 0 e 1 (Label encoder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "le = LabelEncoder()\n",
    "df.sentiment= le.fit_transform(df.sentiment)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.rename(columns={\"sentiment\" : \"positive\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Função plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "def plot_history(history):\n",
    "    acc = history.history['acc']\n",
    "    val_acc = history.history['val_acc']\n",
    "    loss = history.history['loss']\n",
    "    val_loss = history.history['val_loss']\n",
    "    x = range(1, len(acc) + 1)\n",
    "\n",
    "    plt.figure(figsize=(12, 5))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(x, acc, 'b', label='Training acc')\n",
    "    plt.plot(x, val_acc, 'r', label='Validation acc')\n",
    "    plt.title('Training and validation accuracy')\n",
    "    plt.legend()\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(x, loss, 'b', label='Training loss')\n",
    "    plt.plot(x, val_loss, 'r', label='Validation loss')\n",
    "    plt.title('Training and validation loss')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# --------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN\n",
    "   As CNNs podem ser entendidas como um conjunto de várias camadas de convoluções com funções de ativação não lineares. Ela é muito conhecida por sua aplicação em classificação de imagens, mas também está sendo amplamente utilizada para classificação de texto. \n",
    "   \n",
    "   Durante a fase de treinamento, uma CNN aprende automaticamente os valores de seus filtros com base na tarefa que você deseja executar. Caso esteja sendo utilizado para classificação de imagens, ela pode detectar padrões como bordas de figuras, caso esteja sendo utilizado para classificação de texto, pode detectar padrões como expressões ou palavras compostas. \n",
    "\tAs CNNs podem ser construídas com alguns layers:\n",
    "    - Convolution Layer \n",
    "    - Activation Layer\n",
    "    - Pooling Layer\n",
    "    - Fully Connected Layer\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Convolution layer\n",
    "\n",
    "   É geralmente a primeira e principal camada da CNN, onde aplica-se N filtros (também chamados de kernels) aos dados de entrada. Os filtros são unidades (vetores ou matrizes) que são aplicadas através dos dados, como se fosse uma janela deslizante, extraindo padrões e caracteristicas dos dados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](c.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para aplicações em NLP, filtros n-dimensionais são aplicados ao conjunto de dados. Cada linha da matriz corresponde a um token, geralmente uma palavra ou conjunto de palavras."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](nlp.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Activation layer\n",
    "Conhecido também como Non Linear Activation Layer, é responsável por aprender padrões em dados não lineares. A função mais utilizada é a Relu, onde os dados negativos são transformados em valores igual à ZERO, e dados positivos não alterados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](relu.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Pooling layer\n",
    "É responsável por reduzir o tamanho espacial das convoluções (obtidas na Convolution layer) através de filtros. Isso é útil para extrair características importantes e para diminuir a complexidade e dimensionalidade do modelo.\n",
    "Os filtros utilizados tem 2 parâmentros importantes:\n",
    "    1. Dimension of Spatial Extent: Quantidade de features mapeadas pelo filtro para fazer a redução de dimensionalidade, ou seja, o tamanho do filtro; (No gif abaixo, percebemos o filtro=3x3)\n",
    "    2. Stride: Quantidade de posições que o filtro avança após uma aplicação. (No gif abaixo, percebemos o Stride = 1) \n",
    "    \n",
    "A técnica mais utilizada é o MaxPooling, que retorna o maior valor dos dados encontrado pelo filtro."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](pooling.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Fully Connected Layer\n",
    "A camada tem essa nome, pois cada neurônio da camada anterior está conectado ao neurônio da camada posterior. É responsável por aprender as combinações não lineares das features e identificar as categorias da classificação."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Split dados\n",
    "    - Optei por separar os dados em treino, validação e teste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "  \n",
    "X_train, X_test, y_train, y_test  = train_test_split(df.review, df.positive, test_size=0.2, random_state=1)\n",
    "\n",
    "X_test, X_val, y_test, y_val = train_test_split(X_test, y_test, test_size=0.5, random_state=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Tokenization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.text import Tokenizer\n",
    "\n",
    "#Número máximo de palavras do X_train é 100619\n",
    "tokenizer = Tokenizer(num_words=20000) #10000 #20000 #30000 #OVERFITTING\n",
    "#tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(X_train)\n",
    "\n",
    "x_train = tokenizer.texts_to_sequences(X_train)\n",
    "x_test = tokenizer.texts_to_sequences(X_test)\n",
    "x_val = tokenizer.texts_to_sequences(X_val)\n",
    "\n",
    "vocab_size = len(tokenizer.word_index) + 1  # Adding 1 because of reserved 0 index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "92720"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(tokenizer.word_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* pad_sequence: One problem that we have is that each text sequence has in most cases different length of words. To counter this, you can use pad_sequence() which simply pads the sequence of words with zeros.\n",
    "\n",
    "* maxlen = how long the sequences should be"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   86     1  3253   104    71    56     4   193 11556  3435  6682  3122\n",
      "  5453   375    86   170   704 11556   885   109   121    19  6346   606\n",
      "    68   565   120   145     6   218   181   206   307     1  2325  1007\n",
      "    26 18540    36   544  2903   165     3   141  4063    42    30    60\n",
      "   390   648   133     1    77  3512    69  3328    71    77   327     6\n",
      "  2694    16    48    60     1   648   133  2026   461     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0     0     0     0     0\n",
      "     0     0     0     0     0     0     0     0]\n"
     ]
    }
   ],
   "source": [
    "from keras.preprocessing.sequence import pad_sequences\n",
    "\n",
    "#maxlen = max(len(x) for x in x_train) # longest text in train set\n",
    "maxlen = 200 #100\n",
    "\n",
    "x_train = pad_sequences(x_train, padding='post', maxlen=maxlen)\n",
    "x_test = pad_sequences(x_test, padding='post', maxlen=maxlen)\n",
    "x_val = pad_sequences(x_val, padding='post', maxlen=maxlen)\n",
    "\n",
    "print(x_train[0, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maxlen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* input_dim:tamanho do vocabulary\n",
    "* output_dim: tamanho do vetor\n",
    "* input_length: tamanho da entrada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_14\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_14 (Embedding)     (None, 200, 200)          18544200  \n",
      "_________________________________________________________________\n",
      "conv1d_14 (Conv1D)           (None, 200, 5)            1005      \n",
      "_________________________________________________________________\n",
      "max_pooling1d_14 (MaxPooling (None, 100, 5)            0         \n",
      "_________________________________________________________________\n",
      "flatten_14 (Flatten)         (None, 500)               0         \n",
      "_________________________________________________________________\n",
      "dense_14 (Dense)             (None, 1)                 501       \n",
      "=================================================================\n",
      "Total params: 18,545,706\n",
      "Trainable params: 18,545,706\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras import layers\n",
    "\n",
    "embedding_dim = 200\n",
    "\n",
    "model = Sequential()\n",
    "model.add(layers.Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=maxlen))\n",
    "model.add(layers.Conv1D(5, 1, activation='relu'))\n",
    "model.add(layers.MaxPooling1D(pool_size=2))\n",
    "model.add(layers.Flatten())\n",
    "#model.add(layers.Dense(10, activation='relu'))\n",
    "model.add(layers.Dense(1, activation='sigmoid'))\n",
    "model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "history = model.fit(x_train, y_train,\n",
    "                    epochs=20,\n",
    "                    verbose=False,\n",
    "                    validation_data=(x_val, y_val),\n",
    "                    batch_size=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 0.8032\n",
      "Val Accuracy:  0.7711\n",
      "Testing Accuracy:  0.7636\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(x_train, y_train, verbose=False)\n",
    "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
    "loss, accuracy = model.evaluate(x_val, y_val, verbose=False)\n",
    "print(\"Val Accuracy:  {:.4f}\".format(accuracy))\n",
    "loss, accuracy = model.evaluate(x_test, y_test, verbose=False)\n",
    "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.layers import Dense, Activation, Dropout, Flatten, Input\n",
    "from keras.layers import Embedding, Conv1D, MaxPooling1D, GlobalMaxPooling1D, GlobalAveragePooling1D\n",
    "from keras.models import Model, Sequential \n",
    "from keras.layers.merge import concatenate\n",
    "from numpy import array\n",
    "\n",
    "def define_model(length, vocab_size):\n",
    "# channel 1\n",
    "    inputs1 = Input(shape=(length,))\n",
    "    embedding1 = Embedding(vocab_size, 100)(inputs1)\n",
    "    conv1 = Conv1D(filters=1, kernel_size=1, activation='relu')(embedding1)\n",
    "    #drop1 = Dropout(0.5)(conv1)\n",
    "    pool1 = MaxPooling1D(pool_size=2)(conv1)\n",
    "    flat1 = Flatten()(pool1)\n",
    "    # channel 2\n",
    "    inputs2 = Input(shape=(length,))\n",
    "    embedding2 = Embedding(vocab_size, 100)(inputs2)\n",
    "    conv2 = Conv1D(filters=1, kernel_size=2, activation='relu')(embedding2)\n",
    "    #drop2 = Dropout(0.5)(conv2)\n",
    "    pool2 = MaxPooling1D(pool_size=2)(conv2)\n",
    "    flat2 = Flatten()(pool2)\n",
    "    # channel 3\n",
    "    inputs3 = Input(shape=(length,))\n",
    "    embedding3 = Embedding(vocab_size, 100)(inputs3)\n",
    "    conv3 = Conv1D(filters=1, kernel_size=1, activation='relu')(embedding3)\n",
    "    #drop3 = Dropout(0.5)(conv3)\n",
    "    pool3 = MaxPooling1D(pool_size=3)(conv3)\n",
    "    flat3 = Flatten()(pool3)\n",
    "    # merge\n",
    "    merged = concatenate([flat1, flat2, flat3])\n",
    "    # interpretation\n",
    "    #dense1 = Dense(10, activation='relu')(merged)\n",
    "    outputs = Dense(1, activation='sigmoid')(merged)\n",
    "    model = Model(inputs=[inputs1, inputs2, inputs3], outputs=outputs)\n",
    "    # compile\n",
    "    model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
    "    # summarize\n",
    "    print(model.summary())\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_1 (InputLayer)            (None, 100)          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "input_2 (InputLayer)            (None, 100)          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "input_3 (InputLayer)            (None, 100)          0                                            \n",
      "__________________________________________________________________________________________________\n",
      "embedding_2 (Embedding)         (None, 100, 100)     9272100     input_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "embedding_3 (Embedding)         (None, 100, 100)     9272100     input_2[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "embedding_4 (Embedding)         (None, 100, 100)     9272100     input_3[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "conv1d_2 (Conv1D)               (None, 100, 1)       101         embedding_2[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "conv1d_3 (Conv1D)               (None, 100, 1)       101         embedding_3[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "conv1d_4 (Conv1D)               (None, 100, 1)       101         embedding_4[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "max_pooling1d_2 (MaxPooling1D)  (None, 50, 1)        0           conv1d_2[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "max_pooling1d_3 (MaxPooling1D)  (None, 50, 1)        0           conv1d_3[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "max_pooling1d_4 (MaxPooling1D)  (None, 50, 1)        0           conv1d_4[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "flatten_2 (Flatten)             (None, 50)           0           max_pooling1d_2[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "flatten_3 (Flatten)             (None, 50)           0           max_pooling1d_3[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "flatten_4 (Flatten)             (None, 50)           0           max_pooling1d_4[0][0]            \n",
      "__________________________________________________________________________________________________\n",
      "concatenate_1 (Concatenate)     (None, 150)          0           flatten_2[0][0]                  \n",
      "                                                                 flatten_3[0][0]                  \n",
      "                                                                 flatten_4[0][0]                  \n",
      "__________________________________________________________________________________________________\n",
      "dense_2 (Dense)                 (None, 1)            151         concatenate_1[0][0]              \n",
      "==================================================================================================\n",
      "Total params: 27,816,754\n",
      "Trainable params: 27,816,754\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "model = define_model(maxlen, vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 39665 samples, validate on 4959 samples\n",
      "Epoch 1/10\n",
      "39665/39665 [==============================] - 24s 598us/step - loss: 0.6889 - acc: 0.5359 - val_loss: 0.6784 - val_acc: 0.5886\n",
      "Epoch 2/10\n",
      "39665/39665 [==============================] - 22s 542us/step - loss: 0.6172 - acc: 0.7130 - val_loss: 0.5440 - val_acc: 0.7637\n",
      "Epoch 3/10\n",
      "39665/39665 [==============================] - 21s 541us/step - loss: 0.4347 - acc: 0.8201 - val_loss: 0.3919 - val_acc: 0.8298\n",
      "Epoch 4/10\n",
      "39665/39665 [==============================] - 20s 506us/step - loss: 0.3195 - acc: 0.8690 - val_loss: 0.3396 - val_acc: 0.8572\n",
      "Epoch 5/10\n",
      "39665/39665 [==============================] - 20s 516us/step - loss: 0.2702 - acc: 0.8917 - val_loss: 0.3252 - val_acc: 0.8613\n",
      "Epoch 6/10\n",
      "39665/39665 [==============================] - 21s 539us/step - loss: 0.2437 - acc: 0.9034 - val_loss: 0.3233 - val_acc: 0.8617\n",
      "Epoch 7/10\n",
      "39665/39665 [==============================] - 21s 538us/step - loss: 0.2269 - acc: 0.9113 - val_loss: 0.3285 - val_acc: 0.8570\n",
      "Epoch 8/10\n",
      "39665/39665 [==============================] - 21s 534us/step - loss: 0.2143 - acc: 0.9163 - val_loss: 0.3355 - val_acc: 0.8570\n",
      "Epoch 9/10\n",
      "39665/39665 [==============================] - 21s 540us/step - loss: 0.2050 - acc: 0.9200 - val_loss: 0.3418 - val_acc: 0.8552\n",
      "Epoch 10/10\n",
      "39665/39665 [==============================] - 21s 537us/step - loss: 0.1979 - acc: 0.9230 - val_loss: 0.3498 - val_acc: 0.8570\n"
     ]
    }
   ],
   "source": [
    "history = model.fit([x_train,x_train,x_train], y_train,\n",
    "                    epochs=10,validation_data=([x_val,x_val,x_val], y_val),\n",
    "                    batch_size=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 0.9311\n",
      "Val Accuracy:  0.8570\n",
      "Testing Accuracy:  0.8449\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate([x_train,x_train,x_train], y_train, verbose=False)\n",
    "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
    "loss, accuracy = model.evaluate([x_val,x_val,x_val], y_val, verbose=False)\n",
    "print(\"Val Accuracy:  {:.4f}\".format(accuracy))\n",
    "loss, accuracy = model.evaluate([x_test,x_test,x_test], y_test, verbose=False)\n",
    "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(history)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}