bert-lstm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BERT Embeddings on SMS Spam Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TF version:  2.0.0\n",
      "Hub version:  0.7.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow_hub as hub\n",
    "import tensorflow as tf\n",
    "from bert.tokenization import FullTokenizer\n",
    "from tensorflow.keras.models import Model\n",
    "print(\"TF version: \", tf.__version__)\n",
    "print(\"Hub version: \", hub.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_seq_length = 256  # Your choice here.\n",
    "input_word_ids = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\n",
    "                                       name=\"input_word_ids\")\n",
    "input_mask = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\n",
    "                                   name=\"input_mask\")\n",
    "segment_ids = tf.keras.layers.Input(shape=(max_seq_length,), dtype=tf.int32,\n",
    "                                    name=\"segment_ids\")\n",
    "bert_layer = hub.KerasLayer(\"https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/1\",\n",
    "                            trainable=True)\n",
    "pooled_output, sequence_output = bert_layer([input_word_ids, input_mask, segment_ids])\n",
    "\n",
    "model = Model(inputs=[input_word_ids, input_mask, segment_ids], outputs=[pooled_output, sequence_output])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_masks(tokens, max_seq_length):\n",
    "    \"\"\"Mask for padding\"\"\"\n",
    "    if len(tokens)>max_seq_length:\n",
    "        raise IndexError(\"Token length more than max seq length!\")\n",
    "    return [1]*len(tokens) + [0] * (max_seq_length - len(tokens))\n",
    "\n",
    "\n",
    "def get_segments(tokens, max_seq_length):\n",
    "    \"\"\"Segments: 0 for the first sequence, 1 for the second\"\"\"\n",
    "    if len(tokens)>max_seq_length:\n",
    "        raise IndexError(\"Token length more than max seq length!\")\n",
    "    segments = []\n",
    "    current_segment_id = 0\n",
    "    for token in tokens:\n",
    "        segments.append(current_segment_id)\n",
    "        if token == \"[SEP]\":\n",
    "            current_segment_id = 1\n",
    "    return segments + [0] * (max_seq_length - len(tokens))\n",
    "\n",
    "\n",
    "def get_ids(tokens, tokenizer, max_seq_length):\n",
    "    \"\"\"Token ids from Tokenizer vocab\"\"\"\n",
    "    token_ids = tokenizer.convert_tokens_to_ids(tokens)\n",
    "    input_ids = token_ids + [0] * (max_seq_length-len(token_ids))\n",
    "    return input_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_file = bert_layer.resolved_object.vocab_file.asset_path.numpy()\n",
    "do_lower_case = bert_layer.resolved_object.do_lower_case.numpy()\n",
    "tokenizer = FullTokenizer(vocab_file, do_lower_case)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ids_masks_segmenets(sentence):\n",
    "    stokens = tokenizer.tokenize(sentence)\n",
    "    stokens = [\"[CLS]\"] + stokens + [\"[SEP]\"]\n",
    "    input_ids = get_ids(stokens, tokenizer, max_seq_length)\n",
    "    input_masks = get_masks(stokens, max_seq_length)\n",
    "    input_segments = get_segments(stokens, max_seq_length)\n",
    "    return input_ids, input_masks, input_segments\n",
    "\n",
    "\n",
    "def build_ids_masks_segments(sentences):\n",
    "    input_ids_ = []\n",
    "    input_masks_ = []\n",
    "    input_segments_ = []\n",
    "    for s in sentences:\n",
    "        input_ids, input_masks, input_segments = get_ids_masks_segmenets(s)\n",
    "        input_ids_.append(input_ids)\n",
    "        input_masks_.append(input_masks)\n",
    "        input_segments_.append(input_segments)\n",
    "    return input_ids_, input_masks_, input_segments_\n",
    "\n",
    "def get_embeddings(sentences):\n",
    "    input_ids, input_masks, input_segments = build_ids_masks_segments(sentences)\n",
    "    pool_embs, all_embs = model.predict([input_ids,input_masks,input_segments])\n",
    "    return all_embs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 256, 768)\n"
     ]
    }
   ],
   "source": [
    "print(get_embeddings([\"hey\", \"yay\"]).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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>label</th>\n",
       "      <th>data</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>ham</td>\n",
       "      <td>Go until jurong point, crazy.. Available only ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>ham</td>\n",
       "      <td>Ok lar... Joking wif u oni...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>spam</td>\n",
       "      <td>Free entry in 2 a wkly comp to win FA Cup fina...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>ham</td>\n",
       "      <td>U dun say so early hor... U c already then say...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>ham</td>\n",
       "      <td>Nah I don't think he goes to usf, he lives aro...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  label                                               data\n",
       "0   ham  Go until jurong point, crazy.. Available only ...\n",
       "1   ham                      Ok lar... Joking wif u oni...\n",
       "2  spam  Free entry in 2 a wkly comp to win FA Cup fina...\n",
       "3   ham  U dun say so early hor... U c already then say...\n",
       "4   ham  Nah I don't think he goes to usf, he lives aro..."
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('./data/SMSSpamCollection', sep='\\t', names=['label', 'data'])\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df['data']\n",
    "X_train = X[0:int(X.shape[0]*.6)]\n",
    "X_val = X[int(X.shape[0]*.6):int(X.shape[0]*.75)]\n",
    "X_test = X[int(X.shape[0]*.75):]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = get_embeddings(X_train.values)\n",
    "X_val = get_embeddings(X_val.values)\n",
    "X_test = get_embeddings(X_test.values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ham     2897\n",
      "spam     446\n",
      "Name: label, dtype: int64\n",
      "ham     717\n",
      "spam    119\n",
      "Name: label, dtype: int64\n",
      "ham     1211\n",
      "spam     182\n",
      "Name: label, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "y = df['label']\n",
    "y_train = y[0:int(y.shape[0]*.6)]\n",
    "y_val = y[int(y.shape[0]*.6):int(y.shape[0]*.75)]\n",
    "y_test = y[int(y.shape[0]*.75):]\n",
    "\n",
    "print(y_train.value_counts())\n",
    "print(y_val.value_counts())\n",
    "print(y_test.value_counts())\n",
    "\n",
    "HAM = 0\n",
    "SPAM = 1\n",
    "\n",
    "y_train = np.array(list(map(lambda x: HAM if x == 'ham' else SPAM, y_train)))\n",
    "y_val = np.array(list(map(lambda x: HAM if x == 'ham' else SPAM, y_val)))\n",
    "y_test = np.array(list(map(lambda x: HAM if x == 'ham' else SPAM, y_test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1393, 256, 768)\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "print(X_test.shape)\n",
    "\n",
    "model = tf.keras.Sequential([\n",
    "    tf.keras.layers.LSTM(256, input_shape=(X_test.shape[1], X_test.shape[2])),\n",
    "    tf.keras.layers.Dense(64, activation='relu'),\n",
    "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
    "])\n",
    "model.compile(loss='binary_crossentropy',\n",
    "              optimizer=tf.keras.optimizers.Adam(2e-5),\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 3343 samples, validate on 836 samples\n",
      "Epoch 1/10\n",
      "3343/3343 [==============================] - 96s 29ms/sample - loss: 0.3519 - accuracy: 0.8687 - val_loss: 0.2256 - val_accuracy: 0.9324\n",
      "Epoch 2/10\n",
      "3343/3343 [==============================] - 99s 30ms/sample - loss: 0.1169 - accuracy: 0.9707 - val_loss: 0.0834 - val_accuracy: 0.9742\n",
      "Epoch 3/10\n",
      "3343/3343 [==============================] - 98s 29ms/sample - loss: 0.0578 - accuracy: 0.9827 - val_loss: 0.0575 - val_accuracy: 0.9839\n",
      "Epoch 4/10\n",
      "3343/3343 [==============================] - 98s 29ms/sample - loss: 0.0428 - accuracy: 0.9886 - val_loss: 0.0517 - val_accuracy: 0.9796\n",
      "Epoch 5/10\n",
      "3343/3343 [==============================] - 95s 28ms/sample - loss: 0.0348 - accuracy: 0.9907 - val_loss: 0.0395 - val_accuracy: 0.9903\n",
      "Epoch 6/10\n",
      "3343/3343 [==============================] - 75s 22ms/sample - loss: 0.0280 - accuracy: 0.9931 - val_loss: 0.0344 - val_accuracy: 0.9893\n",
      "Epoch 7/10\n",
      "3343/3343 [==============================] - 99s 30ms/sample - loss: 0.0277 - accuracy: 0.9916 - val_loss: 0.0313 - val_accuracy: 0.9925\n",
      "Epoch 8/10\n",
      "3343/3343 [==============================] - 98s 29ms/sample - loss: 0.0182 - accuracy: 0.9958 - val_loss: 0.0262 - val_accuracy: 0.9925\n",
      "Epoch 9/10\n",
      "3343/3343 [==============================] - 102s 30ms/sample - loss: 0.0139 - accuracy: 0.9964 - val_loss: 0.0263 - val_accuracy: 0.9936\n",
      "Epoch 10/10\n",
      "3343/3343 [==============================] - 100s 30ms/sample - loss: 0.0117 - accuracy: 0.9976 - val_loss: 0.0230 - val_accuracy: 0.9946\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(x=X_train, y=y_train, epochs=10,\n",
    "                    validation_data=(X_val, y_val),\n",
    "                    shuffle=True,\n",
    "                    validation_steps=30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "training_loss = history.history['loss']\n",
    "test_loss = history.history['val_loss']\n",
    "epoch_count = range(1, len(training_loss) + 1)\n",
    "\n",
    "plt.plot(epoch_count, training_loss, 'r--')\n",
    "plt.plot(epoch_count, test_loss, 'b-')\n",
    "plt.legend(['Training Loss', 'Test Loss'])\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('loss', 0.046336617), ('accuracy', 0.99096775)]\n"
     ]
    }
   ],
   "source": [
    "test_results = model.test_on_batch(\n",
    "    X_test,\n",
    "    y=y_test,\n",
    "    sample_weight=None,\n",
    "    reset_metrics=True\n",
    ")\n",
    "print(list(zip(model.metrics_names, test_results)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = model.predict(X_test).round()\n",
    "y_pred = list(map(lambda x: int(x[0]), y_pred))\n",
    "confusion = tf.math.confusion_matrix(labels=y_test, predictions=y_pred, num_classes=2)\n",
    "confusion = confusion.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False Positive Rate: 0.495%\n"
     ]
    }
   ],
   "source": [
    "fp = confusion[0][1]\n",
    "tn = confusion[0][0]\n",
    "fp_rate = float(fp / (fp+tn))\n",
    "print(f\"False Positive Rate: {round(fp_rate*100,3)}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "df_cm = pd.DataFrame(confusion, index = [\"HAM\", \"SPAM\"],\n",
    "                  columns = [\"HAM\", \"SPAM\"])\n",
    "plt.figure(figsize = (12,8))\n",
    "sns.set(font_scale=1.5)\n",
    "annot_kws = {\"ha\": 'left',\"va\": 'bottom'}\n",
    "hm = sns.heatmap(df_cm, cmap=\"Pastel1\", fmt=\"d\", annot=True, annot_kws=annot_kws)\n",
    "plt.ylabel('True label')\n",
    "plt.xlabel('Predicted label')\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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}