Classify Emotions in text with BERT.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ed78a411-c54a-4faa-8509-faa34fe574c5",
   "metadata": {},
   "source": [
    "# Classify Emotions in text with BERT NLP Model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "865078a8-2498-47b4-8450-f8e829d57402",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Step-1 Install packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ae945046-0b8b-4e79-832b-8260ee4fb17e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keyring is skipped due to an exception: 'keyring.backends'\n",
      "\u001b[33mWARNING: Skipping keras-nightly as it is not installed.\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0mKeyring is skipped due to an exception: 'keyring.backends'\n",
      "\u001b[33mWARNING: Skipping tensorflow as it is not installed.\u001b[0m\u001b[33m\n",
      "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0mKeyring is skipped due to an exception: 'keyring.backends'\n",
      "Collecting keras==2.1.6\n",
      "  Using cached Keras-2.1.6-py2.py3-none-any.whl (339 kB)\n",
      "Requirement already satisfied: h5py in /opt/conda/lib/python3.7/site-packages (from keras==2.1.6) (2.10.0)\n",
      "Requirement already satisfied: six>=1.9.0 in /opt/conda/lib/python3.7/site-packages (from keras==2.1.6) (1.14.0)\n",
      "Requirement already satisfied: pyyaml in /opt/conda/lib/python3.7/site-packages (from keras==2.1.6) (6.0)\n",
      "Requirement already satisfied: numpy>=1.9.1 in /opt/conda/lib/python3.7/site-packages (from keras==2.1.6) (1.21.6)\n",
      "Requirement already satisfied: scipy>=0.14 in /opt/conda/lib/python3.7/site-packages (from keras==2.1.6) (1.4.1)\n",
      "Installing collected packages: keras\n",
      "Successfully installed keras-2.1.6\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0mKeyring is skipped due to an exception: 'keyring.backends'\n",
      "Collecting tensorflow==2.7.0\n",
      "  Using cached tensorflow-2.7.0-cp37-cp37m-manylinux2010_x86_64.whl (489.6 MB)\n",
      "Requirement already satisfied: wheel<1.0,>=0.32.0 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (0.34.2)\n",
      "Collecting tensorboard~=2.6\n",
      "  Using cached tensorboard-2.11.0-py3-none-any.whl (6.0 MB)\n",
      "Requirement already satisfied: protobuf>=3.9.2 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (3.20.3)\n",
      "Collecting absl-py>=0.4.0\n",
      "  Using cached absl_py-1.3.0-py3-none-any.whl (124 kB)\n",
      "Requirement already satisfied: wrapt>=1.11.0 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.11.2)\n",
      "Collecting astunparse>=1.6.0\n",
      "  Using cached astunparse-1.6.3-py2.py3-none-any.whl (12 kB)\n",
      "Collecting tensorflow-io-gcs-filesystem>=0.21.0\n",
      "  Using cached tensorflow_io_gcs_filesystem-0.27.0-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (2.4 MB)\n",
      "Requirement already satisfied: six>=1.12.0 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.14.0)\n",
      "Collecting gast<0.5.0,>=0.2.1\n",
      "  Downloading gast-0.4.0-py3-none-any.whl (9.8 kB)\n",
      "Collecting grpcio<2.0,>=1.24.3\n",
      "  Using cached grpcio-1.50.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.7 MB)\n",
      "Collecting keras-preprocessing>=1.1.1\n",
      "  Using cached Keras_Preprocessing-1.1.2-py2.py3-none-any.whl (42 kB)\n",
      "Requirement already satisfied: h5py>=2.9.0 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (2.10.0)\n",
      "Requirement already satisfied: typing-extensions>=3.6.6 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (4.4.0)\n",
      "Collecting tensorflow-estimator<2.8,~=2.7.0rc0\n",
      "  Using cached tensorflow_estimator-2.7.0-py2.py3-none-any.whl (463 kB)\n",
      "Collecting opt-einsum>=2.3.2\n",
      "  Using cached opt_einsum-3.3.0-py3-none-any.whl (65 kB)\n",
      "Requirement already satisfied: numpy>=1.14.5 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (1.21.6)\n",
      "Collecting flatbuffers<3.0,>=1.12\n",
      "  Using cached flatbuffers-2.0.7-py2.py3-none-any.whl (26 kB)\n",
      "Requirement already satisfied: google-pasta>=0.1.1 in /opt/conda/lib/python3.7/site-packages (from tensorflow==2.7.0) (0.2.0)\n",
      "Collecting libclang>=9.0.1\n",
      "  Using cached libclang-14.0.6-py2.py3-none-manylinux2010_x86_64.whl (14.1 MB)\n",
      "Collecting keras<2.8,>=2.7.0rc0\n",
      "  Using cached keras-2.7.0-py2.py3-none-any.whl (1.3 MB)\n",
      "Collecting termcolor>=1.1.0\n",
      "  Using cached termcolor-2.1.1-py3-none-any.whl (6.2 kB)\n",
      "Collecting google-auth-oauthlib<0.5,>=0.4.1\n",
      "  Using cached google_auth_oauthlib-0.4.6-py2.py3-none-any.whl (18 kB)\n",
      "Requirement already satisfied: requests<3,>=2.21.0 in /opt/conda/lib/python3.7/site-packages (from tensorboard~=2.6->tensorflow==2.7.0) (2.28.1)\n",
      "Collecting markdown>=2.6.8\n",
      "  Using cached Markdown-3.4.1-py3-none-any.whl (93 kB)\n",
      "Collecting google-auth<3,>=1.6.3\n",
      "  Using cached google_auth-2.14.1-py2.py3-none-any.whl (175 kB)\n",
      "Collecting tensorboard-data-server<0.7.0,>=0.6.0\n",
      "  Using cached tensorboard_data_server-0.6.1-py3-none-manylinux2010_x86_64.whl (4.9 MB)\n",
      "Collecting tensorboard-plugin-wit>=1.6.0\n",
      "  Using cached tensorboard_plugin_wit-1.8.1-py3-none-any.whl (781 kB)\n",
      "Requirement already satisfied: setuptools>=41.0.0 in /opt/conda/lib/python3.7/site-packages (from tensorboard~=2.6->tensorflow==2.7.0) (59.3.0)\n",
      "Collecting werkzeug>=1.0.1\n",
      "  Using cached Werkzeug-2.2.2-py3-none-any.whl (232 kB)\n",
      "Collecting cachetools<6.0,>=2.0.0\n",
      "  Using cached cachetools-5.2.0-py3-none-any.whl (9.3 kB)\n",
      "Collecting pyasn1-modules>=0.2.1\n",
      "  Using cached pyasn1_modules-0.2.8-py2.py3-none-any.whl (155 kB)\n",
      "Requirement already satisfied: rsa<5,>=3.1.4 in /opt/conda/lib/python3.7/site-packages (from google-auth<3,>=1.6.3->tensorboard~=2.6->tensorflow==2.7.0) (4.9)\n",
      "Collecting requests-oauthlib>=0.7.0\n",
      "  Using cached requests_oauthlib-1.3.1-py2.py3-none-any.whl (23 kB)\n",
      "Requirement already satisfied: importlib-metadata>=4.4 in /opt/conda/lib/python3.7/site-packages (from markdown>=2.6.8->tensorboard~=2.6->tensorflow==2.7.0) (5.0.0)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard~=2.6->tensorflow==2.7.0) (2.8)\n",
      "Requirement already satisfied: charset-normalizer<3,>=2 in /opt/conda/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard~=2.6->tensorflow==2.7.0) (2.0.4)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard~=2.6->tensorflow==2.7.0) (2022.9.24)\n",
      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/conda/lib/python3.7/site-packages (from requests<3,>=2.21.0->tensorboard~=2.6->tensorflow==2.7.0) (1.26.12)\n",
      "Requirement already satisfied: MarkupSafe>=2.1.1 in /opt/conda/lib/python3.7/site-packages (from werkzeug>=1.0.1->tensorboard~=2.6->tensorflow==2.7.0) (2.1.1)\n",
      "Requirement already satisfied: zipp>=0.5 in /opt/conda/lib/python3.7/site-packages (from importlib-metadata>=4.4->markdown>=2.6.8->tensorboard~=2.6->tensorflow==2.7.0) (3.10.0)\n",
      "Requirement already satisfied: pyasn1<0.5.0,>=0.4.6 in /opt/conda/lib/python3.7/site-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard~=2.6->tensorflow==2.7.0) (0.4.8)\n",
      "Collecting oauthlib>=3.0.0\n",
      "  Using cached oauthlib-3.2.2-py3-none-any.whl (151 kB)\n",
      "Installing collected packages: tensorflow-estimator, tensorboard-plugin-wit, libclang, keras, flatbuffers, werkzeug, termcolor, tensorflow-io-gcs-filesystem, tensorboard-data-server, pyasn1-modules, opt-einsum, oauthlib, keras-preprocessing, grpcio, gast, cachetools, astunparse, absl-py, requests-oauthlib, markdown, google-auth, google-auth-oauthlib, tensorboard, tensorflow\n",
      "  Attempting uninstall: keras\n",
      "    Found existing installation: Keras 2.1.6\n",
      "    Uninstalling Keras-2.1.6:\n",
      "      Successfully uninstalled Keras-2.1.6\n",
      "  Attempting uninstall: werkzeug\n",
      "    Found existing installation: Werkzeug 1.0.0\n",
      "    Uninstalling Werkzeug-1.0.0:\n",
      "      Successfully uninstalled Werkzeug-1.0.0\n",
      "Successfully installed absl-py-1.3.0 astunparse-1.6.3 cachetools-5.2.0 flatbuffers-2.0.7 gast-0.4.0 google-auth-2.14.1 google-auth-oauthlib-0.4.6 grpcio-1.50.0 keras-2.7.0 keras-preprocessing-1.1.2 libclang-14.0.6 markdown-3.4.1 oauthlib-3.2.2 opt-einsum-3.3.0 pyasn1-modules-0.2.8 requests-oauthlib-1.3.1 tensorboard-2.11.0 tensorboard-data-server-0.6.1 tensorboard-plugin-wit-1.8.1 tensorflow-2.7.0 tensorflow-estimator-2.7.0 tensorflow-io-gcs-filesystem-0.27.0 termcolor-2.1.1 werkzeug-2.2.2\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0mKeyring is skipped due to an exception: 'keyring.backends'\n",
      "Requirement already satisfied: h5py==2.10.0 in /opt/conda/lib/python3.7/site-packages (2.10.0)\n",
      "Requirement already satisfied: six in /opt/conda/lib/python3.7/site-packages (from h5py==2.10.0) (1.14.0)\n",
      "Requirement already satisfied: numpy>=1.7 in /opt/conda/lib/python3.7/site-packages (from h5py==2.10.0) (1.21.6)\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pip3 uninstall keras-nightly\n",
    "!pip3 uninstall -y tensorflow\n",
    "!pip3 install keras==2.1.6\n",
    "!pip3 install tensorflow==2.7.0\n",
    "!pip3 install h5py==2.10.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c8110cdf-03ec-4a0c-8c9d-5a9aca759dd8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f1370ebf-b0f4-4e04-9601-5c119c689ebf",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.7.0'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "94a72dfb-b650-4e46-90ed-7337a25ea289",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keyring is skipped due to an exception: 'keyring.backends'\n",
      "Collecting wordcloud\n",
      "  Using cached wordcloud-1.8.2.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (435 kB)\n",
      "Requirement already satisfied: matplotlib in /opt/conda/lib/python3.7/site-packages (from wordcloud) (3.1.3)\n",
      "Requirement already satisfied: pillow in /opt/conda/lib/python3.7/site-packages (from wordcloud) (9.3.0)\n",
      "Requirement already satisfied: numpy>=1.6.1 in /opt/conda/lib/python3.7/site-packages (from wordcloud) (1.21.6)\n",
      "Requirement already satisfied: python-dateutil>=2.1 in /opt/conda/lib/python3.7/site-packages (from matplotlib->wordcloud) (2.8.2)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in /opt/conda/lib/python3.7/site-packages (from matplotlib->wordcloud) (1.1.0)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /opt/conda/lib/python3.7/site-packages (from matplotlib->wordcloud) (2.4.6)\n",
      "Requirement already satisfied: cycler>=0.10 in /opt/conda/lib/python3.7/site-packages (from matplotlib->wordcloud) (0.10.0)\n",
      "Requirement already satisfied: six in /opt/conda/lib/python3.7/site-packages (from cycler>=0.10->matplotlib->wordcloud) (1.14.0)\n",
      "Requirement already satisfied: setuptools in /opt/conda/lib/python3.7/site-packages (from kiwisolver>=1.0.1->matplotlib->wordcloud) (59.3.0)\n",
      "Installing collected packages: wordcloud\n",
      "Successfully installed wordcloud-1.8.2.2\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pip install wordcloud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c9fc76cb-f98e-43e0-80f3-7e5f21b42523",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keyring is skipped due to an exception: 'keyring.backends'\n",
      "Collecting imbalanced-learn\n",
      "  Using cached imbalanced_learn-0.9.1-py3-none-any.whl (199 kB)\n",
      "Requirement already satisfied: scipy>=1.3.2 in /opt/conda/lib/python3.7/site-packages (from imbalanced-learn) (1.4.1)\n",
      "Collecting joblib>=1.0.0\n",
      "  Using cached joblib-1.2.0-py3-none-any.whl (297 kB)\n",
      "Collecting imbalanced-learn\n",
      "  Using cached imbalanced_learn-0.9.0-py3-none-any.whl (199 kB)\n",
      "Requirement already satisfied: joblib>=0.11 in /opt/conda/lib/python3.7/site-packages (from imbalanced-learn) (0.14.1)\n",
      "Collecting scikit-learn>=1.0.1\n",
      "  Using cached scikit_learn-1.0.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (24.8 MB)\n",
      "Collecting threadpoolctl>=2.0.0\n",
      "  Using cached threadpoolctl-3.1.0-py3-none-any.whl (14 kB)\n",
      "Requirement already satisfied: numpy>=1.14.6 in /opt/conda/lib/python3.7/site-packages (from imbalanced-learn) (1.21.6)\n",
      "Installing collected packages: threadpoolctl, scikit-learn, imbalanced-learn\n",
      "  Attempting uninstall: scikit-learn\n",
      "    Found existing installation: scikit-learn 0.22.1\n",
      "    Uninstalling scikit-learn-0.22.1:\n",
      "      Successfully uninstalled scikit-learn-0.22.1\n",
      "Successfully installed imbalanced-learn-0.9.0 scikit-learn-1.0.2 threadpoolctl-3.1.0\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pip install imbalanced-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "040e0602-02d7-4e0e-b512-019a3a333ed9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keyring is skipped due to an exception: 'keyring.backends'\n",
      "Collecting transformers\n",
      "  Using cached transformers-4.24.0-py3-none-any.whl (5.5 MB)\n",
      "Requirement already satisfied: regex!=2019.12.17 in /opt/conda/lib/python3.7/site-packages (from transformers) (2022.10.31)\n",
      "Requirement already satisfied: pyyaml>=5.1 in /opt/conda/lib/python3.7/site-packages (from transformers) (6.0)\n",
      "Requirement already satisfied: filelock in /opt/conda/lib/python3.7/site-packages (from transformers) (3.0.12)\n",
      "Requirement already satisfied: numpy>=1.17 in /opt/conda/lib/python3.7/site-packages (from transformers) (1.21.6)\n",
      "Requirement already satisfied: importlib-metadata in /opt/conda/lib/python3.7/site-packages (from transformers) (5.0.0)\n",
      "Requirement already satisfied: packaging>=20.0 in /opt/conda/lib/python3.7/site-packages (from transformers) (20.1)\n",
      "Collecting tokenizers!=0.11.3,<0.14,>=0.11.1\n",
      "  Using cached tokenizers-0.13.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (7.6 MB)\n",
      "Requirement already satisfied: tqdm>=4.27 in /opt/conda/lib/python3.7/site-packages (from transformers) (4.42.1)\n",
      "Requirement already satisfied: requests in /opt/conda/lib/python3.7/site-packages (from transformers) (2.28.1)\n",
      "Collecting huggingface-hub<1.0,>=0.10.0\n",
      "  Using cached huggingface_hub-0.11.0-py3-none-any.whl (182 kB)\n",
      "Collecting packaging>=20.0\n",
      "  Using cached packaging-21.3-py3-none-any.whl (40 kB)\n",
      "Requirement already satisfied: typing-extensions>=3.7.4.3 in /opt/conda/lib/python3.7/site-packages (from huggingface-hub<1.0,>=0.10.0->transformers) (4.4.0)\n",
      "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /opt/conda/lib/python3.7/site-packages (from packaging>=20.0->transformers) (2.4.6)\n",
      "Requirement already satisfied: zipp>=0.5 in /opt/conda/lib/python3.7/site-packages (from importlib-metadata->transformers) (3.10.0)\n",
      "Requirement already satisfied: charset-normalizer<3,>=2 in /opt/conda/lib/python3.7/site-packages (from requests->transformers) (2.0.4)\n",
      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /opt/conda/lib/python3.7/site-packages (from requests->transformers) (1.26.12)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /opt/conda/lib/python3.7/site-packages (from requests->transformers) (2.8)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /opt/conda/lib/python3.7/site-packages (from requests->transformers) (2022.9.24)\n",
      "Installing collected packages: tokenizers, packaging, huggingface-hub, transformers\n",
      "  Attempting uninstall: packaging\n",
      "    Found existing installation: packaging 20.1\n",
      "    Uninstalling packaging-20.1:\n",
      "      Successfully uninstalled packaging-20.1\n",
      "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
      "pytest-astropy 0.8.0 requires pytest-cov>=2.0, which is not installed.\n",
      "pytest-astropy 0.8.0 requires pytest-filter-subpackage>=0.1, which is not installed.\n",
      "sagemaker 2.116.0 requires importlib-metadata<5.0,>=1.4.0, but you have importlib-metadata 5.0.0 which is incompatible.\n",
      "docker-compose 1.29.2 requires PyYAML<6,>=3.10, but you have pyyaml 6.0 which is incompatible.\u001b[0m\u001b[31m\n",
      "\u001b[0mSuccessfully installed huggingface-hub-0.11.0 packaging-21.3 tokenizers-0.13.2 transformers-4.24.0\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "!pip install transformers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54ebdc34-fe83-4057-9435-6c0a4b6ef4a8",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Import Required Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c151b77b-8856-471f-8c54-12e789f92ba7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Keyring is skipped due to an exception: 'keyring.backends'\n",
      "Collecting contractions\n",
      "  Using cached contractions-0.1.73-py2.py3-none-any.whl (8.7 kB)\n",
      "Collecting textsearch>=0.0.21\n",
      "  Using cached textsearch-0.0.24-py2.py3-none-any.whl (7.6 kB)\n",
      "Collecting anyascii\n",
      "  Using cached anyascii-0.3.1-py3-none-any.whl (287 kB)\n",
      "Collecting pyahocorasick\n",
      "  Using cached pyahocorasick-1.4.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (106 kB)\n",
      "Installing collected packages: pyahocorasick, anyascii, textsearch, contractions\n",
      "Successfully installed anyascii-0.3.1 contractions-0.1.73 pyahocorasick-1.4.4 textsearch-0.0.24\n",
      "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
      "\u001b[0m"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import nltk\n",
    "nltk.download('stopwords')\n",
    "nltk.download('wordnet')\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "!pip install contractions\n",
    "import contractions\n",
    "import re\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from wordcloud import WordCloud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "79495e70-e15e-4135-a064-2e35109e531c",
   "metadata": {
    "tags": []
   },
   "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>text</th>\n",
       "      <th>emotion</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>i didnt feel humiliated</td>\n",
       "      <td>sadness</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>i can go from feeling so hopeless to so damned...</td>\n",
       "      <td>sadness</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>im grabbing a minute to post i feel greedy wrong</td>\n",
       "      <td>anger</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>i am ever feeling nostalgic about the fireplac...</td>\n",
       "      <td>love</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>i am feeling grouchy</td>\n",
       "      <td>anger</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                text  emotion\n",
       "0                            i didnt feel humiliated  sadness\n",
       "1  i can go from feeling so hopeless to so damned...  sadness\n",
       "2   im grabbing a minute to post i feel greedy wrong    anger\n",
       "3  i am ever feeling nostalgic about the fireplac...     love\n",
       "4                               i am feeling grouchy    anger"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data = pd.read_csv('emotions-dataset-for-nlp/train.txt', names=['text', 'emotion'], sep=';')\n",
    "val_data = pd.read_csv('emotions-dataset-for-nlp/val.txt', names=['text', 'emotion'], sep=';')\n",
    "test_data = pd.read_csv('emotions-dataset-for-nlp/test.txt', names=['text', 'emotion'], sep=';')\n",
    "train_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c2c200b3-b144-448c-8d30-a526b2c6f87a",
   "metadata": {
    "tags": []
   },
   "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>text</th>\n",
       "      <th>emotion</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>i didnt feel humiliated</td>\n",
       "      <td>sadness</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>i can go from feeling so hopeless to so damned...</td>\n",
       "      <td>sadness</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>im grabbing a minute to post i feel greedy wrong</td>\n",
       "      <td>anger</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>i am ever feeling nostalgic about the fireplac...</td>\n",
       "      <td>love</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>i am feeling grouchy</td>\n",
       "      <td>anger</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                text  emotion\n",
       "0                            i didnt feel humiliated  sadness\n",
       "1  i can go from feeling so hopeless to so damned...  sadness\n",
       "2   im grabbing a minute to post i feel greedy wrong    anger\n",
       "3  i am ever feeling nostalgic about the fireplac...     love\n",
       "4                               i am feeling grouchy    anger"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff8da2e6-4c40-4444-bcab-cad54b929121",
   "metadata": {},
   "source": [
    "### Data preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fa626acd-90ec-40c6-9d75-fb5f07f079b3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Data\n",
      "text       0\n",
      "emotion    0\n",
      "dtype: int64\n",
      "********************\n",
      "Validation Data\n",
      "text       0\n",
      "emotion    0\n",
      "dtype: int64\n",
      "********************\n",
      "Test Data\n",
      "text       0\n",
      "emotion    0\n",
      "dtype: int64\n",
      "********************\n"
     ]
    }
   ],
   "source": [
    "data = {'Train Data': train_data, 'Validation Data': val_data, 'Test Data': test_data}\n",
    "for temp in data:\n",
    "    print(temp)\n",
    "    print(data[temp].isnull().sum())\n",
    "    print('*'*20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "909d9e25-b30d-4079-b3e1-c50c8ce7eedf",
   "metadata": {
    "tags": []
   },
   "source": [
    "Class Distribution in Train, val and test dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7febd5c1-d133-4246-8a13-72633e5a56ef",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 3000x1000 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bar, ax = plt.subplots(1,3, figsize=(30, 10))\n",
    "for index, temp in enumerate(data):\n",
    "    sns.countplot(ax = ax[index],x = 'emotion', data = data[temp])\n",
    "    ax[index].set_title(temp+' Class Frequency', size=14)\n",
    "    ax[index].set_ylabel('Frequency', size=14)\n",
    "    ax[index].set_xlabel(temp+' Class', size=14)\n",
    "    \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8811d3d-729a-45b3-9419-6ef9ef5e774f",
   "metadata": {},
   "source": [
    "Word Cloud to get most frequent words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6e9b6770-0cd0-4ccc-a26a-e63fa85dc622",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def plot_cloud(wordcloud, temp):\n",
    "    plt.figure(figsize=(10, 10))\n",
    "    plt.title(temp+' Word Cloud', size = 16)\n",
    "    plt.imshow(wordcloud) \n",
    "    # No axis details\n",
    "    plt.axis(\"off\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e7740822-202a-46c7-ba51-fc12a5bed269",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for temp in data:\n",
    "    temp_text = ' '.join([sentence for sentence in data[temp].text])\n",
    "    wordcloud = WordCloud(width = 600, height = 600).generate(temp_text)\n",
    "    plot_cloud(wordcloud, temp)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3672a58-2f66-42e8-a4ee-9e2da900b081",
   "metadata": {},
   "source": [
    "## Data Processing, Label Creation and Seentence Listing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "a9c03b7b-f96b-440d-9fe5-50ad3e1484f2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def preprocess(sentence):\n",
    "    stop_words = set(stopwords.words('english'))\n",
    "    lemmatizer = WordNetLemmatizer()\n",
    "    sentence = re.sub('[^A-z]', ' ', sentence)\n",
    "    negative = ['not', 'neither', 'nor', 'but', 'however', 'although', 'nonetheless', 'despite', 'except',\n",
    "                        'even though', 'yet']\n",
    "    stop_words = [z for z in stop_words if z not in negative]\n",
    "    preprocessed_tokens = [lemmatizer.lemmatize(contractions.fix(temp.lower())) for temp in sentence.split() if temp not in stop_words] #lemmatization\n",
    "    return ' '.join([x for x in preprocessed_tokens]).strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0cdb7e7d-43c1-4d98-9a83-6f843c0548c6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package omw-1.4 to /root/nltk_data...\n",
      "[nltk_data]   Package omw-1.4 is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download('omw-1.4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9b4da889-8f5f-4e17-b7d1-7d3b309d8447",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "train_data['text'] = train_data['text'].apply(lambda x: preprocess(x))\n",
    "val_data['text'] = val_data['text'].apply(lambda x: preprocess(x))\n",
    "test_data['text'] = test_data['text'].apply(lambda x: preprocess(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b39cf02-1356-4b4a-b8dc-10d5289fc722",
   "metadata": {},
   "source": [
    "Note: As class imbalanced is evident, RandomOverSampler is used to add data(repetition) to all classes except highest frequency class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "66380c8e-8556-41eb-839b-fdf683fd5bae",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from imblearn.over_sampling import RandomOverSampler\n",
    "ros = RandomOverSampler(random_state=0)\n",
    "train_x, train_y = ros.fit_resample(np.array(train_data['text']).reshape(-1, 1), np.array(train_data['emotion']).reshape(-1, 1))\n",
    "train = pd.DataFrame(list(zip([x[0] for x in train_x], train_y)), columns = ['text', 'emotion'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39359d65-bf42-4141-b703-524ed6d725d5",
   "metadata": {},
   "source": [
    "Applying OneHotEncoder on target of all dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4d6f1ae8-59b0-4e9f-a5dd-4fa82956ee79",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sklearn import preprocessing\n",
    "le = preprocessing.OneHotEncoder()\n",
    "y_train= le.fit_transform(np.array(train['emotion']).reshape(-1, 1)).toarray()\n",
    "y_test= le.fit_transform(np.array(test_data['emotion']).reshape(-1, 1)).toarray()\n",
    "y_val= le.fit_transform(np.array(val_data['emotion']).reshape(-1, 1)).toarray()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84edd7cc-bf06-4487-9ce6-bcea4d72a431",
   "metadata": {},
   "source": [
    "## Encoding"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76a46726-236b-4a7f-8b00-ba3d67f20d79",
   "metadata": {},
   "source": [
    "There is a very helpful function called encode_plus provided in the Tokenizer class. It can seamlessly perform the following operations:\n",
    "\n",
    "* Tokenize the text and Add special tokens - [CLS] and [SEP]\n",
    "* create input IDs\n",
    "* Pad the sentences to a maximum length\n",
    "* Create attention masks for the above PAD tokens\n",
    "\n",
    "**Note**: RoBERTa uses byte-level Byte-Pair Encoding (BPE) in contrast to BERT’s character-level BPE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d29a4518-0d3f-4838-aaf2-22f53064b344",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from transformers import RobertaTokenizerFast\n",
    "tokenizer = RobertaTokenizerFast.from_pretrained(\"roberta-base\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "28d212dd-b056-4e93-8b8f-0ac1f3d63343",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def roberta_encode(data,maximum_length) :\n",
    "  input_ids = []\n",
    "  attention_masks = []\n",
    "  \n",
    "\n",
    "  for i in range(len(data.text)):\n",
    "      encoded = tokenizer.encode_plus(\n",
    "        \n",
    "        data.text[i],\n",
    "        add_special_tokens=True,\n",
    "        max_length=maximum_length,\n",
    "        pad_to_max_length=True,\n",
    "        \n",
    "        return_attention_mask=True,\n",
    "        \n",
    "      )\n",
    "      \n",
    "      input_ids.append(encoded['input_ids'])\n",
    "      attention_masks.append(encoded['attention_mask'])\n",
    "  return np.array(input_ids),np.array(attention_masks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "8b308861-f311-4e38-b325-c645e19f0231",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Truncation was not explicitly activated but `max_length` is provided a specific value, please use `truncation=True` to explicitly truncate examples to max length. Defaulting to 'longest_first' truncation strategy. If you encode pairs of sequences (GLUE-style) with the tokenizer you can select this strategy more precisely by providing a specific strategy to `truncation`.\n",
      "/opt/conda/lib/python3.7/site-packages/transformers/tokenization_utils_base.py:2310: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
      "  FutureWarning,\n"
     ]
    }
   ],
   "source": [
    "max_len = max([len(x.split()) for x in train_data['text']])\n",
    "train_input_ids,train_attention_masks = roberta_encode(train, max_len)\n",
    "test_input_ids,test_attention_masks = roberta_encode(test_data, max_len)\n",
    "val_input_ids,val_attention_masks = roberta_encode(val_data, max_len)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da833627-f270-4553-af26-c629d11ef6c4",
   "metadata": {},
   "source": [
    "## Create Model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cac5b941-6d14-449b-9486-a08a1e702363",
   "metadata": {},
   "source": [
    "**How RoBERTa is better than BERT ??**\n",
    "\n",
    "Changes in Pre-Training:\n",
    "* without NSP objective\n",
    "* with dynamic mask generation\n",
    "\n",
    "Changes in Data:\n",
    "* Trained on more data (16GB BERT vs 160GB RoBERTa)\n",
    "* Trained on large batches\n",
    "Note: Pre-requistics is to go through BERT\n",
    "\n",
    "References:\n",
    "* Bert: https://arxiv.org/pdf/1810.04805.pdf\n",
    "* The Illustrated BERT, ELMo, and co. (How NLP Cracked Transfer Learning): http://jalammar.github.io/illustrated-bert/\n",
    "* The Illustrated Transformer: https://jalammar.github.io/illustrated-transformer/\n",
    "* Attention Is All You Need: https://arxiv.org/pdf/1706.03762.pdf\n",
    "* Query,key,value vector: https://stats.stackexchange.com/questions/421935/what-exactly-are-keys-queries-and-values-in-attention-mechanisms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "51a0c61c-1de4-428b-8f8e-da9abac849a4",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def create_model(bert_model, max_len):\n",
    "    input_ids = tf.keras.Input(shape=(max_len,),dtype='int32')\n",
    "    attention_masks = tf.keras.Input(shape=(max_len,),dtype='int32')\n",
    "\n",
    "    output = bert_model([input_ids,attention_masks])\n",
    "    output = output[1]\n",
    "\n",
    "    output = tf.keras.layers.Dense(6, activation='softmax')(output)\n",
    "    model = tf.keras.models.Model(inputs = [input_ids,attention_masks],outputs = output)\n",
    "    model.compile(Adam(lr=1e-5), loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "e951d500-ad48-49d0-9123-43be0b44b9e5",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Some layers from the model checkpoint at roberta-base were not used when initializing TFRobertaModel: ['lm_head']\n",
      "- This IS expected if you are initializing TFRobertaModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n",
      "- This IS NOT expected if you are initializing TFRobertaModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n",
      "All the layers of TFRobertaModel were initialized from the model checkpoint at roberta-base.\n",
      "If your task is similar to the task the model of the checkpoint was trained on, you can already use TFRobertaModel for predictions without further training.\n"
     ]
    }
   ],
   "source": [
    "from transformers import TFRobertaModel\n",
    "roberta_model = TFRobertaModel.from_pretrained('roberta-base')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "54beb7d8-c695-4611-a28f-812c68f8ef47",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)           [(None, 43)]         0           []                               \n",
      "                                                                                                  \n",
      " input_2 (InputLayer)           [(None, 43)]         0           []                               \n",
      "                                                                                                  \n",
      " tf_roberta_model (TFRobertaMod  TFBaseModelOutputWi  124645632  ['input_1[0][0]',                \n",
      " el)                            thPoolingAndCrossAt               'input_2[0][0]']                \n",
      "                                tentions(last_hidde                                               \n",
      "                                n_state=(None, 43,                                                \n",
      "                                768),                                                             \n",
      "                                 pooler_output=(Non                                               \n",
      "                                e, 768),                                                          \n",
      "                                 past_key_values=No                                               \n",
      "                                ne, hidden_states=N                                               \n",
      "                                one, attentions=Non                                               \n",
      "                                e, cross_attentions                                               \n",
      "                                =None)                                                            \n",
      "                                                                                                  \n",
      " dense (Dense)                  (None, 6)            4614        ['tf_roberta_model[0][1]']       \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 124,650,246\n",
      "Trainable params: 124,650,246\n",
      "Non-trainable params: 0\n",
      "__________________________________________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/keras/optimizer_v2/adam.py:105: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
      "  super(Adam, self).__init__(name, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "model = create_model(roberta_model, max_len)\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a0445c3-e6a8-443f-adf7-9c80afe39fb5",
   "metadata": {},
   "source": [
    "## Model Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2d7289d-8431-47ad-a5ae-aba57453f537",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/4\n",
      " 19/322 [>.............................] - ETA: 1:03:22 - loss: 1.8033 - accuracy: 0.1626"
     ]
    }
   ],
   "source": [
    "history = model.fit([train_input_ids,train_attention_masks], y_train, validation_data=([val_input_ids,val_attention_masks], y_val), epochs=4,batch_size=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d8c4e26-d706-438b-b06d-a56ea567994f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "instance_type": "ml.m5.xlarge",
  "kernelspec": {
   "display_name": "Python 3 (Data Science)",
   "language": "python",
   "name": "python3__SAGEMAKER_INTERNAL__arn:aws:sagemaker:us-east-1:081325390199:image/datascience-1.0"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}