RIM_FINAL.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "toc": {
      "base_numbering": 1,
      "nav_menu": {},
      "number_sections": true,
      "sideBar": true,
      "skip_h1_title": false,
      "title_cell": "Table of Contents",
      "title_sidebar": "Contents",
      "toc_cell": false,
      "toc_position": {},
      "toc_section_display": true,
      "toc_window_display": false
    },
    "varInspector": {
      "cols": {
        "lenName": 16,
        "lenType": 16,
        "lenVar": 40
      },
      "kernels_config": {
        "python": {
          "delete_cmd_postfix": "",
          "delete_cmd_prefix": "del ",
          "library": "var_list.py",
          "varRefreshCmd": "print(var_dic_list())"
        },
        "r": {
          "delete_cmd_postfix": ") ",
          "delete_cmd_prefix": "rm(",
          "library": "var_list.r",
          "varRefreshCmd": "cat(var_dic_list()) "
        }
      },
      "types_to_exclude": [
        "module",
        "function",
        "builtin_function_or_method",
        "instance",
        "_Feature"
      ],
      "window_display": false
    },
    "colab": {
      "name": "Putzky Code.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/EmaadKhwaja/Deep-Learning-Denoising/blob/master/Putzky%20Code.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:27.269385Z",
          "start_time": "2020-05-01T06:42:27.264427Z"
        },
        "id": "orNNJNVZM2P9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "BATCH_SIZE=50\n",
        "CROP_SIZE=300\n",
        "\n",
        "TRAIN_DATA_PATH = \"drive/My Drive/Research/Graduate School/Bo Huang Rotation/Deep-Learning-Denoising-master/Confocal_BPAE_B/raw\"\n",
        "GT_DATA_PATH = \"drive/My Drive/Research/Graduate School/Bo Huang Rotation/Deep-Learning-Denoising-master/Confocal_BPAE_B/gt\"\n",
        "NOISE_WEIGHT = 1\n",
        "\n",
        "VALIDATION_PCT = .2\n",
        "RANDOM_SEED = 42\n",
        "SHUFFLE_DATASET = True\n",
        "\n",
        "MAX_T=10\n",
        "EPOCHS=1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aPPZu2sYOlv4",
        "colab_type": "code",
        "outputId": "119d51a6-3e89-4830-c097-213997b6756f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:27.880789Z",
          "start_time": "2020-05-01T06:42:27.830555Z"
        },
        "id": "rR0EIZkVM2Qa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import sys\n",
        "sys.path.append(\"drive/My Drive/Research/Graduate School/Bo Huang Rotation/Deep-Learning-Denoising-master\")\n",
        "\n",
        "from IPython.display import clear_output\n",
        "%matplotlib inline\n",
        "\n",
        "import logging\n",
        "import numpy as np\n",
        "from numpy import inf\n",
        "from skimage.metrics import structural_similarity as ssm\n",
        "from scipy.special import factorial\n",
        "from matplotlib import pyplot as plt\n",
        "\n",
        "\n",
        "import torch\n",
        "import torch.utils.data as data\n",
        "from torch.utils.data import Dataset\n",
        "from torch.utils.data import DataLoader\n",
        "from torch.utils.data.sampler import SequentialSampler\n",
        "import torch.nn as nn\n",
        "from torch.nn import MSELoss\n",
        "from torch.autograd import Variable\n",
        "from torch.optim import Adam\n",
        "import torch.nn.functional as f\n",
        "from torch.autograd import Variable\n",
        "\n",
        "\n",
        "\n",
        "import torchvision\n",
        "from torchvision import transforms\n",
        "\n",
        "\n",
        "\n",
        "from util import show, plot_images, plot_tensors"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:28.454339Z",
          "start_time": "2020-05-01T06:42:28.430195Z"
        },
        "id": "qadbL8z-M2Q0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class gtmatch():\n",
        "    def __init__(self, dataset1, dataset2, batch_size):\n",
        "        self.dataset1 = dataset1\n",
        "        self.dataset2 = dataset2\n",
        "        self.batch_size=batch_size\n",
        "\n",
        "    def __getitem__(self, index):\n",
        "        x = self.dataset1[index][0]\n",
        "        y = self.dataset2[int(index / self.batch_size % self.batch_size)][0]\n",
        "        return x, y\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.dataset1)\n",
        "    \n",
        "  \n",
        "\n",
        "class log_funcs():\n",
        "    def __init__(self, updated, noise_ref):\n",
        "        self.updated=updated\n",
        "        self.noise_ref=noise_ref\n",
        "\n",
        "    def poisson_log(Ax, b):\n",
        "        # from https://stanford.edu/class/ee367/reading/lecture10_notes.pdf\n",
        "        Ax, b =Ax.detach(), b.detach()\n",
        "        term1 = np.log(Ax.cpu())*b.cpu()\n",
        "        term2 = Ax.cpu()\n",
        "        term3 = torch.from_numpy(np.log(factorial(b.cpu())))\n",
        "        \n",
        "        loglikelihood = term1 - term2 - term3\n",
        "        loglikelihood[np.isnan(loglikelihood)==True]=-10000000\n",
        "        loglikelihood[np.isinf(loglikelihood)==True]=-10000000\n",
        "        return loglikelihood[0]\n",
        "    \n",
        "    def gradient(updated, noise_ref):\n",
        "        grad_ll = []\n",
        "        zero_matrix = torch.zeros([noise_ref.shape[2], noise_ref.shape[3]], dtype=torch.double)\n",
        "        \n",
        "        ll_sum=zero_matrix.detach()\n",
        "        llh_sum=zero_matrix.detach()\n",
        "\n",
        "        for i, Ax in enumerate(noise_ref):\n",
        "            b = updated[i]\n",
        "            b_plus = updated[i]+.0001\n",
        "            \n",
        "            # Poisson log-likelihood\n",
        "            loglikelihood = log_funcs.poisson_log(Ax, b)\n",
        "            loglikelihood_plus = log_funcs.poisson_log(Ax, b_plus)\n",
        "\n",
        "        \n",
        "            grad=(loglikelihood_plus-loglikelihood)/.0001\n",
        "            grad_ll.append(grad)\n",
        "            \n",
        "        return torch.stack(grad_ll).unsqueeze(1).float()\n",
        "\n",
        "\n",
        "        \n",
        "def add_noise(clean_images,noise_weight,noise_type):\n",
        "    clean_np = np.clip(clean_images.detach().cpu().numpy(),0,1)\n",
        "\n",
        "    if 'Poisson' in noise_type:\n",
        "        noise_mask = np.random.poisson(clean_np)\n",
        "    else:\n",
        "        noise_mask= clean_np*0\n",
        "\n",
        "    noisy_images = torch.clamp(torch.from_numpy(clean_np+(noise_mask*noise_weight)),0,1).float() \n",
        "    return noisy_images\n",
        "\n",
        "\n",
        "def live_plot(data, figsize=(7,5), title=''):\n",
        "    plt.figure(figsize=figsize)\n",
        "    plt.plot(data)\n",
        "    plt.title(title)\n",
        "    plt.grid(True)\n",
        "    plt.xlabel('Iteration')\n",
        "    clear_output(wait=True)\n",
        "    plt.show();"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:28.896638Z",
          "start_time": "2020-05-01T06:42:28.818476Z"
        },
        "code_folding": [
          38
        ],
        "id": "Iof_I5aeM2RE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "class InputRNN(torch.nn.Module):\n",
        "\n",
        "    def __init__(self, rnn_cell=None, input_fun=None):\n",
        "        super(InputRNN, self).__init__()\n",
        "\n",
        "        self.rnn_cell = rnn_cell\n",
        "        self.input_fun = input_fun\n",
        "\n",
        "    def forward(self, x, hx=None):\n",
        "\n",
        "        if self.input_fun is not None:\n",
        "            x = self.input_fun.forward(x)\n",
        "        if self.rnn_cell is not None:\n",
        "            x = self.rnn_cell.forward(x)\n",
        "            hx = x\n",
        "\n",
        "        return x, hx\n",
        "\n",
        "class ConvNonlinear(nn.Module):\n",
        "\n",
        "    def __init__(self, input_size, features, conv_dim, kernel_size, dilation, bias, nonlinear='relu'):\n",
        "        super(ConvNonlinear, self).__init__()\n",
        "\n",
        "        self.input_size = input_size\n",
        "        self.features = features\n",
        "        self.bias = bias\n",
        "        self.conv_dim = conv_dim\n",
        "        self.conv_class = self.determine_conv_class(conv_dim)\n",
        "        if nonlinear is not None and nonlinear.upper() == 'RELU':\n",
        "            self.nonlinear = torch.nn.ReLU()\n",
        "        elif nonlinear is None:\n",
        "            self.nonlinear = lambda x: x\n",
        "        else:\n",
        "            ValueError('Please specify a proper')\n",
        "\n",
        "        self.padding = [torch.nn.ReplicationPad1d(dilation * (kernel_size-1) // 2),\n",
        "                        torch.nn.ReplicationPad2d(dilation * (kernel_size-1) // 2),\n",
        "                        torch.nn.ReplicationPad3d(dilation * (kernel_size - 1) // 2)][conv_dim-1]\n",
        "        self.conv_layer =  self.conv_class(in_channels=input_size, out_channels=features,\n",
        "                             kernel_size=kernel_size, padding=0,\n",
        "                             dilation=dilation, bias=bias)\n",
        "\n",
        "        self.reset_parameters()\n",
        "\n",
        "    def reset_parameters(self):\n",
        "        torch.nn.init.kaiming_normal_(self.conv_layer.weight, nonlinearity='relu')\n",
        "\n",
        "        if self.conv_layer.bias is not None:\n",
        "            nn.init.zeros_(self.conv_layer.bias)\n",
        "\n",
        "    def determine_conv_class(self, n_dim):\n",
        "\n",
        "        if n_dim is 1:\n",
        "            return nn.Conv1d\n",
        "        elif n_dim is 2:\n",
        "            return nn.Conv2d\n",
        "        elif n_dim is 3:\n",
        "            return nn.Conv3d\n",
        "        else:\n",
        "            NotImplementedError(\"No convolution of this dimensionality implemented\")\n",
        "\n",
        "    def extra_repr(self):\n",
        "        s = '{input_size}, {features}'\n",
        "        if 'bias' in self.__dict__ and self.bias is not True:\n",
        "            s += ', bias={bias}'\n",
        "        if 'nonlinear' in self.__dict__ and self.nonlinear != \"tanh\":\n",
        "            s += ', nonlinearity={nonlinear}'\n",
        "        return s.format(**self.__dict__)\n",
        "\n",
        "    def check_forward_input(self, input):\n",
        "        if input.size(1) != self.input_size:\n",
        "            raise RuntimeError(\n",
        "                \"input has inconsistent input_size: got {}, expected {}\".format(\n",
        "                    input.size(1), self.input_size))\n",
        "\n",
        "    def forward(self, input):\n",
        "        return self.nonlinear(self.conv_layer(self.padding(input)))\n",
        "\n",
        "\n",
        "class ConvRNNCellBase(nn.Module):\n",
        "\n",
        "    def __init__(self, input_size, hidden_size, num_chunks, conv_dim, kernel_size,\n",
        "                dilation, bias):\n",
        "        super(ConvRNNCellBase, self).__init__()\n",
        "\n",
        "        self.input_size = input_size\n",
        "        self.hidden_size = hidden_size\n",
        "        self.bias = bias\n",
        "        self.num_chunks = num_chunks\n",
        "        self.conv_dim = conv_dim\n",
        "        self.conv_class = self.determine_conv_class(conv_dim)\n",
        "        self.ih = self.conv_class(in_channels=input_size, out_channels=num_chunks*hidden_size,\n",
        "                             kernel_size=kernel_size, padding=dilation * (kernel_size-1)//2,\n",
        "                             dilation=dilation, bias=bias)\n",
        "        self.hh = self.conv_class(in_channels=hidden_size, out_channels=num_chunks*hidden_size,\n",
        "                             kernel_size=kernel_size, padding=dilation * (kernel_size-1)//2,\n",
        "                             dilation=dilation, bias=bias)\n",
        "        self.reset_parameters()\n",
        "\n",
        "    def reset_parameters(self):\n",
        "\n",
        "        self.ih.weight.data = self.orthotogonalize_weights(self.ih.weight.data)\n",
        "        self.hh.weight.data = self.orthotogonalize_weights(self.hh.weight.data)\n",
        "\n",
        "        if self.bias is True:\n",
        "            nn.init.zeros_(self.ih.bias)\n",
        "            nn.init.zeros_(self.hh.bias)\n",
        "\n",
        "    def orthotogonalize_weights(self, weights, chunks=1):\n",
        "        return torch.cat([nn.init.orthogonal_(w) for w in weights.chunk(chunks,0)],0)\n",
        "\n",
        "    def determine_conv_class(self, n_dim):\n",
        "\n",
        "        if n_dim is 1:\n",
        "            return nn.Conv1d\n",
        "        elif n_dim is 2:\n",
        "            return nn.Conv2d\n",
        "        elif n_dim is 3:\n",
        "            return nn.Conv3d\n",
        "        else:\n",
        "            NotImplementedError(\"No convolution of this dimensionality implemented\")\n",
        "\n",
        "    def extra_repr(self):\n",
        "        s = '{input_size}, {hidden_size}'\n",
        "        if 'bias' in self.__dict__ and self.bias is not True:\n",
        "            s += ', bias={bias}'\n",
        "        if 'nonlinearity' in self.__dict__ and self.nonlinearity != \"tanh\":\n",
        "            s += ', nonlinearity={nonlinearity}'\n",
        "        return s.format(**self.__dict__)\n",
        "\n",
        "    def check_forward_input(self, input):\n",
        "        if input.size(1) != self.input_size:\n",
        "            raise RuntimeError(\n",
        "                \"input has inconsistent input_size: got {}, expected {}\".format(\n",
        "                    input.size(1), self.input_size))\n",
        "\n",
        "    def check_forward_hidden(self, input, hx, hidden_label=''):\n",
        "        if input.size(0) != hx.size(0):\n",
        "            raise RuntimeError(\n",
        "                \"Input batch size {} doesn't match hidden{} batch size {}\".format(\n",
        "                    input.size(0), hidden_label, hx.size(0)))\n",
        "\n",
        "        if hx.size(1) != self.hidden_size:\n",
        "            raise RuntimeError(\n",
        "                \"hidden{} has inconsistent hidden_size: got {}, expected {}\".format(\n",
        "                    hidden_label, hx.size(1), self.hidden_size))\n",
        "\n",
        "\n",
        "class ConvGRUCell(ConvRNNCellBase):\n",
        "    \"\"\"\n",
        "    This is an implementation of a Convolutional GRU Cell following the Pytorch implementation\n",
        "    of a GRU. Here, the fully connected linear transforms are simply replaced by convolutional\n",
        "    linear transforms.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, input_size, hidden_size, conv_dim, kernel_size, dilation=1, bias=True):\n",
        "        super(ConvGRUCell, self).__init__(input_size=input_size, hidden_size=hidden_size,\n",
        "                                          num_chunks=3, conv_dim=conv_dim, kernel_size=kernel_size,\n",
        "                                          dilation=dilation, bias=bias)\n",
        "\n",
        "    def forward(self, input, hx=None):\n",
        "        # self.check_forward_input(input)\n",
        "        if hx is None:\n",
        "            hx = input.new_zeros((input.size(0), self.hidden_size) + input.size()[2:],\n",
        "                                 requires_grad=False)\n",
        "        # self.check_forward_hidden(input, hx)\n",
        "\n",
        "        ih = self.ih(input).chunk(3,dim=1)\n",
        "        hh = self.hh(hx).chunk(3,dim=1)\n",
        "\n",
        "        z = torch.sigmoid(ih[0] + hh[0])\n",
        "        r = torch.sigmoid(ih[1] + hh[1])\n",
        "        n = torch.tanh(ih[2] + r*hh[2])\n",
        "\n",
        "        hx = (1. - z) * hx + z * n\n",
        "\n",
        "\n",
        "        return hx\n",
        "\n",
        "class ConvRNN(nn.Module):\n",
        "\n",
        "    def __init__(self, input_size,\n",
        "                 conv_params={'features':[64, 64, 2], 'k_size':[5, 3, 3],'dilation':[1, 2, 1],'bias':[True,True,False],\n",
        "                              'nonlinear':['relu','relu',None]},\n",
        "                 rnn_params={'features':[64, 64, 0], 'k_size':[1, 1, 0], 'dilation':[1, 1, 0], 'bias': [True,True, False],\n",
        "                             'rnn_type': ['gru','gru',None]},\n",
        "                 conv_dim=2):\n",
        "        '''\n",
        "        Generates a multi-layer convolutional GRU.\n",
        "        Preserves spatial dimensions across cells, only altering depth.\n",
        "\n",
        "        Parameters\n",
        "        ----------\n",
        "        input_size : integer. depth dimension of input tensors.\n",
        "        hidden_sizes : integer or list. depth dimensions of hidden state.\n",
        "            if integer, the same hidden size is used for all cells.\n",
        "        kernel_sizes : integer or list. sizes of Conv2d gate kernels.\n",
        "            if integer, the same kernel size is used for all cells.\n",
        "        n_layers : integer. number of chained `ConvGRUCell`.\n",
        "        '''\n",
        "\n",
        "        super(ConvRNN, self).__init__()\n",
        "\n",
        "        self.input_size = input_size\n",
        "        self.conv_dim = conv_dim\n",
        "        self.conv_params = conv_params\n",
        "        self.rnn_params = rnn_params\n",
        "\n",
        "        conv_params = zip(*(conv_params[k] for k in ['features', 'k_size', 'dilation', 'bias', 'nonlinear']))\n",
        "        rnn_params = zip(*(rnn_params[k] for k in ['features', 'k_size', 'dilation', 'bias', 'rnn_type']))\n",
        "\n",
        "        self.layers = nn.ModuleList()\n",
        "        for (conv_features, conv_k_size, conv_dilation, conv_bias, nonlinear), \\\n",
        "            (rnn_features, rnn_k_size, rnn_dilation, rnn_bias, rnn_type) in zip(conv_params, rnn_params):\n",
        "            conv_layer = None\n",
        "            rnn_layer = None\n",
        "\n",
        "            if conv_features > 0:\n",
        "                conv_layer = ConvNonlinear(input_size, conv_features, conv_dim=self.conv_dim,\n",
        "                                           kernel_size=conv_k_size, dilation=conv_dilation, bias=conv_bias,\n",
        "                                           nonlinear=nonlinear)\n",
        "                input_size = conv_features\n",
        "\n",
        "            if rnn_features > 0 and rnn_type is not None:\n",
        "                if rnn_type.upper() == 'GRU':\n",
        "                    rnn_type = ConvGRUCell\n",
        "                elif issubclass(rnn_type, ConvRNNCellBase):\n",
        "                    rnn_type = rnn_type\n",
        "                else:\n",
        "                    ValueError('Please speacify a proper rrn_type')\n",
        "\n",
        "                rnn_layer = rnn_type(input_size, rnn_features, conv_dim=self.conv_dim,\n",
        "                                          kernel_size=rnn_k_size, dilation=rnn_dilation, bias=rnn_bias)\n",
        "                input_size = rnn_features\n",
        "\n",
        "            self.layers.append(InputRNN(rnn_layer, conv_layer))\n",
        "\n",
        "    def forward(self, input, hx=None):\n",
        "        if not hx:\n",
        "            hx = [None]*len(self.layers)\n",
        "\n",
        "        hidden_new = []\n",
        "\n",
        "        for layer, local_hx in zip(self.layers,hx):\n",
        "            input, new_hx = layer.forward(input, local_hx)\n",
        "            hidden_new.append(new_hx)\n",
        "\n",
        "        return input, hidden_new"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:29.796333Z",
          "start_time": "2020-05-01T06:42:29.785425Z"
        },
        "id": "Wm2fSnKNM2RR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "\n",
        "class RIM(nn.Module):\n",
        "\n",
        "    def __init__(self, rnn, grad_fun):\n",
        "        super(RIM, self).__init__()\n",
        "        self.rnn = rnn\n",
        "        self.grad_fun = grad_fun\n",
        "\n",
        "    def forward(self, eta, data, hx=None, n_steps=1, accumulate_eta=False):\n",
        "        \"\"\"\n",
        "        :param eta: Starting value for eta [n_batch,features,height,width]\n",
        "        :param grad_fun: The gradient function, takes as input eta and outputs gradient of same dimensionality\n",
        "        :param hx: Hidden state of the RNN\n",
        "        :param n_steps: Number of time steps, that the RIM should perform. Default: 1\n",
        "        :param accumulate_eta: Bool, if True will save all intermediate etas in a list, else outputs only the last eta.\n",
        "                               Default: False\n",
        "        :return: etas, hx\n",
        "        \"\"\"\n",
        "        etas = []\n",
        "\n",
        "        for i in range(n_steps):\n",
        "            \n",
        "                        \n",
        "            eta=eta.permute(1,0,2,3)[0].unsqueeze(1)\n",
        "            grad_eta = self.grad_fun(eta, data).to(device)\n",
        "\n",
        "            x_in = torch.cat((eta, grad_eta), 1)\n",
        "\n",
        "            delta, hx = self.rnn.forward(x_in, hx)\n",
        "            eta = eta + delta\n",
        "\n",
        "            if accumulate_eta:\n",
        "                etas.append(eta)\n",
        "\n",
        "        if not accumulate_eta:\n",
        "            etas = eta\n",
        "\n",
        "        return etas, hx\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:30.507709Z",
          "start_time": "2020-05-01T06:42:30.504583Z"
        },
        "id": "zhnVe-jpM2Rc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:31.143500Z",
          "start_time": "2020-05-01T06:42:31.095869Z"
        },
        "id": "43wr8wdeM2Rm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "# load and sort dataset\n",
        "TRANSFORM_IMG = transforms.Compose([\n",
        "    transforms.RandomCrop(CROP_SIZE),\n",
        "    transforms.Grayscale(num_output_channels=1),\n",
        "    transforms.ToTensor()\n",
        "])\n",
        "\n",
        "train_data = torchvision.datasets.ImageFolder(\n",
        "    root=TRAIN_DATA_PATH, transform=TRANSFORM_IMG)\n",
        "#gt_data = torchvision.datasets.ImageFolder(root=GT_DATA_PATH, transform=TRANSFORM_IMG)\n",
        "\n",
        "#newdataset = gtmatch(train_data, gt_data, BATCH_SIZE)\n",
        "newdataset=train_data\n",
        "\n",
        "# Creating data indices for training and validation splits:\n",
        "dataset_size = len(newdataset)\n",
        "indices = list(range(dataset_size))\n",
        "\n",
        "\n",
        "\n",
        "split = int(np.floor(VALIDATION_PCT * dataset_size))\n",
        "\n",
        "\n",
        "train_indices, val_indices = indices[split:], indices[:split]\n",
        "\n",
        "if SHUFFLE_DATASET:\n",
        "    np.random.seed(RANDOM_SEED)\n",
        "    np.random.shuffle(train_indices)\n",
        "    np.random.shuffle(val_indices)\n",
        "\n",
        "# Creating PT data samplers and loaders:\n",
        "train_sampler = SequentialSampler(train_indices)\n",
        "valid_sampler = SequentialSampler(val_indices)\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(\n",
        "    newdataset, batch_size=1, sampler=train_sampler)\n",
        "validation_loader = torch.utils.data.DataLoader(newdataset, batch_size=1,\n",
        "                                                sampler=valid_sampler)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:31.919574Z",
          "start_time": "2020-05-01T06:42:31.725541Z"
        },
        "id": "UpompUNiM2Rw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "step_models=ConvRNN(2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:42:32.242787Z",
          "start_time": "2020-05-01T06:42:32.225957Z"
        },
        "scrolled": true,
        "id": "4m9uOstRM2R4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "grad_fun=log_funcs.gradient\n",
        "model = RIM(step_models,grad_fun)\n",
        "model = model.to(device)\n",
        "loss_function = MSELoss()\n",
        "optimizer = Adam(model.parameters(), lr=0.001)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "ExecuteTime": {
          "end_time": "2020-05-01T06:46:42.262657Z",
          "start_time": "2020-05-01T06:42:32.955569Z"
        },
        "id": "EBzYFx3nM2SC",
        "colab_type": "code",
        "outputId": "e590ebd0-7519-4a1a-a279-20a91ae206d2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 365
        }
      },
      "source": [
        "losses = []\n",
        "avg_grad_logs = []\n",
        "val_losses = []\n",
        "best_val_loss = 1\n",
        "loss = 'null'\n",
        "\n",
        "data_loader = train_loader\n",
        "\n",
        "torch.cuda.empty_cache()\n",
        "\n",
        "\n",
        "for i in range(EPOCHS):\n",
        "  for i, batch in enumerate(data_loader):\n",
        "      clean_images, gt = batch\n",
        "      noise=torch.distributions.poisson.Poisson(clean_images.detach()).sample()*NOISE_WEIGHT\n",
        "      #gaussian=torch.randn(clean_images.size())*NOISE_WEIGHT/15\n",
        "      noisy_images=clean_images+noise\n",
        "      clean_images=clean_images.to(device)\n",
        "      eta = torch.zeros(noisy_images.shape).to(device)\n",
        "\n",
        "      optimizer.zero_grad()\n",
        "      model.zero_grad()\n",
        "      \n",
        "      eta, hx = model.forward(eta,noisy_images,n_steps=MAX_T)\n",
        "\n",
        "\n",
        "\n",
        "      loss = torch.nn.functional.mse_loss(eta[0,0], clean_images[0,0])\n",
        "\n",
        "      eta=eta.detach()\n",
        "\n",
        "\n",
        "      loss.backward()\n",
        "\n",
        "\n",
        "      optimizer.step()\n",
        "\n",
        "      losses.append(loss.item())\n",
        "\n",
        "      live_plot(losses,title=\"Losses\\nCurrent Loss: \"+str(loss.item()))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7D-tEkTpa9ni",
        "colab_type": "code",
        "outputId": "d3f5577c-ed21-4b05-fb4f-975f1dfb6438",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        }
      },
      "source": [
        "from skimage.measure import compare_psnr\n",
        "model.eval()\n",
        "best_images=[]\n",
        "best_images_labels=[]\n",
        "best_loss=1\n",
        "snrs=[]\n",
        "ssim=[]\n",
        "\n",
        "for i, batch in enumerate(validation_loader):\n",
        "\n",
        "    with torch.no_grad():\n",
        "      clean_images, gt = batch\n",
        "      noise=torch.distributions.poisson.Poisson(clean_images.detach()).sample()*NOISE_WEIGHT\n",
        "      #gaussian=torch.randn(clean_images.size())*NOISE_WEIGHT/15\n",
        "      noisy_images=clean_images+noise\n",
        "\n",
        "\n",
        "      eta = torch.zeros(noisy_images.shape).to(device)\n",
        "\n",
        "\n",
        "      output, hx = model.forward(eta, noisy_images,n_steps=MAX_T)\n",
        "      output=output.cpu()\n",
        "      loss = torch.nn.functional.mse_loss(output[0,0], clean_images[0,0])\n",
        "      loss_noisy = torch.nn.functional.mse_loss(noisy_images[0,0], clean_images[0,0])\n",
        "\n",
        "      if loss<best_loss:\n",
        "        denoised=torch.clamp(output[0,0],0,1)\n",
        "        best_images.append([noisy_images[0,0],denoised,clean_images[0,0]])\n",
        "\n",
        "        noisy_np=noisy_images[0,0].detach().cpu().numpy()\n",
        "        denoised_np=denoised.detach().cpu().numpy()\n",
        "        clean_np=clean_images[0,0].detach().cpu().numpy()\n",
        "\n",
        "        ssm_base=round(ssm(clean_np,clean_np),2)\n",
        "        ssm_denoised=round(ssm(clean_np,denoised_np),2)\n",
        "        ssm_noisy=round(ssm(clean_np,noisy_np),2)\n",
        "\n",
        "        PSNR_base=round(compare_psnr(clean_np,clean_np),2)\n",
        "        PSNR_denoised=round(compare_psnr(clean_np,denoised_np),2)\n",
        "        PSNR_noisy=round(compare_psnr(clean_np,noisy_np),2)\n",
        "\n",
        "        input_label=\"Input\\nSSIM: \" + str(ssm_noisy) + \"\\nPSNR: \" + str(PSNR_noisy)\n",
        "        denoised_label=\"Denoised\\nSSIM: \" + str(ssm_denoised) + \"\\nPSNR: \" + str(PSNR_denoised)\n",
        "        base_label=\"Ground Truth\\nSSIM: \" + str(ssm_base) + \"\\nPSNR: \" + str(PSNR_base)\n",
        "\n",
        "        best_images_labels.append([input_label,denoised_label,base_label])\n",
        "        snrs.append(PSNR_denoised)\n",
        "        ssim.append(ssm_denoised)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:27: RuntimeWarning: divide by zero encountered in log\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:38: UserWarning: DEPRECATED: skimage.measure.compare_psnr has been moved to skimage.metrics.peak_signal_noise_ratio. It will be removed from skimage.measure in version 0.18.\n",
            "/usr/local/lib/python3.6/dist-packages/skimage/metrics/simple_metrics.py:160: RuntimeWarning: divide by zero encountered in double_scalars\n",
            "  return 10 * np.log10((data_range ** 2) / err)\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:39: UserWarning: DEPRECATED: skimage.measure.compare_psnr has been moved to skimage.metrics.peak_signal_noise_ratio. It will be removed from skimage.measure in version 0.18.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:40: UserWarning: DEPRECATED: skimage.measure.compare_psnr has been moved to skimage.metrics.peak_signal_noise_ratio. It will be removed from skimage.measure in version 0.18.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y58iKpBpj1_G",
        "colab_type": "code",
        "outputId": "47b69ddb-bdfe-4d7f-c9dc-264200bad034",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        }
      },
      "source": [
        "idx=len(best_images)-5\n",
        "a=plot_tensors(best_images[idx],best_images_labels[idx])\n",
        "print(\"Average SSIM: \"+ str(np.mean(ssim)) + \"\\nAverage PSNR: \" + str(np.mean(snrs)))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Average SSIM: 0.9018\n",
            "Average PSNR: 31.612599999999997\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x288 with 3 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IqPF6CC_lrWp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}