trial1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPQG1ASNLRKQa8rUo8LTOwm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/threedee003/NotebooksForDL/blob/main/trial1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "9h2o4RQvTWOw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a25a7829-dc7e-4f01-a0b0-452e038621a1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "trainDir = \"/content/drive/MyDrive/GIS/trainTiles\"\n",
        "testDir = \"/content/drive/MyDrive/GIS/testTiles\""
      ],
      "metadata": {
        "id": "_cvvaZxBvHgw"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import os\n",
        "import skimage.io as io\n",
        "import time\n",
        "from itertools import product\n",
        "\n",
        "\n",
        "\n",
        "import torch.nn as nn\n",
        "import torch\n",
        "import torch.optim as optim\n",
        "from torchsummary import summary\n",
        "from torch.utils.data import Dataset\n",
        "from torchvision.transforms import transforms"
      ],
      "metadata": {
        "id": "nMRNA6IgaLo_"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "class CustomDataset(Dataset):\n",
        "    def __init__(self, data_dir, transform=None):\n",
        "        self.data_dir = data_dir\n",
        "        self.transform = transform\n",
        "        self.imageFilenames = sorted(os.listdir(os.path.join(data_dir, \"tiles\")))\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.imageFilenames)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        imagePath = os.path.join(self.data_dir, \"tiles\", self.imageFilenames[idx])\n",
        "        img = np.load(imagePath)\n",
        "        X = img[:,:,0:5]\n",
        "        Y = img[:,:,-1]\n",
        "\n",
        "\n",
        "        \n",
        "\n",
        "        if self.transform:\n",
        "            X = self.transform(X)\n",
        "            Y = self.transform(Y)\n",
        "\n",
        "        return X, Y\n"
      ],
      "metadata": {
        "id": "a4IMKIJoLWSL"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "])"
      ],
      "metadata": {
        "id": "c226ZLD4XTat"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "trainSet = CustomDataset(trainDir, transform=transform)\n",
        "validationSet = CustomDataset(testDir, transform=transform)\n",
        "\n",
        "trainLoader = torch.utils.data.DataLoader(trainSet, batch_size=None, shuffle=True)\n",
        "validationLoader = torch.utils.data.DataLoader(validationSet, batch_size = None, shuffle = True)"
      ],
      "metadata": {
        "id": "2OD0pDzgXTYF"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Number of training samples : {}\".format(len(trainLoader)))\n",
        "print(\"Number of validating samples : {}\".format(len(validationLoader)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rNAe2EhjvgYx",
        "outputId": "dbc7ffdb-fe3e-46b8-e700-a9447da64028"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of training samples : 1120\n",
            "Number of validating samples : 440\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Autoencoder1(nn.Module):\n",
        "  def __init__(self,channels):\n",
        "    super(Autoencoder1,self).__init__()\n",
        "    self.encoder = nn.Sequential(\n",
        "        nn.Conv2d(channels,64, kernel_size = 3),\n",
        "        nn.Conv2d(64,64,kernel_size = 3, stride = 2),\n",
        "        nn.Conv2d(64,128,kernel_size= 3),\n",
        "        nn.Conv2d(128,128,kernel_size = 3,stride = 2),\n",
        "        nn.Conv2d(128,256,kernel_size = 3),\n",
        "        nn.Conv2d(256,256,kernel_size = 3,stride = 2),\n",
        "        nn.Conv2d(256,512,kernel_size = 3)\n",
        "    )\n",
        "\n",
        "    self.decoder = nn.Sequential(\n",
        "        nn.Conv2d(512,256,kernel_size = 2),\n",
        "        nn.ConvTranspose2d(256,256,kernel_size=4, stride=2, padding=1, output_padding=0),\n",
        "        nn.Conv2d(256,128,kernel_size = 3),\n",
        "        nn.ConvTranspose2d(128,128,kernel_size=4, stride=2, padding=1, output_padding=0),\n",
        "        nn.Conv2d(128,64,kernel_size = 3),\n",
        "        nn.ConvTranspose2d(64,64,kernel_size=4, stride=2, padding=1, output_padding=0),\n",
        "        nn.Conv2d(64,1,kernel_size = 3)\n",
        "    )\n",
        "\n",
        "\n",
        "  def forward(self,x):\n",
        "    x = self.encoder(x)\n",
        "    x = self.decoder(x)\n",
        "\n",
        "    return x"
      ],
      "metadata": {
        "id": "mUvldmB7Xepl"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Autoencoder2(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Autoencoder2, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            nn.Conv2d(5, 32, kernel_size=3, stride=1, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
        "            nn.Conv2d(32, 16, kernel_size=3, stride=1, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool2d(kernel_size=2, stride=2)\n",
        "        )\n",
        "        self.decoder = nn.Sequential(\n",
        "            nn.ConvTranspose2d(16, 32, kernel_size=3, stride=2, padding=1, output_padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.ConvTranspose2d(32, 1, kernel_size=3, stride=2, padding=1, output_padding=1),\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.encoder(x)\n",
        "        x = self.decoder(x)\n",
        "        return x"
      ],
      "metadata": {
        "id": "jQ4F4_W5agWh"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "autoenc = Autoencoder2()"
      ],
      "metadata": {
        "id": "NfD2SYtexkmo"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "def trainer(model,trainLoader,validationLoader,epochs,lossFn,optimizer,trainLoss,validLoss,device,batchSize):\n",
        "  model = model.to(device)\n",
        "  for epoch in range(epochs):\n",
        "    runningLoss = 0.0\n",
        "    for x, y in trainLoader:\n",
        "      x = x.to(device)\n",
        "      y = y.to(device)\n",
        "      optimizer.zero_grad()\n",
        "      pred = model(x)\n",
        "      loss = lossFn(pred,y)\n",
        "      loss.backward()\n",
        "      optimizer.step()\n",
        "      runningLoss += loss.item()\n",
        "    trainLoss.append(runningLoss/(len(trainLoader)/batchSize))\n",
        "\n",
        "    with torch.no_grad():\n",
        "      valLoss = 0.0\n",
        "      for x, y in validationLoader:\n",
        "        x = x.to(device)\n",
        "        y = y.to(device)\n",
        "        pred = model(x)\n",
        "        loss = lossFn(pred,y)\n",
        "        valLoss += loss.item()\n",
        "      validLoss.append(valLoss/(len(validationLoader)/batchSize))\n",
        "\n",
        "    print(f\"Epoch {epoch+1}/{epochs}, Training Loss: {runningLoss/len(trainLoader)}, Validation Loss: {valLoss/len(validationLoader)}\")\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "      \n"
      ],
      "metadata": {
        "id": "yiWvAmOsXTQ2"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "criterion = nn.MSELoss()\n",
        "optimizer = optim.Adam(autoenc.parameters(), lr=0.001)\n",
        "batchSize = 1\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "eps = 20\n",
        "trainArr = []\n",
        "validArr = []"
      ],
      "metadata": {
        "id": "y3mUQ_3PbUWI"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if device.type == 'cuda':\n",
        "    print(torch.cuda.get_device_name(0))\n",
        "    print('Memory Usage:')\n",
        "    print('Allocated:', round(torch.cuda.memory_allocated(0)/1024**3,1), 'GB')\n",
        "    print('Cached:   ', round(torch.cuda.memory_reserved(0)/1024**3,1), 'GB')"
      ],
      "metadata": {
        "id": "XYmsbh0sbpFR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab0c35e0-4096-4671-b830-720e5436c68c"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Tesla T4\n",
            "Memory Usage:\n",
            "Allocated: 0.0 GB\n",
            "Cached:    0.0 GB\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "trainer(autoenc,trainLoader,validationLoader,eps,criterion,optimizer,trainArr,validArr,device,batchSize)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uxlNxeGVcdIH",
        "outputId": "64a546b3-9506-4c9f-8e70-d9db6b380e6a"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20, Training Loss: 0.05557431488540325, Validation Loss: 0.03441519501634916\n",
            "Epoch 2/20, Training Loss: 0.05174833213645798, Validation Loss: 0.03660056213474573\n",
            "Epoch 3/20, Training Loss: 0.05155318109079872, Validation Loss: 0.04063302625237901\n",
            "Epoch 4/20, Training Loss: 0.05041664637068217, Validation Loss: 0.03590140416806455\n",
            "Epoch 5/20, Training Loss: 0.05002964172958855, Validation Loss: 0.036551242471085224\n",
            "Epoch 6/20, Training Loss: 0.05010531064276458, Validation Loss: 0.038339501196804286\n",
            "Epoch 7/20, Training Loss: 0.049113506775419834, Validation Loss: 0.03656224893875333\n",
            "Epoch 8/20, Training Loss: 0.04895195204458754, Validation Loss: 0.036995594416789984\n",
            "Epoch 9/20, Training Loss: 0.04897176352620006, Validation Loss: 0.0354427914675894\n",
            "Epoch 10/20, Training Loss: 0.048758907798657804, Validation Loss: 0.035079187237170115\n",
            "Epoch 11/20, Training Loss: 0.04855321170632903, Validation Loss: 0.037222427007195205\n",
            "Epoch 12/20, Training Loss: 0.048916614037109084, Validation Loss: 0.0350082534162952\n",
            "Epoch 13/20, Training Loss: 0.04883378847347168, Validation Loss: 0.03569367524391137\n",
            "Epoch 14/20, Training Loss: 0.04806197774775569, Validation Loss: 0.03819169209539475\n",
            "Epoch 15/20, Training Loss: 0.04763523495233163, Validation Loss: 0.03619456639538508\n",
            "Epoch 16/20, Training Loss: 0.04817731980261572, Validation Loss: 0.03813883678807212\n",
            "Epoch 17/20, Training Loss: 0.047112160043644734, Validation Loss: 0.04187594343476865\n",
            "Epoch 18/20, Training Loss: 0.04737328384858951, Validation Loss: 0.03705633871958195\n",
            "Epoch 19/20, Training Loss: 0.04708447566830825, Validation Loss: 0.03724443844694179\n",
            "Epoch 20/20, Training Loss: 0.04735344428103028, Validation Loss: 0.0433690896822637\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(trainArr, label='training loss')\n",
        "plt.plot(validArr, label='validation loss')\n",
        "plt.title('Loss at the end of each epoch')\n",
        "plt.legend();"
      ],
      "metadata": {
        "id": "lS3ob3qicuAC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "outputId": "faf227e8-0323-4f9f-8e04-f6311b7e62c9"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "hVTDzUwJfewz"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}