test_a3tgcn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bde94709-74e4-49b5-9917-0343a3d5410d",
   "metadata": {},
   "source": [
    "## to perform inference using the A3T-GCN model run the cells below and follow the instuctions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "29b0ce5d-c58f-4bdd-8bf5-9a387154e422",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data was normalized via Z-Score method with mean = [53.59967    0.4982691] and std = [20.209862    0.28815305]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from torch_geometric_temporal.dataset import METRLADatasetLoader\n",
    "from torch_geometric_temporal.signal import StaticGraphTemporalSignal\n",
    "loader = METRLADatasetLoader()\n",
    "dataset = loader.get_dataset(num_timesteps_in=12, num_timesteps_out=12)\n",
    "import torch\n",
    "import torch_geometric as tg\n",
    "from torch_geometric.datasets import Planetoid\n",
    "from torch_geometric.nn import Node2Vec\n",
    "from torch.utils.data import DataLoader\n",
    "from torch_geometric_temporal import temporal_signal_split\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "import utils\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from typing import Union, Callable, Optional\n",
    "import torch.optim as optim\n",
    "import time\n",
    "import torch.nn.functional as F\n",
    "from torch_geometric_temporal.nn.recurrent import A3TGCN\n",
    "import a3tgcn_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "a2ef1482-35b7-4026-92db-881f847fceee",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset, test_dataset = temporal_signal_split(dataset, train_ratio=0.8)\n",
    "device = torch.device('cuda') # cuda\n",
    "\n",
    "# Create model and optimizers\n",
    "model = a3tgcn_model.TemporalGNN(node_features=2, periods=12).to(device)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "383a022c-6950-46f7-8213-5901627e4434",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.load_state_dict(torch.load('final_model_a3tgcn.pt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d2f54aa9-7e27-4fcf-9340-87171dd39794",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(model,sensor=100,timestep=1,height=10,width=8):\n",
    "    model.eval()\n",
    "    loss = 0\n",
    "    step = 0\n",
    "    loss_mae = 0\n",
    "    horizon = 1000\n",
    "    mean = 53.59\n",
    "    std = 20.209\n",
    "    # Store for analysis\n",
    "    predictions = []\n",
    "    labels = []\n",
    "\n",
    "    for snapshot in test_dataset[2350:3000]:\n",
    "        x = snapshot.x.to(device)\n",
    "        #snapshot = snapshot.to(device)\n",
    "        edge_indexes = snapshot.edge_index.to(device)\n",
    "        y = snapshot.y.to(device)\n",
    "        # Get predictions\n",
    "        y_hat = model(x, edge_indexes)\n",
    "        # Mean squared error\n",
    "        loss = loss + torch.mean((y_hat-y)**2)\n",
    "        loss_mae += torch.mean(torch.abs(y_hat-y))\n",
    "        # Store for analysis below\n",
    "        labels.append(y)\n",
    "        predictions.append(y_hat)\n",
    "        step += 1\n",
    "        if step > horizon:\n",
    "              break\n",
    "\n",
    "    loss = loss / (step+1)\n",
    "    loss_mae /= (step+1)\n",
    "    loss = loss.item()\n",
    "    loss_mae = loss_mae.item()\n",
    "    preds = np.asarray([pred[sensor][timestep].detach().cpu().numpy() for pred in predictions])\n",
    "    labs  = np.asarray([label[sensor][timestep].cpu().numpy() for label in labels])\n",
    "    unnorm_preds = preds*std+mean\n",
    "    unnorm_labs = labs*20.209+53.59\n",
    "    plt.figure(figsize=(height,width))\n",
    "    plt.plot(unnorm_labs, label=\"true\")\n",
    "    plt.plot(unnorm_preds, label=\"pred\")\n",
    "    plt.xlabel('Timestep')\n",
    "    plt.ylabel('Speed')\n",
    "    plt.legend()\n",
    "    plt.savefig('sensor_eg1.png')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c0a8cc7-2133-4161-924e-de853d0bc14e",
   "metadata": {},
   "source": [
    "### run the cell below with arguments passed for sensor number [0,206], timestep [0,11] , image height and image width. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "204e8c5c-e391-4010-8c94-cdf8333508ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Evaluate function plots predicted speed values against the true speed values using the trained A3TGCN model.\n",
    "'''\n",
    "evaluate(model,sensor=150,timestep=1,height=10,width=8)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dl_project3",
   "language": "python",
   "name": "dl_project3"
  },
  "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}