{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IMDB Movie Review classification\n",
    "* Author: Johannes Maucher\n",
    "* Last Update: 16.07.2024"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Text-Classification in general\n",
    "Until this stage of the lecture you should be aware of the following 4 different approaches for text classification:\n",
    "\n",
    "1. **Bag-of-Word + Conventional ML**: This is a quite old approach for text classifications. Texts are modelled as *Bag-of-Word* vectors and these numeric vectors can be passed to any conventional ML algorithm e.g. Naive Bayes, Logistic Regresseion, SVM, SLP, MLP, ...\n",
    "\n",
    "2. **Embedding-Bag + Conventional ML**: \n",
    "\n",
    "```{figure} https://maucher.home.hdm-stuttgart.de/Pics/textBagLinear.png\n",
    "---\n",
    "align: center\n",
    "width: 600pt\n",
    "name:  embeddingbag\n",
    "---\n",
    "Embedding-Bag: For each word in the text a word embedding is calculated and all embeddings are added. The resulting summed vector is passed to any conventional ML algorithm.\n",
    "```\n",
    "\n",
    "3. **Word Embeddings passed to a 1D-CNNL**: \n",
    "\n",
    "```{figure} https://maucher.home.hdm-stuttgart.de/Pics/text1DConv.png\n",
    "---\n",
    "align: center\n",
    "width: 500pt\n",
    "name:  embedding1dcnn\n",
    "---\n",
    "Embeddings of the words in the text are passed in order to the input of a 1-D CNN.\n",
    "```\n",
    "\n",
    "4. **Word Embeddings passed to a RNN (any type of RNN)**: \n",
    "```{figure} https://maucher.home.hdm-stuttgart.de/Pics/textRNN.png\n",
    "---\n",
    "align: center\n",
    "width: 550pt\n",
    "name:  embeddingrnn\n",
    "---\n",
    "Embeddings of the words in the text are passed in order to the input of a RNN of any type.\n",
    "```\n",
    "\n",
    "In this notebook we implement approach 3 and 4 for classifying IMDB movie reviews. Later on you will also learn how a Transformer like BERT can be applied for text-classification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Access IMDB dataset\n",
    "The IMDB Movie Review corpus is a standard dataset for the evaluation of text-classifiers. It consists of 25000 movies reviews from IMDB, labeled by sentiment (positive/negative). In this notebook a Convolutional Neural Network (CNN) is implemented for sentiment classification of IMDB reviews."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T07:25:29.240427Z",
     "start_time": "2018-02-27T07:25:26.260347Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-12-09 20:41:04.905965: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-12-09 20:41:04.906111: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-12-09 20:41:05.173575: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2024-12-09 20:41:05.744627: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-12-09 20:41:09.347972: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "from tensorflow.keras.utils import to_categorical\n",
    "from tensorflow.keras.layers import Embedding, Dense, Input, Flatten, Conv1D, MaxPooling1D, Dropout, Concatenate, GlobalMaxPool1D\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.datasets import imdb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T07:25:29.249141Z",
     "start_time": "2018-02-27T07:25:29.242539Z"
    }
   },
   "outputs": [],
   "source": [
    "MAX_NB_WORDS = 10000        # number of most-frequent words that are regarded, all others are ignored\n",
    "EMBEDDING_DIM = 100         # dimension of word-embedding\n",
    "INDEX_FROM=3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [IMDB dataset](https://keras.io/datasets/) is already available in Keras and can easily be accessed by\n",
    "\n",
    "`imdb.load_data()`. \n",
    "\n",
    "The returned dataset contains the sequence of word indices for each review. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=MAX_NB_WORDS,index_from=INDEX_FROM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25000,)\n",
      "(25000,)\n",
      "(25000,)\n",
      "(25000,)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(X_test.shape)\n",
    "print(y_train.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First 15 tokens of the first training document:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 14, 22, 16, 43, 530, 973, 1622, 1385, 65, 458, 4468, 66, 3941, 4]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[0][:15] #plot first 10 elements of the sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First 15 tokens of the second training document:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 194, 1153, 194, 8255, 78, 228, 5, 6, 1463, 4369, 5012, 134, 26, 4]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[1][:15] #plot first 10 elements of the sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First 15 tokens of the third training document:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 14, 47, 8, 30, 31, 7, 4, 249, 108, 7, 4, 5974, 54, 61]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[2][:15] #plot first 10 elements of the sequence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The representation of text as sequence of integers is good for Machine Learning algorithms, but useless for human text understanding. Therefore, we also access the word-index from [Keras IMDB dataset](https://keras.io/api/datasets/imdb/), which maps words to the associated integer-IDs. Since we like to map integer-IDs to words we calculate the inverse wordindex `inv_wordindex`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "wordindex=imdb.get_word_index(path=\"imdb_word_index.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example:** Index of word `the`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wordindex[\"the\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As can be seen, in the output above the index of word `the` is 1. This is because the index is ordered w.r.t. the frequency of words in the dictionary and `the` is the most frequent word."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the wordindex which we got from `imdb.get_word_index()` is not exactly the index, which has been applied in the indexing of imdb-reviews, which are returned by the method `imdb.load_data()`. The difference is a shift of 3 in the indexes. I.e. in the reviews, returned by `imdb.load_data()` the word `the` is represented by the integer 4. This is because in the vocabulary applied for `imdb.load_data()` four special tokens are added at the first index-positions. We also have to add this special tokens, if we like to decode our integer-sequences to real texts: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "wordindex = {k:(v+INDEX_FROM) for k,v in wordindex.items()}\n",
    "wordindex[\"<PAD>\"] = 0\n",
    "wordindex[\"<START>\"] = 1\n",
    "wordindex[\"<UNK>\"] = 2\n",
    "wordindex[\"<UNUSED>\"] = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the index of word `the` is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wordindex[\"the\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we calculate the inverse wordindex, which maps integers to words:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "inv_wordindex = {value:key for key,value in wordindex.items()}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can decode the integer-sequences of our reviews into real texts. The first film-review of the training-partition then reads as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<START> big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal <UNK> the hair is big lots of boobs <UNK> men wear those cut <UNK> shirts that show off their <UNK> sickening that men actually wore them and the music is just <UNK> trash that plays over and over again in almost every scene there is trashy music boobs and <UNK> taking away bodies and the gym still doesn't close for <UNK> all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\n"
     ]
    }
   ],
   "source": [
    "print(' '.join(inv_wordindex[id] for id in X_train[1] ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next the distribution of review-lengths (words per review) is calculated:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "textlenghtsTrain=[len(t) for t in X_train]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.hist(textlenghtsTrain,bins=20)\n",
    "plt.title(\"Distribution of text lengths in words\")\n",
    "plt.xlabel(\"number of words per document\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given this length-distribution, we set our sequence length as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_SEQUENCE_LENGTH = 500  # all text-sequences are padded to this length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing Text Sequences and Labels\n",
    "All sequences must be padded to unique length of `MAX_SEQUENCE_LENGTH`. This means, that longer sequences are cut and shorter sequences are filled with zeros. For this Keras provides the `pad_sequences()`-function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = pad_sequences(X_train, maxlen=MAX_SEQUENCE_LENGTH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test = pad_sequences(X_test, maxlen=MAX_SEQUENCE_LENGTH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, all class-labels must be represented in one-hot-encoded form:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T07:25:59.863486Z",
     "start_time": "2018-02-27T07:25:59.853395Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of Training Data Input: (25000, 500)\n",
      "Shape of Training Data Labels: (25000, 2)\n"
     ]
    }
   ],
   "source": [
    "y_train = to_categorical(np.asarray(y_train))\n",
    "y_test = to_categorical(np.asarray(y_test))\n",
    "print('Shape of Training Data Input:', X_train.shape)\n",
    "print('Shape of Training Data Labels:', y_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of positive and negative reviews in training and validation set \n",
      "[12500. 12500.]\n",
      "[12500. 12500.]\n"
     ]
    }
   ],
   "source": [
    "print('Number of positive and negative reviews in training and validation set ')\n",
    "print (y_train.sum(axis=0))\n",
    "print (y_test.sum(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CNN with 2 Convolutional Layers\n",
    "\n",
    "The first network architecture consists of\n",
    "* an embedding layer. This layer takes sequences of integers and learns word-embeddings. The sequences of word-embeddings are then passed to the first convolutional layer\n",
    "* two 1D-convolutional layers with different number of filters and different filter-sizes\n",
    "* two Max-Pooling layers to reduce the number of neurons, required in the following layers\n",
    "* a MLP classifier with one hidden layer and the output layer\n",
    "\n",
    "### Prepare Embedding Matrix and -Layer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T07:26:10.445153Z",
     "start_time": "2018-02-27T07:26:10.247006Z"
    }
   },
   "outputs": [],
   "source": [
    "embedding_layer = Embedding(MAX_NB_WORDS,\n",
    "                            EMBEDDING_DIM,\n",
    "                            #weights=[embedding_matrix],\n",
    "                            input_length=MAX_SEQUENCE_LENGTH,\n",
    "                            trainable=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define CNN architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T07:26:10.731164Z",
     "start_time": "2018-02-27T07:26:10.447394Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-12-09 21:10:01.898705: W tensorflow/core/common_runtime/gpu/gpu_device.cc:2256] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n"
     ]
    }
   ],
   "source": [
    "sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')\n",
    "embedded_sequences = embedding_layer(sequence_input)\n",
    "l_cov1= Conv1D(32, 5, activation='relu')(embedded_sequences)\n",
    "l_pool1 = MaxPooling1D(2)(l_cov1)\n",
    "l_cov2 = Conv1D(64, 3, activation='relu')(l_pool1)\n",
    "l_pool2 = MaxPooling1D(5)(l_cov2)\n",
    "l_flat = Flatten()(l_pool2)\n",
    "l_dense = Dense(64, activation='relu')(l_flat)\n",
    "preds = Dense(2, activation='softmax')(l_dense)\n",
    "model = Model(sequence_input, preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T07:26:10.793699Z",
     "start_time": "2018-02-27T07:26:10.733432Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 500)]             0         \n",
      "                                                                 \n",
      " embedding (Embedding)       (None, 500, 100)          1000000   \n",
      "                                                                 \n",
      " conv1d (Conv1D)             (None, 496, 32)           16032     \n",
      "                                                                 \n",
      " max_pooling1d (MaxPooling1  (None, 248, 32)           0         \n",
      " D)                                                              \n",
      "                                                                 \n",
      " conv1d_1 (Conv1D)           (None, 246, 64)           6208      \n",
      "                                                                 \n",
      " max_pooling1d_1 (MaxPoolin  (None, 49, 64)            0         \n",
      " g1D)                                                            \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 3136)              0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 64)                200768    \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 2)                 130       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1223138 (4.67 MB)\n",
      "Trainable params: 1223138 (4.67 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer='rmsprop',\n",
    "              metrics=['categorical_accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T08:05:52.012732Z",
     "start_time": "2018-02-27T07:26:10.796149Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model fitting - simplified convolutional neural network\n"
     ]
    }
   ],
   "source": [
    "print(\"model fitting - simplified convolutional neural network\")\n",
    "history=model.fit(X_train, y_train, validation_data=(X_test, y_test),epochs=6, verbose=False, batch_size=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['categorical_accuracy']\n",
    "val_acc = history.history['val_categorical_accuracy']\n",
    "max_val_acc=np.max(val_acc)\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "\n",
    "plt.plot(epochs, acc, 'bo', label='Training accuracy')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 5s 7ms/step - loss: 0.5011 - categorical_accuracy: 0.8498\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.5010811686515808, 0.8497599959373474]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, after 6 epochs of training the cross-entropy-loss is 0.501 and the accuracy is 84.98%. However, it seems that the accuracy-value after 3 epochs has been higher, than the accuracy after 6 epochs. This indicates overfitting due to too long learning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CNN with different filter sizes in one layer\n",
    "In [Y. Kim; Convolutional Neural Networks for Sentence Classification](https://arxiv.org/pdf/1408.5882v2.pdf) a CNN with different filter-sizes in one layer has been proposed. This CNN is implemented below:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![KimCnn](https://maucher.home.hdm-stuttgart.de/Pics/KimCnn.png)\n",
    "\n",
    "Source: [Y. Kim; Convolutional Neural Networks for Sentence Classification](https://arxiv.org/pdf/1408.5882v2.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare Embedding Matrix and -Layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T08:05:52.225106Z",
     "start_time": "2018-02-27T08:05:52.015903Z"
    }
   },
   "outputs": [],
   "source": [
    "embedding_layer = Embedding(MAX_NB_WORDS,\n",
    "                            EMBEDDING_DIM,\n",
    "                            #weights=[embedding_matrix],\n",
    "                            input_length=MAX_SEQUENCE_LENGTH,\n",
    "                            trainable=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T08:05:52.653393Z",
     "start_time": "2018-02-27T08:05:52.227460Z"
    }
   },
   "outputs": [],
   "source": [
    "convs = []\n",
    "filter_sizes = [3,4,5]\n",
    "\n",
    "sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')\n",
    "embedded_sequences = embedding_layer(sequence_input)\n",
    "\n",
    "for fsz in filter_sizes:\n",
    "    l_conv = Conv1D(filters=32,kernel_size=fsz,activation='relu')(embedded_sequences)\n",
    "    l_pool = MaxPooling1D(4)(l_conv)\n",
    "    convs.append(l_pool)\n",
    "    \n",
    "l_merge = Concatenate(axis=1)(convs)\n",
    "l_cov1= Conv1D(64, 5, activation='relu')(l_merge)\n",
    "l_pool1 = GlobalMaxPool1D()(l_cov1)\n",
    "#l_cov2 = Conv1D(128, 5, activation='relu')(l_pool1)\n",
    "#l_pool2 = MaxPooling1D(30)(l_cov2)\n",
    "l_flat = Flatten()(l_pool1)\n",
    "l_dense = Dense(64, activation='relu')(l_flat)\n",
    "preds = Dense(2, activation='softmax')(l_dense)\n",
    "\n",
    "model = Model(sequence_input, preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input_2 (InputLayer)        [(None, 500)]                0         []                            \n",
      "                                                                                                  \n",
      " embedding_1 (Embedding)     (None, 500, 100)             1000000   ['input_2[0][0]']             \n",
      "                                                                                                  \n",
      " conv1d_2 (Conv1D)           (None, 498, 32)              9632      ['embedding_1[0][0]']         \n",
      "                                                                                                  \n",
      " conv1d_3 (Conv1D)           (None, 497, 32)              12832     ['embedding_1[0][0]']         \n",
      "                                                                                                  \n",
      " conv1d_4 (Conv1D)           (None, 496, 32)              16032     ['embedding_1[0][0]']         \n",
      "                                                                                                  \n",
      " max_pooling1d_2 (MaxPoolin  (None, 124, 32)              0         ['conv1d_2[0][0]']            \n",
      " g1D)                                                                                             \n",
      "                                                                                                  \n",
      " max_pooling1d_3 (MaxPoolin  (None, 124, 32)              0         ['conv1d_3[0][0]']            \n",
      " g1D)                                                                                             \n",
      "                                                                                                  \n",
      " max_pooling1d_4 (MaxPoolin  (None, 124, 32)              0         ['conv1d_4[0][0]']            \n",
      " g1D)                                                                                             \n",
      "                                                                                                  \n",
      " concatenate (Concatenate)   (None, 372, 32)              0         ['max_pooling1d_2[0][0]',     \n",
      "                                                                     'max_pooling1d_3[0][0]',     \n",
      "                                                                     'max_pooling1d_4[0][0]']     \n",
      "                                                                                                  \n",
      " conv1d_5 (Conv1D)           (None, 368, 64)              10304     ['concatenate[0][0]']         \n",
      "                                                                                                  \n",
      " global_max_pooling1d (Glob  (None, 64)                   0         ['conv1d_5[0][0]']            \n",
      " alMaxPooling1D)                                                                                  \n",
      "                                                                                                  \n",
      " flatten_1 (Flatten)         (None, 64)                   0         ['global_max_pooling1d[0][0]']\n",
      "                                                                                                  \n",
      " dense_2 (Dense)             (None, 64)                   4160      ['flatten_1[0][0]']           \n",
      "                                                                                                  \n",
      " dense_3 (Dense)             (None, 2)                    130       ['dense_2[0][0]']             \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 1053090 (4.02 MB)\n",
      "Trainable params: 1053090 (4.02 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer='rmsprop',\n",
    "              metrics=['categorical_accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-02-27T10:30:20.771569Z",
     "start_time": "2018-02-27T10:17:57.889209Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model fitting - more complex convolutional neural network\n",
      "Epoch 1/8\n",
      "196/196 [==============================] - 55s 280ms/step - loss: 0.6112 - categorical_accuracy: 0.6336 - val_loss: 0.3946 - val_categorical_accuracy: 0.8298\n",
      "Epoch 2/8\n",
      "196/196 [==============================] - 55s 279ms/step - loss: 0.3409 - categorical_accuracy: 0.8531 - val_loss: 0.3042 - val_categorical_accuracy: 0.8718\n",
      "Epoch 3/8\n",
      "196/196 [==============================] - 54s 278ms/step - loss: 0.2382 - categorical_accuracy: 0.9030 - val_loss: 0.2883 - val_categorical_accuracy: 0.8818\n",
      "Epoch 4/8\n",
      "196/196 [==============================] - 54s 278ms/step - loss: 0.1749 - categorical_accuracy: 0.9341 - val_loss: 0.2858 - val_categorical_accuracy: 0.8885\n",
      "Epoch 5/8\n",
      "196/196 [==============================] - 55s 280ms/step - loss: 0.1228 - categorical_accuracy: 0.9556 - val_loss: 0.2974 - val_categorical_accuracy: 0.8880\n",
      "Epoch 6/8\n",
      "196/196 [==============================] - 54s 278ms/step - loss: 0.0839 - categorical_accuracy: 0.9724 - val_loss: 0.3450 - val_categorical_accuracy: 0.8811\n",
      "Epoch 7/8\n",
      "196/196 [==============================] - 55s 280ms/step - loss: 0.0505 - categorical_accuracy: 0.9849 - val_loss: 0.4407 - val_categorical_accuracy: 0.8728\n",
      "Epoch 8/8\n",
      "196/196 [==============================] - 55s 279ms/step - loss: 0.0297 - categorical_accuracy: 0.9912 - val_loss: 0.4342 - val_categorical_accuracy: 0.8812\n"
     ]
    }
   ],
   "source": [
    "print(\"model fitting - more complex convolutional neural network\")\n",
    "history=model.fit(X_train, y_train, validation_data=(X_test, y_test),epochs=8, batch_size=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['categorical_accuracy']\n",
    "val_acc = history.history['val_categorical_accuracy']\n",
    "max_val_acc=np.max(val_acc)\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "\n",
    "plt.plot(epochs, acc, 'bo', label='Training accuracy')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 11s 13ms/step - loss: 0.4342 - categorical_accuracy: 0.8812\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.4342169463634491, 0.8812000155448914]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, after 8 epochs of training the cross-entropy-loss is 0.434 and the accuracy is 88.12%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import LSTM, Bidirectional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_layer = Embedding(MAX_NB_WORDS,\n",
    "                            EMBEDDING_DIM,\n",
    "                            #weights=[embedding_matrix],\n",
    "                            input_length=MAX_SEQUENCE_LENGTH,\n",
    "                            trainable=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')\n",
    "embedded_sequences = embedding_layer(sequence_input)\n",
    "l_lstm = Bidirectional(LSTM(64))(embedded_sequences)\n",
    "preds = Dense(2, activation='softmax')(l_lstm)\n",
    "model = Model(sequence_input, preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_2\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_3 (InputLayer)        [(None, 500)]             0         \n",
      "                                                                 \n",
      " embedding_2 (Embedding)     (None, 500, 100)          1000000   \n",
      "                                                                 \n",
      " bidirectional (Bidirection  (None, 128)               84480     \n",
      " al)                                                             \n",
      "                                                                 \n",
      " dense_4 (Dense)             (None, 2)                 258       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1084738 (4.14 MB)\n",
      "Trainable params: 1084738 (4.14 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model fitting - Bidirectional LSTM\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer='rmsprop',\n",
    "              metrics=['categorical_accuracy'])\n",
    "\n",
    "print(\"model fitting - Bidirectional LSTM\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/6\n",
      "196/196 [==============================] - 150s 754ms/step - loss: 0.5227 - categorical_accuracy: 0.7223 - val_loss: 0.4264 - val_categorical_accuracy: 0.8202\n",
      "Epoch 2/6\n",
      "196/196 [==============================] - 147s 752ms/step - loss: 0.3275 - categorical_accuracy: 0.8640 - val_loss: 0.3937 - val_categorical_accuracy: 0.8202\n",
      "Epoch 3/6\n",
      "196/196 [==============================] - 147s 748ms/step - loss: 0.2750 - categorical_accuracy: 0.8924 - val_loss: 0.3298 - val_categorical_accuracy: 0.8605\n",
      "Epoch 4/6\n",
      "196/196 [==============================] - 147s 752ms/step - loss: 0.2407 - categorical_accuracy: 0.9097 - val_loss: 0.2941 - val_categorical_accuracy: 0.8808\n",
      "Epoch 5/6\n",
      "196/196 [==============================] - 147s 751ms/step - loss: 0.2142 - categorical_accuracy: 0.9184 - val_loss: 0.4389 - val_categorical_accuracy: 0.8352\n",
      "Epoch 6/6\n",
      "196/196 [==============================] - 147s 750ms/step - loss: 0.1928 - categorical_accuracy: 0.9289 - val_loss: 0.4811 - val_categorical_accuracy: 0.8514\n"
     ]
    }
   ],
   "source": [
    "history=model.fit(X_train, y_train, validation_data=(X_test, y_test),epochs=6, batch_size=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['categorical_accuracy']\n",
    "val_acc = history.history['val_categorical_accuracy']\n",
    "max_val_acc=np.max(val_acc)\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "\n",
    "plt.plot(epochs, acc, 'bo', label='Training accuracy')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 42s 53ms/step - loss: 0.4811 - categorical_accuracy: 0.8514\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.48110508918762207, 0.8514000177383423]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, after 6 epochs of training the cross-entropy-loss is 0.4811 and the accuracy is 85.14%. However, it seems that the accuracy-value after 2 epochs has been higher, than the accuracy after 6 epochs. This indicates overfitting due to too long learning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bidirectional LSTM architecture with Attention\n",
    "\n",
    "### Define Custom Attention Layer\n",
    "Since Keras does not provide an attention-layer, we have to implement this type on our own. The implementation below corresponds to the attention-concept as introduced in [Bahdanau et al: Neural Machine Translation by Jointly Learning to Align and Translate](https://arxiv.org/pdf/1409.0473.pdf).\n",
    "\n",
    "The general concept of writing custom Keras layers is described in the corresponding [Keras documentation](https://keras.io/layers/writing-your-own-keras-layers/). \n",
    "\n",
    "Any custom layer class inherits from the layer-class and must implement three methods:\n",
    "\n",
    "- `build(input_shape)`: this is where you will define your weights. This method must set `self.built = True`, which can be done by calling `super([Layer], self).build()`.\n",
    "- `call(x)`: this is where the layer's logic lives. Unless you want your layer to support masking, you only have to care about the first argument passed to call: the input tensor.\n",
    "- `compute_output_shape(input_shape)`: in case your layer modifies the shape of its input, you should specify here the shape transformation logic. This allows Keras to do automatic shape inference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import regularizers, initializers,constraints\n",
    "from tensorflow.keras.layers import Layer\n",
    "import tensorflow.keras.backend as K\n",
    "\n",
    "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",
    "\n",
    "        self.W_regularizer = regularizers.get(W_regularizer)\n",
    "        self.b_regularizer = regularizers.get(b_regularizer)\n",
    "\n",
    "        self.W_constraint = constraints.get(W_constraint)\n",
    "        self.b_constraint = constraints.get(b_constraint)\n",
    "\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",
    "\n",
    "        self.W = self.add_weight(shape=(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",
    "\n",
    "        if self.bias:\n",
    "            self.b = self.add_weight(shape=(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",
    "\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",
    "\n",
    "        eij = K.reshape(K.dot(K.reshape(x, (-1, features_dim)),\n",
    "                        K.reshape(self.W, (features_dim, 1))), (-1, step_dim))\n",
    "\n",
    "        if self.bias:\n",
    "            eij += self.b\n",
    "\n",
    "        eij = K.tanh(eij)\n",
    "\n",
    "        a = K.exp(eij)\n",
    "\n",
    "        if mask is not None:\n",
    "            a *= K.cast(mask, K.floatx())\n",
    "\n",
    "        a /= K.cast(K.sum(a, axis=1, keepdims=True) + K.epsilon(), K.floatx())\n",
    "\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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_layer = Embedding(MAX_NB_WORDS,\n",
    "                            EMBEDDING_DIM,\n",
    "                            #weights=[embedding_matrix],\n",
    "                            input_length=MAX_SEQUENCE_LENGTH,\n",
    "                            trainable=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32')\n",
    "embedded_sequences = embedding_layer(sequence_input)\n",
    "l_gru = Bidirectional(LSTM(64, return_sequences=True))(embedded_sequences)\n",
    "l_att = Attention(MAX_SEQUENCE_LENGTH)(l_gru)\n",
    "preds = Dense(2, activation='softmax')(l_att)\n",
    "model = Model(sequence_input, preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_3\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_5 (InputLayer)        [(None, 500)]             0         \n",
      "                                                                 \n",
      " embedding_4 (Embedding)     (None, 500, 100)          1000000   \n",
      "                                                                 \n",
      " bidirectional_2 (Bidirecti  (None, 500, 128)          84480     \n",
      " onal)                                                           \n",
      "                                                                 \n",
      " attention_1 (Attention)     (None, 128)               628       \n",
      "                                                                 \n",
      " dense_5 (Dense)             (None, 2)                 258       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 1085366 (4.14 MB)\n",
      "Trainable params: 1085366 (4.14 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='categorical_crossentropy',\n",
    "              optimizer='rmsprop',\n",
    "              metrics=['categorical_accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/6\n",
      "196/196 [==============================] - 166s 837ms/step - loss: 0.6922 - categorical_accuracy: 0.5175 - val_loss: 0.6888 - val_categorical_accuracy: 0.5082\n",
      "Epoch 2/6\n",
      "196/196 [==============================] - 162s 829ms/step - loss: 0.5559 - categorical_accuracy: 0.7150 - val_loss: 0.3844 - val_categorical_accuracy: 0.8459\n",
      "Epoch 3/6\n",
      "196/196 [==============================] - 163s 831ms/step - loss: 0.3490 - categorical_accuracy: 0.8574 - val_loss: 0.3288 - val_categorical_accuracy: 0.8570\n",
      "Epoch 4/6\n",
      "196/196 [==============================] - 162s 829ms/step - loss: 0.2747 - categorical_accuracy: 0.8916 - val_loss: 0.3041 - val_categorical_accuracy: 0.8746\n",
      "Epoch 5/6\n",
      "196/196 [==============================] - 163s 832ms/step - loss: 0.2300 - categorical_accuracy: 0.9111 - val_loss: 0.2938 - val_categorical_accuracy: 0.8753\n",
      "Epoch 6/6\n",
      "196/196 [==============================] - 163s 830ms/step - loss: 0.1996 - categorical_accuracy: 0.9239 - val_loss: 0.2776 - val_categorical_accuracy: 0.8834\n"
     ]
    }
   ],
   "source": [
    "history=model.fit(X_train, y_train, validation_data=(X_test, y_test),epochs=6, batch_size=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['categorical_accuracy']\n",
    "val_acc = history.history['val_categorical_accuracy']\n",
    "max_val_acc=np.max(val_acc)\n",
    "\n",
    "epochs = range(1, len(acc) + 1)\n",
    "\n",
    "plt.figure(figsize=(8,6))\n",
    "\n",
    "plt.plot(epochs, acc, 'bo', label='Training accuracy')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.grid(True)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "782/782 [==============================] - 45s 58ms/step - loss: 0.2776 - categorical_accuracy: 0.8834\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.27762892842292786, 0.8833600282669067]"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, the achieved accuracy is in the same range as for the other architectures. None of the architectures has been optimized, e.g. through hyperparameter-tuning. However, the goal of this notebook is not the determination of an optimal model, but the demonstration of how modern neural network architectures can be implemented for text-classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "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.9.20"
  },
  "nav_menu": {},
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "261.3333435058594px"
   },
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}