trap/test_training.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "from pathlib import Path\n",
    "from typing import List\n",
    "\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from pandas import DataFrame\n",
    "from torch import optim\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "from tqdm import tqdm\n",
    "\n",
    "from trap.frame_emitter import Camera, Track\n",
    "from trap.tracker import FinalDisplacementFilter, TrackReader\n",
    "from trap.utils import ImageMap\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Training options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Training options\n",
    "input_seq_length = 36\n",
    "output_seq_length = 36\n",
    "\n",
    "lr = 0.00005\n",
    "num_epochs = 100\n",
    "batch_size = 512\n",
    "hidden_size = 32\n",
    "num_gru_layers = 1\n",
    "grad_clip = 1.0\n",
    "scheduled_sampling_decay = 10\n",
    "dropout = 0.\n",
    "\n",
    "# As opposed to point-wise (assumes Gaussian)\n",
    "# probabilistic = True\n",
    "\n",
    "# use_attention = True\n",
    "\n",
    "path = Path(\"EXPERIMENTS/raw/hof3/\")\n",
    "calibration_path = Path(\"../DATASETS/hof3/calibration.json\")\n",
    "homography_path = Path(\"../DATASETS/hof3/homography.json\")\n",
    "device = device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "camera = Camera.from_paths(calibration_path, homography_path, 12)\n",
    "\n",
    "# when using a map encoder:\n",
    "image_path = Path(\"../DATASETS/hof3/map-undistorted-H-2.png\")\n",
    "assert image_path.exists()\n",
    "\n",
    "CACHE_DIR = Path(\"/tmp/cache-custom-rnn\")\n",
    "cache_path = Path(CACHE_DIR)\n",
    "cache_path.mkdir(parents=True, exist_ok=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Data loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded 2379\n"
     ]
    }
   ],
   "source": [
    "from trap.tracker import Smoother\n",
    "\n",
    "\n",
    "reader = TrackReader(path, camera.fps, exclude_whitelisted = False, include_blacklisted=False)\n",
    "\n",
    "smoother = Smoother()\n",
    "# \n",
    "# make sure we have all points for all tracks\n",
    "tracks: List[Track] = [t.get_with_interpolated_history() for t in reader]\n",
    "# t = Smoother().smooth_track(t)\n",
    "track_filter = FinalDisplacementFilter(2)\n",
    "tracks = track_filter.apply(tracks, camera)\n",
    "tracks = [smoother.smooth_track(t) for t in tracks]\n",
    "\n",
    "print(f\"Loaded {len(tracks)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# split training & validation:\n",
    "np.random.shuffle(tracks)\n",
    "test_offset_idx = int(len(tracks) * .8)\n",
    "\n",
    "training_tracks, test_tracks = tracks[:test_offset_idx], tracks[test_offset_idx:]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "in_fields = [ 'x', 'y', 'dx', 'dy']\n",
    "out_fields = ['dx', 'dy']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find_id = \"109271\"\n",
    "# for i, track in enumerate(training_tracks):\n",
    "#     if track.track_id == find_id:\n",
    "#         print(i)\n",
    "#         break\n",
    "# # print(track)\n",
    "\n",
    "# track.to_flat_dataframe(camera).isna().any().any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/1903 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1903/1903 [03:23<00:00,  9.35it/s]\n",
      "100%|██████████| 476/476 [00:42<00:00, 11.12it/s]\n"
     ]
    }
   ],
   "source": [
    "def create_dataset(tracks: list[Track], input_seq_length: int, output_seq_length: int, in_fields: list[str], out_fields: list[str], camera: Camera, only_last=False, device='cpu'):\n",
    "    encoder_X, decoder_X, decoder_y, = [], [], []\n",
    "    # factor = SAMPLE_STEP if SAMPLE_STEP is not None else 1\n",
    "    for track in tqdm(tracks):\n",
    "        # track = reader.get(track_id)\n",
    "        if len(track.history) < 2:\n",
    "            print(track.track_id, \"too short\")\n",
    "        df: DataFrame = track.to_flat_dataframe(camera)\n",
    "        # df = data.loc[track_id]\n",
    "        # print(df)\n",
    "        # start_frame = min(df.index.tolist())\n",
    "        for timestep in range(df.shape[0] - (input_seq_length + output_seq_length) + 1):\n",
    "\n",
    "            # enc_inputs: (input seq len, num features)\n",
    "            # print(df[timestep:timestep+input_seq_length][['velocity_x', 'velocity_y']])\n",
    "            past = deepcopy(df[timestep : timestep + input_seq_length][in_fields])\n",
    "            future = deepcopy(df[timestep + input_seq_length : timestep + input_seq_length + output_seq_length][out_fields])\n",
    "            # enc_inputs_at_t = deepcopy(df[timestep : timestep + input_seq_length][in_fields])\n",
    "            # dec_at_t = deepcopy(df[timestep + input_seq_length - 1 : timestep + input_seq_length + output_seq_length])\n",
    "            # dec_targets: (output seq len, num features)\n",
    "            # dec_inputs_at_t = deepcopy(dec_at_t[:-1][in_fields])\n",
    "            # dec_targets: (output seq len, num targets)\n",
    "            # dec_targets_at_t = deepcopy(dec_at_t[1:][out_fields])\n",
    "\n",
    "            if past.isna().any().any():\n",
    "                print(\"nan in past\", track.track_id, timestep)\n",
    "            elif future.isna().any().any():\n",
    "                print(\"nan in future\", track.track_id, timestep)\n",
    "            else:\n",
    "                encoder_X.append(past)\n",
    "                decoder_y.append(future)\n",
    "            \n",
    "        # # for step in range(len(df)-window-1):\n",
    "        #     i = int(start_frame) + (step*factor)\n",
    "        #     # print(step, int(start_frame), i)\n",
    "        #     feature = df.loc[i:i+(window*factor)][in_fields]\n",
    "        #     # target = df.loc[i+1:i+window+1][out_fields]\n",
    "        #     # print(i, window*factor, factor, i+window*factor+factor, df['idx_in_track'])\n",
    "        #     # print(i+window*factor+factor)\n",
    "        #     if only_last:\n",
    "        #         target = df.loc[i+window*factor+factor][out_fields]\n",
    "        #     else:\n",
    "        #         target = df.loc[i+factor:i+window*factor+factor][out_fields]\n",
    "\n",
    "\n",
    "            # encoder_X.append(enc_inputs_at_t.values)\n",
    "            # decoder_X.append(dec_inputs_at_t.values)\n",
    "            # decoder_y.append(dec_targets_at_t.values)\n",
    "    \n",
    "    return TensorDataset(\n",
    "        torch.tensor(np.array(encoder_X), device=device, dtype=torch.float), \n",
    "        torch.tensor(np.array(decoder_y), device=device, dtype=torch.float)\n",
    "    )\n",
    "    \n",
    "    # return {'enc_inputs': torch.tensor(np.array(encoder_X), device=device, dtype=torch.float), \n",
    "    #       'dec_inputs': torch.tensor(np.array(decoder_X), device=device, dtype=torch.float), \n",
    "    #       'dec_outputs': torch.tensor(np.array(decoder_y), device=device, dtype=torch.float)}\n",
    "\n",
    "dataset_train = create_dataset(training_tracks, input_seq_length, output_seq_length, in_fields, out_fields, camera, False, device)\n",
    "dataset_test = create_dataset(test_tracks, input_seq_length, output_seq_length, in_fields, out_fields, camera, False, device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor(False, device='cuda:0'), tensor(False, device='cuda:0'))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset_train.tensors[0].isnan().any(), dataset_train.tensors[1].isnan().any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(210955, 36, 36)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dataset_train), input_seq_length, output_seq_length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataloader_train = DataLoader(dataset_train, batch_size=batch_size, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Probablistic Recurrent VAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def integrate_output_to_input(output_feature: torch.Tensor, input_feature: torch.Tensor):\n",
    "    \"\"\"use four params (x,y, dx, dy) to predict dx, dy\n",
    "    integrate prediction back into input to get a new feature\n",
    "    \"\"\"\n",
    "    # input_feature (batch_size, ?, num in_fields)\n",
    "    # output_feature (batch_size, ?, num out_fields)\n",
    "    new_positions = input_feature[:,:,0:2] + output_feature\n",
    "    return torch.cat((new_positions, output_feature), axis=2)\n",
    "    # return new_feature\n",
    "    # return torch.tensor([\n",
    "    #     input_feature[0] + output_feature[0],\n",
    "    #     input_feature[1] + output_feature[1],\n",
    "    #     output_feature[0],\n",
    "    #     output_feature[1],\n",
    "    # ], device=input_feature.device)\n",
    "\n",
    "\n",
    "# VAE\n",
    "\n",
    "class RPVAE(nn.Module):\n",
    "    def __init__(self, input_size=2, hidden_size=64, latent_dim=16, future_len=12):\n",
    "        super().__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.latent_dim = latent_dim\n",
    "        self.future_len = future_len\n",
    "\n",
    "        # Encoder: encodes past trajectory to latent space\n",
    "        self.encoder = nn.LSTM(input_size, hidden_size, batch_first=True)\n",
    "        self.fc_mu = nn.Linear(hidden_size, latent_dim)\n",
    "        self.fc_logvar = nn.Linear(hidden_size, latent_dim)\n",
    "\n",
    "        # Decoder: decodes z to future trajectory\n",
    "        self.decoder_input = nn.Linear(latent_dim + input_size, hidden_size)\n",
    "        self.decoder_lstm = nn.LSTM(input_size, hidden_size, batch_first=True)\n",
    "        self.output = nn.Linear(hidden_size, 2)\n",
    "\n",
    "    def encode(self, x):\n",
    "        _, (h_n, _) = self.encoder(x)  # h_n: (1, batch, hidden)\n",
    "        h_n = h_n.squeeze(0)\n",
    "        mu = self.fc_mu(h_n)\n",
    "        logvar = self.fc_logvar(h_n)\n",
    "        return mu, logvar\n",
    "\n",
    "    def reparameterize(self, mu, logvar):\n",
    "        std = torch.exp(0.5 * logvar)\n",
    "        eps = torch.randn_like(std)\n",
    "        return mu + eps * std\n",
    "\n",
    "    def decode(self, z, start_pos):\n",
    "        # Initial hidden state from latent + start position\n",
    "        batch_size = z.size(0)\n",
    "        dec_input = torch.cat([z, start_pos], dim=1)\n",
    "        h = torch.tanh(self.decoder_input(dec_input)).unsqueeze(0)  # (1, batch, hidden)\n",
    "        c = torch.zeros_like(h)\n",
    "\n",
    "        outputs = []\n",
    "        input_step = start_pos.unsqueeze(1)  # (batch, 1, 2)\n",
    "        for _ in range(self.future_len):\n",
    "            # print('input_step', input_step.shape)\n",
    "            # print('input_step', input_step)\n",
    "            out, (h, c) = self.decoder_lstm(input_step, (h, c))\n",
    "            pred = self.output(out)\n",
    "            outputs.append(pred.squeeze(1))\n",
    "            # print('output_step', pred.shape)\n",
    "            input_step = integrate_output_to_input(pred, input_step) # feed predicted position as input\n",
    "            \n",
    "            # input_step = pred  \n",
    "\n",
    "        return torch.stack(outputs, dim=1)\n",
    "\n",
    "    def forward(self, past_traj):\n",
    "        # past_traj: (batch_size, history_len, num parameters)\n",
    "        mu, logvar = self.encode(past_traj)\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        \n",
    "        last_pos = past_traj[:, -1, :]  # last observed position\n",
    "        # print('last_pos', last_pos)\n",
    "        future_pred = self.decode(z, last_pos)\n",
    "        return future_pred, mu, logvar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vae_loss(recon, target, mu, logvar):\n",
    "    recon_loss = nn.MSELoss()(recon, target)\n",
    "    # KL Divergence\n",
    "    kl_loss = -0.5 * torch.mean(1 + logvar - mu.pow(2) - logvar.exp())\n",
    "    return recon_loss + kl_loss, recon_loss, kl_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_rpvae(model, dataloader, epochs=20, lr=1e-3):\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "    model.train()\n",
    "    for epoch in range(epochs):\n",
    "        total_loss = 0\n",
    "        for past, future in tqdm(dataloader):\n",
    "            pred, mu, logvar = model(past)\n",
    "            loss, recon_loss, kl_loss = vae_loss(pred, future, mu, logvar)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            total_loss += loss.item()\n",
    "        print(f\"Epoch {epoch+1}, Loss: {total_loss/len(dataloader):.4f} (total:{total_loss})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_multiple(model, past_traj, num_samples=5):\n",
    "    model.eval()\n",
    "    predictions = []\n",
    "    with torch.no_grad():\n",
    "        for _ in range(num_samples):\n",
    "            pred, _, _ = model(past_traj.unsqueeze(0))\n",
    "            predictions.append(pred.squeeze(0))\n",
    "    return torch.stack(predictions)  # (num_samples, future_len, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/1649 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:27<00:00, 60.71it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Loss: 0.0015 (total:2.4276419173402246)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:27<00:00, 60.52it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2, Loss: 0.0006 (total:0.980240458418848)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:25<00:00, 63.70it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3, Loss: 0.0006 (total:0.940998741221847)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:27<00:00, 59.99it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4, Loss: 0.0006 (total:0.9100368080544285)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:25<00:00, 64.31it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5, Loss: 0.0005 (total:0.8973619830212556)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:25<00:00, 63.93it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6, Loss: 0.0005 (total:0.8762864287418779)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:25<00:00, 63.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7, Loss: 0.0005 (total:0.8653568502340931)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 63.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8, Loss: 0.0005 (total:0.858748087339336)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 62.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9, Loss: 0.0005 (total:0.8507893867790699)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 63.08it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10, Loss: 0.0005 (total:0.8442291679384653)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 63.12it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 11, Loss: 0.0005 (total:0.8402256505505648)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 63.25it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 12, Loss: 0.0005 (total:0.8351299523201305)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 62.70it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 13, Loss: 0.0005 (total:0.8282983377866913)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 63.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 14, Loss: 0.0005 (total:0.8267594532226212)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 63.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15, Loss: 0.0005 (total:0.8221607875893824)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 62.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 16, Loss: 0.0005 (total:0.8198444427980576)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 61.50it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 17, Loss: 0.0005 (total:0.8170247735979501)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 62.95it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 18, Loss: 0.0005 (total:0.8117570877220714)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 62.83it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 19, Loss: 0.0005 (total:0.8099762515848852)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1649/1649 [00:26<00:00, 63.02it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 20, Loss: 0.0005 (total:0.8074558652297128)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Train model\n",
    "model = RPVAE(input_size=len(in_fields), future_len=output_seq_length).to(device)\n",
    "train_rpvae(model, dataloader_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.future_len = 100\n",
    "#model.future_len = 36"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# Inference on one sample\n",
    "past, future = dataset_test[29000]\n",
    "samples = predict_multiple(model, past)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "def integrate_samples(first_position, samples):\n",
    "    # first_position: (2) : [x,y]\n",
    "    # samples: (num_samples, future_len, 2 [dx, dy])\n",
    "    \n",
    "    output = []\n",
    "    for sample in samples:\n",
    "        s = torch.cumsum(sample, axis=0) + first_position\n",
    "        output.append(s)\n",
    "    # return torch.cumsum(samples)\n",
    "    # print(output[0].shape)\n",
    "    return torch.stack(output, dim=0)\n",
    "\n",
    "future_xy = integrate_samples(past[-1][:2], [future])\n",
    "samples = integrate_samples(past[-1][:2], samples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "past, future, samples = past.cpu(), future_xy[0].cpu(), samples.cpu()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1800x1600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.figure(figsize=(18, 16))\n",
    "plt.plot(past[:, 0], past[:, 1], 'b-o', label='Past')\n",
    "plt.plot(future[:, 0], future[:, 1], 'g-o', label='Future (GT)')\n",
    "\n",
    "for i in range(samples.shape[0]):\n",
    "    plt.plot(samples[i, :, 0], samples[i, :, 1], '--', label=f'Sample {i+1}')\n",
    "\n",
    "plt.legend()\n",
    "plt.title('Trajectory Prediction with RP-VAE Samples')\n",
    "plt.xlabel('X')\n",
    "plt.ylabel('Y')\n",
    "plt.grid(True)\n",
    "plt.axis('equal')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TODO\n",
    "\n",
    "* Stop prediction in model.forward() based on out of bounds. Only in inference mode.\n",
    "* Duplicate this file and check other notebook for training improvements\n",
    "    * Error/loss metric\n",
    "    * Add attention to network?\n",
    "* Check Trajectron paper on \"Overshoot\"\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}