Main_Network_Code.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "80mPHdATEtti"
      },
      "outputs": [],
      "source": [
        "from torch.nn import AdaptiveMaxPool2d, \\\n",
        "    NLLLoss, BCELoss, CrossEntropyLoss, Softmax, Embedding\n",
        "\n",
        "import torch\n",
        "import torchvision\n",
        "from torch import optim\n",
        "import torch.utils.model_zoo as model_zoo\n",
        "import time\n",
        "from torchsummary import summary\n",
        "import os\n",
        "from easydict import EasyDict as edict\n",
        "import math\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torchvision import transforms as trans\n",
        "from torchvision.datasets import ImageFolder\n",
        "from torch.utils.data import  DataLoader\n",
        "from torch.optim.lr_scheduler import StepLR\n",
        "from tqdm import tqdm\n",
        "import random\n",
        "import matplotlib.pyplot as plt\n",
        "#from tensorboardX import SummaryWriter\n",
        "from torch.utils.tensorboard import SummaryWriter\n",
        "from sklearn.metrics import roc_curve\n",
        "import numpy as np\n",
        "from torch.nn import init\n",
        "from collections import namedtuple\n",
        "from torch.nn import Linear, Conv2d, BatchNorm1d, BatchNorm2d, PReLU, ReLU, Sigmoid, Dropout2d, Dropout, AvgPool2d, MaxPool2d, AdaptiveAvgPool2d, Sequential, Parameter, Module, CrossEntropyLoss, DataParallel"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mio6BLLYddsK"
      },
      "source": [
        "#### Image Width, Image Height was set to 224 in this work.\n",
        "#### RGB Images of Forehead ROI have been used.\n",
        "#### Embedding Dimension is set to 512.\n",
        "## Do Not Modify or delete the below code cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "jfni0BECEttm"
      },
      "outputs": [],
      "source": [
        "img_width = 224\n",
        "img_height = 224\n",
        "channels = 3\n",
        "embedding_dim = 512\n",
        "\n",
        "size1_new = int(np.floor(img_width/2))\n",
        "size2_new = int(np.floor(img_height/2))\n",
        "\n",
        "size1_new = int(np.ceil(size1_new/2))\n",
        "size2_new = int(np.ceil(size2_new/2))\n",
        "\n",
        "size1_new = int(np.ceil(size1_new/2))\n",
        "size2_new = int(np.ceil(size2_new/2))\n",
        "\n",
        "size1_new = int(np.ceil(size1_new/2))\n",
        "size2_new = int(np.ceil(size2_new/2))\n",
        "\n",
        "size1_new = int(np.floor(size1_new/2))\n",
        "size2_new = int(np.floor(size2_new/2))\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "51XPq-xtEttn"
      },
      "outputs": [],
      "source": [
        "def get_train_dataset(imgs_folder):\n",
        "    if channels != 3:\n",
        "        train_transform = trans.Compose([\n",
        "            trans.Grayscale(num_output_channels=channels), \n",
        "            trans.Resize((img_width, img_height)), \n",
        "            trans.RandomHorizontalFlip(),\n",
        "            trans.ToTensor(),\n",
        "            trans.Normalize((0.5,), (0.5,))\n",
        "            \n",
        "        ])\n",
        "    else:\n",
        "        train_transform = trans.Compose([\n",
        "            trans.Resize((img_width, img_height)), \n",
        "            trans.RandomHorizontalFlip(),\n",
        "            trans.ToTensor(),\n",
        "            trans.Normalize((0.5,), (0.5,))\n",
        "        ])\n",
        "    ds = ImageFolder(imgs_folder, train_transform)\n",
        "    class_num = ds[-1][1] + 1\n",
        "    return ds, class_num"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HyRnyz5eEtto"
      },
      "source": [
        "### Code for ArcFace and CosFace has been obtained from the following repository: https://github.com/ronghuaiyang/arcface-pytorch/blob/master/models/metrics.py"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "QY7DbddcEttp"
      },
      "outputs": [],
      "source": [
        "class FocalLoss(nn.Module):\n",
        "\n",
        "    def __init__(self, gamma=0, eps=1e-7):\n",
        "        super(FocalLoss, self).__init__()\n",
        "        self.gamma = gamma\n",
        "        self.eps = eps\n",
        "        self.ce = torch.nn.CrossEntropyLoss()\n",
        "\n",
        "    def forward(self, input, target):\n",
        "        logp = self.ce(input, target)\n",
        "        p = torch.exp(-logp)\n",
        "        loss = (1 - p) ** self.gamma * logp\n",
        "        return loss.mean()\n",
        "\n",
        "\n",
        "class ArcMarginProduct(nn.Module):\n",
        "    r\"\"\"Implement of large margin arc distance: :\n",
        "        Args:\n",
        "            in_features: size of each input sample\n",
        "            out_features: size of each output sample\n",
        "            s: norm of input feature\n",
        "            m: margin\n",
        "\n",
        "            cos(theta + m)\n",
        "        \"\"\"\n",
        "    def __init__(self, in_features, out_features, s=30.0, m=0.50, easy_margin=False):\n",
        "        super(ArcMarginProduct, self).__init__()\n",
        "        self.in_features = in_features\n",
        "        self.out_features = out_features\n",
        "        self.s = s\n",
        "        self.m = m\n",
        "        self.weight = Parameter(torch.FloatTensor(out_features, in_features))\n",
        "        nn.init.xavier_uniform_(self.weight)\n",
        "\n",
        "        self.easy_margin = easy_margin\n",
        "        self.cos_m = math.cos(m)\n",
        "        self.sin_m = math.sin(m)\n",
        "        self.th = math.cos(math.pi - m)\n",
        "        self.mm = math.sin(math.pi - m) * m\n",
        "\n",
        "    def forward(self, input, label):\n",
        "        # --------------------------- cos(theta) & phi(theta) ---------------------------\n",
        "        cosine = F.linear(F.normalize(input), F.normalize(self.weight))\n",
        "        sine = torch.sqrt((1.0 - torch.pow(cosine, 2)).clamp(0, 1))\n",
        "        phi = cosine * self.cos_m - sine * self.sin_m\n",
        "        if self.easy_margin:\n",
        "            phi = torch.where(cosine > 0, phi, cosine)\n",
        "        else:\n",
        "            phi = torch.where(cosine > self.th, phi, cosine - self.mm)\n",
        "        # --------------------------- convert label to one-hot ---------------------------\n",
        "        # one_hot = torch.zeros(cosine.size(), requires_grad=True, device='cuda')\n",
        "        one_hot = torch.zeros(cosine.size(), device='cuda')\n",
        "        one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n",
        "        # -------------torch.where(out_i = {x_i if condition_i else y_i) -------------\n",
        "        output = (one_hot * phi) + ((1.0 - one_hot) * cosine)  # you can use torch.where if your torch.__version__ is 0.4\n",
        "        output *= self.s\n",
        "        # print(output)\n",
        "\n",
        "        return output\n",
        "\n",
        "\n",
        "class AddMarginProduct(nn.Module):\n",
        "    r\"\"\"Implement of large margin cosine distance: :\n",
        "    Args:\n",
        "        in_features: size of each input sample\n",
        "        out_features: size of each output sample\n",
        "        s: norm of input feature\n",
        "        m: margin\n",
        "        cos(theta) - m\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, in_features, out_features, s=30.0, m=0.40):\n",
        "        super(AddMarginProduct, self).__init__()\n",
        "        self.in_features = in_features\n",
        "        self.out_features = out_features\n",
        "        self.s = s\n",
        "        self.m = m\n",
        "        self.weight = Parameter(torch.FloatTensor(out_features, in_features))\n",
        "        nn.init.xavier_uniform_(self.weight)\n",
        "\n",
        "    def forward(self, input, label):\n",
        "        # --------------------------- cos(theta) & phi(theta) ---------------------------\n",
        "        cosine = F.linear(F.normalize(input), F.normalize(self.weight))\n",
        "        phi = cosine - self.m\n",
        "        # --------------------------- convert label to one-hot ---------------------------\n",
        "        one_hot = torch.zeros(cosine.size(), device='cuda')\n",
        "        # one_hot = one_hot.cuda() if cosine.is_cuda else one_hot\n",
        "        one_hot.scatter_(1, label.view(-1, 1).long(), 1)\n",
        "        # -------------torch.where(out_i = {x_i if condition_i else y_i) -------------\n",
        "        output = (one_hot * phi) + ((1.0 - one_hot) * cosine)  # you can use torch.where if your torch.__version__ is 0.4\n",
        "        output *= self.s\n",
        "        # print(output)\n",
        "\n",
        "        return output\n",
        "\n",
        "    def __repr__(self):\n",
        "        return self.__class__.__name__ + '(' \\\n",
        "               + 'in_features=' + str(self.in_features) \\\n",
        "               + ', out_features=' + str(self.out_features) \\\n",
        "               + ', s=' + str(self.s) \\\n",
        "               + ', m=' + str(self.m) + ')'\n",
        "\n",
        "\n",
        "class SphereProduct(nn.Module):\n",
        "    r\"\"\"Implement of large margin cosine distance: :\n",
        "    Args:\n",
        "        in_features: size of each input sample\n",
        "        out_features: size of each output sample\n",
        "        m: margin\n",
        "        cos(m*theta)\n",
        "    \"\"\"\n",
        "    def __init__(self, in_features, out_features, m=4):\n",
        "        super(SphereProduct, self).__init__()\n",
        "        self.in_features = in_features\n",
        "        self.out_features = out_features\n",
        "        self.m = m\n",
        "        self.base = 1000.0\n",
        "        self.gamma = 0.12\n",
        "        self.power = 1\n",
        "        self.LambdaMin = 5.0\n",
        "        self.iter = 0\n",
        "        self.weight = Parameter(torch.FloatTensor(out_features, in_features))\n",
        "        nn.init.xavier_uniform(self.weight)\n",
        "\n",
        "        # duplication formula\n",
        "        self.mlambda = [\n",
        "            lambda x: x ** 0,\n",
        "            lambda x: x ** 1,\n",
        "            lambda x: 2 * x ** 2 - 1,\n",
        "            lambda x: 4 * x ** 3 - 3 * x,\n",
        "            lambda x: 8 * x ** 4 - 8 * x ** 2 + 1,\n",
        "            lambda x: 16 * x ** 5 - 20 * x ** 3 + 5 * x\n",
        "        ]\n",
        "\n",
        "    def forward(self, input, label):\n",
        "        # lambda = max(lambda_min,base*(1+gamma*iteration)^(-power))\n",
        "        self.iter += 1\n",
        "        self.lamb = max(self.LambdaMin, self.base * (1 + self.gamma * self.iter) ** (-1 * self.power))\n",
        "\n",
        "        # --------------------------- cos(theta) & phi(theta) ---------------------------\n",
        "        cos_theta = F.linear(F.normalize(input), F.normalize(self.weight))\n",
        "        cos_theta = cos_theta.clamp(-1, 1)\n",
        "        cos_m_theta = self.mlambda[self.m](cos_theta)\n",
        "        theta = cos_theta.data.acos()\n",
        "        k = (self.m * theta / 3.14159265).floor()\n",
        "        phi_theta = ((-1.0) ** k) * cos_m_theta - 2 * k\n",
        "        NormOfFeature = torch.norm(input, 2, 1)\n",
        "\n",
        "        # --------------------------- convert label to one-hot ---------------------------\n",
        "        one_hot = torch.zeros(cos_theta.size())\n",
        "        one_hot = one_hot.cuda() if cos_theta.is_cuda else one_hot\n",
        "        one_hot.scatter_(1, label.view(-1, 1), 1)\n",
        "\n",
        "        # --------------------------- Calculate output ---------------------------\n",
        "        output = (one_hot * (phi_theta - cos_theta) / (1 + self.lamb)) + cos_theta\n",
        "        output *= NormOfFeature.view(-1, 1)\n",
        "\n",
        "        return output\n",
        "\n",
        "    def __repr__(self):\n",
        "        return self.__class__.__name__ + '(' \\\n",
        "               + 'in_features=' + str(self.in_features) \\\n",
        "               + ', out_features=' + str(self.out_features) \\\n",
        "               + ', m=' + str(self.m) + ')'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W-ecjQ-AfKsW"
      },
      "source": [
        "### Code for Attention Modules have been obtained from: https://github.com/xmu-xiaoma666/External-Attention-pytorch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "knbtK9hh9Kif"
      },
      "outputs": [],
      "source": [
        "class PAM_Module(nn.Module):\n",
        "    \"\"\" Position attention module\"\"\"\n",
        "    #Ref from SAGAN\n",
        "    def __init__(self, in_dim = 512):\n",
        "        super(PAM_Module, self).__init__()\n",
        "        self.chanel_in = in_dim\n",
        "\n",
        "        self.query_conv = Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)\n",
        "        self.key_conv = Conv2d(in_channels=in_dim, out_channels=in_dim//8, kernel_size=1)\n",
        "        self.value_conv = Conv2d(in_channels=in_dim, out_channels=in_dim, kernel_size=1)\n",
        "        self.gamma = Parameter(torch.zeros(1))\n",
        "\n",
        "        self.softmax = Softmax(dim=-1)\n",
        "    def forward(self, x):\n",
        "        \"\"\"\n",
        "            inputs :\n",
        "                x : input feature maps( B X C X H X W)\n",
        "            returns :\n",
        "                out : attention value + input feature\n",
        "                attention: B X (HxW) X (HxW)\n",
        "        \"\"\"\n",
        "        m_batchsize, C, height, width = x.size()\n",
        "        proj_query = self.query_conv(x).view(m_batchsize, -1, width*height).permute(0, 2, 1)\n",
        "        proj_key = self.key_conv(x).view(m_batchsize, -1, width*height)\n",
        "        energy = torch.bmm(proj_query, proj_key)\n",
        "        attention = self.softmax(energy)\n",
        "        proj_value = self.value_conv(x).view(m_batchsize, -1, width*height)\n",
        "\n",
        "        out = torch.bmm(proj_value, attention.permute(0, 2, 1))\n",
        "        out = out.view(m_batchsize, C, height, width)\n",
        "\n",
        "        #out = self.gamma*out\n",
        "        out = self.gamma*out + x\n",
        "        return out\n",
        "\n",
        "class ECAAttention(nn.Module):\n",
        "\n",
        "    def __init__(self, kernel_size=5):\n",
        "        super().__init__()\n",
        "        self.gap=nn.AdaptiveAvgPool2d(1)\n",
        "        self.conv=nn.Conv1d(1,1,kernel_size=kernel_size,padding=(kernel_size-1)//2)\n",
        "        self.sigmoid=nn.Sigmoid()\n",
        "\n",
        "    def init_weights(self):\n",
        "        for m in self.modules():\n",
        "            if isinstance(m, nn.Conv2d):\n",
        "                init.kaiming_normal_(m.weight, mode='fan_out')\n",
        "                if m.bias is not None:\n",
        "                    init.constant_(m.bias, 0)\n",
        "            elif isinstance(m, nn.BatchNorm2d):\n",
        "                init.constant_(m.weight, 1)\n",
        "                init.constant_(m.bias, 0)\n",
        "            elif isinstance(m, nn.Linear):\n",
        "                init.normal_(m.weight, std=0.001)\n",
        "                if m.bias is not None:\n",
        "                    init.constant_(m.bias, 0)\n",
        "\n",
        "    def forward(self, x):\n",
        "        y=self.gap(x) #bs,c,1,1\n",
        "        y=y.squeeze(-1).permute(0,2,1) #bs,1,c\n",
        "        y=self.conv(y) #bs,1,c\n",
        "        y=self.sigmoid(y) #bs,1,c\n",
        "        y=y.permute(0,2,1).unsqueeze(-1) #bs,c,1,1\n",
        "        return x*y.expand_as(x)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "FErDkMoJEttu"
      },
      "outputs": [],
      "source": [
        "\n",
        "model_urls = {\n",
        "    'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',\n",
        "    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',\n",
        "    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',\n",
        "    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',\n",
        "    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',\n",
        "}\n",
        "\n",
        "\n",
        "def conv3x3(in_planes, out_planes, stride=1):\n",
        "    \"\"\"3x3 convolution with padding\"\"\"\n",
        "    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,\n",
        "                     padding=1, bias=False)\n",
        "\n",
        "\n",
        "class BasicBlock(nn.Module):\n",
        "    expansion = 1\n",
        "\n",
        "    def __init__(self, inplanes, planes, stride=1, downsample=None):\n",
        "        super(BasicBlock, self).__init__()\n",
        "        self.conv1 = conv3x3(inplanes, planes, stride)\n",
        "        self.bn1 = nn.BatchNorm2d(planes)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.conv2 = conv3x3(planes, planes)\n",
        "        self.bn2 = nn.BatchNorm2d(planes)\n",
        "        self.downsample = downsample\n",
        "        self.stride = stride\n",
        "\n",
        "    def forward(self, x):\n",
        "        residual = x\n",
        "\n",
        "        out = self.conv1(x)\n",
        "        out = self.bn1(out)\n",
        "        out = self.relu(out)\n",
        "\n",
        "        out = self.conv2(out)\n",
        "        out = self.bn2(out)\n",
        "\n",
        "        if self.downsample is not None:\n",
        "            residual = self.downsample(x)\n",
        "\n",
        "        out += residual\n",
        "        out = self.relu(out)\n",
        "\n",
        "        return out\n",
        "\n",
        "\n",
        "class IRBlock(nn.Module): \n",
        "    expansion = 1\n",
        "\n",
        "    def __init__(self, inplanes, planes, stride=1, downsample=None, use_se=True):\n",
        "        super(IRBlock, self).__init__()\n",
        "        self.bn0 = nn.BatchNorm2d(inplanes)\n",
        "        self.conv1 = conv3x3(inplanes, inplanes)\n",
        "        self.bn1 = nn.BatchNorm2d(inplanes)\n",
        "        self.prelu = nn.PReLU()\n",
        "        self.conv2 = conv3x3(inplanes, planes, stride)\n",
        "        self.bn2 = nn.BatchNorm2d(planes)\n",
        "        self.downsample = downsample\n",
        "        self.stride = stride\n",
        "        self.use_se = use_se\n",
        "        if self.use_se:\n",
        "            self.se = SEBlock(planes)\n",
        "\n",
        "    def forward(self, x):\n",
        "        residual = x\n",
        "        out = self.bn0(x)\n",
        "        out = self.conv1(out)\n",
        "        out = self.bn1(out)\n",
        "        out = self.prelu(out)\n",
        "\n",
        "        out = self.conv2(out)\n",
        "        out = self.bn2(out)\n",
        "        if self.use_se:\n",
        "            out = self.se(out)\n",
        "\n",
        "        if self.downsample is not None:\n",
        "            residual = self.downsample(x)\n",
        "\n",
        "        out += residual\n",
        "        out = self.prelu(out)\n",
        "\n",
        "        return out\n",
        "\n",
        "\n",
        "class Bottleneck(nn.Module):\n",
        "    expansion = 4\n",
        "\n",
        "    def __init__(self, inplanes, planes, stride=1, downsample=None):\n",
        "        super(Bottleneck, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(planes)\n",
        "        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,\n",
        "                               padding=1, bias=False)\n",
        "        self.bn2 = nn.BatchNorm2d(planes)\n",
        "        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, bias=False)\n",
        "        self.bn3 = nn.BatchNorm2d(planes * self.expansion)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.downsample = downsample\n",
        "        self.stride = stride\n",
        "\n",
        "    def forward(self, x):\n",
        "        residual = x\n",
        "\n",
        "        out = self.conv1(x)\n",
        "        out = self.bn1(out)\n",
        "        out = self.relu(out)\n",
        "\n",
        "        out = self.conv2(out)\n",
        "        out = self.bn2(out)\n",
        "        out = self.relu(out)\n",
        "\n",
        "        out = self.conv3(out)\n",
        "        out = self.bn3(out)\n",
        "\n",
        "        if self.downsample is not None:\n",
        "            residual = self.downsample(x)\n",
        "\n",
        "        out += residual\n",
        "        out = self.relu(out)\n",
        "\n",
        "        return out\n",
        "\n",
        "\n",
        "class SEBlock(nn.Module):\n",
        "    def __init__(self, channel, reduction=16):\n",
        "        super(SEBlock, self).__init__()\n",
        "        self.avg_pool = nn.AdaptiveAvgPool2d(1)\n",
        "        self.fc = nn.Sequential(\n",
        "                nn.Linear(channel, channel // reduction),\n",
        "                nn.PReLU(),\n",
        "                nn.Linear(channel // reduction, channel),\n",
        "                nn.Sigmoid()\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        b, c, _, _ = x.size()\n",
        "        y = self.avg_pool(x).view(b, c)\n",
        "        y = self.fc(y).view(b, c, 1, 1)\n",
        "        return x * y\n",
        "\n",
        "\n",
        "class ResNetFace(nn.Module):\n",
        "    def __init__(self, block, layers, use_se=True):\n",
        "        self.inplanes = 64\n",
        "        self.use_se = use_se\n",
        "        super(ResNetFace, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(channels, 64, kernel_size=3, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(64)\n",
        "        self.prelu = nn.PReLU()\n",
        "        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)\n",
        "        \n",
        "        self.sattention = PAM_Module()\n",
        "        self.cattention = ECAAttention(kernel_size = 5)\n",
        "        \n",
        "        self.layer1 = self._make_layer(block, 64, layers[0])\n",
        "        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)\n",
        "        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)\n",
        "        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)\n",
        "        self.bn4 = nn.BatchNorm2d(512)\n",
        "        self.dropout = nn.Dropout()\n",
        "        \n",
        "        self.fc5 = nn.Linear(512 * (size1_new) * (size2_new), embedding_dim)\n",
        "        self.bn5 = nn.BatchNorm1d(embedding_dim)\n",
        "\n",
        "        for m in self.modules():\n",
        "            if isinstance(m, nn.Conv2d):\n",
        "                nn.init.xavier_normal_(m.weight)\n",
        "            elif isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.BatchNorm1d):\n",
        "                nn.init.constant_(m.weight, 1)\n",
        "                nn.init.constant_(m.bias, 0)\n",
        "            elif isinstance(m, nn.Linear):\n",
        "                nn.init.xavier_normal_(m.weight)\n",
        "                nn.init.constant_(m.bias, 0)\n",
        "\n",
        "    def _make_layer(self, block, planes, blocks, stride=1):\n",
        "        downsample = None\n",
        "        if stride != 1 or self.inplanes != planes * block.expansion:\n",
        "            downsample = nn.Sequential(\n",
        "                nn.Conv2d(self.inplanes, planes * block.expansion,\n",
        "                          kernel_size=1, stride=stride, bias=False),\n",
        "                nn.BatchNorm2d(planes * block.expansion),\n",
        "            )\n",
        "        layers = []\n",
        "        layers.append(block(self.inplanes, planes, stride, downsample, use_se=self.use_se))\n",
        "        self.inplanes = planes\n",
        "        for i in range(1, blocks):\n",
        "            layers.append(block(self.inplanes, planes, use_se=self.use_se))\n",
        "\n",
        "        return nn.Sequential(*layers)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv1(x)\n",
        "        x = self.bn1(x)\n",
        "        x = self.prelu(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",
        "        x = self.bn4(x)\n",
        "        x = self.dropout(x)\n",
        "        \n",
        "        x = self.maxpool(x)\n",
        "        \n",
        "        \n",
        "        s_x = self.sattention(x) #spatial or positional attention.\n",
        "        c_x = self.cattention(x)\n",
        "        \n",
        "        x = c_x + s_x #Element Sum Concat of Attention Outputs.\n",
        "        x = x.view(x.size(0), -1)\n",
        "        x = self.fc5(x)\n",
        "        x = self.bn5(x)\n",
        "        return x\n",
        "\n",
        "def resnet_18(use_se=True, **kwargs):\n",
        "    model = ResNetFace(IRBlock, [2, 2, 2, 2], use_se=use_se, **kwargs)\n",
        "    return model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wWo0p9pSuevH"
      },
      "source": [
        "# Load The Dataset. Replace below lines accordingly."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "Irc5wuO0GWoN"
      },
      "outputs": [],
      "source": [
        "ds, class_num = get_train_dataset(\"/home/rohit.bharadwaj/Projects/forehead/Data_Cropped/train\")\n",
        "ds2, class_num2 = get_train_dataset(\"/home/rohit.bharadwaj/Projects/forehead/Data_Cropped/test\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9VksS53e929k"
      },
      "source": [
        "### Configuration Settings for the Network."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "0BG5ngBxEtt1"
      },
      "outputs": [],
      "source": [
        "class Config(object):\n",
        "    env = 'default'\n",
        "    backbone = 'resnet18'\n",
        "    classify = 'softmax'\n",
        "    num_classes = class_num\n",
        "    metric = 'add_margin' #add_margin for CosFace and arc_margin for ArcFace loss.\n",
        "    easy_margin = False\n",
        "    use_se = False\n",
        "    #loss = \"cross_entropy\"\n",
        "    loss = 'focal_loss'\n",
        "\n",
        "    pin_memory = True\n",
        "    \n",
        "    display = True\n",
        "    finetune = False\n",
        "\n",
        "    checkpoints_path = '/home/rohit.bharadwaj/Projects/forehead/checkpoints' #folder name where the checkpoints will be stored.\n",
        "    load_model_path = '/home/rohit.bharadwaj/Projects/forehead/models/resnet18.pth'\n",
        "    test_model_path = '/home/rohit.bharadwaj/Projects/forehead/checkpoints/resnet18_110.pth'\n",
        "    save_interval = 100\n",
        "\n",
        "    train_batch_size = 16  # batch size\n",
        "    test_batch_size = 32\n",
        "\n",
        "    input_shape = (channels, img_width, img_height)\n",
        "\n",
        "    optimizer = 'adam'\n",
        "\n",
        "    use_gpu = True  # use GPU or not\n",
        "    gpu_id = '0, 1'\n",
        "    num_workers = 2  # how many workers for loading data\n",
        "    print_freq = 100  # print info every N batch\n",
        "\n",
        "    debug_file = '/tmp/debug'  # if os.path.exists(debug_file): enter ipdb\n",
        "    result_file = 'result.csv'\n",
        "\n",
        "    \n",
        "    max_epoch = 100\n",
        "    lr = 3e-4  # initial learning rate before 1e-3\n",
        "    lr_step = 20\n",
        "    lr_decay = 0.95  # when val_loss increase, lr = lr*lr_decay\n",
        "    weight_decay = 5e-4\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "jrF5VLTNEtt1"
      },
      "outputs": [],
      "source": [
        "opt = Config()\n",
        "loader = DataLoader(ds, batch_size= opt.train_batch_size, shuffle=True, pin_memory= opt.pin_memory, num_workers= opt.num_workers)\n",
        "test_loader = DataLoader(ds2, batch_size = opt.test_batch_size)\n",
        "class_names = ds.classes\n",
        "\n",
        "device = torch.device(\"cuda\") # Train on GPU.\n",
        "if opt.loss == 'focal_loss':\n",
        "    criterion = FocalLoss(gamma=2)\n",
        "else:\n",
        "    criterion = torch.nn.CrossEntropyLoss()\n",
        "\n",
        "model = resnet_18(use_se=opt.use_se)\n",
        "\n",
        "\n",
        "if opt.metric == 'add_margin':\n",
        "    metric_fc = AddMarginProduct(embedding_dim, opt.num_classes, s=300, m=0.35)\n",
        "elif opt.metric == 'arc_margin':\n",
        "    metric_fc = ArcMarginProduct(embedding_dim, opt.num_classes, s=300, m=0.35, easy_margin=opt.easy_margin)\n",
        "elif opt.metric == 'sphere':\n",
        "    metric_fc = SphereProduct(embedding_dim, opt.num_classes, m=4)\n",
        "else:\n",
        "    metric_fc = nn.Linear(embedding_dim, opt.num_classes)\n",
        "\n",
        "model.to(device)\n",
        "model = DataParallel(model)\n",
        "metric_fc.to(device)\n",
        "metric_fc = DataParallel(metric_fc)\n",
        "if opt.optimizer == 'sgd':\n",
        "    optimizer = torch.optim.SGD([{'params': model.parameters()}, {'params': metric_fc.parameters()}],\n",
        "                                lr=opt.lr, weight_decay=opt.weight_decay)\n",
        "else:\n",
        "    optimizer = torch.optim.Adam([{'params': model.parameters()}, {'params': metric_fc.parameters()}],\n",
        "                                 lr=opt.lr, weight_decay=opt.weight_decay)\n",
        "scheduler = StepLR(optimizer, step_size=opt.lr_step, gamma=0.1) #decays learning rate by gamma every step_size epochs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "nGRRJ0m9Ett7"
      },
      "outputs": [],
      "source": [
        "def save_model(model, save_path, name, iter_cnt):\n",
        "    save_name = os.path.join(save_path, name + '_' + str(iter_cnt) + '.pth')\n",
        "    torch.save(model.state_dict(), save_name)\n",
        "    return save_name"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VLb0X_vB_2Pn"
      },
      "source": [
        "# Do Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "Vxsr-HsyEtt-",
        "scrolled": false
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch: 1, Training Accuracy: 0.0%, Loss: 128.71\n",
            "Epoch: 2, Training Accuracy: 0.0%, Loss: 112.18\n",
            "Epoch: 3, Training Accuracy: 0.04%, Loss: 104.18\n",
            "Epoch: 4, Training Accuracy: 0.93%, Loss: 89.95\n",
            "Epoch: 5, Training Accuracy: 3.45%, Loss: 69.44\n",
            "Epoch: 6, Training Accuracy: 11.41%, Loss: 48.88\n",
            "Epoch: 7, Training Accuracy: 22.66%, Loss: 33.24\n",
            "Epoch: 8, Training Accuracy: 32.94%, Loss: 24.46\n",
            "Epoch: 9, Training Accuracy: 46.63%, Loss: 16.51\n",
            "Epoch: 10, Training Accuracy: 54.59%, Loss: 11.78\n",
            "Epoch: 11, Training Accuracy: 65.96%, Loss: 7.56\n",
            "Epoch: 12, Training Accuracy: 67.14%, Loss: 6.78\n",
            "Epoch: 13, Training Accuracy: 73.19%, Loss: 5.08\n",
            "Epoch: 14, Training Accuracy: 75.67%, Loss: 4.1\n",
            "Epoch: 15, Training Accuracy: 78.23%, Loss: 3.21\n",
            "Epoch: 16, Training Accuracy: 79.45%, Loss: 2.95\n",
            "Epoch: 17, Training Accuracy: 82.13%, Loss: 2.34\n",
            "Epoch: 18, Training Accuracy: 85.05%, Loss: 1.64\n",
            "Epoch: 19, Training Accuracy: 83.59%, Loss: 1.85\n",
            "Epoch: 20, Training Accuracy: 86.56%, Loss: 1.42\n",
            "Epoch: 21, Training Accuracy: 90.74%, Loss: 0.62\n",
            "Epoch: 22, Training Accuracy: 92.77%, Loss: 0.39\n",
            "Epoch: 23, Training Accuracy: 95.25%, Loss: 0.28\n",
            "Epoch: 24, Training Accuracy: 95.41%, Loss: 0.21\n",
            "Epoch: 25, Training Accuracy: 95.98%, Loss: 0.16\n",
            "Epoch: 26, Training Accuracy: 96.34%, Loss: 0.15\n",
            "Epoch: 27, Training Accuracy: 97.16%, Loss: 0.09\n",
            "Epoch: 28, Training Accuracy: 97.48%, Loss: 0.13\n",
            "Epoch: 29, Training Accuracy: 97.08%, Loss: 0.12\n",
            "Epoch: 30, Training Accuracy: 97.32%, Loss: 0.09\n",
            "Epoch: 31, Training Accuracy: 97.77%, Loss: 0.12\n",
            "Epoch: 32, Training Accuracy: 97.08%, Loss: 0.07\n",
            "Epoch: 33, Training Accuracy: 97.93%, Loss: 0.05\n",
            "Epoch: 34, Training Accuracy: 98.42%, Loss: 0.03\n",
            "Epoch: 35, Training Accuracy: 97.85%, Loss: 0.07\n",
            "Epoch: 36, Training Accuracy: 98.38%, Loss: 0.04\n",
            "Epoch: 37, Training Accuracy: 98.33%, Loss: 0.03\n",
            "Epoch: 38, Training Accuracy: 98.05%, Loss: 0.07\n",
            "Epoch: 39, Training Accuracy: 98.38%, Loss: 0.05\n",
            "Epoch: 40, Training Accuracy: 98.54%, Loss: 0.05\n",
            "Epoch: 41, Training Accuracy: 97.89%, Loss: 0.07\n",
            "Epoch: 42, Training Accuracy: 98.46%, Loss: 0.07\n",
            "Epoch: 43, Training Accuracy: 98.94%, Loss: 0.03\n",
            "Epoch: 44, Training Accuracy: 98.09%, Loss: 0.05\n",
            "Epoch: 45, Training Accuracy: 98.82%, Loss: 0.02\n",
            "Epoch: 46, Training Accuracy: 98.62%, Loss: 0.04\n",
            "Epoch: 47, Training Accuracy: 98.17%, Loss: 0.05\n",
            "Epoch: 48, Training Accuracy: 98.5%, Loss: 0.06\n",
            "Epoch: 49, Training Accuracy: 98.21%, Loss: 0.03\n",
            "Epoch: 50, Training Accuracy: 99.27%, Loss: 0.01\n",
            "Epoch: 51, Training Accuracy: 98.74%, Loss: 0.02\n",
            "Epoch: 52, Training Accuracy: 98.94%, Loss: 0.03\n",
            "Epoch: 53, Training Accuracy: 98.86%, Loss: 0.03\n",
            "Epoch: 54, Training Accuracy: 99.19%, Loss: 0.01\n",
            "Epoch: 55, Training Accuracy: 98.74%, Loss: 0.05\n",
            "Epoch: 56, Training Accuracy: 98.94%, Loss: 0.03\n",
            "Epoch: 57, Training Accuracy: 98.78%, Loss: 0.03\n",
            "Epoch: 58, Training Accuracy: 98.54%, Loss: 0.03\n",
            "Epoch: 59, Training Accuracy: 99.15%, Loss: 0.02\n",
            "Epoch: 60, Training Accuracy: 98.78%, Loss: 0.03\n",
            "Epoch: 61, Training Accuracy: 98.82%, Loss: 0.02\n",
            "Epoch: 62, Training Accuracy: 98.46%, Loss: 0.05\n",
            "Epoch: 63, Training Accuracy: 98.98%, Loss: 0.02\n",
            "Epoch: 64, Training Accuracy: 98.94%, Loss: 0.02\n",
            "Epoch: 65, Training Accuracy: 98.94%, Loss: 0.03\n",
            "Epoch: 66, Training Accuracy: 99.19%, Loss: 0.01\n",
            "Epoch: 67, Training Accuracy: 98.74%, Loss: 0.02\n",
            "Epoch: 68, Training Accuracy: 98.74%, Loss: 0.05\n",
            "Epoch: 69, Training Accuracy: 99.07%, Loss: 0.03\n",
            "Epoch: 70, Training Accuracy: 98.94%, Loss: 0.02\n",
            "Epoch: 71, Training Accuracy: 98.82%, Loss: 0.02\n",
            "Epoch: 72, Training Accuracy: 98.86%, Loss: 0.01\n",
            "Epoch: 73, Training Accuracy: 99.11%, Loss: 0.02\n",
            "Epoch: 74, Training Accuracy: 98.9%, Loss: 0.02\n",
            "Epoch: 75, Training Accuracy: 98.82%, Loss: 0.01\n",
            "Epoch: 76, Training Accuracy: 98.9%, Loss: 0.03\n",
            "Epoch: 77, Training Accuracy: 98.62%, Loss: 0.05\n",
            "Epoch: 78, Training Accuracy: 98.78%, Loss: 0.04\n",
            "Epoch: 79, Training Accuracy: 98.98%, Loss: 0.02\n",
            "Epoch: 80, Training Accuracy: 99.31%, Loss: 0.02\n",
            "Epoch: 81, Training Accuracy: 98.98%, Loss: 0.04\n",
            "Epoch: 82, Training Accuracy: 98.82%, Loss: 0.02\n",
            "Epoch: 83, Training Accuracy: 98.7%, Loss: 0.03\n",
            "Epoch: 84, Training Accuracy: 98.54%, Loss: 0.03\n",
            "Epoch: 85, Training Accuracy: 98.94%, Loss: 0.02\n",
            "Epoch: 86, Training Accuracy: 98.98%, Loss: 0.03\n",
            "Epoch: 87, Training Accuracy: 98.98%, Loss: 0.02\n",
            "Epoch: 88, Training Accuracy: 98.94%, Loss: 0.03\n",
            "Epoch: 89, Training Accuracy: 99.35%, Loss: 0.01\n",
            "Epoch: 90, Training Accuracy: 99.19%, Loss: 0.01\n",
            "Epoch: 91, Training Accuracy: 99.27%, Loss: 0.01\n",
            "Epoch: 92, Training Accuracy: 99.23%, Loss: 0.0\n",
            "Epoch: 93, Training Accuracy: 98.58%, Loss: 0.03\n",
            "Epoch: 94, Training Accuracy: 99.03%, Loss: 0.03\n",
            "Epoch: 95, Training Accuracy: 98.86%, Loss: 0.03\n",
            "Epoch: 96, Training Accuracy: 98.82%, Loss: 0.02\n",
            "Epoch: 97, Training Accuracy: 98.82%, Loss: 0.03\n",
            "Epoch: 98, Training Accuracy: 98.54%, Loss: 0.03\n",
            "Epoch: 99, Training Accuracy: 99.19%, Loss: 0.01\n",
            "Epoch: 100, Training Accuracy: 99.15%, Loss: 0.02\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "'/home/rohit.bharadwaj/Projects/forehead/checkpoints/Model_Weights_final.pth'"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "train_acc = []\n",
        "loss_list = []\n",
        "for i in range(opt.max_epoch):\n",
        "    \n",
        "    correct_train = 0\n",
        "    total_train = 0\n",
        "    running_loss = 0.0\n",
        "    model.train()\n",
        "    for ii, data in enumerate(loader):\n",
        "        data_input, label = data\n",
        "        data_input = data_input.to(device)\n",
        "        bs = data_input.shape[0]\n",
        "        label = label.to(device).long()\n",
        "        feature = model(data_input)\n",
        "        output = metric_fc(feature, label)\n",
        "        loss = criterion(output, label)\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        running_loss += (bs * loss.item())\n",
        "        \n",
        "        with torch.no_grad():\n",
        "            output = output.data.cpu().numpy()\n",
        "            output = np.argmax(output, axis = 1)\n",
        "            label = label.data.cpu().numpy()\n",
        "            \n",
        "            total_train += label.shape[0]\n",
        "            correct_train += (output == label).sum().item()\n",
        "            \n",
        "\n",
        "    if i % opt.save_interval == 0 or i == opt.max_epoch:\n",
        "        save_model(model, opt.checkpoints_path, \"Model_Weights\", i)\n",
        "        \n",
        "    \n",
        "    train_acc.append(np.round(100 * correct_train / total_train,2))\n",
        "    print(f\"Epoch: {i+1}, Training Accuracy: {np.round(100 * correct_train / total_train,2)}%, Loss: {np.round(running_loss / total_train,2)}\")\n",
        "    loss_list.append(np.round(running_loss / total_train,2) )\n",
        "    scheduler.step()\n",
        "\n",
        "plt.figure(figsize=(10,6))\n",
        "plt.title(\"Training Accuracy\")\n",
        "plt.xlabel(\"Number of Epochs\")\n",
        "plt.ylabel(\"Accuracy (%)\")\n",
        "\n",
        "plt.annotate(f'Maximum Accuracy\\n at ({np.argmax(train_acc)+1}, {int(max(train_acc))}) ', xy=(np.argmax(train_acc)+1, max(train_acc)), xytext=(np.argmax(train_acc)-10, max(train_acc)-25),\n",
        "             arrowprops=dict(facecolor='black', shrink=0.05),\n",
        "             )\n",
        "plt.annotate(f'Accuracy\\n ({len(train_acc)}, {train_acc[-1]}) ', xy=(len(train_acc), train_acc[-1]), xytext=(len(train_acc)-10, train_acc[-1]-25),\n",
        "             arrowprops=dict(facecolor='blue', shrink=0.05),\n",
        "             )\n",
        "plt.plot(range(1,opt.max_epoch+1), train_acc)\n",
        "plt.savefig(\"train_accuracy.png\")\n",
        "\n",
        "plt.figure(figsize = (10,6))\n",
        "plt.title(\"loss Curve\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.plot(range(1, opt.max_epoch+1), loss_list)\n",
        "plt.savefig(\"loss_curve.png\")\n",
        "\n",
        "\n",
        "import pickle\n",
        "with open(\"loss_data.pkl\", \"wb\") as file:\n",
        "  pickle.dump(loss_list, file)\n",
        "\n",
        "\n",
        "save_model(model, opt.checkpoints_path, \"Model_Weights\", \"final\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-U92iKGmxdRH"
      },
      "source": [
        "# Load Embeddings in Memory"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "kUBlfU-AxU4a"
      },
      "outputs": [],
      "source": [
        "class ImageFolderWithPaths(ImageFolder):\n",
        "    def __getitem__(self, index):\n",
        "        return super(ImageFolderWithPaths, self).__getitem__(index) + (self.imgs[index][0],)\n",
        "\n",
        "\n",
        "\n",
        "def get_dataset_modified(imgs_folder):\n",
        "    if channels != 3:\n",
        "        train_transform = trans.Compose([\n",
        "            trans.Grayscale(num_output_channels=channels),\n",
        "            trans.Resize((img_width, img_height)),\n",
        "            trans.RandomHorizontalFlip(),\n",
        "            trans.ToTensor(),\n",
        "            trans.Normalize((0.5,), (0.5,))\n",
        "        ])\n",
        "    else:\n",
        "        train_transform = trans.Compose([\n",
        "            trans.Resize((img_width, img_height)),\n",
        "            trans.RandomHorizontalFlip(),\n",
        "            trans.ToTensor(),\n",
        "            trans.Normalize((0.5,), (0.5,))\n",
        "        ])\n",
        "    ds = ImageFolderWithPaths(imgs_folder, train_transform)\n",
        "    class_num = ds[-2][1] + 1\n",
        "    return ds, class_num\n",
        "\n",
        "\n",
        "ds3, cnum = get_dataset_modified(\"/home/rohit.bharadwaj/Projects/forehead/Data_Cropped/test\")\n",
        "ds4, cnum2 = get_dataset_modified(\"/home/rohit.bharadwaj/Projects/forehead/Data_Cropped/train\")\n",
        "\n",
        "new_loader = DataLoader(ds3, batch_size = 1)\n",
        "new_loader_train = DataLoader(ds4, batch_size = 1)\n",
        "\n",
        "\n",
        "embedding_dict_test = {}\n",
        "embedding_dict_train = {}\n",
        "with torch.no_grad():\n",
        "    model.eval()\n",
        "    for i, data in enumerate(new_loader, 0):\n",
        "            images, labels, path = data\n",
        "            images = images.to(device)\n",
        "            feature_test = model(images) #512 dimensional embedding\n",
        "            idx1 = path[0].split(\"/\")[-2] \n",
        "            pose1 = path[0].split(\"/\")[-1][:-4]\n",
        "            embedding_dict_test[str(idx1)+\"_\"+str(pose1)] = feature_test.cpu()\n",
        "\n",
        "    for i2, data_train in enumerate(new_loader_train):\n",
        "            images_train, labels_train, path_train = data_train\n",
        "            images_train = images_train.to(device)\n",
        "            feature_train = model(images_train)\n",
        "            idx2 = path_train[0].split(\"/\")[-2] \n",
        "            pose2 = path_train[0].split(\"/\")[-1][:-4]\n",
        "            embedding_dict_train[str(idx2)+\"_\"+str(pose2)] = feature_train.cpu()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "dict_keys(['1_11', '1_12', '1_13', '1_14', '1_15', '1_16', '1_17', '1_18', '1_19', '1_20', '1_21', '1_22', '1_23', '1_24', '1_25', '1_26', '1_27', '1_28', '1_29', '1_30', '10_11', '10_12', '10_13', '10_14', '10_15', '10_16', '10_17', '10_18', '10_19', '10_20', '100_11', '100_12', '100_13', '100_14', '100_15', '100_16', '100_17', '100_18', '100_19', '100_20', '101_11', '101_12', '101_13', '101_14', '101_15', '101_16', '101_17', '101_18', '101_19', '101_20', '102_11', '102_12', '102_13', '102_14', '102_15', '102_16', '102_17', '102_18', '102_19', '102_20', '103_11', '103_12', '103_13', '103_14', '103_15', '103_16', '103_17', '103_18', '103_19', '103_20', '104_11', '104_12', '104_13', '104_14', '104_15', '104_16', '104_17', '104_18', '104_19', '104_20', '105_11', '105_12', '105_13', '105_14', '105_15', '105_16', '105_17', '105_18', '105_19', '105_20', '106_11', '106_12', '106_13', '106_14', '106_15', '106_16', '106_17', '106_18', '106_19', '106_20', '107_11', '107_12', '107_13', '107_14', '107_15', '107_16', '107_17', '107_18', '107_19', '107_20', '108_11', '108_12', '108_13', '108_14', '108_15', '108_16', '108_17', '108_18', '108_19', '108_20', '109_11', '109_12', '109_13', '109_14', '109_15', '109_16', '109_17', '109_18', '109_19', '109_20', '11_11', '11_12', '11_13', '11_14', '11_15', '11_16', '11_17', '11_18', '11_19', '11_20', '110_11', '110_12', '110_13', '110_14', '110_15', '110_16', '110_17', '110_18', '110_19', '110_20', '111_11', '111_12', '111_13', '111_14', '111_15', '111_16', '111_17', '111_18', '111_19', '111_20', '112_11', '112_12', '112_13', '112_14', '112_15', '112_16', '112_17', '112_18', '112_19', '112_20', '113_11', '113_12', '113_13', '113_14', '113_15', '113_16', '113_17', '113_18', '113_19', '113_20', '114_11', '114_12', '114_13', '114_14', '114_15', '114_16', '114_17', '114_18', '114_19', '114_20', '115_11', '115_12', '115_13', '115_14', '115_15', '115_16', '115_17', '115_18', '115_19', '115_20', '116_11', '116_12', '116_13', '116_14', '116_15', '116_16', '116_17', '116_18', '116_19', '116_20', '117_11', '117_12', '117_13', '117_14', '117_15', '117_16', '117_17', '117_18', '117_19', '117_20', '118_11', '118_12', '118_13', '118_14', '118_15', '118_16', '118_17', '118_18', '118_19', '118_20', '119_11', '119_12', '119_13', '119_14', '119_15', '119_16', '119_17', '119_18', '119_19', '119_20', '12_11', '12_12', '12_13', '12_14', '12_15', '12_16', '12_17', '12_18', '12_19', '12_20', '120_11', '120_12', '120_13', '120_14', '120_15', '120_16', '120_17', '120_18', '120_19', '120_20', '121_11', '121_12', '121_13', '121_14', '121_15', '121_16', '121_17', '121_18', '121_19', '121_20', '122_11', '122_12', '122_13', '122_14', '122_15', '122_16', '122_17', '122_18', '122_19', '122_20', '123_11', '123_12', '123_13', '123_14', '123_15', '123_16', '123_17', '123_18', '123_19', '123_20', '124_11', '124_12', '124_13', '124_14', '124_15', '124_16', '124_17', '124_18', '124_19', '124_20', '125_11', '125_12', '125_13', '125_14', '125_15', '125_16', '125_17', '125_18', '125_19', '125_20', '126_11', '126_12', '126_13', '126_14', '126_15', '126_16', '126_17', '126_18', '126_19', '126_20', '127_11', '127_12', '127_13', '127_14', '127_15', '127_16', '127_17', '127_18', '127_19', '127_20', '128_11', '128_12', '128_13', '128_14', '128_15', '128_16', '128_17', '128_18', '128_19', '128_20', '129_11', '129_12', '129_13', '129_14', '129_15', '129_16', '129_17', '129_18', '129_19', '129_20', '13_11', '13_12', '13_13', '13_14', '13_15', '13_16', '13_17', '13_18', '13_19', '13_20', '130_11', '130_12', '130_13', '130_14', '130_15', '130_16', '130_17', '130_18', '130_19', '130_20', '130_21', '130_22', '130_23', '130_24', '130_25', '130_26', '130_27', '130_28', '130_29', '130_30', '131_11', '131_12', '131_13', '131_14', '131_15', '131_16', '131_17', '131_18', '131_19', '131_20', '132_11', '132_12', '132_13', '132_14', '132_15', '132_16', '132_17', '132_18', '132_19', '132_20', '133_11', '133_12', '133_13', '133_14', '133_15', '133_16', '133_17', '133_18', '133_19', '133_20', '134_11', '134_12', '134_13', '134_14', '134_15', '134_16', '134_17', '134_18', '134_19', '134_20', '135_11', '135_12', '135_13', '135_14', '135_15', '135_16', '135_17', '135_18', '135_19', '135_20', '136_11', '136_12', '136_13', '136_14', '136_15', '136_16', '136_17', '136_18', '136_19', '136_20', '137_11', '137_12', '137_13', '137_14', '137_15', '137_16', '137_17', '137_18', '137_19', '137_20', '138_11', '138_12', '138_13', '138_14', '138_15', '138_16', '138_17', '138_18', '138_19', '138_20', '139_11', '139_12', '139_13', '139_14', '139_15', '139_16', '139_17', '139_18', '139_19', '139_20', '14_11', '14_12', '14_13', '14_14', '14_15', '14_16', '14_17', '14_18', '14_19', '14_20', '140_11', '140_12', '140_13', '140_14', '140_15', '140_16', '140_17', '140_18', '140_19', '140_20', '141_11', '141_12', '141_13', '141_14', '141_15', '141_16', '141_17', '141_18', '141_19', '141_20', '142_11', '142_12', '142_13', '142_14', '142_15', '142_16', '142_17', '142_18', '142_19', '142_20', '143_11', '143_12', '143_13', '143_14', '143_15', '143_16', '143_17', '143_18', '143_19', '143_20', '144_11', '144_12', '144_13', '144_14', '144_15', '144_16', '144_17', '144_18', '144_19', '144_20', '145_11', '145_12', '145_13', '145_14', '145_15', '145_16', '145_17', '145_18', '145_19', '145_20', '146_11', '146_12', '146_13', '146_14', '146_15', '146_16', '146_17', '146_18', '146_19', '146_20', '147_11', '147_12', '147_13', '147_14', '147_15', '147_16', '147_17', '147_18', '147_19', '147_20', '148_11', '148_12', '148_13', '148_14', '148_15', '148_16', '148_17', '148_18', '148_19', '148_20', '149_11', '149_12', '149_13', '149_14', '149_15', '149_16', '149_17', '149_18', '149_19', '149_20', '15_11', '15_12', '15_13', '15_14', '15_15', '15_16', '15_17', '15_18', '15_19', '15_20', '150_11', '150_12', '150_13', '150_14', '150_15', '150_16', '150_17', '150_18', '150_19', '150_20', '151_11', '151_12', '151_13', '151_14', '151_15', '151_16', '151_17', '151_18', '151_19', '151_20', '152_11', '152_12', '152_13', '152_14', '152_15', '152_16', '152_17', '152_18', '152_19', '152_20', '153_11', '153_12', '153_13', '153_14', '153_15', '153_16', '153_17', '153_18', '153_19', '153_20', '154_11', '154_12', '154_13', '154_14', '154_15', '154_16', '154_17', '154_18', '154_19', '154_20', '155_11', '155_12', '155_13', '155_14', '155_15', '155_16', '155_17', '155_18', '155_19', '155_20', '156_11', '156_12', '156_13', '156_14', '156_15', '156_16', '156_17', '156_18', '156_19', '156_20', '157_11', '157_12', '157_13', '157_14', '157_15', '157_16', '157_17', '157_18', '157_19', '157_20', '158_11', '158_12', '158_13', '158_14', '158_15', '158_16', '158_17', '158_18', '158_19', '158_20', '159_11', '159_12', '159_13', '159_14', '159_15', '159_16', '159_17', '159_18', '159_19', '159_20', '16_11', '16_12', '16_13', '16_14', '16_15', '16_16', '16_17', '16_18', '16_19', '16_20', '160_11', '160_12', '160_13', '160_14', '160_15', '160_16', '160_17', '160_18', '160_19', '160_20', '161_11', '161_12', '161_13', '161_14', '161_15', '161_16', '161_17', '161_18', '161_19', '161_20', '162_11', '162_12', '162_13', '162_14', '162_15', '162_16', '162_17', '162_18', '162_19', '162_20', '163_11', '163_12', '163_13', '163_14', '163_15', '163_16', '163_17', '163_18', '163_19', '163_20', '164_11', '164_12', '164_13', '164_14', '164_15', '164_16', '164_17', '164_18', '164_19', '164_20', '165_11', '165_12', '165_13', '165_14', '165_15', '165_16', '165_17', '165_18', '165_19', '165_20', '166_11', '166_12', '166_13', '166_14', '166_15', '166_16', '166_17', '166_18', '166_19', '166_20', '167_11', '167_12', '167_13', '167_14', '167_15', '167_16', '167_17', '167_18', '167_19', '167_20', '168_11', '168_12', '168_13', '168_14', '168_15', '168_16', '168_17', '168_18', '168_19', '168_20', '169_11', '169_12', '169_13', '169_14', '169_15', '169_16', '169_17', '169_18', '169_19', '169_20', '17_11', '17_12', '17_13', '17_14', '17_15', '17_16', '17_17', '17_18', '17_19', '17_20', '170_11', '170_12', '170_13', '170_14', '170_15', '170_16', '170_17', '170_18', '170_19', '170_20', '171_11', '171_12', '171_13', '171_14', '171_15', '171_16', '171_17', '171_18', '171_19', '171_20', '172_11', '172_12', '172_13', '172_14', '172_15', '172_16', '172_17', '172_18', '172_19', '172_20', '173_11', '173_12', '173_13', '173_14', '173_15', '173_16', '173_17', '173_18', '173_19', '173_20', '174_11', '174_12', '174_13', '174_14', '174_15', '174_16', '174_17', '174_18', '174_19', '174_20', '175_11', '175_12', '175_13', '175_14', '175_15', '175_16', '175_17', '175_18', '175_19', '175_20', '176_11', '176_12', '176_13', '176_14', '176_15', '176_16', '176_17', '176_18', '176_19', '176_20', '177_11', '177_12', '177_13', '177_14', '177_15', '177_16', '177_17', '177_18', '177_19', '177_20', '178_11', '178_12', '178_13', '178_14', '178_15', '178_16', '178_17', '178_18', '178_19', '178_20', '179_11', '179_12', '179_13', '179_14', '179_15', '179_16', '179_17', '179_18', '179_19', '179_20', '18_11', '18_12', '18_13', '18_14', '18_15', '18_16', '18_17', '18_18', '18_19', '18_20', '180_11', '180_12', '180_13', '180_14', '180_15', '180_16', '180_17', '180_18', '180_19', '180_20', '181_11', '181_12', '181_13', '181_14', '181_15', '181_16', '181_17', '181_18', '181_19', '181_20', '182_11', '182_12', '182_13', '182_14', '182_15', '182_16', '182_17', '182_18', '182_19', '182_20', '183_11', '183_12', '183_13', '183_14', '183_15', '183_16', '183_17', '183_18', '183_19', '183_20', '184_11', '184_12', '184_13', '184_14', '184_15', '184_16', '184_17', '184_18', '184_19', '184_20', '185_11', '185_12', '185_13', '185_14', '185_15', '185_16', '185_17', '185_18', '185_19', '185_20', '186_11', '186_12', '186_13', '186_14', '186_15', '186_16', '186_17', '186_18', '186_19', '186_20', '187_11', '187_12', '187_13', '187_14', '187_15', '187_16', '187_17', '187_18', '187_19', '187_20', '188_11', '188_12', '188_13', '188_14', '188_15', '188_16', '188_17', '188_18', '188_19', '188_20', '189_11', '189_12', '189_13', '189_14', '189_15', '189_16', '189_17', '189_18', '189_19', '189_20', '19_11', '19_12', '19_13', '19_14', '19_15', '19_16', '19_17', '19_18', '19_19', '19_20', '190_11', '190_12', '190_13', '190_14', '190_15', '190_16', '190_17', '190_18', '190_19', '190_20', '191_11', '191_12', '191_13', '191_14', '191_15', '191_16', '191_17', '191_18', '191_19', '191_20', '192_11', '192_12', '192_13', '192_14', '192_15', '192_16', '192_17', '192_18', '192_19', '192_20', '193_11', '193_12', '193_13', '193_14', '193_15', '193_16', '193_17', '193_18', '193_19', '194_11', '194_12', '194_13', '194_14', '194_15', '194_16', '194_17', '194_18', '194_19', '194_20', '195_11', '195_12', '195_13', '195_14', '195_15', '195_16', '195_17', '195_18', '195_19', '195_20', '196_11', '196_12', '196_13', '196_14', '196_15', '196_16', '196_17', '196_18', '196_19', '196_20', '197_11', '197_12', '197_13', '197_14', '197_15', '197_16', '197_17', '197_18', '197_19', '197_20', '198_11', '198_12', '198_13', '198_14', '198_15', '198_16', '198_17', '198_18', '198_19', '198_20', '199_11', '199_12', '199_13', '199_14', '199_15', '199_16', '199_17', '199_18', '199_19', '199_20', '2_11', '2_12', '2_13', '2_14', '2_15', '2_16', '2_17', '2_18', '2_19', '2_20', '20_11', '20_12', '20_13', '20_14', '20_15', '20_16', '20_17', '20_18', '20_19', '20_20', '200_11', '200_12', '200_13', '200_14', '200_15', '200_16', '200_17', '200_18', '200_19', '200_20', '201_11', '201_12', '201_13', '201_14', '201_15', '201_16', '201_17', '201_18', '201_19', '201_20', '202_11', '202_12', '202_13', '202_14', '202_15', '202_16', '202_17', '202_18', '202_19', '202_20', '203_11', '203_12', '203_13', '203_14', '203_15', '203_16', '203_17', '203_18', '203_19', '203_20', '204_11', '204_12', '204_13', '204_14', '204_15', '204_16', '204_17', '204_18', '204_19', '204_20', '205_11', '205_12', '205_13', '205_14', '205_15', '205_16', '205_17', '205_18', '205_19', '205_20', '206_11', '206_12', '206_13', '206_14', '206_15', '206_16', '206_17', '206_18', '206_19', '206_20', '207_11', '207_12', '207_13', '207_14', '207_15', '207_16', '207_17', '207_18', '207_19', '207_20', '208_11', '208_12', '208_13', '208_14', '208_15', '208_16', '208_17', '208_18', '208_19', '208_20', '209_11', '209_12', '209_13', '209_14', '209_15', '209_16', '209_17', '209_18', '209_19', '209_20', '21_11', '21_12', '21_13', '21_14', '21_15', '21_16', '21_17', '21_18', '21_19', '21_20', '210_11', '210_12', '210_13', '210_14', '210_15', '210_16', '210_17', '210_18', '210_19', '210_20', '211_11', '211_12', '211_13', '211_14', '211_15', '211_16', '211_17', '211_18', '211_19', '212_11', '212_12', '212_13', '212_14', '213_11', '213_12', '213_13', '213_14', '213_15', '213_16', '213_17', '213_18', '213_19', '213_20', '214_11', '214_12', '214_13', '214_14', '214_15', '214_16', '214_17', '214_18', '214_19', '214_20', '215_11', '215_12', '215_13', '215_14', '215_15', '215_16', '215_17', '215_18', '215_19', '215_20', '216_11', '216_12', '216_13', '216_14', '216_15', '216_16', '216_17', '216_18', '216_19', '216_20', '217_11', '217_12', '217_13', '217_14', '217_15', '217_16', '217_17', '217_18', '217_19', '217_20', '218_11', '218_12', '218_13', '218_14', '218_15', '218_16', '218_17', '218_18', '218_19', '218_20', '219_11', '219_12', '219_13', '219_14', '219_15', '219_16', '219_17', '219_18', '219_19', '219_20', '22_11', '22_12', '22_13', '22_14', '22_15', '22_16', '22_17', '22_18', '22_19', '22_20', '22_21', '22_22', '22_23', '22_24', '22_25', '22_26', '22_27', '22_28', '22_29', '22_30', '220_11', '220_12', '220_13', '220_14', '220_15', '220_16', '220_17', '220_18', '220_19', '220_20', '221_11', '221_12', '221_13', '221_14', '221_15', '221_16', '221_17', '221_18', '221_19', '221_20', '222_11', '222_12', '222_13', '222_14', '222_15', '222_16', '222_17', '222_18', '222_19', '222_20', '223_11', '223_12', '223_13', '223_14', '223_15', '223_16', '223_17', '223_18', '223_19', '223_20', '224_11', '224_12', '224_13', '224_14', '224_15', '224_16', '224_17', '224_18', '224_19', '224_20', '225_11', '225_12', '225_13', '225_14', '225_15', '225_16', '225_17', '225_18', '225_19', '225_20', '226_11', '226_12', '226_13', '226_14', '226_15', '226_16', '226_17', '226_18', '226_19', '226_20', '227_11', '227_12', '227_13', '227_14', '227_15', '227_16', '227_17', '227_18', '227_19', '227_20', '228_11', '228_12', '228_13', '228_14', '228_15', '228_16', '228_17', '228_18', '228_19', '228_20', '229_11', '229_12', '229_13', '229_14', '229_15', '229_16', '229_17', '229_18', '229_19', '229_20', '23_11', '23_12', '23_13', '23_14', '23_15', '23_16', '23_17', '23_18', '23_19', '23_20', '230_11', '230_12', '230_13', '230_14', '230_15', '230_16', '230_17', '230_18', '230_19', '230_20', '231_11', '231_12', '231_13', '231_14', '231_15', '231_16', '231_17', '231_18', '231_19', '231_20', '232_11', '232_12', '232_13', '232_14', '232_15', '232_16', '232_17', '232_18', '232_19', '232_20', '233_11', '233_12', '233_13', '233_14', '233_15', '233_16', '233_17', '233_18', '233_19', '233_20', '234_11', '234_12', '234_13', '234_14', '234_15', '234_16', '234_17', '234_18', '234_19', '234_20', '235_11', '235_12', '235_13', '235_14', '235_15', '235_16', '235_17', '235_18', '235_19', '235_20', '236_11', '236_12', '236_13', '236_14', '236_15', '236_16', '236_17', '236_18', '236_19', '236_20', '237_11', '237_12', '237_13', '237_14', '237_15', '237_16', '237_17', '237_18', '237_19', '237_20', '238_11', '238_12', '238_13', '238_14', '238_15', '238_16', '238_17', '238_18', '238_19', '238_20', '239_11', '239_12', '239_13', '239_14', '239_15', '239_16', '239_17', '239_18', '239_19', '239_20', '24_11', '24_12', '24_13', '24_14', '24_15', '24_16', '24_17', '24_18', '24_19', '24_20', '240_11', '240_12', '240_13', '240_14', '240_15', '240_16', '240_17', '240_18', '240_19', '240_20', '241_11', '241_12', '241_13', '241_14', '241_15', '241_16', '241_17', '241_18', '241_19', '241_20', '242_11', '242_12', '242_13', '242_14', '242_15', '242_16', '242_17', '242_18', '242_19', '242_20', '243_11', '243_12', '243_13', '243_14', '243_15', '243_16', '243_17', '243_18', '243_19', '243_20', '244_11', '244_12', '244_13', '244_14', '244_15', '244_16', '244_17', '244_18', '244_19', '244_20', '245_11', '245_12', '245_13', '245_14', '245_15', '245_16', '245_17', '245_18', '245_19', '245_20', '246_11', '246_12', '246_13', '246_14', '246_15', '246_16', '246_17', '246_18', '246_19', '246_20', '247_11', '247_12', '247_13', '247_14', '247_15', '247_16', '247_17', '247_18', '247_19', '247_20', '25_11', '25_12', '25_13', '25_14', '25_15', '25_16', '25_17', '25_18', '25_19', '25_20', '26_11', '26_12', '26_13', '26_14', '26_15', '26_16', '26_17', '26_18', '26_19', '26_20', '27_11', '27_12', '27_13', '27_14', '27_15', '27_16', '27_17', '27_18', '27_19', '27_20', '28_11', '28_12', '28_13', '28_14', '28_15', '28_16', '28_17', '28_18', '28_19', '28_20', '29_11', '29_12', '29_13', '29_14', '29_15', '29_16', '29_17', '29_18', '29_19', '29_20', '3_11', '3_12', '3_13', '3_14', '3_15', '3_16', '3_17', '3_18', '3_19', '3_20', '30_11', '30_12', '30_13', '30_14', '30_15', '30_16', '30_17', '30_18', '30_19', '30_20', '31_11', '31_12', '31_13', '31_14', '31_15', '31_16', '31_17', '31_18', '31_19', '31_20', '32_11', '32_12', '32_13', '32_14', '32_15', '32_16', '32_17', '32_18', '32_19', '32_20', '33_11', '33_12', '33_13', '33_14', '33_15', '33_16', '33_17', '33_18', '33_19', '33_20', '34_11', '34_12', '34_13', '34_14', '34_15', '34_16', '34_17', '34_18', '34_19', '34_20', '35_11', '35_12', '35_13', '35_14', '35_15', '35_16', '35_17', '35_18', '35_19', '35_20', '36_11', '36_12', '36_13', '36_14', '36_15', '36_16', '36_17', '36_18', '36_19', '36_20', '37_11', '37_12', '37_13', '37_14', '37_15', '37_16', '37_17', '37_18', '37_19', '37_20', '38_11', '38_12', '38_13', '38_14', '38_15', '38_16', '38_17', '38_18', '38_19', '38_20', '39_11', '39_12', '39_13', '39_14', '39_15', '39_16', '39_17', '39_18', '39_19', '39_20', '4_11', '4_12', '4_13', '4_14', '4_15', '4_16', '4_17', '4_18', '4_19', '4_20', '4_21', '4_22', '4_23', '4_24', '4_25', '4_26', '4_27', '4_28', '4_29', '4_30', '40_11', '40_12', '40_13', '40_14', '40_15', '40_16', '40_17', '40_18', '40_19', '40_20', '41_11', '41_12', '41_13', '41_14', '41_15', '41_16', '41_17', '41_18', '41_19', '41_20', '42_11', '42_12', '42_13', '42_14', '42_15', '42_16', '42_17', '42_18', '42_19', '42_20', '43_11', '43_12', '43_13', '43_14', '43_15', '43_16', '43_17', '43_18', '43_19', '43_20', '44_11', '44_12', '44_13', '44_14', '44_15', '44_16', '44_17', '44_18', '44_19', '44_20', '45_11', '45_12', '45_13', '45_14', '45_15', '45_16', '45_17', '45_18', '45_19', '45_20', '46_11', '46_12', '46_13', '46_14', '46_15', '46_16', '46_17', '46_18', '46_19', '46_20', '47_11', '47_12', '47_13', '47_14', '47_15', '47_16', '47_17', '47_18', '47_19', '47_20', '48_11', '48_12', '48_13', '48_14', '48_15', '48_16', '48_17', '48_18', '48_19', '48_20', '49_11', '49_12', '49_13', '49_14', '49_15', '49_16', '49_17', '49_18', '49_19', '49_20', '5_11', '5_12', '5_13', '5_14', '5_15', '5_16', '5_17', '5_18', '5_19', '5_20', '50_11', '50_12', '50_13', '50_14', '50_15', '50_16', '50_17', '50_18', '50_19', '50_20', '51_11', '51_12', '51_13', '51_14', '51_15', '51_16', '51_17', '51_18', '51_19', '51_20', '52_11', '52_12', '52_13', '52_14', '52_15', '52_16', '52_17', '52_18', '52_19', '52_20', '53_11', '53_12', '53_13', '53_14', '53_15', '53_16', '53_17', '53_18', '53_19', '53_20', '54_11', '54_12', '54_13', '54_14', '54_15', '54_16', '54_17', '54_18', '54_19', '54_20', '55_11', '55_12', '55_13', '55_14', '55_15', '55_16', '55_17', '55_18', '55_19', '55_20', '56_11', '56_12', '56_13', '56_14', '56_15', '56_16', '56_17', '56_18', '56_19', '56_20', '57_11', '57_12', '57_13', '57_14', '57_15', '57_16', '57_17', '57_18', '57_19', '57_20', '58_11', '58_12', '58_13', '58_14', '58_15', '58_16', '58_17', '58_18', '58_19', '58_20', '59_11', '59_12', '59_13', '59_14', '59_15', '59_16', '59_17', '59_18', '59_19', '59_20', '6_11', '6_12', '6_13', '6_14', '6_15', '6_16', '6_17', '6_18', '6_19', '6_20', '60_11', '60_12', '60_13', '60_14', '60_15', '60_16', '60_17', '60_18', '60_19', '60_20', '61_11', '61_12', '61_13', '61_14', '61_15', '61_16', '61_17', '61_18', '61_19', '61_20', '62_11', '62_12', '62_13', '62_14', '62_15', '62_16', '62_17', '62_18', '62_19', '62_20', '63_11', '63_12', '63_13', '63_14', '63_15', '63_16', '63_17', '63_18', '63_19', '63_20', '64_11', '64_12', '64_13', '64_14', '64_15', '64_16', '64_17', '64_18', '64_19', '64_20', '65_11', '65_12', '65_13', '65_14', '65_15', '65_16', '65_17', '65_18', '65_19', '65_20', '66_11', '66_12', '66_13', '66_14', '66_15', '66_16', '66_17', '66_18', '66_19', '66_20', '67_11', '67_12', '67_13', '67_14', '67_15', '67_16', '67_17', '67_18', '67_19', '67_20', '68_11', '68_12', '68_13', '68_14', '68_15', '68_16', '68_17', '68_18', '68_19', '68_20', '69_11', '69_12', '69_13', '69_14', '69_15', '69_16', '69_17', '69_18', '69_19', '69_20', '7_11', '7_12', '7_13', '7_14', '7_15', '7_16', '7_17', '7_18', '7_19', '7_20', '70_11', '70_12', '70_13', '70_14', '70_15', '70_16', '70_17', '70_18', '70_19', '70_20', '71_11', '71_12', '71_13', '71_14', '71_15', '71_16', '71_17', '71_18', '71_19', '71_20', '72_11', '72_12', '72_13', '72_14', '72_15', '72_16', '72_17', '72_18', '72_19', '72_20', '73_11', '73_12', '73_13', '73_14', '73_15', '73_16', '73_17', '73_18', '73_19', '73_20', '74_11', '74_12', '74_13', '74_14', '74_15', '74_16', '74_17', '74_18', '74_19', '74_20', '75_11', '75_12', '75_13', '75_14', '75_15', '75_16', '75_17', '75_18', '75_19', '75_20', '76_11', '76_12', '76_13', '76_14', '76_15', '76_16', '76_17', '76_18', '76_19', '76_20', '77_11', '77_12', '77_13', '77_14', '77_15', '77_16', '77_17', '77_18', '77_19', '77_20', '78_11', '78_12', '78_13', '78_14', '78_15', '78_16', '78_17', '78_18', '78_19', '78_20', '79_11', '79_12', '79_13', '79_14', '79_15', '79_16', '79_17', '79_18', '79_19', '79_20', '8_11', '8_12', '8_13', '8_14', '8_15', '8_16', '8_17', '8_18', '8_19', '8_20', '80_11', '80_12', '80_13', '80_14', '80_15', '80_16', '80_17', '80_18', '80_19', '80_20', '81_11', '81_12', '81_13', '81_14', '81_15', '81_16', '81_17', '81_18', '81_19', '81_20', '82_11', '82_12', '82_13', '82_14', '82_15', '82_16', '82_17', '82_18', '82_19', '82_20', '83_11', '83_12', '83_13', '83_14', '83_15', '83_16', '83_17', '83_18', '83_19', '83_20', '84_11', '84_12', '84_13', '84_14', '84_15', '84_16', '84_17', '84_18', '84_19', '84_20', '85_11', '85_12', '85_13', '85_14', '85_15', '85_16', '85_17', '85_18', '85_19', '85_20', '86_11', '86_12', '86_13', '86_14', '86_15', '86_16', '86_17', '86_18', '86_19', '86_20', '87_11', '87_12', '87_13', '87_14', '87_15', '87_16', '87_17', '87_18', '87_19', '87_20', '88_11', '88_12', '88_13', '88_14', '88_15', '88_16', '88_17', '88_18', '88_19', '88_20', '89_11', '89_12', '89_13', '89_14', '89_15', '89_16', '89_17', '89_18', '89_19', '89_20', '9_11', '9_12', '9_13', '9_14', '9_15', '9_16', '9_17', '9_18', '9_19', '9_20', '90_11', '90_12', '90_13', '90_14', '90_15', '90_16', '90_17', '90_18', '90_19', '90_20', '91_11', '91_12', '91_13', '91_14', '91_15', '91_16', '91_17', '91_18', '91_19', '91_20', '92_11', '92_12', '92_13', '92_14', '92_15', '92_16', '92_17', '92_18', '92_19', '92_20', '93_11', '93_12', '93_13', '93_14', '93_15', '93_16', '93_17', '93_18', '93_19', '93_20', '94_11', '94_12', '94_13', '94_14', '94_15', '94_16', '94_17', '94_18', '94_19', '94_20', '95_11', '95_12', '95_13', '95_14', '95_15', '95_16', '95_17', '95_18', '95_19', '95_20', '96_11', '96_12', '96_13', '96_14', '96_15', '96_16', '96_17', '96_18', '96_19', '96_20', '97_11', '97_12', '97_13', '97_14', '97_15', '97_16', '97_17', '97_18', '97_19', '97_20', '98_11', '98_12', '98_13', '98_14', '98_15', '98_16', '98_17', '98_18', '98_19', '98_20', '99_11', '99_12', '99_13', '99_14', '99_15', '99_16', '99_17', '99_18', '99_19', '99_20'])"
            ]
          },
          "execution_count": 39,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "embedding_dict_test.keys()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2502"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(embedding_dict_test.keys())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2462"
            ]
          },
          "execution_count": 37,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(embedding_dict_train.keys())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BHmHQO-LyCby"
      },
      "source": [
        "#Create Matching Score File"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W3zly_NbyCD6"
      },
      "outputs": [],
      "source": [
        "for k_test,v_test in embedding_dict_test.items():\n",
        "  myKList = k_test.split(\"_\")\n",
        "  idx1 = myKList[0]\n",
        "  pose1 = myKList[1]\n",
        "  for k_train,v_train in embedding_dict_train.items():\n",
        "    myKList2 = k_train.split(\"_\")\n",
        "    idx2 = myKList2[0]\n",
        "    pose2 = myKList2[1]\n",
        "    if idx1 == idx2:\n",
        "      isGen = 1\n",
        "    else:\n",
        "      isGen = 0\n",
        "    with open(\"scores.txt\", \"a\") as file:\n",
        "      file.write(str(idx1) + \"\\t\" + str(pose1) + \"\\t\" + str(idx2) + \"\\t\" + str(pose2) + \"\\t\" + str(isGen) + \"\\t\" + str(torch.dist(v_test, v_train, p = 2).item()) + \"\\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fEOjL6rJykm7"
      },
      "source": [
        "# Once the Score file is created, you can compute standard biometric results like CRR, EER, DI, etc."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O8hOjdoxyvQx"
      },
      "source": [
        "# Android and Network Code written by Rohit K Bharadwaj.\n",
        "## Follow me on:\n",
        "### Twitter: https://twitter.com/rohit901\n",
        "### Github: https://github.com/rohit901\n",
        "### LinkedIn: https://www.linkedin.com/in/rohit901/\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [],
      "name": "Main_Network_Code.ipynb",
      "provenance": []
    },
    "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.11.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}