small_dataset_project.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "small_dataset project.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nxf-emma/APS360-Artificial-Intelligence-Fundamentals/blob/main/small_dataset_project.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": "ihbRrhOPrlrl"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np\n",
        "import os\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pyplot as plt\n",
        "import torch.optim as optim\n",
        "import torchvision\n",
        "from torchvision import datasets, models, transforms\n",
        "from torch.utils.data.sampler import SubsetRandomSampler\n",
        "from torch.utils.data import TensorDataset as Dataset"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KjdXATOhfKX8",
        "outputId": "7b7ccfae-137b-4bff-a448-e5bf86a4bbe4"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Composes several transforms together.\n",
        "\n",
        "data_transform = transforms.Compose(\n",
        "    [\n",
        "        \n",
        "        #convert image to grayscale\n",
        "        transforms.Grayscale(num_output_channels=3),\n",
        "        #randomly adding brightness \n",
        "        transforms.ColorJitter(brightness=(1,1.2)),\n",
        "        #apply ramdom rotation from -30 to 30 degrees\n",
        "        transforms.RandomRotation(30),\n",
        "        #apply random horizontal flip with probability of 50% \n",
        "        transforms.RandomHorizontalFlip(p=0.5),\n",
        "        transforms.ToTensor(),\n",
        "        #normalize the data with 0.5 mean and variance.\n",
        "        transforms.Normalize((0.5073955,), (0.25,), inplace=True)\n",
        "       \n",
        "    ])\n",
        "\n",
        "#data_transform = transforms.ToTensor()\n",
        "\n",
        "\n",
        "parent_path = '/content/drive/MyDrive/APS360 Team/aps360_dataset/small-dataset/'\n",
        "\n",
        "training_set = torchvision.datasets.ImageFolder(parent_path+'train',data_transform)\n",
        "valid_set = torchvision.datasets.ImageFolder(parent_path+'valid',data_transform)\n",
        "test_set = torchvision.datasets.ImageFolder(parent_path+'test',data_transform)\n",
        "\n",
        "\n",
        "'''\n",
        "batch_size = 400\n",
        "# two sub processes used for data loading\n",
        "num_workers = 1\n",
        "\n",
        "#get data loader\n",
        "train_loader = torch.utils.data.DataLoader(training_set,batch_size = batch_size ,num_workers = num_workers,shuffle = True)\n",
        "valid_loader = torch.utils.data.DataLoader(valid_set,batch_size = batch_size ,num_workers = num_workers,shuffle = True)\n",
        "test_loader = torch.utils.data.DataLoader(test_set,batch_size = batch_size,num_workers = num_workers,shuffle = True)\n",
        "'''"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "1UGwqUeCjmd1",
        "outputId": "d74b6789-1c12-4486-e0a3-bc146752ee5f"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\nbatch_size = 400\\n# two sub processes used for data loading\\nnum_workers = 1\\n\\n#get data loader\\ntrain_loader = torch.utils.data.DataLoader(training_set,batch_size = batch_size ,num_workers = num_workers,shuffle = True)\\nvalid_loader = torch.utils.data.DataLoader(valid_set,batch_size = batch_size ,num_workers = num_workers,shuffle = True)\\ntest_loader = torch.utils.data.DataLoader(test_set,batch_size = batch_size,num_workers = num_workers,shuffle = True)\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "class small_dataset(Dataset):\n",
        "\n",
        "    def __init__(self, data, transform):\n",
        "        self.data = data\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data.shape[0])\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        item = self.data[idx]\n",
        "        item = self.transform(item)\n",
        "        return item\n",
        "'''\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "id": "U7xMiFHenlXD",
        "outputId": "64a1ee77-7eb0-4f60-c2ca-164cf91acd48"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'\\nclass small_dataset(Dataset):\\n\\n    def __init__(self, data, transform):\\n        self.data = data\\n        self.transform = transform\\n\\n    def __len__(self):\\n        return len(self.data.shape[0])\\n\\n    def __getitem__(self, idx):\\n        item = self.data[idx]\\n        item = self.transform(item)\\n        return item\\n'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "img_size = 48 "
      ],
      "metadata": {
        "id": "CW1MxNmaBNS3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Convolutional Neural Network Architecture\n",
        "class CNN(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(CNN, self).__init__()\n",
        "\n",
        "        self.pool = nn.MaxPool2d(2, 2) #kernel_size, stride \n",
        "        self.conv1 = nn.Conv2d(3, 5, 3, padding = 2) #in_channels, out_chanels, kernel_size\n",
        "        self.conv2 = nn.Conv2d(5, 25, 3) #in_channels, out_chanels, kernel_size\n",
        "        self.conv3 = nn.Conv2d(25, 50, 3)\n",
        "        self.conv4 = nn.Conv2d(50, 100, 3)\n",
        "      \n",
        "        self.dropout=nn.Dropout(0.3)\n",
        "        self.fc1 = nn.Linear(100*1*1, 32) #chanels*dimension\n",
        "        self.fc2 = nn.Linear(32, 7) #last output channel always = 7\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        # 25x25\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        # 11x11\n",
        "        x = self.pool(F.relu(self.conv3(x)))\n",
        "        # 4x4\n",
        "        x = self.pool(F.relu(self.conv4(x)))\n",
        "        # 1x1\n",
        "      \n",
        "        x = x.view(-1, 100*1*1)\n",
        "\n",
        "        x=F.relu(self.dropout(self.fc1(x)))\n",
        "        x=F.relu(self.dropout(self.fc2(x)))\n",
        "        '''\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        '''\n",
        "        x = x.squeeze(1)\n",
        "        \n",
        "        return x"
      ],
      "metadata": {
        "id": "U4pkyLBiApwZ"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_accuracy(model, dataloader):\n",
        "    \n",
        "\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for imgs, labels in dataloader:\n",
        "        \n",
        "        if use_cuda and torch.cuda.is_available():\n",
        "            imgs = imgs.cuda()\n",
        "            labels = labels.cuda()\n",
        "\n",
        "        output = model(imgs)\n",
        "        \n",
        "        #select index with maximum prediction score\n",
        "        pred = output.max(1, keepdim=True)[1]\n",
        "        correct += pred.eq(labels.view_as(pred)).sum().item()\n",
        "        total += imgs.shape[0]\n",
        "    return correct / total"
      ],
      "metadata": {
        "id": "CX0EUse3A1nB"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train(model, train_data, val_data, batch_size=32, num_epochs=200, lr = 0.1):\n",
        "    num_workers = 1\n",
        "    train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, \n",
        "                                           num_workers=num_workers, shuffle=True)\n",
        "    val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size, \n",
        "                                          num_workers=num_workers, shuffle=True)\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.Adam(model.parameters(), lr=lr)\n",
        "\n",
        "    iters, losses, train_acc, val_acc = [], [], [], []\n",
        "    '''\n",
        "    #we plot of images for verification\n",
        "    data_iter = iter(train_loader)\n",
        "    images, labels = data_iter.next()\n",
        "    images = images.numpy()\n",
        "    classes = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']\n",
        "\n",
        "    fig = plt.figure(figsize=(25, 4))\n",
        "    for idx in np.arange(20):\n",
        "        ax = fig.add_subplot(2, 20/2, idx+1, xticks=[], yticks=[])\n",
        "        img = np.transpose(images[idx], (1, 2, 0))\n",
        "        #to disable the clip warning when ploting\n",
        "        img = img/np.amax(img)\n",
        "        img = np.clip(img, 0, 1)\n",
        "        plt.imshow(img)\n",
        "        ax.set_title(classes[labels[idx]])\n",
        "    '''\n",
        "    # training\n",
        "    n = 0 # the number of iterations\n",
        "    for epoch in range(num_epochs):\n",
        "        for imgs, labels in iter(train_loader):\n",
        "\n",
        "            if use_cuda and torch.cuda.is_available():\n",
        "                imgs = imgs.cuda()\n",
        "                labels = labels.cuda()\n",
        "\n",
        "            out = model(imgs)             # forward pass\n",
        "\n",
        "            loss = criterion(out, labels) # compute the total loss\n",
        "            loss.backward()               # backward pass (compute parameter updates)\n",
        "            optimizer.step()              # make the updates for each parameter\n",
        "            optimizer.zero_grad()         # a clean up step for PyTorch\n",
        "            n += 1\n",
        "\n",
        "        # save the current training information\n",
        "        iters.append(n)\n",
        "        losses.append(float(loss)/batch_size)             # compute *average* loss\n",
        "        train_acc.append(get_accuracy(model, train_loader)) # compute training accuracy \n",
        "        val_acc.append(get_accuracy(model, val_loader))  # compute validation accuracy\n",
        "            \n",
        "        #print each epoch acc \n",
        "        print(\"epoch:\", epoch, \"acc = \", train_acc[epoch])\n",
        "\n",
        "            \n",
        "\n",
        "    # plotting\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, losses, label=\"Train\")\n",
        "    plt.xlabel(\"Iterations\")\n",
        "    plt.ylabel(\"Loss\")\n",
        "    plt.show()\n",
        "\n",
        "    plt.title(\"Training Curve\")\n",
        "    plt.plot(iters, train_acc, label=\"Train\")\n",
        "    plt.plot(iters, val_acc, label=\"Validation\")\n",
        "    plt.xlabel(\"Iterations\")\n",
        "    plt.ylabel(\"Training Accuracy\")\n",
        "    plt.legend(loc='best')\n",
        "    plt.show()\n",
        "\n",
        "    print(\"Final Training Accuracy: {}\".format(train_acc[-1]))\n",
        "    print(\"Final Validation Accuracy: {}\".format(val_acc[-1]))\n"
      ],
      "metadata": {
        "id": "PWPxMA3gA2Gi"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''\n",
        "train_path = '/content/gdrive/My Drive/aps360/train/'\n",
        "val_path = '/content/gdrive/My Drive/aps360/val/'\n",
        "test_path = '/content/gdrive/My Drive/aps360/test/'\n",
        "\n",
        "train_data = datasets.DatasetFolder(training_set, loader=torch.load, extensions=('.tensor'))\n",
        "val_data = datasets.DatasetFolder(valid_set, loader=torch.load, extensions=('.tensor'))\n",
        "test_data = datasets.DatasetFolder(test_set, loader=torch.load, extensions=('.tensor'))\n",
        "'''"
      ],
      "metadata": {
        "id": "8TP_4QGdEdVr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "d3996c81-acd4-4081-9319-119a66036b65"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"\\ntrain_path = '/content/gdrive/My Drive/aps360/train/'\\nval_path = '/content/gdrive/My Drive/aps360/val/'\\ntest_path = '/content/gdrive/My Drive/aps360/test/'\\n\\ntrain_data = datasets.DatasetFolder(training_set, loader=torch.load, extensions=('.tensor'))\\nval_data = datasets.DatasetFolder(valid_set, loader=torch.load, extensions=('.tensor'))\\ntest_data = datasets.DatasetFolder(test_set, loader=torch.load, extensions=('.tensor'))\\n\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\n",
        "#train\n",
        "model = CNN()\n",
        "use_cuda = True\n",
        "model.cuda()\n",
        "\n",
        "'''\n",
        "training_set = '/content/drive/MyDrive/APS360 Team/aps360_dataset/small-dataset/train'\n",
        "valid_set = '/content/drive/MyDrive/APS360 Team/aps360_dataset/small-dataset/valid'\n",
        "#small_training_set = small_dataset(training_set,data_transform)\n",
        "#small_valid_set = small_dataset(valid_set,data_transform)\n",
        "'''\n",
        "train(model,training_set,valid_set)"
      ],
      "metadata": {
        "id": "uQ_udpVWA72X",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 781
        },
        "outputId": "31955a30-8bae-4538-f792-1c5cbe1603ef"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "epoch: 0 acc =  0.15714285714285714\n",
            "epoch: 1 acc =  0.14285714285714285\n",
            "epoch: 2 acc =  0.11428571428571428\n",
            "epoch: 3 acc =  0.14285714285714285\n",
            "epoch: 4 acc =  0.14285714285714285\n",
            "epoch: 5 acc =  0.14285714285714285\n",
            "epoch: 6 acc =  0.14285714285714285\n",
            "epoch: 7 acc =  0.14285714285714285\n",
            "epoch: 8 acc =  0.14285714285714285\n",
            "epoch: 9 acc =  0.14285714285714285\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Final Training Accuracy: 0.14285714285714285\n",
            "Final Validation Accuracy: 0.14285714285714285\n"
          ]
        }
      ]
    }
  ]
}