CDCN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "06aabb63",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:04:42.112721Z",
     "start_time": "2021-09-20T22:04:39.865723Z"
    },
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from torch import nn\n",
    "import pretrainedmodels\n",
    "\n",
    "from utils.train import train\n",
    "from utils.evaluation import evaluation\n",
    "from utils.loader import get_loader, get_image_list\n",
    "from utils.losses import CostSensitiveRegularizedLoss\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
    "warnings.filterwarnings(\"ignore\", category=DeprecationWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cb64b0db",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:04:42.127719Z",
     "start_time": "2021-09-20T22:04:42.113721Z"
    }
   },
   "outputs": [],
   "source": [
    "# hyper params\n",
    "num_of_class = 102\n",
    "learning_rate = 1e-03\n",
    "batch_size = 64\n",
    "input_size = 64\n",
    "device = torch.device(\"cuda\")\n",
    "test_size = 0.2\n",
    "train_size = 0.7\n",
    "val_size = 0.1\n",
    "directoryAgeDB = 'AgeDB/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6d920459",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:04:42.143719Z",
     "start_time": "2021-09-20T22:04:42.128720Z"
    },
    "code_folding": [],
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "def findAge(image_list):\n",
    "    listofzeros = [0] * 102\n",
    "    same_age = [i for i in range(0, 102)]\n",
    "    age_number = dict(zip(same_age, listofzeros))\n",
    "    sum = 0\n",
    "\n",
    "    for i in range(len(image_list)):\n",
    "\n",
    "        if image_list[i]['age'] in age_number:\n",
    "            age_number[image_list[i]['age']] += 1\n",
    "            sum += 1\n",
    "\n",
    "    print(sum)\n",
    "    return dict(age_number)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f8ae2b44",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:05:03.714686Z",
     "start_time": "2021-09-20T22:04:42.144721Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6c1058fe3bbb42ed8cacd87b503903d7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/11541 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Set Length:  34623\n",
      "Test Set Length:  3298\n",
      "Validation Set Length:  1649\n",
      "Total:  39570\n"
     ]
    }
   ],
   "source": [
    "train_image_list, test_image_list, validate_image_list = get_image_list(\n",
    "    train_size=train_size, \n",
    "    test_size=test_size, \n",
    "    val_size=val_size, \n",
    "    directory=directoryAgeDB,\n",
    ")\n",
    "\n",
    "train_loader, test_loader, validation_loader = get_loader(\n",
    "    input_size=input_size,\n",
    "    train_image_list=train_image_list,\n",
    "    test_image_list=test_image_list, \n",
    "    validate_image_list=validate_image_list, \n",
    "    batch_size=batch_size,\n",
    "    train_augment=3,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5641b0b5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:05:03.746683Z",
     "start_time": "2021-09-20T22:05:03.715686Z"
    },
    "code_folding": [
     21,
     44,
     62,
     163
    ]
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import torch.utils.model_zoo as model_zoo\n",
    "from torch import nn\n",
    "from torch.nn import Parameter\n",
    "import pdb\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "########################   Centeral-difference (second order, with 9 parameters and a const theta for 3x3 kernel) 2D Convolution   ##############################\n",
    "## | a1 a2 a3 |   | w1 w2 w3 |\n",
    "## | a4 a5 a6 | * | w4 w5 w6 | --> output = \\sum_{i=1}^{9}(ai * wi) - \\sum_{i=1}^{9}wi * a5 --> Conv2d (k=3) - Conv2d (k=1)\n",
    "## | a7 a8 a9 |   | w7 w8 w9 |\n",
    "##\n",
    "##   --> output = \n",
    "## | a1 a2 a3 |   |  w1  w2  w3 |     \n",
    "## | a4 a5 a6 | * |  w4  w5  w6 |  -  | a | * | w\\_sum |     (kernel_size=1x1, padding=0)\n",
    "## | a7 a8 a9 |   |  w7  w8  w9 |     \n",
    "\n",
    "class Conv2d_cd(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1,\n",
    "                 padding=1, dilation=1, groups=1, bias=False, theta=0.7):\n",
    "\n",
    "        super(Conv2d_cd, self).__init__() \n",
    "        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=bias)\n",
    "        self.theta = theta\n",
    "\n",
    "    def forward(self, x):\n",
    "        out_normal = self.conv(x)\n",
    "\n",
    "        if math.fabs(self.theta - 0.0) < 1e-8:\n",
    "            return out_normal \n",
    "        else:\n",
    "            #pdb.set_trace()\n",
    "            [C_out,C_in, kernel_size,kernel_size] = self.conv.weight.shape\n",
    "            kernel_diff = self.conv.weight.sum(2).sum(2)\n",
    "            kernel_diff = kernel_diff[:, :, None, None]\n",
    "            out_diff = F.conv2d(input=x, weight=kernel_diff, bias=self.conv.bias, stride=self.conv.stride, padding=0, groups=self.conv.groups)\n",
    "\n",
    "            return out_normal - self.theta * out_diff\n",
    "\n",
    "\n",
    "class SpatialAttention(nn.Module):\n",
    "    def __init__(self, kernel = 3):\n",
    "        super(SpatialAttention, self).__init__()\n",
    "\n",
    "\n",
    "        self.conv1 = nn.Conv2d(2, 1, kernel_size=kernel, padding=kernel//2, bias=False)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        avg_out = torch.mean(x, dim=1, keepdim=True)\n",
    "        max_out, _ = torch.max(x, dim=1, keepdim=True)\n",
    "        x = torch.cat([avg_out, max_out], dim=1)\n",
    "        x = self.conv1(x)\n",
    "        \n",
    "        return self.sigmoid(x)\n",
    "\n",
    "\n",
    "\n",
    "class CDCN(nn.Module):\n",
    "\n",
    "    def __init__(self, basic_conv=Conv2d_cd, theta=0.7):   \n",
    "        super(CDCN, self).__init__()\n",
    "        \n",
    "        \n",
    "        self.conv1 = nn.Sequential(\n",
    "            basic_conv(3, 64, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(),    \n",
    "        )\n",
    "        \n",
    "        self.Block1 = nn.Sequential(\n",
    "            basic_conv(64, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),   \n",
    "            basic_conv(128, 196, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(196),\n",
    "            nn.ReLU(),  \n",
    "            basic_conv(196, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),   \n",
    "            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),\n",
    "            \n",
    "        )\n",
    "        \n",
    "        self.Block2 = nn.Sequential(\n",
    "            basic_conv(128, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),   \n",
    "            basic_conv(128, 196, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(196),\n",
    "            nn.ReLU(),  \n",
    "            basic_conv(196, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),  \n",
    "            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),\n",
    "        )\n",
    "        \n",
    "        self.Block3 = nn.Sequential(\n",
    "            basic_conv(128, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),   \n",
    "            basic_conv(128, 196, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(196),\n",
    "            nn.ReLU(),  \n",
    "            basic_conv(196, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),   \n",
    "            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),\n",
    "        )\n",
    "        \n",
    "        self.lastconv1 = nn.Sequential(\n",
    "            basic_conv(128*3, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),    \n",
    "        )\n",
    "        \n",
    "        self.lastconv2 = nn.Sequential(\n",
    "            basic_conv(128, 64, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(),    \n",
    "        )\n",
    "        \n",
    "        self.lastconv3 = nn.Sequential(\n",
    "            basic_conv(64, 1, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.ReLU(),    \n",
    "        )\n",
    "        \n",
    "        \n",
    "        self.downsample32x32 = nn.Upsample(size=(32, 32), mode='bilinear')\n",
    "\n",
    " \n",
    "    def forward(self, x):\t    \t# x [3, 256, 256]\n",
    "        \n",
    "        x_input = x\n",
    "        x = self.conv1(x)\t\t   \n",
    "        \n",
    "        x_Block1 = self.Block1(x)\t    \t    \t# x [128, 128, 128]\n",
    "        x_Block1_32x32 = self.downsample32x32(x_Block1)   # x [128, 32, 32]  \n",
    "        \n",
    "        x_Block2 = self.Block2(x_Block1)\t    # x [128, 64, 64]\t  \n",
    "        x_Block2_32x32 = self.downsample32x32(x_Block2)   # x [128, 32, 32]  \n",
    "        \n",
    "        x_Block3 = self.Block3(x_Block2)\t    # x [128, 32, 32]  \t\n",
    "        x_Block3_32x32 = self.downsample32x32(x_Block3)   # x [128, 32, 32]  \n",
    "        \n",
    "        x_concat = torch.cat((x_Block1_32x32,x_Block2_32x32,x_Block3_32x32), dim=1)    # x [128*3, 32, 32]  \n",
    "        \n",
    "        #pdb.set_trace()\n",
    "        \n",
    "        x = self.lastconv1(x_concat)    # x [128, 32, 32] \n",
    "        x = self.lastconv2(x)    # x [64, 32, 32] \n",
    "        x = self.lastconv3(x)    # x [1, 32, 32] \n",
    "        \n",
    "        map_x = x.squeeze(1)\n",
    "        \n",
    "        return map_x, x_concat, x_Block1, x_Block2, x_Block3, x_input\n",
    "\n",
    "\t\t\n",
    "\n",
    "class CDCNpp(nn.Module):\n",
    "\n",
    "    def __init__(self, basic_conv=Conv2d_cd, theta=0.0):   \n",
    "        super(CDCNpp, self).__init__()\n",
    "        \n",
    "        \n",
    "        self.conv1 = nn.Sequential(\n",
    "            basic_conv(3, 64, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(64),\n",
    "            nn.ReLU(),    \n",
    "            \n",
    "        )\n",
    "        \n",
    "        self.Block1 = nn.Sequential(\n",
    "            basic_conv(64, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),  \n",
    "            \n",
    "            basic_conv(128, int(128*1.6), kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(int(128*1.6)),\n",
    "            nn.ReLU(),  \n",
    "            basic_conv(int(128*1.6), 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(), \n",
    "            \n",
    "            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),\n",
    "            \n",
    "        )\n",
    "        \n",
    "        self.Block2 = nn.Sequential(\n",
    "            basic_conv(128, int(128*1.2), kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(int(128*1.2)),\n",
    "            nn.ReLU(),  \n",
    "            basic_conv(int(128*1.2), 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),  \n",
    "            basic_conv(128, int(128*1.4), kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(int(128*1.4)),\n",
    "            nn.ReLU(),  \n",
    "            basic_conv(int(128*1.4), 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),  \n",
    "            \n",
    "            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),\n",
    "        )\n",
    "        \n",
    "        self.Block3 = nn.Sequential(\n",
    "            basic_conv(128, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(), \n",
    "            basic_conv(128, int(128*1.2), kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(int(128*1.2)),\n",
    "            nn.ReLU(),  \n",
    "            basic_conv(int(128*1.2), 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(), \n",
    "            nn.MaxPool2d(kernel_size=3, stride=2, padding=1),\n",
    "        )\n",
    "        \n",
    "        # Original\n",
    "        \n",
    "        self.lastconv1 = nn.Sequential(\n",
    "            basic_conv(128*3, 128, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.BatchNorm2d(128),\n",
    "            nn.ReLU(),\n",
    "            basic_conv(128, 1, kernel_size=3, stride=1, padding=1, bias=False, theta= theta),\n",
    "            nn.ReLU(),    \n",
    "        )\n",
    "        \n",
    "      \n",
    "        self.sa1 = SpatialAttention(kernel = 7)\n",
    "        self.sa2 = SpatialAttention(kernel = 5)\n",
    "        self.sa3 = SpatialAttention(kernel = 3)\n",
    "        self.downsample32x32 = nn.Upsample(size=(32, 32), mode='bilinear')\n",
    "\n",
    "        self.fc = nn.Linear(1024, 102)\n",
    "            \n",
    "    def forward(self, x):\n",
    "        \n",
    "        x_input = x\n",
    "        x = self.conv1(x)   \n",
    "        \n",
    "        x_Block1 = self.Block1(x)\n",
    "        attention1 = self.sa1(x_Block1)\n",
    "        x_Block1_SA = attention1 * x_Block1\n",
    "        x_Block1_32x32 = self.downsample32x32(x_Block1_SA)   \n",
    "        \n",
    "        x_Block2 = self.Block2(x_Block1)    \n",
    "        attention2 = self.sa2(x_Block2)  \n",
    "        x_Block2_SA = attention2 * x_Block2\n",
    "        x_Block2_32x32 = self.downsample32x32(x_Block2_SA)  \n",
    "        \n",
    "        x_Block3 = self.Block3(x_Block2)    \n",
    "        attention3 = self.sa3(x_Block3)  \n",
    "        x_Block3_SA = attention3 * x_Block3\n",
    "        x_Block3_32x32 = self.downsample32x32(x_Block3_SA)   \n",
    "        \n",
    "        x_concat = torch.cat((x_Block1_32x32,x_Block2_32x32,x_Block3_32x32), dim=1)    \n",
    "        \n",
    "        #pdb.set_trace()\n",
    "        map_x = self.lastconv1(x_concat)\n",
    "    \n",
    "        map_x = map_x.reshape(map_x.size(0), -1)\n",
    "\n",
    "        map_x = self.fc(map_x)\n",
    "        map_x = map_x.squeeze(1)\n",
    "        return map_x\n",
    "\t\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d5e10e0b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:05:05.296684Z",
     "start_time": "2021-09-20T22:05:03.747684Z"
    }
   },
   "outputs": [],
   "source": [
    "model1 = CDCNpp().to(device)\n",
    "model2 = CDCNpp().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3ca9b2a2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:05:05.312685Z",
     "start_time": "2021-09-20T22:05:05.298685Z"
    }
   },
   "outputs": [],
   "source": [
    "criteria = CostSensitiveRegularizedLoss(n_classes=num_of_class, base_loss='focal_loss', reduction='mean') \n",
    "optimizer = torch.optim.SGD(model1.parameters(), lr=learning_rate, momentum=0.9, nesterov=True, weight_decay=1e-1)\n",
    "model_name = 'cdcn_aug.pth'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6ed4bb3e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:26:40.645683Z",
     "start_time": "2021-09-20T22:05:05.314686Z"
    },
    "hide_input": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1/10, Train Loss: 2.461692417395093,  Validation Loss: 2.2477692549045267\n",
      "Validation Loss Decreased(inf ---> 2.2477692549045267)\n",
      "Epoch: 2/10, Train Loss: 2.1529353541940064,  Validation Loss: 2.0930329331984887\n",
      "Validation Loss Decreased(2.2477692549045267 ---> 2.0930329331984887)\n",
      "Epoch: 3/10, Train Loss: 2.0465210577035786,  Validation Loss: 2.053894652770116\n",
      "Validation Loss Decreased(2.0930329331984887 ---> 2.053894652770116)\n",
      "Epoch: 4/10, Train Loss: 1.9945661801287076,  Validation Loss: 2.007474509569315\n",
      "Validation Loss Decreased(2.053894652770116 ---> 2.007474509569315)\n",
      "Epoch: 5/10, Train Loss: 1.9620075117858633,  Validation Loss: 2.0246601013036876\n",
      "Epoch: 6/10, Train Loss: 1.9380603076790266,  Validation Loss: 1.9893609606302702\n",
      "Validation Loss Decreased(2.007474509569315 ---> 1.9893609606302702)\n",
      "Epoch: 7/10, Train Loss: 1.9234336738004703,  Validation Loss: 1.9467763625658476\n",
      "Validation Loss Decreased(1.9893609606302702 ---> 1.9467763625658476)\n",
      "Epoch: 8/10, Train Loss: 1.9142306683905244,  Validation Loss: 1.9569998979568481\n",
      "Epoch: 9/10, Train Loss: 1.9000731281343979,  Validation Loss: 1.9772299528121948\n",
      "Epoch: 10/10, Train Loss: 1.8877466853136495,  Validation Loss: 1.9349227822743928\n",
      "Validation Loss Decreased(1.9467763625658476 ---> 1.9349227822743928)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train(model1, optimizer, criteria, train_loader, validation_loader, num_of_epoch=10, model_name=model_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "10b735ef",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:27:38.748683Z",
     "start_time": "2021-09-20T22:26:40.646685Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Error: 7.956155586242676\n",
      "Minimum: 0.0, Maximum: 64.0, Median: 7.0\n",
      "Mean Absolute Error: 7.459405422210693\n",
      "Minimum: 0.0, Maximum: 53.0, Median: 6.0\n"
     ]
    }
   ],
   "source": [
    "model1.load_state_dict(torch.load(model_name))\n",
    "loss_per_class = evaluation(model1, test_loader)\n",
    "_ = evaluation(model1, train_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6452b440",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:27:38.795683Z",
     "start_time": "2021-09-20T22:27:38.749684Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3298\n",
      "Age: Test Sample: Loss\n",
      "1 : 1 : 61.00\n",
      "2  No Sample\n",
      "3 : 2 : 42.00\n",
      "4 : 1 : 23.00\n",
      "5 : 1 : 23.00\n",
      "6 : 2 : 20.00\n",
      "7 : 2 : 25.00\n",
      "8 : 2 : 18.00\n",
      "9 : 1 : 19.00\n",
      "10 : 3 : 26.67\n",
      "11 : 4 : 21.25\n",
      "12 : 3 : 14.67\n",
      "13 : 4 : 14.00\n",
      "14 : 5 : 14.00\n",
      "15 : 9 : 14.11\n",
      "16 : 10 : 11.70\n",
      "17 : 16 : 12.81\n",
      "18 : 24 : 12.71\n",
      "19 : 22 : 12.00\n",
      "20 : 32 : 11.28\n",
      "21 : 33 : 8.85\n",
      "22 : 37 : 7.08\n",
      "23 : 42 : 7.12\n",
      "24 : 52 : 7.12\n",
      "25 : 57 : 6.67\n",
      "26 : 55 : 6.18\n",
      "27 : 61 : 6.70\n",
      "28 : 69 : 4.97\n",
      "29 : 62 : 5.15\n",
      "30 : 77 : 5.42\n",
      "31 : 63 : 6.00\n",
      "32 : 75 : 5.39\n",
      "33 : 67 : 6.90\n",
      "34 : 72 : 5.97\n",
      "35 : 82 : 6.74\n",
      "36 : 69 : 5.61\n",
      "37 : 74 : 5.81\n",
      "38 : 76 : 6.63\n",
      "39 : 64 : 6.56\n",
      "40 : 77 : 8.70\n",
      "41 : 64 : 7.05\n",
      "42 : 71 : 8.96\n",
      "43 : 65 : 8.52\n",
      "44 : 56 : 8.41\n",
      "45 : 68 : 8.47\n",
      "46 : 57 : 8.81\n",
      "47 : 58 : 8.07\n",
      "48 : 62 : 7.77\n",
      "49 : 53 : 8.19\n",
      "50 : 63 : 8.62\n",
      "51 : 57 : 8.93\n",
      "52 : 62 : 8.56\n",
      "53 : 50 : 8.78\n",
      "54 : 51 : 8.24\n",
      "55 : 59 : 8.88\n",
      "56 : 45 : 8.09\n",
      "57 : 49 : 9.12\n",
      "58 : 49 : 8.12\n",
      "59 : 43 : 8.79\n",
      "60 : 49 : 10.29\n",
      "61 : 41 : 8.56\n",
      "62 : 48 : 6.81\n",
      "63 : 44 : 9.25\n",
      "64 : 39 : 7.85\n",
      "65 : 46 : 6.67\n",
      "66 : 35 : 7.34\n",
      "67 : 35 : 8.03\n",
      "68 : 43 : 6.60\n",
      "69 : 30 : 5.53\n",
      "70 : 43 : 7.40\n",
      "71 : 29 : 8.07\n",
      "72 : 35 : 7.17\n",
      "73 : 31 : 8.39\n",
      "74 : 28 : 8.61\n",
      "75 : 32 : 8.94\n",
      "76 : 22 : 10.41\n",
      "77 : 21 : 9.14\n",
      "78 : 21 : 14.00\n",
      "79 : 15 : 11.87\n",
      "80 : 18 : 14.11\n",
      "81 : 15 : 8.47\n",
      "82 : 14 : 14.57\n",
      "83 : 11 : 14.91\n",
      "84 : 9 : 16.89\n",
      "85 : 12 : 16.25\n",
      "86 : 7 : 18.86\n",
      "87 : 6 : 17.00\n",
      "88 : 4 : 15.50\n",
      "89 : 4 : 16.50\n",
      "90 : 4 : 20.00\n",
      "91 : 3 : 15.67\n",
      "92 : 2 : 22.00\n",
      "93 : 3 : 19.67\n",
      "94 : 1 : 24.00\n",
      "95 : 2 : 25.00\n",
      "96 : 1 : 28.00\n",
      "97 : 1 : 38.00\n",
      "98 : 1 : 28.00\n",
      "99 : 1 : 29.00\n",
      "100 : 1 : 64.00\n",
      "101 : 1 : 31.00\n"
     ]
    }
   ],
   "source": [
    "sample_per_class = findAge(test_image_list)\n",
    "print('Age: Test Sample: Loss')\n",
    "for i in range(1, 102):\n",
    "    if sample_per_class[i] == 0:\n",
    "        print(i,' No Sample')\n",
    "    else:\n",
    "        print(i,':', sample_per_class[i],':', format(loss_per_class[i].item()/sample_per_class[i],'.2f'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "052a2ce7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:35:18.307039Z",
     "start_time": "2021-09-20T22:27:38.796685Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d303b70faefb4c09890f76ad522b39dd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/11541 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Set Length:  11541\n",
      "Test Set Length:  3298\n",
      "Validation Set Length:  1649\n",
      "Total:  16488\n",
      "Epoch: 1/10, Train Loss: 2.736657124197944,  Validation Loss: 2.340480400965764\n",
      "Validation Loss Decreased(inf ---> 2.340480400965764)\n",
      "Epoch: 2/10, Train Loss: 2.261117322668845,  Validation Loss: 2.251740758235638\n",
      "Validation Loss Decreased(2.340480400965764 ---> 2.251740758235638)\n",
      "Epoch: 3/10, Train Loss: 2.155594169764229,  Validation Loss: 2.165382343989152\n",
      "Validation Loss Decreased(2.251740758235638 ---> 2.165382343989152)\n",
      "Epoch: 4/10, Train Loss: 2.0707513054431472,  Validation Loss: 2.097103137236375\n",
      "Validation Loss Decreased(2.165382343989152 ---> 2.097103137236375)\n",
      "Epoch: 5/10, Train Loss: 2.0025884163313807,  Validation Loss: 2.093622835782858\n",
      "Validation Loss Decreased(2.097103137236375 ---> 2.093622835782858)\n",
      "Epoch: 6/10, Train Loss: 1.9562621531565545,  Validation Loss: 2.074514013070327\n",
      "Validation Loss Decreased(2.093622835782858 ---> 2.074514013070327)\n",
      "Epoch: 7/10, Train Loss: 1.9111658743073268,  Validation Loss: 2.077637846653278\n",
      "Epoch: 8/10, Train Loss: 1.8777806712777576,  Validation Loss: 2.146284731534811\n",
      "Epoch: 9/10, Train Loss: 1.850395627443303,  Validation Loss: 2.0745707154273987\n",
      "Epoch: 10/10, Train Loss: 1.8253654959452086,  Validation Loss: 2.022711542936472\n",
      "Validation Loss Decreased(2.074514013070327 ---> 2.022711542936472)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_loader, test_loader, validation_loader = get_loader(\n",
    "    input_size=input_size,\n",
    "    train_image_list=train_image_list,\n",
    "    test_image_list=test_image_list, \n",
    "    validate_image_list=validate_image_list, \n",
    "    batch_size=batch_size,\n",
    "    train_augment=1,\n",
    ")\n",
    "criteria = CostSensitiveRegularizedLoss(n_classes=num_of_class, base_loss='focal_loss', reduction='mean') \n",
    "optimizer = torch.optim.SGD(model2.parameters(), lr=learning_rate, momentum=0.9, nesterov=True, weight_decay=1e-1)\n",
    "model_name = 'cdcn.pth'\n",
    "train(model2, optimizer, criteria, train_loader, validation_loader, num_of_epoch=10, model_name=model_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "86013069",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:35:42.010041Z",
     "start_time": "2021-09-20T22:35:18.308039Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Error: 9.111279487609863\n",
      "Minimum: 0.0, Maximum: 75.0, Median: 8.0\n",
      "Mean Absolute Error: 7.388267993927002\n",
      "Minimum: 0.0, Maximum: 50.0, Median: 6.0\n"
     ]
    }
   ],
   "source": [
    "model2.load_state_dict(torch.load(model_name))\n",
    "loss_per_class = evaluation(model2, test_loader)\n",
    "_ = evaluation(model2, train_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "33c7b360",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-09-20T22:35:42.074053Z",
     "start_time": "2021-09-20T22:35:42.011039Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3298\n",
      "Age: Test Sample: Loss\n",
      "1 : 1 : 37.00\n",
      "2  No Sample\n",
      "3 : 2 : 55.00\n",
      "4 : 1 : 26.00\n",
      "5 : 1 : 16.00\n",
      "6 : 2 : 16.50\n",
      "7 : 2 : 22.50\n",
      "8 : 2 : 14.50\n",
      "9 : 1 : 15.00\n",
      "10 : 3 : 15.67\n",
      "11 : 4 : 27.75\n",
      "12 : 3 : 17.67\n",
      "13 : 4 : 18.75\n",
      "14 : 5 : 16.40\n",
      "15 : 9 : 12.11\n",
      "16 : 10 : 10.40\n",
      "17 : 16 : 11.50\n",
      "18 : 24 : 13.83\n",
      "19 : 22 : 9.36\n",
      "20 : 32 : 10.50\n",
      "21 : 33 : 8.76\n",
      "22 : 37 : 7.97\n",
      "23 : 42 : 8.52\n",
      "24 : 52 : 7.73\n",
      "25 : 57 : 8.51\n",
      "26 : 55 : 7.47\n",
      "27 : 61 : 8.77\n",
      "28 : 69 : 8.68\n",
      "29 : 62 : 6.85\n",
      "30 : 77 : 7.17\n",
      "31 : 63 : 7.46\n",
      "32 : 75 : 7.63\n",
      "33 : 67 : 7.27\n",
      "34 : 72 : 8.25\n",
      "35 : 82 : 7.71\n",
      "36 : 69 : 7.28\n",
      "37 : 74 : 5.97\n",
      "38 : 76 : 5.53\n",
      "39 : 64 : 6.55\n",
      "40 : 77 : 7.38\n",
      "41 : 64 : 6.50\n",
      "42 : 71 : 6.83\n",
      "43 : 65 : 8.31\n",
      "44 : 56 : 8.48\n",
      "45 : 68 : 9.16\n",
      "46 : 57 : 8.89\n",
      "47 : 58 : 8.60\n",
      "48 : 62 : 8.45\n",
      "49 : 53 : 8.60\n",
      "50 : 63 : 7.41\n",
      "51 : 57 : 8.49\n",
      "52 : 62 : 9.05\n",
      "53 : 50 : 7.50\n",
      "54 : 51 : 8.53\n",
      "55 : 59 : 8.49\n",
      "56 : 45 : 9.22\n",
      "57 : 49 : 9.63\n",
      "58 : 49 : 9.14\n",
      "59 : 43 : 8.91\n",
      "60 : 49 : 11.22\n",
      "61 : 41 : 9.17\n",
      "62 : 48 : 9.54\n",
      "63 : 44 : 9.18\n",
      "64 : 39 : 8.90\n",
      "65 : 46 : 8.59\n",
      "66 : 35 : 8.40\n",
      "67 : 35 : 10.49\n",
      "68 : 43 : 8.26\n",
      "69 : 30 : 9.90\n",
      "70 : 43 : 9.26\n",
      "71 : 29 : 12.34\n",
      "72 : 35 : 8.89\n",
      "73 : 31 : 12.32\n",
      "74 : 28 : 11.14\n",
      "75 : 32 : 12.28\n",
      "76 : 22 : 13.55\n",
      "77 : 21 : 13.10\n",
      "78 : 21 : 16.05\n",
      "79 : 15 : 14.73\n",
      "80 : 18 : 16.78\n",
      "81 : 15 : 22.33\n",
      "82 : 14 : 18.93\n",
      "83 : 11 : 15.09\n",
      "84 : 9 : 21.33\n",
      "85 : 12 : 21.83\n",
      "86 : 7 : 16.86\n",
      "87 : 6 : 23.83\n",
      "88 : 4 : 14.75\n",
      "89 : 4 : 25.75\n",
      "90 : 4 : 23.25\n",
      "91 : 3 : 11.67\n",
      "92 : 2 : 17.00\n",
      "93 : 3 : 24.67\n",
      "94 : 1 : 9.00\n",
      "95 : 2 : 18.50\n",
      "96 : 1 : 31.00\n",
      "97 : 1 : 45.00\n",
      "98 : 1 : 13.00\n",
      "99 : 1 : 34.00\n",
      "100 : 1 : 62.00\n",
      "101 : 1 : 36.00\n"
     ]
    }
   ],
   "source": [
    "sample_per_class = findAge(test_image_list)\n",
    "print('Age: Test Sample: Loss')\n",
    "for i in range(1, 102):\n",
    "    if sample_per_class[i] == 0:\n",
    "        print(i,' No Sample')\n",
    "    else:\n",
    "        print(i,':', sample_per_class[i],':', format(loss_per_class[i].item()/sample_per_class[i],'.2f'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf0b1434",
   "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
}