init

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+data/
+__pycache__/
+__MACOSX/
+dataset.zip
+*.pth

Dockerfile

@@ -0,0 +1,19 @@
+FROM pytorch/pytorch:1.10.0-cuda11.3-cudnn8-devel
+RUN apt-key adv --keyserver keyserver.ubuntu.com --recv-keys A4B469963BF863CC
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install -y git
+RUN apt-get -y install libgl1-mesa-glx libglib2.0-0
+RUN apt-get -y install vim byobu aria2
+
+COPY . /usr/src/motorbike_cls
+# RUN ls /usr/src/motorbike_cls
+RUN cd /usr/src/motorbike_cls
+
+WORKDIR /usr/src/motorbike_cls
+
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install -r /usr/src/motorbike_cls/requirements.txt
+
+CMD ["test.py"]
+ENTRYPOINT ["python3"]

README.md

@@ -0,0 +1,12 @@
+---
+title: HI Motorcycle Trunk Cls
+emoji: 👀
+colorFrom: gray
+colorTo: indigo
+sdk: gradio
+sdk_version: 3.24.1
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,3 @@
+import os
+
+print(os.getcwd())

binary_classification.ipynb

@@ -0,0 +1,558 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "%config InlineBackend.figure_format = 'retina'\n",
+    "\n",
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pandas.core.common import flatten\n",
+    "import copy\n",
+    "import numpy as np\n",
+    "import random\n",
+    "\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch import optim\n",
+    "import torch.nn.functional as F\n",
+    "from torchvision import datasets, transforms, models\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torch.nn as nn\n",
+    "import albumentations as A\n",
+    "from albumentations.pytorch import ToTensorV2\n",
+    "import cv2\n",
+    "\n",
+    "import glob\n",
+    "from tqdm import tqdm\n",
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#######################################################\n",
+    "#               Define Transforms\n",
+    "#######################################################\n",
+    "\n",
+    "#To define an augmentation pipeline, you need to create an instance of the Compose class.\n",
+    "#As an argument to the Compose class, you need to pass a list of augmentations you want to apply. \n",
+    "#A call to Compose will return a transform function that will perform image augmentation.\n",
+    "#(https://albumentations.ai/docs/getting_started/image_augmentation/)\n",
+    "\n",
+    "train_transforms = A.Compose(\n",
+    "    [\n",
+    "        A.SmallestMaxSize(max_size=350),\n",
+    "        A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=360, p=0.5),\n",
+    "        A.RandomCrop(height=256, width=256),\n",
+    "        A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15, p=0.5),\n",
+    "        A.RandomBrightnessContrast(p=0.5),\n",
+    "        A.MultiplicativeNoise(multiplier=[0.5,2], per_channel=True, p=0.2),\n",
+    "        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),\n",
+    "        A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),\n",
+    "        A.RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5),\n",
+    "        ToTensorV2(),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "test_transforms = A.Compose(\n",
+    "    [\n",
+    "        A.SmallestMaxSize(max_size=350),\n",
+    "        A.CenterCrop(height=256, width=256),\n",
+    "        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),\n",
+    "        ToTensorV2(),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pandas.core.common import flatten\n",
+    "import copy\n",
+    "import numpy as np\n",
+    "import random\n",
+    "\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch import optim\n",
+    "import torch.nn.functional as F\n",
+    "from torchvision import datasets, transforms, models\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torch.nn as nn\n",
+    "import albumentations as A\n",
+    "from albumentations.pytorch import ToTensorV2\n",
+    "import cv2\n",
+    "\n",
+    "import glob\n",
+    "from tqdm import tqdm\n",
+    "import random\n",
+    "\n",
+    "class MotorbikeDataset(torch.utils.data.Dataset):\n",
+    "    def __init__(self, image_paths, transform=None):\n",
+    "        self.root = image_paths\n",
+    "        self.image_paths = os.listdir(image_paths)\n",
+    "        self.transform = transform\n",
+    "        \n",
+    "    def __len__(self):\n",
+    "        return len(self.image_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        image_filepath = self.image_paths[idx]\n",
+    "        \n",
+    "        image = cv2.imread(os.path.join(self.root,image_filepath))\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        \n",
+    "        label = int('t' in image_filepath)\n",
+    "        if self.transform is not None:\n",
+    "            image = self.transform(image=image)[\"image\"]\n",
+    "        \n",
+    "        return image, label\n",
+    "    \n",
+    "\n",
+    "class MotorbikeDataset_CV(torch.utils.data.Dataset):\n",
+    "    def __init__(self, root, train_transforms, val_transforms, trainval_ratio=0.8) -> None:\n",
+    "        self.root = root\n",
+    "        self.train_transforms = train_transforms\n",
+    "        self.val_transforms = val_transforms\n",
+    "        self.trainval_ratio = trainval_ratio\n",
+    "        self.train_split, self.val_split = self.gen_split()\n",
+    "        \n",
+    "    def __len__(self):\n",
+    "        return len(self.root)\n",
+    "\n",
+    "    def gen_split(self):\n",
+    "        img_list = os.listdir(self.root)\n",
+    "        n_list = [img for img in img_list if img.startswith('n_')]\n",
+    "        t_list = [img for img in img_list if img.startswith('t_')]\n",
+    "        \n",
+    "        n_train = random.choices(n_list, k=int(len(n_list)*self.trainval_ratio))\n",
+    "        t_train = random.choices(t_list, k=int(len(t_list)*self.trainval_ratio))\n",
+    "        n_val = [img for img in n_list if img not in n_train]\n",
+    "        t_val = [img for img in t_list if img not in t_train]\n",
+    "        \n",
+    "        train_split = n_train + t_train\n",
+    "        val_split = n_val + t_val\n",
+    "        return train_split, val_split\n",
+    "\n",
+    "    def get_split(self):\n",
+    "        train_dataset = Dataset_from_list(self.root, self.train_split, self.train_transforms)\n",
+    "        val_dataset = Dataset_from_list(self.root, self.val_split, self.val_transforms)\n",
+    "        return train_dataset, val_dataset\n",
+    "    \n",
+    "class Dataset_from_list(torch.utils.data.Dataset):\n",
+    "    def __init__(self, root, img_list, transform) -> None:\n",
+    "        self.root = root\n",
+    "        self.img_list = img_list\n",
+    "        self.transform = transform\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.img_list)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        image = cv2.imread(os.path.join(self.root, self.img_list[idx]))\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        \n",
+    "        label = int(self.img_list[idx].startswith('t_'))\n",
+    "        \n",
+    "        if self.transform is not None:\n",
+    "            image = self.transform(image=image)[\"image\"]\n",
+    "            \n",
+    "        return image, label\n",
+    "        \n",
+    "        \n",
+    "        \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset_CV = MotorbikeDataset_CV(\n",
+    "    root='/workspace/data/',\n",
+    "    train_transforms=train_transforms,\n",
+    "    val_transforms=test_transforms\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_dataset, val_dataset = dataset_CV.get_split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "277\n",
+      "150\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(train_dataset))\n",
+    "print(len(val_dataset))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=True)\n",
+    "val_loader = DataLoader(val_dataset,batch_size=64, shuffle=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "classes = ('no_trunk', 'trunk')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = torch.device(\"cuda:2\") if torch.cuda.is_available() else torch.device(\"cpu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "ResNet(\n",
+       "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+       "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "  (relu): ReLU(inplace=True)\n",
+       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+       "  (layer1): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer2): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (3): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer3): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (3): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (4): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (5): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer4): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
+       "  (fc): Sequential(\n",
+       "    (0): Linear(in_features=2048, out_features=2, bias=True)\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = models.resnet50(pretrained=True)\n",
+    "model.fc = nn.Sequential(\n",
+    "    # nn.Dropout(0.5),\n",
+    "    nn.Linear(model.fc.in_features, 2),\n",
+    "    # nn.Sigmoid()\n",
+    ")\n",
+    "\n",
+    "for n, p in model.named_parameters():\n",
+    "    if 'fc' in n:\n",
+    "        p.requires_grad = True\n",
+    "    else:\n",
+    "        p.requires_grad = False\n",
+    "\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch.optim as optim\n",
+    "criterion = nn.BCEWithLogitsLoss().to(device)\n",
+    "optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=0.1, momentum=0.9)\n",
+    "# optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "Target size (torch.Size([64])) must be the same as input size (torch.Size([64, 2]))",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_107755/1844816491.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m         \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m         \u001b[0mloss\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcriterion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m         \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m         \u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36m_call_impl\u001b[0;34m(self, *input, **kwargs)\u001b[0m\n\u001b[1;32m   1100\u001b[0m         if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks\n\u001b[1;32m   1101\u001b[0m                 or _global_forward_hooks or _global_forward_pre_hooks):\n\u001b[0;32m-> 1102\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mforward_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1103\u001b[0m         \u001b[0;31m# Do not call functions when jit is used\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1104\u001b[0m         \u001b[0mfull_backward_hooks\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnon_full_backward_hooks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/torch/nn/modules/loss.py\u001b[0m in \u001b[0;36mforward\u001b[0;34m(self, input, target)\u001b[0m\n\u001b[1;32m    705\u001b[0m                                                   \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    706\u001b[0m                                                   \u001b[0mpos_weight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpos_weight\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 707\u001b[0;31m                                                   reduction=self.reduction)\n\u001b[0m\u001b[1;32m    708\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    709\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/opt/conda/lib/python3.7/site-packages/torch/nn/functional.py\u001b[0m in \u001b[0;36mbinary_cross_entropy_with_logits\u001b[0;34m(input, target, weight, size_average, reduce, reduction, pos_weight)\u001b[0m\n\u001b[1;32m   2978\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2979\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2980\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Target size ({}) must be the same as input size ({})\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2981\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2982\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbinary_cross_entropy_with_logits\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpos_weight\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduction_enum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mValueError\u001b[0m: Target size (torch.Size([64])) must be the same as input size (torch.Size([64, 2]))"
+     ]
+    }
+   ],
+   "source": [
+    "for epoch in range(10):\n",
+    "    model.train()\n",
+    "    running_loss = 0.0\n",
+    "    for i, data in enumerate(train_loader, 0):\n",
+    "        inputs, labels = data[0].to(device), data[1].to(device)\n",
+    "        \n",
+    "        optimizer.zero_grad()\n",
+    "        \n",
+    "        outputs = model(inputs)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        running_loss += loss.item()\n",
+    "    \n",
+    "    print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n",
+    "    # print(\"TRAIN acc = {}\".format(acc))\n",
+    "    # running_loss = 0.0\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        model.eval()\n",
+    "        running_loss = 0.0\n",
+    "        correct =0\n",
+    "        for i, data in enumerate(val_loader, 0):\n",
+    "            inputs, labels = data[0].to(device), data[1].to(device)\n",
+    "            outputs = model(inputs)\n",
+    "            _, preds = outputs.max(1)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            running_loss += loss.item()\n",
+    "            labels_one_hot = F.one_hot(labels, 2)\n",
+    "            outputs_one_hot = F.one_hot(preds, 2)\n",
+    "            correct = correct + (labels_one_hot + outputs_one_hot == 2).sum(dim=0).to(torch.float)\n",
+    "        \n",
+    "        acc = 100 * correct / len(val_dataset)\n",
+    "        print(f'VAL: [{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n",
+    "        print(\"VAL acc = {}\".format(acc))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.11"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

classification.ipynb

@@ -0,0 +1,632 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "%config InlineBackend.figure_format = 'retina'\n",
+    "\n",
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pandas.core.common import flatten\n",
+    "import copy\n",
+    "import numpy as np\n",
+    "import random\n",
+    "\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch import optim\n",
+    "import torch.nn.functional as F\n",
+    "from torchvision import datasets, transforms, models\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torch.nn as nn\n",
+    "import albumentations as A\n",
+    "from albumentations.pytorch import ToTensorV2\n",
+    "import cv2\n",
+    "\n",
+    "import glob\n",
+    "from tqdm import tqdm\n",
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#######################################################\n",
+    "#               Define Transforms\n",
+    "#######################################################\n",
+    "\n",
+    "#To define an augmentation pipeline, you need to create an instance of the Compose class.\n",
+    "#As an argument to the Compose class, you need to pass a list of augmentations you want to apply. \n",
+    "#A call to Compose will return a transform function that will perform image augmentation.\n",
+    "#(https://albumentations.ai/docs/getting_started/image_augmentation/)\n",
+    "\n",
+    "train_transforms = A.Compose(\n",
+    "    [\n",
+    "        A.SmallestMaxSize(max_size=350),\n",
+    "        A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=360, p=0.5),\n",
+    "        A.RandomCrop(height=256, width=256),\n",
+    "        A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15, p=0.5),\n",
+    "        A.RandomBrightnessContrast(p=0.5),\n",
+    "        A.MultiplicativeNoise(multiplier=[0.5,2], per_channel=True, p=0.2),\n",
+    "        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),\n",
+    "        A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),\n",
+    "        A.RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5),\n",
+    "        ToTensorV2(),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "test_transforms = A.Compose(\n",
+    "    [\n",
+    "        A.SmallestMaxSize(max_size=350),\n",
+    "        A.CenterCrop(height=256, width=256),\n",
+    "        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),\n",
+    "        ToTensorV2(),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pandas.core.common import flatten\n",
+    "import copy\n",
+    "import numpy as np\n",
+    "import random\n",
+    "\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch import optim\n",
+    "import torch.nn.functional as F\n",
+    "from torchvision import datasets, transforms, models\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import torch.nn as nn\n",
+    "import albumentations as A\n",
+    "from albumentations.pytorch import ToTensorV2\n",
+    "import cv2\n",
+    "\n",
+    "import glob\n",
+    "from tqdm import tqdm\n",
+    "import random\n",
+    "\n",
+    "class MotorbikeDataset(torch.utils.data.Dataset):\n",
+    "    def __init__(self, image_paths, transform=None):\n",
+    "        self.root = image_paths\n",
+    "        self.image_paths = os.listdir(image_paths)\n",
+    "        self.transform = transform\n",
+    "        \n",
+    "    def __len__(self):\n",
+    "        return len(self.image_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        image_filepath = self.image_paths[idx]\n",
+    "        \n",
+    "        image = cv2.imread(os.path.join(self.root,image_filepath))\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        \n",
+    "        label = int('t' in image_filepath)\n",
+    "        if self.transform is not None:\n",
+    "            image = self.transform(image=image)[\"image\"]\n",
+    "        \n",
+    "        return image, label\n",
+    "    \n",
+    "\n",
+    "class MotorbikeDataset_CV(torch.utils.data.Dataset):\n",
+    "    def __init__(self, root, train_transforms, val_transforms, trainval_ratio=0.8) -> None:\n",
+    "        self.root = root\n",
+    "        self.train_transforms = train_transforms\n",
+    "        self.val_transforms = val_transforms\n",
+    "        self.trainval_ratio = trainval_ratio\n",
+    "        self.train_split, self.val_split = self.gen_split()\n",
+    "        \n",
+    "    def __len__(self):\n",
+    "        return len(self.root)\n",
+    "\n",
+    "    def gen_split(self):\n",
+    "        img_list = os.listdir(self.root)\n",
+    "        n_list = [img for img in img_list if img.startswith('n_')]\n",
+    "        t_list = [img for img in img_list if img.startswith('t_')]\n",
+    "        \n",
+    "        n_train = random.choices(n_list, k=int(len(n_list)*self.trainval_ratio))\n",
+    "        t_train = random.choices(t_list, k=int(len(t_list)*self.trainval_ratio))\n",
+    "        n_val = [img for img in n_list if img not in n_train]\n",
+    "        t_val = [img for img in t_list if img not in t_train]\n",
+    "        \n",
+    "        train_split = n_train + t_train\n",
+    "        val_split = n_val + t_val\n",
+    "        return train_split, val_split\n",
+    "\n",
+    "    def get_split(self):\n",
+    "        train_dataset = Dataset_from_list(self.root, self.train_split, self.train_transforms)\n",
+    "        val_dataset = Dataset_from_list(self.root, self.val_split, self.val_transforms)\n",
+    "        return train_dataset, val_dataset\n",
+    "    \n",
+    "class Dataset_from_list(torch.utils.data.Dataset):\n",
+    "    def __init__(self, root, img_list, transform) -> None:\n",
+    "        self.root = root\n",
+    "        self.img_list = img_list\n",
+    "        self.transform = transform\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.img_list)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        image = cv2.imread(os.path.join(self.root, self.img_list[idx]))\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "        \n",
+    "        label = int(self.img_list[idx].startswith('t_'))\n",
+    "        \n",
+    "        if self.transform is not None:\n",
+    "            image = self.transform(image=image)[\"image\"]\n",
+    "            \n",
+    "        return image, label\n",
+    "        \n",
+    "        \n",
+    "        \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset_CV = MotorbikeDataset_CV(\n",
+    "    root='/workspace/data/',\n",
+    "    train_transforms=train_transforms,\n",
+    "    val_transforms=test_transforms\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_dataset, val_dataset = dataset_CV.get_split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "277\n",
+      "166\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(train_dataset))\n",
+    "print(len(val_dataset))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=True)\n",
+    "val_loader = DataLoader(val_dataset,batch_size=64, shuffle=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "classes = ('no_trunk', 'trunk')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = torch.device(\"cuda:1\") if torch.cuda.is_available() else torch.device(\"cpu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "ResNet(\n",
+       "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+       "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "  (relu): ReLU(inplace=True)\n",
+       "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+       "  (layer1): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer2): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (3): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer3): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "        (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (3): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (4): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (5): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (layer4): Sequential(\n",
+       "    (0): Bottleneck(\n",
+       "      (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "      (downsample): Sequential(\n",
+       "        (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
+       "        (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      )\n",
+       "    )\n",
+       "    (1): Bottleneck(\n",
+       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "    (2): Bottleneck(\n",
+       "      (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+       "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+       "      (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+       "      (relu): ReLU(inplace=True)\n",
+       "    )\n",
+       "  )\n",
+       "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
+       "  (fc): Sequential(\n",
+       "    (0): Linear(in_features=2048, out_features=2, bias=True)\n",
+       "  )\n",
+       ")"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = models.resnet50(pretrained=True)\n",
+    "model.fc = nn.Sequential(\n",
+    "    # nn.Dropout(0.5),\n",
+    "    nn.Linear(model.fc.in_features, 2)\n",
+    ")\n",
+    "\n",
+    "for n, p in model.named_parameters():\n",
+    "    if 'fc' in n:\n",
+    "        p.requires_grad = True\n",
+    "    else:\n",
+    "        p.requires_grad = False\n",
+    "\n",
+    "model.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch.optim as optim\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=0.1, momentum=0.9)\n",
+    "# optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1,     4] loss: 0.009\n",
+      "VAL: [1,     3] loss: 0.028\n",
+      "VAL acc = tensor([51.8072,  0.0000], device='cuda:1')\n",
+      "[2,     4] loss: 0.026\n",
+      "VAL: [2,     3] loss: 0.018\n",
+      "VAL acc = tensor([51.8072,  0.0000], device='cuda:1')\n",
+      "[3,     4] loss: 0.014\n",
+      "VAL: [3,     3] loss: 0.003\n",
+      "VAL acc = tensor([50.6024, 33.7349], device='cuda:1')\n",
+      "[4,     4] loss: 0.006\n",
+      "VAL: [4,     3] loss: 0.006\n",
+      "VAL acc = tensor([21.0843, 46.9879], device='cuda:1')\n",
+      "[5,     4] loss: 0.007\n",
+      "VAL: [5,     3] loss: 0.006\n",
+      "VAL acc = tensor([50.6024, 30.1205], device='cuda:1')\n",
+      "[6,     4] loss: 0.005\n",
+      "VAL: [6,     3] loss: 0.003\n",
+      "VAL acc = tensor([50.0000, 38.5542], device='cuda:1')\n",
+      "[7,     4] loss: 0.005\n",
+      "VAL: [7,     3] loss: 0.002\n",
+      "VAL acc = tensor([49.3976, 39.7590], device='cuda:1')\n",
+      "[8,     4] loss: 0.003\n",
+      "VAL: [8,     3] loss: 0.004\n",
+      "VAL acc = tensor([50.6024, 33.1325], device='cuda:1')\n",
+      "[9,     4] loss: 0.005\n",
+      "VAL: [9,     3] loss: 0.002\n",
+      "VAL acc = tensor([48.1928, 41.5663], device='cuda:1')\n",
+      "[10,     4] loss: 0.004\n",
+      "VAL: [10,     3] loss: 0.002\n",
+      "VAL acc = tensor([49.3976, 38.5542], device='cuda:1')\n"
+     ]
+    }
+   ],
+   "source": [
+    "for epoch in range(10):\n",
+    "    model.train()\n",
+    "    running_loss = 0.0\n",
+    "    for i, data in enumerate(train_loader, 0):\n",
+    "        inputs, labels = data[0].to(device), data[1].to(device)\n",
+    "        \n",
+    "        optimizer.zero_grad()\n",
+    "        \n",
+    "        outputs = model(inputs)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        running_loss += loss.item()\n",
+    "    \n",
+    "    print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n",
+    "    # print(\"TRAIN acc = {}\".format(acc))\n",
+    "    # running_loss = 0.0\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        model.eval()\n",
+    "        running_loss = 0.0\n",
+    "        correct =0\n",
+    "        for i, data in enumerate(val_loader, 0):\n",
+    "            inputs, labels = data[0].to(device), data[1].to(device)\n",
+    "            outputs = model(inputs)\n",
+    "            _, preds = outputs.max(1)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            running_loss += loss.item()\n",
+    "            labels_one_hot = F.one_hot(labels, 2)\n",
+    "            outputs_one_hot = F.one_hot(preds, 2)\n",
+    "            correct = correct + (labels_one_hot + outputs_one_hot == 2).sum(dim=0).to(torch.float)\n",
+    "        \n",
+    "        acc = 100 * correct / len(val_dataset)\n",
+    "        print(f'VAL: [{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n",
+    "        print(\"VAL acc = {}\".format(acc))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "349"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(os.listdir('/workspace//data'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "n_0000000187.jpg\n",
+      "t_0000000182.jpg\n"
+     ]
+    }
+   ],
+   "source": [
+    "root = '/workspace/data'\n",
+    "for img in os.listdir(root):\n",
+    "    try:\n",
+    "        image = cv2.imread(os.path.join(root,img))\n",
+    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "    except:\n",
+    "        print(img)\n",
+    "        \n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.11"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

dataset.py

@@ -0,0 +1,96 @@
+import os
+import matplotlib.pyplot as plt
+from pandas.core.common import flatten
+import copy
+import numpy as np
+import random
+
+import torch
+from torch import nn
+from torch import optim
+import torch.nn.functional as F
+from torchvision import datasets, transforms, models
+from torch.utils.data import Dataset, DataLoader
+import torch.nn as nn
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+import cv2
+
+import glob
+from tqdm import tqdm
+import random
+
+class MotorbikeDataset(torch.utils.data.Dataset):
+    def __init__(self, image_paths, transform=None):
+        self.root = image_paths
+        self.image_paths = os.listdir(image_paths)
+        self.transform = transform
+        
+    def __len__(self):
+        return len(self.image_paths)
+
+    def __getitem__(self, idx):
+        image_filepath = self.image_paths[idx]
+        
+        image = cv2.imread(os.path.join(self.root,image_filepath))
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        label = int('t' in image_filepath)
+        if self.transform is not None:
+            image = self.transform(image=image)["image"]
+        
+        return image, label
+    
+
+class MotorbikeDataset_CV(torch.utils.data.Dataset):
+    def __init__(self, root, train_transforms, val_transforms, trainval_ratio=0.8) -> None:
+        self.root = root
+        self.train_transforms = train_transforms
+        self.val_transforms = val_transforms
+        self.trainval_ratio = trainval_ratio
+        self.train_split, self.val_split = self.gen_split()
+        
+    def __len__(self):
+        return len(self.root)
+
+    def gen_split(self):
+        img_list = os.listdir(self.root)
+        n_list = [img for img in img_list if img.startswith('n_')]
+        t_list = [img for img in img_list if img.startswith('t_')]
+        
+        n_train = random.choices(n_list, k=int(len(n_list)*self.trainval_ratio))
+        t_train = random.choices(t_list, k=int(len(t_list)*self.trainval_ratio))
+        n_val = [img for img in n_list if img not in n_train]
+        t_val = [img for img in t_list if img not in t_train]
+        
+        train_split = n_train + t_train
+        val_split = n_val + t_val
+        return train_split, val_split
+
+    def get_split(self):
+        train_dataset = Dataset_from_list(self.root, self.train_split, self.train_transforms)
+        val_dataset = Dataset_from_list(self.root, self.val_split, self.val_transforms)
+        return train_dataset, val_dataset
+    
+class Dataset_from_list(torch.utils.data.Dataset):
+    def __init__(self, root, img_list, transform) -> None:
+        self.root = root
+        self.img_list = img_list
+        self.transform = transform
+    
+    def __len__(self):
+        return len(self.img_list)
+    
+    def __getitem__(self, idx):
+        image = cv2.imread(os.path.join(self.root, self.img_list[idx]))
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        label = int(self.img_list[idx].startswith('t_'))
+        
+        if self.transform is not None:
+            image = self.transform(image=image)["image"]
+            
+        return image, label
+        
+        
+        

main.py

@@ -0,0 +1,119 @@
+import os
+import sys
+
+import matplotlib.pyplot as plt
+from pandas.core.common import flatten
+
+import torch
+from torch import nn
+from torch import optim
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from torchvision import datasets, transforms, models
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+
+from tqdm import tqdm
+import random
+
+sys.path.append('/workspace')
+import dataset
+
+
+
+train_transforms = A.Compose(
+    [
+        A.SmallestMaxSize(max_size=350),
+        A.ShiftScaleRotate(shift_limit=0.05, scale_limit=0.05, rotate_limit=360, p=0.5),
+        A.RandomCrop(height=256, width=256),
+        A.RGBShift(r_shift_limit=15, g_shift_limit=15, b_shift_limit=15, p=0.5),
+        A.RandomBrightnessContrast(p=0.5),
+        A.MultiplicativeNoise(multiplier=[0.5,2], per_channel=True, p=0.2),
+        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
+        A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),
+        A.RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5),
+        ToTensorV2(),
+    ]
+)
+
+test_transforms = A.Compose(
+    [
+        A.SmallestMaxSize(max_size=350),
+        A.CenterCrop(height=256, width=256),
+        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
+        ToTensorV2(),
+    ]
+)
+
+dataset_CV = dataset.MotorbikeDataset_CV(
+    root='/workspace/data/',
+    train_transforms=train_transforms,
+    val_transforms=test_transforms
+    )
+
+train_dataset, val_dataset = dataset_CV.get_split()
+
+train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, drop_last=True)
+val_loader = DataLoader(val_dataset,batch_size=64, shuffle=False)
+
+device = torch.device("cuda:3") if torch.cuda.is_available() else torch.device("cpu")
+
+model = models.resnet50(pretrained=True)
+model.fc = nn.Sequential(
+    nn.Dropout(0.5),
+    nn.Linear(model.fc.in_features, 2)
+)
+
+for n, p in model.named_parameters():
+    if 'fc' in n:
+        p.requires_grad = True
+    else:
+        p.requires_grad = False
+
+model.to(device)
+
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
+scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5)
+best_acc = 0.0
+
+for epoch in range(10):
+    model.train()
+    running_loss = 0.0
+    for i, data in enumerate(train_loader, 0):
+        inputs, labels = data[0].to(device), data[1].to(device)
+        
+        optimizer.zero_grad()
+        
+        outputs = model(inputs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+        running_loss += loss.item()
+    scheduler.step()
+    
+    print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
+    # print("TRAIN acc = {}".format(acc))
+    running_loss = 0.0
+    
+    with torch.no_grad():
+        model.eval()
+        running_loss = 0.0
+        correct =0
+        for i, data in enumerate(val_loader, 0):
+            inputs, labels = data[0].to(device), data[1].to(device)
+            outputs = model(inputs)
+            _, preds = outputs.max(1)
+            loss = criterion(outputs, labels)
+            running_loss += loss.item()
+            labels_one_hot = F.one_hot(labels, 2)
+            outputs_one_hot = F.one_hot(preds, 2)
+            correct = correct + (labels_one_hot + outputs_one_hot == 2).sum().to(torch.float)
+        
+        acc = 100 * correct / len(val_dataset)
+        print(f'VAL: [{epoch + 1}, {i + 1:5d}] loss: {running_loss / len(val_loader):.3f}')
+        print("VAL acc = {:.2f}".format(acc))
+        if best_acc < acc:
+            torch.save(model.state_dict(), './result/best_model.pth')

requirements.txt

@@ -0,0 +1,7 @@
+pandas
+numpy
+albumentations
+opencv-python
+tqdm
+matplotlib
+jupyter

test.py

@@ -0,0 +1,89 @@
+import os
+import sys
+
+import matplotlib.pyplot as plt
+from pandas.core.common import flatten
+
+import torch
+from torch import nn
+from torch import optim
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+from torchvision import datasets, transforms, models
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+
+from tqdm import tqdm
+import random
+import cv2
+
+sys.path.append('/workspace')
+import dataset
+import argparse
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='MiSLAS training (Stage-2)')
+    parser.add_argument('--input',
+                        help='test image path',
+                        required=True,
+                        type=str)
+    args = parser.parse_args()
+    return args
+
+classes = ('no_trunk', 'trunk')
+
+test_transforms = A.Compose(
+    [
+        A.SmallestMaxSize(max_size=350),
+        A.CenterCrop(height=256, width=256),
+        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
+        ToTensorV2(),
+    ]
+)
+
+def main():
+    args = parse_args()
+    assert os.path.exists(args.input)
+    device = torch.device("cuda:3") if torch.cuda.is_available() else torch.device("cpu")
+
+    model = models.resnet50(pretrained=True)
+    model.fc = nn.Sequential(
+        nn.Dropout(0.5),
+        nn.Linear(model.fc.in_features, 2)
+    )
+
+    state_dict = torch.load('./result/best_model.pth')
+    model.load_state_dict(state_dict)
+
+    for _, p in model.named_parameters():
+        p.requires_grad = False
+
+    model.to(device)
+    model.eval()
+
+    test_transforms = A.Compose(
+        [
+            A.SmallestMaxSize(max_size=350),
+            A.CenterCrop(height=256, width=256),
+            A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
+            ToTensorV2(),
+        ]
+    )
+
+    image = cv2.imread(args.input)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    image = test_transforms(image=image)["image"]
+    image = torch.unsqueeze(image, 0).to(device)
+
+    output = model(image)
+    _, preds = output.max(1)
+
+    input_cls = 'trunk' if 't_' in args.input else 'no_trunk'
+
+    print("input: %s \n" %(input_cls))
+    print("output: %s" %(classes[preds.item()]))
+
+if __name__ == '__main__':
+    main()

utils.py

@@ -0,0 +1,12 @@
+import torch
+
+
+def mic_acc_cal(preds, labels):
+    if isinstance(labels, tuple):
+        assert len(labels) == 3
+        targets_a, targets_b, lam = labels
+        acc_mic_top1 = (lam * preds.eq(targets_a.data).cpu().sum().float() \
+                       + (1 - lam) * preds.eq(targets_b.data).cpu().sum().float()) / len(preds)
+    else:
+        acc_mic_top1 = (preds == labels).sum().item() / len(labels)
+    return acc_mic_top1