AGEDB CNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "06aabb63",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:18.837059Z",
     "start_time": "2021-09-20T06:17:17.905060Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import torch\n",
    "import torchvision\n",
    "from torch import nn\n",
    "from PIL import Image\n",
    "from parse import parse\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from torchvision.transforms import ToTensor, Compose, Grayscale, Resize, CenterCrop\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cb64b0db",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:18.853062Z",
     "start_time": "2021-09-20T06:17:18.838063Z"
    }
   },
   "outputs": [],
   "source": [
    "# hyper params\n",
    "num_of_class = 102\n",
    "learning_rate = 1e-04\n",
    "batch_size = 256\n",
    "device = torch.device(\"cuda\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5ec9c1e6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:18.869060Z",
     "start_time": "2021-09-20T06:17:18.854061Z"
    }
   },
   "outputs": [],
   "source": [
    "class AgeDBDataset(Dataset):\n",
    "    def __init__(self, directory, transform, preload=False, device: torch.device = torch.device('cpu'), **kwargs):\n",
    "        self.device = device\n",
    "        self.directory = directory\n",
    "        self.transform = transform\n",
    "        self.labels = []\n",
    "        self.images = []\n",
    "        self.preload = preload\n",
    "\n",
    "        for i, file in enumerate(os.listdir(self.directory)):\n",
    "            file_labels = parse('{}_{}_{age}_{gender}.jpg', file)\n",
    "            \n",
    "            if file_labels is None:\n",
    "                continue\n",
    "                \n",
    "            if self.preload:\n",
    "                image = Image.open(os.path.join(self.directory, file)).convert('RGB')\n",
    "                if self.transform is not None:\n",
    "                    image = self.transform(image).to(self.device)\n",
    "            \n",
    "            else:\n",
    "                image = os.path.join(self.directory, file)\n",
    "                \n",
    "            \n",
    "            gender_to_class_id = {\n",
    "                'm': 0, \n",
    "                'f': 1\n",
    "            }\n",
    "            \n",
    "            gender = gender_to_class_id[file_labels['gender']]\n",
    "            age = int(file_labels['age'])\n",
    "            \n",
    "            self.images.append(image)\n",
    "            self.labels.append({\n",
    "                'age': age,\n",
    "                'gender': gender\n",
    "            })\n",
    "            \n",
    "        pass\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        if torch.is_tensor(idx):\n",
    "            idx = idx.tolist()\n",
    "\n",
    "        image = self.images[idx]\n",
    "\n",
    "        if not self.preload:\n",
    "            image = Image.open(image).convert('RGB')\n",
    "            if self.transform is not None:\n",
    "                image = self.transform(image).to(self.device)\n",
    "\n",
    "        labels = {\n",
    "            'age': self.labels[idx]['age'], \n",
    "            'gender': self.labels[idx]['gender'],\n",
    "        }\n",
    "        return image.to(self.device), labels\n",
    "    \n",
    "    def get_loaders(self, batch_size, train_size=0.7, test_size=0.2, **kwargs):\n",
    "        train_len = int(len(self) * train_size)\n",
    "        test_len = int(len(self) * test_size)\n",
    "        validate_len = len(self) - (train_len + test_len)\n",
    "        \n",
    "        self.trainDataset, self.validateDataset, self.testDataset = torch.utils.data.random_split(\n",
    "            dataset = self, \n",
    "            lengths = [train_len, validate_len, test_len], \n",
    "            generator = torch.Generator().manual_seed(42)\n",
    "        )\n",
    "\n",
    "        train_loader = DataLoader(self.trainDataset, batch_size=batch_size)\n",
    "        validate_loader = DataLoader(self.validateDataset, batch_size=batch_size)\n",
    "        test_loader = DataLoader(self.testDataset, batch_size=batch_size)\n",
    "\n",
    "        return train_loader, validate_loader, test_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6de83481",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:19.374059Z",
     "start_time": "2021-09-20T06:17:18.870061Z"
    }
   },
   "outputs": [],
   "source": [
    "dataset = AgeDBDataset(\n",
    "    directory = 'AgeDB/',\n",
    "    transform = Compose([\n",
    "        Resize(size=(64, 64)),\n",
    "        CenterCrop(size=64),\n",
    "        Grayscale(num_output_channels=1),\n",
    "        ToTensor(),\n",
    "    ]),\n",
    "    device = device,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "db16a8b9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:19.389060Z",
     "start_time": "2021-09-20T06:17:19.375062Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16488"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "64cc1bff",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:19.405059Z",
     "start_time": "2021-09-20T06:17:19.390062Z"
    }
   },
   "outputs": [],
   "source": [
    "train_set, validation_set, test_set = dataset.get_loaders(\n",
    "    batch_size=batch_size,\n",
    "    train_size=0.8,\n",
    "    test_size=0.2,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5641b0b5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:19.421060Z",
     "start_time": "2021-09-20T06:17:19.407059Z"
    },
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class AgeDBConvModel(nn.Module):\n",
    "    def __init__(self, num_of_classes):\n",
    "        super(AgeDBConvModel, self).__init__()\n",
    "        self.layer1 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=1, out_channels=32, kernel_size=3, stride=1, padding=2), #(64+2(2)-3)+1=66\n",
    "            nn.BatchNorm2d(num_features=32),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2) #((66-2)/2)+1 = 33\n",
    "        )\n",
    "        self.layer2 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=2), #(33+2(2)-3)+1=35\n",
    "            nn.BatchNorm2d(num_features=64),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2) #((35-2)/2)+1 = 17 + 0.5\n",
    "        )\n",
    "        self.layer3 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=2), #(17+2(2)-3)+1=19\n",
    "            nn.BatchNorm2d(num_features=128),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2) #((19-2)/2)+1 = 9 + 0.5\n",
    "        )\n",
    "        self.layer4 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=2), #(9+2(2)-3)+1=11\n",
    "            nn.BatchNorm2d(num_features=256),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2) #((11-2)/2)+1 = 5 + 0.5\n",
    "        )\n",
    "        self.layer5 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=1, padding=2), #(5+2(2)-3)+1=7\n",
    "            nn.BatchNorm2d(num_features=512),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2) #((7-2)/2)+1 = 3 + 0.5\n",
    "        )\n",
    "        self.fc = nn.Linear(3*3*512, num_of_classes)\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "        out = self.layer1(x)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.layer4(out)\n",
    "        out = self.layer5(out)\n",
    "\n",
    "        out = out.reshape(out.size(0), -1)\n",
    "        out = self.fc(out)\n",
    "        \n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6938c26a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:20.748059Z",
     "start_time": "2021-09-20T06:17:19.422061Z"
    }
   },
   "outputs": [],
   "source": [
    "convModel = AgeDBConvModel(num_of_class).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fed7d490",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:20.764059Z",
     "start_time": "2021-09-20T06:17:20.749061Z"
    }
   },
   "outputs": [],
   "source": [
    "# Training loop\n",
    "def train(model, optimizer, criterion, train_loader, num_of_epoch):\n",
    "    total_step = len(train_loader)\n",
    "    for epoch in range(num_of_epoch):\n",
    "        for i, (imgs, labels) in enumerate(train_loader):\n",
    "            imgs = imgs.to(device)\n",
    "            labels = torch.as_tensor(labels['age']).to(device)\n",
    "            \n",
    "            outputs = model(imgs)\n",
    "            loss = criterion(outputs, labels)\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            if (i+1)%total_step == 0:\n",
    "                print(f\"Epoch: {epoch+1}/{num_of_epoch}, Step: {i+1}/{total_step}, Loss: {loss.item()}\")\n",
    "\n",
    "# Evaluation\n",
    "def eval(model, test_loader):\n",
    "    with torch.no_grad():\n",
    "        correct = 0\n",
    "        total = 0\n",
    "        error = torch.zeros(0).to(device)\n",
    "        \n",
    "        for imgs, labels in test_loader:\n",
    "            imgs = imgs.to(device)\n",
    "            labels = torch.as_tensor(labels['age']).to(device)\n",
    "            outputs = model(imgs)\n",
    "            \n",
    "            _, pred = torch.max(outputs.data, 1)\n",
    "\n",
    "            error = torch.cat([error, torch.abs(\n",
    "                torch.subtract(torch.reshape(labels, (-1,)), torch.reshape(pred, (-1,)))\n",
    "            )])\n",
    "            \n",
    "            total += labels.size(0)\n",
    "            correct += (pred == labels).sum().item()\n",
    "            \n",
    "    print(f\"Accuracy: {(100*correct)/total}%\")\n",
    "    print(f\"Mean Absolute Error: {(torch.mean(error))}\")\n",
    "    print(f\"Minimum: {torch.min(error)}, Maximum: {torch.max(error)}, Median: {torch.median(error)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3ca9b2a2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:17:20.780059Z",
     "start_time": "2021-09-20T06:17:20.765059Z"
    }
   },
   "outputs": [],
   "source": [
    "criteria = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(convModel.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6ed4bb3e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:19:48.613421Z",
     "start_time": "2021-09-20T06:17:20.781061Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/10, Step: 52/52, Loss: 4.208644866943359\n",
      "Epoch: 2/10, Step: 52/52, Loss: 3.958613634109497\n",
      "Epoch: 3/10, Step: 52/52, Loss: 3.6929430961608887\n",
      "Epoch: 4/10, Step: 52/52, Loss: 3.3307101726531982\n",
      "Epoch: 5/10, Step: 52/52, Loss: 2.921128273010254\n",
      "Epoch: 6/10, Step: 52/52, Loss: 2.4748032093048096\n",
      "Epoch: 7/10, Step: 52/52, Loss: 2.039329767227173\n",
      "Epoch: 8/10, Step: 52/52, Loss: 1.6440496444702148\n",
      "Epoch: 9/10, Step: 52/52, Loss: 1.3424772024154663\n",
      "Epoch: 10/10, Step: 52/52, Loss: 1.1302732229232788\n"
     ]
    }
   ],
   "source": [
    "train(convModel, optimizer, criteria, train_set, num_of_epoch=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "10b735ef",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:19:52.828425Z",
     "start_time": "2021-09-20T06:19:48.614422Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 3.002729754322111%\n",
      "Mean Absolute Error: 12.138307571411133\n",
      "Minimum: 0.0, Maximum: 63.0, Median: 10.0\n"
     ]
    }
   ],
   "source": [
    "eval(convModel, test_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "96d5fe78",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T06:20:04.672424Z",
     "start_time": "2021-09-20T06:19:52.829425Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 64.11675511751326%\n",
      "Mean Absolute Error: 5.237679958343506\n",
      "Minimum: 0.0, Maximum: 63.0, Median: 0.0\n"
     ]
    }
   ],
   "source": [
    "eval(convModel, train_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f62df95c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}