3D_reconstructVNET.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "3D reconstructVNET.ipynb",
      "version": "0.3.2",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DNim96U0rF9H",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hWuVfBbNFvMT",
        "colab_type": "code",
        "outputId": "ef6a81d8-ac2d-49c9-de51-f0024caf09c8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 128
        }
      },
      "source": [
        "#Connecting google drive for dataset\n",
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive/')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&scope=email%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdocs.test%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fdrive.photos.readonly%20https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fpeopleapi.readonly&response_type=code\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/gdrive/\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "78LD1eSRa1ci",
        "colab_type": "text"
      },
      "source": [
        "#Dataset\n",
        "I have taken 4 classes(car,airplane,table,chair). each object contains 100 classes. and each class contanis 6 different images.\\\n",
        "For data Preparation their is another notebook."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F6zlPYSWBlOv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "am1=am1.view(2400,3,128,128)\n",
        "arr_3DD=arr_3DD.view(2400,32,32,32)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MIcuZJ8A2p4T",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ks5lJV6e25wc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "am=torch.tensor(am).view((100,24,3,128,128))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wumS5C3PipQK",
        "colab_type": "code",
        "outputId": "4886ccd9-541c-4f33-dbb4-d9794de179b9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "am1.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([800, 24, 3, 128, 128])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uokaf6ZMrFHH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Random shuffle the dataset\n",
        "np.random.seed(0)\n",
        "am1=np.random.permutation(am1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e1n3zWj75EAm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.random.seed(0)\n",
        "arr=np.random.permutation(arr_3DD)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O8m3LLTKDjq7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xzgrx-BgbBoV",
        "colab_type": "text"
      },
      "source": [
        "As I am traning data on colab so its quiet difficuly to import all the images. thats why i first prepared \\\n",
        "the images to npy and then upload it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rxflp4aQHUmB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "#am1=torch.tensor(np.load(\"/content/gdrive/My Drive/Data/images_200.npy\"))#.view(100,24,3,128,128))\n",
        "\n",
        "\n",
        "#am2=(torch.tensor(np.load(\"/content/gdrive/My Drive/Data/tr1.npy\"))).view(100,24,3,128,128)\n",
        "\"\"\"\n",
        "am3=(torch.tensor(np.load(\"/content/gdrive/My Drive/Data/tr2.npy\"))).view(100,24,3,128,128)\n",
        "am4=(torch.tensor(np.load(\"/content/gdrive/My Drive/Data/tr3.npy\"))).view(100,24,3,128,128)\n",
        "\"\"\"\n",
        "                 \n",
        "#arr_3D=(torch.tensor(np.load(\"/content/gdrive/My Drive/Data/Data_3D_200.npy\")))#.#view(100,1,32,32,32)\n",
        "arr_3D=(torch.tensor(np.load(\"/content/gdrive/My Drive/Data/data_3D.npy\")))#.\n",
        "\n",
        "\n",
        "#Binary Converted Data\n",
        "#######arr_3D=(torch.tensor(np.load(\"/content/gdrive/My Drive/F/data_3DD.npy\"))).view(100,24,2,32,32,32)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gGYG1cZ1btuO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "am1=torch.tensor(am1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VLvAO-nNpQDr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "arr_3D=arr_3D.view(800,32,32,32)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rXwN6Vjnb0ug",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "The dataset is like 6 images from different views of a object. and Its corrosponding 3D.\n",
        "So I associate each image with 3D.To be trained."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GHtaK4_Nb0nR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#######FOR  Making 1Data===whole\n",
        "arr_3DD=torch.zeros(,24,32,32,32)\n",
        "for i in range(arr_3DD.shape[0]):\n",
        "  for j in range(24):\n",
        "    arr_3DD[i][j]=arr_3D[i]\n",
        "  "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ld9s9o9AGpu0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#####Testing Purpose###################\n",
        "l1=[]\n",
        "l1.append(am1)\n",
        "l1.append(am2)\n",
        "l1.append(am3)\n",
        "l1.append(am4)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KMNXcdcq1Mmn",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NpI4on_-FrGk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "import pandas as pd\n",
        "from torchvision import transforms\n",
        "import PIL.Image as Image\n",
        "import torch"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1cM1mvEFFrG1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "from torch.autograd import Variable\n",
        "import torch.nn as nn\n",
        "from torch.nn import Linear,Conv2d,MaxPool2d,LeakyReLU,ConvTranspose3d,Tanh,Sigmoid,ConvTranspose2d,Conv3d\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k2ATZbX_FrG_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oL5xcgSdFrHJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "\n",
        "class GRUNet(nn.Module):\n",
        "   \n",
        "    def __init__(self):\n",
        "        print(\"\\ninitializing \\\"BaseGRUNet\\\"\")\n",
        "        super(GRUNet, self).__init__()\n",
        "        self.is_x_tensor4 = False\n",
        "        \n",
        "        self.batch_size, self.img_w, self.img_h=1,128,128\n",
        "        self.input_shape = (self.batch_size, 3, self.img_w, self.img_h)# here 1 is batch size\n",
        "        \n",
        "        #number of filters for each convolution layer in the encoder\n",
        "        self.n_convfilter = [96, 64, 128, 256, 256,256]#n[1:]=256\n",
        "        \n",
        "        #the dimension of the fully connected layer\n",
        "        self.n_fc_filters = [1024]\n",
        "        \n",
        "        #number of filters for each 3d convolution layer in the decoder\n",
        "        self.n_deconvfilter = [1024,256, 128,64, 32, 16,2]#n[0]=128                       ######one more conv to add as to convert dimenstion of conv\n",
        "        \n",
        "        self.encoder=encoder(self.input_shape,self.n_convfilter,\\\n",
        "                            self.n_fc_filters)\n",
        "        #HERE THE PROBELM IS idx1,idx2,idx3\n",
        "        self.decoder=decoder(self.n_deconvfilter)\n",
        "        \n",
        "    def forward(self,x):\n",
        "        output=self.encoder(x)\n",
        "        #a,b,c,\n",
        "        d=self.decoder(output)\n",
        "        return d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wApjDwCpFrHP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "class encoder(nn.Module):\n",
        "    def __init__(self,input_shape,n_convfilter,\\\n",
        "               n_fc_filters):\n",
        "        print(\"\\ninitalizing \\\"encoder\\\"\")\n",
        "        super(encoder,self).__init__()\n",
        "        #conv1(128->64)\n",
        "        self.conv1a = Conv2d(input_shape[1], 96, 7, padding=3,stride=1)#\n",
        "        self.conv1b = Conv2d(96,96, 3, padding=1,stride=1)\n",
        "        self.bn1=nn.BatchNorm2d(96)\n",
        "        \n",
        "        #conv2(64->32)\n",
        "        self.conv2a = Conv2d(96,128,3,padding=1,stride=1)\n",
        "        self.conv2b = Conv2d(128,128, 3, padding=1,stride=1)\n",
        "        self.conv2c = Conv2d(96,128, 3,padding=1,stride=1)#--------------------\n",
        "        self.bn2=nn.BatchNorm2d(128)\n",
        "        #conv3(32->16)\n",
        "        self.conv3a = Conv2d(128, 256,3, padding=1,stride=1)\n",
        "        self.conv3b = Conv2d(256,256, 3, padding=1,stride=1)\n",
        "        self.conv3c = Conv2d(128,256,3,padding=1,stride=1)#----------------------\n",
        "        self.bn3=nn.BatchNorm2d(256)\n",
        "        #conv4(16*16->8*8)\n",
        "        self.conv4a = Conv2d(256,256, 3, padding=1,stride=1)\n",
        "        self.conv4b = Conv2d(256,256, 3, padding=1,stride=1)\n",
        "        #self.conv4c = Conv2d(256,256,3,padding=1,stride=1)\n",
        "        self.bn4=nn.BatchNorm2d(256)\n",
        "        #conv5(8->4)\n",
        "        self.conv5a = Conv2d(256,256, 3, padding=1,stride=1)\n",
        "        self.conv5b = Conv2d(256,256, 3, padding=1,stride=1)\n",
        "        #self.conv5c = Conv2d(256,256,3,padding=1,stride=1)\n",
        "        self.bn5=nn.BatchNorm2d(256)\n",
        "        #conv6(4->2)\n",
        "        self.conv6a = Conv2d(256,256, 3, padding=1,stride=1)\n",
        "        self.conv6b = Conv2d(256,256, 3, padding=1,stride=1)\n",
        "        #self.conv6c = Conv2d(256,256,3,padding=1,stride=1)\n",
        "        self.bn6=nn.BatchNorm2d(256)\n",
        "       \n",
        "        #(2*2*256->1*1*256)\n",
        "        self.gpool=nn.AvgPool2d(kernel_size=2) \n",
        "        \n",
        "        #((1*1*256)->((1*1*1024))\n",
        "        self.fc7 = Linear(256, 1024)\n",
        "        \n",
        "        #dropout Layers      \n",
        "        self.d1=nn.Dropout2d(0.4)\n",
        "        self.d2=nn.Dropout(0.5)\n",
        "        \n",
        "        \n",
        "        #pooling layer\n",
        "        self.pool1 = MaxPool2d(kernel_size= 2,stride=2)#,return_indices=True)\n",
        "        self.pool2 = MaxPool2d(kernel_size=1,stride=2)#,return_indices=True)\n",
        "        \n",
        "        \n",
        "        #nonlinearities of the network\n",
        "        self.leaky_relu = LeakyReLU(negative_slope= 0.02)\n",
        "        self.sigmoid = Sigmoid()\n",
        "        self.tanh = Tanh() \n",
        "        \n",
        "        \n",
        "         \n",
        "            \n",
        "        \n",
        "            \n",
        "    def forward(self, x):\n",
        "        #x is the input and the size of x is (batch_size, channels, heights, widths).\n",
        "        \n",
        "        conv1a = self.conv1a(x)\n",
        "        conv1a=self.bn1(conv1a)\n",
        "        rect1a = self.leaky_relu(conv1a)\n",
        "        \n",
        "        conv1b = self.conv1b(rect1a)\n",
        "        conv1b=self.bn1(conv1b)\n",
        "        rect1 = self.leaky_relu(conv1b)\n",
        "        \n",
        "        pool1= self.pool1(rect1)\n",
        "        \n",
        "        \n",
        "        #conv2\n",
        "        conv2a = self.conv2a(pool1)\n",
        "        conv2a=self.bn2(conv2a)\n",
        "        rect2a = self.leaky_relu(conv2a)\n",
        "        \n",
        "        conv2b = self.conv2b(rect2a)\n",
        "        conv2b=self.bn2(conv2b)\n",
        "        rect2 = conv2b#self.leaky_relu(conv2b)\n",
        "        \n",
        "        conv2c = self.conv2c(pool1)\n",
        "        conv2c=self.bn2(conv2c)\n",
        "        #conv2c = self.leaky_relu(conv2c)\n",
        "        \n",
        "        res2 = conv2c + rect2\n",
        "        res2= self.leaky_relu(res2)\n",
        "        pool2= self.pool2(res2)\n",
        "        \n",
        "        \n",
        "        #conv3\n",
        "        conv3a = self.conv3a(pool2)\n",
        "        conv3a=self.bn3(conv3a)\n",
        "        rect3a = self.leaky_relu(conv3a)\n",
        "        \n",
        "        conv3b = self.conv3b(rect3a)\n",
        "        conv3b=self.bn3(conv3b)\n",
        "        rect3 = conv3b#self.leaky_relu(conv3b)\n",
        "        \n",
        "        conv3c = self.conv3c(pool2)\n",
        "        conv3c=self.bn3(conv3c)\n",
        "        \n",
        "        \n",
        "        res3 = conv3c + rect3\n",
        "        res3 = self.leaky_relu(res3)\n",
        "        pool3= self.pool2(res3)\n",
        "        \n",
        "        #Conv 4\n",
        "        conv4a = self.conv4a(pool3)\n",
        "        conv4a=self.bn4(conv4a)\n",
        "        rect4a = self.leaky_relu(conv4a)\n",
        "        \n",
        "        conv4b = self.conv4b(rect4a)\n",
        "        conv4b=self.bn4(conv4b)\n",
        "        \n",
        "        res4 = pool3 + conv4b\n",
        "        res4 = self.leaky_relu(res4)        \n",
        "        pool4= self.pool2(res4)\n",
        "        \n",
        "        \n",
        "        #Conv 5\n",
        "        conv5a = self.conv5a(pool4)\n",
        "        conv5a=self.bn5(conv5a)\n",
        "        rect5a = self.leaky_relu(conv5a)\n",
        "        \n",
        "        conv5b = self.conv5b(rect5a)\n",
        "        conv5b=self.bn5(conv5b)\n",
        "        \n",
        "        res5 = pool4 + conv5b\n",
        "        rect5 = self.leaky_relu(res5)\n",
        "        pool5 = self.pool2(rect5)\n",
        "        \n",
        "        \n",
        "        #Conv6\n",
        "        conv6a = self.conv6a(pool5)\n",
        "        conv6a=self.bn6(conv6a)\n",
        "        rect6a = self.leaky_relu(conv6a)\n",
        "        \n",
        "        conv6b = self.conv6b(rect6a)\n",
        "        conv6b=self.bn6(conv6b)\n",
        "        \n",
        "         \n",
        "        res6 = conv6b + pool5\n",
        "        res6 = self.leaky_relu(res6)\n",
        "        pool6= self.pool2(res6)\n",
        "                \n",
        "        #Average Pool\n",
        "        pool8=self.gpool(pool6)  \n",
        "        \n",
        "        pool9 = pool8.view(pool8.size(0), -1)\n",
        "        \n",
        "        #print(\"pool9 \",pool9.shape)\n",
        "        #FC LAyer\n",
        "        fc7 = self.fc7(pool9)\n",
        "        rect7 = self.leaky_relu(fc7)\n",
        "        \n",
        "        \n",
        "        \n",
        "        return rect7\n",
        "    \n",
        "\n",
        "        \n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WOS0KVDLrj88",
        "colab_type": "code",
        "outputId": "8e8a5bcc-3773-4a05-bb65-68907b9b33b2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "am.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2400, 3, 128, 128])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JaYOvExAmgOJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J-lpKUMvFrHW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "def init_weights(m):\n",
        "  #if isinstance(m,nn.Conv2d):\n",
        "    torch.nn.init.xavier_uniform_(m.weight.data)\n",
        "    #print(\"yes\")\n",
        "    \n",
        "    m.bias.data.fill_(0.1)\n",
        "    #m.weight.data.fill_(0.1)\n",
        "    #torch.nn.init.xavier_uniform(m.bias.data)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "al7FaQicFrHc",
        "colab_type": "code",
        "outputId": "c6d6e58f-85a9-4fdc-9dcf-189d50f83ef7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 126
        }
      },
      "source": [
        "model=GRUNet().cuda()\n",
        "\n",
        "ob=[]\n",
        "ob.append(model.encoder.conv1a)\n",
        "ob.append(model.encoder.conv1b)\n",
        "ob.append(model.encoder.conv2a)\n",
        "ob.append(model.encoder.conv2b)\n",
        "ob.append(model.encoder.conv2c)\n",
        "ob.append(model.encoder.conv3a)\n",
        "ob.append(model.encoder.conv3b)\n",
        "ob.append(model.encoder.conv3c)\n",
        "ob.append(model.encoder.conv4a)\n",
        "ob.append(model.encoder.conv4b)\n",
        "ob.append(model.encoder.conv5a)\n",
        "ob.append(model.encoder.conv5b)\n",
        "#ob.append(model.encoder.conv5c)\n",
        "ob.append(model.encoder.conv6a)\n",
        "ob.append(model.encoder.conv6b)\n",
        "#ob.append(model.encoder.conv7a)\n",
        "#ob.append(model.encoder.conv7b)\n",
        "\n",
        "\n",
        "ob.append(model.decoder.conv8a)\n",
        "ob.append(model.decoder.conv8b)\n",
        "ob.append(model.decoder.conv8c)\n",
        "\n",
        "ob.append(model.decoder.conv9a)\n",
        "ob.append(model.decoder.conv9b)\n",
        "ob.append(model.decoder.conv9c)\n",
        "\n",
        "ob.append(model.decoder.conv10a)\n",
        "ob.append(model.decoder.conv10b)\n",
        "ob.append(model.decoder.conv10c)\n",
        "\n",
        "ob.append(model.decoder.conv11a)\n",
        "ob.append(model.decoder.conv11b)\n",
        "ob.append(model.decoder.conv11c)\n",
        "\n",
        "ob.append(model.decoder.conv12a)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "initializing \"BaseGRUNet\"\n",
            "\n",
            "initalizing \"encoder\"\n",
            "\n",
            "initializing \"decoder\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3GysPk-aFrHm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "for i in range(len(ob)):\n",
        "      #print(\"yes\")\n",
        "      init_weights(ob[i])\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5IdNkEsMsiws",
        "colab_type": "code",
        "outputId": "bc07875e-80a5-4610-8b05-621b26e73123",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "\"\"\"model=GRUNet().cuda()\n",
        "pl=model(am1[0][:1].cuda())\n",
        "pl.shape\"\"\""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'model=GRUNet().cuda()\\npl=model(am1[0][:1].cuda())\\npl.shape'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AEv-cgUyFrH4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "################OUR NETWORK#########################\n",
        "###################DECODER\n",
        "\n",
        "class decoder(nn.Module):\n",
        "    def __init__(self, n_deconvfilter):\n",
        "        print(\"\\ninitializing \\\"decoder\\\"\")\n",
        "        super(decoder, self).__init__()\n",
        "        \n",
        "        #3d conv8---op(4)(256)\n",
        "        self.conv7a = ConvTranspose3d(1024, n_deconvfilter[1], kernel_size=4,stride=1,padding=0)#(1-1)*1+4=4\n",
        "        self.bn7=nn.BatchNorm3d(n_deconvfilter[1])\n",
        "        \n",
        "        #3d conv9(op-8)(128)\n",
        "        self.conv8a = ConvTranspose3d(n_deconvfilter[1], n_deconvfilter[2],kernel_size=3, padding=2,stride=3)\n",
        "        self.conv8b = Conv3d(n_deconvfilter[2], n_deconvfilter[2], kernel_size=3, padding=1,stride=1)\n",
        "        self.conv8c = Conv3d(n_deconvfilter[2], n_deconvfilter[2], 3, padding=1,stride=1)#8-128\n",
        "        self.bn8=nn.BatchNorm3d(n_deconvfilter[2])\n",
        "        \n",
        "        #3d conv10(op-16)(64)\n",
        "        self.conv9a = ConvTranspose3d(n_deconvfilter[2], n_deconvfilter[3], 3, padding=4,stride=3)\n",
        "        self.conv9b = Conv3d(n_deconvfilter[3], n_deconvfilter[3], 3, padding=1,stride=1)\n",
        "        self.conv9c = Conv3d(n_deconvfilter[3], n_deconvfilter[3], 3,padding=1,stride=1)#16*16*16*64\n",
        "        self.bn9=nn.BatchNorm3d(n_deconvfilter[3])\n",
        "        \n",
        "        #3d conv11(op-32*32*32*32)(32)\n",
        "        self.conv10a = ConvTranspose3d(n_deconvfilter[3], n_deconvfilter[4], 3, padding=8,stride=3)\n",
        "        self.conv10b = Conv3d(n_deconvfilter[4], n_deconvfilter[4], 3, padding=1,stride=1)\n",
        "        self.conv10c = Conv3d(n_deconvfilter[4], n_deconvfilter[4], 3, padding=1,stride=1)#32*32*32*32\n",
        "        self.bn10=nn.BatchNorm3d(n_deconvfilter[4])\n",
        "        \n",
        "        #3d conv12(32*32*32*16)(16)\n",
        "        #####################GAPHLA HEREEEEEEEEEEEE#############\n",
        "        self.conv11a = ConvTranspose3d(n_deconvfilter[4], n_deconvfilter[5], 3, padding=1,stride=1)\n",
        "        self.conv11b = Conv3d(n_deconvfilter[5], n_deconvfilter[5], 3, padding=1,stride=1)\n",
        "        self.conv11c = Conv3d(n_deconvfilter[5], n_deconvfilter[5], 3, padding=1,stride=1)#32*32*32*16\n",
        "        self.bn11=nn.BatchNorm3d(n_deconvfilter[5])\n",
        "        \n",
        "        #opconv13(32*32*32*2)(2)\n",
        "        self.conv12a = ConvTranspose3d(n_deconvfilter[5], n_deconvfilter[6], 3, padding=1,stride=1)\n",
        "        #self.bn12=nn.BatchNorm3d(n_deconvfilter[6])\n",
        "        #nonlinearities of the network\n",
        "        self.relu =torch.nn.ReLU()\n",
        "        \n",
        "        self.softmax=nn.Softmax(dim=1)\n",
        "        #SoftmaxWithLoss3D()\n",
        "        \n",
        "    def forward(self, rect7):\n",
        "        rec7=rect7.view(rect7.shape[0],1024,1,1,1)#1024 channels becz of conv7a\n",
        "        #unpool7 = self.unpool3d(rec7)\n",
        "        \n",
        "        ##########7#######3\n",
        "        conv7a = self.conv7a(rec7)\n",
        "        rect=self.bn7(conv7a)\n",
        "        rect7a = self.relu(rect)\n",
        "                         \n",
        "        ##################8##########\n",
        "        conv8a = self.conv8a(rect7a)\n",
        "        conv8a=self.bn8(conv8a)\n",
        "        rect8a = self.relu(conv8a)\n",
        "        \n",
        "        \n",
        "        conv8b = self.conv8b(rect8a)\n",
        "        rect8b=self.bn8(conv8b)\n",
        "        rect8b = self.relu(rect8b)\n",
        "        \n",
        "        conv8c = self.conv8c(rect8b)\n",
        "        rect8c=self.bn8(conv8c)\n",
        "        rect8c = self.relu(rect8c)\n",
        "        \n",
        "        \n",
        "        rect=rect8a+rect8c\n",
        "        \n",
        "        #dblock9\n",
        "        conv9a = self.conv9a(rect)\n",
        "        conv9a=self.bn9(conv9a)\n",
        "        rect9a=self.relu(conv9a)\n",
        "        \n",
        "        conv9b = self.conv9b(rect9a)\n",
        "        conv9b=self.bn9(conv9b)\n",
        "        rect9b =self.relu(conv9b)\n",
        "        \n",
        "        conv9c = self.conv9c(rect9b)\n",
        "        conv9c=self.bn9(conv9c)\n",
        "        rect9c=self.relu(conv9c)\n",
        "        \n",
        "        rect=rect9a+rect9c\n",
        "        \n",
        "        ###############10###############\n",
        "        conv10a = self.conv10a(rect)\n",
        "        conv10a=self.bn10(conv10a)\n",
        "        rect10a = self.relu(conv10a)\n",
        "        \n",
        "        conv10b = self.conv10b(rect10a)\n",
        "        conv10b=self.bn10(conv10b)\n",
        "        rect10b = self.relu(conv10b)\n",
        "        \n",
        "        conv10c = self.conv10c(rect10b)\n",
        "        conv10c=self.bn10(conv10c)\n",
        "        rect10c =self.relu(conv10c)\n",
        "        \n",
        "        rect=rect10a+rect10c\n",
        "        #rect = self.relu(rect)\n",
        "        #rect=self.bn10(rect)\n",
        "        ################11###############\n",
        "        #dblck11\n",
        "        conv11a = self.conv11a(rect)\n",
        "        conv11a=self.bn11(conv11a)\n",
        "        rect11a = self.relu(conv11a)\n",
        "        \n",
        "        conv11b = self.conv11b(rect11a)\n",
        "        conv11b=self.bn11(conv11b)\n",
        "        rect11b =self.relu(conv11b)\n",
        "        \n",
        "        conv11c = self.conv11c(rect11b)\n",
        "        conv11c=self.bn11(conv11c)\n",
        "        rect11c = self.relu(conv11c)\n",
        "        \n",
        "        rect=rect11a+rect11c\n",
        "        \n",
        "        ###############12###############\n",
        "        conv12a = self.conv12a(rect)\n",
        "        \n",
        "        soft=self.softmax(conv12a)\n",
        "       \n",
        "        \n",
        "        return soft"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I1O_DjT5FrIK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Testing\n",
        "trans=transforms.Compose([transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sc9HWkecEF0j",
        "colab_type": "code",
        "outputId": "8e5ff14d-6dfb-4fd6-cef6-79083d91ace8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "am1=am1.view(800,24,3,128,128)\n",
        "da=am1[:100]\n",
        "da.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([100, 24, 3, 128, 128])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bQRxoUvBFrId",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "am=am.view((100,24,3,128,128))\n",
        "arr=arr.view((100,24,32,32,32))\n",
        "\n",
        "#for i in range(len(am)):\n",
        " #   am[i]=trans(am[i])\n",
        "    \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kmuVDmGCOrJS",
        "colab_type": "code",
        "outputId": "81851e31-6484-460f-c7ff-32aa4e64eb64",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2329"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zM_hzV9NFrIm",
        "colab_type": "code",
        "outputId": "1237394c-e34a-48e9-f4e9-23a5be96fb9d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        }
      },
      "source": [
        "am1=am1.view(800,24,3,128,128)\n",
        "print(am1.shape)\n",
        "print(arr_3DD.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([800, 24, 3, 128, 128])\n",
            "torch.Size([800, 24, 32, 32, 32])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x3dRcA3XFrIx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch.optim as optim\n",
        "import torch.optim.lr_scheduler as lr_scheduler\n",
        "\n",
        "\n",
        "criterion =  nn.CrossEntropyLoss()\n",
        "#criterion =  nn.BCELoss()\n",
        "\n",
        "optimizer = optim.Adam(model.parameters(),lr=((2)))#,eps=(1e-5)/10)#,betas=(0.9,0.999))\n",
        "#optimizer = optim.SGD(model.parameters(), lr = 2, momentum=0.0001)\n",
        "scheduler = lr_scheduler.CosineAnnealingLR(optimizer, 100, eta_min=0)\n",
        "#scheduler = lr_scheduler.CosineAnnealingLR(optimizer, arr.shape[0], eta_min=1e-8) #HEre i cosine not working"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D4A-Wgk70PM8",
        "colab_type": "code",
        "outputId": "3559e562-9063-4d37-8cbf-2e1c6130dde4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "arr_3DD.shape\n",
        "print(am1.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([800, 24, 3, 128, 128])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S-53_GTIPMN9",
        "colab_type": "text"
      },
      "source": [
        "sgd return none as loss"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BjDAFexWFrJC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import shutil\n",
        "n_epochs = 50\n",
        "#model=model.cuda()\n",
        "valid_loss_min = np.Inf # track change in validation loss\n",
        "model.train()\n",
        "import datetime\n",
        "for epoch in range(1, n_epochs+1):\n",
        "    #print(\"ALL ABOUT LOSS(valid)--------\",(valid_loss/len(valid_target)),\"----------/n\")\n",
        "    print(\"time--\", datetime.datetime.now().time())\n",
        "    train_loss = 0.0 \n",
        "    valid_loss=0.0\n",
        "    model.train()\n",
        "    #for j in range(len(l1)-1):\n",
        "    #arr=#l1[j]\n",
        "    arr=arr_3DD#[:100]\n",
        "    amk=da\n",
        "    for i in range(len(arr)):\n",
        "\n",
        "                        tar=arr[i].cuda()\n",
        "                        data=am1[i].cuda()#arr_3DD[i].cuda()\n",
        "                        tar=tar.long()\n",
        "                        optimizer.zero_grad()\n",
        "                        output=model(data)\n",
        "                        \n",
        "                        loss = criterion(output, tar)\n",
        "                        loss.backward()\n",
        "                        optimizer.step()\n",
        "                        \n",
        "                        train_loss += loss.item()*data.size(0)\n",
        "    #scheduler.step()\n",
        "    #print(\"Learning Rate is----\",scheduler.get_lr())\n",
        "    \n",
        "    \"\"\"model.eval() \n",
        "    data1=l1[3]          \n",
        "    for i in range(len(data1)):\n",
        "                data=data1[i].cuda()\n",
        "                tar=arr_3DD[i].cuda()\n",
        "                tar=tar.long()\n",
        "                loss = criterion(model(data), tar)\n",
        "    \"\"\"         #valid_loss += loss.item()*data.size(0)\n",
        "\n",
        "    print(\"Epoch---\",epoch)      \n",
        "    print(\"ALL ABOUT LOSS(training)--------\",(train_loss/800))\n",
        "    #print(\"ALL ABOUT LOSS(valid)--------\",(valid_loss/100))\n",
        "    print(\" \")                   \n",
        "torch.save(model.state_dict(),\"VNets_checkpoint50.pth\")\n",
        "shutil.copy(\"/content/VNets_checkpoint50.pth\",\"/content/gdrive/My Drive/Data\")                        \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lddIA_pR_6qK",
        "colab_type": "code",
        "outputId": "b059f0d8-d0c5-4cf4-cfe9-0066fd66a21f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 308
        }
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Thu May 16 05:12:46 2019       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 418.56       Driver Version: 410.79       CUDA Version: 10.0     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   76C    P0    34W /  70W |  14987MiB / 15079MiB |      0%      Default |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                       GPU Memory |\n",
            "|  GPU       PID   Type   Process name                             Usage      |\n",
            "|=============================================================================|\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "poZAnBhoFrJQ",
        "colab_type": "code",
        "outputId": "9bdfe1c8-d433-4973-c5fe-c535ef09f3d2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "torch.save(model.state_dict(),\"VNets_checkpoint50.pth\")\n",
        "shutil.copy(\"/content/VNets_checkpoint50.pth\",\"/content/gdrive/My Drive/Data\")                        \n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'/content/gdrive/My Drive/Data/VNets_checkpoint50.pth'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 143
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VxDBg6wvEJ17",
        "colab_type": "code",
        "outputId": "2afb7e9e-cdbb-45a2-8bfb-c2d204b5cb75",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "import shutil\n",
        "torch.save(model.state_dict(),\"VNets_checkpoint.pth\")\n",
        "shutil.copy(\"/content/VNets_checkpoint(50)Iter.pth\",\"/content/gdrive/My Drive/Data\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'/content/gdrive/My Drive/Data/VNets_checkpoint(50)Iter.pth'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pfYbu7rojfdw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model.load_state_dict(torch.load(\"/content/gdrive/My Drive/Data/VNets_checkpoint30.pth\"))\n",
        "model.eval();"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0kEdiW60cduu",
        "colab_type": "code",
        "outputId": "08f2e148-2722-4394-bf5b-7adce502b340",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        }
      },
      "source": [
        "print(arr_3DD.shape)\n",
        "print(am2.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([100, 24, 32, 32, 32])\n",
            "torch.Size([100, 24, 3, 128, 128])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jrj0VabuMw6R",
        "colab_type": "code",
        "outputId": "b1ea2a5b-43db-4bc3-ab0b-a2d45d3d0d2d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "out.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 32, 32, 32])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qrwEBbDrF1hC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "out=model(am1[2][:1].cuda())\n",
        "voxel2obj(\"ash4.obj\",out[0].cpu().numpy())#,arr_3DD[96][22\n",
        "#voxel2obj code below"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cPiJjm2P3T0B",
        "colab_type": "code",
        "outputId": "893f6e24-edf9-4b1d-bf9b-ad6ef02901b6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 145
        }
      },
      "source": [
        "#amk=am1.view((2400,3,128,128))\n",
        "to_pil(am1[2][9])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAAAHuUlEQVR4nO3aS2wT2xkH8DNzzsz4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\nAAAAAAAAAAAAAAAAAAAAsBX8B4XAUzy9VLkIAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=128x128 at 0x7F19A7B828D0>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C56R2NonGa1S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "out=torch.argmax(out,dim=1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jP4YcNVE9-g2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "am=torch.tensor(am)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BQqwl68D3Ib9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "am=torch.tensor(am)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5ELud2DHFrJf",
        "colab_type": "code",
        "outputId": "95a31f80-737e-445f-f235-92766b83489c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 145
        }
      },
      "source": [
        "import torchvision\n",
        "to_pil = torchvision.transforms.ToPILImage()\n",
        "to_pil(am1[700][11])\n",
        "#tar = to_pil(train_imag[24])\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAIAAABMXPacAAANsElEQVR4nO1cu48cxROuntc+bn1e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\nPDw8/nP4HyOO28h+WbR5AAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=128x128 at 0x7FF2A4400780>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dolqUlq94WaI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QUK_vzEGcy2v",
        "colab_type": "text"
      },
      "source": [
        "# 3D voxel(model o/p) to mesh representation to be saved in .obj format. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hzCKkgHp8jv1",
        "colab_type": "code",
        "outputId": "d806a3ab-89c8-4a17-9bbd-e7961a0aca58",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "\n",
        "def evaluate_voxel_prediction(preds, gt, thresh):\n",
        "    preds_occupy = preds[:, 1, :, :] >= thresh\n",
        "    diff = np.sum(np.logical_xor(preds_occupy, gt[:, 1, :, :]))\n",
        "    intersection = np.sum(np.logical_and(preds_occupy, gt[:, 1, :, :]))\n",
        "    union = np.sum(np.logical_or(preds_occupy, gt[:, 1, :, :]))\n",
        "    num_fp = np.sum(np.logical_and(preds_occupy, gt[:, 0, :, :]))  # false positive\n",
        "    num_fn = np.sum(np.logical_and(np.logical_not(preds_occupy), gt[:, 1, :, :]))  # false negative\n",
        "    return np.array([diff, intersection, union, num_fp, num_fn])\n",
        "\n",
        "\n",
        "def voxel2mesh(voxels):\n",
        "    cube_verts = [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0],\n",
        "                  [1, 1, 1]]  # 8 points\n",
        "\n",
        "    cube_faces = [[0, 1, 2], [1, 3, 2], [2, 3, 6], [3, 7, 6], [0, 2, 6], [0, 6, 4], [0, 5, 1],\n",
        "                  [0, 4, 5], [6, 7, 5], [6, 5, 4], [1, 7, 3], [1, 5, 7]]  # 12 face\n",
        "\n",
        "    cube_verts = np.array(cube_verts)\n",
        "    cube_faces = np.array(cube_faces) + 1\n",
        "\n",
        "    l, m, n = voxels.shape\n",
        "\n",
        "    scale = 0.01\n",
        "    cube_dist_scale = 1.1\n",
        "    verts = []\n",
        "    faces = []\n",
        "    curr_vert = 0\n",
        "    for i in range(l):\n",
        "        for j in range(m):\n",
        "            for k in range(n):\n",
        "                # If there is a non-empty voxel\n",
        "                if voxels[i, j, k] > 0:\n",
        "                    verts.extend(scale * (cube_verts + cube_dist_scale * np.array([[i, j, k]])))\n",
        "                    faces.extend(cube_faces + curr_vert)\n",
        "                    curr_vert += len(cube_verts)\n",
        "\n",
        "    return np.array(verts), np.array(faces)\n",
        "\n",
        "\n",
        "def write_obj(filename, verts, faces):\n",
        "    \"\"\" write the verts and faces on file.\"\"\"\n",
        "    with open(filename, 'w') as f:\n",
        "        # write vertices\n",
        "        f.write('g\\n# %d vertex\\n' % len(verts))\n",
        "        for vert in verts:\n",
        "            f.write('v %f %f %f\\n' % tuple(vert))\n",
        "\n",
        "        # write faces\n",
        "        f.write('# %d faces\\n' % len(faces))\n",
        "        for face in faces:\n",
        "            f.write('f %d %d %d\\n' % tuple(face))\n",
        "\n",
        "\n",
        "def voxel2obj(filename, pred):\n",
        "    verts, faces = voxel2mesh(pred)\n",
        "    write_obj(filename, verts, faces)\n",
        " \n",
        "\n",
        "#You can open .obj in any of the 3D viewing software.\n",
        "voxel2obj(\"ash7.obj\",arr_3DD[700][11])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([800, 24, 32, 32, 32])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mUtwVpnV5c4y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NCQSQiv94FcB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fDF97W5VbbpM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#out.shape\n",
        "#ou=torch.argmax(out,dim=1)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NclshiS7GSke",
        "colab_type": "code",
        "outputId": "691399d0-706e-47be-d264-e41301455835",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([16, 32, 32, 32])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "isVS7mxRbqMf",
        "colab_type": "code",
        "outputId": "e89c56ab-7084-4093-bcd1-fba4e9490b1f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "arr_3DD.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([100, 24, 32, 32, 32])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ulPEF5wWgzBU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ALgNITIz19k8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "voxel2obj(\"ash5.obj\",mm[0].cpu())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fITZxAPjFrJl",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L3JloXxKFrJr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "am=model(data[:1])\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eD5Dem2VFrKC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "mm=torch.argmax(dd,dim=1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KHTxDwCq2nM_",
        "colab_type": "code",
        "outputId": "46dbda13-0a5f-496d-dc55-4be3d1adc190",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "mm.shape"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 32, 32, 32])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1s9mi40fFrLR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dd=model(am1[33][:1].cuda())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PxnW8DRcFrLo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "##################DEFINE transform###########\n",
        "from torchvision import transforms\n",
        "transform=transforms.Compose([\n",
        "    transforms.CenterCrop((128,128)),\n",
        "    transforms.ToTensor()\n",
        "])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uF45tEd7FrLu",
        "colab_type": "text"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NJRbwLqbFrLv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Here now list 2 contanins name of all the folder images:\n",
        "\n",
        "\n",
        "def DataRead(path):\n",
        "    list2={}\n",
        "    dict1={}\n",
        "    list1=[]\n",
        "    ak=os.listdir(path)\n",
        "    for i in range(len(ak)):\n",
        "        pk=os.path.join(path,ak[i])\n",
        "        list1.append(pk)\n",
        "    for i in range(len(list1)):\n",
        "        ak=os.listdir(list1[i])\n",
        "        for j in range(len(ak)):\n",
        "            pk=os.path.join(list1[i],ak[j])\n",
        "            dict1.update({j:pk})\n",
        "        list2.update({i:dict1})\n",
        "        dict1={}\n",
        "    \n",
        "    return list2       \n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qZ2z3HAbFrL1",
        "colab_type": "code",
        "outputId": "538aabe4-76c9-47ce-cefd-e8ac133d30fb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 108
        }
      },
      "source": [
        "#NOW list1 contains all the name of files\n",
        "#Eg---'F:\\\\SProject\\\\ShapeNetRendering\\\\02691156',\n",
        "#imges(only images)-----\n",
        "import torch\n",
        "#only 5 sets are taken\n",
        "arr=torch.empty([5,100,24,3,128,128])\n",
        "\n",
        "path1=r\"/content/New folder\"\n",
        "\n",
        "list1=DataRead(path1)\n",
        "for i in range(5):#(len(list1)):\n",
        "    print(i)\n",
        "    for j in range(100):#(len(list1[i])):\n",
        "        nm=os.path.join(list1[i][j],\"rendering/renderings.txt\")\n",
        "        #print(nm)\n",
        "        pl=pd.read_csv(nm,names=[0])\n",
        "        for k in range(len(pl)):\n",
        "            img=Image.open(os.path.join(list1[i][j],\"rendering\",pl[0][k])).convert(\"RGB\")\n",
        "            im=transform(img)\n",
        "            arr[i][j][k]=im\n",
        "        "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GK4Wq5nEFrL9",
        "colab_type": "code",
        "outputId": "89f3fa21-773d-4f15-c5a3-8731181b577a",
        "colab": {}
      },
      "source": [
        "arr.shape\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([5, 100, 24, 1, 128, 128])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MkyhQ6Tc-wfh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hfq7v_ZlFrMB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i3pDd70UFrMF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import binvox_rw\n",
        "def read_3D(an):\n",
        "    with open(an, 'rb') as f:\n",
        "        model = binvox_rw.read_as_3d_array(f)\n",
        "        m=model.data \n",
        "        return m.astype(int)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xlBohdTcKG5R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WFe5n2mDFrMJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Now binvox file Time\n",
        "trans3D=transforms.ToTensor()\n",
        "path2=\"r/content/ShapeNetVox32\"\n",
        "arr_3D=torch.empty([5,100,32,32,32])\n",
        "list2=DataRead(path2)\n",
        "for i in range(5):#(len(list2)):\n",
        "    print(\"Hey its \",i)\n",
        "    for j in range(100):#(len(list2[i])):\n",
        "        an=os.path.join(list2[i][j],'model.binvox')#IT CONTAINS THE FINAL DIRECTORIES    \n",
        "        ap=trans3D(read_3D(an))\n",
        "        arr_3D[i][j]=ap\n",
        "        \n",
        "arr_3D=arr_3D.view(5,100,1,32,32,32)        \n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4xJ7l3BLFrMN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "path2=r\"/content/ShapeNetVox32\"\n",
        "list2=DataRead(path2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ht9XdQO-FrMQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H9YvAtF742bV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "####Making Binary\n",
        "arr_m=torch.empty(100,1,2,32,32,32)\n",
        "for i in range(100):\n",
        "  for j in range(32):\n",
        "    for k in range(32):\n",
        "      for l in range(32):\n",
        "        arr_m[i][0][0][j][k][l]=0\n",
        "        if arr_3d[i][0][j][k][l]==0:\n",
        "            arr_m[i][0][1][j][k][l]=0\n",
        "        elif arr_3d[i][0][j][k][l]==1:\n",
        "            arr_m[i][0][1][j][k][l]=1\n",
        "        else:\n",
        "          print(\"i\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tUTWoBE_FrMR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4iAk4rLOFrMh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_-CIhGhoFrMk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "\n",
        "    "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GV1QZLP3FrMm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oRh7hpF9FrMv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e83btHPAFrMy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FXjjSQPAFrM1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dnQnXcs6FrM7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zlGLNVwuFrM_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}