gru_handler.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "executionInfo": {
     "elapsed": 3880,
     "status": "ok",
     "timestamp": 1672332059330,
     "user": {
      "displayName": "Sabbir Rahman",
      "userId": "01732831767365883220"
     },
     "user_tz": -360
    },
    "id": "8iMWMhNCwRPD"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os\n",
    "import csv\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from sklearn import preprocessing\n",
    "import time\n",
    "from geopy.distance import distance, lonlat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "executionInfo": {
     "elapsed": 399,
     "status": "ok",
     "timestamp": 1672332064792,
     "user": {
      "displayName": "Sabbir Rahman",
      "userId": "01732831767365883220"
     },
     "user_tz": -360
    },
    "id": "0z5w6XVUwRPL"
   },
   "outputs": [],
   "source": [
    "class GRU_Handler:\n",
    "    \"\"\" A helper class to train, test and diagnose the GRU\"\"\"\n",
    "\n",
    "    def __init__(self, model, loss_fn, optimizer, scheduler):\n",
    "        self.model = model\n",
    "        self.loss_fn = loss_fn\n",
    "        self.optimizer = optimizer\n",
    "        self.scheduler = scheduler\n",
    "        self.train_losses = []\n",
    "        self.val_losses = []\n",
    "        \n",
    "    def train(\n",
    "        self,\n",
    "        train_loader,\n",
    "        val_loader=None,\n",
    "        batch_size=100,\n",
    "        n_epochs=15,\n",
    "        input_dim=57,\n",
    "        seq_len=89,\n",
    "        print_step=100\n",
    "    ):\n",
    "        self.train_losses = []\n",
    "        self.val_losses = []\n",
    "        self.distances = []\n",
    "        \n",
    "        start_time = time.time()\n",
    "        \n",
    "        for epoch in range(n_epochs):\n",
    "            train_loss = 0\n",
    "            batch = 0\n",
    "    \n",
    "            for data, target in train_loader:\n",
    "                batch += 1\n",
    "                data = data.view(-1, seq_len, input_dim).requires_grad_().cpu()\n",
    "                target = target.cpu()\n",
    "                \n",
    "                # Clear gradients w.r.t. parameters\n",
    "                self.optimizer.zero_grad()\n",
    "        \n",
    "                # Forward pass to get outputs\n",
    "                y_pred = self.predict(data)\n",
    "                \n",
    "                # Calculate Loss\n",
    "                # Convert y_pred and target to 2D tensors\n",
    "                y_pred = y_pred.view(-1, 2)\n",
    "                target = target.view(-1, 2)\n",
    "\n",
    "                loss = self.loss_fn(y_pred, target)\n",
    "                train_loss += loss.item()\n",
    "                \n",
    "                # Getting gradients w.r.t. parameters\n",
    "                loss.backward()\n",
    "        \n",
    "                # Updating parameters\n",
    "                self.optimizer.step()\n",
    "            \n",
    "            train_loss /= batch\n",
    "#             self.scheduler.step()\n",
    "            self.train_losses.append(train_loss)\n",
    "\n",
    "            self.validation(val_loader)\n",
    "            self.scheduler.step(self.val_losses[-1])\n",
    "\n",
    "            if epoch % print_step == 0:\n",
    "                mean_distance_error = self.distance_error()\n",
    "                self.distances.append(mean_distance_error)\n",
    "                elapsed = time.time() - start_time\n",
    "                start_time = time.time()\n",
    "                print(\n",
    "                    \"Epoch %d Train loss: %.10f. Validation loss: %.10f. Elapsed time: %.5fs. Distance Error: %.5f km\"\n",
    "                    % (epoch + 1, train_loss, self.val_losses[-1], elapsed, mean_distance_error)\n",
    "                )\n",
    "\n",
    "    def predict(self, x_data):\n",
    "        y_pred = self.model(x_data)\n",
    "        return y_pred\n",
    "\n",
    "    def validation(self, val_loader):\n",
    "        if val_loader is None:\n",
    "            return\n",
    "        with torch.no_grad():\n",
    "            val_loss = 0\n",
    "            batch = 0\n",
    "            for data, target in val_loader:\n",
    "                batch += 1\n",
    "                y_pred = self.model(data)\n",
    "                loss = self.loss_fn(y_pred, target)\n",
    "                val_loss += loss.item()\n",
    "            val_loss /= batch\n",
    "            self.val_losses.append(val_loss)\n",
    "\n",
    "    def evaluate(self, test_loader, seq_len=89, feed_forward=False):\n",
    "        with torch.no_grad():\n",
    "            test_loss = 0\n",
    "            batch = 0\n",
    "            actual, predicted = [], []\n",
    "            for data, target in test_loader:\n",
    "                batch += 1\n",
    "                y_pred = self.model(data, feed_forward)\n",
    "                loss = self.loss_fn(y_pred, target)\n",
    "                test_loss += loss.item()\n",
    "                y_pred = y_pred.view(-1, 2)\n",
    "                target = target.view(-1, 2)\n",
    "                y_pred, target = scaler.unnormalize(y_pred.cpu().detach().numpy()), scaler.unnormalize(target.cpu().detach().numpy())\n",
    "                actual.append(target)\n",
    "                predicted.append(y_pred)\n",
    "    \n",
    "            test_loss /= batch\n",
    "            actual = np.concatenate(actual, axis=0)\n",
    "            predicted = np.concatenate(predicted, axis=0)\n",
    "            actual /= 10\n",
    "            predicted /= 10\n",
    "            actual3d = np.reshape(actual, (-1, seq_len, 2))\n",
    "            predicted3d = np.reshape(predicted, (-1, seq_len, 2))\n",
    "            return actual3d, predicted3d, test_loss\n",
    "\n",
    "    def distance_error(self):\n",
    "        with torch.no_grad():\n",
    "            mean_error = 0\n",
    "            batch = 0\n",
    "            for data, target in train_loader:\n",
    "                batch += 1\n",
    "                y_pred = self.model(data, feed_forward=True)\n",
    "                \n",
    "                y_pred = y_pred.view(-1, 2)\n",
    "                target = target.view(-1, 2)\n",
    "                \n",
    "                target_copy = target.detach().clone().cpu().numpy()\n",
    "                y_pred_copy = y_pred.detach().clone().cpu().numpy()\n",
    "\n",
    "                mask = (target_copy[:,0] != 0)\n",
    "                target_copy = target_copy[mask]\n",
    "                y_pred_copy = y_pred_copy[mask]\n",
    "\n",
    "                target_copy, y_pred_copy = scaler.unnormalize(target_copy), scaler.unnormalize(y_pred_copy)\n",
    "\n",
    "                target_copy /= 10\n",
    "                y_pred_copy /= 10\n",
    "\n",
    "                a = pd.DataFrame(target_copy)\n",
    "                b = pd.DataFrame(y_pred_copy, columns=[2, 3])\n",
    "                c = pd.concat([a, b], axis=1)\n",
    "                c['distance'] = c.apply(lambda x : distance(lonlat(x.loc[1], x.loc[0]), lonlat(x.loc[3], x.loc[2])).km, axis=1)\n",
    "\n",
    "                mean_error += np.mean(c['distance'])\n",
    "            \n",
    "            mean_error /= batch\n",
    "            \n",
    "            return mean_error\n",
    "            \n",
    "    def plot_losses(self):\n",
    "        plt.plot(self.train_losses, label=\"Training loss\")\n",
    "        plt.plot(self.val_losses, label=\"Validation loss\")\n",
    "        plt.legend()\n",
    "        plt.title(\"Losses for Training and Validation\")\n",
    "        \n",
    "    def save_model(self, filename):\n",
    "        # Save the Model\n",
    "        torch.save(model.state_dict(), filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aA7pkQx1wRPP"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9oVmGfOkwRPQ"
   },
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}