model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !conda install -n sentiment ipykernel --update-deps --force-reinstall\n",
    "# run above command if using python3.8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow_text as text  # Registers the ops.\n",
    "import keras\n",
    "import tensorflow_hub as hub\n",
    "import tensorflow_datasets as tfds\n",
    "from tensorflow_addons.optimizers import AdamW\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "\n",
    "print(os.getenv('LD_LIBRARY_PATH'))\n",
    "print(tf.config.list_physical_devices('GPU'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "logger = tf.get_logger()\n",
    "logger.setLevel(logging.ERROR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load dataset from TensorFlow Hub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "(training_set, validation_set), dataset_info = tfds.load(\n",
    "    'sentiment140',\n",
    "    split=['train[:30%]', 'train[30%:32%]'],\n",
    "    with_info=True,\n",
    "    as_supervised=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "480000\n"
     ]
    }
   ],
   "source": [
    "num_training_examples = 0\n",
    "for example in training_set:\n",
    "  num_training_examples += 1\n",
    "\n",
    "print(num_training_examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32000\n"
     ]
    }
   ],
   "source": [
    "val_training_examples = 0\n",
    "for example in validation_set:\n",
    "    val_training_examples += 1\n",
    "\n",
    "print(val_training_examples)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert isinstance(training_set, tf.data.Dataset)\n",
    "assert isinstance(validation_set, tf.data.Dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert tfds to a pandas dataframe to manipulate it\n",
    "\n",
    "df_train_set = tfds.as_dataframe(training_set, dataset_info)\n",
    "df_validation_set = tfds.as_dataframe(validation_set, dataset_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([], dtype=int64), array([], dtype=int64))"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train_set.dropna()\n",
    "df_train_set = df_train_set.replace(4,1) # represent positives as a 1 instead of a 4\n",
    "\n",
    "df_validation_set.dropna()\n",
    "df_validation_set = df_validation_set.replace(4,1)\n",
    "\n",
    "# verify that there are no more 4s\n",
    "np.where(df_train_set.to_numpy() == 4)\n",
    "np.where(df_validation_set.to_numpy() == 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tensorflow.python.data.ops.dataset_ops.TensorSliceDataset'>\n",
      "(b\"i'm 10x cooler than all of you! \", 1)\n"
     ]
    }
   ],
   "source": [
    "# just checkout out some elements\n",
    "df_train_set.iat[3,0]\n",
    "type(df_train_set.iat[1,0])\n",
    "\n",
    "# get input and target outputs from dataframe to cast into tf dataset\n",
    "target = df_train_set['polarity']\n",
    "text = df_train_set['text']\n",
    "dt = tf.data.Dataset.from_tensor_slices((text, target))\n",
    "print(type(dt))\n",
    "print(dt.take(1).as_numpy_iterator().next())\n",
    "training_set = dt.prefetch(1)\n",
    "\n",
    "# validation here\n",
    "val_target = df_validation_set['polarity']\n",
    "val_text = df_validation_set['text']\n",
    "val_dt = tf.data.Dataset.from_tensor_slices((val_text, val_target))\n",
    "validation_set = val_dt.prefetch(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 b\"i'm 10x cooler than all of you! \"\n",
      "0 b'O.kk? Thats weird I cant stop following people on twitter... I have tons of people to unfollow '\n",
      "1 b'what a beautiful day not to got to my first class '\n",
      "1 b\".@HildyGottlieb &amp; I was just saying to Maha'al yesterday, everything we ever needed to know was in Beatles' lyrics - you prove my point! \"\n",
      "0 b'kinda sad and confused  why do guys do this?'\n"
     ]
    }
   ],
   "source": [
    "for text, labels in training_set.take(5):  # only take first element of dataset\n",
    "    numpy_text = text.numpy()\n",
    "    numpy_labels = labels.numpy()\n",
    "    print(numpy_labels, numpy_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training and validation sets after manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 32\n",
    "\n",
    "train_batches = training_set.shuffle(num_training_examples//4).batch(BATCH_SIZE).prefetch(1)\n",
    "train_val = validation_set.batch(BATCH_SIZE).prefetch(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load preprocesor for the albert model and the model itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Create a Feature Extractor\n",
    "# First do some preprocessing on the input raw data to tokenize and create embeddings with the sequences\n",
    "\n",
    "URL_PREPROCESSOR = \"http://tfhub.dev/tensorflow/albert_en_preprocess/3\"\n",
    "preprocessor = hub.KerasLayer(URL_PREPROCESSOR, name='preprocessing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keys       : ['input_mask', 'input_type_ids', 'input_word_ids']\n",
      "Shape      : (1, 128)\n",
      "Word Ids   : [   2   48   25  145   40 5289 1308  187    3    0    0    0]\n",
      "Input Mask : [1 1 1 1 1 1 1 1 1 0 0 0]\n",
      "Type Ids   : [0 0 0 0 0 0 0 0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "text_test = ['this is such an amazing movie!']\n",
    "text_preprocessed = preprocessor(text_test)\n",
    "\n",
    "print(f'Keys       : {list(text_preprocessed.keys())}')\n",
    "print(f'Shape      : {text_preprocessed[\"input_word_ids\"].shape}')\n",
    "print(f'Word Ids   : {text_preprocessed[\"input_word_ids\"][0, :12]}')\n",
    "print(f'Input Mask : {text_preprocessed[\"input_mask\"][0, :12]}')\n",
    "print(f'Type Ids   : {text_preprocessed[\"input_type_ids\"][0, :12]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pooled Outputs Shape:(1, 768)\n",
      "Pooled Outputs Values:[ 0.56420034 -0.583381    0.8920307  -0.88340575 -0.5900779  -0.9748928\n",
      "  0.59733653 -0.56507444  0.6582606  -0.99990517  0.92246985  0.5789059 ]\n",
      "Sequence Outputs Shape:(1, 128, 768)\n",
      "Sequence Outputs Values:[[ 0.93791425  0.2850878  -0.3770112  ...  0.1940784  -1.122175\n",
      "   0.502108  ]\n",
      " [ 1.6732271  -1.2593404   0.98551434 ... -0.03488392  2.4402459\n",
      "  -1.415178  ]\n",
      " [ 1.5726161  -0.72766566 -0.6132505  ...  1.136941   -0.24407187\n",
      "  -0.20239015]\n",
      " ...\n",
      " [ 0.4637535   0.78065205 -0.00772761 ...  0.36924595  0.9916418\n",
      "  -1.1032659 ]\n",
      " [ 0.44642836  0.8588993   0.02044564 ...  0.40769723  1.0863211\n",
      "  -1.0217946 ]\n",
      " [ 0.46782282  0.8818836   0.02625225 ...  0.44045782  1.1098733\n",
      "  -1.016713  ]]\n"
     ]
    }
   ],
   "source": [
    "# let's look at the outputs from albert model\n",
    "\n",
    "URL = \"https://tfhub.dev/tensorflow/albert_en_base/3\"\n",
    "albert_model = hub.KerasLayer(URL, trainable=False)\n",
    "albert_results = albert_model(text_preprocessed)\n",
    "print(f'Pooled Outputs Shape:{albert_results[\"pooled_output\"].shape}')\n",
    "print(f'Pooled Outputs Values:{albert_results[\"pooled_output\"][0, :12]}')\n",
    "print(f'Sequence Outputs Shape:{albert_results[\"sequence_output\"].shape}')\n",
    "print(f'Sequence Outputs Values:{albert_results[\"sequence_output\"][0, :12]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"albert_model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " text (InputLayer)              [(None,)]            0           []                               \n",
      "                                                                                                  \n",
      " preprocessing (KerasLayer)     {'input_mask': (Non  0           ['text[0][0]']                   \n",
      "                                e, 128),                                                          \n",
      "                                 'input_type_ids':                                                \n",
      "                                (None, 128),                                                      \n",
      "                                 'input_word_ids':                                                \n",
      "                                (None, 128)}                                                      \n",
      "                                                                                                  \n",
      " ALBERT_encoder (KerasLayer)    {'encoder_outputs':  11683584    ['preprocessing[0][0]',          \n",
      "                                 [(None, 128, 768),               'preprocessing[0][1]',          \n",
      "                                 (None, 128, 768),                'preprocessing[0][2]']          \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 (None, 128, 768)],                                               \n",
      "                                 'default': (None,                                                \n",
      "                                768),                                                             \n",
      "                                 'sequence_output':                                               \n",
      "                                 (None, 128, 768),                                                \n",
      "                                 'pooled_output': (                                               \n",
      "                                None, 768)}                                                       \n",
      "                                                                                                  \n",
      " classifier (Dense)             (None, 1)            769         ['ALBERT_encoder[0][13]']        \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 11,684,353\n",
      "Trainable params: 769\n",
      "Non-trainable params: 11,683,584\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "def build_classifier_model():\n",
    "    text_input = tf.keras.layers.Input(shape=(), dtype=tf.string, name='text')\n",
    "    encoder_inputs = preprocessor(text_input)\n",
    "    encoder = hub.KerasLayer(URL, trainable=False, name='ALBERT_encoder')\n",
    "    outputs = encoder(encoder_inputs)\n",
    "    net = outputs['pooled_output']\n",
    "    dropout_layer = tf.keras.layers.Dropout(0.1, name='dropout')\n",
    "    # net = dropout_layer(net)\n",
    "    net = tf.keras.layers.Dense(1, activation=None, name='classifier')(net)\n",
    "    return tf.keras.Model(inputs=text_input, outputs=net, name='albert_model')\n",
    "\n",
    "build_classifier_model().summary()\n",
    "# pooled_output = outputs[\"pooled_output\"]      # [batch_size, 768].\n",
    "# sequence_output = outputs[\"sequence_output\"]  # [batch_size, seq_length, 768].\n",
    "# print(pooled_output)\n",
    "# print(sequence_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([[0.80214405]], shape=(1, 1), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "model = build_classifier_model()\n",
    "albert_raw_result = model(tf.constant(text_test))\n",
    "print(tf.sigmoid(albert_raw_result))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "step = tf.Variable(0, trainable=False)\n",
    "schedule = tf.optimizers.schedules.PiecewiseConstantDecay(\n",
    "    [10000, 15000], [1e-1, 1e-2, 1e-3])\n",
    "# lr and wd can be a function or a tensor\n",
    "lr = 1e-3 * schedule(step)\n",
    "wd = lambda: 1e-4 * schedule(step)\n",
    "\n",
    "optimizer = AdamW(learning_rate=lr, weight_decay=wd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.config.list_physical_devices('GPU')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/6\n",
      "15000/15000 [==============================] - 3529s 235ms/step - loss: 0.6275 - binary_accuracy: 0.5943 - val_loss: 0.6081 - val_binary_accuracy: 0.6009\n",
      "Epoch 2/6\n",
      "15000/15000 [==============================] - 3461s 231ms/step - loss: 0.5972 - binary_accuracy: 0.6375 - val_loss: 0.5908 - val_binary_accuracy: 0.6333\n",
      "Epoch 3/6\n",
      "15000/15000 [==============================] - 3326s 222ms/step - loss: 0.5873 - binary_accuracy: 0.6502 - val_loss: 0.5833 - val_binary_accuracy: 0.6586\n",
      "Epoch 4/6\n",
      "15000/15000 [==============================] - 3321s 221ms/step - loss: 0.5822 - binary_accuracy: 0.6566 - val_loss: 0.5795 - val_binary_accuracy: 0.6672\n",
      "Epoch 5/6\n",
      "15000/15000 [==============================] - 3246s 216ms/step - loss: 0.5788 - binary_accuracy: 0.6605 - val_loss: 0.5794 - val_binary_accuracy: 0.6817\n",
      "Epoch 6/6\n",
      "15000/15000 [==============================] - 3319s 221ms/step - loss: 0.5767 - binary_accuracy: 0.6632 - val_loss: 0.5752 - val_binary_accuracy: 0.6720\n"
     ]
    }
   ],
   "source": [
    "epochs=6\n",
    "init_lr = 5e-2\n",
    "lr_schedule = tf.keras.callbacks.LearningRateScheduler(\n",
    "    lambda epoch: init_lr * 10**(epoch / 2))\n",
    "# optimizer = tf.keras.optimizers.Adam(lr=init_lr)\n",
    "metrics = tf.metrics.BinaryAccuracy()\n",
    "\n",
    "model_checkpoint = tf.keras.callbacks.ModelCheckpoint(\n",
    "    \"sentiment_model_v1.h5\", save_best_only=True, save_weights_only=True)\n",
    "\n",
    "early_stopping = tf.keras.callbacks.EarlyStopping(patience=2)\n",
    "\n",
    "\n",
    "model.compile(\n",
    "    optimizer = optimizer,\n",
    "    loss = tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
    "    metrics = metrics)\n",
    "\n",
    "\n",
    "history = model.fit(train_batches, validation_data=train_val, epochs=epochs, \n",
    "        callbacks=[model_checkpoint, early_stopping])\n",
    "\n",
    "# model.save(\"sentiment_model_v1.h5\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'binary_accuracy', 'val_loss', 'val_binary_accuracy'])\n"
     ]
    }
   ],
   "source": [
    "print(history.history.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot Training and Validation Graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "acc = history.history['binary_accuracy']\n",
    "val_acc = history.history['val_binary_accuracy']\n",
    "\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "\n",
    "epochs_range = range(epochs)\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(epochs_range, acc, label='Training Accuracy')\n",
    "plt.plot(epochs_range, val_acc, label='Validation Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(epochs_range, loss, label='Training Loss')\n",
    "plt.plot(epochs_range, val_loss, label='Validation Loss')\n",
    "plt.legend(loc='upper right')\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 ('mlops-dev')",
   "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.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "491432b71267407106fe202c40c842fdd5910eb46324614520b83b7fa9472d1b"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}