CV_22 Faces Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.7"
    },
    "colab": {
      "name": "Copy of Gedeon_Pacific.ipynb",
      "private_outputs": true,
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Gedeon-m-gedus/Image_Processing/blob/master/CV_22%20Faces%20Classification.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zFD-yOpaLtYC"
      },
      "source": [
        "import os\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DsW7ZVlLROj6"
      },
      "source": [
        "import os\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "from torch.utils import data\n",
        "import torch\n",
        "import torchvision   \n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import natsort\n",
        "from torch.utils.data import Dataset, DataLoader\n",
        "import time"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gh3AFfjsVopO"
      },
      "source": [
        "!unzip \"/content/drive/MyDrive/idl-fall21-hw2p2s1-face-classification.zip\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hOcv-crDLtYD"
      },
      "source": [
        "from torchvision import transforms\n",
        "train_dataset = torchvision.datasets.ImageFolder(root='/content/train_data', \n",
        "                                                 transform=transforms.ToTensor())\n",
        "train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=256, \n",
        "                                               shuffle=True, num_workers=6,drop_last=True)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hSU7moJ3Xip1"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R7IEpj6JQqr8"
      },
      "source": [
        "\n",
        "val_dataset = torchvision.datasets.ImageFolder(root='/content/val_data', \n",
        "                                               transform=transforms.ToTensor())\n",
        "\n",
        "val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=256, \n",
        "                                             shuffle=True, num_workers=6)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p7EbT7VoQUja"
      },
      "source": [
        "testDataLoaderArguments = dict(shuffle = False, batch_size = 1, num_workers = 6)\n",
        "testDataLoader = data.DataLoader(dataset= os.listdir('/content/test_data/'), **testDataLoaderArguments)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C9LJEqlaMTUo"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "69zKnz46LtYE"
      },
      "source": [
        "# Models"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nt1TuGqcLtYP"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "\n",
        "class Block(nn.Module):\n",
        "    def __init__(self, num_layers, in_channels, out_channels, identity_downsample=None, stride=1):\n",
        "        assert num_layers in [18, 34, 50, 101, 152], \"should be a a valid architecture\"\n",
        "        super(Block, self).__init__()\n",
        "        self.num_layers = num_layers\n",
        "        if self.num_layers > 34:\n",
        "            self.expansion = 4\n",
        "        else:\n",
        "            self.expansion = 1\n",
        "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)\n",
        "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
        "        if self.num_layers > 34:\n",
        "            self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=stride, padding=1)\n",
        "        else:\n",
        "            self.conv2 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)\n",
        "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
        "        self.conv3 = nn.Conv2d(out_channels, out_channels * self.expansion, kernel_size=1, stride=1, padding=0)\n",
        "        self.bn3 = nn.BatchNorm2d(out_channels * self.expansion)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.identity_downsample = identity_downsample\n",
        "\n",
        "    def forward(self, x):\n",
        "        identity = x\n",
        "        if self.num_layers > 34:\n",
        "            x = self.conv1(x)\n",
        "            x = self.bn1(x)\n",
        "            x = self.relu(x)\n",
        "        x = self.conv2(x)\n",
        "        x = self.bn2(x)\n",
        "        x = self.relu(x)\n",
        "        x = self.conv3(x)\n",
        "        x = self.bn3(x)\n",
        "\n",
        "        if self.identity_downsample is not None:\n",
        "            identity = self.identity_downsample(identity)\n",
        "\n",
        "        x += identity\n",
        "        x = self.relu(x)\n",
        "        return x\n",
        "\n",
        "\n",
        "class ResNet(nn.Module):\n",
        "    def __init__(self, num_layers, block, image_channels, num_classes):\n",
        "        assert num_layers in [18, 34, 50, 101, 152], f'ResNet{num_layers}: Unknown architecture! Number of layers has ' \\\n",
        "                                                     f'to be 18, 34, 50, 101, or 152 '\n",
        "        super(ResNet, self).__init__()\n",
        "        if num_layers < 50:\n",
        "            self.expansion = 1\n",
        "        else:\n",
        "            self.expansion = 4\n",
        "        if num_layers == 18:\n",
        "            layers = [2, 2, 2, 2]\n",
        "        elif num_layers == 34 or num_layers == 50:\n",
        "            layers = [3, 4, 6, 3]\n",
        "        elif num_layers == 101:\n",
        "            layers = [3, 4, 23, 3]\n",
        "        else:\n",
        "            layers = [3, 8, 36, 3]\n",
        "        self.in_channels = 64\n",
        "        self.conv1 = nn.Conv2d(image_channels, 64, kernel_size=7, stride=2, padding=3)\n",
        "        self.bn1 = nn.BatchNorm2d(64)\n",
        "        self.relu = nn.ReLU()\n",
        "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n",
        "\n",
        "        # ResNetLayers\n",
        "        self.layer1 = self.make_layers(num_layers, block, layers[0], intermediate_channels=64, stride=1)\n",
        "        self.layer2 = self.make_layers(num_layers, block, layers[1], intermediate_channels=128, stride=2)\n",
        "        self.layer3 = self.make_layers(num_layers, block, layers[2], intermediate_channels=256, stride=2)\n",
        "        self.layer4 = self.make_layers(num_layers, block, layers[3], intermediate_channels=512, stride=2)\n",
        "\n",
        "        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n",
        "        self.fc = nn.Linear(512 * self.expansion, num_classes)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.relu(x)\n",
        "        x = self.maxpool(x)\n",
        "\n",
        "        x = self.layer1(x)\n",
        "        x = self.layer2(x)\n",
        "        x = self.layer3(x)\n",
        "        x = self.layer4(x)\n",
        "\n",
        "        x = self.avgpool(x)\n",
        "        x = x.reshape(x.shape[0], -1)\n",
        "        x = self.fc(x)\n",
        "        return x\n",
        "\n",
        "    def make_layers(self, num_layers, block, num_residual_blocks, intermediate_channels, stride):\n",
        "        layers = []\n",
        "\n",
        "        identity_downsample = nn.Sequential(nn.Conv2d(self.in_channels, intermediate_channels*self.expansion, kernel_size=1, stride=stride),\n",
        "                                            nn.BatchNorm2d(intermediate_channels*self.expansion))\n",
        "        layers.append(block(num_layers, self.in_channels, intermediate_channels, identity_downsample, stride))\n",
        "        self.in_channels = intermediate_channels * self.expansion # 256\n",
        "        for i in range(num_residual_blocks - 1):\n",
        "            layers.append(block(num_layers, self.in_channels, intermediate_channels)) # 256 -> 64, 64*4 (256) again\n",
        "        return nn.Sequential(*layers)\n",
        "    \n",
        "\n",
        "def createModel(name='R18'):\n",
        "    img_channels = 3\n",
        "    num_classes = 4000\n",
        "    if name == 'R18': return ResNet(18, Block, img_channels, num_classes)\n",
        "    elif name == 'R34': return ResNet(34, Block, img_channels, num_classes)\n",
        "    elif name == 'R50': return ResNet(50, Block, img_channels, num_classes)\n",
        "    elif name == 'R101': return ResNet(101, Block, img_channels, num_classes)\n",
        "    elif name == 'R152': return ResNet(152, Block, img_channels, num_classes)\n",
        "    else: return None\n",
        "    \n",
        "def testModel():\n",
        "    models = ['R18', 'R34', 'R50', 'R101', 'R154']\n",
        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "    for model_name in models:\n",
        "        print('Testing', model_name)\n",
        "        model = createModel(name='R18')\n",
        "        y = model(torch.randn(4, 3, 64, 64)).to(device)\n",
        "        print(y.size())\n",
        "\n",
        "testModel()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zBg7Z6N1LtYT"
      },
      "source": [
        "model = createModel(name='R18')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fiYU7w2vLtYT"
      },
      "source": [
        "# Optimzers and training loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JoXtZacLtYU"
      },
      "source": [
        "import torch.optim as optim\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)\n",
        "\n",
        "n_epochs = 3\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = model.to(device)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r7-KfQiVLtYU"
      },
      "source": [
        "for epoch in range(n_epochs):  # loop over the dataset multiple times\n",
        "\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(train_dataloader, 0):\n",
        "        # get the inputs; data is a list of [inputs, labels]\n",
        "        inputs, labels = data\n",
        "        inputs = inputs.to(device)\n",
        "        labels = labels.to(device)\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "        #print(inputs.shape)\n",
        "\n",
        "        # forward + backward + optimize\n",
        "        outputs = model(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # print statistics\n",
        "        running_loss += loss.item()\n",
        "        if i % 10 == 0:\n",
        "            print('[%d, %5d] loss: %.3f' %\n",
        "                  (epoch + 1, i + 1, running_loss / 10))\n",
        "            running_loss = 0.0\n",
        "\n",
        "print('Finished Training')\n",
        "PATH = './model_chckpoint.pth'\n",
        "torch.save(model.state_dict(), PATH)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PAlXNT8-LtYV"
      },
      "source": [
        "# Testing and Inference"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wZjubuzsLtYV"
      },
      "source": [
        "import pandas as pd\n",
        "def inference(model, dataloader_test):    \n",
        "    model.eval()\n",
        "    results = []\n",
        "    transform = transforms.ToTensor()\n",
        "    print('Inferencing ...')\n",
        "    for ims in dataloader_test:\n",
        "        img = Image.open('/content/test_data/'+ims[0])\n",
        "        input = transform(img)\n",
        "        input = input.view(-1, 3,64,64).to(device)\n",
        "        model.eval()\n",
        "        output = model(input)\n",
        "        _, preds = output.topk(1, 1, True, True)\n",
        "        preds = preds.cpu().detach().numpy()\n",
        "        results.append({'id':ims[0], 'label':preds[0][0]})\n",
        "    df = pd.DataFrame(results, columns=['id', 'label'])\n",
        "    df.to_csv('sub.csv', index=False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aYDmo8FdesHH"
      },
      "source": [
        "inference(model, testDataLoader)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ialo_WNBf7rR"
      },
      "source": [
        "pd.read_csv('sub.csv')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ECghUkkAnx38"
      },
      "source": [
        "model.load_state_dict(best_model_wts)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-FLcVLuGoZE1"
      },
      "source": [
        "# mdl = createModel(name='R18')\n",
        "# mdl.load_state_dict('model_chckpoint.pth')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ov2LKDAbon3l"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}