SimpleEncDec.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple Model 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "torch.set_default_tensor_type(torch.cuda.FloatTensor)\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import os, os.path \n",
    "import numpy \n",
    "import pickle\n",
    "from glob import glob\n",
    "import random\n",
    "\n",
    "\"\"\"Change to the data folder\"\"\"\n",
    "new_path = \"./new_train/new_train/\"\n",
    "\n",
    "val_path = \"./new_val_in/new_val_in/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ArgoverseDataset(Dataset):\n",
    "    \"\"\"Dataset class for Argoverse\"\"\"\n",
    "    def __init__(self, data_path: str, transform=None):\n",
    "        super(ArgoverseDataset, self).__init__()\n",
    "        self.data_path = data_path\n",
    "        self.transform = transform\n",
    "\n",
    "        self.pkl_list = glob(os.path.join(self.data_path, '*'))\n",
    "        self.pkl_list.sort()\n",
    "        random.shuffle(self.pkl_list)\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.pkl_list)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "\n",
    "        pkl_path = self.pkl_list[idx]\n",
    "        with open(pkl_path, 'rb') as f:\n",
    "            data = pickle.load(f)\n",
    "            \n",
    "        if self.transform:\n",
    "            data = self.transform(data)\n",
    "\n",
    "        return data\n",
    "    \n",
    "    def capIt(self, a, b):\n",
    "        self.pkl_list = self.pkl_list[a:b]\n",
    "\n",
    "\n",
    "# intialize a dataset\n",
    "train_dataset  = ArgoverseDataset(data_path=new_path)\n",
    "test_dataset = ArgoverseDataset(data_path=new_path)\n",
    "val_dataset  = ArgoverseDataset(data_path=val_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "205942"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset.capIt(0,200000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dataset.capIt(201000,202008)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU is available\n"
     ]
    }
   ],
   "source": [
    "is_cuda = torch.cuda.is_available()\n",
    "\n",
    "if is_cuda:\n",
    "    device = torch.device(\"cuda\")\n",
    "    print(\"GPU is available\")\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "    print(\"GPU not available, CPU used\")\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_sz = 16\n",
    "\n",
    "def collateInput(batch):\n",
    "    \"\"\" collate lists of samples into batches, create  \"\"\"\n",
    "    \n",
    "    '''\n",
    "    inp = [numpy.dstack([scene['p_in'], scene['v_in']]) for scene in batch]\n",
    "    out = [numpy.dstack([scene['p_out'], scene['v_out']]) for scene in batch]\n",
    "    index = [i for i in range(60) for scene in batch if scene['agent_id'] == scene['track_id'][i, 0, 0]]\n",
    "    inp = torch.FloatTensor(inp)\n",
    "    out = torch.FloatTensor(out)\n",
    "    return [inp, out, index]\n",
    "    '''\n",
    "    inp = []\n",
    "    out = []\n",
    "    index = []\n",
    "    for scene in batch:\n",
    "        inp = inp + [[scene['p_in'][i]] for i in range(60) if scene['track_id'][i, 0, 0] == scene['agent_id']]\n",
    "        out = out + [[scene['p_out'][i]] for i in range(60) if scene['track_id'][i, 0, 0] == scene['agent_id']]\n",
    "        index = index + [i for i in range(60) if scene['agent_id'] == scene['track_id'][i, 0, 0]]\n",
    "    inp = torch.FloatTensor(inp).squeeze(1)\n",
    "    out = torch.FloatTensor(out).squeeze(1)\n",
    "\n",
    "    return[inp, out, index]\n",
    "\n",
    "train_loader = DataLoader(train_dataset,batch_size=batch_sz, shuffle = True, collate_fn=collateInput, num_workers=0)\n",
    "test_loader = DataLoader(test_dataset,batch_size=batch_sz, shuffle = True, collate_fn=collateInput, num_workers=0)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(4744.3594, device='cpu')\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "#Normalize\n",
    "'''\n",
    "sumX = 0\n",
    "sumY = 0\n",
    "total = 0\n",
    "batch_size = 16\n",
    "for [inp, out, index] in train_loader:\n",
    "    total = total + (batch_size * 19 * 2)\n",
    "    sumX = sumX + inp[:, :, 0].sum() + out[:, :, 0].sum()\n",
    "    sumY = sumY + inp[:, :, 1].sum() + out[:, :, 1].sum()\n",
    "meanX = sumX/total\n",
    "meanY = sumY/total\n",
    "\n",
    "print(\"half done\")\n",
    "\n",
    "sqX = 0\n",
    "sqY = 0\n",
    "a = torch.zeros(batch_size, 19)\n",
    "a[:, :] = meanX\n",
    "b[:, :] = meanY\n",
    "for [inp, out, index] in train_loader:\n",
    "    sqX = sqX + (torch.square(inp[:, :, 0] - a)).sum().item()\n",
    "    sqY = sqY + (torch.square(inp[:, :, 1] - a)).sum().item()\n",
    "    \n",
    "stdX = torch.sqrt(sqX/total)\n",
    "stdY = torch.sqrt(sqY/total)\n",
    "print(meanX, meanY, stdX, stdY)\n",
    "'''\n",
    "max = 0\n",
    "min = 0\n",
    "for [inp, out, index] in train_loader:        \n",
    "        if (torch.max(inp) > max):\n",
    "            max = torch.max(inp)\n",
    "           \n",
    "        if (torch.min(inp) < min):\n",
    "            min = torch.min(inp)\n",
    "            \n",
    "        if (torch.max(out) > max):\n",
    "            max = (torch.max(out))\n",
    "                   \n",
    "                \n",
    "        if (torch.min(out) < min):\n",
    "            min = torch.min(out)\n",
    "            \n",
    "            \n",
    "\n",
    "print(max)\n",
    "print(min)\n",
    "maxVal = 4744.3594"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import math\n",
    "\n",
    "class RNNEncoder(nn.Module):\n",
    "\n",
    "    def __init__(self, i_size, h_size, n_layers, batchsize):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.i_size = i_size\n",
    "        self.h_size = h_size\n",
    "        self.n_layers = n_layers\n",
    "        self.batch_size = batchsize\n",
    "        self.encoder = nn.LSTM(self.i_size, h_size, n_layers, batch_first=True)\n",
    "        self.fc_out = nn.Linear(self.h_size, i_size)\n",
    "        self.batchNorm = nn.BatchNorm1d(19)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        batch_size = x.size(0)\n",
    "        h = self.init_hidden(self.batch_size, self.n_layers, self.h_size)\n",
    "        c = self.init_hidden(self.batch_size, self.n_layers, self.h_size)\n",
    "        x.to(device)\n",
    "        out, (hidden, cellstate) = self.encoder(x, (h, c))\n",
    "        #out = self.batchNorm(out)\n",
    "        out = F.tanh(self.fc_out(out))\n",
    "        #out = self.batchNorm(out)\n",
    "        return out, hidden, cellstate\n",
    "    \n",
    "    def init_hidden(self, batch_size, n_layers, hidden_dim):\n",
    "        hidden = torch.zeros(n_layers, batch_size, hidden_dim).to(device)\n",
    "        return hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNNDecoder(nn.Module):\n",
    "\n",
    "    def __init__(self, o_size, h_size, n_layers, batchSize):\n",
    "        super().__init__()\n",
    "        \n",
    "        \n",
    "        self.o_size = o_size\n",
    "        self.h_size = h_size\n",
    "        self.n_layers = n_layers\n",
    "        self.decoder = nn.LSTM(self.o_size, h_size, n_layers, batch_first=True)\n",
    "        self.fc_out = nn.Linear(self.h_size , self.o_size)\n",
    "        #self.batchNorm = nn.BatchNorm1d(1)\n",
    "        #self.batchNorm2 = nn.BatchNorm1d(2)\n",
    "\n",
    "\n",
    "        \n",
    "    def forward(self, x, h):\n",
    "        batch_size = x.size(0)\n",
    "        out, (hidden, cellstate) = self.decoder(x, h)\n",
    "        #out = self.batchNorm(out)\n",
    "        out = F.relu(self.fc_out(out.reshape((batch_size, -1))))\n",
    "        #out = self.batchNorm2(out)\n",
    "        \n",
    "        return out, hidden, cellstate\n",
    "    \n",
    "    def init_hidden(self, batch_size):\n",
    "        hidden = torch.zeros(self.n_layers, batch_size, self.hidden_dim).to(device)\n",
    "        return hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RNNendec(nn.Module):\n",
    "    def __init__(self, enc, enc2, dec, dec2, numOutputs, numFeatures, batchSize):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.encoder = enc\n",
    "        self.encoder2 = enc2\n",
    "        self.decoder = dec\n",
    "        self.decoder2 = dec2\n",
    "        self.numO = numOutputs\n",
    "        self.feat = numFeatures\n",
    "        self.batchSize = batchSize\n",
    "        \n",
    "    def forward(self, x, target, teacher_force_ratio = 0.5):\n",
    "        \n",
    "        seqLen = x.size(1)\n",
    "        batchSize = x.size(0)\n",
    "        features = x.size(2)\n",
    "        \n",
    "        \n",
    "        outputTensor = torch.zeros(batchSize, self.numO, self.feat)\n",
    "        \n",
    "        \n",
    "        o, h, c = self.encoder(x[:,:,0 ].reshape(batchSize, 19,1))\n",
    "        o2, h2, c2, = self.encoder(x[:, :, 1].reshape(batchSize, 19, 1))\n",
    "        \n",
    "        o = o.reshape(batchSize, 19, 1)\n",
    "        # first input to decoder is last output of encoder\n",
    "        t = o[:, 18, :].reshape(batchSize, 1, 1)\n",
    "        \n",
    "        for i in range(self.numO):\n",
    "            o, h, c = self.decoder(t , (h, c))\n",
    "            \n",
    "            #update output tensor\n",
    "            o = o.reshape(self.batchSize, 1)\n",
    "            \n",
    "            \n",
    "            outputTensor[:, i, 0] = o.reshape(batchSize)\n",
    "            \n",
    "            \n",
    "            # set next input to be either correct from target or prediction\n",
    "            #target is a flag, when zero, we are doing predictions\n",
    "            if target.size() != torch.Size([1]):\n",
    "                #t = target[:, i, :].reshape(batchSize, 1, 1) \n",
    "                if random.random() < teacher_force_ratio: \n",
    "                    t = target[:, i, 0].reshape(batchSize, 1, 1) \n",
    "                else:\n",
    "                    t = o.reshape(batchSize, 1, 1)\n",
    "            else:\n",
    "                t = o.reshape(batchSize, 1, 1)\n",
    "                \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "        o2 = o2.reshape(batchSize, 19, 1)\n",
    "        # first input to decoder is last output of encoder\n",
    "        t2 = o2[:, 18, :].reshape(batchSize, 1, 1)\n",
    "        \n",
    "        for i in range(self.numO):\n",
    "            o2, h2, c2 = self.decoder(t2 , (h2, c2))\n",
    "            \n",
    "            #update output tensor\n",
    "            o2 = o2.reshape(self.batchSize, 1)\n",
    "            \n",
    "            \n",
    "            outputTensor[:, i, 1] = o2.reshape(batchSize)\n",
    "            \n",
    "            \n",
    "            # set next input to be either correct from target or prediction\n",
    "            #target is a flag, when zero, we are doing predictions\n",
    "            if target.size() != torch.Size([1]):\n",
    "                \n",
    "                if random.random() < teacher_force_ratio: \n",
    "                    t2 = target[:, i, 1].reshape(batchSize, 1, 1) \n",
    "                else:\n",
    "                    t2 = o2.reshape(batchSize, 1, 1)\n",
    "                    #t = target[:, i, :].reshape(batchSize, 1, 1) \n",
    "            else:\n",
    "                    t2 = o2.reshape(batchSize, 1, 1)\n",
    "                \n",
    "                \n",
    "        return outputTensor\n",
    "    \n",
    "    def init_hidden(self, batch_size, n_layers, hidden_dim):\n",
    "        hidden = torch.zeros(n_layers, batch_size, hidden_dim).to(device)\n",
    "        return hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU is available\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "MSELoss()"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "is_cuda = torch.cuda.is_available()\n",
    "\n",
    "if is_cuda:\n",
    "    device = torch.device(\"cuda\")\n",
    "    print(\"GPU is available\")\n",
    "else:\n",
    "    device = torch.device(\"cpu\")\n",
    "    print(\"GPU not available, CPU used\")\n",
    "\n",
    "    \n",
    "\n",
    "#Hyperparameters\n",
    "\n",
    "inputFeat = 1\n",
    "outputFeat = 1\n",
    "numFeat = 2\n",
    "hiddenFeat = 4\n",
    "batchSize = 16\n",
    "outputSeqLen = 30\n",
    "numLayers = 1\n",
    "\n",
    "maxVal = 4736.1733\n",
    "enc = RNNEncoder(inputFeat, hiddenFeat, numLayers, batchSize)\n",
    "enc2 = RNNEncoder(inputFeat, hiddenFeat, numLayers, batchSize)\n",
    "enc.to(device)\n",
    "enc2.to(device)\n",
    "dec = RNNDecoder(outputFeat, hiddenFeat, numLayers, batchSize)\n",
    "dec2 = RNNDecoder(outputFeat, hiddenFeat, numLayers, batchSize)\n",
    "dec.to(device)\n",
    "dec2.to(device)\n",
    "\n",
    "model = RNNendec(enc, enc2, dec, dec2,  outputSeqLen, numFeat, batchSize)\n",
    "model.to(device)\n",
    "\n",
    "n_epochs = 5\n",
    "lr=0.001\n",
    "\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay = 1e-4)\n",
    "criterion.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm_notebook as tqdm\n",
    "\n",
    "losses = []\n",
    "\n",
    "\n",
    "def train(model, device, train_loader, optimizer, epoch, log_interval=10000):\n",
    "    model.train()\n",
    "    iterator = tqdm(train_loader, total=int(len(train_loader)))\n",
    "    counter = 0\n",
    "    for batch_idx, (inp, target, index) in enumerate(iterator):\n",
    "        inp, target = inp.to(device), target.to(device)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        a = torch.zeros(1)\n",
    "        \n",
    "        inp = inp/maxVal\n",
    "        target = target/maxVal\n",
    "        \n",
    "        output = model(inp, target)\n",
    "\n",
    "   \n",
    "        output.to(device)\n",
    "        target.to(device)\n",
    "        loss = criterion(output * maxVal, target * maxVal)\n",
    "        losses.append(loss)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        counter += 1\n",
    "        iterator.set_postfix(loss=(loss.item()*inp.size(0) / (counter * train_loader.batch_size)))\n",
    "        \n",
    "def test(model, device, test_loader):\n",
    "    model.eval()\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "    i = 0\n",
    "    with torch.no_grad():\n",
    "        for inp, target, index in test_loader:\n",
    "            inp, target = inp.to(device), target.to(device)\n",
    "            \n",
    "            inp = inp/maxVal\n",
    "            target = target/maxVal\n",
    "            a = torch.zeros(1)\n",
    "            output = model(inp, a)\n",
    "\n",
    "             #reshape output and target to check loss only on agent car\n",
    "\n",
    "            test_loss += criterion(output * maxVal, target * maxVal)# sum up batch loss\n",
    "    test_loss /= len(test_loader.dataset)\n",
    "\n",
    "    print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "        test_loss, correct, len(test_loader.dataset),\n",
    "        100. * correct / len(test_loader.dataset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.load_state_dict(torch.load('./simpleEncDec'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:8: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  \n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9c8eaeacaa2141baa7a960c9935f5a11",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=12500.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-63-4464d1d64914>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Training Run\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_epochs\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtest_loader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-12-725d585cf018>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(model, device, train_loader, optimizer, epoch, log_interval)\u001b[0m\n\u001b[1;32m     25\u001b[0m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mmaxVal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mmaxVal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m         \u001b[0mlosses\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 27\u001b[0;31m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     28\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m         \u001b[0mcounter\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/torch/tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph)\u001b[0m\n\u001b[1;32m    116\u001b[0m                 \u001b[0mproducts\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mDefaults\u001b[0m \u001b[0mto\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    117\u001b[0m         \"\"\"\n\u001b[0;32m--> 118\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    119\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    120\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables)\u001b[0m\n\u001b[1;32m     91\u001b[0m     Variable._execution_engine.run_backward(\n\u001b[1;32m     92\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 93\u001b[0;31m         allow_unreachable=True)  # allow_unreachable flag\n\u001b[0m\u001b[1;32m     94\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     95\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Training Run\n",
    "for epoch in range(1, n_epochs + 1):\n",
    "    train(model, device, train_loader, optimizer, epoch)\n",
    "    test(model, device, test_loader)\n",
    "    break\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f16c4cdfc10>]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "time = numpy.arange(1000)\n",
    "plt.plot(time, losses[:1000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_sz = 16\n",
    "\n",
    "\n",
    "def collateVal(batch):\n",
    "\n",
    "    inp = []\n",
    "    index = []\n",
    "    scene1 = []\n",
    "    for scene in batch:\n",
    "        inp = inp + [[scene['p_in'][i]] for i in range(60) if scene['track_id'][i, 0, 0] == scene['agent_id']]\n",
    "        index = index + [i for i in range(60) if scene['agent_id'] == scene['track_id'][i, 0, 0]]\n",
    "        scene1 = scene1 + [scene['scene_idx']]\n",
    "    inp = torch.FloatTensor(inp).squeeze(1)\n",
    "\n",
    "    return[inp, index, scene1]\n",
    "\n",
    "\n",
    "\n",
    "val_loader = DataLoader(val_dataset,batch_size=batch_sz, shuffle = True, collate_fn=collateVal, num_workers=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished Writing\n"
     ]
    }
   ],
   "source": [
    "## test file writing\n",
    "import csv\n",
    "\n",
    "\n",
    "\n",
    "header = ['ID','v1','v2','v3','v4','v5','v6','v7','v8','v9','v10','v11','v12','v13','v14','v15','v16','v17','v18',\n",
    "          'v19','v20','v21','v22','v23','v24','v25','v26','v27','v28','v29','v30','v31','v32','v33','v34','v35'\n",
    "          ,'v36','v37','v38','v39','v40','v41','v42','v43','v44','v45','v46','v47','v48','v49','v50','v51','v52',\n",
    "          'v53','v54','v55','v56','v57','v58','v59','v60']\n",
    "\n",
    "with open('./submission.csv', mode = 'w') as f:\n",
    "    writer = csv.writer(f, delimiter=',')\n",
    "    writer.writerow(header)\n",
    "\n",
    "    \n",
    "    \n",
    "    for inp, index, scene in val_loader:\n",
    "        inp  = inp.to(device)\n",
    "        \n",
    "        inp = inp/maxVal\n",
    "        a = torch.zeros(1)\n",
    "        output = model(inp, a)\n",
    " \n",
    "        output = output * maxVal\n",
    "         #reshape output and target to check loss only on agent car\n",
    "\n",
    "        for i in range(batch_sz):\n",
    "            writeLine = []\n",
    "            writeLine.append(str(scene[i]))\n",
    "            temp = output.reshape(batch_sz, 60)\n",
    "            \n",
    "            temp = temp[i]\n",
    "            \n",
    "            writeLine = writeLine + temp.tolist()\n",
    "        \n",
    "            if(len(writeLine) != 61):\n",
    "                print(\"list error\")\n",
    "                \n",
    "            writer.writerow(writeLine)\n",
    "            #print(index)\n",
    "        \n",
    "        \n",
    "print(\"Finished Writing\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(model.state_dict(), './simpleEncDec')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sample predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x216 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x216 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x216 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x216 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x216 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x216 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "\n",
    "agent_id = 0\n",
    "def show_sample_batch(inp , out, agent_id, output):\n",
    "    \"\"\"visualize the trajectory for a batch of samples with a randon agent\"\"\"\n",
    "    inp, out = inp, out\n",
    "    batch_sz = inp.size(0)\n",
    "    agent_sz = inp.size(1)\n",
    "    \n",
    "    inp = inp.to('cpu')\n",
    "    out = out.to('cpu')\n",
    "    \n",
    "    fig, axs = plt.subplots(1,batch_sz, figsize=(15, 3), facecolor='w', edgecolor='k')\n",
    "    fig.subplots_adjust(hspace = .5, wspace=.001)\n",
    "   \n",
    "    axs = axs.ravel()   \n",
    "    for i in range(batch_sz):\n",
    "        axs[i].xaxis.set_ticks([])\n",
    "        axs[i].yaxis.set_ticks([])\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",
    "        \n",
    "        \n",
    "    fig2, axs2 = plt.subplots(1,batch_sz, figsize=(15, 3), facecolor='w', edgecolor='k')\n",
    "    fig2.subplots_adjust(hspace = .5, wspace=.001)\n",
    "    axs2 = axs2.ravel()   \n",
    "    for i in range(batch_sz):\n",
    "        axs2[i].xaxis.set_ticks([])\n",
    "        axs2[i].yaxis.set_ticks([])\n",
    "        \n",
    "        # first two feature dimensions are (x,y) positions\n",
    "        axs2[i].scatter(inp[i,:,0], inp[i,:,1])\n",
    "        axs2[i].scatter(output[i,:,0], output[i,:,1])\n",
    "\n",
    "\n",
    "k = 0\n",
    "for i_batch, sample_batch in enumerate(test_loader):\n",
    "    inp, out, index = sample_batch\n",
    "    inp = inp.to(device)\n",
    "    out = out.to(device)\n",
    "    inp = inp/maxVal\n",
    "    out = out/maxVal\n",
    "    #print(inp.size())\n",
    "    #print(out.size())\n",
    "    k = k+1\n",
    "    \"\"\"TODO:\n",
    "      Deep learning model\n",
    "      training routine\n",
    "    \"\"\"\n",
    "    output = model(inp, out)\n",
    "    output = output.to('cpu')\n",
    "    output = output.detach().numpy()\n",
    "    a = torch.zeros(1)\n",
    "    show_sample_batch(inp * maxVal, out * maxVal, agent_id, output * maxVal)\n",
    "    if k == 3:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple FC network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import math\n",
    "\n",
    "device = 'cuda'\n",
    "\n",
    "class fcNetwork(nn.Module):\n",
    "\n",
    "    def __init__(self, i_size, o_size, n_layers, batchsize):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.fc_out = nn.Linear(i_size * 2, o_size * 2)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        \n",
    "        out = F.relu(self.fc_out(x))\n",
    "        return out\n",
    "        \n",
    "    def init_hidden(self, batch_size, n_layers, hidden_dim):\n",
    "        hidden = torch.zeros(n_layers, batch_size, hidden_dim).to(device)\n",
    "        return hidden"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_sz = 16\n",
    "def collateFC(batch):\n",
    "\n",
    "    inp = []\n",
    "    out = []\n",
    "    index = []\n",
    "    for scene in batch:\n",
    "        inp = inp + [[scene['p_in'][i]] for i in range(60) if scene['track_id'][i, 0, 0] == scene['agent_id']]\n",
    "        out = out + [[scene['p_out'][i]] for i in range(60) if scene['track_id'][i, 0, 0] == scene['agent_id']]\n",
    "        index = index + [i for i in range(60) if scene['agent_id'] == scene['track_id'][i, 0, 0]]\n",
    "    inp = torch.FloatTensor(inp).squeeze(1)\n",
    "    out = torch.FloatTensor(out).squeeze(1)\n",
    "\n",
    "    return[inp, out, index]\n",
    "\n",
    "\n",
    "\n",
    "fc_loader = DataLoader(train_dataset,batch_size=batch_sz, shuffle = False, collate_fn=collateFC, num_workers=0)\n",
    "fc_test = DataLoader(test_dataset,batch_size=batch_sz, shuffle = False, collate_fn=collateFC, num_workers=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, device, train_loader, optimizer, epoch, log_interval=10000):\n",
    "    model.train()\n",
    "    iterator = tqdm(fc_loader, total=int(len(fc_loader)))\n",
    "    counter = 0\n",
    "    for batch_idx, (inp, target, index) in enumerate(iterator):\n",
    "        inp, target = inp.to(device), target.to(device)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        a = torch.zeros(1)\n",
    "        inp = inp.reshape(batchSize, -1)\n",
    "        target = target.reshape(batchSize, -1)\n",
    "        \n",
    "        #inp = inp/maxVal\n",
    "        #target = target/maxVal        \n",
    "        output = model(inp)\n",
    "\n",
    "   \n",
    "        output.to(device)\n",
    "        target.to(device)\n",
    "        loss = criterion(output, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        counter += 1\n",
    "        iterator.set_postfix(loss=(loss.item()*inp.size(0) / (counter * fc_loader.batch_size)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(model, device, test_loader):\n",
    "    model.eval()\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "    i = 0\n",
    "    with torch.no_grad():\n",
    "        for inp, target, index in fc_test:\n",
    "            inp, target = inp.to(device), target.to(device)\n",
    "            \n",
    "            inp = inp.reshape(batchSize, -1)\n",
    "            target = target.reshape(batchSize, -1)\n",
    "            #inp = inp/maxVal\n",
    "            #target = target/maxVal\n",
    "            a = torch.zeros(1)\n",
    "            output = model(inp)\n",
    "\n",
    "             #reshape output and target to check loss only on agent car\n",
    "\n",
    "            test_loss += criterion(output , target)# sum up batch loss\n",
    "    test_loss /= len(test_loader.dataset)\n",
    "\n",
    "    print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
    "        test_loss, correct, len(fc_test.dataset),\n",
    "        100. * correct / len(fc_test.dataset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MSELoss()"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newModel = fcNetwork(19, 30, 1, 16)\n",
    "newModel = newModel.to(device)\n",
    "\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay = 1e-4)\n",
    "criterion.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.7/site-packages/ipykernel_launcher.py:3: TqdmDeprecationWarning: This function will be removed in tqdm==5.0.0\n",
      "Please use `tqdm.notebook.tqdm` instead of `tqdm.tqdm_notebook`\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dd2ea889d5ab459aaed154bb8eca201c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=12500.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Test set: Average loss: 212205.9219, Accuracy: 0/1008 (0%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d5129573cb3424ca5ae30ff440ba1b6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=12500.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Test set: Average loss: 212205.9219, Accuracy: 0/1008 (0%)\n",
      "\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7a096ac7a0b441c68405ffae4e04c3e8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=12500.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-167-0f90a279180e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Training Run\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_epochs\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mtrain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnewModel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfc_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepoch\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m     \u001b[0mtest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnewModel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdevice\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfc_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-164-86adb24abc63>\u001b[0m in \u001b[0;36mtrain\u001b[0;34m(model, device, train_loader, optimizer, epoch, log_interval)\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0miterator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtqdm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfc_loader\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtotal\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfc_loader\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mcounter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m     \u001b[0;32mfor\u001b[0m \u001b[0mbatch_idx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0minp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m         \u001b[0minp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdevice\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tqdm/notebook.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    216\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    217\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 218\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtqdm_notebook\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__iter__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    219\u001b[0m                 \u001b[0;31m# return super(tqdm...) will not catch exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    220\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/tqdm/std.py\u001b[0m in \u001b[0;36m__iter__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   1127\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1128\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1129\u001b[0;31m             \u001b[0;32mfor\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1130\u001b[0m                 \u001b[0;32myield\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1131\u001b[0m                 \u001b[0;31m# Update and possibly print the progressbar.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/torch/utils/data/dataloader.py\u001b[0m in \u001b[0;36m__next__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    344\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__next__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    345\u001b[0m         \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_next_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 346\u001b[0;31m         \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset_fetcher\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# may raise StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    347\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    348\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_utils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpin_memory\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36mfetch\u001b[0;34m(self, possibly_batched_index)\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     45\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/torch/utils/data/_utils/fetch.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m     42\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mfetch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mauto_collation\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0midx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     45\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdataset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpossibly_batched_index\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-2-5b8471debae4>\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, idx)\u001b[0m\n\u001b[1;32m     17\u001b[0m         \u001b[0mpkl_path\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpkl_list\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0midx\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m         \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpkl_path\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m             \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpickle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Training Run\n",
    "for epoch in range(1, n_epochs + 1):\n",
    "    train(newModel, device, fc_loader, optimizer, epoch)\n",
    "    test(newModel, device, fc_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}