Capsule_Network_with_ensemble.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import time\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "from torch.optim import Adam\n",
    "from torchvision import datasets, transforms\n",
    "\n",
    "verbose = False\n",
    "USE_CUDA = True\n",
    "device = torch.device('cuda:0' if USE_CUDA else 'cpu')\n",
    "USE_MNIST = False\n",
    "USE_CIFAR100 = False\n",
    "NUM_CLASSES = 10\n",
    "num_ensemble = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if USE_CIFAR100:\n",
    "        #Classes :\n",
    "        #aquatic mammals\tbeaver=0, dolphin=1, otter=2, seal=3, whale=4\n",
    "        #fish\taquarium fish=5, flatfish=6, ray=7, shark=8, trout=9\n",
    "        #food containers\tbottles=15, bowls=16, cans=17, cups=18, plates=19\n",
    "        #people\tbaby=70, boy=71, girl=72, man=73, woman=74\n",
    "    label_class = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 70, 71, 72, 73, 74]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cifar10:\n",
    "    def __init__(self, batch_size):\n",
    "        dataset_transform = transforms.Compose([\n",
    "            transforms.ToTensor(),\n",
    "            #transforms.Normalize((0.1307,), (0.3081,))\n",
    "            #transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)            \n",
    "            transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))\n",
    "        ])\n",
    "\n",
    "        train_dataset = datasets.CIFAR10('../data', train=True, download=True, transform=dataset_transform)\n",
    "        test_dataset = datasets.CIFAR10('../data', train=False, download=True, transform=dataset_transform)\n",
    "        \n",
    "        self.train_loader  = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "        self.test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True) \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_same_index(target, label):\n",
    "    label_indices = []\n",
    "\n",
    "    for i in range(len(target)):\n",
    "        if target[i] in label:\n",
    "            label_indices.append(i)\n",
    "\n",
    "    return label_indices\n",
    "class Cifar100:\n",
    "    def __init__(self, batch_size):\n",
    "        dataset_transform = transforms.Compose([\n",
    "            transforms.ToTensor(),\n",
    "            #transforms.Normalize((0.1307,), (0.3081,))\n",
    "            transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))\n",
    "        ])\n",
    "        \n",
    "        train_dataset = datasets.CIFAR100('../data', train=True, download=True, transform=dataset_transform)\n",
    "        test_dataset = datasets.CIFAR100('../data', train=False, download=True, transform=dataset_transform)\n",
    "                \n",
    "        # Get indices of label_class\n",
    "        train_indices = get_same_index(train_dataset.train_labels, label_class)\n",
    "        test_indices = get_same_index(test_dataset.test_labels, label_class)\n",
    "    \n",
    "        print(\"Training data {}, Test data {}, Num_classes {}\".format(len(train_indices),len(test_indices),NUM_CLASSES))\n",
    "    \n",
    "        self.train_loader  = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler(train_indices))\n",
    "        self.test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, sampler=torch.utils.data.sampler.SubsetRandomSampler(test_indices)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Mnist:\n",
    "    def __init__(self, batch_size):\n",
    "        dataset_transform = transforms.Compose([\n",
    "                       transforms.ToTensor(),\n",
    "                       transforms.Normalize((0.1307,), (0.3081,))\n",
    "                   ])\n",
    "\n",
    "        train_dataset = datasets.MNIST('../data', train=True, download=True, transform=dataset_transform)\n",
    "        test_dataset = datasets.MNIST('../data', train=False, download=True, transform=dataset_transform)\n",
    "        \n",
    "        self.train_loader  = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "        self.test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True) \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvLayer(nn.Module):\n",
    "    #MNIST \n",
    "    def __init__(self, MNIST = USE_MNIST):\n",
    "        if MNIST:\n",
    "            in_channels=1\n",
    "            out_channels=256\n",
    "            kernel_size=9\n",
    "        else:\n",
    "            in_channels=3\n",
    "            out_channels=256\n",
    "            kernel_size=9\n",
    "            \n",
    "        super(ConvLayer, self).__init__()\n",
    "\n",
    "        self.conv = nn.Conv2d(in_channels=in_channels,\n",
    "                               out_channels=out_channels,\n",
    "                               kernel_size=kernel_size,\n",
    "                               stride=1\n",
    "                             )\n",
    "\n",
    "    def forward(self, x):\n",
    "        if verbose: print( \"Conv {}\".format(x.size()))\n",
    "        return F.relu(self.conv(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PrimaryCaps(nn.Module):\n",
    "    #MNIST  \n",
    "    def __init__(self, MNIST = USE_MNIST):\n",
    "        if MNIST:\n",
    "            num_capsules=8\n",
    "            in_channels=256\n",
    "            out_channels=32\n",
    "            kernel_size=9\n",
    "        else:\n",
    "            num_capsules=8\n",
    "            in_channels=256\n",
    "            out_channels=32\n",
    "            kernel_size= 9\n",
    "\n",
    "        super(PrimaryCaps, self).__init__()\n",
    "\n",
    "        self.capsules = nn.ModuleList([\n",
    "            nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=2, padding=0) \n",
    "                          for _ in range(num_capsules)])\n",
    "    \n",
    "    def forward(self, x, MNIST = USE_MNIST):\n",
    "        u = [capsule(x) for capsule in self.capsules]\n",
    "        u = torch.stack(u, dim=1)\n",
    "        if verbose: print( \"PrimaryCaps {}\".format(u.size()))\n",
    "        if MNIST: \n",
    "            u = u.view(x.size(0), 32 * 6 * 6, -1)\n",
    "        else:\n",
    "            u = u.view(x.size(0), 32 * 8 * 8, -1)\n",
    "        if verbose: print(u.size())\n",
    "        return self.squash(u)\n",
    "    \n",
    "    def squash(self, input_tensor):\n",
    "        squared_norm = (input_tensor ** 2).sum(-1, keepdim=True)\n",
    "        output_tensor = squared_norm *  input_tensor / ((1. + squared_norm) * torch.sqrt(squared_norm))\n",
    "        if verbose: print(output_tensor.size())\n",
    "        return output_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DigitCaps(nn.Module):\n",
    "    #MNIST \n",
    "    def __init__(self, MNIST = USE_MNIST):\n",
    "        if MNIST:\n",
    "            num_capsules=10\n",
    "            num_routes=32 * 6 * 6\n",
    "            in_channels=8\n",
    "            out_channels=16\n",
    "        else:\n",
    "            num_capsules=NUM_CLASSES \n",
    "            num_routes=32 * 8 * 8 \n",
    "            in_channels=8\n",
    "            out_channels=16  \n",
    "\n",
    "        super(DigitCaps, self).__init__()\n",
    "\n",
    "        self.in_channels = in_channels\n",
    "        self.num_routes = num_routes\n",
    "        self.num_capsules = num_capsules\n",
    "\n",
    "        self.W = nn.Parameter(torch.randn(1, num_routes, num_capsules, out_channels, in_channels))\n",
    "\n",
    "    def forward(self, x):\n",
    "        batch_size = x.size(0)\n",
    "        x = torch.stack([x] * self.num_capsules, dim=2).unsqueeze(4)\n",
    "        if verbose: print( \"DigitCaps {},{}\".format(x.size(),self.W.size()))\n",
    "        if verbose: print(len(([self.W][0])))\n",
    "        W = torch.cat([self.W] * batch_size, dim=0)\n",
    "        if verbose: print(W.size())\n",
    "        u_hat = torch.matmul(W, x)\n",
    "\n",
    "        b_ij = Variable(torch.zeros(1, self.num_routes, self.num_capsules, 1))\n",
    "        if USE_CUDA:\n",
    "            b_ij = b_ij.to(device)#cuda()\n",
    "\n",
    "        num_iterations = 3\n",
    "        for iteration in range(num_iterations):\n",
    "            c_ij = F.softmax(b_ij)\n",
    "            c_ij = torch.cat([c_ij] * batch_size, dim=0).unsqueeze(4)\n",
    "\n",
    "            s_j = (c_ij * u_hat).sum(dim=1, keepdim=True)\n",
    "            v_j = self.squash(s_j)\n",
    "            \n",
    "            if iteration < num_iterations - 1:\n",
    "                a_ij = torch.matmul(u_hat.transpose(3, 4), torch.cat([v_j] * self.num_routes, dim=1))\n",
    "                b_ij = b_ij + a_ij.squeeze(4).mean(dim=0, keepdim=True)\n",
    "\n",
    "        return v_j.squeeze(1)\n",
    "    \n",
    "    def squash(self, input_tensor):\n",
    "        squared_norm = (input_tensor ** 2).sum(-1, keepdim=True)\n",
    "        output_tensor = squared_norm *  input_tensor / ((1. + squared_norm) * torch.sqrt(squared_norm))\n",
    "        return output_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder(nn.Module):\n",
    "    def __init__(self, MNIST = USE_MNIST):\n",
    "        super(Decoder, self).__init__()\n",
    "        \n",
    "        if MNIST:\n",
    "            self.reconstraction_layers = nn.Sequential(\n",
    "                nn.Linear(16 * NUM_CLASSES, 512),\n",
    "                nn.ReLU(inplace=True),\n",
    "                nn.Linear(512, 1024),\n",
    "                nn.ReLU(inplace=True),\n",
    "                nn.Linear(1024, 784),\n",
    "                nn.Sigmoid()\n",
    "            )            \n",
    "        else:\n",
    "            self.reconstraction_layers = nn.Sequential(\n",
    "                nn.Linear(16 * NUM_CLASSES, 512),\n",
    "                nn.ReLU(inplace=True),\n",
    "                nn.Linear(512, 1024),\n",
    "                nn.ReLU(inplace=True),\n",
    "                nn.Linear(1024, 3072),\n",
    "                nn.Sigmoid()\n",
    "            )\n",
    "        \n",
    "    def forward(self, x, data, MNIST = USE_MNIST):\n",
    "        classes = torch.sqrt((x ** 2).sum(2))\n",
    "        classes = F.softmax(classes)\n",
    "        \n",
    "        _, max_length_indices = classes.max(dim=1)\n",
    "        masked = Variable(torch.eye(NUM_CLASSES))\n",
    "        if USE_CUDA:\n",
    "            masked = masked.to(device)#cuda()\n",
    "        masked = masked.index_select(dim=0, index=max_length_indices.squeeze(1).data)\n",
    "        \n",
    "        reconstructions = self.reconstraction_layers((x * masked[:, :, None, None]).view(x.size(0), -1))\n",
    "        if MNIST:\n",
    "            reconstructions = reconstructions.view(-1,1,28,28)\n",
    "        else:\n",
    "            \n",
    "            reconstructions = reconstructions.view(-1,3,32,32)\n",
    "        \n",
    "        return reconstructions, masked"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CapsNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(CapsNet, self).__init__()\n",
    "        self.conv_layer = ConvLayer()\n",
    "        self.primary_capsules = PrimaryCaps()\n",
    "        self.digit_capsules = DigitCaps()\n",
    "        self.decoder = Decoder()\n",
    "        \n",
    "        self.mse_loss = nn.MSELoss()\n",
    "        \n",
    "    def forward(self, data):\n",
    "        output = self.digit_capsules(self.primary_capsules(self.conv_layer(data)))\n",
    "        reconstructions, masked = self.decoder(output, data)\n",
    "        return output, reconstructions, masked\n",
    "    \n",
    "    def loss(self, data, x, target, reconstructions):\n",
    "        return self.margin_loss(x, target) + self.reconstruction_loss(data, reconstructions)\n",
    "    \n",
    "    def margin_loss(self, x, labels, size_average=True):\n",
    "        batch_size = x.size(0)\n",
    "\n",
    "        v_c = torch.sqrt((x**2).sum(dim=2, keepdim=True))\n",
    "\n",
    "        left = F.relu(0.9 - v_c).view(batch_size, -1)\n",
    "        right = F.relu(v_c - 0.1).view(batch_size, -1)\n",
    "\n",
    "        loss = labels * left + 0.5 * (1.0 - labels) * right\n",
    "        loss = loss.sum(dim=1).mean()\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def reconstruction_loss(self, data, reconstructions):\n",
    "        loss = self.mse_loss(reconstructions.view(reconstructions.size(0), -1), data.view(reconstructions.size(0), -1))\n",
    "        return loss * 0.0005"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "batch_size = 100\n",
    "\n",
    "if USE_MNIST:\n",
    "    mnist = Mnist(batch_size) \n",
    "    if verbose: print('MNIST dataset')\n",
    "else:\n",
    "    if USE_CIFAR100:\n",
    "        mnist = Cifar100(batch_size)\n",
    "        if verbose: print('CIFAR100 dataset')\n",
    "    else:\n",
    "        mnist = Cifar10(batch_size)\n",
    "        if verbose: print('CIFAR10 dataset')\n",
    "#for batch_id,(data, target) in  enumerate(mnist.train_loader):\n",
    " #       data = Variable(data)\n",
    "\n",
    "  #      if USE_CUDA:\n",
    "   #         data = data.to(device)#.cuda()\n",
    "    \n",
    "#plot_images_separately(data[:6,0].data.cpu().numpy())    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_dictionary():\n",
    "\n",
    "    dictionary = {}\n",
    "    for i in range(NUM_CLASSES):\n",
    "        dictionary[i] = label_class[i]\n",
    "    \n",
    "    return dictionary\n",
    "\n",
    "def reformat_targetTensor(target):\n",
    "    dictionary_labels = generate_dictionary()\n",
    "    if verbose: print(\"Dictionary labels generated: \",dictionary_labels)\n",
    "    if verbose: print(\"Target Tensor before reformat:\", target)\n",
    "    for i in range(NUM_CLASSES):\n",
    "        target[target==dictionary_labels[i]] = i\n",
    "        \n",
    "    if verbose: print(\"Target Tensor after reformat:\", target)\n",
    "    return target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'torch.version' from '/home/rita/.local/lib/python3.6/site-packages/torch/version.py'>\n",
      "cuda\n",
      "epoch 1:15 - of 0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:38: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:26: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:46: UserWarning: invalid index of a 0-dim tensor. This will be an error in PyTorch 0.5. Use tensor.item() to convert a 0-dim tensor to a Python number\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train accuracy: 0.08\n",
      "train accuracy: 0.22\n",
      "train accuracy: 0.37\n",
      "train accuracy: 0.32\n"
     ]
    }
   ],
   "source": [
    "print(torch.version)\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "\n",
    "n_epochs = 15\n",
    "x = range(0,n_epochs)\n",
    "mean_batch_accuracy = []\n",
    "loss_train = []\n",
    "\n",
    "ensemble_output = []\n",
    "target_output = []\n",
    "\n",
    "for ensemble in range(num_ensemble):\n",
    "    capsule_net = CapsNet()\n",
    "    if USE_CUDA:\n",
    "        capsule_net = capsule_net.to(device)#cuda()\n",
    "        print('cuda')\n",
    "    optimizer = Adam(capsule_net.parameters(),lr = 0.001)#, weight_decay = 0.96)\n",
    "    start = time.time()\n",
    "    for epoch in range(n_epochs): \n",
    "        capsule_net.train() \n",
    "        train_loss = 0 \n",
    "\n",
    "        batch_accuracy = []\n",
    "\n",
    "        print('epoch {}:{} - of {}'.format(epoch+1, n_epochs, ensemble)) \n",
    "        for batch_id, (data, target) in enumerate(mnist.train_loader):\n",
    "\n",
    "            if USE_CIFAR100:\n",
    "                target = reformat_targetTensor(target)\n",
    "\n",
    "            target =torch.eye(NUM_CLASSES).index_select(dim=0, index=target)\n",
    "            data, target = Variable(data), Variable(target)\n",
    "\n",
    "            if USE_CUDA:\n",
    "                data, target = data.to(device), target.to(device)#.cuda()\n",
    "\n",
    "            optimizer.zero_grad()\n",
    "            output, reconstructions, masked = capsule_net(data)\n",
    "            loss = capsule_net.loss(data, output, target, reconstructions)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            train_loss += loss.data[0]\n",
    "\n",
    "            if batch_id % 100 == 0:\n",
    "                print(\"train accuracy:\", sum(np.argmax(masked.data.cpu().numpy(), 1) == \n",
    "                                       np.argmax(target.data.cpu().numpy(), 1)) / float(batch_size))\n",
    "                batch_accuracy.append(sum(np.argmax(masked.data.cpu().numpy(), 1) == \n",
    "                                       np.argmax(target.data.cpu().numpy(), 1)) / float(batch_size))\n",
    "        mean_batch_accuracy.append(np.mean(batch_accuracy))\n",
    "        del batch_accuracy\n",
    "        loss_train.append(train_loss/len(mnist.train_loader))\n",
    "    end = time.time()\n",
    "    print(\"Training time execution {}\".format(end-start))\n",
    "    \n",
    "   # fig = plt.figure(1)\n",
    "   # ax = plt.axes()\n",
    "   # plt.plot(x,mean_batch_accuracy)\n",
    "   # fig2 = plt.figure(2)\n",
    "   # ax = plt.axes()\n",
    "   # plt.plot(x,loss_train)\n",
    "   # print(train_loss / len(mnist.train_loader))\n",
    "   # print(len(mnist.train_loader))    \n",
    "    capsule_net.eval()\n",
    "    test_loss = 0\n",
    "    start = time.time()\n",
    "    for batch_id, (data, target) in enumerate(mnist.test_loader):\n",
    "        if USE_CIFAR100:\n",
    "            target = reformat_targetTensor(target)\n",
    "\n",
    "        target = torch.eye(NUM_CLASSES).index_select(dim=0, index=target)\n",
    "        data, target = Variable(data), Variable(target)\n",
    "\n",
    "        if USE_CUDA:\n",
    "            data, target = data.to(device), target.to(device)#cuda()\n",
    "\n",
    "        output, reconstructions, masked = capsule_net(data)\n",
    "        loss = capsule_net.loss(data, output, target, reconstructions)\n",
    "\n",
    "        test_loss += loss.data[0]\n",
    "\n",
    "        if batch_id % 100 == 0:\n",
    "            print(\"test accuracy:\", sum(np.argmax(masked.data.cpu().numpy(), 1) == \n",
    "                                   np.argmax(target.data.cpu().numpy(), 1)) / float(batch_size)) \n",
    "        output_np = output.cpu().detach().numpy()\n",
    "        ensemble_output = np.append(ensemble_output, [output_np])\n",
    "        if ensemble == 0:\n",
    "            target_output = np.append(target_output, target.cpu().detach().numpy())\n",
    "    end = time.time()\n",
    "\n",
    "\n",
    "\n",
    "    print(\"Test time execution {}\".format(end-start))\n",
    "    print(test_loss / len(mnist.test_loader))\n",
    "    print(len(mnist.test_loader))\n",
    "   \n",
    "    torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = ((ensemble_output.reshape(num_ensemble,batch_id+1, batch_size,NUM_CLASSES,16)).sum(axis=0)).max(axis=3)\n",
    "targets = target_output.reshape(batch_id+1,batch_size,NUM_CLASSES)\n",
    "total_wrong = np.sum(np.not_equal(predictions,targets))\n",
    "print('Total wrong predictions: {}, wrong percent: {}'.format(\n",
    "        total_wrong, total_wrong /(batch_id+1) * 100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_images_separately(images):\n",
    "    \"Plot the six MNIST images separately.\"\n",
    "    fig = plt.figure()\n",
    "    for j in range(1, 7):\n",
    "    \n",
    "        ax = fig.add_subplot(1, 6, j)\n",
    "        if USE_MNIST:\n",
    "            ax.matshow(images[j-1], cmap = matplotlib.cm.binary)\n",
    "        else:\n",
    "            min = (np.min(images[j-1],(1,2,0)))\n",
    "            max = (np.max(images[j-1],(1,2,0)))\n",
    "            img = ((np.transpose(images[j-1],(1,2,0))-min)/(max-min)).astype(np.float)\n",
    "            ax.imshow(img)   \n",
    "        plt.xticks(np.array([]))\n",
    "        plt.yticks(np.array([]))\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(data.size())\n",
    "print((data[2,:,:,:]).size())\n",
    "print(np.transpose(data[2,:,:,:].data.cpu().numpy(),(1,2,0)).shape)\n",
    "min = (np.min(data[2,:,:,:].data.cpu().numpy(),(1,2,0)))\n",
    "max = (np.max(data[2,:,:,:].data.cpu().numpy(),(1,2,0)))\n",
    "fig = plt.figure(1)\n",
    "plt.imshow(((np.transpose(data[2,:,:,:].data.cpu().numpy(),(1,2,0))-min)/(max-min)).astype(np.float))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_images_separately(data[:6,:,:,:].data.cpu().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = reconstructions[4,:,:,:].data.cpu().numpy()\n",
    "fig = plt.figure()\n",
    "minimum = np.min(image)\n",
    "maximum = np.max(image)\n",
    "plt.imshow(np.transpose(image,(1,2,0)))\n",
    "plt.show()\n",
    "print(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_images_separately(reconstructions[:6,:,:,:].data.cpu().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}