DATASET_BUILDER.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "custom_covid_dataset_builder.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMnCI0/Uo3lMTxDvf3NgBQu",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/SimoneRosset/AUGMENTATION_GAN/blob/master/custom_covid_dataset_builder.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zxv4fbaYUIon",
        "colab_type": "text"
      },
      "source": [
        "# CUSTOM COVID-19 X-RAYs SCANS DATASET BUILDER"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7HiUA-waF1vI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "from torchsummary import summary"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UnEsFdblgHH-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import os\n",
        "from tqdm import notebook\n",
        "from sklearn.metrics import classification_report, confusion_matrix\n",
        "from tabulate import tabulate\n",
        "import gc\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from PIL import Image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jkvQS_ffS7yE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!git clone https://github.com/vj2050/Transfer-Learning-COVID-19.git"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mV2-VF7TSxHC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!git clone https://github.com/SimoneRosset/AUGMENTATION_GAN.git"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WDfRQKdehgiX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for func in [lambda: os.mkdir(os.path.join('.','AUGMENTATION_GAN/custom_covid_dataset/')),\n",
        "            lambda: os.mkdir(os.path.join('.', 'AUGMENTATION_GAN/custom_covid_dataset/test/')),\n",
        "            lambda: os.mkdir(os.path.join('.', 'AUGMENTATION_GAN/custom_covid_dataset/test/covid')),\n",
        "            lambda: os.mkdir(os.path.join('.', 'AUGMENTATION_GAN/custom_covid_dataset/test/normal')),\n",
        "            lambda: os.mkdir(os.path.join('.', 'AUGMENTATION_GAN/custom_covid_dataset/test/pneumonia_bac')),\n",
        "            lambda: os.mkdir(os.path.join('.', 'AUGMENTATION_GAN/custom_covid_dataset/test/pneumonia_vir'))]:\n",
        "  try:\n",
        "    func()\n",
        "  except Exception as error:\n",
        "    print(error)\n",
        "    continue\n",
        "\n",
        "sets=[500,1000,2000,3000]\n",
        "\n",
        "paths=[]\n",
        "\n",
        "for i in range(len(sets)):\n",
        "  paths.append('AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/')\n",
        "  paths.append('AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/covid')\n",
        "  paths.append('AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/normal')\n",
        "  paths.append('AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/pneumonia_bac')\n",
        "  paths.append('AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/pneumonia_vir')\n",
        "\n",
        "for path in paths:\n",
        "  try:\n",
        "    os.mkdir(os.path.join('.', path))\n",
        "  except Exception as error:\n",
        "    print(error)\n",
        "    continue"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5_RpgtM2fx1J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "img_dim=64\n",
        "N_rot=2\n",
        "N_flip=2\n",
        "N_tran=4\n",
        "N_scal=4\n",
        "N_color=2\n",
        "transform_list=[]\n",
        "\n",
        "transform_list.append(transforms.Resize((img_dim*2,img_dim*2),interpolation=2))\n",
        "\n",
        "for i in range(N_color):\n",
        "  transform_list.append(transforms.RandomApply([transforms.ColorJitter(brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5)],p=0.5))\n",
        "for i in range(N_rot):\n",
        "  transform_list.append(transforms.RandomApply([transforms.RandomRotation(degrees=(-5,5))], p=0.5))\n",
        "for i in range(N_flip):\n",
        "  transform_list.append(transforms.RandomHorizontalFlip(p=0.5))\n",
        "for i in range(N_scal):\n",
        "  transform_list.append(transforms.RandomApply([transforms.RandomAffine(degrees=0,scale=(0.9,1.1))], p=0.5))\n",
        "for i in range(N_tran):\n",
        "  transform_list.append(transforms.RandomApply([transforms.RandomAffine(degrees=0,translate=(0.1,0.1))], p=0.5))\n",
        "\n",
        "transform_list.append(transforms.Resize((img_dim,img_dim),interpolation=2))\n",
        "\n",
        "transform_list.append(transforms.ToTensor())\n",
        "\n",
        "transform = transforms.Compose(transform_list)\n",
        "\n",
        "test_transform = transforms.Compose([transforms.Resize((img_dim,img_dim),interpolation=2),\n",
        "                                    transforms.ToTensor(),\n",
        "                                    ])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Psz_Y4I9GBBn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class MyImageFolder(torchvision.datasets.ImageFolder):\n",
        "  def __getitem__(self, index):\n",
        "    return super(MyImageFolder, self).__getitem__(index)[0], super(MyImageFolder, self).__getitem__(index)[1], self.imgs[index][0]#return image path"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2YOlOfWPFTys",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "batch_size=1\n",
        "data_dir='Transfer-Learning-COVID-19/dataset_4_classes/'\n",
        "\n",
        "trainset = MyImageFolder(os.path.join(\n",
        "          data_dir, \"train/\"), transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(\n",
        "          trainset, batch_size=batch_size, shuffle=True)\n",
        "testset = MyImageFolder(os.path.join( \n",
        "          data_dir, \"test/\"), transform=test_transform)\n",
        "testloader = torch.utils.data.DataLoader(\n",
        "          testset, batch_size=batch_size, shuffle=False)\n",
        "normalset = MyImageFolder(os.path.join(\n",
        "          data_dir, \"train/\"), transform=test_transform)\n",
        "normalloader = torch.utils.data.DataLoader(\n",
        "          normalset, batch_size=batch_size, shuffle=False)\n",
        "\n",
        "classes = (\"covid\", \"normal\", \"pneumonia_bac\",\"pneumonia_vir\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2rMBlGLfPn3X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# functions to show an image\n",
        "\n",
        "def imshow(img):\n",
        "    #img = img / 2 + 0.5     # unnormalize\n",
        "    npimg = img.numpy()\n",
        "    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
        "    plt.show()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E5_y_AE9VfN_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "outputId": "b4cb56ee-0db4-449b-c0de-342d1b356418"
      },
      "source": [
        "# get some random training images\n",
        "dataiter = iter(trainloader)\n",
        "images, labels, path = dataiter.next()\n",
        "\n",
        "# show images\n",
        "imshow(torchvision.utils.make_grid(images))\n",
        "# print labels\n",
        "print(' '.join('%5s' % classes[labels[j]] for j in range(batch_size)))\n",
        "\n",
        "name, ext= (path[0].split('/')[-1]).rsplit('.', 1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "pneumonia_bac\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SR0vD-Cca3dd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#MAKE FOLDER TEST\n",
        "dataiter = iter(testloader)\n",
        "\n",
        "for i in range(len(testloader.dataset)):\n",
        "    images, labels, path = dataiter.next()\n",
        "   \n",
        "    npimg = np.transpose(images.squeeze(0).numpy(), (1, 2, 0))\n",
        "\n",
        "    img = Image.fromarray((npimg * 255).astype(np.uint8))\n",
        "\n",
        "    name, ext= (path[0].split(\"/\")[-1]).rsplit('.', 1)\n",
        "\n",
        "    fold=classes[labels[0]]\n",
        "\n",
        "    abs_path='AUGMENTATION_GAN/custom_covid_dataset/test/'+fold+'/'+name+'.'+ext\n",
        "\n",
        "    if ext=='png':\n",
        "      img.save(abs_path, 'PNG')\n",
        "    else:\n",
        "      img.save(abs_path, 'JPEG')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JJ8zuHztBsDE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#MAKE FOLDER 0\n",
        "dataiter = iter(normalloader)\n",
        "\n",
        "for i in range(len(normalloader.dataset)):\n",
        "    images, labels, path = dataiter.next()\n",
        "   \n",
        "    npimg = np.transpose(images.squeeze(0).numpy(), (1, 2, 0))\n",
        "\n",
        "    img = Image.fromarray((npimg * 255).astype(np.uint8))\n",
        "\n",
        "    name, ext= (path[0].split(\"/\")[-1]).rsplit('.', 1)\n",
        "\n",
        "    fold=classes[labels[0]]\n",
        "\n",
        "    abs_path='AUGMENTATION_GAN/custom_covid_dataset/train/'+fold+'/'+name+'.'+ext\n",
        "\n",
        "    if ext=='png':\n",
        "      img.save(abs_path, 'PNG')\n",
        "    else:\n",
        "      img.save(abs_path, 'JPEG')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V7MHt8l3SjnQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 81
        },
        "outputId": "5ded8e65-308d-400c-b859-8791f488d58d"
      },
      "source": [
        "dataiter = iter(normalloader)\n",
        "\n",
        "images, labels, path = dataiter.next()\n",
        "   \n",
        "npimg = np.transpose(images.squeeze(0).numpy(), (1, 2, 0))\n",
        "\n",
        "im = Image.fromarray((npimg * 255).astype(np.uint8))\n",
        "\n",
        "display(im)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=64x64 at 0x7FA77ADB96D8>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mR8bwBP0EQHJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dataiter = iter(trainloader) # MAKE OTHER FOLDERS\n",
        "\n",
        "for i in range(1,len(sets),1):\n",
        "  covid=sets[i-1] #sequential\n",
        "  normal=sets[i-1]\n",
        "  pneu=sets[i-1]\n",
        "  vir=sets[i-1]\n",
        "  # covid=0 \n",
        "  # normal=0\n",
        "  # pneu=0\n",
        "  none=1\n",
        "  print('folder start: ',sets[i])\n",
        "  dataiter = iter(trainloader)\n",
        " \n",
        "  while covid<sets[i] or normal<sets[i] or pneu<sets[i] or vir<sets[i]:\n",
        "\n",
        "    images, labels, path = dataiter.next()\n",
        "   \n",
        "    npimg = np.transpose(images.squeeze(0).numpy(), (1, 2, 0))\n",
        "\n",
        "    img = Image.fromarray((npimg * 255).astype(np.uint8))\n",
        "\n",
        "    name, ext= (path[0].split('/')[-1]).rsplit('.', 1)\n",
        "\n",
        "    fold=classes[labels[0]]\n",
        "\n",
        "\n",
        "    if fold == 'covid' and covid<sets[i]:\n",
        "      abs_path='AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/'+fold+'/'+str(sets[i])+'.'+str(covid)+'.'+name+'.'+ext\n",
        "      covid+=1\n",
        "      if ext=='png':\n",
        "        img.save(abs_path, 'PNG')\n",
        "      else:\n",
        "        img.save(abs_path, 'JPEG')\n",
        "    else:\n",
        "      if fold == 'normal' and normal<sets[i]:\n",
        "        abs_path='AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/'+fold+'/'+str(sets[i])+'.'+str(normal)+'.'+name+'.'+ext\n",
        "        normal+=1\n",
        "        if ext=='png':\n",
        "          img.save(abs_path, 'PNG')\n",
        "        else:\n",
        "          img.save(abs_path, 'JPEG')\n",
        "      else:\n",
        "        if fold == 'pneumonia_bac' and pneu<sets[i]:\n",
        "          abs_path='AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/'+fold+'/'+str(sets[i])+'.'+str(pneu)+'.'+name+'.'+ext\n",
        "          pneu+=1\n",
        "          if ext=='png':\n",
        "            img.save(abs_path, 'PNG')\n",
        "          else:\n",
        "            img.save(abs_path, 'JPEG')\n",
        "        else:\n",
        "          if fold == 'pneumonia_vir' and vir<sets[i]:\n",
        "            abs_path='AUGMENTATION_GAN/custom_covid_dataset/train_classic/'+str(sets[i])+'/'+fold+'/'+str(sets[i])+'.'+str(vir)+'.'+name+'.'+ext\n",
        "            vir+=1\n",
        "            if ext=='png':\n",
        "              img.save(abs_path, 'PNG')\n",
        "            else:\n",
        "              img.save(abs_path, 'JPEG')\n",
        "          else:\n",
        "            none+=1\n",
        "\n",
        "    if (covid+normal+pneu+vir+none)%200==0:\n",
        "      dataiter = iter(trainloader)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tKHZrUjXUpPd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}