PretrainedTeacher.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-01-02T19:38:48.014904Z",
     "iopub.status.busy": "2022-01-02T19:38:48.014055Z",
     "iopub.status.idle": "2022-01-02T19:39:28.910347Z",
     "shell.execute_reply": "2022-01-02T19:39:28.909695Z",
     "shell.execute_reply.started": "2022-01-02T18:26:51.63521Z"
    },
    "papermill": {
     "duration": 40.929307,
     "end_time": "2022-01-02T19:39:28.910471",
     "exception": false,
     "start_time": "2022-01-02T19:38:47.981164",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "!python -c \"import torch; print(torch.__version__)\"\n",
    "!python -c \"import torch; print(torch.version.cuda)\"\n",
    "!pip -q install torch-spline-conv==latest+cu102 torch-scatter==latest+cu102 torch-cluster==latest+cu102 torch-sparse==latest+cu102  -f https://pytorch-geometric.com/whl/torch-1.6.0.html\n",
    "\n",
    "!pip install -q git+https://github.com/elmahyai/pytorch_geometric_temporal   # remove after merging"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.020249,
     "end_time": "2022-01-02T19:39:28.951508",
     "exception": false,
     "start_time": "2022-01-02T19:39:28.931259",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "<h1>\n",
    "<center>Attention Based Spatial-Temporal Graph Convolutional Networks\n",
    "for Traffic Flow Forecasting</center>\n",
    "</h1>\n",
    "\n",
    "In this notebook we will dive into attentional temporal graph convolution networks where everything new meets Attention + deep learning time series analysis( temporal data) + Graph convolution all in one thing. This is a rewriting of the code of the paper (Attention Based Spatial-Temporal Graph Convolutional Networks for Traffic Flow Forecasting https://ojs.aaai.org/index.php/AAAI/article/view/3881 ), from which we will include quotes and parts of their code. This notebook uses the data prepared in the previous notebook (Processing traffic data for deep learning projects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "papermill": {
     "duration": 7.749484,
     "end_time": "2022-01-02T19:39:36.721075",
     "exception": false,
     "start_time": "2022-01-02T19:39:28.971591",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA: True cuda:0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from time import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from scipy.sparse.linalg import eigs\n",
    "\n",
    "\n",
    "USE_CUDA = torch.cuda.is_available()\n",
    "DEVICE = torch.device('cuda:0')\n",
    "print(\"CUDA:\", USE_CUDA, DEVICE)\n",
    "\n",
    "from tensorboardX import SummaryWriter\n",
    "sw = SummaryWriter(logdir='./Teacher', flush_secs=5)\n",
    "\n",
    "import math\n",
    "from typing import Optional, List, Union\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.nn import Parameter\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from torch_geometric.data import Data\n",
    "from torch_geometric.typing import OptTensor\n",
    "from torch_geometric.nn.conv import MessagePassing\n",
    "from torch_geometric.transforms import LaplacianLambdaMax\n",
    "from torch_geometric.utils import remove_self_loops, add_self_loops, get_laplacian\n",
    "from torch_geometric.utils import to_dense_adj\n",
    "from torch_scatter import scatter_add"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022775,
     "end_time": "2022-01-02T19:39:36.766042",
     "exception": false,
     "start_time": "2022-01-02T19:39:36.743267",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Loading data  ( The temporal part) \n",
    "As discussed in the previous notebook, the data is splitted as follows:\n",
    "\n",
    "10181 data/target examples will be used as the training set ( 35 days )\n",
    "\n",
    "3394 data/target examples will be used as the validation set (12 days)\n",
    "\n",
    "3394 data/target examples will be used as the testing set (12 days)\n",
    "\n",
    "The shape for each prediction / target hour example is  (12, 307, 3)  , As the data will be loaded in batches of size 32 \n",
    "\n",
    "data, edge hour\n",
    "\n",
    "its shape will be (32, 12, 307, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "papermill": {
     "duration": 0.097144,
     "end_time": "2022-01-02T19:39:36.902795",
     "exception": false,
     "start_time": "2022-01-02T19:39:36.805651",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def load_graphdata_channel1(graph_signal_matrix_filename, num_of_hours, num_of_days, num_of_weeks, batch_size,\n",
    "                            shuffle=True, DEVICE = torch.device('cuda:0')):\n",
    "    '''\n",
    "    :param graph_signal_matrix_filename: str\n",
    "    :param num_of_hours: int\n",
    "    :param num_of_days: int\n",
    "    :param num_of_weeks: int\n",
    "    :param DEVICE:\n",
    "    :param batch_size: int\n",
    "    :return:\n",
    "    three DataLoaders, each dataloader contains:\n",
    "    test_x_tensor: (B, N_nodes, in_feature, T_input)\n",
    "    test_decoder_input_tensor: (B, N_nodes, T_output)\n",
    "    test_target_tensor: (B, N_nodes, T_output)\n",
    "    '''\n",
    "\n",
    "    file = os.path.basename(graph_signal_matrix_filename).split('.')[0]\n",
    "    filename = os.path.join('./data/PEMS04/', file + '_r' + str(num_of_hours) + '_d' + str(num_of_days) + '_w' + str(num_of_weeks)) +'_astcgn'\n",
    "    print('load file:', filename)\n",
    "\n",
    "    file_data = np.load(filename + '.npz')\n",
    "    train_x = file_data['train_x']  # (10181, 307, 3, 12)\n",
    "    train_x = train_x[:, :, 0:1, :]\n",
    "    train_target = file_data['train_target']  # (10181, 307, 12)\n",
    "\n",
    "    val_x = file_data['val_x']\n",
    "    val_x = val_x[:, :, 0:1, :]\n",
    "    val_target = file_data['val_target']\n",
    "\n",
    "    test_x = file_data['test_x']\n",
    "    test_x = test_x[:, :, 0:1, :]\n",
    "    test_target = file_data['test_target']\n",
    "\n",
    "    mean = file_data['mean'][:, :, 0:1, :]  # (1, 1, 3, 1)\n",
    "    std = file_data['std'][:, :, 0:1, :]  # (1, 1, 3, 1)\n",
    "\n",
    "    # ------- train_loader -------\n",
    "    train_x_tensor = torch.from_numpy(train_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)\n",
    "    train_target_tensor = torch.from_numpy(train_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)\n",
    "    train_dataset = torch.utils.data.TensorDataset(train_x_tensor, train_target_tensor)\n",
    "    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle)\n",
    "\n",
    "    # ------- val_loader -------\n",
    "    val_x_tensor = torch.from_numpy(val_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)\n",
    "    val_target_tensor = torch.from_numpy(val_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)\n",
    "    val_dataset = torch.utils.data.TensorDataset(val_x_tensor, val_target_tensor)\n",
    "    val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "    # ------- test_loader -------\n",
    "    test_x_tensor = torch.from_numpy(test_x).type(torch.FloatTensor).to(DEVICE)  # (B, N, F, T)\n",
    "    test_target_tensor = torch.from_numpy(test_target).type(torch.FloatTensor).to(DEVICE)  # (B, N, T)\n",
    "    test_dataset = torch.utils.data.TensorDataset(test_x_tensor, test_target_tensor)\n",
    "    test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n",
    "\n",
    "    # print\n",
    "    print('train:', train_x_tensor.size(), train_target_tensor.size())\n",
    "    print('val:', val_x_tensor.size(), val_target_tensor.size())\n",
    "    print('test:', test_x_tensor.size(), test_target_tensor.size())\n",
    "\n",
    "    return train_loader, train_target_tensor, val_loader, val_target_tensor, test_loader, test_target_tensor, mean, std\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "papermill": {
     "duration": 45.287987,
     "end_time": "2022-01-02T19:40:22.221921",
     "exception": false,
     "start_time": "2022-01-02T19:39:36.933934",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load file: ./data/PEMS04/pems04_r1_d1_w1_astcgn\n",
      "train: torch.Size([13575, 307, 1, 12]) torch.Size([13575, 307, 12])\n",
      "val: torch.Size([1697, 307, 1, 12]) torch.Size([1697, 307, 12])\n",
      "test: torch.Size([1697, 307, 1, 12]) torch.Size([1697, 307, 12])\n"
     ]
    }
   ],
   "source": [
    "graph_signal_matrix_filename = './data/PEMS04/pems04.npz'\n",
    "batch_size = 16\n",
    "num_of_weeks = 1\n",
    "num_of_days = 1\n",
    "num_of_hours = 1\n",
    "\n",
    "train_loader, train_target_tensor, val_loader, val_target_tensor, test_loader, test_target_tensor, _mean, _std = load_graphdata_channel1(\n",
    "    graph_signal_matrix_filename, num_of_hours, num_of_days, num_of_weeks, batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.020698,
     "end_time": "2022-01-02T19:40:22.263490",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.242792",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Loading the graph ( The spatial part) \n",
    "\n",
    "In our case the graph is the Traffic Networks (literally, the network between the detectors (sensors) applied on the traffic networks\n",
    "\n",
    "In our example we have 307 detectors that when connected spatially, give our traffic network under investigation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "papermill": {
     "duration": 0.039407,
     "end_time": "2022-01-02T19:40:22.325118",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.285711",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_adjacency_matrix(distance_df_filename, num_of_vertices, id_filename=None):\n",
    "    '''\n",
    "    Parameters\n",
    "    ----------\n",
    "    distance_df_filename: str, path of the csv file contains edges information\n",
    "    num_of_vertices: int, the number of vertices\n",
    "    Returns\n",
    "    ----------\n",
    "    A: np.ndarray, adjacency matrix\n",
    "    '''\n",
    "    if 'npy' in distance_df_filename:  # false\n",
    "        adj_mx = np.load(distance_df_filename)\n",
    "        return adj_mx, None\n",
    "    else:\n",
    "        \n",
    "        #--------------------------------------------- read from here\n",
    "        import csv\n",
    "        A = np.zeros((int(num_of_vertices), int(num_of_vertices)),dtype=np.float32)\n",
    "        distaneA = np.zeros((int(num_of_vertices), int(num_of_vertices)), dtype=np.float32)\n",
    "\n",
    "        \n",
    "        if id_filename: \n",
    "            with open(id_filename, 'r') as f:\n",
    "                id_dict = {int(i): idx for idx, i in enumerate(f.read().strip().split('\\n'))}  # 把节点id（idx）映射成从0开始的索引\n",
    "\n",
    "            with open(distance_df_filename, 'r') as f:\n",
    "                f.readline()\n",
    "                reader = csv.reader(f)\n",
    "                for row in reader:\n",
    "                    if len(row) != 3:\n",
    "                        continue\n",
    "                    i, j, distance = int(row[0]), int(row[1]), float(row[2])\n",
    "                    A[id_dict[i], id_dict[j]] = 1\n",
    "                    distaneA[id_dict[i], id_dict[j]] = distance\n",
    "            return A, distaneA\n",
    "\n",
    "        else:\n",
    "         #-------------Continue reading\n",
    "            with open(distance_df_filename, 'r') as f:\n",
    "                f.readline()\n",
    "                reader = csv.reader(f)\n",
    "                for row in reader:\n",
    "                    if len(row) != 3:\n",
    "                        continue\n",
    "                    i, j, distance = int(row[0]), int(row[1]), float(row[2])\n",
    "                    A[i, j] = 1\n",
    "                    distaneA[i, j] = distance\n",
    "            return A, distaneA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "papermill": {
     "duration": 0.404466,
     "end_time": "2022-01-02T19:40:22.750585",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.346119",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "id_filename = None\n",
    "adj_filename = './data/PEMS04/PEMS04.csv'\n",
    "num_of_vertices = 307\n",
    "adj_mx, distance_mx = get_adjacency_matrix(adj_filename, num_of_vertices, id_filename) #  adj_mx and distance_mx (307, 307)\n",
    "rows, cols = np.where(adj_mx == 1)\n",
    "edges = zip(rows.tolist(), cols.tolist())\n",
    "gr = nx.Graph()\n",
    "gr.add_edges_from(edges)\n",
    "nx.draw(gr, node_size=3)\n",
    "plt.show()\n",
    "rows, cols = np.where(adj_mx == 1)\n",
    "edges = zip(rows.tolist(), cols.tolist())\n",
    "edge_index_data = torch.LongTensor(np.array([rows, cols])).to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.023484,
     "end_time": "2022-01-02T19:40:22.799782",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.776298",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Making the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022939,
     "end_time": "2022-01-02T19:40:22.846081",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.823142",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Model Layers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021699,
     "end_time": "2022-01-02T19:40:22.890144",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.868445",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Temporal attention layer\n",
    "\n",
    "In the temporal dimension, there exist correlations between the traffic conditions in different time slices, and the correlations are also varying under different situations. Likewise, we use an attention mechanism to adaptively attach different importance to data. \n",
    "\n",
    "<img src=\"https://i.ibb.co/KwXCqJx/temp-attention.png\" width=\"400\">\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021848,
     "end_time": "2022-01-02T19:40:22.935135",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.913287",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "To understand the equation :\n",
    "\n",
    "It learns to attend (focus) on which part of the time segement used as input. In our case we have 12 time points So it will generate 12 by 12 weights. \n",
    "\n",
    "<img src=\"https://i.ibb.co/NZ4fh4k/atten2.jpg\" width=\"400\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.0216,
     "end_time": "2022-01-02T19:40:22.978912",
     "exception": false,
     "start_time": "2022-01-02T19:40:22.957312",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Spatial attention layer\n",
    "\n",
    "In the spatial dimension, the traffic conditions of different locations have influence among each other and the mutual influence is highly dynamic. Here, we use an attention mechanism (Feng et al. 2017) to adaptively capture the dynamic correlations between nodes in the spatial dimension.\n",
    "\n",
    "<img src=\"https://i.ibb.co/PGnj4MR/spatial1.png\" width=\"400\">\n",
    "\n",
    "<img src=\"https://i.ibb.co/G5jkKvr/spatial2.png\" width=\"400\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022913,
     "end_time": "2022-01-02T19:40:23.023944",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.001031",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "The same as with the temporal attention; however, here the attention weights will be used inside a Graph convolution layer\n",
    "\n",
    "\n",
    "\n",
    "<img src=\"https://i.ibb.co/stTfTFM/spat2.jpg\" width=\"400\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.02208,
     "end_time": "2022-01-02T19:40:23.068302",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.046222",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Spectral graph analysis on the spatial part\n",
    "Since the spatial part is represented as a graph, we will apply graph convolution to aggregate messages from neighbor nodes. The type of graph convolution that we are going to use is spectral convolution. \n",
    "\n",
    "* In spectral graph analysis, a graph is represented by its corresponding Laplacian matrix. \n",
    "* The properties of the graph structure can be obtained by analyzing Laplacian matrix and its eigenvalues\n",
    "\n",
    "* Laplacian matrix of a graph is defined as L = D − A, \n",
    "\n",
    "* Its normalized form is L = I − ((1/ sqrt(D) A ( 1/ sqrt(D))  \n",
    "\n",
    "where A is the adjacent matrix, I is a unit matrix, and the degree matrix D (diagnoal diagonal matrix, consisting of node degrees,at the diagonal) \n",
    "\n",
    "The eigenvalue decomposition of the Laplacian matrix is L = U*Λ*(U.transpose()) , where Λ = diag([λ0, ..., λN −1]) is a diagonal matrix, and U is Fourier basis. \n",
    "\n",
    "U is an orthogonal matrix.\n",
    "\n",
    "The graph convolution is a convolution operation implemented by using linear operators that diagonalize in the Fourier domain to replace the classical convolution operator.\n",
    "\n",
    "However, it is expensive to directly perform the eigenvalue decomposition on the Laplacian matrix when the scale of the graph is large. Therefore, Chebyshev polynomials are adopted to solve this problem approximately but efficiently. \n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022081,
     "end_time": "2022-01-02T19:40:23.113054",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.090973",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022314,
     "end_time": "2022-01-02T19:40:23.157536",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.135222",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# The ASTGCN model structure\n",
    "\n",
    "\n",
    "The model is composed of two ASTGCN blocks followed by a final layer\n",
    "\n",
    "Original x (input) is (32, 307, 1, 12) -Block1> (32, 307, 64, 12) -Block2> (32, 307, 64, 12) -permute-> (32, 12, 307,64) \n",
    "            # -final_conv-> (32, 12, 307, 1) -reshape-> (32,307,12) \"The target\"\n",
    "            \n",
    "\n",
    "\n",
    "The model is  the fusion of three independent components with the same structure, which are designed to respectively model the recent, daily-periodic and weekly-periodic dependencies of the historical data. This is discussed in the previous notebook (https://www.kaggle.com/elmahy/processing-traffic-data-for-deep-learning-projects). \n",
    "\n",
    " \n",
    "\n",
    "![astgcn.png](attachment:ec80c00c-6836-4449-85ba-e0b9d174a2f5.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from model.ASTGCN import ASTGCN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "papermill": {
     "duration": 0.04099,
     "end_time": "2022-01-02T19:40:23.220618",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.179628",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# from torch_geometric_temporal.nn.attention import ASTGCN   # For information about the architecture check the source code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.021947,
     "end_time": "2022-01-02T19:40:23.264474",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.242527",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Initialized the ASTGCN model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "papermill": {
     "duration": 0.066646,
     "end_time": "2022-01-02T19:40:23.353254",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.286608",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ASTGCN(\n",
      "  (_blocklist): ModuleList(\n",
      "    (0): ASTGCNBlock(\n",
      "      (_temporal_attention): TemporalAttention()\n",
      "      (_spatial_attention): SpatialAttention()\n",
      "      (_chebconv_attention): ChebConvAttention(1, 64, K=3, normalization=None)\n",
      "      (_time_convolution): Conv2d(64, 64, kernel_size=(1, 3), stride=(1, 1), padding=(0, 1))\n",
      "      (_residual_convolution): Conv2d(1, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (_layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "      (_dropout): Dropout2d(p=0.01, inplace=True)\n",
      "    )\n",
      "    (1): ASTGCNBlock(\n",
      "      (_temporal_attention): TemporalAttention()\n",
      "      (_spatial_attention): SpatialAttention()\n",
      "      (_chebconv_attention): ChebConvAttention(64, 64, K=3, normalization=None)\n",
      "      (_time_convolution): Conv2d(64, 64, kernel_size=(1, 3), stride=(1, 1), padding=(0, 1))\n",
      "      (_residual_convolution): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "      (_layer_norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
      "      (_dropout): Dropout2d(p=0.01, inplace=True)\n",
      "    )\n",
      "  )\n",
      "  (_final_conv): Conv2d(12, 12, kernel_size=(1, 64), stride=(1, 1))\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "nb_block = 2\n",
    "in_channels = 1\n",
    "K = 3\n",
    "nb_chev_filter = 64\n",
    "nb_time_filter = 64\n",
    "time_strides = num_of_hours\n",
    "num_for_predict = 12\n",
    "len_input = 12\n",
    "dropout=0.01\n",
    "#dropout posibilty\n",
    "#L_tilde = scaled_Laplacian(adj_mx)\n",
    "#cheb_polynomials = [torch.from_numpy(i).type(torch.FloatTensor).to(DEVICE) for i in cheb_polynomial(L_tilde, K)]\n",
    "# net = ASTGCN( nb_block, in_channels, K, nb_chev_filter, nb_time_filter, time_strides, num_for_predict, len_input, num_of_vertices).to(DEVICE)\n",
    "\n",
    "Teacher= ASTGCN(nb_block, in_channels, K, nb_chev_filter, nb_time_filter, time_strides, num_for_predict, len_input, num_of_vertices,dropout).to(DEVICE)\n",
    "print(Teacher)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## initialized teacher model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "papermill": {
     "duration": 0.101833,
     "end_time": "2022-01-02T19:40:23.477478",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.375645",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Teacher's state_dict:\n",
      "_blocklist.0._temporal_attention._U1 \t torch.Size([307]) \t cuda:0\n",
      "_blocklist.0._temporal_attention._U2 \t torch.Size([1, 307]) \t cuda:0\n",
      "_blocklist.0._temporal_attention._U3 \t torch.Size([1]) \t cuda:0\n",
      "_blocklist.0._temporal_attention._be \t torch.Size([1, 12, 12]) \t cuda:0\n",
      "_blocklist.0._temporal_attention._Ve \t torch.Size([12, 12]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._W1 \t torch.Size([12]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._W2 \t torch.Size([1, 12]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._W3 \t torch.Size([1]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._bs \t torch.Size([1, 307, 307]) \t cuda:0\n",
      "_blocklist.0._spatial_attention._Vs \t torch.Size([307, 307]) \t cuda:0\n",
      "_blocklist.0._chebconv_attention._weight \t torch.Size([3, 1, 64]) \t cuda:0\n",
      "_blocklist.0._chebconv_attention._bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.0._time_convolution.weight \t torch.Size([64, 64, 1, 3]) \t cuda:0\n",
      "_blocklist.0._time_convolution.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.0._residual_convolution.weight \t torch.Size([64, 1, 1, 1]) \t cuda:0\n",
      "_blocklist.0._residual_convolution.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.0._layer_norm.weight \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.0._layer_norm.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._U1 \t torch.Size([307]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._U2 \t torch.Size([64, 307]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._U3 \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._be \t torch.Size([1, 12, 12]) \t cuda:0\n",
      "_blocklist.1._temporal_attention._Ve \t torch.Size([12, 12]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._W1 \t torch.Size([12]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._W2 \t torch.Size([64, 12]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._W3 \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._bs \t torch.Size([1, 307, 307]) \t cuda:0\n",
      "_blocklist.1._spatial_attention._Vs \t torch.Size([307, 307]) \t cuda:0\n",
      "_blocklist.1._chebconv_attention._weight \t torch.Size([3, 64, 64]) \t cuda:0\n",
      "_blocklist.1._chebconv_attention._bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._time_convolution.weight \t torch.Size([64, 64, 1, 3]) \t cuda:0\n",
      "_blocklist.1._time_convolution.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._residual_convolution.weight \t torch.Size([64, 64, 1, 1]) \t cuda:0\n",
      "_blocklist.1._residual_convolution.bias \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._layer_norm.weight \t torch.Size([64]) \t cuda:0\n",
      "_blocklist.1._layer_norm.bias \t torch.Size([64]) \t cuda:0\n",
      "_final_conv.weight \t torch.Size([12, 12, 1, 64]) \t cuda:0\n",
      "_final_conv.bias \t torch.Size([12]) \t cuda:0\n",
      "Teacher's total params: 450159\n",
      "Optimizer's state_dict:\n",
      "state \t {}\n",
      "param_groups \t [{'lr': 0.001, 'betas': (0.9, 0.999), 'eps': 1e-08, 'weight_decay': 1e-06, 'amsgrad': False, 'maximize': False, 'foreach': None, 'capturable': False, 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37]}]\n"
     ]
    }
   ],
   "source": [
    "#------------------------------------------------------\n",
    "# \n",
    "optimizerTeacher = optim.Adam(Teacher.parameters(), lr=1e-3,weight_decay=1e-6)#l2 regularization applied in weightdecay<0\n",
    "\n",
    "print('Teacher\\'s state_dict:')\n",
    "total_param = 0\n",
    "for param_tensor in Teacher.state_dict():\n",
    "    print(param_tensor, '\\t', Teacher.state_dict()[param_tensor].size(), '\\t', Teacher.state_dict()[param_tensor].device)\n",
    "    total_param += np.prod(Teacher.state_dict()[param_tensor].size())\n",
    "print('Teacher\\'s total params:', total_param)\n",
    "#--------------------------------------------------\n",
    "print('Optimizer\\'s state_dict:')\n",
    "for var_name in optimizerTeacher.state_dict():\n",
    "    print(var_name, '\\t', optimizerTeacher.state_dict()[var_name])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.022902,
     "end_time": "2022-01-02T19:40:23.523502",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.500600",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Defining the loss function\n",
    "\n",
    " 1. masked_mae"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "papermill": {
     "duration": 0.032533,
     "end_time": "2022-01-02T19:40:23.578674",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.546141",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def masked_mae(preds, labels, null_val=np.nan):\n",
    "    if np.isnan(null_val):\n",
    "        mask = ~torch.isnan(labels)\n",
    "    else:\n",
    "        mask = (labels != null_val)\n",
    "    mask = mask.float()\n",
    "    mask /= torch.mean((mask))\n",
    "    mask = torch.where(torch.isnan(mask), torch.zeros_like(mask), mask)\n",
    "    loss = torch.abs(preds - labels)\n",
    "    loss = loss * mask\n",
    "    loss = torch.where(torch.isnan(loss), torch.zeros_like(loss), loss)\n",
    "    return torch.mean(loss)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RMSELoss(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.mse = nn.MSELoss()\n",
    "        \n",
    "    def forward(self,ytil,y):\n",
    "        return torch.sqrt(self.mse(ytil,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "papermill": {
     "duration": 0.032116,
     "end_time": "2022-01-02T19:40:23.633813",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.601697",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "criterionTeacher=RMSELoss().to(DEVICE)\n",
    "criterion_masked = masked_mae\n",
    "loss_function='mae'\n",
    "\n",
    "metric_method = 'mask'\n",
    "missing_value=0.0\n",
    "\n",
    "if loss_function=='masked_mse':\n",
    "    criterion_masked = masked_mse         #nn.MSELoss().to(DEVICE)\n",
    "    masked_flag=1\n",
    "elif loss_function=='masked_mae':\n",
    "    criterion_masked = masked_mae\n",
    "    masked_flag = 1\n",
    "elif loss_function == 'mae':\n",
    "    criterion = nn.L1Loss().to(DEVICE)\n",
    "    masked_flag = 0\n",
    "elif loss_function == 'rmse':\n",
    "    criterion = nn.MSELoss().to(DEVICE)\n",
    "    masked_flag= 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ValLoss=[]\n",
    "TrainLoss=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "papermill": {
     "duration": 0.036068,
     "end_time": "2022-01-02T19:40:23.692677",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.656609",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def compute_val_loss_mstgcn(net, val_loader, criterion,  masked_flag,missing_value,sw, epoch, edge_index_data, limit=None):\n",
    "    '''\n",
    "    for rnn, compute mean loss on validation set\n",
    "    :param net: model\n",
    "    :param val_loader: torch.utils.data.utils.DataLoader\n",
    "    :param criterion: torch.nn.MSELoss\n",
    "    :param sw: tensorboardX.SummaryWriter\n",
    "    :param global_step: int, current global_step\n",
    "    :param limit: int,\n",
    "    :return: val_loss\n",
    "    '''\n",
    "    net.train(False)  # ensure dropout layers are in evaluation mode\n",
    "    with torch.no_grad():\n",
    "        val_loader_length = len(val_loader)  # nb of batch\n",
    "        tmp = []  # batch loss\n",
    "        for batch_index, batch_data in enumerate(val_loader):\n",
    "            encoder_inputs, labels = batch_data\n",
    "            outputs = net(encoder_inputs, edge_index_data)\n",
    "            if masked_flag:\n",
    "                loss = criterion(outputs, labels)\n",
    "            else:\n",
    "                loss = criterion(outputs, labels)\n",
    "            tmp.append(loss.item())\n",
    "            if batch_index % 20 == 0:\n",
    "                print('validation batch %s / %s, loss: %.2f' % (batch_index + 1, val_loader_length, loss.item()))\n",
    "            if (limit is not None) and batch_index >= limit:\n",
    "                break\n",
    "\n",
    "        validation_loss = sum(tmp) / len(tmp)\n",
    "        sw.add_scalar('validation_loss', validation_loss, epoch)\n",
    "        ValLoss.append(validation_loss)\n",
    "        print(\"rata rata val_loss\",validation_loss,\"pada epoch:\",epoch)\n",
    "    return validation_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "papermill": {
     "duration": 0.029214,
     "end_time": "2022-01-02T19:40:23.744592",
     "exception": false,
     "start_time": "2022-01-02T19:40:23.715378",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "global_step = 0\n",
    "best_epoch = 0\n",
    "best_val_loss = np.inf\n",
    "start_time= time()\n",
    "masked_flag = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# pretrain model teacher\n",
    "maxi=[]\n",
    "for epoch in range(40):\n",
    "    params_filename = os.path.join('./Teacher/', 'checkpoint_%s.pth' %epoch)\n",
    "    tmp=[]\n",
    "    Teacher.train()  # ensure dropout layers are in train mode\n",
    "    for batch_index, batch_data in enumerate(train_loader):\n",
    "        encoder_inputs, labels = batch_data   # encoder_inputs torch.Size([32, 307, 1, 12])  label torch.Size([32, 307, 12])\n",
    "        optimizerTeacher.zero_grad()\n",
    "        outputs = Teacher(encoder_inputs, edge_index_data) # torch.Size([32, 307, 12])\n",
    "        loss = criterionTeacher(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizerTeacher.step()\n",
    "        training_loss = loss.item()\n",
    "        tmp.append(training_loss)\n",
    "        global_step += 1\n",
    "        maxi.append(training_loss)\n",
    "        sw.add_scalar('training_loss', training_loss, global_step)\n",
    "        if global_step % 100 == 0:\n",
    "            print('global step: %s, training loss: %.2f, time: %.2fs' % (global_step, training_loss, time() - start_time))\n",
    "    rtloss_t=sum(tmp) / len(tmp)\n",
    "    TrainLoss.append(rtloss_t)\n",
    "    print(\"rata rata Trainingloss\",rtloss_t,\"pada epoch:\",epoch)\n",
    "    val_loss = compute_val_loss_mstgcn(Teacher, val_loader, criterionTeacher, masked_flag, missing_value, sw, epoch,edge_index_data)\n",
    "    if val_loss < best_val_loss:\n",
    "        best_val_loss = val_loss\n",
    "        best_epoch = epoch\n",
    "        checkpoint = {\n",
    "            'epoch': best_epoch,\n",
    "            'model_state': Teacher.state_dict(),\n",
    "            'optimizer_state': optimizerTeacher.state_dict()\n",
    "        }\n",
    "        torch.save(checkpoint, params_filename)\n",
    "        \n",
    "        print('save parameters to file: %s' % params_filename)\n",
    "    \n",
    "          \n",
    "    \n",
    "print('best epoch:', best_epoch)\n",
    "path=os.path.join(\"./Teacher/\",'losshistval.npy')\n",
    "path1=os.path.join(\"./Teacher/\",'losshisttrain.npy')\n",
    "np.save(path,ValLoss)\n",
    "np.save(path1,TrainLoss)\n",
    "n=max(maxi)-min(maxi)\n",
    "print(n)\n",
    "np.save('./Teacher/N',n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epoch=39\n",
    "params_filename = os.path.join('./Teacher/', 'checkpoint_%s.pth' %epoch)\n",
    "checkpoint = {\n",
    "            'epoch': epoch,\n",
    "            'model_state': Teacher.state_dict(),\n",
    "            'optimizer_state': optimizerTeacher.state_dict()\n",
    "        }\n",
    "torch.save(checkpoint, params_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(best_epoch)\n",
    "print(best_val_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "epoch =  13\n",
    "params_filename = os.path.join('./Teacher/', 'checkpoint_%s.pth' % epoch)\n",
    "loaded_checkpoint=torch.load(params_filename)\n",
    "epoch=loaded_checkpoint['epoch']\n",
    "Teacher.load_state_dict(loaded_checkpoint['model_state'])\n",
    "optimizerTeacher.load_state_dict(loaded_checkpoint['optimizer_state'])\n",
    "Teacher.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "print(Teacher.state_dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "for var_name in optimizerTeacher.state_dict():\n",
    "    print(var_name, \"\\t\", optimizerTeacher.state_dict()[var_name])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "papermill": {
     "duration": 7.428189,
     "end_time": "2022-01-02T19:59:17.814238",
     "exception": false,
     "start_time": "2022-01-02T19:59:10.386049",
     "status": "completed"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "from time import process_time as ps\n",
    "start = ps() \n",
    "Teacher.train(False)  # ensure dropout layers are in evaluation mode\n",
    "with torch.no_grad():\n",
    "    test_loader_length = len(test_loader)  # nb of batch\n",
    "    tmp = []  # batch loss\n",
    "    for batch_index, batch_data in enumerate(test_loader):\n",
    "        encoder_inputs, labels = batch_data\n",
    "        outputs = Teacher(encoder_inputs, edge_index_data)\n",
    "        loss = criterionTeacher(outputs, labels)\n",
    "        tmp.append(loss.item())\n",
    "        if batch_index % 1 == 0:\n",
    "            print('test_loss batch %s / %s, loss: %.2f ' % (batch_index + 1, test_loader_length, loss.item()))\n",
    "\n",
    "    \n",
    "    test_loss = sum(tmp) / len(tmp)\n",
    "end = ps()\n",
    "print(\" waktu komputasi : \",end-start, \"second\" + \" loss: \", test_loss)  \n",
    "    \n",
    "# print(test_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_output = outputs[0]  # prediction\n",
    "sample_labels = labels[0] # truth\n",
    "print(sample_output.shape, sample_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchmetrics import MeanAbsolutePercentageError as Mape\n",
    "mape=Mape().to(DEVICE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=0\n",
    "Teacher.train(False)  # ensure dropout layers are in evaluation mode\n",
    "with torch.no_grad():\n",
    "    test_loader_length = len(test_loader)  # nb of\n",
    "    for batch_index, batch_data in enumerate(test_loader):\n",
    "        if accuracy1==accuracy2:\n",
    "            a.sum(1)\n",
    "        else:\n",
    "            a\n",
    "a/test_loader_length    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(30,20),dpi=60)\n",
    "\n",
    "for i in range(1):\n",
    "    new_i = i * 12\n",
    "    plt.plot(range(0+new_i,12+new_i),sample_labels[i].cpu().numpy(), color='blue')\n",
    "    plt.plot(range(0+new_i,12+new_i),sample_output[i].detach().cpu().numpy(), color = 'red')\n",
    "fig.suptitle('Kepadatan Lalu lintas pada detektor No.40030 ', fontsize=20)\n",
    "plt.xlabel('Jam', fontsize=18)\n",
    "plt.ylabel('Kepadatan', fontsize=16)\n",
    "fig.savefig(\"10pred.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total_params = sum(\n",
    "\tparam.numel() for param in Teacher.parameters()\n",
    ")\n",
    "total_params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.046401,
     "end_time": "2022-01-02T19:59:17.907126",
     "exception": false,
     "start_time": "2022-01-02T19:59:17.860725",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Pickig a random time point and visualizing the predictions of the first 50 detectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "papermill": {
     "duration": 0.055894,
     "end_time": "2022-01-02T19:59:18.008925",
     "exception": false,
     "start_time": "2022-01-02T19:59:17.953031",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "sample_output = outputs[0]  # prediction\n",
    "sample_labels = labels[0] # truth\n",
    "print(sample_output.shape, sample_labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "papermill": {
     "duration": 0.335176,
     "end_time": "2022-01-02T19:59:18.390710",
     "exception": false,
     "start_time": "2022-01-02T19:59:18.055534",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from matplotlib.pyplot import figure\n",
    "\n",
    "figure(figsize=(3,4), dpi=80)\n",
    "for i in range(50):\n",
    "    new_i = i * 12\n",
    "    plt.plot(range(0+new_i,12+new_i),sample_output[i].detach().cpu().numpy(), color = 'red')\n",
    "    plt.plot(range(0+new_i,12+new_i),sample_labels[i].cpu().numpy(), color='blue')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "papermill": {
     "duration": 0.049622,
     "end_time": "2022-01-02T19:59:18.489086",
     "exception": false,
     "start_time": "2022-01-02T19:59:18.439464",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(figsize=(80,6),dpi=80)\n",
    "\n",
    "for i in range(50):\n",
    "    new_i = i * 12\n",
    "    plt.plot(range(0+new_i,12+new_i),sample_output[i].detach().cpu().numpy(), color = 'red')\n",
    "    plt.plot(range(0+new_i,12+new_i),sample_labels[i].cpu().numpy(), color='blue')\n",
    "ax.set(title=\"prediction and target\",xlabel=\"location id\",ylabel=\"pediction\")\n",
    "fig.savefig(\"10pred.png\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # test_x_tensor: (B, N_nodes, in_feature, T_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "for batch_index, batch_data in enumerate(train_loader):\n",
    "        encoder_inputs, labels = batch_data\n",
    "        print(encoder_inputs[0])\n",
    "        print(labels[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder_inputs[0].size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoder_inputs[:1,:4,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "edge_index_data.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "edge_index_data.size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels[0,0]"
   ]
  }
 ],
 "metadata": {
  "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.10.8"
  },
  "papermill": {
   "duration": 1234.454996,
   "end_time": "2022-01-02T19:59:18.744009",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2022-01-02T19:38:44.289013",
   "version": "2.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}