CUNY_GC_ML_Final_Project_Sentiment_analysis_with_Pytorch.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CUNY GC - ML Final Project - Sentiment analysis with Pytorch",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mgrafu/CUNY-ML-DeepLearning/blob/main/CUNY_GC_ML_Final_Project_Sentiment_analysis_with_Pytorch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install --upgrade matplotlib"
      ],
      "metadata": {
        "id": "8TYack72-us0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import string \n",
        "import time\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim\n",
        "\n",
        "from torchtext.legacy import data, datasets"
      ],
      "metadata": {
        "id": "A8oFgqY5WeDi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Complementary Functions**"
      ],
      "metadata": {
        "id": "BCnV5UUhaQIN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check how many parameters to train are in a model.\n",
        "def count_parameters(model):\n",
        "    return sum(p.numel() for p in model.parameters() if p.requires_grad)"
      ],
      "metadata": {
        "id": "1Ow1xi6Sb5Rr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute accuracy per batch.\n",
        "def binary_accuracy(preds, y):\n",
        "    # Round predictions to the closest integer.\n",
        "    rounded_preds = torch.round(torch.sigmoid(preds))\n",
        "    correct = (rounded_preds == y).float()\n",
        "    return correct.sum() / len(correct)"
      ],
      "metadata": {
        "id": "pbVV8UdGdwnY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the duration of a process.\n",
        "def epoch_time(start_time, end_time):\n",
        "    elapsed_time = end_time - start_time\n",
        "    elapsed_mins = int(elapsed_time  / 60)\n",
        "    elapsed_secs = int(elapsed_time -  (elapsed_mins * 60))\n",
        "    return  elapsed_mins, elapsed_secs"
      ],
      "metadata": {
        "id": "wHhfCTL_eiYU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Load Data**"
      ],
      "metadata": {
        "id": "_oVPnn7bGN7w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "BATCH_SIZE = 64\n",
        "MAX_VOCAB_SIZE = 25_000\n",
        "SEED = 42\n",
        "\n",
        "start_time = time.time()\n",
        "\n",
        "torch.manual_seed(SEED)\n",
        "torch.backends.cudnn.deterministic = True\n",
        "\n",
        "# Define the fields.\n",
        "TEXT = data.Field(tokenize='spacy',\n",
        "                  tokenizer_language='en_core_web_sm',\n",
        "                  include_lengths=True)\n",
        "LABEL = data.LabelField(dtype=torch.float)\n",
        "\n",
        "print(\"Loading data from server...\")\n",
        "train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)\n",
        "train_data, valid_data = train_data.split(random_state=random.seed(SEED))\n",
        "print(train_data[0].__dict__.keys())\n",
        "\n",
        "# Build the vocabulary with GloVe.\n",
        "TEXT.build_vocab(train_data, \n",
        "                 max_size = MAX_VOCAB_SIZE, \n",
        "                 vectors = \"glove.6B.100d\", \n",
        "                 unk_init = torch.Tensor.normal_)\n",
        "LABEL.build_vocab(train_data)\n",
        "print(\"Vocabulary built successfully.\")\n",
        "\n",
        "# Determine whether to use CUDA or not.\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Create iterator for the dataset.\n",
        "train_iter, valid_iter, test_iter = data.BucketIterator.splits(\n",
        "    (train_data, valid_data, test_data), batch_size=BATCH_SIZE,\n",
        "    sort_within_batch=True, device=device)\n",
        "print(\"Iterators built successfully.\")\n",
        "\n",
        "mins, secs = epoch_time(start_time, time.time())\n",
        "print(f\"Loading Time: {mins}m {secs}s\")"
      ],
      "metadata": {
        "id": "6BDnsO4dC_UO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **LSTM Architecture**"
      ],
      "metadata": {
        "id": "MYKV4MpIa7TV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class LSTM(nn.Module):\n",
        "    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim,\n",
        "                 n_layers, bidirectional, dropout, pad_idx):\n",
        "        super().__init__()\n",
        "\n",
        "        # Define layers in the model.        \n",
        "        self.embedding = nn.Embedding(vocab_size, embedding_dim,\n",
        "                                      padding_idx=pad_idx)\n",
        "        \n",
        "        self.LSTM = nn.LSTM(embedding_dim, \n",
        "                           hidden_dim, \n",
        "                           num_layers=n_layers, \n",
        "                           bidirectional=bidirectional, \n",
        "                           dropout=dropout)\n",
        "        \n",
        "        self.fc = nn.Linear(hidden_dim * 2, output_dim)\n",
        "        \n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "        \n",
        "    def forward(self, text, text_lengths):\n",
        "        # Compute embeddings.\n",
        "        # text format: [len(sent), batch_size]\n",
        "        # embedded format: [len(sent), batch_size, embedding_dim]\n",
        "        embedded = self.dropout(self.embedding(text))\n",
        "        \n",
        "        # Pack sequence.\n",
        "        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded,\n",
        "                                                            text_lengths.to(\"cpu\"),\n",
        "                                                            enforce_sorted=False)\n",
        "        # Run through LSTM.\n",
        "        packed_output, (hidden, cell) = self.LSTM(packed_embedded)\n",
        "        \n",
        "        # Unpack sequence.\n",
        "        # Output over padding tokens are zero tensors.\n",
        "        # output format: [len(sent), batch_size, hidden_dim * n_directions]\n",
        "        # hidden format: [n_layers * n_directions, batch_size, hidden_dim]\n",
        "        # cell format: [n_layers * n_directions, batch_size, hidden_dim]\n",
        "        output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output)\n",
        "        \n",
        "        # Apply dropout and concat the last forward and backward hidden layers.\n",
        "        # hidden format: [batch_size, hidden_dim * n_directions]\n",
        "        hidden = self.dropout(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1))\n",
        "    \n",
        "        return self.fc(hidden)"
      ],
      "metadata": {
        "id": "3iFaX2LuZ_nm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_LSTM(model, iterator, optimizer, criterion):\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    epoch_acc = 0\n",
        "    model.train()\n",
        "    for i, batch in enumerate(iterator):\n",
        "        optimizer.zero_grad()\n",
        "        \n",
        "        text, text_lengths = batch.text\n",
        "        predictions = model(text, text_lengths).squeeze(1)\n",
        "        \n",
        "        loss = criterion(predictions, batch.label.float())\n",
        "        acc = binary_accuracy(predictions, batch.label)\n",
        "        \n",
        "        loss.backward()        \n",
        "        optimizer.step()\n",
        "        \n",
        "        epoch_loss += loss.item()\n",
        "        epoch_acc += acc.item()\n",
        "        batch_size = len(iterator)\n",
        "\n",
        "        if i % 50 == 0:\n",
        "            print(f\"[{i:03}/{len(iterator)}]:\", end=\" \")\n",
        "            print(f\"epoch_acc: {epoch_acc / batch_size:.2f}\")\n",
        "    return epoch_loss / batch_size, epoch_acc / batch_size"
      ],
      "metadata": {
        "id": "6NzDfEXBd_dq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def evaluate_LSTM(model, iterator, criterion):\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    epoch_acc = 0\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for batch in iterator:\n",
        "            text, text_lengths = batch.text\n",
        "            predictions = model(text, text_lengths).squeeze(1)\n",
        "\n",
        "            loss = criterion(predictions, batch.label.float())\n",
        "            acc = binary_accuracy(predictions, batch.label)\n",
        "        \n",
        "            epoch_loss += loss.item()\n",
        "            epoch_acc += acc.item()\n",
        "            batch_size = len(iterator)\n",
        "\n",
        "    return epoch_loss / batch_size, epoch_acc / batch_size"
      ],
      "metadata": {
        "id": "-Bkrv-u1fmIA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_eval_LSTM(n_layers=1, dropout=0, num_epochs=2):\n",
        "    # Set variable model hyperparameters:\n",
        "    N_LAYERS = n_layers\n",
        "    DROPOUT = dropout\n",
        "\n",
        "    # Set fixed model hyperparameters.\n",
        "    INPUT_DIM = len(TEXT.vocab)\n",
        "    EMBEDDING_DIM = 100\n",
        "    HIDDEN_DIM = 256\n",
        "    OUTPUT_DIM = 1\n",
        "    BIDIRECTIONAL = True\n",
        "    PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]\n",
        "    \n",
        "    # Instantiate model.\n",
        "    model = LSTM(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM, \n",
        "                 N_LAYERS, BIDIRECTIONAL, DROPOUT, PAD_IDX)\n",
        "    print(f'The model has {count_parameters(model):,} trainable parameters')\n",
        "\n",
        "    # Define the optimizer and loss function.\n",
        "    optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "    criterion = nn.BCEWithLogitsLoss()\n",
        "\n",
        "    # Pass the model and loss function to GPU.\n",
        "    model = model.to(device)\n",
        "    criterion = criterion.to(device)\n",
        "\n",
        "    # Store accuracies per epoch.\n",
        "    all_train_acc = []\n",
        "    all_valid_acc = []\n",
        "\n",
        "    # Train the model.\n",
        "    best_valid_loss = float('inf')\n",
        "    for epoch in range(num_epochs):\n",
        "        st = time.time()\n",
        "        train_loss, train_acc = train_LSTM(model, train_iter, optimizer, criterion)\n",
        "        valid_loss, valid_acc = evaluate_LSTM(model, valid_iter, criterion)    \n",
        "        epoch_mins, epoch_secs = epoch_time(st, time.time())\n",
        "        \n",
        "        # Append to lists of accuracies.\n",
        "        all_train_acc.append(train_acc)\n",
        "        all_valid_acc.append(valid_acc)        \n",
        "\n",
        "        if valid_loss < best_valid_loss:\n",
        "            best_valid_loss = valid_loss\n",
        "            torch.save(model.state_dict(), 'LSTM-model.pt')\n",
        "            \n",
        "        print(f'Epoch:  {epoch+1:03} | Epoch Time: {epoch_mins}m {epoch_secs}s')\n",
        "        print(f'\\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')\n",
        "        print(f'\\tValid Loss: {valid_loss:.3f} | Valid Acc: {valid_acc*100:.2f}%')\n",
        "\n",
        "    # Evaluate on test set.\n",
        "    model.load_state_dict(torch.load('LSTM-model.pt'))\n",
        "    test_loss, test_acc = evaluate_LSTM(model, test_iter, criterion)\n",
        "    print(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')\n",
        "    print()\n",
        "\n",
        "    return all_train_acc, all_valid_acc, test_acc"
      ],
      "metadata": {
        "id": "B_bxoB0_e_09"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **CNN Architecture**"
      ],
      "metadata": {
        "id": "TB3--oRMb_xR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class CNN(nn.Module):\n",
        "    def __init__(self, vocab_size, embedding_dim, n_filters, filter_sizes, \n",
        "                 output_dim, dropout, pad_idx):\n",
        "        super(CNN, self).__init__()\n",
        "        \n",
        "        # Define layers in the model.        \n",
        "        self.embedding = nn.Embedding(vocab_size, embedding_dim, \n",
        "                                      padding_idx=pad_idx)\n",
        "        \n",
        "        self.convs = nn.ModuleList([nn.Conv2d(in_channels=1, \n",
        "                                              out_channels=n_filters, \n",
        "                                              kernel_size=(fs, embedding_dim)) \n",
        "                                    for fs in filter_sizes])\n",
        "        \n",
        "        self.fc = nn.Linear(len(filter_sizes) * n_filters, output_dim)\n",
        "        \n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "        \n",
        "    def forward(self, text):\n",
        "        # Permute text format.\n",
        "        #      from: [len(sent), batch_size] \n",
        "        #      to: [batch_size, len(sent)]\n",
        "        text = text.permute(1, 0)\n",
        "\n",
        "        # Compute embeddings.\n",
        "        # embedded format: [batch_size, len(sent), embedding_dim]\n",
        "        embedded = self.embedding(text)\n",
        "        # embedded format: [batch_size, 1, len(sent), embedding_dim]\n",
        "        embedded = embedded.unsqueeze(1)\n",
        "        \n",
        "        # Perform convolution.\n",
        "        # conved_n format: [batch_size, n_filters, len(sent) - filter_sizes[n] + 1]\n",
        "        conved = [F.relu(conv(embedded)).squeeze(3) for conv in self.convs]  \n",
        "        \n",
        "        # Apply max pooling.\n",
        "        # pooled format: [len(filter_sizes), batch_size, n_filters]\n",
        "        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]\n",
        "        \n",
        "        # Concatenate results from all filter sizes.\n",
        "        # cat format: [batch_size, n_filters * len(filter_sizes)]\n",
        "        cat = self.dropout(torch.cat(pooled, dim=1))\n",
        "            \n",
        "        return self.fc(cat)"
      ],
      "metadata": {
        "id": "IIlj_p-acGR6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_CNN(model, iterator, optimizer, criterion):\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    epoch_acc = 0\n",
        "    model.train()\n",
        "    for i, batch in enumerate(iterator):\n",
        "        optimizer.zero_grad()\n",
        "        text, text_lengths = batch.text\n",
        "        predictions = model(text).squeeze(1)\n",
        "        \n",
        "        loss = criterion(predictions, batch.label.float())\n",
        "        acc = binary_accuracy(predictions, batch.label)\n",
        "        \n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        epoch_loss += loss.item()\n",
        "        epoch_acc += acc.item()\n",
        "        batch_size = len(iterator)\n",
        "\n",
        "        if i % 50 == 0:\n",
        "            print(f\"[{i:03}/{len(iterator)}]:\", end=\" \")\n",
        "            print(f\"epoch_acc: {epoch_acc / batch_size:.2f}\")\n",
        "    return epoch_loss / batch_size, epoch_acc / batch_size"
      ],
      "metadata": {
        "id": "siCSOJ_DufCq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def evaluate_CNN(model, iterator, criterion):\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    epoch_acc = 0\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for batch in iterator:\n",
        "            text, text_lengths = batch.text\n",
        "            predictions = model(text).squeeze(1)\n",
        "\n",
        "            loss = criterion(predictions, batch.label.float())\n",
        "            acc = binary_accuracy(predictions, batch.label)\n",
        "\n",
        "            epoch_loss += loss.item()\n",
        "            epoch_acc += acc.item()\n",
        "            batch_size = len(iterator)\n",
        "        \n",
        "    return epoch_loss / batch_size, epoch_acc / batch_size"
      ],
      "metadata": {
        "id": "NsPgn4OCwp4W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_eval_CNN(filter_sizes=[3, 4, 5], dropout=0.5, num_epochs=2):\n",
        "    # Set variable model hyperparameters:\n",
        "    FILTER_SIZES = filter_sizes\n",
        "    DROPOUT = dropout\n",
        "\n",
        "    # Set fixed model hyperparameters.\n",
        "    INPUT_DIM = len(TEXT.vocab)\n",
        "    EMBEDDING_DIM = 100\n",
        "    N_FILTERS = 100\n",
        "    OUTPUT_DIM = 1\n",
        "    PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]\n",
        "\n",
        "    # Instantiate model.\n",
        "    model = CNN(INPUT_DIM, EMBEDDING_DIM, N_FILTERS, FILTER_SIZES, \n",
        "                OUTPUT_DIM, DROPOUT, PAD_IDX)\n",
        "    print(f'The model has {count_parameters(model):,} trainable parameters')\n",
        "\n",
        "    # Define the optimizer and loss function.\n",
        "    optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "    criterion = nn.BCEWithLogitsLoss()\n",
        "\n",
        "    # Pass the model and loss function to GPU.\n",
        "    model = model.to(device)\n",
        "    criterion = criterion.to(device)\n",
        "\n",
        "    # Store accuracies per epoch.\n",
        "    all_train_acc = []\n",
        "    all_valid_acc = []\n",
        "\n",
        "    # Train the model.\n",
        "    best_valid_loss = float('inf')\n",
        "    for epoch in range(num_epochs):\n",
        "        start_time = time.time()\n",
        "        train_loss, train_acc = train_CNN(model, train_iter, optimizer, criterion)\n",
        "        valid_loss, valid_acc = evaluate_CNN(model, valid_iter, criterion)\n",
        "        epoch_mins, epoch_secs = epoch_time(start_time, time.time())\n",
        "\n",
        "        # Append to lists of accuracies.\n",
        "        all_train_acc.append(train_acc)\n",
        "        all_valid_acc.append(valid_acc)        \n",
        "\n",
        "        if valid_loss < best_valid_loss:\n",
        "            best_valid_loss = valid_loss\n",
        "            torch.save(model.state_dict(), 'CNN-model.pt')\n",
        "        \n",
        "        print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')\n",
        "        print(f'\\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')\n",
        "        print(f'\\t Val. Loss: {valid_loss:.3f} |  Val. Acc: {valid_acc*100:.2f}%')\n",
        "\n",
        "    # Evaluate on test set.\n",
        "    model.load_state_dict(torch.load('CNN-model.pt'))\n",
        "    test_loss, test_acc = evaluate_CNN(model, test_iter, criterion)\n",
        "    print(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')\n",
        "    print()\n",
        "\n",
        "    return all_train_acc, all_valid_acc, test_acc"
      ],
      "metadata": {
        "id": "LySXX-WwxX6c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Combined Model Architecture**"
      ],
      "metadata": {
        "id": "7lkC2hRdy1iC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class CNN_LSTM(nn.Module):\n",
        "    def __init__(self, vocab_size, embedding_dim, n_filters, filter_sizes, \n",
        "                 dropout, pad_idx, hidden_dim, output_dim, n_layers, bidirectional):\n",
        "        \n",
        "        super().__init__()\n",
        "        # Define layers in the model.\n",
        "        self.embedding = nn.Embedding(vocab_size, embedding_dim, \n",
        "                                      padding_idx=pad_idx)\n",
        "        \n",
        "        self.convs = nn.ModuleList([nn.Conv2d(in_channels = 1, \n",
        "                                              out_channels = n_filters, \n",
        "                                              kernel_size = (fs, embedding_dim)) \n",
        "                                    for fs in filter_sizes])\n",
        "        \n",
        "        self.LSTM = nn.LSTM(n_filters, hidden_dim, num_layers=n_layers, \n",
        "                            bidirectional=bidirectional, dropout=dropout)\n",
        "        \n",
        "        self.fc = nn.Linear(hidden_dim * 2, output_dim)\n",
        "                \n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, text, text_lengths):\n",
        "        # Permute text format.\n",
        "        #      from: [len(sent), batch_size] \n",
        "        #      to: [batch_size, len(sent)]\n",
        "        text = text.permute(1, 0)\n",
        "\n",
        "        # Compute embeddings.\n",
        "        # embedded format: [batch_size, len(sent), embedding_dim]\n",
        "        embedded = self.embedding(text)\n",
        "        # embedded format: [batch_size, 1, len(sent), embedding_dim]\n",
        "        embedded = embedded.unsqueeze(1)\n",
        "\n",
        "        # Perform convolution.\n",
        "        # conved_n format: [batch_size, n_filters, len(sent) - filter_sizes[n] + 1]\n",
        "        conved = [F.relu(conv(embedded)).squeeze(3) for conv in self.convs]  \n",
        "\n",
        "        # Apply max pooling.\n",
        "        # pooled format: [len(filter_sizes), batch_size, n_filters]\n",
        "        pooled = [F.max_pool1d(conv, conv.shape[2]).squeeze(2) for conv in conved]\n",
        "\n",
        "        # Stack the output matrices of all filter sizes.\n",
        "        # stacked format: [len(filter_sizes), batch_size, n_filters]\n",
        "        stacked = self.dropout(torch.stack(pooled))\n",
        "\n",
        "        # Run stacked matrix through LSTM.\n",
        "        # output format: [len(filter_sizes), batch_size, hidden_dim * n_directions]\n",
        "        # hidden format: [n_layers * n_directions, batch_size, hidden_dim]\n",
        "        # cell format: [n_layers * n_directions, batch_size, hidden_dim]\n",
        "        output, (hidden, cell) = self.LSTM(stacked)\n",
        "        \n",
        "        # Apply dropout and concat the last forward and backward hidden layers.\n",
        "        # hidden format: [batch_size, hidden_dim * n_directions]\n",
        "        hidden = self.dropout(torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim = 1))\n",
        "            \n",
        "        return self.fc(hidden)"
      ],
      "metadata": {
        "id": "eQlC6_CkdmWQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_CNN_LSTM(model, iterator, optimizer, criterion):\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    epoch_acc = 0\n",
        "    model.train()\n",
        "    for i, batch in enumerate(iterator):\n",
        "        optimizer.zero_grad()\n",
        "        text, text_lengths = batch.text\n",
        "        predictions = model(text, text_lengths).squeeze(1)\n",
        "        \n",
        "        loss = criterion(predictions, batch.label)\n",
        "        acc = binary_accuracy(predictions, batch.label)\n",
        "        \n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        epoch_loss += loss.item()\n",
        "        epoch_acc += acc.item()\n",
        "        batch_size = len(iterator)\n",
        "\n",
        "        if i % 50 == 0:\n",
        "            print(f\"[{i:03}/{len(iterator)}]:\", end=\" \")\n",
        "            print(f\"epoch_acc: {epoch_acc / batch_size:.2f}\")\n",
        "    return epoch_loss / batch_size, epoch_acc / batch_size"
      ],
      "metadata": {
        "id": "qvdy9IuG4hPX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def evaluate_CNN_LSTM(model, iterator, criterion):\n",
        "    \n",
        "    epoch_loss = 0\n",
        "    epoch_acc = 0\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        for batch in iterator:\n",
        "            text, text_lengths = batch.text\n",
        "            predictions = model(text, text_lengths).squeeze(1)\n",
        "  \n",
        "            loss = criterion(predictions, batch.label)\n",
        "            acc = binary_accuracy(predictions, batch.label)\n",
        "\n",
        "            epoch_loss += loss.item()\n",
        "            epoch_acc += acc.item()\n",
        "            batch_size = len(iterator)\n",
        "        \n",
        "    return epoch_loss / batch_size, epoch_acc / batch_size"
      ],
      "metadata": {
        "id": "UQRXMjB95MJQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_eval_CNN_LSTM(n_layers=2, dropout=0.5, \n",
        "                        filter_sizes=[3,4,5], num_epochs=2):\n",
        "    # Set variable model hyperparameters:\n",
        "    N_LAYERS = n_layers\n",
        "    DROPOUT = dropout\n",
        "    FILTER_SIZES = filter_sizes\n",
        "\n",
        "    # Set fixed model hyperparameters.\n",
        "    INPUT_DIM = len(TEXT.vocab)\n",
        "    EMBEDDING_DIM = 100\n",
        "    N_FILTERS = 100\n",
        "    BIDIRECTIONAL = True\n",
        "    HIDDEN_DIM = 256\n",
        "    OUTPUT_DIM = 1\n",
        "    PAD_IDX = TEXT.vocab.stoi[TEXT.pad_token]\n",
        "\n",
        "    # Instantiate model.\n",
        "    model = CNN_LSTM(INPUT_DIM, EMBEDDING_DIM, N_FILTERS,FILTER_SIZES, DROPOUT, \n",
        "                     PAD_IDX, HIDDEN_DIM, OUTPUT_DIM, N_LAYERS, BIDIRECTIONAL)\n",
        "    print(f'The model has {count_parameters(model):,} trainable parameters')\n",
        "\n",
        "    # Define the optimizer and loss function.\n",
        "    optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
        "    criterion = nn.BCEWithLogitsLoss()\n",
        "\n",
        "    # Pass the model and loss function to GPU.\n",
        "    model = model.to(device)\n",
        "    criterion = criterion.to(device)\n",
        "\n",
        "    # Store accuracies per epoch.\n",
        "    all_train_acc = []\n",
        "    all_valid_acc = []\n",
        "\n",
        "    # Train the model.\n",
        "    best_valid_loss = float('inf')\n",
        "    for epoch in range(num_epochs):\n",
        "        start_time = time.time()\n",
        "        train_loss, train_acc = train_CNN_LSTM(model, train_iter, optimizer, criterion)\n",
        "        valid_loss, valid_acc = evaluate_CNN_LSTM(model, valid_iter, criterion)\n",
        "        epoch_mins, epoch_secs = epoch_time(start_time, time.time())\n",
        "        \n",
        "        # Append to lists of accuracies.\n",
        "        all_train_acc.append(train_acc)\n",
        "        all_valid_acc.append(valid_acc)        \n",
        "\n",
        "        if valid_loss < best_valid_loss:\n",
        "            best_valid_loss = valid_loss\n",
        "            torch.save(model.state_dict(), 'CNN-LSTM-model.pt')\n",
        "        \n",
        "        print(f'Epoch: {epoch+1:02} | Epoch Time: {epoch_mins}m {epoch_secs}s')\n",
        "        print(f'\\tTrain Loss: {train_loss:.3f} | Train Acc: {train_acc*100:.2f}%')\n",
        "        print(f'\\t Val. Loss: {valid_loss:.3f} |  Val. Acc: {valid_acc*100:.2f}%')\n",
        "\n",
        "    # Evaluate on test set.\n",
        "    model.load_state_dict(torch.load('CNN-LSTM-model.pt'))\n",
        "    test_loss, test_acc = evaluate_CNN_LSTM(model, test_iter, criterion)\n",
        "    print(f'Test Loss: {test_loss:.3f} | Test Acc: {test_acc*100:.2f}%')\n",
        "    print()\n",
        "\n",
        "    return all_train_acc, all_valid_acc, test_acc"
      ],
      "metadata": {
        "id": "MkFWlYcL6cca"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Hyperparameter Tuning**"
      ],
      "metadata": {
        "id": "vcYCC8TlTsIq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# TUNE HYPERPARAMETERS FOR LSTM\n",
        "\n",
        "N_EPOCHS = 15\n",
        "\n",
        "start_time = time.time()\n",
        "\n",
        "# Define hyperparameter ranges to test.\n",
        "all_num_layers = [1, 2, 3, 4]\n",
        "all_dropouts = [0, 0.1, 0.2, 0.3, 0.4, 0.5]\n",
        "\n",
        "# Store best hyperparameters.\n",
        "best_accuracy = 0\n",
        "best_LSTM_hyperparameters = {\"layers\": 0, \"dropout\": 0}\n",
        "\n",
        "for num_layers in all_num_layers:\n",
        "    # Initialize plot.\n",
        "    plt.figure(num_layers, figsize=[10,7.5])\n",
        "    plt.title(f\"LSTM Accuracy with {num_layers} layer(s)\")\n",
        "    plt.xlabel(\"epoch num\")\n",
        "    plt.ylabel(\"Accuracy\")\n",
        "\n",
        "    # Add dropout only if there's more than one layer.\n",
        "    dropouts = all_dropouts if num_layers > 1 else [0]\n",
        "\n",
        "    for drop in dropouts:\n",
        "        # Run LSTM with current hyperparameters.\n",
        "        print(\"Training with the following hyperparameters:\")\n",
        "        print(f\"  Layer(s):\\t{num_layers}\")\n",
        "        print(f\"  Dropout:\\t{drop}\")\n",
        "        stats = train_eval_LSTM(n_layers=num_layers, dropout=drop, \n",
        "                                num_epochs=N_EPOCHS)\n",
        "\n",
        "        # Plot stats for this run.\n",
        "        _, valid_stats, _ = stats\n",
        "        epochs = [i + 1 for i in range(len(valid_stats))]\n",
        "        plt.plot(epochs, valid_stats, label=f\"valid, dropout={drop}\")\n",
        "\n",
        "        # Save best hyperparameters.\n",
        "        if max(valid_stats) > best_accuracy:\n",
        "            best_accuracy = max(valid_stats)\n",
        "            best_LSTM_hyperparameters[\"layers\"] = num_layers\n",
        "            best_LSTM_hyperparameters[\"dropout\"] = drop\n",
        "    \n",
        "    plt.legend()\n",
        "    plt.savefig(f\"Accuracy_LSTM-{num_layers}layer(s)-15epochs.pdf\")\n",
        "    plt.show()\n",
        "\n",
        "print(\"BEST HYPERPARAMETERS\")\n",
        "for key, val in best_LSTM_hyperparameters.items():\n",
        "    print(f\"{key} = {val}\")\n",
        "print(f\"validation set accuracy = {best_accuracy}\")\n",
        "mins, secs = epoch_time(start_time, time.time())\n",
        "print(f\"Tuning Time: {mins}m {secs}s\")"
      ],
      "metadata": {
        "id": "onkemtxqTvwN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# TUNE HYPERPARAMETERS FOR CNN\n",
        "\n",
        "N_EPOCHS = 15\n",
        "\n",
        "start_time = time.time()\n",
        "\n",
        "# Define hyperparameter ranges to test.\n",
        "all_filter_sizes = [[2,3,4], [3,4,5], [3,4,5,6], [2,3,4,5,6]]\n",
        "all_dropouts = [0, 0.1, 0.3, 0.5, 0.7, 0.9]\n",
        "\n",
        "# Store best hyperparameters.\n",
        "best_accuracy = 0\n",
        "best_CNN_hyperparameters = {\"filter sizes\": [0], \"dropout\": 0}\n",
        "\n",
        "for filters_list in all_filter_sizes:\n",
        "    # Initialize plot.\n",
        "    plt.figure(len(filters_list) + 10, figsize=[10,7.5])\n",
        "    plt.title(f\"CNN Accuracy with {filters_list}-size filters\")\n",
        "    plt.xlabel(\"epoch num\")\n",
        "    plt.ylabel(\"Accuracy\")\n",
        "\n",
        "    for drop in all_dropouts:\n",
        "        # Run CNN with current hyperparameters.\n",
        "        print(\"Training with the following hyperparameters:\")\n",
        "        print(f\"  Filter sizes:\\t{filters_list}\")\n",
        "        print(f\"  Dropout:\\t{drop}\")\n",
        "        stats = train_eval_CNN(filter_sizes=filters_list, dropout=drop, \n",
        "                               num_epochs=N_EPOCHS)\n",
        "\n",
        "        # Plot stats for this run.\n",
        "        _, valid_stats, _ = stats\n",
        "        epochs = [i + 1 for i in range(len(valid_stats))]\n",
        "        plt.plot(epochs, valid_stats, label=f\"valid, dropout={drop}\")\n",
        "\n",
        "        # Save best hyperparameters.\n",
        "        if max(valid_stats) > best_accuracy:\n",
        "            best_accuracy = max(valid_stats)\n",
        "            best_CNN_hyperparameters[\"filter sizes\"] = filters_list\n",
        "            best_CNN_hyperparameters[\"dropout\"] = drop\n",
        "    \n",
        "    plt.legend()\n",
        "    plt.savefig(f\"Accuracy_CNN-{filters_list}filter_sizes-15epochs.pdf\")\n",
        "    plt.show()\n",
        "\n",
        "print(\"BEST HYPERPARAMETERS\")\n",
        "for key, val in best_CNN_hyperparameters.items():\n",
        "    print(f\"{key} = {val}\")\n",
        "print(f\"validation set accuracy = {best_accuracy}\")\n",
        "mins, secs = epoch_time(start_time, time.time())\n",
        "print(f\"Tuning Time: {mins}m {secs}s\")"
      ],
      "metadata": {
        "id": "HfbGzUwIiDqz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# TUNE HYPERPARAMETERS FOR CNN-LSTM\n",
        "\n",
        "N_EPOCHS = 15\n",
        "\n",
        "start_time = time.time()\n",
        "\n",
        "# Define hyperparameter ranges to test.\n",
        "all_layers = [2, 3]\n",
        "all_filter_sizes=[[2,3,4], [3,4,5]]\n",
        "all_dropouts = [0, 0.1, 0.3, 0.5, 0.7, 0.9]\n",
        "\n",
        "# Store best hyperparameters.\n",
        "best_accuracy = 0\n",
        "best_CNN_LSTM_hyperparameters = {\"layers\": 0, \"filter sizes\": [0], \"dropout\": 0}\n",
        "\n",
        "for num_layers in all_layers:\n",
        "    for filters_list in all_filter_sizes:\n",
        "        # Initialize plot.\n",
        "        plt.figure(len(filters_list) + 20, figsize=[10,7.5])\n",
        "        plt.title(f\"CNN-LSTM Accuracy with {filters_list}-size filters / {num_layers} layers\")\n",
        "        plt.xlabel(\"epoch num\")\n",
        "        plt.ylabel(\"Accuracy\")\n",
        "\n",
        "        for drop in all_dropouts:\n",
        "            # Run CNN with current hyperparameters.\n",
        "            print(\"Training with the following hyperparameters:\")\n",
        "            print(f\"  Layers:\\t{num_layers}\")\n",
        "            print(f\"  Filter sizes:\\t{filters_list}\")\n",
        "            print(f\"  Dropout:\\t{drop}\")\n",
        "            stats = train_eval_CNN_LSTM(n_layers=num_layers, dropout=drop,\n",
        "                                        filter_sizes=filters_list,\n",
        "                                        num_epochs=N_EPOCHS)\n",
        "\n",
        "            # Plot stats for this run.\n",
        "            _, valid_stats, _ = stats\n",
        "            epochs = [i + 1 for i in range(len(valid_stats))]\n",
        "            plt.plot(epochs, valid_stats, label=f\"valid, dropout={drop}\")\n",
        "\n",
        "            # Save best hyperparameters.\n",
        "            if max(valid_stats) > best_accuracy:\n",
        "                best_accuracy = max(valid_stats)\n",
        "                best_CNN_LSTM_hyperparameters[\"layers\"] = num_layers\n",
        "                best_CNN_LSTM_hyperparameters[\"filter sizes\"] = filters_list\n",
        "                best_CNN_LSTM_hyperparameters[\"dropout\"] = drop\n",
        "        \n",
        "        plt.legend()\n",
        "        plt.savefig(f\"Accuracy_CNN_LSTM-{filters_list}filter_sizes-{num_layers}layers-15epochs.pdf\")\n",
        "        plt.show()\n",
        "\n",
        "print(\"BEST HYPERPARAMETERS\")\n",
        "for key, val in best_CNN_LSTM_hyperparameters.items():\n",
        "    print(f\"{key} = {val}\")\n",
        "print(f\"validation set accuracy = {best_accuracy}\")\n",
        "mins, secs = epoch_time(start_time, time.time())\n",
        "print(f\"Tuning Time: {mins}m {secs}s\")"
      ],
      "metadata": {
        "id": "qv7NqL14ngU6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Comparing Models**"
      ],
      "metadata": {
        "id": "MRmNEZoxFnIW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Normally, this should all run sequentially, but if we need to run\n",
        "# the tuning runs separatey, the best hyperparameters are hard-coded here.\n",
        "\n",
        "# # Best stats if models are run for 10 epochs:\n",
        "# best_LSTM_hyperparameters = {\"layers\": 2, \"dropout\": 0.3}\n",
        "# best_CNN_hyperparameters = {\"filter sizes\": [2,3,4], \"dropout\": 0.3}\n",
        "# best_CNN_LSTM_hyperparameters = {\"layers\": 3, \"dropout\": 0.3, \n",
        "#                                  \"filter sizes\": [2,3,4]}\n",
        "\n",
        "# # Best stats if models are run for 15 epochs:\n",
        "# best_LSTM_hyperparameters = {\"layers\": 4, \"dropout\": 0.5}\n",
        "# best_CNN_hyperparameters = {\"filter sizes\": [2,3,4], \"dropout\": 0.1}\n",
        "# best_CNN_LSTM_hyperparameters = {\"layers\": 3, \"dropout\": 0.3, \n",
        "#                                  \"filter sizes\": [2,3,4]}"
      ],
      "metadata": {
        "id": "9L4KYccrS7Mh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "param_dicts = [best_LSTM_hyperparameters, \n",
        "               best_CNN_hyperparameters, \n",
        "               best_CNN_LSTM_hyperparameters]\n",
        "\n",
        "for i, param_dict in enumerate(param_dicts):\n",
        "  print(f\"Model {i + 1}\")\n",
        "  for key, value in param_dict.items():\n",
        "    print(key, value)\n",
        "  print()"
      ],
      "metadata": {
        "id": "qJcZ5Z6QcRei"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Training LSTM for evaluation...\")\n",
        "NUM_EPOCHS = 20\n",
        "\n",
        "# Train and evaluate optimal LSTM model.\n",
        "st = time.time()\n",
        "lstm_layers = best_LSTM_hyperparameters[\"layers\"]\n",
        "lstm_dropout = best_LSTM_hyperparameters[\"dropout\"]\n",
        "lstm_train_acc, lstm_valid_acc, lstm_test_acc = train_eval_LSTM(n_layers=lstm_layers, \n",
        "                                       dropout=lstm_dropout, \n",
        "                                       num_epochs=NUM_EPOCHS)\n",
        "lstm_duration = time.time() - st"
      ],
      "metadata": {
        "id": "o46CPH_gFrHY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train and evaluate optimal CNN model.\n",
        "print(\"Training CNN for evaluation...\")\n",
        "st = time.time()\n",
        "cnn_filter_sizes = best_CNN_hyperparameters[\"filter sizes\"]\n",
        "cnn_dropout = best_CNN_hyperparameters[\"dropout\"]\n",
        "cnn_train_acc, cnn_valid_acc, cnn_test_acc = train_eval_CNN(\n",
        "    filter_sizes=cnn_filter_sizes, dropout=cnn_dropout, num_epochs=NUM_EPOCHS)\n",
        "cnn_duration = time.time() - st"
      ],
      "metadata": {
        "id": "nH_rHj4PNTX8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Train and evaluate optimal CNN-LSTM model.\n",
        "print(\"Training CNN-LSTM for evaluation...\")\n",
        "st = time.time()\n",
        "cnn_lstm_layers = best_CNN_LSTM_hyperparameters[\"layers\"]\n",
        "cnn_lstm_filter_sizes = best_CNN_LSTM_hyperparameters[\"filter sizes\"]\n",
        "cnn_lstm_dropout = best_CNN_LSTM_hyperparameters[\"dropout\"]\n",
        "cnn_lstm_train_acc, cnn_lstm_valid_acc, cnn_lstm_test_acc = train_eval_CNN_LSTM(\n",
        "    n_layers=cnn_lstm_layers, dropout=cnn_lstm_dropout, \n",
        "    filter_sizes=cnn_lstm_filter_sizes, num_epochs=NUM_EPOCHS)\n",
        "cnn_lstm_duration = time.time() - st"
      ],
      "metadata": {
        "id": "4NQwTRzsNWsm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Time elapsed training each model:\")\n",
        "print(f\"LSTM\\t\\t= {lstm_duration:.2}s\")\n",
        "print(f\"CNN\\t\\t= {cnn_duration:.2}s\")\n",
        "print(f\"CNN-LSTM\\t= {cnn_lstm_duration:.2}s\")"
      ],
      "metadata": {
        "id": "sSEDOhvEb8tw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot running time comparison.\n",
        "labels = ['LSTM', 'CNN', 'CNN LSTM']\n",
        "time_per_epoch = [lstm_duration / NUM_EPOCHS, \n",
        "                  cnn_duration / NUM_EPOCHS, \n",
        "                  cnn_lstm_duration / NUM_EPOCHS]\n",
        "total_time = [lstm_duration, cnn_duration, cnn_lstm_duration]\n",
        "\n",
        "x = np.arange(len(labels))\n",
        "width = 0.35\n",
        "\n",
        "fig, ax = plt.subplots(figsize=[10,7.5])\n",
        "ax.set_title('Running Time per Model')\n",
        "ax.set_xticks(x, labels)\n",
        "ax.set_ylabel('Seconds')\n",
        "\n",
        "rects1 = ax.bar(x - width/2, time_per_epoch, width, label='Avg. Epoch Time')\n",
        "rects2 = ax.bar(x + width/2, total_time, width, label='Total Time')\n",
        "\n",
        "ax.bar_label(rects1, padding=3)\n",
        "ax.bar_label(rects2, padding=3)\n",
        "\n",
        "ax.legend()\n",
        "fig.tight_layout()\n",
        "plt.savefig(\"Model Comparison - Running Time.pdf\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 549
        },
        "id": "hBOimiDiGr8e",
        "outputId": "07b89886-95a9-4050-fb78-6e55581cad02"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x540 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "epochs = [i + 1 for i in range(NUM_EPOCHS)]\n",
        "\n",
        "# Plot accuracy comparison.\n",
        "plt.figure(101, figsize=[10,7.5])\n",
        "plt.title(\"Accuracy per Model\")\n",
        "plt.xlabel(\"epoch num\")\n",
        "plt.ylabel(\"Accuracy\")\n",
        "\n",
        "# plt.plot(epochs, lstm_train_acc, label=\"LSTM-training\")\n",
        "# plt.plot(epochs, cnn_train_acc, label=\"CNN-training\")\n",
        "# plt.plot(epochs, cnn_lstm_train_acc, label=\"CNN-LSTM-training\")\n",
        "\n",
        "plt.plot(epochs, lstm_valid_acc, label=\"LSTM-validation\")\n",
        "plt.plot(epochs, cnn_valid_acc, label=\"CNN-validation\")\n",
        "plt.plot(epochs, cnn_lstm_valid_acc, label=\"CNN-LSTM-validation\")\n",
        "\n",
        "plt.legend()\n",
        "plt.savefig(\"Model Comparison - Accuracy.pdf\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 486
        },
        "id": "NWJQ1EsBGsmx",
        "outputId": "d0538e6e-dda8-4f02-e8e6-d6296f898417"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x540 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot accuracy over time comparisons.\n",
        "fig, ax = plt.subplots(figsize=[10,7.5])\n",
        "plt.title(\"Accuracy Over Time per Model\")\n",
        "plt.xlabel('time (seconds)')\n",
        "plt.ylabel('Accuracy')\n",
        "\n",
        "lstm_times = [time_per_epoch[0] for _ in range(len(lstm_valid_acc))]\n",
        "cnn_times = [time_per_epoch[1] for _ in range(len(cnn_valid_acc))]\n",
        "cnn_lstm_times = [time_per_epoch[2] for _ in range(len(cnn_lstm_valid_acc))]\n",
        "\n",
        "ax.plot(np.cumsum(lstm_times), lstm_valid_acc, label=\"LSTM\")\n",
        "ax.plot(np.cumsum(cnn_times), cnn_valid_acc, label=\"CNN\")\n",
        "ax.plot(np.cumsum(cnn_lstm_times), cnn_lstm_valid_acc, label=\"CNN-LSTM\")\n",
        "\n",
        "legend = ax.legend()\n",
        "plt.savefig(\"Model Comparisons - Accuracy Over Time.pdf\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 486
        },
        "id": "CxuOwnwEV3Iv",
        "outputId": "f9ab419c-aa57-4ebd-ad69-5c5d40a77cd1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x540 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Accuracy on the test set for each model:\")\n",
        "print(f\"LSTM\\t\\t= {lstm_test_acc:.2%}\")\n",
        "print(f\"CNN\\t\\t= {cnn_test_acc:.2%}\")\n",
        "print(f\"CNN-LSTM\\t= {cnn_lstm_test_acc:.2%}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qB2NA7U8kVvQ",
        "outputId": "1edf0a2c-80b8-4810-85f4-9ae1baff4c1b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy on the test set for each model:\n",
            "LSTM\t\t= 88.35%\n",
            "CNN\t\t= 88.11%\n",
            "CNN-LSTM\t= 88.27%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Accuracy on the training set for each model:\")\n",
        "print(f\"LSTM\\t\\t= {max(lstm_train_acc):.2%}\")\n",
        "print(f\"CNN\\t\\t= {max(cnn_train_acc):.2%}\")\n",
        "print(f\"CNN-LSTM\\t= {max(cnn_lstm_train_acc):.2%}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IQgZVpbOH690",
        "outputId": "d07ef3c5-a6b5-4937-f224-d09a12f7256f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy on the training set for each model:\n",
            "LSTM\t\t= 94.41%\n",
            "CNN\t\t= 99.58%\n",
            "CNN-LSTM\t= 99.14%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Accuracy on the validation set for each model:\")\n",
        "print(f\"LSTM\\t\\t= {max(lstm_valid_acc):.2%}\")\n",
        "print(f\"CNN\\t\\t= {max(cnn_valid_acc):.2%}\")\n",
        "print(f\"CNN-LSTM\\t= {max(cnn_lstm_valid_acc):.2%}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WOw2XDOWISNn",
        "outputId": "7efad706-0b51-43fc-f8b7-f6ba1521fa89"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy on the validation set for each model:\n",
            "LSTM\t\t= 89.11%\n",
            "CNN\t\t= 89.19%\n",
            "CNN-LSTM\t= 88.44%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Reference**\n",
        "\n",
        "Source Code on which this work was based:\n",
        "https://github.com/bentrevett/pytorch-sentiment-analysis"
      ],
      "metadata": {
        "id": "REYQIYDBLZsn"
      }
    }
  ]
}