Models.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['figure.figsize'] = (6,6)\n",
    "\n",
    "from keras import backend as K\n",
    "from keras.engine.topology import Layer\n",
    "from keras import initializers, regularizers, constraints\n",
    "\n",
    "from keras.layers import Dense, Input, LSTM, Bidirectional, Activation, Conv1D, GRU, TimeDistributed\n",
    "from keras.layers import Dropout, Embedding, GlobalMaxPooling1D, MaxPooling1D, Add, Flatten, SpatialDropout1D\n",
    "from keras.layers import GlobalAveragePooling1D, BatchNormalization, concatenate\n",
    "from keras.layers import Reshape, merge, Concatenate, Lambda, Average\n",
    "from keras.models import Sequential, Model, load_model\n",
    "from keras.callbacks import ModelCheckpoint\n",
    "from keras.initializers import Constant\n",
    "from keras.layers.merge import add\n",
    "\n",
    "from keras.preprocessing import sequence\n",
    "from keras.preprocessing.text import Tokenizer, text_to_word_sequence\n",
    "from keras.utils import np_utils\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "# Input data files are available in the \"../input/\" directory.\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n",
    "\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>authors</th>\n",
       "      <th>category</th>\n",
       "      <th>date</th>\n",
       "      <th>headline</th>\n",
       "      <th>link</th>\n",
       "      <th>short_description</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Melissa Jeltsen</td>\n",
       "      <td>CRIME</td>\n",
       "      <td>2018-05-26</td>\n",
       "      <td>There Were 2 Mass Shootings In Texas Last Week...</td>\n",
       "      <td>https://www.huffingtonpost.com/entry/texas-ama...</td>\n",
       "      <td>She left her husband. He killed their children...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Andy McDonald</td>\n",
       "      <td>ENTERTAINMENT</td>\n",
       "      <td>2018-05-26</td>\n",
       "      <td>Will Smith Joins Diplo And Nicky Jam For The 2...</td>\n",
       "      <td>https://www.huffingtonpost.com/entry/will-smit...</td>\n",
       "      <td>Of course it has a song.</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ron Dicker</td>\n",
       "      <td>ENTERTAINMENT</td>\n",
       "      <td>2018-05-26</td>\n",
       "      <td>Hugh Grant Marries For The First Time At Age 57</td>\n",
       "      <td>https://www.huffingtonpost.com/entry/hugh-gran...</td>\n",
       "      <td>The actor and his longtime girlfriend Anna Ebe...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Ron Dicker</td>\n",
       "      <td>ENTERTAINMENT</td>\n",
       "      <td>2018-05-26</td>\n",
       "      <td>Jim Carrey Blasts 'Castrato' Adam Schiff And D...</td>\n",
       "      <td>https://www.huffingtonpost.com/entry/jim-carre...</td>\n",
       "      <td>The actor gives Dems an ass-kicking for not fi...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Ron Dicker</td>\n",
       "      <td>ENTERTAINMENT</td>\n",
       "      <td>2018-05-26</td>\n",
       "      <td>Julianna Margulies Uses Donald Trump Poop Bags...</td>\n",
       "      <td>https://www.huffingtonpost.com/entry/julianna-...</td>\n",
       "      <td>The \"Dietland\" actress said using the bags is ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           authors       category       date  \\\n",
       "0  Melissa Jeltsen          CRIME 2018-05-26   \n",
       "1    Andy McDonald  ENTERTAINMENT 2018-05-26   \n",
       "2       Ron Dicker  ENTERTAINMENT 2018-05-26   \n",
       "3       Ron Dicker  ENTERTAINMENT 2018-05-26   \n",
       "4       Ron Dicker  ENTERTAINMENT 2018-05-26   \n",
       "\n",
       "                                            headline  \\\n",
       "0  There Were 2 Mass Shootings In Texas Last Week...   \n",
       "1  Will Smith Joins Diplo And Nicky Jam For The 2...   \n",
       "2    Hugh Grant Marries For The First Time At Age 57   \n",
       "3  Jim Carrey Blasts 'Castrato' Adam Schiff And D...   \n",
       "4  Julianna Margulies Uses Donald Trump Poop Bags...   \n",
       "\n",
       "                                                link  \\\n",
       "0  https://www.huffingtonpost.com/entry/texas-ama...   \n",
       "1  https://www.huffingtonpost.com/entry/will-smit...   \n",
       "2  https://www.huffingtonpost.com/entry/hugh-gran...   \n",
       "3  https://www.huffingtonpost.com/entry/jim-carre...   \n",
       "4  https://www.huffingtonpost.com/entry/julianna-...   \n",
       "\n",
       "                                   short_description  \n",
       "0  She left her husband. He killed their children...  \n",
       "1                           Of course it has a song.  \n",
       "2  The actor and his longtime girlfriend Anna Ebe...  \n",
       "3  The actor gives Dems an ass-kicking for not fi...  \n",
       "4  The \"Dietland\" actress said using the bags is ...  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_json('News_Category_Dataset_v2.json', lines=True)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total categories: 41\n",
      "category\n",
      "ARTS               1509\n",
      "ARTS & CULTURE     1339\n",
      "BLACK VOICES       4528\n",
      "BUSINESS           5937\n",
      "COLLEGE            1144\n",
      "COMEDY             5175\n",
      "CRIME              3405\n",
      "CULTURE & ARTS     1030\n",
      "DIVORCE            3426\n",
      "EDUCATION          1004\n",
      "ENTERTAINMENT     16058\n",
      "ENVIRONMENT        1323\n",
      "FIFTY              1401\n",
      "FOOD & DRINK       6226\n",
      "GOOD NEWS          1398\n",
      "GREEN              2622\n",
      "HEALTHY LIVING     6694\n",
      "HOME & LIVING      4195\n",
      "IMPACT             3459\n",
      "LATINO VOICES      1129\n",
      "MEDIA              2815\n",
      "MONEY              1707\n",
      "PARENTING          8677\n",
      "PARENTS            3955\n",
      "POLITICS          32739\n",
      "QUEER VOICES       6314\n",
      "RELIGION           2556\n",
      "SCIENCE            2178\n",
      "SPORTS             4884\n",
      "STYLE              2254\n",
      "STYLE & BEAUTY     9649\n",
      "TASTE              2096\n",
      "TECH               2082\n",
      "THE WORLDPOST      3664\n",
      "TRAVEL             9887\n",
      "WEDDINGS           3651\n",
      "WEIRD NEWS         2670\n",
      "WELLNESS          17827\n",
      "WOMEN              3490\n",
      "WORLD NEWS         2177\n",
      "WORLDPOST          2579\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "cates = df.groupby('category')\n",
    "print(\"total categories:\", cates.ngroups)\n",
    "print(cates.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.category = df.category.map(lambda x: \"WORLDPOST\" if x == \"THE WORLDPOST\" else x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total categories: 40\n",
      "category\n",
      "ARTS               1509\n",
      "ARTS & CULTURE     1339\n",
      "BLACK VOICES       4528\n",
      "BUSINESS           5937\n",
      "COLLEGE            1144\n",
      "COMEDY             5175\n",
      "CRIME              3405\n",
      "CULTURE & ARTS     1030\n",
      "DIVORCE            3426\n",
      "EDUCATION          1004\n",
      "ENTERTAINMENT     16058\n",
      "ENVIRONMENT        1323\n",
      "FIFTY              1401\n",
      "FOOD & DRINK       6226\n",
      "GOOD NEWS          1398\n",
      "GREEN              2622\n",
      "HEALTHY LIVING     6694\n",
      "HOME & LIVING      4195\n",
      "IMPACT             3459\n",
      "LATINO VOICES      1129\n",
      "MEDIA              2815\n",
      "MONEY              1707\n",
      "PARENTING          8677\n",
      "PARENTS            3955\n",
      "POLITICS          32739\n",
      "QUEER VOICES       6314\n",
      "RELIGION           2556\n",
      "SCIENCE            2178\n",
      "SPORTS             4884\n",
      "STYLE              2254\n",
      "STYLE & BEAUTY     9649\n",
      "TASTE              2096\n",
      "TECH               2082\n",
      "TRAVEL             9887\n",
      "WEDDINGS           3651\n",
      "WEIRD NEWS         2670\n",
      "WELLNESS          17827\n",
      "WOMEN              3490\n",
      "WORLD NEWS         2177\n",
      "WORLDPOST          6243\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "cates = df.groupby('category')\n",
    "print(\"total categories:\", cates.ngroups)\n",
    "print(cates.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "def clean_str(string):\n",
    "    \"\"\"\n",
    "    Tokenization/string cleaning for dataset\n",
    "    Every dataset is lower cased except\n",
    "    \"\"\"\n",
    "    string = re.sub(r\"[^A-Za-z0-9(),!?\\'\\`]\", \" \", string)\n",
    "\n",
    "    return string.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using headlines and short_description as input X\n",
    "\n",
    "df['text'] = df.headline + \" \" + df.short_description\n",
    "\n",
    "# tokenizing\n",
    "\n",
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(df.text)\n",
    "X = tokenizer.texts_to_sequences(df.text)\n",
    "df['words'] = X\n",
    "\n",
    "# delete some empty and short data\n",
    "\n",
    "df['word_length'] = df.words.apply(lambda i: len(i))\n",
    "df = df[df.word_length >= 5]\n",
    "\n",
    "df = df.drop(df.columns[[0, 2,3,4,5,7,8]], axis=1)\n",
    "\n",
    "df.shape\n",
    "df.to_csv('cleaned.csv',encoding='utf-8')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(127945, 3)\n",
      "(31986, 3)\n",
      "(39983, 3)\n"
     ]
    }
   ],
   "source": [
    "df1 = pd.read_csv('cleaned.csv')\n",
    "X=df1.sample(frac=0.8,random_state=200)\n",
    "test=df1.drop(X.index)\n",
    "train=X.sample(frac=0.8,random_state=200)\n",
    "val=X.drop(train.index)\n",
    "\n",
    "print(train.shape)\n",
    "print(val.shape)\n",
    "print(test.shape)\n",
    "# train.to_csv('data/news_cat/train.csv', sep='\\t')\n",
    "# val.to_csv('data/news_cat/val.csv', sep='\\t')\n",
    "# test.to_csv('data/news_cat/test.csv', sep='\\t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:5: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \"\"\"\n"
     ]
    }
   ],
   "source": [
    "clean_df = pd.read_csv('cleaned.csv')\n",
    "sent_lens = []\n",
    "sent_nums = []\n",
    "for idx in range(clean_df.text.shape[0]):\n",
    "    clean_df.text[idx] = clean_str(clean_df.text[idx])\n",
    "\n",
    "clean_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train=df.sample(frac=0.8[p,random_state=200)\n",
    "test=df.drop(train.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    199914.000000\n",
       "mean         29.725032\n",
       "std          14.024717\n",
       "min           5.000000\n",
       "25%          20.000000\n",
       "50%          29.000000\n",
       "75%          36.000000\n",
       "max         248.000000\n",
       "Name: word_length, dtype: float64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.word_length.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxlen = 50\n",
    "X = list(sequence.pad_sequences(df.words, maxlen=maxlen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/ipykernel_launcher.py:8: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "categories = df.groupby('category').size().index.tolist()\n",
    "category_int = {}\n",
    "int_category = {}\n",
    "for i, k in enumerate(categories):\n",
    "    category_int.update({k:i})\n",
    "    int_category.update({i:k})\n",
    "\n",
    "df['c2id'] = df['category'].apply(lambda x: category_int[x])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 116617 unique tokens.\n",
      "Total 2195892 word vectors.\n"
     ]
    }
   ],
   "source": [
    "word_index = tokenizer.word_index\n",
    "\n",
    "EMBEDDING_DIM = 300\n",
    "\n",
    "embeddings_index = {}\n",
    "f = open('glove.840B.300d.txt')\n",
    "for line in f:\n",
    "    values = line.split()\n",
    "    word = ''.join(values[:-300])\n",
    "    coefs = np.asarray(values[-300:], dtype='float32')\n",
    "    embeddings_index[word] = coefs\n",
    "f.close()\n",
    "\n",
    "print('Found %s unique tokens.' % len(word_index))\n",
    "print('Total %s word vectors.' % len(embeddings_index))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_matrix = np.zeros((len(word_index) + 1, EMBEDDING_DIM))\n",
    "for word, i in word_index.items():\n",
    "    embedding_vector = embeddings_index.get(word)\n",
    "    if embedding_vector is not None:\n",
    "        embedding_matrix[i] = embedding_vector\n",
    "\n",
    "embedding_layer = Embedding(len(word_index)+1,\n",
    "                            EMBEDDING_DIM,\n",
    "                            embeddings_initializer=Constant(embedding_matrix),\n",
    "                            input_length=maxlen,\n",
    "                            trainable=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prepared data \n",
    "\n",
    "X = np.array(X)\n",
    "Y = np_utils.to_categorical(list(df.c2id))\n",
    "\n",
    "# and split to training set and validation set\n",
    "\n",
    "seed = 29\n",
    "x_train, x_val, y_train, y_val = train_test_split(X, Y, test_size=0.2, random_state=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bidrectional LSTM with convolution\n",
    "# from https://www.kaggle.com/eashish/bidirectional-gru-with-convolution\n",
    "\n",
    "inp = Input(shape=(maxlen,), dtype='int32')\n",
    "x = embedding_layer(inp)\n",
    "x = SpatialDropout1D(0.2)(x)\n",
    "x = Bidirectional(GRU(128, return_sequences=True, dropout=0.1, recurrent_dropout=0.1))(x)\n",
    "x = Conv1D(64, kernel_size=3)(x)\n",
    "avg_pool = GlobalAveragePooling1D()(x)\n",
    "max_pool = GlobalMaxPooling1D()(x)\n",
    "x = concatenate([avg_pool, max_pool])\n",
    "outp = Dense(len(int_category), activation=\"softmax\")(x)\n",
    "\n",
    "BiGRU = Model(inp, outp)\n",
    "BiGRU.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])\n",
    "\n",
    "BiGRU.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bigru_history = BiGRU.fit(x_train, \n",
    "                          y_train, \n",
    "                          batch_size=128, \n",
    "                          epochs=20, \n",
    "                          validation_data=(x_val, y_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rcParams['figure.figsize'] = (6,6)\n",
    "\n",
    "acc = bigru_history.history['acc']\n",
    "val_acc = bigru_history.history['val_acc']\n",
    "loss = bigru_history.history['loss']\n",
    "val_loss = bigru_history.history['val_loss']\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.plot(epochs, acc, 'red', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'blue', label='Validation acc')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "plt.title('Training and validation loss')\n",
    "plt.plot(epochs, loss, 'red', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'blue', label='Validation loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "embedding_2 (Embedding)      (None, 50, 300)           34985400  \n",
      "_________________________________________________________________\n",
      "lstm_1 (LSTM)                (None, 50, 300)           721200    \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 50, 300)           0         \n",
      "_________________________________________________________________\n",
      "attention_1 (Attention)      (None, 300)               350       \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 256)               77056     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 256)               0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_1 (Batch (None, 256)               1024      \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 40)                10280     \n",
      "=================================================================\n",
      "Total params: 35,795,310\n",
      "Trainable params: 809,398\n",
      "Non-trainable params: 34,985,912\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "class Attention(Layer):\n",
    "    def __init__(self, step_dim,\n",
    "                 W_regularizer=None, b_regularizer=None,\n",
    "                 W_constraint=None, b_constraint=None,\n",
    "                 bias=True, **kwargs):\n",
    "        self.supports_masking = True\n",
    "        self.init = initializers.get('glorot_uniform')\n",
    "        self.W_regularizer = regularizers.get(W_regularizer)\n",
    "        self.b_regularizer = regularizers.get(b_regularizer)\n",
    "        self.W_constraint = constraints.get(W_constraint)\n",
    "        self.b_constraint = constraints.get(b_constraint)\n",
    "        self.bias = bias\n",
    "        self.step_dim = step_dim\n",
    "        self.features_dim = 0\n",
    "        super(Attention, self).__init__(**kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        assert len(input_shape) == 3\n",
    "        self.W = self.add_weight((input_shape[-1],),\n",
    "                                 initializer=self.init,\n",
    "                                 name='{}_W'.format(self.name),\n",
    "                                 regularizer=self.W_regularizer,\n",
    "                                 constraint=self.W_constraint)\n",
    "        self.features_dim = input_shape[-1]\n",
    "        if self.bias:\n",
    "            self.b = self.add_weight((input_shape[1],),\n",
    "                                     initializer='zero',\n",
    "                                     name='{}_b'.format(self.name),\n",
    "                                     regularizer=self.b_regularizer,\n",
    "                                     constraint=self.b_constraint)\n",
    "        else:\n",
    "            self.b = None\n",
    "        self.built = True\n",
    "\n",
    "    def compute_mask(self, input, input_mask=None):\n",
    "        return None\n",
    "\n",
    "    def call(self, x, mask=None):\n",
    "        features_dim = self.features_dim\n",
    "        step_dim = self.step_dim\n",
    "        eij = K.reshape(K.dot(K.reshape(x, (-1, features_dim)), K.reshape(self.W, (features_dim, 1))), (-1, step_dim))\n",
    "        if self.bias:\n",
    "            eij += self.b\n",
    "        eij = K.tanh(eij)\n",
    "        a = K.exp(eij)\n",
    "        if mask is not None:\n",
    "            a *= K.cast(mask, K.floatx())\n",
    "        a /= K.cast(K.sum(a, axis=1, keepdims=True) + K.epsilon(), K.floatx())\n",
    "        a = K.expand_dims(a)\n",
    "        weighted_input = x * a\n",
    "        return K.sum(weighted_input, axis=1)\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        return input_shape[0],  self.features_dim\n",
    "    \n",
    "\n",
    "lstm_layer = LSTM(300, dropout=0.25, recurrent_dropout=0.25, return_sequences=True)\n",
    "\n",
    "inp = Input(shape=(maxlen,), dtype='int32')\n",
    "embedding= embedding_layer(inp)\n",
    "x = lstm_layer(embedding)\n",
    "x = Dropout(0.25)(x)\n",
    "merged = Attention(maxlen)(x)\n",
    "merged = Dense(256, activation='relu')(merged)\n",
    "merged = Dropout(0.25)(merged)\n",
    "merged = BatchNormalization()(merged)\n",
    "outp = Dense(len(int_category), activation='softmax')(merged)\n",
    "\n",
    "AttentionLSTM = Model(inputs=inp, outputs=outp)\n",
    "AttentionLSTM.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc'])\n",
    "\n",
    "AttentionLSTM.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 159931 samples, validate on 39983 samples\n",
      "Epoch 1/20\n",
      "159931/159931 [==============================] - 126s 788us/step - loss: 1.6651 - acc: 0.5483 - val_loss: 1.3324 - val_acc: 0.6139\n",
      "Epoch 2/20\n",
      "159931/159931 [==============================] - 99s 622us/step - loss: 1.3665 - acc: 0.6104 - val_loss: 1.2331 - val_acc: 0.6389\n",
      "Epoch 3/20\n",
      "159931/159931 [==============================] - 99s 618us/step - loss: 1.2669 - acc: 0.6322 - val_loss: 1.1892 - val_acc: 0.6479\n",
      "Epoch 4/20\n",
      "159931/159931 [==============================] - 104s 650us/step - loss: 1.2039 - acc: 0.6463 - val_loss: 1.1635 - val_acc: 0.6558\n",
      "Epoch 5/20\n",
      "159931/159931 [==============================] - 99s 619us/step - loss: 1.1514 - acc: 0.6582 - val_loss: 1.1386 - val_acc: 0.6629\n",
      "Epoch 6/20\n",
      "159931/159931 [==============================] - 98s 614us/step - loss: 1.1074 - acc: 0.6684 - val_loss: 1.1258 - val_acc: 0.6664\n",
      "Epoch 7/20\n",
      "159931/159931 [==============================] - 98s 615us/step - loss: 1.0675 - acc: 0.6786 - val_loss: 1.1233 - val_acc: 0.6661\n",
      "Epoch 8/20\n",
      "159931/159931 [==============================] - 94s 586us/step - loss: 1.0342 - acc: 0.6868 - val_loss: 1.1208 - val_acc: 0.6669\n",
      "Epoch 9/20\n",
      "159931/159931 [==============================] - 92s 577us/step - loss: 1.0069 - acc: 0.6926 - val_loss: 1.1275 - val_acc: 0.6680\n",
      "Epoch 10/20\n",
      "159931/159931 [==============================] - 93s 584us/step - loss: 0.9800 - acc: 0.6991 - val_loss: 1.1209 - val_acc: 0.6719\n",
      "Epoch 11/20\n",
      "159931/159931 [==============================] - 93s 582us/step - loss: 0.9572 - acc: 0.7037 - val_loss: 1.1273 - val_acc: 0.6717\n",
      "Epoch 12/20\n",
      "159931/159931 [==============================] - 94s 589us/step - loss: 0.9372 - acc: 0.7098 - val_loss: 1.1279 - val_acc: 0.6710\n",
      "Epoch 13/20\n",
      "159931/159931 [==============================] - 89s 558us/step - loss: 0.9183 - acc: 0.7146 - val_loss: 1.1302 - val_acc: 0.6701\n",
      "Epoch 14/20\n",
      "159931/159931 [==============================] - 90s 561us/step - loss: 0.9026 - acc: 0.7166 - val_loss: 1.1515 - val_acc: 0.6727\n",
      "Epoch 15/20\n",
      "159931/159931 [==============================] - 90s 566us/step - loss: 0.8891 - acc: 0.7205 - val_loss: 1.1436 - val_acc: 0.6725\n",
      "Epoch 16/20\n",
      "159931/159931 [==============================] - 90s 565us/step - loss: 0.8741 - acc: 0.7240 - val_loss: 1.1510 - val_acc: 0.6721\n",
      "Epoch 17/20\n",
      "159931/159931 [==============================] - 94s 588us/step - loss: 0.8588 - acc: 0.7275 - val_loss: 1.1620 - val_acc: 0.6724\n",
      "Epoch 18/20\n",
      "159931/159931 [==============================] - 96s 603us/step - loss: 0.8458 - acc: 0.7320 - val_loss: 1.1677 - val_acc: 0.6737\n",
      "Epoch 19/20\n",
      "159931/159931 [==============================] - 95s 594us/step - loss: 0.8393 - acc: 0.7322 - val_loss: 1.1539 - val_acc: 0.6714\n",
      "Epoch 20/20\n",
      "159931/159931 [==============================] - 92s 575us/step - loss: 0.8281 - acc: 0.7367 - val_loss: 1.1673 - val_acc: 0.6722\n"
     ]
    }
   ],
   "source": [
    "attlstm_history = AttentionLSTM.fit(x_train, \n",
    "                                    y_train, \n",
    "                                    batch_size=128, \n",
    "                                    epochs=20, \n",
    "                                    validation_data=(x_val, y_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = attlstm_history.history['acc']\n",
    "val_acc = attlstm_history.history['val_acc']\n",
    "loss = attlstm_history.history['loss']\n",
    "val_loss = attlstm_history.history['val_loss']\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.plot(epochs, acc, 'red', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'blue', label='Validation acc')\n",
    "plt.legend()\n",
    "\n",
    "plt.figure()\n",
    "plt.title('Training and validation loss')\n",
    "plt.plot(epochs, loss, 'red', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'blue', label='Validation loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}