04_01_ConvTimeLSTM_SeqToOne_Adam.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "import torch.nn as nn\n",
    "from torch.utils import data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import moving MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 10000, 64, 64)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Moving_MNIST = np.load('data/mnist_test_seq.npy')\n",
    "Moving_MNIST = Moving_MNIST / 255\n",
    "Moving_MNIST.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Give `torch` the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([10000, 20, 1, 64, 64])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Making into PyTorch tensor\n",
    "Moving_MNIST_tensor = torch.from_numpy(Moving_MNIST)\n",
    "\n",
    "# Putting the existing dimensions into appropriate order\n",
    "Moving_MNIST_tensor = Moving_MNIST_tensor.permute(1, 0, 2, 3)\n",
    "\n",
    "# Added the acknowledge that this is 1 spectral band\n",
    "Moving_MNIST_tensor = Moving_MNIST_tensor.unsqueeze(2)\n",
    "\n",
    "# Checking shape\n",
    "Moving_MNIST_tensor.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train/validation split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_indices = np.random.choice(range(10000), size = 8000, replace = False)\n",
    "\n",
    "OutofSample_indices = [index for index in range(10000) if index not in train_indices.tolist()]\n",
    "validation_indices = np.random.choice(OutofSample_indices, size = 1000, replace = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Separating $x$ (first $10$ in each sequence) and $y$ (last $10$ in each sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sep_x_y(tensor_to_separate):\n",
    "    x = []\n",
    "    y = []\n",
    "    for i in range(len(tensor_to_separate)):\n",
    "        current_seq = tensor_to_separate[i, :, :, :, :]\n",
    "        for j in range(current_seq.shape[0]):\n",
    "            if j >= 10:\n",
    "                current_x = current_seq[(j-10):j].numpy()\n",
    "                x.append(current_x)\n",
    "                current_y = current_seq[j].unsqueeze(dim = 0).numpy()\n",
    "                y.append(current_y)\n",
    "    x = np.asarray(x)\n",
    "    x = torch.from_numpy(x).type(torch.FloatTensor)\n",
    "    y = np.asarray(y)\n",
    "    y = torch.from_numpy(y).type(torch.FloatTensor)\n",
    "    return(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = sep_x_y(Moving_MNIST_tensor[train_indices])\n",
    "x_validation, y_validation = sep_x_y(Moving_MNIST_tensor[validation_indices])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Viewing the overlaid $(x, y)$ sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random_index = np.random.choice(len(x_validation))\n",
    "\n",
    "for i in range(10):\n",
    "    plt.imshow(x_validation[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "plt.imshow(y_validation[random_index, 0, 0], cmap = 'Reds', alpha = 0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Defining the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvTime_LSTMCell(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size, input_dim, hidden_dim, kernel_size, bias, GPU):\n",
    "        \"\"\"\n",
    "        Initialize ConvTime_LSTM cell.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        input_size: (int, int)\n",
    "            Height and width of input tensor as (height, width).\n",
    "        input_dim: int\n",
    "            Number of channels of input tensor.\n",
    "        hidden_dim: int\n",
    "            Number of channels of hidden state.\n",
    "        kernel_size: (int, int)\n",
    "            Size of the convolutional kernel.\n",
    "        bias: bool\n",
    "            Whether or not to add the bias.\n",
    "        \"\"\"\n",
    "\n",
    "        super(ConvTime_LSTMCell, self).__init__()\n",
    "\n",
    "        self.height, self.width = input_size\n",
    "        self.input_dim  = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "\n",
    "        self.kernel_size = kernel_size\n",
    "        self.padding     = kernel_size[0] // 2, kernel_size[1] // 2\n",
    "        self.bias        = bias\n",
    "        self.GPU         = GPU\n",
    "        \n",
    "        ## Defining the input convolutional layer ##\n",
    "        self.i_conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n",
    "                                out_channels=self.hidden_dim,\n",
    "                                kernel_size=self.kernel_size,\n",
    "                                padding=self.padding,\n",
    "                                bias=self.bias)\n",
    "        \n",
    "        ## Defining the T2 convolutional layer ##\n",
    "        self.T1_conv = nn.Conv2d(in_channels=self.input_dim,\n",
    "                                 out_channels=self.hidden_dim,\n",
    "                                 kernel_size=self.kernel_size,\n",
    "                                 padding=self.padding,\n",
    "                                 bias=self.bias)\n",
    "        \n",
    "        ## Defining the T1 convolutional layer ##\n",
    "        self.T2_conv = nn.Conv2d(in_channels=self.input_dim,\n",
    "                                 out_channels=self.hidden_dim,\n",
    "                                 kernel_size=self.kernel_size,\n",
    "                                 padding=self.padding,\n",
    "                                 bias=self.bias)\n",
    "        \n",
    "        ## Defining the activation convolutional layer ##\n",
    "        self.c_conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n",
    "                                out_channels=self.hidden_dim,\n",
    "                                kernel_size=self.kernel_size,\n",
    "                                padding=self.padding,\n",
    "                                bias=self.bias)\n",
    "        \n",
    "        ## Defining the output convolutional layer ##\n",
    "        self.o_conv = nn.Conv2d(in_channels=self.input_dim + self.hidden_dim,\n",
    "                                out_channels=self.hidden_dim,\n",
    "                                kernel_size=self.kernel_size,\n",
    "                                padding=self.padding,\n",
    "                                bias=self.bias)\n",
    "        \n",
    "        ## Defining the learnable parameter for time scaling ##\n",
    "        self.constrained_scalar = nn.Parameter(torch.rand(1, 1))\n",
    "        self.unconstrained_scalars = nn.Parameter(torch.rand(2, 1))\n",
    "\n",
    "    def forward(self, input_tensor, time_tensor, cur_state):\n",
    "        \n",
    "        \n",
    "        ## Getting the h_{m-1} and c_{m-1} ##\n",
    "        ##     the previous hidden and activations ##\n",
    "        h_cur, c_cur = cur_state\n",
    "        \n",
    "        \n",
    "        ## Getting the (time tensor)*(their learned scalar) ##\n",
    "        ## For T1, with a constrained weight ##\n",
    "        t_T1 = self.constrained_scalar.clamp(max = 0) * time_tensor\n",
    "        ## For T2 and output gate, without constraints ##\n",
    "        t_bands_list = []\n",
    "        for i in range(2):\n",
    "            unconstrained_scalar = self.unconstrained_scalars[i]\n",
    "            scaled_time_tensors = time_tensor * unconstrained_scalar\n",
    "            t_bands_list.append(scaled_time_tensors)\n",
    "        t_T2, t_o = t_bands_list\n",
    "        ## Applying the appropriate non-linearities to t_T1 and t_T2 ##\n",
    "        t_T1 = torch.sigmoid(t_T1)\n",
    "        t_T2 = torch.sigmoid(t_T2)\n",
    "\n",
    "\n",
    "        ## concatenate the prev. hidden state and the current input along the color channel dim ##\n",
    "        x_h_combined = torch.cat([input_tensor, h_cur], dim = 1)\n",
    "        \n",
    "        \n",
    "        ## The input gate ##\n",
    "        ## Running the input convolution ##\n",
    "        i_conv_outputs = self.i_conv(x_h_combined)\n",
    "        ## Running the input LSTM gate equations ##\n",
    "        i_m = torch.sigmoid(i_conv_outputs)\n",
    "        \n",
    "        \n",
    "        ## The first time gate ##\n",
    "        ## Running the first time convolution ##\n",
    "        T1_conv_outputs = self.T1_conv(input_tensor)\n",
    "        T1_conv_outputs = T1_conv_outputs + t_T1\n",
    "        ## Running the T1 LSTM gate equations ##\n",
    "        T1_m = torch.sigmoid(T1_conv_outputs)\n",
    "        \n",
    "        \n",
    "        ## The second time gate ##\n",
    "        ## Running the second time convolution ##\n",
    "        T2_conv_outputs = self.T2_conv(input_tensor)\n",
    "        T2_conv_outputs = T2_conv_outputs + t_T2\n",
    "        ## Running the T2 LSTM gate equations ##\n",
    "        T2_m = torch.sigmoid(T2_conv_outputs)\n",
    "        \n",
    "        \n",
    "        ## The c vectors ##\n",
    "        ## Running the c convolution ##\n",
    "        c_conv_outputs = self.c_conv(x_h_combined)\n",
    "        ## Computing the c tilde and c activation vectors ##\n",
    "        c_m_tilde = (((1 - i_m * T1_m) * c_cur) +\n",
    "                     (i_m * T1_m * torch.tanh(c_conv_outputs)))\n",
    "        c_m = (((1 - i_m) * c_cur) +\n",
    "               (i_m * T2_m * torch.tanh(c_conv_outputs)))\n",
    "        \n",
    "         \n",
    "        ## The output gate ##\n",
    "        ## Running the output gate convolution\n",
    "        o_conv_output = self.o_conv(x_h_combined)\n",
    "        o_conv_output = o_conv_output + t_o\n",
    "        ## Running the output LSTM gate equations\n",
    "        o_m = torch.sigmoid(o_conv_output)\n",
    "        \n",
    "        \n",
    "        ## The hidden vector ##\n",
    "        h_m = o_m * torch.tanh(c_m_tilde)\n",
    "        \n",
    "        \n",
    "        return h_m, c_m\n",
    "\n",
    "    def init_hidden(self, batch_size):\n",
    "        to_return = (Variable(torch.zeros(batch_size, self.hidden_dim, self.height, self.width)),\n",
    "                     Variable(torch.zeros(batch_size, self.hidden_dim, self.height, self.width)))\n",
    "        if self.GPU:\n",
    "            to_return = (to_return[0].cuda(), to_return[1].cuda())\n",
    "        return(to_return)\n",
    "\n",
    "\n",
    "class ConvTime_LSTM(nn.Module):\n",
    "\n",
    "    def __init__(self, input_size, input_dim, hidden_dim, kernel_size, num_layers,\n",
    "                 batch_first, bias, return_all_layers, GPU):\n",
    "        super(ConvTime_LSTM, self).__init__()\n",
    "\n",
    "        self._check_kernel_size_consistency(kernel_size)\n",
    "\n",
    "        # Make sure that both `kernel_size` and `hidden_dim` are lists having len == num_layers\n",
    "        kernel_size = self._extend_for_multilayer(kernel_size, num_layers)\n",
    "        hidden_dim  = self._extend_for_multilayer(hidden_dim, num_layers)\n",
    "        if not len(kernel_size) == len(hidden_dim) == num_layers:\n",
    "            raise ValueError('Inconsistent list length.')\n",
    "\n",
    "        self.height, self.width = input_size\n",
    "\n",
    "        self.input_dim  = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.kernel_size = kernel_size\n",
    "        self.num_layers = num_layers\n",
    "        self.batch_first = batch_first\n",
    "        self.bias = bias\n",
    "        self.return_all_layers = return_all_layers\n",
    "        self.GPU = GPU\n",
    "\n",
    "        cell_list = []\n",
    "        for i in range(0, self.num_layers):\n",
    "            cur_input_dim = self.input_dim if i == 0 else self.hidden_dim[i-1]\n",
    "\n",
    "            cell_list.append(ConvTime_LSTMCell(input_size=(self.height, self.width),\n",
    "                                               input_dim=cur_input_dim,\n",
    "                                               hidden_dim=self.hidden_dim[i],\n",
    "                                               kernel_size=self.kernel_size[i],\n",
    "                                               bias=self.bias,\n",
    "                                               GPU=self.GPU))\n",
    "\n",
    "        self.cell_list = nn.ModuleList(cell_list)\n",
    "\n",
    "    def forward(self, input_tensor, time_tensor, hidden_state=None):\n",
    "        \"\"\"\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        input_tensor: todo \n",
    "            5-D Tensor either of shape (t, b, c, h, w) or (b, t, c, h, w)\n",
    "        hidden_state: todo\n",
    "            None. todo implement stateful\n",
    "            \n",
    "        Returns\n",
    "        -------\n",
    "        last_state_list, layer_output\n",
    "        \"\"\"\n",
    "        \n",
    "        if not self.batch_first:\n",
    "            # (t, b, c, h, w) -> (b, t, c, h, w)\n",
    "            input_tensor.permute(1, 0, 2, 3, 4)\n",
    "\n",
    "        # Implement stateful ConvLSTM\n",
    "        if hidden_state is not None:\n",
    "            raise NotImplementedError()\n",
    "        else:\n",
    "            hidden_state = self._init_hidden(batch_size=input_tensor.size(0))\n",
    "\n",
    "        layer_output_list = []\n",
    "        last_state_list   = []\n",
    "\n",
    "        seq_len = input_tensor.size(1)\n",
    "        cur_layer_input = input_tensor\n",
    "        cur_time_input = time_tensor\n",
    "\n",
    "        for layer_idx in range(self.num_layers):\n",
    "            h, c = hidden_state[layer_idx]\n",
    "            output_inner = []\n",
    "            for t in range(seq_len):\n",
    "\n",
    "                h, c = self.cell_list[layer_idx](input_tensor = cur_layer_input[:, t, :, :, :],\n",
    "                                                 time_tensor = cur_time_input[:, t, :, :, :],\n",
    "                                                 cur_state=[h, c])\n",
    "                output_inner.append(h)\n",
    "\n",
    "            layer_output = torch.stack(output_inner, dim=1)\n",
    "            cur_layer_input = layer_output\n",
    "\n",
    "            layer_output_list.append(layer_output)\n",
    "            last_state_list.append([h, c])\n",
    "\n",
    "        if not self.return_all_layers:\n",
    "            layer_output_list = layer_output_list[-1:]\n",
    "            last_state_list   = last_state_list[-1:]\n",
    "\n",
    "        return layer_output_list, last_state_list\n",
    "\n",
    "    def _init_hidden(self, batch_size):\n",
    "        init_states = []\n",
    "        for i in range(self.num_layers):\n",
    "            init_states.append(self.cell_list[i].init_hidden(batch_size))\n",
    "        return init_states\n",
    "\n",
    "    @staticmethod\n",
    "    def _check_kernel_size_consistency(kernel_size):\n",
    "        if not (isinstance(kernel_size, tuple) or\n",
    "                    (isinstance(kernel_size, list) and all([isinstance(elem, tuple) for elem in kernel_size]))):\n",
    "            raise ValueError('`kernel_size` must be tuple or list of tuples')\n",
    "\n",
    "    @staticmethod\n",
    "    def _extend_for_multilayer(param, num_layers):\n",
    "        if not isinstance(param, list):\n",
    "            param = [param] * num_layers\n",
    "        return param"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Picking one of the like-sequence tensors within the list to set parameters\n",
    "channels = x.shape[2]\n",
    "height = x.shape[3]\n",
    "width = x.shape[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_time_lstm = ConvTime_LSTM(input_size = (height,\n",
    "                                             width),\n",
    "                               input_dim = channels,\n",
    "                               hidden_dim = [128, 64, 64, 1],\n",
    "                               kernel_size = (5, 5),\n",
    "                               num_layers = 4,\n",
    "                               batch_first = True,\n",
    "                               bias = True,\n",
    "                               return_all_layers = False,\n",
    "                               GPU = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ConvTime_LSTM(\n",
       "  (cell_list): ModuleList(\n",
       "    (0): ConvTime_LSTMCell(\n",
       "      (i_conv): Conv2d(129, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv): Conv2d(1, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv): Conv2d(1, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (c_conv): Conv2d(129, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (o_conv): Conv2d(129, 128, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (1): ConvTime_LSTMCell(\n",
       "      (i_conv): Conv2d(192, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (c_conv): Conv2d(192, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (o_conv): Conv2d(192, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (2): ConvTime_LSTMCell(\n",
       "      (i_conv): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv): Conv2d(64, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv): Conv2d(64, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (c_conv): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (o_conv): Conv2d(128, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "    (3): ConvTime_LSTMCell(\n",
       "      (i_conv): Conv2d(65, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T1_conv): Conv2d(64, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (T2_conv): Conv2d(64, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (c_conv): Conv2d(65, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "      (o_conv): Conv2d(65, 1, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_time_lstm.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = torch.nn.MSELoss()\n",
    "optimizer = torch.optim.Adam(conv_time_lstm.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class train_Dataset(data.Dataset):\n",
    "    'Characterizes a dataset for PyTorch'\n",
    "    def __init__(self, data_indices):\n",
    "        'Initialization'\n",
    "        self.data_indices = data_indices\n",
    "    \n",
    "    def __len__(self):\n",
    "        'Denotes the total number of samples'\n",
    "        return len(self.data_indices)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Select sample\n",
    "        IDs = self.data_indices[index]\n",
    "\n",
    "        # Load data and get label\n",
    "        curr_x = x[IDs, :, :, :, :]\n",
    "        curr_y = y[IDs, :, :, :, :]\n",
    "\n",
    "        #return X, y\n",
    "        return(curr_x, curr_y)\n",
    "    \n",
    "class validation_Dataset(data.Dataset):\n",
    "    'Characterizes a dataset for PyTorch'\n",
    "    def __init__(self, data_indices):\n",
    "        'Initialization'\n",
    "        self.data_indices = data_indices\n",
    "    \n",
    "    def __len__(self):\n",
    "        'Denotes the total number of samples'\n",
    "        return len(self.data_indices)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Select sample\n",
    "        IDs = self.data_indices[index]\n",
    "\n",
    "        # Load data and get label\n",
    "        curr_x = x_validation[IDs, :, :, :, :]\n",
    "        curr_y = y_validation[IDs, :, :, :, :]\n",
    "\n",
    "        #return X, y\n",
    "        return(curr_x, curr_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_set = train_Dataset(data_indices=range(y.shape[0]))\n",
    "validation_set = validation_Dataset(data_indices=range(y_validation.shape[0]))\n",
    "\n",
    "batch_size = 64\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(dataset = training_set,\n",
    "                                           batch_size = batch_size,\n",
    "                                           shuffle = True)\n",
    "validation_loader = torch.utils.data.DataLoader(dataset = validation_set,\n",
    "                                                batch_size = batch_size,\n",
    "                                                shuffle = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_time_lstm = torch.nn.DataParallel(conv_time_lstm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:  0 \n",
      "\tBatch loss:  0.016040362417697906 \n",
      "\n",
      "Epoch:  1 \n",
      "\tBatch loss:  0.015307961031794548 \n",
      "\n",
      "Epoch:  2 \n",
      "\tBatch loss:  0.011756250634789467 \n",
      "\n",
      "Epoch:  3 \n",
      "\tBatch loss:  0.012823062017560005 \n",
      "\n",
      "Epoch:  4 \n",
      "\tBatch loss:  0.011319277808070183 \n",
      "\n",
      "Epoch:  5 \n",
      "\tBatch loss:  0.011674477718770504 \n",
      "\n",
      "Epoch:  6 \n",
      "\tBatch loss:  0.01063500251621008 \n",
      "\n",
      "Epoch:  7 \n",
      "\tBatch loss:  0.009473486803472042 \n",
      "\n",
      "Epoch:  8 \n",
      "\tBatch loss:  0.009690665639936924 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "loss_list = []\n",
    "epochs = int(np.ceil((7*10**5) / x.shape[0]))\n",
    "for i in range(epochs):\n",
    "    for data in train_loader:\n",
    "        \n",
    "        # data loader\n",
    "        batch_x, batch_y = data\n",
    "        \n",
    "        # move to GPU\n",
    "        batch_x = batch_x.to(device)\n",
    "        batch_y = batch_y.to(device)\n",
    "        \n",
    "        # run model and get the prediction\n",
    "        batch_y_hat = conv_time_lstm(batch_x,\n",
    "                                     torch.ones_like(batch_x))\n",
    "        batch_y_hat = batch_y_hat[0][0][:, -2:-1, :, :, :]\n",
    "        \n",
    "        # calculate and store the loss\n",
    "        batch_loss = loss(batch_y, batch_y_hat)\n",
    "        loss_list.append(batch_loss.item())\n",
    "        \n",
    "        # update parameters\n",
    "        optimizer.zero_grad()\n",
    "        batch_loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    print('Epoch: ', i, '\\n\\tBatch loss: ', batch_loss.item(), '\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(loss_list,\n",
    "         color = 'cyan',\n",
    "         label = 'Batch')\n",
    "plt.plot(np.convolve(loss_list, 1/10*np.ones(10))[10:-10],\n",
    "         color = 'navy',\n",
    "         label = 'Running average')\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting random predictions for the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "rand_x, rand_y = next(iter(validation_loader))\n",
    "\n",
    "rand_y_hat = conv_time_lstm(rand_x.to(device),\n",
    "                            torch.ones_like(rand_x).to(device))[0][0][:, -2:-1, :, :, :]\n",
    "rand_y_hat = rand_y_hat.cpu().data.numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Viewing random predictions for the validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_random_validation_pred():\n",
    "    f, axarr = plt.subplots(1, 2)\n",
    "    f.set_figheight(4)\n",
    "    f.set_figwidth(8)\n",
    "    random_index = np.random.choice(len(rand_x))\n",
    "    for i in range(10):\n",
    "        axarr[0].imshow(rand_x[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "        axarr[1].imshow(rand_x[random_index, i, 0], alpha = 0.25, cmap = 'gist_gray')\n",
    "    axarr[0].imshow(rand_y[random_index, 0, 0], cmap = 'Reds', alpha = 0.5)\n",
    "    axarr[0].set_title('Red = True', fontsize = 15)\n",
    "    axarr[1].imshow(rand_y_hat[random_index, 0, 0], cmap = 'Greens', alpha = 0.5)\n",
    "    axarr[1].set_title('Green = Predicted', fontsize = 15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_random_validation_pred()\n",
    "plot_random_validation_pred()\n",
    "plot_random_validation_pred()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def overlay_pred_true():\n",
    "    random_index = np.random.choice(len(rand_x))\n",
    "    plt.imshow(rand_y[random_index, 0, 0], cmap = 'Reds', alpha = 0.5)\n",
    "    plt.imshow(rand_y_hat[random_index, 0, 0], cmap = 'Greens', alpha = 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "overlay_pred_true()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mimicking sequence-to-sequence by shuffling in predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x216 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "random_index = np.random.choice(len(rand_x) - 1)\n",
    "rand_x = rand_x[random_index:(random_index+1)]\n",
    "\n",
    "for i in range(10):\n",
    "    f, axarr = plt.subplots(1, 2)\n",
    "    f.set_figheight(3)\n",
    "    f.set_figwidth(6)\n",
    "    axarr[0].imshow(rand_x[0, 0, 0], cmap = 'gist_gray')\n",
    "    rand_y_hat = conv_time_lstm(rand_x.to(device),\n",
    "                                torch.ones_like(rand_x.to(device)))[0][0][:, -2:-1, :, :, :]\n",
    "    axarr[1].imshow(rand_y_hat[0, 0, 0].data.cpu().numpy(), cmap = 'Greens')\n",
    "    rand_x = torch.cat([rand_x, rand_y_hat.data.cpu()], dim = 1)\n",
    "    rand_x = rand_x[:, 1:]\n",
    "    plt.pause(0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving the model weights for transfer learning to MissingMNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type ConvTime_LSTM. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n",
      "/usr/local/lib/python3.5/dist-packages/torch/serialization.py:256: UserWarning: Couldn't retrieve source code for container of type ConvTime_LSTMCell. It won't be checked for correctness upon loading.\n",
      "  \"type \" + obj.__name__ + \". It won't be checked \"\n"
     ]
    }
   ],
   "source": [
    "torch.save(conv_time_lstm, 'ConvTimeLSTMSavedModel.pt')"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}