transformer+autoregression+conv.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "aa9bdfaf",
   "metadata": {},
   "source": [
    "### Acknowledgement\n",
    "\n",
    "Upon building the final model we use for the result of the competition, we consulted [TensorFlow tutorials](https://www.tensorflow.org/text/tutorials/transformer) and PyTorch tutorials with practical examples such as [Language Modeling](https://pytorch.org/tutorials/beginner/transformer_tutorial.html) and [Language Translation](https://pytorch.org/tutorials/beginner/translation_transformer.html.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8a3d7322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import os, os.path \n",
    "import numpy as np\n",
    "import pickle\n",
    "from glob import glob\n",
    "import pandas as pd\n",
    "import torch\n",
    "from torch import nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "from tqdm.notebook import tqdm\n",
    "import math\n",
    "import random\n",
    "\n",
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "\"\"\"\n",
    "    number of trajectories in each city\n",
    "    # austin --  train: 43041 test: 6325 \n",
    "    # miami -- train: 55029 test:7971\n",
    "    # pittsburgh -- train: 43544 test: 6361\n",
    "    # dearborn -- train: 24465 test: 3671\n",
    "    # washington-dc -- train: 25744 test: 3829\n",
    "    # palo-alto -- train:  11993 test:1686\n",
    "\n",
    "    trajectories sampled at 10HZ rate, input 5 seconds, output 6 seconds\n",
    "\"\"\"\n",
    "ROOT_PATH = \"./\"\n",
    "cities = [\"austin\", \"miami\", \"pittsburgh\", \"dearborn\", \"washington-dc\", \"palo-alto\"]\n",
    "splits = [\"train\", \"test\"]\n",
    "\n",
    "DEVICE = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
    "print(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "066e3292",
   "metadata": {},
   "source": [
    "## Create a Torch.Dataset class for the training dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e6db7f9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rotation_matrix(inputs, device=DEVICE): \n",
    "    vectors = inputs[:, 1, :]\n",
    "    matrices = torch.zeros((vectors.shape[0], 2, 2)).to(device).float()\n",
    "    for i in range(vectors.shape[0]):\n",
    "        matrices[i] = rotate_matrix(vectors[i]).to(device)\n",
    "    return matrices\n",
    "\n",
    "def rotate_matrix(v, device=DEVICE):\n",
    "    \"\"\"\n",
    "    Rotates the vector into the (1, 1) direction\n",
    "    \"\"\"    \n",
    "    a, b = v\n",
    "    norm = torch.linalg.norm(v)\n",
    "    if norm == 0:\n",
    "        Q1 = torch.eye(2).to(device)\n",
    "    else:\n",
    "        Q1 = torch.tensor([[a, b], [-b, a]]).to(device) / torch.linalg.norm(v)\n",
    "    Q2 = torch.tensor([[1, -1], [1, 1]]).to(device) / torch.sqrt(torch.tensor(2).to(device))\n",
    "    \n",
    "    return Q2.float() @ Q1.float()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "43f963d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# def normalize(A, Q, T):\n",
    "#     return torch.matmul((A - T.unsqueeze(1)), Q.T)\n",
    "\n",
    "def revert(A, Q, T):\n",
    "    return torch.matmul(A, Q) + T.unsqueeze(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "85496736",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ArgoverseDataset(Dataset):\n",
    "    \"\"\"Dataset class for Argoverse\"\"\"\n",
    "    def __init__(self, city: str, split:str, transform=False, normalize=False):\n",
    "        super(ArgoverseDataset, self).__init__()\n",
    "        self.transform = transform\n",
    "        self.normalize = normalize\n",
    "        self.split = split\n",
    "        self.inputs, self.outputs = self.get_city_trajectories(city=city, split=split)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.inputs)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        if self.split == 'train':       \n",
    "            data = (self.inputs[idx], self.outputs[idx])\n",
    "            return data     \n",
    "        return self.inputs[idx]\n",
    "    \n",
    "    def get_city_trajectories(self, city=\"palo-alto\", split=\"train\", device=DEVICE):\n",
    "        assert city in cities and split in splits\n",
    "\n",
    "        # get input\n",
    "        f_in = ROOT_PATH + split + \"/\" + city + \"_inputs\"\n",
    "        inputs = pickle.load(open(f_in, \"rb\"))\n",
    "        inputs = torch.tensor(inputs).to(device).float()\n",
    "\n",
    "        # store input starting positions and rotation matrix\n",
    "        self.T0 = inputs[:, 0, :].clone()\n",
    "\n",
    "        # normalize inputs\n",
    "        if self.normalize:     \n",
    "            # translation\n",
    "            inputs = inputs - self.T0.unsqueeze(1)\n",
    "            \n",
    "            # rotation\n",
    "            self.Q0 = get_rotation_matrix(inputs)\n",
    "            inputs = torch.matmul(inputs, self.Q0.transpose(1, 2))\n",
    "\n",
    "        # get outputs\n",
    "        outputs = None\n",
    "        if split == \"train\":\n",
    "            # get outputs\n",
    "            f_out = ROOT_PATH + split + \"/\" + city + \"_outputs\"\n",
    "            outputs = pickle.load(open(f_out, \"rb\"))\n",
    "            outputs = torch.tensor(outputs).to(device).float()\n",
    "            \n",
    "            # normalize outputs\n",
    "            if self.normalize:      \n",
    "                # translation\n",
    "                outputs = outputs - self.T0.unsqueeze(1)\n",
    "                    \n",
    "                # rotation\n",
    "                outputs = torch.matmul(outputs, self.Q0.transpose(1, 2))\n",
    "        return inputs, outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b30b1b28",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11993"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# intialize a dataset\n",
    "city = 'palo-alto' \n",
    "split = 'train' #'test' #'train'\n",
    "train_dataset = ArgoverseDataset(city = city, split = split, transform=False, normalize=True)\n",
    "original_dataset = ArgoverseDataset(city = city, split = split, transform=False, normalize=False)\n",
    "\n",
    "len(train_dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7877ed6",
   "metadata": {},
   "source": [
    "## Create a DataLoader class for training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "97632d1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2998"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "batch_sz = 4  # batch size \n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_sz, drop_last=True)\n",
    "original_loader = DataLoader(original_dataset, batch_size=batch_sz, drop_last=True)\n",
    "train_single_loader = DataLoader(train_dataset, batch_size=1, drop_last=True)\n",
    "original_single_loader = DataLoader(original_dataset, batch_size=1, drop_last=True)\n",
    "\n",
    "len(train_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddbfef58",
   "metadata": {},
   "source": [
    "## Sample a batch of data and visualize "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9ea7e317",
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_sample_batch(sample_batch):\n",
    "    \"\"\"visualize the trajectory for a batch of samples\"\"\"\n",
    "    inp, out = sample_batch\n",
    "    inp = inp.cpu().detach().numpy()\n",
    "    out = out.cpu().detach().numpy()\n",
    "    batch_sz, agent_sz = inp.shape[0], inp.shape[1]\n",
    "    \n",
    "    if batch_sz > 1:\n",
    "        fig, axs = plt.subplots(1, batch_sz, figsize=(15, 3), facecolor='w', edgecolor='k')\n",
    "        fig.subplots_adjust(hspace=.2, wspace=.5)\n",
    "        axs = axs.ravel()   \n",
    "        for i in range(4):\n",
    "            axs[i].xaxis.set_ticks([inp[i,0,0],\n",
    "                                       inp[i,-1,0], out[i,-1,0]])\n",
    "            axs[i].yaxis.set_ticks([inp[i,0,1],\n",
    "                                       inp[i,-1,1], out[i,-1,1]])\n",
    "\n",
    "            # first two feature dimensions are (x,y) positions\n",
    "            axs[i].scatter(inp[i,:,0], inp[i,:,1])\n",
    "            axs[i].scatter(out[i,:,0], out[i,:,1])\n",
    "    else:\n",
    "        plt.scatter(inp[0,:,0], inp[0,:,1])\n",
    "        plt.scatter(out[0,:,0], out[0,:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8b1a2362",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x216 with 4 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 193,
       "width": 888
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i_batch, data in enumerate(train_loader):\n",
    "    if i_batch < 20:\n",
    "        continue\n",
    "    show_sample_batch(data)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "604ee1e4",
   "metadata": {},
   "source": [
    "## Transformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "d88f6adc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransAutoReg(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        batch_size,\n",
    "        model_dim,\n",
    "        conv_depth=16,\n",
    "        kernel_size=4,\n",
    "        conv_padding=3,\n",
    "        n_heads=8, \n",
    "        linear_dim=256, \n",
    "        dropout_rate=0.1, \n",
    "        encoder_layers=1,\n",
    "        input_dim=2,\n",
    "        regress_steps=4\n",
    "    ):\n",
    "        super(TransAutoReg, self).__init__()\n",
    "        self.batch_size = batch_size\n",
    "        self.model_dim = model_dim\n",
    "        self.conv_depth = conv_depth\n",
    "        self.kernel_size = kernel_size\n",
    "        self.conv_padding = conv_padding\n",
    "        self.n_heads = n_heads\n",
    "        self.linear_dim = linear_dim\n",
    "        self.dropout_rate = dropout_rate\n",
    "        self.encoder_layers = encoder_layers\n",
    "        self.input_dim = input_dim\n",
    "        self.regress_steps = regress_steps\n",
    "        self.input_length = 50\n",
    "        self.output_length = 60 // regress_steps\n",
    "        \n",
    "        # compute convolution output size\n",
    "        size_1 = self.input_length + 2 * conv_padding - kernel_size + 1\n",
    "        size_2 = size_1 + 2 * conv_padding - kernel_size + 1\n",
    "        self.conv_outsize = (size_2 - kernel_size) // 2 + 1\n",
    "        \n",
    "        # input convolution\n",
    "        self.input_convolution = nn.Sequential(\n",
    "            nn.Conv1d(input_dim, conv_depth, kernel_size=kernel_size, padding=conv_padding),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.Conv1d(conv_depth, conv_depth, kernel_size=kernel_size, padding=conv_padding),\n",
    "            nn.LeakyReLU(),\n",
    "            nn.MaxPool1d(kernel_size=kernel_size, stride=2, padding=0)\n",
    "        )  \n",
    "        self.input_projection = nn.Linear(conv_depth, model_dim)\n",
    "        \n",
    "        # encoder\n",
    "        encoder = nn.TransformerEncoderLayer(\n",
    "            d_model=model_dim, \n",
    "            nhead=n_heads, \n",
    "            dim_feedforward=linear_dim, \n",
    "            dropout=dropout_rate, \n",
    "            batch_first=True,\n",
    "            device=DEVICE\n",
    "        )\n",
    "        self.encoder = nn.TransformerEncoder(encoder, num_layers=encoder_layers, norm=None)\n",
    "        \n",
    "        # decoder\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.Linear(self.conv_outsize * model_dim, linear_dim),\n",
    "            nn.LeakyReLU(), \n",
    "            nn.Linear(linear_dim, linear_dim),\n",
    "            nn.LeakyReLU(), \n",
    "            nn.Linear(linear_dim, self.output_length * input_dim)\n",
    "        )\n",
    "    \n",
    "    def get_angles(self, pos, i, D):\n",
    "        angle_rates = 1 / np.power(10000, (2 * (i // 2)) / np.float32(D))\n",
    "        return pos * angle_rates\n",
    "\n",
    "    def positional_encoding(self, D, position=110, dim=3, device=DEVICE):\n",
    "        angle_rads = self.get_angles(np.arange(position)[:, np.newaxis],\n",
    "                                np.arange(D)[np.newaxis, :],\n",
    "                                D)\n",
    "        # apply sin to even indices in the array; 2i\n",
    "        angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])\n",
    "        # apply cos to odd indices in the array; 2i+1\n",
    "        angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])\n",
    "        if dim == 3:\n",
    "            pos_encoding = angle_rads[np.newaxis, ...]\n",
    "        elif dim == 4:\n",
    "            pos_encoding = angle_rads[np.newaxis,np.newaxis,  ...]\n",
    "        return torch.tensor(pos_encoding, device=device)\n",
    "    \n",
    "    def one_pass(self, inputs):\n",
    "        input_pos = self.input_convolution(inputs.transpose(1, 2))\n",
    "        input_pos = self.input_projection(input_pos.transpose(1, 2))\n",
    "        input_pos += self.positional_encoding(self.model_dim)[:, :self.conv_outsize, :]\n",
    "        memory = self.encoder(input_pos).reshape(self.batch_size, -1)\n",
    "        out = self.decoder(memory)\n",
    "        return out.reshape(self.batch_size, self.output_length, self.input_dim)\n",
    "    \n",
    "    def forward(self, inputs):\n",
    "        # predict first roll\n",
    "        step_pred = self.one_pass(inputs)\n",
    "        inputs = torch.cat((\n",
    "            inputs,\n",
    "            step_pred\n",
    "        ), dim=1)\n",
    "        \n",
    "        for step in range(1, self.regress_steps):\n",
    "            # take chunk\n",
    "            train_inputs = inputs[:, step * self.output_length:, :]\n",
    "            \n",
    "            # normalize\n",
    "            T_t = train_inputs[:, 0, :].clone()\n",
    "            train_inputs = train_inputs - T_t.unsqueeze(1)\n",
    "            \n",
    "            Q_t = get_rotation_matrix(train_inputs)\n",
    "            train_inputs = torch.matmul(train_inputs, Q_t.transpose(1, 2))\n",
    "            \n",
    "            # autoregress\n",
    "            step_pred = self.one_pass(train_inputs)\n",
    "            \n",
    "            # revert to original scale\n",
    "            step_pred = revert(step_pred, Q_t, T_t)\n",
    "            \n",
    "            # add new predictions\n",
    "            inputs = torch.cat((\n",
    "                inputs,\n",
    "                step_pred\n",
    "            ), dim=1)\n",
    "            \n",
    "        return inputs[:, self.input_length:, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57610ecc",
   "metadata": {},
   "source": [
    "## Train the Transformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "d033cf67",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(\n",
    "    batch_size, \n",
    "    city, \n",
    "    model_dim,\n",
    "    conv_depth,\n",
    "    kernel_size,\n",
    "    conv_padding,\n",
    "    n_heads,\n",
    "    linear_dim,\n",
    "    dropout_rate,\n",
    "    encoder_layers,\n",
    "    regress_steps,\n",
    "    num_iters,\n",
    "    learning_rate,\n",
    "    factor,\n",
    "    patience,\n",
    "    device=DEVICE\n",
    "):    \n",
    "    # Create the training/validation set\n",
    "    train_dataset = ArgoverseDataset(city=city, split='train', transform=False, normalize=True)\n",
    "    train_sz = int(len(train_dataset) * 0.9)\n",
    "    val_sz = len(train_dataset) - train_sz\n",
    "    train_loader, val_loader = torch.utils.data.random_split(train_dataset, [train_sz, val_sz])\n",
    "    train_loader = DataLoader(train_loader, batch_size=batch_size, drop_last=True)\n",
    "    val_loader = DataLoader(val_loader, batch_size=batch_size, drop_last=True)\n",
    "    \n",
    "    # Initialize the model/optimizer/loss function\n",
    "    model = TransAutoReg(\n",
    "        batch_size=batch_size,\n",
    "        model_dim=model_dim,\n",
    "        conv_depth=conv_depth,\n",
    "        kernel_size=kernel_size,\n",
    "        conv_padding=conv_padding,\n",
    "        n_heads=n_heads, \n",
    "        linear_dim=linear_dim, \n",
    "        dropout_rate=dropout_rate, \n",
    "        encoder_layers=encoder_layers,\n",
    "        regress_steps=regress_steps\n",
    "    ).to(device)\n",
    "\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) \n",
    "    loss_function = nn.MSELoss()\n",
    "    scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=factor, patience=patience, verbose=True) \n",
    "    \n",
    "    # Print out how many parameters to train\n",
    "    param_sizes = [p.numel() for p in model.parameters()]\n",
    "    print(f\"number of weight/biases matrices: {len(param_sizes)} \"\n",
    "          f\"for a total of {np.sum(param_sizes)} parameters \")\n",
    "    \n",
    "    avg_train_loss, avg_val_loss = [], []\n",
    "    best_val_score = float('inf')\n",
    "    \n",
    "    # Start training\n",
    "    for epoch in tqdm(list(range(num_iters))):\n",
    "        print(f'Epoch {epoch+1}')\n",
    "        print('Training & Validating ', end='')\n",
    "        \n",
    "        train_loss, val_loss = [], []\n",
    "        \n",
    "        # Training set\n",
    "        for batches, (X, y) in enumerate(train_loader):\n",
    "            X = X.to(device).float()\n",
    "            y = y.to(device).float()\n",
    "            \n",
    "            # Track progress\n",
    "            if (batches + 1) % 20 == 0:\n",
    "                print('-', end='')\n",
    "            \n",
    "            # Forward pass\n",
    "            optimizer.zero_grad()\n",
    "            out = model(X)\n",
    "            \n",
    "            # Backpropagation\n",
    "            loss = loss_function(out, y)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            train_loss.append(loss.item())\n",
    "            \n",
    "            \n",
    "        print()\n",
    "        avg_train = np.mean(train_loss)\n",
    "        avg_train_loss.append(avg_train)\n",
    "        \n",
    "\n",
    "        # Evaluate on val set\n",
    "        with torch.no_grad():\n",
    "            for X, y in val_loader:\n",
    "                X = X.to(device).float()\n",
    "                y = y.to(device).float()\n",
    "                \n",
    "                out = model(X)\n",
    "                loss = loss_function(out, y)\n",
    "                val_loss.append(loss.item())\n",
    "                \n",
    "            avg_val = np.mean(val_loss)\n",
    "            avg_val_loss.append(avg_val)\n",
    "\n",
    "        print(f'- Training Loss: {avg_train}')\n",
    "        print(f'- Validation Loss: {avg_val}')\n",
    "        print()\n",
    "        \n",
    "        scheduler.step(avg_val)\n",
    "        \n",
    "        # save better model\n",
    "        if avg_val < best_val_score:\n",
    "            best_val_score = avg_val\n",
    "            torch.save(model, f'TF_Auto_Conv_{city}_0528.pt')\n",
    "        \n",
    "    return model, (avg_train_loss, avg_val_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "3f29b3a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_loss(start_from, city, split, losses):\n",
    "\n",
    "    avg_train_loss, avg_val_loss = losses\n",
    "    plt.plot(np.sqrt(avg_train_loss[start_from:]), label='train_loss')\n",
    "    plt.plot(np.sqrt(avg_val_loss[start_from:]), label='validation_loss')\n",
    "    plt.title(f'{city} RMSE {split} Loss vs. Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "59a82219",
   "metadata": {},
   "outputs": [],
   "source": [
    "def vis_results(city, split, batch_size, model, idx, device=DEVICE):\n",
    "    train_dataset = ArgoverseDataset(city = city, split = split, transform=False, normalize=True)\n",
    "    train_loader = DataLoader(train_dataset, batch_size=batch_size)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for X, y in train_loader:\n",
    "            X = X.to(device).float()\n",
    "            y = y.to(device).float()\n",
    "\n",
    "            out = model(X).reshape(batch_size, -1, 2)\n",
    "            break\n",
    "    \n",
    "    X = X.cpu()\n",
    "    y = y.cpu()\n",
    "    out = out.cpu()\n",
    "    \n",
    "    Q = train_dataset.Q0[idx].cpu()\n",
    "    T = train_dataset.T0[idx].cpu()\n",
    "    X = X[idx] @ Q + T\n",
    "    y = y[idx] @ Q + T\n",
    "    out = out[idx] @ Q + T\n",
    "    \n",
    "    plt.scatter(X[:, 0], X[:, 1], label='seed')\n",
    "    plt.scatter(y[:, 0], y[:, 1], label='ground truth')\n",
    "    plt.scatter(out[:, 0], out[:, 1], label='prediction')\n",
    "    plt.title(f'Random Sample From {city}_{split} Projectile Visualization')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "66b3efc2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def vis_test(city, split, batch_sz, model, idx, norm_viz=True):\n",
    "    '''\n",
    "    This is the last batch, which is usually not complete and need to fill with 0s.\n",
    "    Check if I convert the prediction back correctly or not\n",
    "    '''\n",
    "    \n",
    "    # Create the dataset for testing\n",
    "    test_dataset = ArgoverseDataset(city = city, split = split,\n",
    "                                    transform=False, normalized=True)\n",
    "        \n",
    "    test_loader = DataLoader(test_dataset, batch_size=batch_sz)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for X in test_loader:\n",
    "            if len(X) == batch_sz:\n",
    "                continue\n",
    "            print(len(X))\n",
    "            to_fill = np.zeros([batch_sz-len(X), 50, 2])\n",
    "            X = torch.from_numpy(np.append(X, to_fill, axis=0)).float()\n",
    "            X = X.to(device).float()\n",
    "            S = X.shape[1]\n",
    "            mask = create_look_ahead_mask(S)\n",
    "\n",
    "            output = model(X, mask)[0].reshape(batch_size, -1, 2)\n",
    "\n",
    "            X = X.cpu()\n",
    "            output = output.cpu()\n",
    "\n",
    "            if norm_viz:\n",
    "                plt.scatter(X[idx, :, 0], X[idx, :, 1], label='input')\n",
    "                plt.scatter(output[idx, :, 0], output[idx, :, 1], label='pred')\n",
    "                plt.legend()\n",
    "                plt.show()\n",
    "            else:\n",
    "                rotation =  test_dataset.rotate_matrix[-1].T\n",
    "                X[idx] = X[idx] @ np.linalg.inv(rotation)\n",
    "                X[idx] = X[idx] + test_dataset.start_pos[-1, : ]\n",
    "                output[idx] = output[idx] @ np.linalg.inv(rotation)\n",
    "                output[idx] = output[idx] + test_dataset.start_pos[-1, : ]\n",
    "\n",
    "                plt.scatter(X[idx, :, 0], X[idx, :, 1], label='input')\n",
    "                plt.scatter(output[idx, :, 0], output[idx, :, 1], label='pred')\n",
    "                plt.legend()\n",
    "                plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "6b019b96",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_pred(test_loader, batch_sz, model):\n",
    "    '''\n",
    "    Remember to use test_dataset stats, NOT train_dataset\n",
    "    '''\n",
    "    count_row = 0\n",
    "    out = []\n",
    "\n",
    "    for X in test_loader:\n",
    "        if len(X) != batch_sz:\n",
    "            print(len(X))\n",
    "            to_fill = np.zeros([batch_sz-len(X), 50, 2])\n",
    "            X = torch.from_numpy(np.append(X, to_fill, axis=0))\n",
    "            \n",
    "#             a = test_dataset.rotate_matrix[-1].T\n",
    "#             temp = X[20]@np.linalg.inv(a) + test_dataset.start_pos[-1]\n",
    "#             plt.scatter(temp[:, 0], temp[:, 1], label='input')\n",
    "\n",
    "        X = X.to(device).float()\n",
    "    \n",
    "        S = X.shape[1]\n",
    "        mask = create_look_ahead_mask(S)\n",
    "\n",
    "        pred = model(X, mask)[0].reshape(batch_size, -1, 2).cpu().detach().numpy()\n",
    "\n",
    "        for i in range(batch_sz):\n",
    "            if count_row >= len(test_dataset):\n",
    "                break\n",
    "                \n",
    "#             if count_row == (len(test_dataset) - 1):\n",
    "#                 plt.scatter(X[i, :, 0], X[i, :, 1], label='input')\n",
    "#                 plt.scatter(pred[i, :, 0], pred[i, :, 1], label='pred')\n",
    "#                 plt.legend()\n",
    "#                 plt.show()\n",
    "\n",
    "            rotation =  test_dataset.rotate_matrix[count_row].T\n",
    "            pred[i] = pred[i] @ np.linalg.inv(rotation)\n",
    "            pred[i] = pred[i] + test_dataset.start_pos[count_row, : ]\n",
    "\n",
    "    #         print(pred[i, 0, :])\n",
    "                \n",
    "            out.append(pred[i])\n",
    "            count_row += 1 \n",
    "            \n",
    "    #         print(count_row)\n",
    "    #         print(pred[0, :5, :])\n",
    "\n",
    "    out = np.array(out).reshape(len(test_dataset), -1)\n",
    "\n",
    "    return out\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b100eb9b",
   "metadata": {},
   "source": [
    "### palo-alto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "cb032509",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of weight/biases matrices: 36 for a total of 21336 parameters \n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "93aac0839c524c719399355243fe4aa4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 224.36623596508355\n",
      "- Validation Loss: 98.0727215328732\n",
      "\n",
      "Epoch 2\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 89.27125832305818\n",
      "- Validation Loss: 87.5918837882377\n",
      "\n",
      "Epoch 3\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 82.28231347420802\n",
      "- Validation Loss: 76.92877558115366\n",
      "\n",
      "Epoch 4\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 73.22441065417553\n",
      "- Validation Loss: 74.11217735909126\n",
      "\n",
      "Epoch 5\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 70.37455608017014\n",
      "- Validation Loss: 66.54308525291648\n",
      "\n",
      "Epoch 6\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 66.7913030856441\n",
      "- Validation Loss: 68.57244682312012\n",
      "\n",
      "Epoch 7\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 64.7745619471066\n",
      "- Validation Loss: 64.93736102129962\n",
      "\n",
      "Epoch 8\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 60.60189058094421\n",
      "- Validation Loss: 57.811628187024915\n",
      "\n",
      "Epoch 9\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 52.221167725696056\n",
      "- Validation Loss: 59.927738292797194\n",
      "\n",
      "Epoch 10\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 43.35864141220863\n",
      "- Validation Loss: 43.52798642338933\n",
      "\n",
      "Epoch 11\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 39.28100692907498\n",
      "- Validation Loss: 42.09019681569692\n",
      "\n",
      "Epoch 12\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 35.815923764373146\n",
      "- Validation Loss: 38.09921491468275\n",
      "\n",
      "Epoch 13\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 34.32098643928324\n",
      "- Validation Loss: 34.14766234320563\n",
      "\n",
      "Epoch 14\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 33.44793664383251\n",
      "- Validation Loss: 37.8257207097234\n",
      "\n",
      "Epoch 15\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 32.4302199162786\n",
      "- Validation Loss: 36.30917167663574\n",
      "\n",
      "Epoch 16\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 32.14335002955768\n",
      "- Validation Loss: 33.18618496044262\n",
      "\n",
      "Epoch 17\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 30.371532779772842\n",
      "- Validation Loss: 30.768364571236276\n",
      "\n",
      "Epoch 18\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 30.630606504151658\n",
      "- Validation Loss: 30.465459565858584\n",
      "\n",
      "Epoch 19\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 29.961560215369882\n",
      "- Validation Loss: 38.647833489082956\n",
      "\n",
      "Epoch 20\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 29.771656574056834\n",
      "- Validation Loss: 29.51348572808343\n",
      "\n",
      "Epoch 21\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 29.109846072663892\n",
      "- Validation Loss: 29.540430558694375\n",
      "\n",
      "Epoch 22\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 29.000459668190615\n",
      "- Validation Loss: 29.57597201579326\n",
      "\n",
      "Epoch 23\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 28.743442125065744\n",
      "- Validation Loss: 32.39050282658757\n",
      "\n",
      "Epoch    23: reducing learning rate of group 0 to 1.0000e-03.\n",
      "Epoch 24\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 25.003998235708174\n",
      "- Validation Loss: 26.24611186981201\n",
      "\n",
      "Epoch 25\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 24.321178308934062\n",
      "- Validation Loss: 25.57760883021999\n",
      "\n",
      "Epoch 26\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 24.65789175175064\n",
      "- Validation Loss: 25.694295625428897\n",
      "\n",
      "Epoch 27\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 24.216889313491233\n",
      "- Validation Loss: 24.397536612845755\n",
      "\n",
      "Epoch 28\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 24.348445487659127\n",
      "- Validation Loss: 25.30557137566644\n",
      "\n",
      "Epoch 29\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 23.944338917378502\n",
      "- Validation Loss: 25.68460358800115\n",
      "\n",
      "Epoch 30\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 24.06445785941285\n",
      "- Validation Loss: 25.050780992250186\n",
      "\n",
      "Epoch    30: reducing learning rate of group 0 to 5.0000e-04.\n",
      "Epoch 31\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 22.516442969574065\n",
      "- Validation Loss: 23.86207034136798\n",
      "\n",
      "Epoch 32\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 21.95098634714189\n",
      "- Validation Loss: 23.552817267340583\n",
      "\n",
      "Epoch 33\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 21.868878783387316\n",
      "- Validation Loss: 23.238353136423473\n",
      "\n",
      "Epoch 34\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 21.65684495127873\n",
      "- Validation Loss: 23.621272087097168\n",
      "\n",
      "Epoch 35\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 21.653081418498687\n",
      "- Validation Loss: 23.391355488751387\n",
      "\n",
      "Epoch 36\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 21.381472731910048\n",
      "- Validation Loss: 22.668959385639912\n",
      "\n",
      "Epoch 37\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 21.20616744463097\n",
      "- Validation Loss: 23.010758657713193\n",
      "\n",
      "Epoch 38\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 21.38542159162572\n",
      "- Validation Loss: 23.15646743774414\n",
      "\n",
      "Epoch 39\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 21.17340098927212\n",
      "- Validation Loss: 23.15839249378926\n",
      "\n",
      "Epoch    39: reducing learning rate of group 0 to 2.5000e-04.\n",
      "Epoch 40\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 20.56860720863682\n",
      "- Validation Loss: 22.514180879335147\n",
      "\n",
      "Epoch 41\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 20.250162492520023\n",
      "- Validation Loss: 22.66474942903261\n",
      "\n",
      "Epoch 42\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 20.156593311434328\n",
      "- Validation Loss: 22.26088709444613\n",
      "\n",
      "Epoch 43\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 20.022877192285012\n",
      "- Validation Loss: 22.171791076660156\n",
      "\n",
      "Epoch 44\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.948422502693152\n",
      "- Validation Loss: 22.22455207721607\n",
      "\n",
      "Epoch 45\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.815713489091006\n",
      "- Validation Loss: 22.250533954517262\n",
      "\n",
      "Epoch 46\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.874182658662427\n",
      "- Validation Loss: 22.474415083189268\n",
      "\n",
      "Epoch    46: reducing learning rate of group 0 to 1.2500e-04.\n",
      "Epoch 47\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.441904178359035\n",
      "- Validation Loss: 21.855384079185693\n",
      "\n",
      "Epoch 48\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.374973532000354\n",
      "- Validation Loss: 21.698475219107962\n",
      "\n",
      "Epoch 49\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.25620845092864\n",
      "- Validation Loss: 21.80599730723613\n",
      "\n",
      "Epoch 50\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.155001275263484\n",
      "- Validation Loss: 21.724478824718577\n",
      "\n",
      "Epoch 51\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.122990486529886\n",
      "- Validation Loss: 21.619050721864443\n",
      "\n",
      "Epoch 52\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.07413521435565\n",
      "- Validation Loss: 21.600560136743493\n",
      "\n",
      "Epoch 53\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 19.04862681765231\n",
      "- Validation Loss: 21.50670453664419\n",
      "\n",
      "Epoch 54\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.957894033777254\n",
      "- Validation Loss: 21.5621192777479\n",
      "\n",
      "Epoch 55\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.93041445451957\n",
      "- Validation Loss: 21.639116261456465\n",
      "\n",
      "Epoch 56\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.890726938445773\n",
      "- Validation Loss: 21.592728666357093\n",
      "\n",
      "Epoch    56: reducing learning rate of group 0 to 6.2500e-05.\n",
      "Epoch 57\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.71006250239975\n",
      "- Validation Loss: 21.407464388254528\n",
      "\n",
      "Epoch 58\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.603657179133474\n",
      "- Validation Loss: 21.42846682264998\n",
      "\n",
      "Epoch 59\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.57845233102227\n",
      "- Validation Loss: 21.353777627687197\n",
      "\n",
      "Epoch 60\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.532679543650822\n",
      "- Validation Loss: 21.315383627608014\n",
      "\n",
      "Epoch 61\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.510518889045148\n",
      "- Validation Loss: 21.33637033926474\n",
      "\n",
      "Epoch 62\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.485823501111494\n",
      "- Validation Loss: 21.279215090983623\n",
      "\n",
      "Epoch 63\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.477500658006978\n",
      "- Validation Loss: 21.299245860125566\n",
      "\n",
      "Epoch 64\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.448521690481847\n",
      "- Validation Loss: 21.383036304164577\n",
      "\n",
      "Epoch 65\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.406217914660537\n",
      "- Validation Loss: 21.339369361465042\n",
      "\n",
      "Epoch    65: reducing learning rate of group 0 to 3.1250e-05.\n",
      "Epoch 66\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training & Validating ----------------\n",
      "- Training Loss: 18.313462806384713\n",
      "- Validation Loss: 21.44018840789795\n",
      "\n",
      "Epoch 67\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.258281509671082\n",
      "- Validation Loss: 21.349825034270417\n",
      "\n",
      "Epoch 68\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.231521946032608\n",
      "- Validation Loss: 21.323619507454538\n",
      "\n",
      "Epoch    68: reducing learning rate of group 0 to 1.5625e-05.\n",
      "Epoch 69\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.180486152716842\n",
      "- Validation Loss: 21.2082735783345\n",
      "\n",
      "Epoch 70\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.143192449733835\n",
      "- Validation Loss: 21.18839779415646\n",
      "\n",
      "Epoch 71\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.12629583964362\n",
      "- Validation Loss: 21.179229916752995\n",
      "\n",
      "Epoch 72\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.12002655448121\n",
      "- Validation Loss: 21.166385006260228\n",
      "\n",
      "Epoch 73\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.108478563121942\n",
      "- Validation Loss: 21.16103185189737\n",
      "\n",
      "Epoch 74\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.099633137620874\n",
      "- Validation Loss: 21.173146196313805\n",
      "\n",
      "Epoch 75\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.086988650019162\n",
      "- Validation Loss: 21.156769365877718\n",
      "\n",
      "Epoch 76\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.076236076807763\n",
      "- Validation Loss: 21.170300715678447\n",
      "\n",
      "Epoch 77\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.06777159184306\n",
      "- Validation Loss: 21.1563957832955\n",
      "\n",
      "Epoch 78\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.058113833917\n",
      "- Validation Loss: 21.15221188519452\n",
      "\n",
      "Epoch 79\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.049003649182417\n",
      "- Validation Loss: 21.155753109906172\n",
      "\n",
      "Epoch 80\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.038697950210345\n",
      "- Validation Loss: 21.152913969916266\n",
      "\n",
      "Epoch 81\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.034653768341336\n",
      "- Validation Loss: 21.162091693362676\n",
      "\n",
      "Epoch    81: reducing learning rate of group 0 to 7.8125e-06.\n",
      "Epoch 82\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 18.009322858351982\n",
      "- Validation Loss: 21.12768660364924\n",
      "\n",
      "Epoch 83\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.990436998248455\n",
      "- Validation Loss: 21.12679960921004\n",
      "\n",
      "Epoch 84\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.9834210582586\n",
      "- Validation Loss: 21.121061247748298\n",
      "\n",
      "Epoch 85\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.97671718201227\n",
      "- Validation Loss: 21.115007555162585\n",
      "\n",
      "Epoch 86\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.970964615705814\n",
      "- Validation Loss: 21.108604740452122\n",
      "\n",
      "Epoch 87\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.96779372076606\n",
      "- Validation Loss: 21.10690199362265\n",
      "\n",
      "Epoch 88\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.961786234767924\n",
      "- Validation Loss: 21.105979970983558\n",
      "\n",
      "Epoch 89\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.956323330763187\n",
      "- Validation Loss: 21.101758029009844\n",
      "\n",
      "Epoch 90\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.95232491818663\n",
      "- Validation Loss: 21.103172817745723\n",
      "\n",
      "Epoch 91\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.946847652469263\n",
      "- Validation Loss: 21.101451023204906\n",
      "\n",
      "Epoch 92\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.942412069360298\n",
      "- Validation Loss: 21.0968338476645\n",
      "\n",
      "Epoch 93\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.936819222277634\n",
      "- Validation Loss: 21.096935890816354\n",
      "\n",
      "Epoch 94\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.932449480900072\n",
      "- Validation Loss: 21.100009840887946\n",
      "\n",
      "Epoch 95\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.928761168120523\n",
      "- Validation Loss: 21.104379937455462\n",
      "\n",
      "Epoch    95: reducing learning rate of group 0 to 3.9063e-06.\n",
      "Epoch 96\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.916878318220643\n",
      "- Validation Loss: 21.0881344821002\n",
      "\n",
      "Epoch 97\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.904965958184942\n",
      "- Validation Loss: 21.090282208210713\n",
      "\n",
      "Epoch 98\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.901906856797215\n",
      "- Validation Loss: 21.090761262017327\n",
      "\n",
      "Epoch 99\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.898444294575768\n",
      "- Validation Loss: 21.087477323171253\n",
      "\n",
      "Epoch    99: reducing learning rate of group 0 to 1.9531e-06.\n",
      "Epoch 100\n",
      "Training & Validating ----------------\n",
      "- Training Loss: 17.88708421101556\n",
      "- Validation Loss: 21.089028590434307\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Hyperparameter\n",
    "batch_size = 32\n",
    "city = 'palo-alto'\n",
    "model_dim = 16\n",
    "conv_depth = 16\n",
    "kernel_size = 3\n",
    "conv_padding = 2\n",
    "n_heads = 8\n",
    "linear_dim = 32 # [32, 128]\n",
    "dropout_rate = 0 # [0, 0.5]\n",
    "encoder_layers = 2\n",
    "num_iters = 100 # [50, 100]\n",
    "learning_rate = 0.002 # [0.001, 0.005]\n",
    "factor = 0.5 # 0.1 ~ 0.99\n",
    "patience = 2\n",
    "regress_steps = 3\n",
    "\n",
    "palo_net, palo_loss = train(\n",
    "    batch_size, \n",
    "    city, \n",
    "    model_dim,\n",
    "    conv_depth,\n",
    "    kernel_size,\n",
    "    conv_padding,\n",
    "    n_heads,\n",
    "    linear_dim,\n",
    "    dropout_rate,\n",
    "    encoder_layers,\n",
    "    regress_steps,\n",
    "    num_iters,\n",
    "    learning_rate,\n",
    "    factor,\n",
    "    patience,\n",
    "    device=DEVICE\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "93275d3a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 263,
       "width": 394
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "vis_results('palo-alto', 'train', 32, palo_net, 29)"
   ]
  }
 ],
 "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}