person_reid.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "person_reid.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "cvC-yUPIVrzl",
        "Cgx9IhNbVY4f",
        "MnfB5FeIV7H0",
        "217qDx8QWbDX",
        "cA3-twA9dZKb",
        "wcbDx2_-VwHQ",
        "pkyDoVXrsUF0",
        "L7K_dd6PUvqy",
        "ndMdX8bBVhmp",
        "q9QGv9w4V5kY",
        "yzEoO85MWexR",
        "4gIwqpLAXQ_p",
        "6sKzI1Sctg6-",
        "5VrITMEkkdAw",
        "CR1fzqbNsAb4",
        "W05gC2xhtAFH",
        "mNjqYgJXtM_A",
        "OjLFxBeitS-I",
        "z8qTSnRytXg3",
        "VCQtsPSjtdvl",
        "8-CLi5Mk567l",
        "xq12FDTLgNoD"
      ],
      "authorship_tag": "ABX9TyM5aG069SmYU/hg7QtCvZpa",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/haonguyenuet/person_reid/blob/master/person_reid.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YXTn5U-mULeR"
      },
      "source": [
        "import torch\n",
        "from torch.utils.data import DataLoader\n",
        "from torch.nn import functional as F\n",
        "from torch import nn\n",
        "\n",
        "import torchvision.transforms as T\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "from PIL import Image\n",
        "\n",
        "from collections import namedtuple\n",
        "\n",
        "import os\n",
        "import os.path as osp\n",
        "import tarfile\n",
        "import zipfile\n",
        "import re\n",
        "import glob\n",
        "import urllib\n",
        "import sys\n",
        "import warnings\n",
        "import errno\n",
        "import unittest"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cvC-yUPIVrzl"
      },
      "source": [
        "# Utils"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "461YxxkXVwe_"
      },
      "source": [
        "def mkdir_if_missing(dirname):\n",
        "    \"\"\"Creates dirname if it is missing.\"\"\"\n",
        "    if not osp.exists(dirname):\n",
        "        try:\n",
        "            os.makedirs(dirname)\n",
        "        except OSError as e:\n",
        "            if e.errno != errno.EEXIST:\n",
        "                raise\n",
        "\n",
        "\n",
        "def isfile(fpath):\n",
        "    isfile = osp.isfile(fpath)\n",
        "    if not isfile:\n",
        "        warnings.warn('No file found at \"{}\"'.format(fpath))\n",
        "    return isfile\n",
        "\n",
        "def read_image(path):\n",
        "    got_img = False\n",
        "    if not osp.exists(path):\n",
        "        raise IOError('\"{}\" does not exist'.format(path))\n",
        "    while not got_img:\n",
        "        try:\n",
        "            img = Image.open(path).convert('RGB')\n",
        "            got_img = True\n",
        "        except IOError:\n",
        "            print(\n",
        "                'IOError incurred when reading \"{}\". Will redo. Don\\'t worry. Just chill.'\n",
        "                .format(path)\n",
        "            )\n",
        "    return img\n",
        "\n",
        "def download_url(url, dst):\n",
        "    \"\"\"Downloads file from a url to a destination.\n",
        "    Args:\n",
        "        url (str): url to download file.\n",
        "        dst (str): destination path.\n",
        "    \"\"\"\n",
        "    print('* url=\"{}\"'.format(url))\n",
        "    print('* destination=\"{}\"'.format(dst))\n",
        "\n",
        "    def _reporthook(count, block_size, total_size):\n",
        "        progress_size = int(count * block_size)\n",
        "        percent = int(progress_size * 100 / total_size)\n",
        "        sys.stdout.write(\n",
        "            '\\r...%d%%, %d MB' %\n",
        "            (percent, progress_size / (1024*1024))\n",
        "        )\n",
        "        sys.stdout.flush()\n",
        "\n",
        "    urllib.request.urlretrieve(url, dst, _reporthook)\n",
        "    sys.stdout.write('\\n')"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oecIPOoBfUJY"
      },
      "source": [
        ""
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cgx9IhNbVY4f"
      },
      "source": [
        "#Prepare Data ✔"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MnfB5FeIV7H0"
      },
      "source": [
        "### ImageDataset\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ETLrGNcV-09"
      },
      "source": [
        "class ImageDataset(object):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "        train (list): contains tuples of (img_path(s), pid, camid).\n",
        "        query (list): contains tuples of (img_path(s), pid, camid).\n",
        "        gallery (list): contains tuples of (img_path(s), pid, camid).\n",
        "        transform: transform function.\n",
        "        mode (str): 'train', 'query' or 'gallery'.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(\n",
        "        self,\n",
        "        train,\n",
        "        query,\n",
        "        gallery,\n",
        "        mode='train',\n",
        "        transform=None,\n",
        "    ):\n",
        "        # adding a dataset indicator \"dsetid\"\n",
        "        # (img_path(s), pid, camid) ==> (img_path(s), pid, camid, dsetid)\n",
        "\n",
        "        if len(train[0]) == 3:\n",
        "            train = [(*items, 0) for items in train]\n",
        "        if len(query[0]) == 3:\n",
        "            query = [(*items, 0) for items in query]\n",
        "        if len(gallery[0]) == 3:\n",
        "            gallery = [(*items, 0) for items in gallery]\n",
        "\n",
        "        self.train = train\n",
        "        self.query = query\n",
        "        self.gallery = gallery\n",
        "        self.transform = transform\n",
        "        self.mode = mode\n",
        "\n",
        "        self.num_train_pids = self.get_num_pids(self.train)\n",
        "        self.num_train_cams = self.get_num_cams(self.train)\n",
        "\n",
        "        if self.mode == 'train':\n",
        "            self.data = self.train\n",
        "        elif self.mode == 'query':\n",
        "            self.data = self.query\n",
        "        elif self.mode == 'gallery':\n",
        "            self.data = self.gallery\n",
        "        else:\n",
        "            raise ValueError(\n",
        "                'Invalid mode. Got {}, but expected to be '\n",
        "                'one of [train | query | gallery]'.format(self.mode)\n",
        "            )\n",
        "    \n",
        "    def __getitem__(self, index):\n",
        "        img_path, pid, camid, dsetid = self.data[index]\n",
        "        img = read_image(img_path)\n",
        "        if self.transform is not None:\n",
        "            img = self.transform(img)\n",
        "        item = {\n",
        "            'img': img,\n",
        "            'pid': pid,\n",
        "            'camid': camid,\n",
        "            'impath': img_path,\n",
        "            'dsetid': dsetid\n",
        "        }\n",
        "        return item\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data)\n",
        "    \n",
        "    def get_num_pids(self, data):\n",
        "        pids = set()\n",
        "        for items in data:\n",
        "            pid = items[1]\n",
        "            pids.add(pid)\n",
        "        return len(pids)\n",
        "\n",
        "    def get_num_cams(self, data):\n",
        "        cams = set()\n",
        "        for items in data:\n",
        "            camid = items[2]\n",
        "            cams.add(camid)\n",
        "        return len(cams)\n",
        "\n",
        "    def download_dataset(self, dataset_dir, dataset_url):\n",
        "        if osp.exists(dataset_dir):\n",
        "            return\n",
        "\n",
        "        print('Creating directory \"{}\"'.format(dataset_dir))\n",
        "        mkdir_if_missing(dataset_dir)\n",
        "        fpath = osp.join(dataset_dir, osp.basename(dataset_url))\n",
        "\n",
        "        download_url(dataset_url, fpath)\n",
        "        print('Extracting \"{}\"'.format(fpath))\n",
        "        try:\n",
        "            tar = tarfile.open(fpath)\n",
        "            tar.extractall(path=dataset_dir)\n",
        "            tar.close()\n",
        "        except:\n",
        "            zip_ref = zipfile.ZipFile(fpath, 'r')\n",
        "            zip_ref.extractall(dataset_dir)\n",
        "            zip_ref.close()\n",
        "\n",
        "        print('{} dataset is ready'.format(self.__class__.__name__))\n",
        "\n",
        "    def check_required_files(self, required_files):\n",
        "        for fpath in required_files:\n",
        "            if not osp.exists(fpath):\n",
        "                raise RuntimeError('\"{}\" is not found'.format(fpath))"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "217qDx8QWbDX"
      },
      "source": [
        "### Market1501\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QfdQVF9WWhlv"
      },
      "source": [
        "class Market1501(ImageDataset):\n",
        "    dataset_dir = 'market1501'\n",
        "    dataset_url = 'http://188.138.127.15:81/Datasets/Market-1501-v15.09.15.zip'\n",
        "\n",
        "    def __init__(self, root='', **kwargs):\n",
        "        self.root = osp.abspath(osp.expanduser(root))\n",
        "        self.dataset_dir = osp.join(self.root, self.dataset_dir)\n",
        "        self.download_dataset(self.dataset_dir, self.dataset_url)\n",
        "\n",
        "        data_dir = osp.join(self.dataset_dir, 'Market-1501-v15.09.15')\n",
        "        if osp.isdir(data_dir):\n",
        "            self.data_dir = data_dir\n",
        "\n",
        "        self.train_dir = osp.join(self.data_dir, 'bounding_box_train')\n",
        "        self.query_dir = osp.join(self.data_dir, 'query')\n",
        "        self.gallery_dir = osp.join(self.data_dir, 'bounding_box_test')\n",
        "\n",
        "        required_files = [\n",
        "            self.data_dir, self.train_dir, self.query_dir, self.gallery_dir\n",
        "        ]\n",
        "        self.check_required_files(required_files)\n",
        "\n",
        "        train = self.process_dir(self.train_dir, relabel=True)\n",
        "        query = self.process_dir(self.query_dir, relabel=False)\n",
        "        gallery = self.process_dir(self.gallery_dir, relabel=False)\n",
        "      \n",
        "        super().__init__(train, query, gallery, **kwargs)\n",
        "\n",
        "    def process_dir(self, dir_path, relabel=False):\n",
        "        img_paths = glob.glob(osp.join(dir_path, '*.jpg'))\n",
        "        pattern = re.compile(r'([-\\d]+)_c(\\d)')\n",
        "\n",
        "        pid_container = set()\n",
        "        for img_path in img_paths:\n",
        "            pid, _ = map(int, pattern.search(img_path).groups())\n",
        "            if pid == -1:\n",
        "                continue # junk images are just ignored\n",
        "            pid_container.add(pid)\n",
        "        pid2label = {pid: label for label, pid in enumerate(pid_container)}\n",
        "\n",
        "        data = []\n",
        "        for img_path in img_paths:\n",
        "            pid, camid = map(int, pattern.search(img_path).groups())\n",
        "            if pid == -1:\n",
        "                continue # junk images are just ignored\n",
        "            assert 0 <= pid <= 1501 # pid == 0 means background\n",
        "            assert 1 <= camid <= 6\n",
        "            camid -= 1 # index starts from 0\n",
        "            if relabel:\n",
        "                pid = pid2label[pid]\n",
        "            data.append((img_path, pid, camid))\n",
        "\n",
        "        return data"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cA3-twA9dZKb"
      },
      "source": [
        "### DataPreparer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oyzyejmSdy1i"
      },
      "source": [
        "QueryGallery = namedtuple('QueryGallery', ['query', 'gallery'])\n",
        "TrainTest = namedtuple('TrainTest', ['train', 'test'])\n",
        "\n",
        "class DataPreparer(object):\n",
        "    def __init__(\n",
        "        self,\n",
        "        root=\"\",\n",
        "        batch_size_train=32,\n",
        "        batch_size_test=32,\n",
        "        workers=4,\n",
        "    ):\n",
        "        self.root = root\n",
        "        self.batch_size_train = batch_size_train\n",
        "        self.batch_size_test = batch_size_test\n",
        "        self.workers = workers\n",
        "\n",
        "        self._build_transforms()\n",
        "        self._prepare_data()\n",
        "\n",
        "        self._num_train_pids = self.trainset.num_train_pids\n",
        "        self._num_train_cams = self.trainset.num_train_cams\n",
        "\n",
        "    @property\n",
        "    def num_train_pids(self):\n",
        "        return self._num_train_pids\n",
        "\n",
        "    @property\n",
        "    def num_train_cams(self):\n",
        "        return self._num_train_cams\n",
        "        \n",
        "    def _build_transforms(self):\n",
        "        norm_mean = [0.485, 0.456, 0.406]\n",
        "        norm_std = [0.229, 0.224, 0.225]\n",
        "\n",
        "        self.transform_train = T.Compose([\n",
        "            T.Resize((256, 128)),\n",
        "            T.Pad(10),\n",
        "            T.RandomCrop((256,128)),\n",
        "            T.RandomHorizontalFlip(),\n",
        "            T.ToTensor(),\n",
        "            T.Normalize(mean=norm_mean, std=norm_std),\n",
        "        ])\n",
        "\n",
        "        self.transform_test = T.Compose([\n",
        "            T.Resize((256, 128)),\n",
        "            T.ToTensor(),\n",
        "            T.Normalize(mean=norm_mean, std=norm_std),\n",
        "        ])\n",
        "\n",
        "    def _prepare_data(self):\n",
        "        print('=> Loading train (source) dataset')\n",
        "        self.trainset = Market1501(\n",
        "            root=self.root,\n",
        "            mode='train',\n",
        "            transform=self.transform_train\n",
        "        )\n",
        "\n",
        "        self.queryset = Market1501(\n",
        "            root=self.root,\n",
        "            mode='query',\n",
        "            transform=self.transform_test\n",
        "        )\n",
        "\n",
        "        self.galleryset = Market1501(\n",
        "            root=self.root,\n",
        "            mode='gallery',\n",
        "            transform=self.transform_test\n",
        "        )\n",
        "\n",
        "    def train_loader(self):\n",
        "        return DataLoader(\n",
        "            dataset=self.trainset,\n",
        "            batch_size= self.batch_size_train,\n",
        "            shuffle=True,\n",
        "            num_workers= self.workers,\n",
        "            drop_last=True\n",
        "        )\n",
        "\n",
        "    def test_loader(self):\n",
        "        return QueryGallery(\n",
        "            query=DataLoader(\n",
        "                dataset=self.queryset,\n",
        "                batch_size= self.batch_size_test,\n",
        "                shuffle=False,\n",
        "                num_workers= self.workers\n",
        "            ),\n",
        "            gallery=DataLoader(\n",
        "                dataset=self.galleryset,\n",
        "                batch_size=self.batch_size_test,\n",
        "                shuffle=False,\n",
        "                num_workers=self.workers\n",
        "            )\n",
        "        )"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 556
        },
        "id": "2Eme0YV46e6E",
        "outputId": "e5d275cf-7937-4d84-9329-92b1a31376c9"
      },
      "source": [
        "preparer = DataPreparer(root = \"./data\")\n",
        "print(\"number of train pids:\", preparer.num_train_pids)\n",
        "print(\"number of train cids:\", preparer.num_train_cams)\n",
        "\n",
        "trainloader = preparer.train_loader()\n",
        "data = iter(trainloader).next()\n",
        "imgs, pids = data['img'], data['pid']\n",
        "print(pids[31])\n",
        "print(imgs[31].shape)\n",
        "plt.imshow(imgs[31].permute(1, 2, 0))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=> Loading train (source) dataset\n",
            "Creating directory \"/content/data/market1501\"\n",
            "* url=\"http://188.138.127.15:81/Datasets/Market-1501-v15.09.15.zip\"\n",
            "* destination=\"/content/data/market1501/Market-1501-v15.09.15.zip\"\n",
            "...100%, 145 MB\n",
            "Extracting \"/content/data/market1501/Market-1501-v15.09.15.zip\"\n",
            "Market1501 dataset is ready\n",
            "number of train pids: 751\n",
            "number of train cids: 6\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(284)\n",
            "torch.Size([3, 256, 128])\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7f6780268d90>"
            ]
          },
          "metadata": {},
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wcbDx2_-VwHQ"
      },
      "source": [
        "# OSNet ✔\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pkyDoVXrsUF0"
      },
      "source": [
        "### Conv1x1 "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nVryN7L9sUF1"
      },
      "source": [
        "class Conv1x1(nn.Module):\n",
        "    \"\"\" 1x1 Conv -> Batch norm -> ReLU \"\"\"\n",
        "\n",
        "    def __init__(self, c_in, c_out, stride=1):\n",
        "        super().__init__()\n",
        "        self.conv = nn.Conv2d(c_in, c_out, 1, stride=stride, padding=0, bias=False)\n",
        "        self.bn = nn.BatchNorm2d(c_out)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv(x)\n",
        "        x = self.bn(x)\n",
        "        x = self.relu(x)\n",
        "        return x\n",
        "\n",
        "\n",
        "class Conv1x1Linear(nn.Module):\n",
        "    \"\"\" 1x1 Conv -> Batch norm \"\"\"\n",
        " \n",
        "    def __init__(self, c_in, c_out, stride=1):\n",
        "        super().__init__()\n",
        "        self.conv = nn.Conv2d(c_in, c_out, 1, stride=stride, padding=0, bias=False)\n",
        "        self.bn = nn.BatchNorm2d(c_out)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv(x)\n",
        "        x = self.bn(x)\n",
        "        return x"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L7K_dd6PUvqy"
      },
      "source": [
        "### LightConv3x3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kgpRQDJGU_Bk"
      },
      "source": [
        "class LightConv3x3(nn.Module):\n",
        "    \"\"\" 1x1 Conv -> DW 3x3 Conv -> Batch norm -> ReLU \"\"\"\n",
        "\n",
        "    def __init__(self, c_in, c_out):\n",
        "        super().__init__()\n",
        "        self.conv1 = nn.Conv2d(c_in, c_out, 1, stride=1, padding=0, bias=False)\n",
        "        self.depthwise = nn.Conv2d(\n",
        "            c_out, c_out, 3, stride=1, padding=1, bias=False, groups=c_out\n",
        "\t\t\t\t)\n",
        "        self.bn = nn.BatchNorm2d(c_out)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv1(x)\n",
        "        x = self.depthwise(x)\n",
        "        x = self.bn(x)\n",
        "        x = self.relu(x)\n",
        "        return x"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ndMdX8bBVhmp"
      },
      "source": [
        "### ConvLayer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hROJTzImVlkI"
      },
      "source": [
        "class ConvLayer(nn.Module):\n",
        "    \"\"\"Conv -> Batch norm -> ReLU\"\"\"\n",
        "\n",
        "    def __init__(self, c_in, c_out, kernel_size, stride=1, padding=0, groups=1):\n",
        "        super().__init__()\n",
        "        self.conv = nn.Conv2d(c_in, c_out, kernel_size, stride=stride,\n",
        "                              padding=padding, bias=False, groups=groups)\n",
        "\n",
        "        self.bn = nn.BatchNorm2d(c_out)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.conv(x)\n",
        "        x = self.bn(x)\n",
        "        x = self.relu(x)\n",
        "        return x"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q9QGv9w4V5kY"
      },
      "source": [
        "### AggregationGate"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l06qVNmoWAI_"
      },
      "source": [
        "class AggregationGate(nn.Module):\n",
        "\n",
        "    def __init__(self, c_in):\n",
        "        super().__init__()\n",
        "        reduction = 16\n",
        "        self.global_avgpool = nn.AdaptiveAvgPool2d(1)\n",
        "        self.fc1 = nn.Conv2d(c_in, c_in//reduction, kernel_size=1, bias=True, padding=0)\n",
        "        self.relu = nn.ReLU(inplace=True)\n",
        "        self.fc2 = nn.Conv2d(c_in//reduction, c_in, kernel_size=1, bias=True, padding=0)\n",
        "        self.activation = nn.Sigmoid()\n",
        "        \n",
        "    def forward(self, x):\n",
        "        output = self.global_avgpool(x)\n",
        "        output = self.fc1(output)\n",
        "        output = self.relu(output)\n",
        "        output = self.fc2(output)\n",
        "        output = self.activation(output)\n",
        "        return output * x"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yzEoO85MWexR"
      },
      "source": [
        "### OSResBlock"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ptCkYgxVWigS"
      },
      "source": [
        "class OSResBlock(nn.Module):\n",
        "    def __init__(self, c_in, c_out, bottleneck_reduction=4, **kwargs):\n",
        "        super().__init__()\n",
        "        c_mid = c_out // bottleneck_reduction\n",
        "        self.conv1 = Conv1x1(c_in, c_mid)\n",
        "        self.conv2a = LightConv3x3(c_mid, c_mid)\n",
        "        self.conv2b = nn.Sequential(\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "        )\n",
        "        self.conv2c = nn.Sequential(\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "        )\n",
        "        self.conv2d = nn.Sequential(\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "            LightConv3x3(c_mid, c_mid),\n",
        "        )\n",
        "        self.gate = AggregationGate(c_mid)\n",
        "        self.conv3 = Conv1x1Linear(c_mid, c_out)\n",
        "        self.downsample = None\n",
        "        if c_in != c_out:\n",
        "            self.downsample = Conv1x1Linear(c_in, c_out)\n",
        "\t\t\t\n",
        "    def forward(self, x):\n",
        "        residual = self.conv1(x)\n",
        "        x_a = self.conv2a(residual)\n",
        "        x_b = self.conv2b(residual)\n",
        "        x_c = self.conv2c(residual)\n",
        "        x_d = self.conv2d(residual)\n",
        "        residual = self.gate(x_a) + self.gate(x_b) + self.gate(x_c) + self.gate(x_d)\n",
        "        residual = self.conv3(residual)\n",
        "        if self.downsample is not None:\n",
        "            x = self.downsample(x)\n",
        "        out = x + residual\n",
        "        return F.relu(out)"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4gIwqpLAXQ_p"
      },
      "source": [
        "### OSNet"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "046ZECf2XYrQ"
      },
      "source": [
        "class OSNet(nn.Module):\n",
        "    def __init__(self,\n",
        "\t\t\t\t\t\t\t\tnum_classes = 751, \n",
        "\t\t\t\t\t\t\t\tblocks=[OSResBlock, OSResBlock, OSResBlock], \n",
        "\t\t\t\t\t\t\t\tlayers=[2, 2, 2],\n",
        "                channels=[64, 256, 384, 512],\n",
        "\t\t\t\t\t\t\t\tfc_dim=512,\n",
        "\t\t\t\t\t\t\t\tloss='softmax'):\n",
        "        super().__init__()\n",
        "        self.loss = loss\n",
        "\n",
        "        # convolutional backbone\n",
        "        self.conv1 = ConvLayer(3, channels[0], 7, stride=2, padding=3)\n",
        "        self.maxpool = nn.MaxPool2d(3, stride=2, padding=1)\n",
        "        self.conv2 = self._make_layer(blocks[0], layers[0], channels[0], channels[1])\n",
        "        self.tran1 =  nn.Sequential(\n",
        "                    Conv1x1(channels[1], channels[1]),\n",
        "                    nn.AvgPool2d(2, stride=2)\n",
        "        )\n",
        "        self.conv3 = self._make_layer(blocks[1], layers[1], channels[1], channels[2])\n",
        "        self.tran2 =  nn.Sequential(\n",
        "                    Conv1x1(channels[2], channels[2]),\n",
        "                    nn.AvgPool2d(2, stride=2)\n",
        "        )\n",
        "        self.conv4 = self._make_layer(blocks[2], layers[2], channels[2], channels[3])\n",
        "        self.conv5 = Conv1x1(channels[3], channels[3])\n",
        "        self.global_avgpool = nn.AdaptiveAvgPool2d(1)\n",
        "        # fully connected layer\n",
        "        self.fc = nn.Sequential(\n",
        "            nn.Linear(channels[3], fc_dim),\n",
        "            nn.BatchNorm1d(fc_dim),\n",
        "            nn.ReLU(inplace=True)\n",
        "        )\n",
        "        self.classifier = nn.Linear(fc_dim, num_classes)\n",
        "\n",
        "    def _make_layer(self, block, num_layers, c_in, c_out):\n",
        "        layers = []\n",
        "\n",
        "        layers.append(block(c_in, c_out))\n",
        "        for i in range(1, num_layers):\n",
        "            layers.append(block(c_out, c_out))\n",
        "\n",
        "        return nn.Sequential(*layers)\n",
        "\n",
        "    def featuremaps(self, x):\n",
        "        x = self.conv1(x)\n",
        "        x = self.maxpool(x)\n",
        "        x = self.conv2(x)\n",
        "        x = self.tran1(x)\n",
        "        x = self.conv3(x)\n",
        "        x = self.tran2(x)\n",
        "        x = self.conv4(x)\n",
        "        x = self.conv5(x)\n",
        "        return x\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.featuremaps(x)\n",
        "        v = self.global_avgpool(x)\n",
        "        v = v.view(v.size(0), -1)\n",
        "        v = self.fc(v)\n",
        "        y = self.classifier(v)\n",
        "        return y"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6sKzI1Sctg6-"
      },
      "source": [
        "# CrossEntropyLoss ✔"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ImdpD7NDtlri"
      },
      "source": [
        "class CrossEntropyLoss(nn.Module):\n",
        "    def __init__(self, num_classes, use_gpu=True, label_smooth = True):\n",
        "        super(CrossEntropyLoss, self).__init__()\n",
        "        self.num_classes = num_classes\n",
        "        self.eps = 0.1 if label_smooth else 0\n",
        "        self.use_gpu = use_gpu\n",
        "        self.logsoftmax = nn.LogSoftmax(dim=1)\n",
        "\n",
        "    def forward(self, logits, targets):\n",
        "        \"\"\"\n",
        "        Args:\n",
        "            logits: prediction matrix with shape (batch_size, num_classes).\n",
        "            targets: Each position contains the true label index\n",
        "\t\t\t\t\t\t\t\t\t\t with shape (batch_size).\n",
        "        \"\"\"\n",
        "        log_probs = self.logsoftmax(logits)\n",
        "        zeros = torch.zeros(log_probs.size())\n",
        "        y = zeros.scatter_(1, targets.unsqueeze(1).data.cpu(), 1)\n",
        "        if self.use_gpu:\n",
        "            y = y.cuda()\n",
        "        y = (1 - self.eps) * y + self.eps / self.num_classes\n",
        "        return (-y * log_probs).mean(0).sum()"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5VrITMEkkdAw"
      },
      "source": [
        "#Distance"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_1M0f9Wmk3dR"
      },
      "source": [
        "def cosine_distance(input1, input2):\n",
        "    input1_normed = F.normalize(input1, p=2, dim=1)\n",
        "    input2_normed = F.normalize(input2, p=2, dim=1)\n",
        "    distmat = 1 - torch.mm(input1_normed, input2_normed.t())\n",
        "    return  distmat"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CR1fzqbNsAb4"
      },
      "source": [
        "# Unit Tests ✔"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W05gC2xhtAFH"
      },
      "source": [
        "### TestConv1x1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pIZeZHVBuBc_"
      },
      "source": [
        "class TestConv1x1(unittest.TestCase):\n",
        "  def test_ouput(self):\n",
        "    layer1 = Conv1x1(c_in=3, c_out = 1)\n",
        "    layer2 = Conv1x1Linear(c_in=3, c_out = 1)\n",
        "    input = torch.randn(1, 3, 256, 128)\n",
        "    output1 = layer1(input)\n",
        "    output2 = layer2(input)\n",
        "\n",
        "    self.assertEqual(output1.shape, (1, 1, 256, 128))\n",
        "    self.assertEqual(output2.shape, (1, 1, 256, 128))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mNjqYgJXtM_A"
      },
      "source": [
        "### TestLightConv3x3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CjFPaEi85KvV"
      },
      "source": [
        "class TestLightConv3x3(unittest.TestCase):\n",
        "  def test_ouput(self):\n",
        "    layer = LightConv3x3(c_in=10, c_out = 5)\n",
        "    input = torch.randn(1, 10, 256, 128)\n",
        "    output = layer(input)\n",
        "\n",
        "    self.assertEqual(output.shape, (1, 5, 256, 128))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OjLFxBeitS-I"
      },
      "source": [
        "### TestConvLayer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-1bECocs6D0M"
      },
      "source": [
        "class TestConvLayer(unittest.TestCase):\n",
        "  def test_ouput(self):\n",
        "    layer1 = ConvLayer(c_in=10, c_out = 5, kernel_size=5, padding = 0)\n",
        "    layer2 = ConvLayer(c_in=10, c_out = 8, kernel_size=5, padding = 1)\n",
        "    layer3 = ConvLayer(c_in=10, c_out = 10, kernel_size=5, padding = 2)\n",
        "\n",
        "    input = torch.randn(1, 10, 256, 128)\n",
        "    output1 = layer1(input)\n",
        "    output2 = layer2(input)\n",
        "    output3 = layer3(input)\n",
        "\n",
        "    self.assertEqual(output1.shape, (1, 5, 252, 124))\n",
        "    self.assertEqual(output2.shape, (1, 8, 254, 126))\n",
        "    self.assertEqual(output3.shape, (1, 10, 256, 128))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8qTSnRytXg3"
      },
      "source": [
        "### TestOSResBlock"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ANOeOK_cDP3-"
      },
      "source": [
        "class TestOSResBlock(unittest.TestCase):\n",
        "  def test_ouput(self):\n",
        "    layer1 = OSResBlock(c_in=64, c_out = 128, bottleneck_reduction = 4)\n",
        "    layer2 = OSResBlock(c_in=128, c_out = 256, bottleneck_reduction = 2)\n",
        "\n",
        "    input = torch.randn(1, 64, 64, 32)\n",
        "    output1 = layer1(input)\n",
        "    output2 = layer2(output1)\n",
        "\n",
        "    self.assertEqual(output1.shape, (1, 128, 64, 32))\n",
        "    self.assertEqual(output2.shape, (1, 256, 64, 32))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VCQtsPSjtdvl"
      },
      "source": [
        "### TestOSNet"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BUxxDuFEI66z"
      },
      "source": [
        "class TestOSNet(unittest.TestCase):\n",
        "  def test_ouput(self):\n",
        "    model = OSNet(num_classes=10)\n",
        "\n",
        "    batch_size = 2\n",
        "    input = torch.randn(2, 3, 256, 128)\n",
        "    stage1 = model.conv1(input)\n",
        "    stage1 = model.maxpool(stage1)\n",
        "\n",
        "    stage2 = model.conv2(stage1)\n",
        "    stage2 = model.tran1(stage2)\n",
        "\n",
        "    stage3 = model.conv3(stage2)\n",
        "    stage3 = model.tran2(stage3)\n",
        "\n",
        "    stage4 = model.conv4(stage3)\n",
        "    stage5 = model.conv5(stage4)\n",
        "\n",
        "    feature = model.featuremaps(input)\n",
        "    output = model(input)\n",
        "\n",
        "    self.assertEqual(model.loss, 'softmax')\n",
        "    self.assertEqual(stage1.shape, (batch_size, 64, 64, 32))\n",
        "    self.assertEqual(stage2.shape, (batch_size, 256, 32, 16))\n",
        "    self.assertEqual(stage3.shape, (batch_size, 384, 16, 8))\n",
        "    self.assertEqual(stage4.shape, (batch_size, 512, 16, 8))\n",
        "    self.assertEqual(stage5.shape, (batch_size, 512, 16, 8))\n",
        "    self.assertEqual(feature.shape, stage5.shape)\n",
        "    self.assertEqual(output.shape, (batch_size, 10))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8-CLi5Mk567l"
      },
      "source": [
        "# Run test ✔"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_qU9Zvny5-ks",
        "outputId": "06538ffa-727e-452a-b95f-5da5e4341919"
      },
      "source": [
        "unittest.main(argv=[''], verbosity=2, exit=False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "test_ouput (__main__.TestConv1x1) ... ok\n",
            "test_ouput (__main__.TestConvLayer) ... ok\n",
            "test_ouput (__main__.TestLightConv3x3) ... ok\n",
            "test_ouput (__main__.TestOSNet) ... ok\n",
            "test_ouput (__main__.TestOSResBlock) ... ok\n",
            "\n",
            "----------------------------------------------------------------------\n",
            "Ran 5 tests in 1.096s\n",
            "\n",
            "OK\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "<unittest.main.TestProgram at 0x7ff9abf42ed0>"
            ]
          },
          "execution_count": 67,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xq12FDTLgNoD"
      },
      "source": [
        "# Training ✔"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j57r4w6igSCE",
        "outputId": "76bad425-a272-4c1d-b043-d40e6b8ff45e"
      },
      "source": [
        "def train_epoch(epoch, model, trainloader, criterion, optimizer, print_freq = 10, use_gpu = True):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    running_acc = 0.0\n",
        "\n",
        "    for batch_index, data in enumerate(trainloader):\n",
        "      loss, acc = forward_backward(model, data, criterion, optimizer, use_gpu)\n",
        "\n",
        "      running_loss += loss\n",
        "      running_acc += acc\n",
        "      if (batch_index + 1) % print_freq == 0:\n",
        "        print('[%d, %5d]\\t loss: %.3f\\t accuracy: %.3f' \n",
        "              %(epoch + 1, batch_index + 1, running_loss / print_freq, running_acc / print_freq))\n",
        "        running_loss = 0.0\n",
        "        running_acc  = 0.0\n",
        "\n",
        "def forward_backward(model, data, criterion, optimizer, use_gpu = True):\n",
        "    imgs, pids = parse_data_for_train(data)\n",
        "    \n",
        "    if use_gpu:\n",
        "        imgs, pids = imgs.cuda(), pids.cuda()\n",
        "\n",
        "    logits = model(imgs)\n",
        "    loss = criterion(logits, pids)\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    \n",
        "    _, prediction = torch.max(logits, dim=1)\n",
        "    acc = (prediction == pids).sum() * 100 / len(pids)\n",
        "    \n",
        "    return loss.item(), acc.item()\n",
        "\n",
        "def parse_data_for_train(data):\n",
        "    imgs = data['img']\n",
        "    pids = data['pid']\n",
        "    return imgs, pids\n",
        "\n",
        "def main(max_epoch = 15, print_freq = 10, use_gpu = True):\n",
        "    data_preparer = DataPreparer(root='./data')\n",
        "\n",
        "    if torch.cuda.is_available() == False:\n",
        "       use_gpu = False\n",
        "\n",
        "    model = OSNet(num_classes = data_preparer.num_train_pids)\n",
        "    if use_gpu:\n",
        "       model = model.cuda()\n",
        "\n",
        "    criterion = CrossEntropyLoss(num_classes = data_preparer.num_train_pids)\n",
        "    optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4)\n",
        "\n",
        "    for epoch in range(max_epoch):\n",
        "        train_epoch(    \n",
        "            epoch = epoch,\n",
        "            model=model,\n",
        "            trainloader = data_preparer.train_loader(),\n",
        "            criterion = criterion,\n",
        "            optimizer = optimizer,\n",
        "            print_freq=print_freq,\n",
        "            use_gpu=use_gpu\n",
        "        )\n",
        "        torch.save(model.state_dict(), './pretrained_model.pth')\n",
        "\n",
        "main(use_gpu = True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=> Loading train (source) dataset\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n",
            "/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py:718: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at  /pytorch/c10/core/TensorImpl.h:1156.)\n",
            "  return torch.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1,    10]\t loss: 6.708\t accuracy: 0.000\n",
            "[1,    20]\t loss: 6.654\t accuracy: 0.625\n",
            "[1,    30]\t loss: 6.636\t accuracy: 1.250\n",
            "[1,    40]\t loss: 6.547\t accuracy: 0.938\n",
            "[1,    50]\t loss: 6.516\t accuracy: 0.938\n",
            "[1,    60]\t loss: 6.529\t accuracy: 1.562\n",
            "[1,    70]\t loss: 6.506\t accuracy: 1.250\n",
            "[1,    80]\t loss: 6.400\t accuracy: 1.250\n",
            "[1,    90]\t loss: 6.471\t accuracy: 0.625\n",
            "[1,   100]\t loss: 6.425\t accuracy: 0.938\n",
            "[1,   110]\t loss: 6.365\t accuracy: 0.312\n",
            "[1,   120]\t loss: 6.322\t accuracy: 0.938\n",
            "[1,   130]\t loss: 6.300\t accuracy: 1.562\n",
            "[1,   140]\t loss: 6.321\t accuracy: 0.312\n",
            "[1,   150]\t loss: 6.276\t accuracy: 1.250\n",
            "[1,   160]\t loss: 6.238\t accuracy: 1.562\n",
            "[1,   170]\t loss: 6.211\t accuracy: 1.562\n",
            "[1,   180]\t loss: 6.135\t accuracy: 2.188\n",
            "[1,   190]\t loss: 6.122\t accuracy: 3.438\n",
            "[1,   200]\t loss: 6.199\t accuracy: 1.250\n",
            "[1,   210]\t loss: 6.137\t accuracy: 1.250\n",
            "[1,   220]\t loss: 6.081\t accuracy: 2.188\n",
            "[1,   230]\t loss: 6.008\t accuracy: 1.562\n",
            "[1,   240]\t loss: 5.987\t accuracy: 2.500\n",
            "[1,   250]\t loss: 6.019\t accuracy: 2.812\n",
            "[1,   260]\t loss: 5.981\t accuracy: 4.375\n",
            "[1,   270]\t loss: 5.997\t accuracy: 5.000\n",
            "[1,   280]\t loss: 5.771\t accuracy: 4.688\n",
            "[1,   290]\t loss: 5.821\t accuracy: 3.438\n",
            "[1,   300]\t loss: 5.845\t accuracy: 4.062\n",
            "[1,   310]\t loss: 5.843\t accuracy: 1.875\n",
            "[1,   320]\t loss: 5.807\t accuracy: 4.688\n",
            "[1,   330]\t loss: 5.805\t accuracy: 4.688\n",
            "[1,   340]\t loss: 5.748\t accuracy: 2.812\n",
            "[1,   350]\t loss: 5.726\t accuracy: 3.750\n",
            "[1,   360]\t loss: 5.830\t accuracy: 2.188\n",
            "[1,   370]\t loss: 5.711\t accuracy: 4.062\n",
            "[1,   380]\t loss: 5.533\t accuracy: 6.250\n",
            "[1,   390]\t loss: 5.518\t accuracy: 5.938\n",
            "[1,   400]\t loss: 5.554\t accuracy: 6.562\n",
            "[2,    10]\t loss: 5.416\t accuracy: 6.562\n",
            "[2,    20]\t loss: 5.417\t accuracy: 5.625\n",
            "[2,    30]\t loss: 5.333\t accuracy: 7.812\n",
            "[2,    40]\t loss: 5.311\t accuracy: 8.125\n",
            "[2,    50]\t loss: 5.306\t accuracy: 6.875\n",
            "[2,    60]\t loss: 5.366\t accuracy: 8.125\n",
            "[2,    70]\t loss: 5.218\t accuracy: 6.562\n",
            "[2,    80]\t loss: 5.270\t accuracy: 7.812\n",
            "[2,    90]\t loss: 5.247\t accuracy: 9.688\n",
            "[2,   100]\t loss: 5.215\t accuracy: 8.750\n",
            "[2,   110]\t loss: 5.185\t accuracy: 10.625\n",
            "[2,   120]\t loss: 5.146\t accuracy: 11.562\n",
            "[2,   130]\t loss: 5.119\t accuracy: 10.000\n",
            "[2,   140]\t loss: 5.088\t accuracy: 10.000\n",
            "[2,   150]\t loss: 5.049\t accuracy: 10.938\n",
            "[2,   160]\t loss: 5.100\t accuracy: 10.312\n",
            "[2,   170]\t loss: 5.002\t accuracy: 9.375\n",
            "[2,   180]\t loss: 4.894\t accuracy: 12.188\n",
            "[2,   190]\t loss: 5.021\t accuracy: 12.500\n",
            "[2,   200]\t loss: 4.970\t accuracy: 10.938\n",
            "[2,   210]\t loss: 4.937\t accuracy: 13.125\n",
            "[2,   220]\t loss: 4.859\t accuracy: 13.125\n",
            "[2,   230]\t loss: 4.936\t accuracy: 11.875\n",
            "[2,   240]\t loss: 4.701\t accuracy: 14.688\n",
            "[2,   250]\t loss: 4.773\t accuracy: 12.812\n",
            "[2,   260]\t loss: 4.686\t accuracy: 17.188\n",
            "[2,   270]\t loss: 4.919\t accuracy: 10.938\n",
            "[2,   280]\t loss: 4.534\t accuracy: 18.750\n",
            "[2,   290]\t loss: 4.696\t accuracy: 13.125\n",
            "[2,   300]\t loss: 4.670\t accuracy: 18.125\n",
            "[2,   310]\t loss: 4.649\t accuracy: 17.812\n",
            "[2,   320]\t loss: 4.671\t accuracy: 15.938\n",
            "[2,   330]\t loss: 4.608\t accuracy: 14.688\n",
            "[2,   340]\t loss: 4.513\t accuracy: 20.625\n",
            "[2,   350]\t loss: 4.582\t accuracy: 14.688\n",
            "[2,   360]\t loss: 4.531\t accuracy: 16.875\n",
            "[2,   370]\t loss: 4.464\t accuracy: 18.438\n",
            "[2,   380]\t loss: 4.391\t accuracy: 20.625\n",
            "[2,   390]\t loss: 4.402\t accuracy: 24.062\n",
            "[2,   400]\t loss: 4.510\t accuracy: 19.375\n",
            "[3,    10]\t loss: 4.216\t accuracy: 24.062\n",
            "[3,    20]\t loss: 4.303\t accuracy: 15.312\n",
            "[3,    30]\t loss: 4.205\t accuracy: 25.312\n",
            "[3,    40]\t loss: 4.005\t accuracy: 25.938\n",
            "[3,    50]\t loss: 4.121\t accuracy: 25.938\n",
            "[3,    60]\t loss: 4.170\t accuracy: 22.500\n",
            "[3,    70]\t loss: 4.153\t accuracy: 21.562\n",
            "[3,    80]\t loss: 3.973\t accuracy: 26.250\n",
            "[3,    90]\t loss: 4.058\t accuracy: 25.938\n",
            "[3,   100]\t loss: 4.132\t accuracy: 23.750\n",
            "[3,   110]\t loss: 4.101\t accuracy: 25.625\n",
            "[3,   120]\t loss: 3.970\t accuracy: 26.250\n",
            "[3,   130]\t loss: 4.160\t accuracy: 22.500\n",
            "[3,   140]\t loss: 3.995\t accuracy: 26.250\n",
            "[3,   150]\t loss: 3.943\t accuracy: 30.625\n",
            "[3,   160]\t loss: 3.979\t accuracy: 27.500\n",
            "[3,   170]\t loss: 3.954\t accuracy: 27.500\n",
            "[3,   180]\t loss: 3.773\t accuracy: 33.438\n",
            "[3,   190]\t loss: 3.772\t accuracy: 33.125\n",
            "[3,   200]\t loss: 3.817\t accuracy: 30.625\n",
            "[3,   210]\t loss: 3.873\t accuracy: 29.062\n",
            "[3,   220]\t loss: 3.829\t accuracy: 30.000\n",
            "[3,   230]\t loss: 3.930\t accuracy: 28.438\n",
            "[3,   240]\t loss: 3.871\t accuracy: 30.625\n",
            "[3,   250]\t loss: 3.818\t accuracy: 30.625\n",
            "[3,   260]\t loss: 3.756\t accuracy: 32.812\n",
            "[3,   270]\t loss: 3.711\t accuracy: 32.500\n",
            "[3,   280]\t loss: 3.575\t accuracy: 39.375\n",
            "[3,   290]\t loss: 3.617\t accuracy: 38.125\n",
            "[3,   300]\t loss: 3.733\t accuracy: 32.500\n",
            "[3,   310]\t loss: 3.650\t accuracy: 36.562\n",
            "[3,   320]\t loss: 3.586\t accuracy: 34.688\n",
            "[3,   330]\t loss: 3.689\t accuracy: 34.375\n",
            "[3,   340]\t loss: 3.705\t accuracy: 32.188\n",
            "[3,   350]\t loss: 3.623\t accuracy: 35.938\n",
            "[3,   360]\t loss: 3.568\t accuracy: 35.312\n",
            "[3,   370]\t loss: 3.674\t accuracy: 37.812\n",
            "[3,   380]\t loss: 3.545\t accuracy: 39.062\n",
            "[3,   390]\t loss: 3.306\t accuracy: 40.625\n",
            "[3,   400]\t loss: 3.564\t accuracy: 35.000\n",
            "[4,    10]\t loss: 3.186\t accuracy: 43.438\n",
            "[4,    20]\t loss: 3.335\t accuracy: 38.438\n",
            "[4,    30]\t loss: 3.303\t accuracy: 44.688\n",
            "[4,    40]\t loss: 3.312\t accuracy: 39.375\n",
            "[4,    50]\t loss: 3.173\t accuracy: 46.562\n",
            "[4,    60]\t loss: 3.090\t accuracy: 47.500\n",
            "[4,    70]\t loss: 3.156\t accuracy: 44.688\n",
            "[4,    80]\t loss: 3.324\t accuracy: 40.000\n",
            "[4,    90]\t loss: 3.086\t accuracy: 48.438\n",
            "[4,   100]\t loss: 3.158\t accuracy: 45.000\n",
            "[4,   110]\t loss: 3.233\t accuracy: 43.750\n",
            "[4,   120]\t loss: 3.090\t accuracy: 52.500\n",
            "[4,   130]\t loss: 3.040\t accuracy: 52.500\n",
            "[4,   140]\t loss: 3.294\t accuracy: 41.875\n",
            "[4,   150]\t loss: 3.104\t accuracy: 47.500\n",
            "[4,   160]\t loss: 3.146\t accuracy: 44.688\n",
            "[4,   170]\t loss: 3.175\t accuracy: 47.188\n",
            "[4,   180]\t loss: 2.986\t accuracy: 47.812\n",
            "[4,   190]\t loss: 3.048\t accuracy: 45.938\n",
            "[4,   200]\t loss: 3.030\t accuracy: 51.562\n",
            "[4,   210]\t loss: 2.945\t accuracy: 55.312\n",
            "[4,   220]\t loss: 2.989\t accuracy: 51.562\n",
            "[4,   230]\t loss: 3.075\t accuracy: 48.125\n",
            "[4,   240]\t loss: 2.942\t accuracy: 54.688\n",
            "[4,   250]\t loss: 2.987\t accuracy: 50.625\n",
            "[4,   260]\t loss: 2.962\t accuracy: 52.500\n",
            "[4,   270]\t loss: 3.100\t accuracy: 46.875\n",
            "[4,   280]\t loss: 2.997\t accuracy: 48.125\n",
            "[4,   290]\t loss: 2.894\t accuracy: 52.188\n",
            "[4,   300]\t loss: 2.922\t accuracy: 53.438\n",
            "[4,   310]\t loss: 2.762\t accuracy: 55.625\n",
            "[4,   320]\t loss: 2.895\t accuracy: 54.375\n",
            "[4,   330]\t loss: 2.782\t accuracy: 57.500\n",
            "[4,   340]\t loss: 2.816\t accuracy: 56.250\n",
            "[4,   350]\t loss: 2.735\t accuracy: 56.875\n",
            "[4,   360]\t loss: 2.826\t accuracy: 55.312\n",
            "[4,   370]\t loss: 2.845\t accuracy: 53.750\n",
            "[4,   380]\t loss: 2.795\t accuracy: 57.188\n",
            "[4,   390]\t loss: 2.821\t accuracy: 52.812\n",
            "[4,   400]\t loss: 2.706\t accuracy: 56.875\n",
            "[5,    10]\t loss: 2.497\t accuracy: 67.188\n",
            "[5,    20]\t loss: 2.594\t accuracy: 59.062\n",
            "[5,    30]\t loss: 2.630\t accuracy: 60.000\n",
            "[5,    40]\t loss: 2.625\t accuracy: 59.688\n",
            "[5,    50]\t loss: 2.631\t accuracy: 62.500\n",
            "[5,    60]\t loss: 2.499\t accuracy: 67.188\n",
            "[5,    70]\t loss: 2.508\t accuracy: 64.688\n",
            "[5,    80]\t loss: 2.445\t accuracy: 68.750\n",
            "[5,    90]\t loss: 2.480\t accuracy: 65.938\n",
            "[5,   100]\t loss: 2.576\t accuracy: 60.625\n",
            "[5,   110]\t loss: 2.489\t accuracy: 63.750\n",
            "[5,   120]\t loss: 2.504\t accuracy: 68.438\n",
            "[5,   130]\t loss: 2.451\t accuracy: 66.562\n",
            "[5,   140]\t loss: 2.482\t accuracy: 65.312\n",
            "[5,   150]\t loss: 2.454\t accuracy: 65.000\n",
            "[5,   160]\t loss: 2.467\t accuracy: 65.000\n",
            "[5,   170]\t loss: 2.254\t accuracy: 71.875\n",
            "[5,   180]\t loss: 2.388\t accuracy: 68.125\n",
            "[5,   190]\t loss: 2.504\t accuracy: 61.562\n",
            "[5,   200]\t loss: 2.457\t accuracy: 64.062\n",
            "[5,   210]\t loss: 2.388\t accuracy: 67.500\n",
            "[5,   220]\t loss: 2.572\t accuracy: 60.938\n",
            "[5,   230]\t loss: 2.292\t accuracy: 72.812\n",
            "[5,   240]\t loss: 2.475\t accuracy: 66.875\n",
            "[5,   250]\t loss: 2.447\t accuracy: 66.250\n",
            "[5,   260]\t loss: 2.471\t accuracy: 65.000\n",
            "[5,   270]\t loss: 2.355\t accuracy: 67.188\n",
            "[5,   280]\t loss: 2.284\t accuracy: 71.875\n",
            "[5,   290]\t loss: 2.357\t accuracy: 68.438\n",
            "[5,   300]\t loss: 2.320\t accuracy: 67.812\n",
            "[5,   310]\t loss: 2.358\t accuracy: 67.500\n",
            "[5,   320]\t loss: 2.324\t accuracy: 69.375\n",
            "[5,   330]\t loss: 2.243\t accuracy: 69.688\n",
            "[5,   340]\t loss: 2.553\t accuracy: 61.562\n",
            "[5,   350]\t loss: 2.406\t accuracy: 67.500\n",
            "[5,   360]\t loss: 2.419\t accuracy: 65.625\n",
            "[5,   370]\t loss: 2.339\t accuracy: 69.688\n",
            "[5,   380]\t loss: 2.322\t accuracy: 70.938\n",
            "[5,   390]\t loss: 2.202\t accuracy: 73.750\n",
            "[5,   400]\t loss: 2.318\t accuracy: 67.500\n",
            "[6,    10]\t loss: 2.125\t accuracy: 77.500\n",
            "[6,    20]\t loss: 2.073\t accuracy: 78.438\n",
            "[6,    30]\t loss: 2.075\t accuracy: 74.062\n",
            "[6,    40]\t loss: 2.065\t accuracy: 78.125\n",
            "[6,    50]\t loss: 2.138\t accuracy: 74.688\n",
            "[6,    60]\t loss: 2.186\t accuracy: 71.250\n",
            "[6,    70]\t loss: 2.156\t accuracy: 73.438\n",
            "[6,    80]\t loss: 2.169\t accuracy: 72.500\n",
            "[6,    90]\t loss: 2.059\t accuracy: 75.312\n",
            "[6,   100]\t loss: 2.071\t accuracy: 77.500\n",
            "[6,   110]\t loss: 2.087\t accuracy: 77.188\n",
            "[6,   120]\t loss: 2.005\t accuracy: 77.188\n",
            "[6,   130]\t loss: 2.111\t accuracy: 73.750\n",
            "[6,   140]\t loss: 2.077\t accuracy: 78.125\n",
            "[6,   150]\t loss: 2.123\t accuracy: 74.062\n",
            "[6,   160]\t loss: 2.072\t accuracy: 77.188\n",
            "[6,   170]\t loss: 2.102\t accuracy: 76.562\n",
            "[6,   180]\t loss: 2.023\t accuracy: 77.812\n",
            "[6,   190]\t loss: 1.995\t accuracy: 80.625\n",
            "[6,   200]\t loss: 2.161\t accuracy: 76.250\n",
            "[6,   210]\t loss: 2.035\t accuracy: 78.750\n",
            "[6,   220]\t loss: 2.034\t accuracy: 79.375\n",
            "[6,   230]\t loss: 2.019\t accuracy: 78.125\n",
            "[6,   240]\t loss: 1.976\t accuracy: 83.438\n",
            "[6,   250]\t loss: 2.007\t accuracy: 78.750\n",
            "[6,   260]\t loss: 2.040\t accuracy: 77.500\n",
            "[6,   270]\t loss: 2.020\t accuracy: 80.000\n",
            "[6,   280]\t loss: 2.041\t accuracy: 79.062\n",
            "[6,   290]\t loss: 1.976\t accuracy: 81.875\n",
            "[6,   300]\t loss: 1.967\t accuracy: 81.875\n",
            "[6,   310]\t loss: 2.029\t accuracy: 78.750\n",
            "[6,   320]\t loss: 2.015\t accuracy: 78.125\n",
            "[6,   330]\t loss: 1.954\t accuracy: 80.312\n",
            "[6,   340]\t loss: 1.959\t accuracy: 78.438\n",
            "[6,   350]\t loss: 1.835\t accuracy: 85.625\n",
            "[6,   360]\t loss: 1.974\t accuracy: 77.188\n",
            "[6,   370]\t loss: 1.993\t accuracy: 80.000\n",
            "[6,   380]\t loss: 1.900\t accuracy: 82.500\n",
            "[6,   390]\t loss: 2.004\t accuracy: 80.312\n",
            "[6,   400]\t loss: 1.893\t accuracy: 82.812\n",
            "[7,    10]\t loss: 1.786\t accuracy: 86.250\n",
            "[7,    20]\t loss: 1.745\t accuracy: 87.500\n",
            "[7,    30]\t loss: 1.877\t accuracy: 82.812\n",
            "[7,    40]\t loss: 1.806\t accuracy: 85.625\n",
            "[7,    50]\t loss: 1.727\t accuracy: 89.375\n",
            "[7,    60]\t loss: 1.815\t accuracy: 86.562\n",
            "[7,    70]\t loss: 1.773\t accuracy: 87.188\n",
            "[7,    80]\t loss: 1.814\t accuracy: 86.875\n",
            "[7,    90]\t loss: 1.787\t accuracy: 86.875\n",
            "[7,   100]\t loss: 1.747\t accuracy: 86.875\n",
            "[7,   110]\t loss: 1.758\t accuracy: 87.500\n",
            "[7,   120]\t loss: 1.816\t accuracy: 84.375\n",
            "[7,   130]\t loss: 1.844\t accuracy: 83.438\n",
            "[7,   140]\t loss: 1.827\t accuracy: 84.062\n",
            "[7,   150]\t loss: 1.781\t accuracy: 85.938\n",
            "[7,   160]\t loss: 1.838\t accuracy: 83.750\n",
            "[7,   170]\t loss: 1.780\t accuracy: 88.750\n",
            "[7,   180]\t loss: 1.838\t accuracy: 80.312\n",
            "[7,   190]\t loss: 1.757\t accuracy: 89.375\n",
            "[7,   200]\t loss: 1.739\t accuracy: 86.562\n",
            "[7,   210]\t loss: 1.781\t accuracy: 86.875\n",
            "[7,   220]\t loss: 1.724\t accuracy: 88.438\n",
            "[7,   230]\t loss: 1.736\t accuracy: 87.812\n",
            "[7,   240]\t loss: 1.783\t accuracy: 85.625\n",
            "[7,   250]\t loss: 1.700\t accuracy: 87.188\n",
            "[7,   260]\t loss: 1.719\t accuracy: 89.062\n",
            "[7,   270]\t loss: 1.810\t accuracy: 85.938\n",
            "[7,   280]\t loss: 1.771\t accuracy: 84.062\n",
            "[7,   290]\t loss: 1.730\t accuracy: 89.688\n",
            "[7,   300]\t loss: 1.717\t accuracy: 86.250\n",
            "[7,   310]\t loss: 1.763\t accuracy: 86.250\n",
            "[7,   320]\t loss: 1.704\t accuracy: 88.438\n",
            "[7,   330]\t loss: 1.870\t accuracy: 82.500\n",
            "[7,   340]\t loss: 1.758\t accuracy: 86.250\n",
            "[7,   350]\t loss: 1.761\t accuracy: 86.875\n",
            "[7,   360]\t loss: 1.857\t accuracy: 83.125\n",
            "[7,   370]\t loss: 1.861\t accuracy: 82.188\n",
            "[7,   380]\t loss: 1.804\t accuracy: 83.750\n",
            "[7,   390]\t loss: 1.681\t accuracy: 89.688\n",
            "[7,   400]\t loss: 1.736\t accuracy: 87.500\n",
            "[8,    10]\t loss: 1.583\t accuracy: 92.188\n",
            "[8,    20]\t loss: 1.646\t accuracy: 87.188\n",
            "[8,    30]\t loss: 1.607\t accuracy: 91.250\n",
            "[8,    40]\t loss: 1.672\t accuracy: 89.062\n",
            "[8,    50]\t loss: 1.636\t accuracy: 90.625\n",
            "[8,    60]\t loss: 1.607\t accuracy: 92.812\n",
            "[8,    70]\t loss: 1.592\t accuracy: 90.625\n",
            "[8,    80]\t loss: 1.582\t accuracy: 93.750\n",
            "[8,    90]\t loss: 1.634\t accuracy: 89.688\n",
            "[8,   100]\t loss: 1.618\t accuracy: 91.250\n",
            "[8,   110]\t loss: 1.631\t accuracy: 91.250\n",
            "[8,   120]\t loss: 1.598\t accuracy: 90.625\n",
            "[8,   130]\t loss: 1.659\t accuracy: 89.375\n",
            "[8,   140]\t loss: 1.631\t accuracy: 91.250\n",
            "[8,   150]\t loss: 1.631\t accuracy: 90.000\n",
            "[8,   160]\t loss: 1.629\t accuracy: 90.625\n",
            "[8,   170]\t loss: 1.580\t accuracy: 92.812\n",
            "[8,   180]\t loss: 1.603\t accuracy: 91.250\n",
            "[8,   190]\t loss: 1.567\t accuracy: 91.250\n",
            "[8,   200]\t loss: 1.626\t accuracy: 89.688\n",
            "[8,   210]\t loss: 1.581\t accuracy: 92.812\n",
            "[8,   220]\t loss: 1.600\t accuracy: 91.562\n",
            "[8,   230]\t loss: 1.616\t accuracy: 92.812\n",
            "[8,   240]\t loss: 1.567\t accuracy: 91.875\n",
            "[8,   250]\t loss: 1.605\t accuracy: 90.625\n",
            "[8,   260]\t loss: 1.632\t accuracy: 88.750\n",
            "[8,   270]\t loss: 1.552\t accuracy: 91.875\n",
            "[8,   280]\t loss: 1.629\t accuracy: 87.188\n",
            "[8,   290]\t loss: 1.624\t accuracy: 92.188\n",
            "[8,   300]\t loss: 1.612\t accuracy: 91.875\n",
            "[8,   310]\t loss: 1.659\t accuracy: 91.562\n",
            "[8,   320]\t loss: 1.656\t accuracy: 90.000\n",
            "[8,   330]\t loss: 1.602\t accuracy: 93.125\n",
            "[8,   340]\t loss: 1.608\t accuracy: 91.250\n",
            "[8,   350]\t loss: 1.617\t accuracy: 91.250\n",
            "[8,   360]\t loss: 1.606\t accuracy: 90.000\n",
            "[8,   370]\t loss: 1.617\t accuracy: 89.688\n",
            "[8,   380]\t loss: 1.654\t accuracy: 89.062\n",
            "[8,   390]\t loss: 1.566\t accuracy: 92.500\n",
            "[8,   400]\t loss: 1.601\t accuracy: 91.250\n",
            "[9,    10]\t loss: 1.501\t accuracy: 93.750\n",
            "[9,    20]\t loss: 1.580\t accuracy: 91.250\n",
            "[9,    30]\t loss: 1.487\t accuracy: 94.688\n",
            "[9,    40]\t loss: 1.468\t accuracy: 95.312\n",
            "[9,    50]\t loss: 1.465\t accuracy: 96.875\n",
            "[9,    60]\t loss: 1.509\t accuracy: 93.438\n",
            "[9,    70]\t loss: 1.510\t accuracy: 95.000\n",
            "[9,    80]\t loss: 1.483\t accuracy: 95.000\n",
            "[9,    90]\t loss: 1.487\t accuracy: 95.000\n",
            "[9,   100]\t loss: 1.488\t accuracy: 94.375\n",
            "[9,   110]\t loss: 1.479\t accuracy: 94.688\n",
            "[9,   120]\t loss: 1.478\t accuracy: 95.312\n",
            "[9,   130]\t loss: 1.491\t accuracy: 95.938\n",
            "[9,   140]\t loss: 1.504\t accuracy: 94.688\n",
            "[9,   150]\t loss: 1.457\t accuracy: 96.562\n",
            "[9,   160]\t loss: 1.478\t accuracy: 94.375\n",
            "[9,   170]\t loss: 1.493\t accuracy: 94.688\n",
            "[9,   180]\t loss: 1.481\t accuracy: 94.375\n",
            "[9,   190]\t loss: 1.474\t accuracy: 95.312\n",
            "[9,   200]\t loss: 1.456\t accuracy: 94.375\n",
            "[9,   210]\t loss: 1.457\t accuracy: 95.625\n",
            "[9,   220]\t loss: 1.472\t accuracy: 95.938\n",
            "[9,   230]\t loss: 1.490\t accuracy: 95.000\n",
            "[9,   240]\t loss: 1.487\t accuracy: 95.000\n",
            "[9,   250]\t loss: 1.467\t accuracy: 94.375\n",
            "[9,   260]\t loss: 1.459\t accuracy: 95.000\n",
            "[9,   270]\t loss: 1.501\t accuracy: 94.062\n",
            "[9,   280]\t loss: 1.494\t accuracy: 95.000\n",
            "[9,   290]\t loss: 1.542\t accuracy: 90.938\n",
            "[9,   300]\t loss: 1.475\t accuracy: 95.938\n",
            "[9,   310]\t loss: 1.508\t accuracy: 93.750\n",
            "[9,   320]\t loss: 1.434\t accuracy: 95.625\n",
            "[9,   330]\t loss: 1.464\t accuracy: 95.625\n",
            "[9,   340]\t loss: 1.513\t accuracy: 92.812\n",
            "[9,   350]\t loss: 1.522\t accuracy: 92.188\n",
            "[9,   360]\t loss: 1.461\t accuracy: 95.000\n",
            "[9,   370]\t loss: 1.540\t accuracy: 91.562\n",
            "[9,   380]\t loss: 1.489\t accuracy: 93.125\n",
            "[9,   390]\t loss: 1.482\t accuracy: 95.312\n",
            "[9,   400]\t loss: 1.486\t accuracy: 93.438\n",
            "[10,    10]\t loss: 1.381\t accuracy: 97.500\n",
            "[10,    20]\t loss: 1.429\t accuracy: 96.250\n",
            "[10,    30]\t loss: 1.410\t accuracy: 97.500\n",
            "[10,    40]\t loss: 1.403\t accuracy: 97.188\n",
            "[10,    50]\t loss: 1.415\t accuracy: 94.688\n",
            "[10,    60]\t loss: 1.369\t accuracy: 97.500\n",
            "[10,    70]\t loss: 1.408\t accuracy: 96.250\n",
            "[10,    80]\t loss: 1.411\t accuracy: 96.562\n",
            "[10,    90]\t loss: 1.390\t accuracy: 97.500\n",
            "[10,   100]\t loss: 1.408\t accuracy: 97.500\n",
            "[10,   110]\t loss: 1.408\t accuracy: 96.875\n",
            "[10,   120]\t loss: 1.389\t accuracy: 97.188\n",
            "[10,   130]\t loss: 1.402\t accuracy: 97.812\n",
            "[10,   140]\t loss: 1.376\t accuracy: 97.188\n",
            "[10,   150]\t loss: 1.394\t accuracy: 97.812\n",
            "[10,   160]\t loss: 1.455\t accuracy: 94.062\n",
            "[10,   170]\t loss: 1.400\t accuracy: 98.125\n",
            "[10,   180]\t loss: 1.400\t accuracy: 96.875\n",
            "[10,   190]\t loss: 1.405\t accuracy: 95.938\n",
            "[10,   200]\t loss: 1.390\t accuracy: 97.500\n",
            "[10,   210]\t loss: 1.430\t accuracy: 96.250\n",
            "[10,   220]\t loss: 1.411\t accuracy: 97.500\n",
            "[10,   230]\t loss: 1.441\t accuracy: 95.938\n",
            "[10,   240]\t loss: 1.447\t accuracy: 95.000\n",
            "[10,   250]\t loss: 1.418\t accuracy: 96.562\n",
            "[10,   260]\t loss: 1.443\t accuracy: 96.562\n",
            "[10,   270]\t loss: 1.450\t accuracy: 95.000\n",
            "[10,   280]\t loss: 1.354\t accuracy: 98.750\n",
            "[10,   290]\t loss: 1.374\t accuracy: 97.188\n",
            "[10,   300]\t loss: 1.436\t accuracy: 95.312\n",
            "[10,   310]\t loss: 1.436\t accuracy: 95.938\n",
            "[10,   320]\t loss: 1.430\t accuracy: 95.312\n",
            "[10,   330]\t loss: 1.441\t accuracy: 95.625\n",
            "[10,   340]\t loss: 1.424\t accuracy: 95.625\n",
            "[10,   350]\t loss: 1.415\t accuracy: 96.250\n",
            "[10,   360]\t loss: 1.421\t accuracy: 96.562\n",
            "[10,   370]\t loss: 1.427\t accuracy: 94.375\n",
            "[10,   380]\t loss: 1.370\t accuracy: 98.125\n",
            "[10,   390]\t loss: 1.421\t accuracy: 95.312\n",
            "[10,   400]\t loss: 1.437\t accuracy: 93.125\n",
            "[11,    10]\t loss: 1.345\t accuracy: 97.812\n",
            "[11,    20]\t loss: 1.320\t accuracy: 97.188\n",
            "[11,    30]\t loss: 1.352\t accuracy: 96.562\n",
            "[11,    40]\t loss: 1.330\t accuracy: 98.438\n",
            "[11,    50]\t loss: 1.334\t accuracy: 98.750\n",
            "[11,    60]\t loss: 1.340\t accuracy: 98.125\n",
            "[11,    70]\t loss: 1.322\t accuracy: 98.750\n",
            "[11,    80]\t loss: 1.314\t accuracy: 98.438\n",
            "[11,    90]\t loss: 1.321\t accuracy: 97.812\n",
            "[11,   100]\t loss: 1.332\t accuracy: 98.125\n",
            "[11,   110]\t loss: 1.329\t accuracy: 97.812\n",
            "[11,   120]\t loss: 1.324\t accuracy: 99.062\n",
            "[11,   130]\t loss: 1.317\t accuracy: 98.750\n",
            "[11,   140]\t loss: 1.323\t accuracy: 97.500\n",
            "[11,   150]\t loss: 1.329\t accuracy: 97.500\n",
            "[11,   160]\t loss: 1.339\t accuracy: 97.812\n",
            "[11,   170]\t loss: 1.332\t accuracy: 98.125\n",
            "[11,   180]\t loss: 1.349\t accuracy: 97.812\n",
            "[11,   190]\t loss: 1.370\t accuracy: 95.938\n",
            "[11,   200]\t loss: 1.380\t accuracy: 96.250\n",
            "[11,   210]\t loss: 1.359\t accuracy: 96.875\n",
            "[11,   220]\t loss: 1.358\t accuracy: 96.875\n",
            "[11,   230]\t loss: 1.337\t accuracy: 97.812\n",
            "[11,   240]\t loss: 1.383\t accuracy: 96.562\n",
            "[11,   250]\t loss: 1.369\t accuracy: 97.188\n",
            "[11,   260]\t loss: 1.337\t accuracy: 98.125\n",
            "[11,   270]\t loss: 1.372\t accuracy: 95.000\n",
            "[11,   280]\t loss: 1.346\t accuracy: 97.812\n",
            "[11,   290]\t loss: 1.368\t accuracy: 97.500\n",
            "[11,   300]\t loss: 1.400\t accuracy: 95.312\n",
            "[11,   310]\t loss: 1.381\t accuracy: 95.000\n",
            "[11,   320]\t loss: 1.351\t accuracy: 97.500\n",
            "[11,   330]\t loss: 1.356\t accuracy: 97.500\n",
            "[11,   340]\t loss: 1.360\t accuracy: 96.875\n",
            "[11,   350]\t loss: 1.372\t accuracy: 96.562\n",
            "[11,   360]\t loss: 1.354\t accuracy: 98.438\n",
            "[11,   370]\t loss: 1.321\t accuracy: 99.375\n",
            "[11,   380]\t loss: 1.341\t accuracy: 96.562\n",
            "[11,   390]\t loss: 1.365\t accuracy: 96.250\n",
            "[11,   400]\t loss: 1.376\t accuracy: 98.125\n",
            "[12,    10]\t loss: 1.293\t accuracy: 99.062\n",
            "[12,    20]\t loss: 1.304\t accuracy: 96.875\n",
            "[12,    30]\t loss: 1.299\t accuracy: 99.062\n",
            "[12,    40]\t loss: 1.288\t accuracy: 98.438\n",
            "[12,    50]\t loss: 1.264\t accuracy: 99.062\n",
            "[12,    60]\t loss: 1.291\t accuracy: 99.062\n",
            "[12,    70]\t loss: 1.262\t accuracy: 99.062\n",
            "[12,    80]\t loss: 1.305\t accuracy: 98.125\n",
            "[12,    90]\t loss: 1.311\t accuracy: 97.500\n",
            "[12,   100]\t loss: 1.317\t accuracy: 98.125\n",
            "[12,   110]\t loss: 1.339\t accuracy: 96.562\n",
            "[12,   120]\t loss: 1.294\t accuracy: 98.125\n",
            "[12,   130]\t loss: 1.302\t accuracy: 97.812\n",
            "[12,   140]\t loss: 1.341\t accuracy: 97.188\n",
            "[12,   150]\t loss: 1.333\t accuracy: 97.500\n",
            "[12,   160]\t loss: 1.303\t accuracy: 98.438\n",
            "[12,   170]\t loss: 1.311\t accuracy: 98.438\n",
            "[12,   180]\t loss: 1.300\t accuracy: 99.062\n",
            "[12,   190]\t loss: 1.339\t accuracy: 97.812\n",
            "[12,   200]\t loss: 1.321\t accuracy: 97.812\n",
            "[12,   210]\t loss: 1.293\t accuracy: 99.062\n",
            "[12,   220]\t loss: 1.318\t accuracy: 97.500\n",
            "[12,   230]\t loss: 1.333\t accuracy: 98.438\n",
            "[12,   240]\t loss: 1.327\t accuracy: 97.500\n",
            "[12,   250]\t loss: 1.335\t accuracy: 96.562\n",
            "[12,   260]\t loss: 1.299\t accuracy: 99.062\n",
            "[12,   270]\t loss: 1.323\t accuracy: 96.562\n",
            "[12,   280]\t loss: 1.334\t accuracy: 99.062\n",
            "[12,   290]\t loss: 1.291\t accuracy: 99.688\n",
            "[12,   300]\t loss: 1.337\t accuracy: 96.875\n",
            "[12,   310]\t loss: 1.302\t accuracy: 98.750\n",
            "[12,   320]\t loss: 1.324\t accuracy: 97.188\n",
            "[12,   330]\t loss: 1.295\t accuracy: 97.812\n",
            "[12,   340]\t loss: 1.297\t accuracy: 98.750\n",
            "[12,   350]\t loss: 1.330\t accuracy: 97.188\n",
            "[12,   360]\t loss: 1.335\t accuracy: 97.500\n",
            "[12,   370]\t loss: 1.318\t accuracy: 98.438\n",
            "[12,   380]\t loss: 1.288\t accuracy: 99.375\n",
            "[12,   390]\t loss: 1.305\t accuracy: 98.125\n",
            "[12,   400]\t loss: 1.279\t accuracy: 98.125\n",
            "[13,    10]\t loss: 1.273\t accuracy: 99.688\n",
            "[13,    20]\t loss: 1.266\t accuracy: 98.750\n",
            "[13,    30]\t loss: 1.290\t accuracy: 98.125\n",
            "[13,    40]\t loss: 1.271\t accuracy: 99.062\n",
            "[13,    50]\t loss: 1.269\t accuracy: 99.062\n",
            "[13,    60]\t loss: 1.263\t accuracy: 98.750\n",
            "[13,    70]\t loss: 1.271\t accuracy: 99.375\n",
            "[13,    80]\t loss: 1.265\t accuracy: 98.750\n",
            "[13,    90]\t loss: 1.267\t accuracy: 98.125\n",
            "[13,   100]\t loss: 1.280\t accuracy: 98.438\n",
            "[13,   110]\t loss: 1.274\t accuracy: 99.062\n",
            "[13,   120]\t loss: 1.241\t accuracy: 99.688\n",
            "[13,   130]\t loss: 1.250\t accuracy: 99.062\n",
            "[13,   140]\t loss: 1.260\t accuracy: 99.375\n",
            "[13,   150]\t loss: 1.273\t accuracy: 98.438\n",
            "[13,   160]\t loss: 1.291\t accuracy: 98.125\n",
            "[13,   170]\t loss: 1.261\t accuracy: 99.062\n",
            "[13,   180]\t loss: 1.281\t accuracy: 97.812\n",
            "[13,   190]\t loss: 1.259\t accuracy: 100.000\n",
            "[13,   200]\t loss: 1.274\t accuracy: 98.438\n",
            "[13,   210]\t loss: 1.256\t accuracy: 99.688\n",
            "[13,   220]\t loss: 1.270\t accuracy: 99.062\n",
            "[13,   230]\t loss: 1.270\t accuracy: 98.438\n",
            "[13,   240]\t loss: 1.287\t accuracy: 98.438\n",
            "[13,   250]\t loss: 1.252\t accuracy: 98.750\n",
            "[13,   260]\t loss: 1.267\t accuracy: 98.438\n",
            "[13,   270]\t loss: 1.284\t accuracy: 98.750\n",
            "[13,   280]\t loss: 1.243\t accuracy: 99.375\n",
            "[13,   290]\t loss: 1.262\t accuracy: 99.375\n",
            "[13,   300]\t loss: 1.275\t accuracy: 98.125\n",
            "[13,   310]\t loss: 1.286\t accuracy: 99.375\n",
            "[13,   320]\t loss: 1.309\t accuracy: 97.812\n",
            "[13,   330]\t loss: 1.259\t accuracy: 99.375\n",
            "[13,   340]\t loss: 1.289\t accuracy: 97.500\n",
            "[13,   350]\t loss: 1.255\t accuracy: 99.062\n",
            "[13,   360]\t loss: 1.276\t accuracy: 98.438\n",
            "[13,   370]\t loss: 1.301\t accuracy: 98.750\n",
            "[13,   380]\t loss: 1.284\t accuracy: 98.750\n",
            "[13,   390]\t loss: 1.285\t accuracy: 98.125\n",
            "[13,   400]\t loss: 1.277\t accuracy: 98.438\n",
            "[14,    10]\t loss: 1.250\t accuracy: 98.750\n",
            "[14,    20]\t loss: 1.229\t accuracy: 99.062\n",
            "[14,    30]\t loss: 1.220\t accuracy: 99.375\n",
            "[14,    40]\t loss: 1.217\t accuracy: 99.688\n",
            "[14,    50]\t loss: 1.238\t accuracy: 99.375\n",
            "[14,    60]\t loss: 1.236\t accuracy: 99.375\n",
            "[14,    70]\t loss: 1.241\t accuracy: 99.062\n",
            "[14,    80]\t loss: 1.221\t accuracy: 100.000\n",
            "[14,    90]\t loss: 1.253\t accuracy: 98.438\n",
            "[14,   100]\t loss: 1.250\t accuracy: 98.750\n",
            "[14,   110]\t loss: 1.240\t accuracy: 99.062\n",
            "[14,   120]\t loss: 1.228\t accuracy: 99.062\n",
            "[14,   130]\t loss: 1.253\t accuracy: 98.750\n",
            "[14,   140]\t loss: 1.230\t accuracy: 99.375\n",
            "[14,   150]\t loss: 1.236\t accuracy: 99.375\n",
            "[14,   160]\t loss: 1.217\t accuracy: 99.688\n",
            "[14,   170]\t loss: 1.253\t accuracy: 98.750\n",
            "[14,   180]\t loss: 1.238\t accuracy: 99.688\n",
            "[14,   190]\t loss: 1.254\t accuracy: 97.812\n",
            "[14,   200]\t loss: 1.241\t accuracy: 99.062\n",
            "[14,   210]\t loss: 1.236\t accuracy: 99.688\n",
            "[14,   220]\t loss: 1.255\t accuracy: 99.062\n",
            "[14,   230]\t loss: 1.236\t accuracy: 100.000\n",
            "[14,   240]\t loss: 1.252\t accuracy: 99.062\n",
            "[14,   250]\t loss: 1.245\t accuracy: 99.688\n",
            "[14,   260]\t loss: 1.241\t accuracy: 99.375\n",
            "[14,   270]\t loss: 1.259\t accuracy: 98.750\n",
            "[14,   280]\t loss: 1.248\t accuracy: 98.125\n",
            "[14,   290]\t loss: 1.260\t accuracy: 99.062\n",
            "[14,   300]\t loss: 1.242\t accuracy: 99.062\n",
            "[14,   310]\t loss: 1.274\t accuracy: 99.062\n",
            "[14,   320]\t loss: 1.236\t accuracy: 99.062\n",
            "[14,   330]\t loss: 1.249\t accuracy: 99.688\n",
            "[14,   340]\t loss: 1.244\t accuracy: 99.375\n",
            "[14,   350]\t loss: 1.265\t accuracy: 98.125\n",
            "[14,   360]\t loss: 1.255\t accuracy: 99.375\n",
            "[14,   370]\t loss: 1.270\t accuracy: 98.750\n",
            "[14,   380]\t loss: 1.247\t accuracy: 99.062\n",
            "[14,   390]\t loss: 1.255\t accuracy: 99.375\n",
            "[14,   400]\t loss: 1.248\t accuracy: 98.438\n",
            "[15,    10]\t loss: 1.222\t accuracy: 99.688\n",
            "[15,    20]\t loss: 1.241\t accuracy: 99.062\n",
            "[15,    30]\t loss: 1.220\t accuracy: 99.375\n",
            "[15,    40]\t loss: 1.231\t accuracy: 98.750\n",
            "[15,    50]\t loss: 1.192\t accuracy: 100.000\n",
            "[15,    60]\t loss: 1.206\t accuracy: 99.375\n",
            "[15,    70]\t loss: 1.213\t accuracy: 99.688\n",
            "[15,    80]\t loss: 1.216\t accuracy: 99.062\n",
            "[15,    90]\t loss: 1.205\t accuracy: 100.000\n",
            "[15,   100]\t loss: 1.218\t accuracy: 99.688\n",
            "[15,   110]\t loss: 1.221\t accuracy: 98.125\n",
            "[15,   120]\t loss: 1.200\t accuracy: 99.062\n",
            "[15,   130]\t loss: 1.216\t accuracy: 99.375\n",
            "[15,   140]\t loss: 1.207\t accuracy: 100.000\n",
            "[15,   150]\t loss: 1.224\t accuracy: 98.750\n",
            "[15,   160]\t loss: 1.217\t accuracy: 99.688\n",
            "[15,   170]\t loss: 1.217\t accuracy: 99.688\n",
            "[15,   180]\t loss: 1.216\t accuracy: 99.688\n",
            "[15,   190]\t loss: 1.233\t accuracy: 99.375\n",
            "[15,   200]\t loss: 1.212\t accuracy: 99.375\n",
            "[15,   210]\t loss: 1.221\t accuracy: 98.750\n",
            "[15,   220]\t loss: 1.239\t accuracy: 98.750\n",
            "[15,   230]\t loss: 1.241\t accuracy: 100.000\n",
            "[15,   240]\t loss: 1.223\t accuracy: 99.062\n",
            "[15,   250]\t loss: 1.211\t accuracy: 100.000\n",
            "[15,   260]\t loss: 1.221\t accuracy: 99.375\n",
            "[15,   270]\t loss: 1.216\t accuracy: 99.688\n",
            "[15,   280]\t loss: 1.216\t accuracy: 99.375\n",
            "[15,   290]\t loss: 1.211\t accuracy: 99.375\n",
            "[15,   300]\t loss: 1.214\t accuracy: 99.688\n",
            "[15,   310]\t loss: 1.218\t accuracy: 98.438\n",
            "[15,   320]\t loss: 1.224\t accuracy: 98.750\n",
            "[15,   330]\t loss: 1.221\t accuracy: 99.688\n",
            "[15,   340]\t loss: 1.225\t accuracy: 99.688\n",
            "[15,   350]\t loss: 1.214\t accuracy: 98.750\n",
            "[15,   360]\t loss: 1.227\t accuracy: 99.375\n",
            "[15,   370]\t loss: 1.229\t accuracy: 99.375\n",
            "[15,   380]\t loss: 1.244\t accuracy: 99.375\n",
            "[15,   390]\t loss: 1.218\t accuracy: 99.375\n",
            "[15,   400]\t loss: 1.225\t accuracy: 99.062\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5z6rxSLskJdi"
      },
      "source": [
        "# Testing ✔"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "czMswsR5kL5i",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 646
        },
        "outputId": "253cc594-55c5-4d18-f657-f848864f9a1e"
      },
      "source": [
        "class Tester(object):\n",
        "    def __init__(self, model, dm, use_gpu):\n",
        "        self.model = model\n",
        "        self.dm = dm\n",
        "        self.use_gpu = use_gpu\n",
        "        self.calc_distmat()\n",
        "\n",
        "    def compute_rank_market1501(self, max_rank = 10):\n",
        "        num_q, num_g = self.distmat.shape\n",
        "        print('Computing CMC and mAP ...')\n",
        "        all_cmc = []\n",
        "        all_AP = []\n",
        "        num_valid_q = 0. # number of valid query\n",
        "\n",
        "        for q_idx in range(num_q):\n",
        "            # compute cmc curve\n",
        "            raw_cmc, _ = self.remove_duplication(q_idx)\n",
        "            if not np.any(raw_cmc):\n",
        "                # this condition is true when query identity does not appear in gallery\n",
        "                continue\n",
        "\n",
        "            cmc = raw_cmc.cumsum()\n",
        "            cmc[cmc > 1] = 1\n",
        "\n",
        "            all_cmc.append(cmc[:max_rank])\n",
        "            num_valid_q += 1.\n",
        "\n",
        "            # compute average precision\n",
        "            num_rel = raw_cmc.sum()\n",
        "            tmp_cmc = raw_cmc.cumsum()\n",
        "            tmp_cmc = [x / (i+1.) for i, x in enumerate(tmp_cmc)]\n",
        "            tmp_cmc = np.asarray(tmp_cmc) * raw_cmc\n",
        "            AP = tmp_cmc.sum() / num_rel\n",
        "            all_AP.append(AP)\n",
        "\n",
        "        assert num_valid_q > 0, 'Error: all query identities do not appear in gallery'\n",
        "\n",
        "        all_cmc = np.asarray(all_cmc).astype(np.float32)\n",
        "        all_cmc = all_cmc.sum(0) / num_valid_q\n",
        "        mAP = np.mean(all_AP)\n",
        "        return cmc, mAP\n",
        "\n",
        "    def visualize(self, q_index):\n",
        "        q_img, q_pid, _ = self.parse_data_for_test(self.dm.queryset[q_index])\n",
        "        _ , sorted_index = self.remove_duplication(q_index)\n",
        "        print('Top 10 images are as follow:')\n",
        "        fig = plt.figure(figsize=(16,4))\n",
        "        ax = plt.subplot(1,11,1)\n",
        "        ax.set_title('q %d\\npid %d'%(q_index, q_pid))\n",
        "        ax.axis('off')\n",
        "        self.img_show(q_img)\n",
        "        for i in range(10):\n",
        "            ax = plt.subplot(1,11,i+2)\n",
        "            ax.axis('off')\n",
        "            g_index = sorted_index[i]\n",
        "            g_img, g_pid, _  = self.parse_data_for_test(self.dm.galleryset[g_index])\n",
        "            self.img_show(g_img)\n",
        "            if g_pid == q_pid:\n",
        "                ax.set_title('g %d\\npid %d'%(g_index, g_pid) , color='green')\n",
        "            else:\n",
        "                ax.set_title('g %d\\npid %d'%(g_index, g_pid) , color='red')\n",
        "\n",
        "    def calc_distmat(self):\n",
        "        self.model.eval()\n",
        "        q_features, self.q_pids, self.q_camids = self.feature_extraction(\n",
        "            self.dm.test_loader().query,\n",
        "        )\n",
        "        g_features, self.g_pids, self.g_camids = self.feature_extraction(\n",
        "            self.dm.test_loader().gallery,\n",
        "        )\n",
        "        print('Computing feature distance ...')\n",
        "        distmat = cosine_distance(q_features, g_features)\n",
        "        self.distmat = distmat.numpy()\n",
        "        print('Sorting feature distance ...')\n",
        "        self.sorted_indices = np.argsort(self.distmat, axis=1)\n",
        "        self.matches = (self.g_pids[self.sorted_indices] == self.q_pids[:, np.newaxis]).astype(np.int32)\n",
        "\n",
        "    def remove_duplication(self, q_index):\n",
        "        q_pid = self.q_pids[q_index]\n",
        "        q_camid = self.q_camids[q_index]\n",
        "\n",
        "        order = self.sorted_indices[q_index]\n",
        "        remove = (self.g_pids[order] == q_pid) & (self.g_camids[order] == q_camid)\n",
        "        keep = np.invert(remove)\n",
        "\n",
        "        cmc = self.matches[q_index][keep]\n",
        "        sort_idx = order[keep]\n",
        "        return cmc, sort_idx\n",
        "\n",
        "    def feature_extraction(self, loader):\n",
        "        features_, pids_, camids_ = [], [], []\n",
        "        with torch.no_grad():\n",
        "            for _, data in enumerate(loader):\n",
        "                imgs, pids, camids = self.parse_data_for_test(data)\n",
        "                if self.use_gpu:\n",
        "                    imgs = imgs.cuda()\n",
        "\n",
        "                features = self.model(imgs)\n",
        "                features = features.cpu().clone()\n",
        "                features_.append(features)\n",
        "                pids_.extend(pids)\n",
        "                camids_.extend(camids)\n",
        "        features_ = torch.cat(features_, 0)\n",
        "        pids_ = np.asarray(pids_)\n",
        "        camids_ = np.asarray(camids_)\n",
        "        return features_, pids_, camids_\n",
        "\n",
        "    def img_show(self, tensor_image):\n",
        "        plt.imshow(tensor_image.permute(1, 2, 0))\n",
        "        \n",
        "    def parse_data_for_test(self, data):\n",
        "        imgs = data['img']\n",
        "        pids = data['pid']\n",
        "        camids = data['camid']\n",
        "        return imgs, pids, camids\n",
        "\n",
        "#################################################################\n",
        "def load_model(model, use_gpu):\n",
        "    if use_gpu:\n",
        "       device = torch.device('cuda:0')\n",
        "       model.load_state_dict(torch.load('./pretrained_model.pth'))\n",
        "       model.to(device)\n",
        "    else:\n",
        "       device = torch.device('cpu')\n",
        "       model.load_state_dict(torch.load('./pretrained_model.pth',map_location=device))\n",
        "\n",
        "    return model\n",
        "    \n",
        "def print_result(cmc, mAP):\n",
        "      print(\"Dataset statistics:\")\n",
        "      print(\"  ----------------------------------------\")\n",
        "      print(\"  distance  | rank1 | rank5 | mAP\")\n",
        "      print(\"  ----------------------------------------\")\n",
        "      print(\"  cosine    | %.2f  | %.2f  | %.2f \" %(cmc[0] * 100, cmc[4] * 100, mAP * 100))\n",
        "      print(\"  ----------------------------------------\")\n",
        "\n",
        "def main(root='./data', use_gpu = True, query_index = 0):\n",
        "    data_preparer = DataPreparer(root = root)\n",
        "\n",
        "    if torch.cuda.is_available() == False:\n",
        "       use_gpu = False\n",
        "\n",
        "    model = OSNet(num_classes=data_preparer.num_train_pids)\n",
        "    model = load_model(model, use_gpu)\n",
        "\n",
        "    tester = Tester(model, data_preparer, use_gpu)\n",
        "\n",
        "    cmc, mAP = tester.compute_rank_market1501()\n",
        "    print_result(cmc, mAP)\n",
        "\n",
        "    tester.visualize(query_index)\n",
        "\n",
        "\n",
        "main(use_gpu = True)"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=> Loading train (source) dataset\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/torch/utils/data/dataloader.py:481: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n",
            "  cpuset_checked))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Computing feature distance ...\n",
            "Sorting feature distance ...\n",
            "Computing CMC and mAP ...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dataset statistics:\n",
            "  ----------------------------------------\n",
            "  distance  | rank1 | rank5 | mAP\n",
            "  ----------------------------------------\n",
            "  cosine    | 100.00  | 100.00  | 49.87 \n",
            "  ----------------------------------------\n",
            "Top 10 images are as follow:\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n",
            "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1152x288 with 11 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}