rnn.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.nn.utils import clip_grad_norm_\n",
    "from torch.autograd import Variable\n",
    "from torchsummary import summary\n",
    "\n",
    "from torchvision.utils import save_image\n",
    "from IPython.core.display import Image, display\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from vae import VAE\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Device configuration\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Truncated backpropagation\n",
    "def detach(states):\n",
    "    return [state.detach() for state in states] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "bsz = 20\n",
    "epochs = 500\n",
    "seqlen = 30\n",
    "\n",
    "zsize = 32\n",
    "nhidden = 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([20, 1500, 32])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = torch.from_numpy(np.load('z.npy'))\n",
    "z = z.view(bsz, -1, z.size(1)).to(device)\n",
    "z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class V(nn.Module):\n",
    "    def __init__(self, nembed, nhidden=265, nlayers=1):\n",
    "        super(V, self).__init__()\n",
    "\n",
    "        self.nhidden = nhidden\n",
    "        self.nlayers = nlayers\n",
    "        \n",
    "        self.lstm = nn.LSTM(nembed, nhidden, nlayers, batch_first=True)\n",
    "        self.linear = nn.Linear(nhidden, nembed)\n",
    "        \n",
    "    def forward(self, x, h):\n",
    "        # Forward propagate LSTM\n",
    "        out, (h, c) = self.lstm(x, h)\n",
    "        out = self.linear(out)\n",
    "        return out, (h, c)\n",
    "    \n",
    "    def init_hidden(self, bsz):\n",
    "        return (torch.zeros(self.nlayers, bsz, self.nhidden).to(device),\n",
    "                torch.zeros(self.nlayers, bsz, self.nhidden).to(device))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "V(\n",
       "  (lstm): LSTM(32, 256, batch_first=True)\n",
       "  (linear): Linear(in_features=256, out_features=32, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = V(zsize, nhidden).to(device)\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loss and optimizer\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(model.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/500], Loss: 0.2344\n",
      "Epoch [51/500], Loss: 0.0190\n",
      "Epoch [101/500], Loss: 0.0128\n",
      "Epoch [151/500], Loss: 0.0099\n",
      "Epoch [201/500], Loss: 0.0085\n",
      "Epoch [251/500], Loss: 0.0075\n",
      "Epoch [301/500], Loss: 0.0058\n",
      "Epoch [351/500], Loss: 0.0053\n",
      "Epoch [401/500], Loss: 0.0082\n",
      "Epoch [451/500], Loss: 0.0046\n"
     ]
    }
   ],
   "source": [
    "# Train the model\n",
    "for epoch in range(epochs):\n",
    "    # Set initial hidden and cell states\n",
    "    hidden = model.init_hidden(bsz)\n",
    "    \n",
    "    for i in range(0, z.size(1) - seqlen, seqlen):\n",
    "        # Get mini-batch inputs and targets\n",
    "        inputs = z[:, i:i+seqlen, :]\n",
    "        targets = z[:, (i+1):(i+1)+seqlen, :]\n",
    "        \n",
    "        # Forward pass\n",
    "        hidden = detach(hidden)\n",
    "        outputs, hidden = model(inputs, hidden)\n",
    "        loss = criterion(outputs, targets)\n",
    "        \n",
    "        # Backward and optimize\n",
    "        model.zero_grad()\n",
    "        loss.backward()\n",
    "        clip_grad_norm_(model.parameters(), 0.5)\n",
    "        optimizer.step()\n",
    "        \n",
    "    if epoch % 50 == 0:\n",
    "        print ('Epoch [{}/{}], Loss: {:.4f}'\n",
    "               .format(epoch+1, epochs, loss.item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.linalg.norm(z[0, 0, :].cpu().data - z1[0, :, :].cpu().data, axis=1)\n",
    "# np.linalg.norm(inputs.cpu().data - targets.cpu().data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test RNN next frame prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "vae = VAE(image_channels=3).to(device)\n",
    "vae.load_state_dict(torch.load('vae.torch', map_location='cpu'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Frame\t\t\t\t Next Frame\t\t\t Next Frame Prediction\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {
      "image/png": {
       "unconfined": true,
       "width": 900
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "zero = np.random.randint(z.size(0))\n",
    "one = np.random.randint(z.size(1))\n",
    "z_in = z[zero:zero+1, one:one+1, :]\n",
    "z_next = z[zero:zero+1, one+1:one+2, :]\n",
    "\n",
    "hidden = model.init_hidden(1)\n",
    "z_next_pred = model(z_in, hidden)[0]\n",
    "\n",
    "compare_x = torch.cat((vae.decode(z_in), vae.decode(z_next), vae.decode(z_next_pred)))\n",
    "\n",
    "# compare_x = vae.decode(z_out)\n",
    "save_image(compare_x.data.cpu(), 'sample_image.png')\n",
    "print(\"Current Frame\\t\\t\\t\\t\", \"Next Frame\\t\\t\\t\", \"Next Frame Prediction\")\n",
    "display(Image('sample_image.png', width=900, unconfined=True))"
   ]
  },
  {
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}