05_Fasttext_Hierarchical_RNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TUZxuDpO0WUi"
   },
   "outputs": [],
   "source": [
    "!pip install nltk>=3.0 numpy==1.21.6 matplotlib torch fasttext scikit-learn~=0.24.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "a1bj5Quj0zde"
   },
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "gNIW3ki_07Ix"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/e.trufanova/.pyenv/versions/3.8.6/lib/python3.8/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import fasttext\n",
    "import torch\n",
    "import torch.optim as optim\n",
    "from torch.nn.utils.rnn import pad_sequence\n",
    "from torch.utils.data import DataLoader\n",
    "from tqdm import tqdm\n",
    "\n",
    "import sys\n",
    "sys.path.append('DialogueActClassification')\n",
    "\n",
    "from dialogue_classification.dataset_utils import load_swda_corpus_data\n",
    "from dialogue_classification.dataset import FasttextDataset\n",
    "from dialogue_classification.models import DialogueNetFasttext\n",
    "from dialogue_classification.train_test_split import train_set_idx, valid_set_idx, test_set_idx\n",
    "from dialogue_classification.training import train_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "j_9mFuuc23oY"
   },
   "outputs": [],
   "source": [
    "!wget https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.en.300.bin.gz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "0mVvHYJp2479"
   },
   "outputs": [],
   "source": [
    "!gzip -dk cc.en.300.bin.gz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E6SrBAMs1o7a"
   },
   "source": [
    "## Prepare data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hbuKg3Qm1chv",
    "outputId": "446eae9c-841c-4265-ceec-95dbb118c146"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading SwDA Corpus...\n",
      "\n",
      "Found 43 different utterance tags.\n",
      "\n",
      "Loaded SwDA Corpus.\n"
     ]
    }
   ],
   "source": [
    "talks, talk_names, tag_indices, tag_occurances = load_swda_corpus_data('swda/swda/swda')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "lc6bTubM1mw-",
    "outputId": "4ba01153-bcc0-49f9-81dd-ce2dbe2d517a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1155, 43)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(talks), len(tag_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "kOpRJxOt2_9v"
   },
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def preprocess(text):\n",
    "    text = text.lower()\n",
    "    text = re.sub(\"[,']+\", '', text)\n",
    "    text = re.sub('\\.', ' . ', text)\n",
    "    text = re.sub('\\?', ' ? ', text)\n",
    "    text = re.sub('!', ' ! ', text)\n",
    "    text = re.sub('\\s+', ' ', text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "S0Z-vN201qog"
   },
   "outputs": [],
   "source": [
    "texts, labels = [], []\n",
    "for text, label in talks:\n",
    "    assert len(text) == len(label)\n",
    "    text = [' '.join(utterance) for utterance in text]\n",
    "    texts.append(text)\n",
    "    labels.append(label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "id": "8oBi3tge3C6S"
   },
   "outputs": [],
   "source": [
    "texts = [[preprocess(utt) for utt in text] for text in texts]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 610
    },
    "id": "p8ai7FTJ1zfh",
    "outputId": "94c125d4-1672-4cc2-c229-502f1fb8a5e3"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "count    221616.000000\n",
       "mean          7.634850\n",
       "std           6.896954\n",
       "min           0.000000\n",
       "25%           2.000000\n",
       "50%           6.000000\n",
       "75%          10.000000\n",
       "max          80.000000\n",
       "dtype: float64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "utterance_lens = [len(utterance.split()) for utterance in sum(texts, [])]\n",
    "utterance_lens = pd.Series(utterance_lens)\n",
    "\n",
    "sns.histplot(utterance_lens, binwidth=1)\n",
    "plt.vlines(utterance_lens.quantile(0.97), 0, 50_000, color='red', label='p97')\n",
    "plt.xlabel(\"Utterance length (# of words)\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "utterance_lens.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "17_MNNNw2fmI",
    "outputId": "ca652447-8b56-40cc-e452-c01089e82270"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "utterance_lens.quantile(0.97) # => max_length = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "dYSHNgFR4H3j"
   },
   "outputs": [],
   "source": [
    "max_length = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "nv523VRq3F-E"
   },
   "outputs": [],
   "source": [
    "train_idx = np.isin(talk_names, train_set_idx)\n",
    "valid_idx = np.isin(talk_names, valid_set_idx)\n",
    "test_idx = np.isin(talk_names, test_set_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XESytZMk3Kgc",
    "outputId": "4a86eefb-1a1f-4bd2-b07b-7d186610b526"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/pk/0hw9m8496w7gxnl1pfsssfdddh310s/T/ipykernel_76048/1925198038.py:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
      "  texts, labels = np.array(texts), np.array(labels)\n"
     ]
    }
   ],
   "source": [
    "texts, labels = np.array(texts), np.array(labels)\n",
    "\n",
    "train_texts, train_labels = texts[train_idx], labels[train_idx]\n",
    "valid_texts, valid_labels = texts[valid_idx], labels[valid_idx]\n",
    "test_texts, test_labels = texts[test_idx], labels[test_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "zUs18wu8EsXo"
   },
   "outputs": [],
   "source": [
    "del texts, labels, talks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yMxa5LWu3N2y"
   },
   "source": [
    "## Fasttext embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6nxjLWy43Q1p",
    "outputId": "ee6994fe-6176-4275-814c-4b1b0ff2033f"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning : `load_model` does not return WordVectorModel or SupervisedModel any more, but a `FastText` object which is very similar.\n"
     ]
    }
   ],
   "source": [
    "fasttext_model = fasttext.load_model(\"cc.en.300.bin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "id": "u0bjDuit3SHr"
   },
   "outputs": [],
   "source": [
    "EPS = 1e-5\n",
    "\n",
    "def l2_norm(vector):\n",
    "    return vector / (np.linalg.norm(vector) + EPS)\n",
    "\n",
    "\n",
    "def get_fasttext_embeddings(texts):\n",
    "    fasttext_embs = []\n",
    "    for text in tqdm(texts):\n",
    "        utterance_embs = [] \n",
    "        for utterance in text:\n",
    "            if not utterance.split():\n",
    "                embs = torch.Tensor(0, fasttext_model.get_dimension())\n",
    "            else:\n",
    "                embs = torch.Tensor(\n",
    "                    np.stack([\n",
    "                      l2_norm(fasttext_model.get_word_vector(word))\n",
    "                      for word in utterance.split()\n",
    "                    ])\n",
    "                  )\n",
    "            if len(embs) > max_length:\n",
    "                embs = embs[:max_length]\n",
    "            if len(embs) < max_length:\n",
    "                padding_shape = (max_length - len(embs), fasttext_model.get_dimension())\n",
    "                embs = torch.cat((torch.zeros(padding_shape), embs), axis=0)\n",
    "            utterance_embs.append(embs)\n",
    "        fasttext_embs.append(torch.stack(utterance_embs))\n",
    "\n",
    "    dialogue_lengths = [len(dialogue) for dialogue in fasttext_embs]\n",
    "    dialogue_lengths = torch.LongTensor(dialogue_lengths)\n",
    "\n",
    "    fasttext_embs = pad_sequence(fasttext_embs, batch_first=True)\n",
    "\n",
    "    return fasttext_embs, dialogue_lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "l-21uddSBPSX",
    "outputId": "540eb5e0-b0ad-4a27-c00f-73457e2d1dbc"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 19/19 [00:00<00:00, 44.46it/s]\n",
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 112/112 [00:01<00:00, 68.37it/s]\n",
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1003/1003 [00:15<00:00, 65.25it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(torch.Size([1003, 540, 30, 300]),\n",
       " torch.Size([112, 394, 30, 300]),\n",
       " torch.Size([19, 388, 30, 300]))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_embs, test_lengts = get_fasttext_embeddings(test_texts)\n",
    "valid_embs, valid_lengts = get_fasttext_embeddings(valid_texts)\n",
    "train_embs, train_lengts = get_fasttext_embeddings(train_texts)\n",
    "\n",
    "train_embs.size(), valid_embs.size(), test_embs.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "I8hFxCcWD2Ge",
    "outputId": "4a6091d4-1408-45cd-8b2a-645cb0688b35"
   },
   "outputs": [],
   "source": [
    "del fasttext_model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "fXbSSUTCAq8w"
   },
   "outputs": [],
   "source": [
    "train_labels = [torch.LongTensor(label) for label in train_labels]\n",
    "train_labels = pad_sequence(train_labels, batch_first=True)\n",
    "\n",
    "valid_labels = [torch.LongTensor(label) for label in valid_labels]\n",
    "valid_labels = pad_sequence(valid_labels, batch_first=True)\n",
    "\n",
    "test_labels = [torch.LongTensor(label) for label in test_labels]\n",
    "test_labels = pad_sequence(test_labels, batch_first=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "\n",
    "train_set = FasttextDataset(train_embs, train_lengts, train_labels)\n",
    "valid_set = FasttextDataset(valid_embs, valid_lengts, valid_labels)\n",
    "test_set = FasttextDataset(test_embs, test_lengts, test_labels)\n",
    "\n",
    "train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True)\n",
    "valid_loader = DataLoader(valid_set, batch_size=batch_size, shuffle=False)\n",
    "test_loader = DataLoader(test_set, batch_size=batch_size, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DialogueNetFasttext(\n",
       "  (rnn_embedder): RNNEmbedder(\n",
       "    (rnn): GRU(300, 128, batch_first=True, bidirectional=True)\n",
       "  )\n",
       "  (dialogue_rnn): DialogueRNN(\n",
       "    (rnn): GRU(256, 128, batch_first=True)\n",
       "    (norm): LayerNorm((128,), eps=1e-05, elementwise_affine=True)\n",
       "    (head): Sequential(\n",
       "      (0): Linear(in_features=128, out_features=128, bias=True)\n",
       "      (1): ReLU()\n",
       "      (2): Linear(in_features=128, out_features=43, bias=True)\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net = DialogueNetFasttext(\n",
    "    input_size=300, \n",
    "    output_size=len(tag_occurances), \n",
    "    rnn_hidden_size=128, \n",
    "    use_layer_norm=True, \n",
    "    max_utterance_len=max_length,\n",
    ")\n",
    "\n",
    "net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[EPOCH 0] Train loss: 2.1569758355617523\n",
      "[EPOCH 0] Val loss: 1.6215979158878326, F1-score: 0.5408546839449995\n",
      "[EPOCH 0] Test loss: 1.6923454999923706, F1-score: 0.49490474080638014\n",
      "[EPOCH 1] Train loss: 1.4027735851705074\n",
      "[EPOCH 1] Val loss: 1.2336041331291199, F1-score: 0.6182114947076862\n",
      "[EPOCH 1] Test loss: 1.3457103967666626, F1-score: 0.5624723083739477\n",
      "[EPOCH 2] Train loss: 1.1046676971018314\n",
      "[EPOCH 2] Val loss: 0.9988842308521271, F1-score: 0.6951231575823523\n",
      "[EPOCH 2] Test loss: 1.1133297681808472, F1-score: 0.6535223748338502\n",
      "[EPOCH 3] Train loss: 0.9527820367366076\n",
      "[EPOCH 3] Val loss: 0.8835627436637878, F1-score: 0.7281630230487685\n",
      "[EPOCH 3] Test loss: 0.9548056721687317, F1-score: 0.7042534337616305\n",
      "[EPOCH 4] Train loss: 0.8554622232913971\n",
      "[EPOCH 4] Val loss: 0.8157291859388351, F1-score: 0.7484914432683747\n",
      "[EPOCH 4] Test loss: 0.8814233541488647, F1-score: 0.727292866637129\n",
      "[EPOCH 5] Train loss: 0.7931054085493088\n",
      "[EPOCH 5] Val loss: 0.7624399065971375, F1-score: 0.7615985755267584\n",
      "[EPOCH 5] Test loss: 0.8343629240989685, F1-score: 0.7381479840496233\n",
      "[EPOCH 6] Train loss: 0.7382356580346823\n",
      "[EPOCH 6] Val loss: 0.7655123472213745, F1-score: 0.7522010090018795\n",
      "[EPOCH 6] Test loss: 0.8204759955406189, F1-score: 0.7337173238812583\n",
      "[EPOCH 7] Train loss: 0.7113202195614576\n",
      "[EPOCH 7] Val loss: 0.7203398793935776, F1-score: 0.76807795034128\n",
      "[EPOCH 7] Test loss: 0.7972266674041748, F1-score: 0.743907842268498\n",
      "[EPOCH 8] Train loss: 0.6736366841942072\n",
      "[EPOCH 8] Val loss: 0.7086797505617142, F1-score: 0.7694133940053418\n",
      "[EPOCH 8] Test loss: 0.7645148038864136, F1-score: 0.7483385024368631\n",
      "[EPOCH 9] Train loss: 0.6513499692082405\n",
      "[EPOCH 9] Val loss: 0.6998999118804932, F1-score: 0.7788604214066672\n",
      "[EPOCH 9] Test loss: 0.7543931007385254, F1-score: 0.7662826761187417\n",
      "[EPOCH 10] Train loss: 0.6311103142797947\n",
      "[EPOCH 10] Val loss: 0.7093686610460281, F1-score: 0.770303689781383\n",
      "[EPOCH 10] Test loss: 0.7857492566108704, F1-score: 0.7423571112095703\n",
      "[EPOCH 11] Train loss: 0.6040255315601826\n",
      "[EPOCH 11] Val loss: 0.6871512085199356, F1-score: 0.7783658126422002\n",
      "[EPOCH 11] Test loss: 0.7535040378570557, F1-score: 0.7576428887904297\n",
      "[EPOCH 12] Train loss: 0.5760403387248516\n",
      "[EPOCH 12] Val loss: 0.6875178515911102, F1-score: 0.7763873775843307\n",
      "[EPOCH 12] Test loss: 0.7574904561042786, F1-score: 0.7509968985378821\n",
      "Early stopping\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_model(net, train_loader, valid_loader, test_loader, optimizer,\n",
    "            bert_finetuning_epochs=None, n_epochs=100, verbose=True, plot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}