F_FPN_LoDoPab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "F-FPN-LoDoPab.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "uco9yMnAmbIm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "975a82b5-143f-4164-9c30-745839efabbc"
      },
      "source": [
        "import pickle\n",
        "import zipfile\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# update path to import from Drive\n",
        "import sys\n",
        "sys.path.append('content/drive/MyDrive')\n",
        "\n",
        "import numpy as np\n",
        "import torch\n",
        "import matplotlib.pyplot as plt\n",
        "from torch import nn\n",
        "from torch.utils.data import Dataset, TensorDataset, DataLoader\n",
        "import torch.optim as optim\n",
        "import time\n",
        "from time import sleep\n",
        "from tqdm import tqdm\n",
        "\n",
        "with zipfile.ZipFile('/content/drive/MyDrive/FPN/FFPN-Lodopab-TrainingData-IndividualNoise.zip', 'r') as zip_ref:\n",
        "    zip_ref.extractall('./')\n",
        "\n",
        "sys.path.append('content/drive/MyDrive/FPN')\n",
        "sys.path.insert(0,'/content/drive/My Drive/FPN')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UOzfAilOduUG"
      },
      "source": [
        "from FPNLBA import FPN\n",
        "device = 'cuda'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tq1IvrVGmhdb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9d6874c1-8cc2-4a96-fd64-a4dbbf1180ee"
      },
      "source": [
        "# load train data\n",
        "# folder_path = './dataset/'\n",
        "folder_path = './'\n",
        "\n",
        "data_path = folder_path + 'FFPN-Lodopab-TrainingData-0.015IndividualNoise.pkl'\n",
        "\n",
        "state = torch.load(data_path)\n",
        "\n",
        "A = state['A'].to(device)\n",
        "data_obs_train = state['data_obs_train']\n",
        "data_obs_test = state['data_obs_test']\n",
        "u_train       = state['u_true_train']\n",
        "u_test       = state['u_true_test']\n",
        "\n",
        "n_samples       = data_obs_train.shape[0]\n",
        "n_samples_test  = data_obs_test.shape[0]\n",
        "\n",
        "print('u_train.shape =', u_train.shape)\n",
        "print('u_test.shape = ', u_test.shape)\n",
        "print('data_obs_train.shape = ', data_obs_train.shape)\n",
        "print('data_obs_test.shape = ', data_obs_test.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "u_train.shape = torch.Size([20000, 1, 128, 128])\n",
            "u_test.shape =  torch.Size([2000, 1, 128, 128])\n",
            "data_obs_train.shape =  torch.Size([20000, 1, 30, 183])\n",
            "data_obs_test.shape =  torch.Size([2000, 1, 30, 183])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bzUyStSFmu0p",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fbe04214-6fa6-4a6b-ec2a-ac79e5e12662"
      },
      "source": [
        "# Create training datasets\n",
        "\n",
        "batch_size = 50\n",
        "\n",
        "data_train      = TensorDataset(u_train[0:n_samples,:,:,:], data_obs_train[0:n_samples,:,:,:])\n",
        "data_loader     = DataLoader(dataset=data_train, batch_size=batch_size, shuffle=True)\n",
        "\n",
        "n_batches = int(len(data_loader.dataset)/batch_size)\n",
        "\n",
        "# Info about the dataset\n",
        "print()\n",
        "print(f'u_train.min(): {u_train.min()}')\n",
        "print(f'u_train.max(): {u_train.max()}')\n",
        "print(\"data_obs_train.shape = \", data_obs_train.shape)\n",
        "print('n_batches = ', n_batches)\n",
        "#print()*7410\n",
        "\n",
        "print(\"A size = \", A.size())\n",
        "S = torch.diag(torch.count_nonzero(A, dim=0) ** -1.0).float().to(device)\n",
        "print(S)\n",
        "print('S size = ', S.size())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "u_train.min(): 0.0\n",
            "u_train.max(): 1.0\n",
            "data_obs_train.shape =  torch.Size([20000, 1, 30, 183])\n",
            "n_batches =  400\n",
            "A size =  torch.Size([5490, 16384])\n",
            "tensor([[0.0147, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
            "        [0.0000, 0.0143, 0.0000,  ..., 0.0000, 0.0000, 0.0000],\n",
            "        [0.0000, 0.0000, 0.0154,  ..., 0.0000, 0.0000, 0.0000],\n",
            "        ...,\n",
            "        [0.0000, 0.0000, 0.0000,  ..., 0.0149, 0.0000, 0.0000],\n",
            "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0149, 0.0000],\n",
            "        [0.0000, 0.0000, 0.0000,  ..., 0.0000, 0.0000, 0.0147]],\n",
            "       device='cuda:0')\n",
            "S size =  torch.Size([16384, 16384])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e2mA2xk3pInW"
      },
      "source": [
        "latent_variable = torch.Tensor\n",
        "image           = torch.Tensor\n",
        "classification  = torch.Tensor\n",
        "measurement     = torch.Tensor"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4BKNprqKmwzp"
      },
      "source": [
        "# ----------------------------------------------------------------------------------------------------------------------\n",
        "# Create neural network model and initialize it\n",
        "# ----------------------------------------------------------------------------------------------------------------------\n",
        "class Regularizer_Net(nn.Module):\n",
        "    def __init__(self, D, M, res_net_contraction=0.99):\n",
        "        super().__init__()\n",
        "        self.relu = nn.ReLU()\n",
        "        self.leaky_relu = nn.LeakyReLU(0.1)\n",
        "        self.gamma = res_net_contraction\n",
        "        self.num_channels = 44     \n",
        "        self.D = D \n",
        "        self.convs = nn.ModuleList([nn.Conv2d(1, self.num_channels, \n",
        "                                              kernel_size=5, stride=1, \n",
        "                                              padding=(2,2)),\n",
        "                                    nn.Conv2d(self.num_channels, \n",
        "                                              self.num_channels, kernel_size=5, \n",
        "                                              stride=1, padding=(2,2)),\n",
        "                                    nn.Conv2d(self.num_channels, \n",
        "                                              self.num_channels, kernel_size=5, \n",
        "                                              stride=1, padding=(2,2)),\n",
        "                                    nn.Conv2d(self.num_channels, 1, \n",
        "                                              kernel_size=5, stride=1, \n",
        "                                              padding=(2,2))])\n",
        "        self.M = M\n",
        "        self.Mt = M.t()         \n",
        "\n",
        "    def name(self) -> str:\n",
        "        return \"Regularizer_Net\"\n",
        "\n",
        "    def device(self):\n",
        "        return next(self.parameters()).data.device\n",
        "\n",
        "    def _T(self, u, d):\n",
        "        batch_size = u.shape[0]\n",
        "\n",
        "        # Learned Gradient\n",
        "        for idx, conv in enumerate(self.convs):\n",
        "            u_ref = u if idx + 1 < len(self.convs) else u[:,0,:,:].view(batch_size,1,128,128)\n",
        "            u = u_ref + self.leaky_relu(conv(u))\n",
        "        u = torch.clamp(u, min=0, max=1.0e1)\n",
        "\n",
        "        # Constraints Projection\n",
        "        u_vec = u.view(batch_size, -1).to(self.device())\n",
        "        u_vec = u_vec.permute(1,0).to(self.device())   \n",
        "        d = d.view(batch_size,-1).to(self.device())\n",
        "        d = d.permute(1,0)\n",
        "        res = torch.matmul(self.Mt, self.M.matmul(u_vec) - d)\n",
        "        res = 1.99 * torch.matmul(self.D.to(self.device()), res)\n",
        "        res = res.permute(1,0)\n",
        "        res = res.view(batch_size, 1, 128, 128).to(self.device())\n",
        "        return u - res\n",
        "\n",
        "    def normalize_lip_const(self, u, d):\n",
        "        ''' Scale convolutions in R to make it gamma Lipschitz\n",
        "\n",
        "            It should hold that |R(u,v) - R(w,v)| <= gamma * |u-w| for all u\n",
        "            and w. If this doesn't hold, then we must rescale the convolution.\n",
        "            Consider R = I + Conv. To rescale, ideally we multiply R by\n",
        "\n",
        "                norm_fact = gamma * |u-w| / |R(u,v) - R(w,v)|,\n",
        "            \n",
        "            averaged over a batch of samples, i.e. R <-- norm_fact * R. The \n",
        "            issue is that ResNets include an identity operation, which we don't \n",
        "            wish to rescale. So, instead we use\n",
        "                \n",
        "                R <-- I + norm_fact * Conv,\n",
        "            \n",
        "            which is accurate up to an identity term scaled by (norm_fact - 1).\n",
        "            If we do this often enough, then norm_fact ~ 1.0 and the identity \n",
        "            term is negligible.\n",
        "\n",
        "            Note: BatchNorm and ReLUs are nonexpansive when...???\n",
        "        '''\n",
        "        noise_u = torch.randn(u.size(), device=self.device()) \n",
        "        w = u.clone() + noise_u\n",
        "        w = w.to(self.device())\n",
        "        Twd = self._T(w, d)\n",
        "        Tud = self._T(u, d)\n",
        "        T_diff_norm = torch.mean(torch.norm(Twd - Tud, dim=1))\n",
        "        u_diff_norm = torch.mean(torch.norm(w - u, dim=1))\n",
        "        R_is_gamma_lip = T_diff_norm <= self.gamma * u_diff_norm\n",
        "        if not R_is_gamma_lip:\n",
        "            normalize_factor = (self.gamma * u_diff_norm / T_diff_norm) ** (1.0 / len(self.convs))\n",
        "            for i in range(len(self.convs)):\n",
        "                self.convs[i].weight.data *= normalize_factor\n",
        "                self.convs[i].bias.data *= normalize_factor\n",
        "\n",
        "    def forward(self, d, eps=1.0e-3, max_depth=100, \n",
        "                depth_warning=False):\n",
        "        ''' FPN forward prop\n",
        "\n",
        "            With gradients detached, find fixed point. During forward iteration,\n",
        "            u is updated via R(u,Q(d)) and Lipschitz constant estimates are\n",
        "            refined. Gradient are attached performing one final step.\n",
        "        '''         \n",
        "        with torch.no_grad():\n",
        "            self.depth = 0.0\n",
        "            u = torch.zeros((d.size()[0], 1, 128, 128), \n",
        "                            device=self.device())\n",
        "            u_prev = np.Inf*torch.ones(u.shape, device=self.device())            \n",
        "            all_samp_conv = False\n",
        "            while not all_samp_conv and self.depth < max_depth:\n",
        "                u_prev = u.clone()   \n",
        "                u = self._T(u, d)\n",
        "                res_norm = torch.max(torch.norm(u - u_prev, dim=1)) \n",
        "                self.depth += 1.0\n",
        "                all_samp_conv = res_norm <= eps\n",
        "            \n",
        "            if self.training:\n",
        "                self.normalize_lip_const(u, d)\n",
        "\n",
        "        if self.depth >= max_depth and depth_warning:\n",
        "            print(\"\\nWarning: Max Depth Reached - Break Forward Loop\\n\")\n",
        "\n",
        "        return self._T(u, d)                "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mMcRhjnqm-Uy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a3950e80-46c8-4b51-b82e-af16a715d832"
      },
      "source": [
        "#-------------------------------------------------------------------------------\n",
        "# Set up training parameters\n",
        "#-------------------------------------------------------------------------------\n",
        "\n",
        "Phi = Regularizer_Net(S, A)\n",
        "Phi = Phi.to(device)\n",
        "\n",
        "pytorch_total_params = sum(p.numel() for p in Phi.parameters() if p.requires_grad)\n",
        "print(f'Number of trainable parameters: {pytorch_total_params}')\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of trainable parameters: 99133\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UDoVIWSQ3uR5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6945a7bf-4ba7-4106-ff99-c99461778fa6"
      },
      "source": [
        "max_epochs    = 10\n",
        "learning_rate = 1.0e-5\n",
        "max_depth     = 150\n",
        "eps           = 1.0e-3\n",
        "\n",
        "criterion = torch.nn.MSELoss()  \n",
        "optimizer = optim.Adam(Phi.parameters(), lr=learning_rate)\n",
        "lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=25, gamma=1.0)\n",
        "\n",
        "fmt        = '[{:2d}/{:2d}]: train_loss = {:7.3e} | ' \n",
        "fmt       += 'depth = {:5.1f} | lr = {:5.1e} | time = {:4.1f} sec'\n",
        "\n",
        "\n",
        "load_weights = True\n",
        "if load_weights:\n",
        "    # FOR RELOADING\n",
        "    state = torch.load('./drive/MyDrive/FPN/Feasible_FPN_Lodopab_weights.pth') \n",
        "    Phi.load_state_dict(state['Phi_state_dict'])\n",
        "    print('Loaded Phi from file.')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Loaded Phi from file.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "485DE4iRxHRB"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LEr2wb91nCoa"
      },
      "source": [
        "#-------------------------------------------------------------------------------\n",
        "# Execute Training\n",
        "#-------------------------------------------------------------------------------\n",
        "best_loss = 1.0e10 \n",
        "\n",
        "for epoch in range(max_epochs): \n",
        "  sleep(0.5)  # slows progress bar so it won't print on multiple lines\n",
        "  tot = len(data_loader)\n",
        "  loss_ave = 0.0\n",
        "  start_time_epoch = time.time() \n",
        "  with tqdm(total=tot, unit=\" batch\", leave=False, ascii=True) as tepoch:\n",
        "      \n",
        "    for idx, (u_batch, d) in enumerate(data_loader): \n",
        "      u_batch    = u_batch.to(device) \n",
        "      batch_size = u_batch.shape[0]\n",
        "      d = d.view(batch_size, -1).to(device)\n",
        "\n",
        "      train_batch_size = d.shape[0] \n",
        "      Phi.train()\n",
        "      optimizer.zero_grad()\n",
        "      u = Phi(d, max_depth=max_depth, eps=eps) \n",
        "      loss_val = criterion(u, u_batch)\n",
        "      train_loss = loss_val.detach().cpu().numpy()\n",
        "      loss_ave += train_loss * train_batch_size\n",
        "      loss_val.backward()\n",
        "      optimizer.step()\n",
        "\n",
        "\n",
        "      tepoch.update(1)\n",
        "      tepoch.set_postfix(train_loss=\"{:5.2e}\".format(train_loss),\n",
        "                            depth=\"{:5.1f}\".format(Phi.depth))\n",
        "    \n",
        "    if epoch%1 == 0:\n",
        "        # compute test image \n",
        "        Phi.eval()\n",
        "        testing_image = data_obs_test[0,0,:,:].view(1,1,-1)\n",
        "        u_test_approx = Phi(testing_image, max_depth=max_depth, eps=eps)\n",
        "\n",
        "        plt.figure()\n",
        "        plt.subplot(2,2,1)\n",
        "        plt.imshow(u_batch[0,0,:,:].cpu(), vmin=0, vmax=1)\n",
        "        plt.title('u true train')\n",
        "        plt.subplot(2,2,2)\n",
        "        plt.imshow(u[0,0,:,:].detach().cpu(), vmin=0, vmax=1)\n",
        "        plt.title('u approx train')\n",
        "        plt.subplot(2,2,3)\n",
        "        plt.imshow(u_test[0,0,:,:].cpu(), vmin=0, vmax=1)\n",
        "        plt.title('u true test')\n",
        "        plt.subplot(2,2,4)\n",
        "        plt.imshow(u_test_approx[0,0,:,:].detach().cpu(), vmin=0, vmax=1)\n",
        "        plt.title('u approx test')\n",
        "        plt.show() \n",
        "\n",
        "        Phi.train() \n",
        "\n",
        "    # ---------------------------------------------------------------------\n",
        "    # Save weights\n",
        "    # ---------------------------------------------------------------------\n",
        "    if loss_ave < best_loss:\n",
        "        best_loss = loss_ave\n",
        "        state = {\n",
        "            'Phi_state_dict': Phi.state_dict(),\n",
        "            'optimizer_state_dict': optimizer.state_dict(),\n",
        "            'lr_scheduler': lr_scheduler\n",
        "        }\n",
        "        file_name = './drive/MyDrive/FPN/Feasible_FPN_Lodopab_weights.pth'\n",
        "        torch.save(state, file_name)\n",
        "        print('\\nModel weights saved to ' + file_name)        \n",
        "    \n",
        "  loss_ave = loss_ave/len(data_loader.dataset)\n",
        "  end_time_epoch = time.time()\n",
        "  time_epoch = end_time_epoch - start_time_epoch\n",
        "  lr_scheduler.step()\n",
        "  print(fmt.format(epoch+1, max_epochs, loss_ave, Phi.depth, \n",
        "                   optimizer.param_groups[0]['lr'],\n",
        "                   time_epoch))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rK80ynzN-TBu"
      },
      "source": [
        "from skimage.metrics import structural_similarity as ssim\n",
        "from skimage.metrics import peak_signal_noise_ratio as psnr\n",
        "\n",
        "n_samples = u_test.shape[0]\n",
        "\n",
        "data_test     = TensorDataset(u_test, data_obs_test)\n",
        "test_data_loader     = DataLoader(dataset=data_test, batch_size=batch_size, shuffle=True)\n",
        "\n",
        "\n",
        "def compute_avg_SSIM_PSNR(u_true, u_gen, n_mesh, data_range):\n",
        "    # assumes images are size n_samples x n_features**2 and are detached\n",
        "    n_samples = u_true.shape[0]\n",
        "    u_true = u_true.reshape(n_samples, n_mesh, n_mesh).cpu().numpy()\n",
        "    u_gen  = u_gen.reshape(n_samples, n_mesh, n_mesh).cpu().numpy()\n",
        "    ssim_val = 0\n",
        "    psnr_val = 0\n",
        "    for j in range(n_samples):\n",
        "        ssim_val = ssim_val + ssim(u_true[j,:,:], u_gen[j,:,:], data_range=data_range)\n",
        "        psnr_val = psnr_val + psnr(u_true[j,:,:], u_gen[j,:,:], data_range=data_range)\n",
        "    return ssim_val/n_samples, psnr_val/n_samples"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bUqn5O7IpWtc"
      },
      "source": [
        "\n",
        "test_loss_ave = 0\n",
        "test_PSNR_ave = 0\n",
        "test_SSIM_ave = 0\n",
        "with torch.no_grad():\n",
        "    for idx, (u_batch, d) in enumerate(test_data_loader): \n",
        "\n",
        "        u_batch    = u_batch.to(device) \n",
        "        batch_size = u_batch.shape[0]\n",
        "        temp       = u_batch.view(batch_size, -1)\n",
        "        temp       = temp.permute(1,0)        \n",
        "        test_batch_size = d.shape[0] \n",
        "        Phi.eval()\n",
        "        u = Phi(d, max_depth=max_depth, eps=eps) \n",
        "        output = criterion(u, u_batch)\n",
        "        test_loss = output.detach().cpu().numpy()\n",
        "        test_SSIM, test_PSNR = compute_avg_SSIM_PSNR(u_batch, u, 128, 1)\n",
        "        test_PSNR_ave += test_PSNR * test_batch_size\n",
        "        test_loss_ave += test_loss * test_batch_size\n",
        "        test_SSIM_ave += test_SSIM * test_batch_size\n",
        "\n",
        "        print('test_PSNR = {:7.3e}'.format(test_PSNR))\n",
        "        print('test_SSIM = {:7.3e}'.format(test_SSIM))\n",
        "        print('test_loss = {:7.3e}'.format(test_loss))\n",
        "        if idx%1 == 0:\n",
        "            # compute test image \n",
        "            plt.figure()\n",
        "            plt.subplot(1,2,1)\n",
        "            plt.imshow(u_batch[0,0,:,:].cpu(), vmin=0, vmax=1)\n",
        "            plt.title('u true')\n",
        "            plt.subplot(1,2,2)\n",
        "            plt.imshow(u[0,0,:,:].detach().cpu(), vmin=0, vmax=1)\n",
        "            plt.title('u approx')\n",
        "            plt.show()  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p6LHqo3qEXL9",
        "outputId": "4080cd66-9cf4-47e1-976a-8e6d1cd0c86a"
      },
      "source": [
        "print('\\n\\nSUMMARY')\n",
        "print('test_loss_ave =  {:7.3e}'.format(test_loss_ave / 2000))\n",
        "print('test_PSNR_ave =  {:7.3e}'.format(test_PSNR_ave / 2000))\n",
        "print('test_SSIM_ave =  {:7.3e}'.format(test_SSIM_ave / 2000))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "SUMMARY\n",
            "test_loss_ave =  9.585e-04\n",
            "test_PSNR_ave =  3.046e+01\n",
            "test_SSIM_ave =  8.319e-01\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 496
        },
        "id": "nY6ihY9VCtff",
        "outputId": "8f12bfb6-d161-451c-f6d1-04649893466e"
      },
      "source": [
        "ind_val = 1000\n",
        "\n",
        "u = Phi(data_obs_test[ind_val,:,:,:]).view(128,128)\n",
        "u_true = u_test[ind_val,0,:,:]\n",
        "def string_ind(index):\n",
        "    if index < 10:\n",
        "        return '000' + str(index)\n",
        "    elif index < 100:\n",
        "        return '00' + str(index)\n",
        "    elif index < 1000:\n",
        "        return '0' + str(index)\n",
        "    else:\n",
        "        return str(index)\n",
        "\n",
        "cmap = 'gray'\n",
        "fig = plt.figure()\n",
        "plt.imshow(np.rot90(u.detach().cpu().numpy()),cmap=cmap, vmin=0, vmax=1)\n",
        "plt.axis('off')\n",
        "\n",
        "\n",
        "save_loc = './Learned_Feasibility_Lodopab_FFPN_ind_' + string_ind(ind_val) + '.pdf'\n",
        "plt.savefig(save_loc,bbox_inches='tight')\n",
        "plt.show()\n",
        "\n",
        "print(\"SSIM: \", compute_avg_SSIM_PSNR(u_true.view(1,128,128), u.view(1,128,128).detach(), 128, 1))\n",
        "\n",
        "#------------------------------------------------------------\n",
        "# TRUE\n",
        "#------------------------------------------------------------\n",
        "\n",
        "cmap = 'gray'\n",
        "fig = plt.figure()\n",
        "plt.imshow(np.rot90(u_true.detach().cpu().numpy()),cmap=cmap, vmin=0, vmax=1)\n",
        "plt.axis('off')\n",
        "\n",
        "\n",
        "save_loc = './Learned_Feasibility_Lodopab_GT_ind_' + string_ind(ind_val) + '.pdf'\n",
        "plt.savefig(save_loc,bbox_inches='tight')\n",
        "plt.show()\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "SSIM:  (0.8319270686541259, 28.98200842392084)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}