data_preprocessing.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ncorriveau/ood_computervision/blob/main/data_preprocessing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Preprocessing"
      ],
      "metadata": {
        "id": "hVpCiVQ4-f8b"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wM9WNrzj-a0W",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "outputId": "6ac4bd0d-63ea-410f-dad5-6efff8cf8912"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cpu'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "import numpy as np \n",
        "import pandas as pd\n",
        "import os\n",
        "from pathlib import Path\n",
        "import random\n",
        "from PIL import Image\n",
        "from matplotlib import pyplot as plt\n",
        "import requests\n",
        "import zipfile\n",
        "import shutil\n",
        "\n",
        "#put on gpu if available \n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "device\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''steps:\n",
        "\n",
        "1.) map the images to the superclass, sublcass in a dict\n",
        "2.) map superclass, sublcass to names \n",
        "2.) loop through training images and put them into appropriate folders\n",
        "    we will build in a way to exclude certain sub classes here \n",
        "3.) loop through testing images and categorize the same way  \n",
        "'''\n",
        "\n",
        "data_path = '/content/drive/MyDrive/NN and DL/projects/Released_Data'\n",
        "train_zip = data_path + '/train_image.zip'\n",
        "test_zip = data_path + 'test_image.zip'\n"
      ],
      "metadata": {
        "id": "CABV1OQQBIOH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UdmVpDK5dym-",
        "outputId": "5bd084d8-dbae-4503-d00e-edc95f42c2aa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''uncomment out this cell if you'd like to delete the existing train/test directories to reshape them'''\n",
        "# shutil.rmtree(data_path+'/train', ignore_errors=False, onerror=None)\n",
        "# shutil.rmtree(data_path+'/test', ignore_errors=False, onerror=None)\n"
      ],
      "metadata": {
        "id": "1FUFiGmjaMfR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def make_class_dict(path):\n",
        "  '''takes class mapping csv and returns dict of {class: name}'''\n",
        "  import pandas as pd\n",
        "  df = pd.read_csv(path)\n",
        "  return df['class'].to_dict()\n",
        "\n",
        "\n",
        "super_class_names = make_class_dict(data_path + '/super_classes_mapping.csv')\n",
        "sub_class_names = make_class_dict(data_path + '/sub_classes_mapping.csv')\n",
        "sub_class_names"
      ],
      "metadata": {
        "id": "jF-u64VoEfqd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def make_image_mapping(path):\n",
        "  '''reads the label files and maps image names to (class, sublcass) tuples'''\n",
        "  import pandas as pd\n",
        "  df = pd.read_csv(path)\n",
        "  df = df.set_index('image')\n",
        "  df['combined'] = df.apply(lambda x: (x[0],x[1]), axis=1)\n",
        "  return df['combined'].to_dict()\n",
        "  \n",
        "image_mappings = make_image_mapping(data_path + '/train_data.csv')\n",
        "image_mappings"
      ],
      "metadata": {
        "id": "XFeqDtFQGGZJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def make_dir(root, new_dir, verbose=False):\n",
        "  '''takes a given root path, and a desired directory in that path, and either confirms it exists or creates a new one'''\n",
        "\n",
        "  data_path = Path(root)\n",
        "  image_path = data_path / new_dir \n",
        " \n",
        "  if image_path.exists() and verbose:\n",
        "      print(f\"{image_path} directory exists.\")\n",
        "  else:\n",
        "    if verbose:\n",
        "      print(f\"Did not find {image_path} directory, creating one...\")\n",
        "      print(f\"{image_path} created\")\n",
        "    image_path.mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "make_dir(data_path, 'train')\n",
        "make_dir(data_path, 'test')"
      ],
      "metadata": {
        "id": "V2RgXpBS_Riw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "path = Path('./tmp/train_shuffle')\n",
        "for dirpath, dirnames, filenames in os.walk(path):\n",
        "    print(f\"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.\")\n",
        "    #for file in filenames:\n",
        "      "
      ],
      "metadata": {
        "id": "Ul_dAnYX_8yd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#make the super class folders for training and testing \n",
        "train_path = '/content/drive/MyDrive/NN and DL/projects/Released_Data/train'\n",
        "test_path = '/content/drive/MyDrive/NN and DL/projects/Released_Data/test'\n",
        "\n",
        "superclass_list = pd.read_csv(data_path + '/super_classes_mapping.csv')\n",
        "superclass_list = superclass_list['class'].to_list()\n",
        "#print(superclass_list)\n",
        "for sclass in superclass_list:\n",
        "  make_dir(train_path, sclass)\n",
        "  make_dir(test_path, sclass)\n",
        "\n",
        "print(os.listdir(train_path))"
      ],
      "metadata": {
        "id": "spMZhthHghQn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7dc26c3f-114f-4680-8f62-ae335a648079"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['bird', 'dog', 'reptile']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def create_folder_structure(zip_path, dest_path, sub_class_names, super_class_names, image_mappings, exclude_list = []):\n",
        "  '''\n",
        "  loops through the zip folder and creates folder structure in the dest_path of \n",
        "    super class/ \n",
        "      sub class/\n",
        "    \n",
        "  \n",
        "    where the image is moved from the original folder to the appropiate subclass folder. \n",
        "    \n",
        "    zip_path is the path to the train_image.zip folder, \n",
        "    sub_class_names, super_class_names, and image_mappings are all dictionaries \n",
        "    mapping sub class indexes to names, super class indexes to names, and images to \n",
        "    their respective super class, sub class \n",
        "\n",
        "    optional argument exception list where you can designate subclasses \n",
        "    you'd like to not copy over. This would be used if we want to exclude \n",
        "    training examples from our training set. \n",
        "    '''\n",
        "\n",
        "  with zipfile.ZipFile(zip_path, 'r') as zip_ref:\n",
        "      zip_ref.extractall('./tmp')\n",
        "\n",
        "  path = Path('./tmp/train_shuffle')\n",
        "  count = 0\n",
        "\n",
        "  for dirpath, dirnames, images in os.walk(path):\n",
        "    for image in images:\n",
        "      count+=1\n",
        "      if count%100 == 0:\n",
        "        print(f\"{count} images copied\")\n",
        "\n",
        "      if image != '.DS_Store':\n",
        "        super_class, sub_class  = image_mappings[image]\n",
        "        #print(super_class,sub_class)\n",
        "        super_class_name = super_class_names[super_class]\n",
        "        sub_class_name = sub_class_names[sub_class]\n",
        "        sub_class_name = sub_class_name.replace(\" \", \"\").split(',')[0]\n",
        "\n",
        "        if sub_class_name not in exclude_list:\n",
        "          print(f\"making {sub_class_name} directory\")\n",
        "\n",
        "          #create directories if they don't already exist\n",
        "          make_dir(dest_path+'/'+super_class_name, sub_class_name)\n",
        "\n",
        "          #get path to superclass folder, subclass folder\n",
        "          sub_path = dest_path+\"/\"+super_class_name+\"/\"+sub_class_name\n",
        "          #print(f\"super path : {super_path}\\n sub path = {sub_path}\")\n",
        "          if Path(sub_path + \"/\" + image).is_dir():\n",
        "            print(f\"{sub_path} + \"/\" {image} already present\")\n",
        "          else:\n",
        "            shutil.copy(dirpath + '/' + image, sub_path)\n"
      ],
      "metadata": {
        "id": "9WwZmcDeD1PX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "zippath = '/content/drive/MyDrive/NN and DL/projects/Released_Data/train_image.zip'\n",
        "dest_path = '/content/drive/MyDrive/NN and DL/projects/Released_Data/train'\n",
        "create_folder_structure(zippath, dest_path, sub_class_names, super_class_names, image_mappings)"
      ],
      "metadata": {
        "id": "PZIRqFKXU0sj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "zippath = '/content/drive/MyDrive/NN and DL/projects/Released_Data/test_image.zip'\n",
        "dest_path = '/content/drive/MyDrive/NN and DL/projects/Released_Data/test'\n",
        "create_folder_structure(zippath, dest_path, sub_class_names, super_class_names, image_mappings)"
      ],
      "metadata": {
        "id": "noHkmwU5t394"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Augmentation"
      ],
      "metadata": {
        "id": "psudbRSqlnjd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from torch.utils.data import DataLoader\n",
        "from torchvision import datasets, transforms"
      ],
      "metadata": {
        "id": "532ZmenQlpsJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#kind've randomly created this from available transformations on pytorch, can play around with this \n",
        "#https://pytorch.org/vision/stable/generated/torchvision.transforms.RandomRotation.html#torchvision.transforms.RandomRotation\n",
        "\n",
        "train_transforms = train_transforms = transforms.Compose([\n",
        "    transforms.Resize((8, 8)),\n",
        "    #transforms.RandomGrayscale(0.5),\n",
        "    #transforms.RandomAdjustSharpness(2, 0.5), # adjust sharpness by a factor of 2 with prob 0.5 of it being adjusted\n",
        "    transforms.RandomInvert(p=0.5),\n",
        "    transforms.RandomHorizontalFlip(p=0.5),\n",
        "    transforms.TrivialAugmentWide(num_magnitude_bins=31), # change intensity of image with max being 31 \n",
        "    transforms.ToTensor() # use ToTensor() last to get everything between 0 & 1\n",
        "])\n"
      ],
      "metadata": {
        "id": "6ui-B68wmPLv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_transforms = transforms.Compose([\n",
        "    transforms.Resize((8,8)),\n",
        "    transforms.ToTensor()\n",
        "])\n"
      ],
      "metadata": {
        "id": "ZGVAY9TwoVyd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_transformed_images(image_paths, transform, n=3, seed=42):\n",
        "    \"\"\"Plots a series of random images from image_paths.\n",
        "\n",
        "    Will open n image paths from image_paths, transform them\n",
        "    with transform and plot them side by side.\n",
        "\n",
        "    Args:\n",
        "        image_paths (list): List of target image paths. \n",
        "        transform (PyTorch Transforms): Transforms to apply to images.\n",
        "        n (int, optional): Number of images to plot. Defaults to 3.\n",
        "        seed (int, optional): Random seed for the random generator. Defaults to 42.\n",
        "    \"\"\"\n",
        "\n",
        "    random.seed(seed)\n",
        "    random_image_paths = random.sample(image_paths, k=n)\n",
        "    for image_path in random_image_paths:\n",
        "        with Image.open(image_path) as f:\n",
        "            fig, ax = plt.subplots(1, 2)\n",
        "            ax[0].imshow(f) \n",
        "            ax[0].set_title(f\"Original \\nSize: {f.size}\")\n",
        "            ax[0].axis(\"off\")\n",
        "\n",
        "            # Transform and plot image\n",
        "            # Note: permute() will change shape of image to suit matplotlib \n",
        "            # (PyTorch default is [C, H, W] but Matplotlib is [H, W, C])\n",
        "            transformed_image = transform(f).permute(1, 2, 0) \n",
        "            ax[1].imshow(transformed_image) \n",
        "            ax[1].set_title(f\"Transformed \\nSize: {transformed_image.shape}\")\n",
        "            ax[1].axis(\"off\")\n",
        "\n",
        "            fig.suptitle(f\"Class: {image_path.parent.stem}\", fontsize=16)\n"
      ],
      "metadata": {
        "id": "byzT0FZWqU-p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#this returns a posix path to every image in our training directory \n",
        "image_paths = list(Path(train_path).glob(\"*/*/*.jpg\"))\n",
        "\n",
        "plot_transformed_images(image_paths, \n",
        "                        transform=train_transforms, \n",
        "                        n=3)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 701
        },
        "id": "71NKTy_Nq0u7",
        "outputId": "ce23d2d0-d784-48b9-fb59-c0883f4cbb6b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from torchvision import datasets\n",
        "train_data_super_class = datasets.ImageFolder(root=train_path, transform=train_transforms)\n",
        "train_data_sub_class_dog = datasets.ImageFolder(root=train_path+'/dog', transform=train_transforms)\n",
        "train_data_sub_class_reptile = datasets.ImageFolder(root=train_path+'/reptile', transform=train_transforms)\n",
        "train_data_sub_class_bird = datasets.ImageFolder(root=train_path+'/bird', transform=train_transforms)\n",
        "\n",
        "# 2. Turn data into DataLoaders\n",
        "import os\n",
        "from torch.utils.data import DataLoader\n",
        "\n",
        "# Setup batch size and number of workers \n",
        "BATCH_SIZE = 32\n",
        "NUM_WORKERS = os.cpu_count()\n",
        "\n",
        "train_ds_super = DataLoader(train_data_super_class, \n",
        "                            batch_size=BATCH_SIZE, \n",
        "                            shuffle=True, \n",
        "                            num_workers=NUM_WORKERS)\n",
        "\n",
        "train_ds_sublcass_dog =DataLoader(train_data_sub_class_dog, \n",
        "                                  batch_size=BATCH_SIZE, \n",
        "                                  shuffle=True, \n",
        "                                  num_workers=NUM_WORKERS)\n",
        "\n",
        "\n",
        "train_ds_sublcass_bird =DataLoader(train_data_sub_class_bird, \n",
        "                                  batch_size=BATCH_SIZE, \n",
        "                                  shuffle=True, \n",
        "                                  num_workers=NUM_WORKERS)\n",
        "\n",
        "train_ds_sublcass_reptile =DataLoader(train_data_sub_class_reptile, \n",
        "                                  batch_size=BATCH_SIZE, \n",
        "                                  shuffle=True, \n",
        "                                  num_workers=NUM_WORKERS)\n"
      ],
      "metadata": {
        "id": "O_wDS85vrhgT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "img_batch, label_batch = next(iter(train_ds_sublcass_reptile))\n",
        "print(label_batch)"
      ],
      "metadata": {
        "id": "Y312m9MCsEI9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "XDDGHOUOmmIX"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}