GRU_Approach.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "I65MFEHrLfk6"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from dataset import Dataset, Sample\n",
        "import utils\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "from sklearn.model_selection import train_test_split\n",
        "from torch.utils.data import DataLoader, TensorDataset\n",
        "import time\n",
        "from sklearn.metrics import accuracy_score\n",
        "import seaborn as sns\n",
        "sns.set_theme(style='whitegrid')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "v3kyGu_qMP_Z"
      },
      "outputs": [],
      "source": [
        "class PreprocessedSample(object):\n",
        "    def __init__(self, sample: Sample, n=64):\n",
        "        trajectory = utils.resample(sample.trajectory, n)\n",
        "        trajectory = utils.scale_to_unit_square(trajectory)\n",
        "        vecs = utils.vectorize(trajectory)\n",
        "        \n",
        "        self.trajectory = trajectory\n",
        "        self.vecs = vecs\n",
        "        self.gname = sample.gname\n",
        "\n",
        "ds = Dataset.Load(\"datasets/gds/training\") # Load the dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SCZBc0wGMYFa",
        "outputId": "7f536e7e-454f-4050-8180-ce27ac845828"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "processed 1000 samples\n",
            "processed 2000 samples\n",
            "processed 3000 samples\n",
            "processed 4000 samples\n",
            "(4800, 200)\n"
          ]
        }
      ],
      "source": [
        "# Resample, scale, translate and convert to floats\n",
        "preprocessed_samples = []\n",
        "for i, s in enumerate(ds.samples):\n",
        "    ps = PreprocessedSample(s, 100)\n",
        "    if i % 1000 == 0 and i > 0:\n",
        "        print(f\"processed {i} samples\")\n",
        "    preprocessed_samples.append(ps)\n",
        "\n",
        "preprocessed_x = np.array([p.trajectory.flatten() for p in preprocessed_samples])\n",
        "preprocessed_x = preprocessed_x.astype(np.float32)\n",
        "print(preprocessed_x.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Qms7TiloQRMR",
        "outputId": "74507158-ecbe-45fc-da78-856fe36521f5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(4800, 16)\n"
          ]
        }
      ],
      "source": [
        "# Encode labels\n",
        "preprocessed_y = [p.gname for p in preprocessed_samples]\n",
        "preprocessed_y = np.array(preprocessed_y).reshape(-1, 1)\n",
        "oh = OneHotEncoder()\n",
        "oh.fit(preprocessed_y)\n",
        "preprocessed_y = oh.transform(preprocessed_y).toarray()\n",
        "preprocessed_y = preprocessed_y.astype(np.float32)\n",
        "print(preprocessed_y.shape)\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(preprocessed_x, preprocessed_y, test_size=0.2, train_size=0.8, random_state=42, shuffle=True, stratify=preprocessed_y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "AYHI23NwVDfC"
      },
      "outputs": [],
      "source": [
        "batch_size = 512\n",
        "train_data = TensorDataset(torch.from_numpy(X_train), torch.from_numpy(y_train))\n",
        "train_loader = DataLoader(train_data, batch_size=batch_size, drop_last=True)\n",
        "test_data = TensorDataset(torch.from_numpy(X_test), torch.from_numpy(y_test))\n",
        "test_loader = DataLoader(test_data, batch_size=960, drop_last=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "OVRbTAT8VE-S"
      },
      "outputs": [],
      "source": [
        "device = torch.device(\"cuda\")\n",
        "class GRUNet(nn.Module):\n",
        "  def __init__(self, input_dim, hidden_dim, output_dim, n_layers, drop_prob=0.2):\n",
        "    super(GRUNet, self).__init__()\n",
        "    self.hidden_dim = hidden_dim\n",
        "    self.n_layers = n_layers\n",
        "\n",
        "    self.gru = nn.GRU(input_dim, hidden_dim, n_layers, dropout=drop_prob, batch_first=True)\n",
        "    self.fc = nn.Linear(hidden_dim, output_dim)\n",
        "    self.relu = nn.ReLU()\n",
        "\n",
        "  def forward(self, x, h):\n",
        "    out, h = self.gru(x, h)\n",
        "    out = self.fc(self.relu(out[:, -1]))\n",
        "    return out, h\n",
        "\n",
        "  def init_hidden(self, batch_size):\n",
        "    weight = next(self.parameters()).data\n",
        "    hidden  = weight.new(self.n_layers, batch_size, self.hidden_dim).zero_().to(device)\n",
        "    return hidden\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "4jnPKMKGWmMW"
      },
      "outputs": [],
      "source": [
        "def train(train_loader, learning_rate, hidden_dim=256, epochs=5):\n",
        "  input_dim = next(iter(train_loader))[0].shape[1]\n",
        "  output_dim = 16\n",
        "  n_layers = 2\n",
        "\n",
        "  model = GRUNet(input_dim, hidden_dim, output_dim, n_layers)\n",
        "  model.to(device)\n",
        "\n",
        "  criterion = nn.MSELoss()\n",
        "  optimizer = torch.optim.Adam(model.parameters(), lr = learning_rate)\n",
        "  correct = 0\n",
        "\n",
        "  \n",
        "  print(\"Starting training of GRU Model.....\")\n",
        "  epoch_times = []\n",
        "  losses = []\n",
        "  accuracies = []\n",
        "  test_losses = []\n",
        "  test_accuracies = []\n",
        "\n",
        "\n",
        "  for epoch in range(1, epochs+1):\n",
        "    model.train()\n",
        "    h = model.init_hidden(batch_size)\n",
        "    true_labels = []\n",
        "    predictions = []\n",
        "    \n",
        "    average_loss = 0.0\n",
        "    counter = 0\n",
        "    for batch_idx, (x, label) in enumerate(train_loader):\n",
        "      \n",
        "      x = x.view(-1, 1, 200)\n",
        "      h = h.data \n",
        "\n",
        "      model.zero_grad()\n",
        "\n",
        "      out, h = model(x.to(device).float(), h)\n",
        "      out.reshape(-1, 16)\n",
        "      loss = criterion(out, label.to(device).float())\n",
        "\n",
        "      loss.backward()\n",
        "      optimizer.step()\n",
        "\n",
        "      true_label = label.argmax(dim=1, keepdim=True)\n",
        "      prediction = out.argmax(dim=1, keepdim=True)\n",
        "      \n",
        "      true_labels.append(true_label.to('cpu').numpy()) \n",
        "      predictions.append(prediction.to('cpu').numpy())\n",
        "\n",
        "      #correct = prediction.to(device).eq(true_label.to(device)).sum()\n",
        "      \n",
        "      average_loss += loss.item()\n",
        "\n",
        "      \n",
        "\n",
        "    true_labels = np.vstack(true_labels)\n",
        "    predictions = np.vstack(predictions)\n",
        "    \n",
        "\n",
        "    losses.append(average_loss/len(train_loader))\n",
        "    accuracies.append(accuracy_score(true_labels, predictions))\n",
        "    \n",
        "    \n",
        "    if epoch % 50 == 0:\n",
        "        print(\"Epoch {}/{} Done, Total Loss: {}, Accuracy: {}%\".format(epoch, epochs, average_loss/len(train_loader), accuracy_score(true_labels, predictions) * 100))\n",
        "\n",
        "    test_loss, test_accuracy = test(model, \"cuda\", test_loader, epoch)\n",
        "    \n",
        "    test_losses.append(test_loss)\n",
        "    test_accuracies.append(test_accuracy)\n",
        "    \n",
        "    \n",
        "\n",
        "  return model, losses, accuracies, test_losses, test_accuracies\n",
        "\n",
        "\n",
        "def test(model, device, test_loader, epoch):\n",
        "    '''\n",
        "    Tests the model.\n",
        "    model: The model to train. Should already be in correct device.\n",
        "    device: 'cuda' or 'cpu'.\n",
        "    test_loader: dataloader for test samples.\n",
        "    '''\n",
        "    \n",
        "    # Set model to eval mode to notify all layers.\n",
        "    model.eval()\n",
        "    \n",
        "    losses = []\n",
        "    correct = 0\n",
        "    criterion = nn.MSELoss()\n",
        "    true_labels = []\n",
        "    predictions = []\n",
        "    accuracies = []\n",
        "    \n",
        "    # Set torch.no_grad() to disable gradient computation and backpropagation\n",
        "    with torch.no_grad():\n",
        "        h = model.init_hidden(X_test.shape[0])\n",
        "        for batch_idx, (x, label) in enumerate(test_loader):\n",
        "            x = x.view(-1, 1, 200)\n",
        "            h = h.data\n",
        "            # Predict for data by doing forward pass\n",
        "            out, h = model(x.to(device).float(), h)\n",
        "            \n",
        "            # ======================================================================\n",
        "            # Compute loss based on same criterion as training\n",
        "            # ----------------- YOUR CODE HERE ----------------------\n",
        "            #\n",
        "            # Remove NotImplementedError and assign correct loss function.\n",
        "            # Compute loss based on same criterion as training \n",
        "            loss = criterion(out, label.to(device).float())\n",
        "            \n",
        "            # Append loss to overall test loss\n",
        "            losses.append(loss.item())\n",
        "            \n",
        "            \n",
        "            true_label = label.argmax(dim=1, keepdim=True)\n",
        "            prediction = out.argmax(dim=1, keepdim=True)\n",
        "            \n",
        "            # Count correct predictions overall \n",
        "            true_labels.append(true_label.to('cpu').numpy()) \n",
        "            predictions.append(prediction.to('cpu').numpy())\n",
        "            \n",
        "            \n",
        "    true_labels = np.vstack(true_labels)\n",
        "    predictions = np.vstack(predictions)\n",
        "    \n",
        "    \n",
        "    if epoch % 50 == 0:\n",
        "        print(\"Predicting on test data....\")\n",
        "        print(\"Total Loss: {}, Accuracy: {}%\".format( \n",
        "            losses[0], accuracy_score(true_labels, predictions) * 100))\n",
        "\n",
        "    return losses[0], accuracy_score(true_labels, predictions) \n",
        "  \n",
        "def plot_all_losses(train_l=None, test_l=None, train_ac=None, test_ac=None, title=None):\n",
        "    fig, axes = plt.subplots(nrows=2, ncols=2, figsize=(8, 6), dpi=100)\n",
        "    \n",
        "    if title:\n",
        "        fig.suptitle(title)\n",
        "    if train_l:\n",
        "        axes[0][0].plot(train_l)\n",
        "        axes[0][0].set_title(\"Training Loss\")\n",
        "    if test_l:\n",
        "        axes[0][1].plot(test_l)\n",
        "        axes[0][1].set_title(\"Test Loss\")\n",
        "    if train_ac:\n",
        "        axes[1][0].plot(train_ac)\n",
        "        axes[1][0].set_title(\"Training Accuracy\")\n",
        "    if test_ac:\n",
        "        axes[1][1].plot(test_ac)\n",
        "        axes[1][1].set_title(\"Test Accuracy\")\n",
        "    \n",
        "    plt.tight_layout()\n",
        "       "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PN8R_aGoYTN-",
        "outputId": "bb2be599-716d-45d6-a0cd-9feaf306fd37"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Starting training of GRU Model.....\n",
            "Epoch 50/300 Done, Total Loss: 0.0011256996326015464, Accuracy: 99.94419642857143%\n",
            "Predicting on test data....\n",
            "Total Loss: 0.0017545251175761223, Accuracy: 98.95833333333334%\n",
            "Epoch 100/300 Done, Total Loss: 0.0004112599542297955, Accuracy: 99.97209821428571%\n",
            "Predicting on test data....\n",
            "Total Loss: 0.0012977519072592258, Accuracy: 99.16666666666667%\n",
            "Epoch 150/300 Done, Total Loss: 0.00022543487180623094, Accuracy: 100.0%\n",
            "Predicting on test data....\n",
            "Total Loss: 0.0011571432696655393, Accuracy: 99.0625%\n",
            "Epoch 200/300 Done, Total Loss: 0.0003757913426462827, Accuracy: 99.88839285714286%\n",
            "Predicting on test data....\n",
            "Total Loss: 0.0012797645758837461, Accuracy: 98.85416666666667%\n",
            "Epoch 250/300 Done, Total Loss: 0.0001361283741841492, Accuracy: 100.0%\n",
            "Predicting on test data....\n",
            "Total Loss: 0.0010367638897150755, Accuracy: 99.0625%\n",
            "Epoch 300/300 Done, Total Loss: 0.00030891448841430247, Accuracy: 99.88839285714286%\n",
            "Predicting on test data....\n",
            "Total Loss: 0.0012756427749991417, Accuracy: 98.85416666666667%\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 4 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "lr = 0.001\n",
        "model, train_losses, train_accuracies, test_losses, test_accuracies = train(train_loader, learning_rate=lr, epochs=300)\n",
        "plot_all_losses(train_losses, test_losses, train_accuracies, test_accuracies)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "GRU_Approach.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.5"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}