Analog_UNet_MedNas_nuclei.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Install AIHWKIT\n",
        "- This installation is for a GPU enabled Google Colab environment.\n",
        "If you're using it on your local machine, please refer to the [documentation](https://aihwkit.readthedocs.io/en/latest/install.html)\n"
      ],
      "metadata": {
        "id": "XnMyj4kHY4rH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!wget https://aihwkit-gpu-demo.s3.us-east.cloud-object-storage.appdomain.cloud/aihwkit-0.8.0+cuda117-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl\n",
        "!pip install aihwkit-0.8.0+cuda117-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl"
      ],
      "metadata": {
        "id": "s6dBOCsaGzoM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Install monai package\n",
        "- For advanced settings, please refer to the [documentation](https://docs.monai.io/en/latest/installation.html#installation-guide)"
      ],
      "metadata": {
        "id": "FsbVLeWfZVCw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!python -c \"import monai\" || pip install -q \"monai-weekly[gdown, nibabel, tqdm, ignite, einops]\"\n",
        "!python -c \"import matplotlib\" || pip install -q matplotlib\n",
        "%matplotlib inline"
      ],
      "metadata": {
        "id": "EraNm11VHnq0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a72c5928-1442-4f22-da9c-64e3edd8a7e1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2023-10-30 11:35:56.492771: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
            "2023-10-30 11:35:56.492827: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
            "2023-10-30 11:35:56.492864: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
            "2023-10-30 11:35:56.500947: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
            "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
            "2023-10-30 11:35:58.928622: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Dataset download\n",
        "- We use the same transformations and dependencies as [nested-unet](https://github.com/4uiiurz1/pytorch-nested-unet)(UNet++), so we clone the repo and use the same repo structure"
      ],
      "metadata": {
        "id": "to2brybmZ6UH"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m88RmTo9Gm4e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "363fc3db-b921-42b7-809a-71f947479597"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "fatal: destination path 'pytorch-nested-unet' already exists and is not an empty directory.\n"
          ]
        }
      ],
      "source": [
        "!git clone https://github.com/4uiiurz1/pytorch-nested-unet"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%cd pytorch-nested-unet"
      ],
      "metadata": {
        "id": "JQFNEb34Gy0A",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39045ade-42ce-4153-d5eb-0d65c0035528"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/pytorch-nested-unet\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -r requirements.txt"
      ],
      "metadata": {
        "id": "NEfn9lLYGvPR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Mount dataset from kaggle\n",
        "- Upload your kaggle.json file and execute the following cells, for more details please refer to this [blog](https://www.analyticsvidhya.com/blog/2021/06/how-to-load-kaggle-datasets-directly-into-google-colab/)"
      ],
      "metadata": {
        "id": "MqzZ_H6FaeEP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!mkdir ~/.kaggle\n",
        "!cp /content/kaggle.json ~/.kaggle\n",
        "!chmod 600 ~/.kaggle/kaggle.json\n",
        "!kaggle competitions download data-science-bowl-2018"
      ],
      "metadata": {
        "id": "fQMvfj_9GvRd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4faec93e-313e-48db-c211-0a3cc7aa5ace"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "mkdir: cannot create directory ‘/root/.kaggle’: File exists\n",
            "Downloading data-science-bowl-2018.zip to /content/pytorch-nested-unet\n",
            " 97% 349M/358M [00:03<00:00, 137MB/s]\n",
            "100% 358M/358M [00:03<00:00, 119MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!unzip /content/pytorch-nested-unet/data-science-bowl-2018.zip -d /content/pytorch-nested-unet/inputs\n",
        "!unzip /content/pytorch-nested-unet/inputs/stage1_train.zip -d /content/pytorch-nested-unet/inputs/stage1_train/\n",
        "!unzip /content/pytorch-nested-unet/inputs/stage1_test.zip -d /content/pytorch-nested-unet/inputs/stage1_test/\n",
        "!unzip /content/pytorch-nested-unet/inputs/stage1_train_labels.csv.zip -d /content/pytorch-nested-unet/inputs/stage1_train_labels/"
      ],
      "metadata": {
        "id": "8mtwUO6rGvTp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "%cd /content/pytorch-nested-unet/\n",
        "!pwd"
      ],
      "metadata": {
        "id": "2VYmv8sFGvVp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e4559dcf-43f0-48c2-d276-c7215fef056e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/pytorch-nested-unet\n",
            "/content/pytorch-nested-unet\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data loading in Colab:"
      ],
      "metadata": {
        "id": "wsoAOWw4frDP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "from glob import glob\n",
        "\n",
        "import cv2\n",
        "import numpy as np\n",
        "from tqdm import tqdm\n",
        "\n",
        "\n",
        "def main():\n",
        "    img_size = 96\n",
        "\n",
        "    paths = glob('/content/pytorch-nested-unet/inputs/stage1_train/*')\n",
        "\n",
        "    os.makedirs('inputs/dsb2018_%d/images' % img_size, exist_ok=True)\n",
        "    os.makedirs('inputs/dsb2018_%d/masks/0' % img_size, exist_ok=True)\n",
        "    print(\"here\")\n",
        "    for i in tqdm(range(len(paths))):\n",
        "        print(i)\n",
        "        path = paths[i]\n",
        "        img = cv2.imread(os.path.join(path, 'images',#\n",
        "                         os.path.basename(path) + '.png'))\n",
        "        mask = np.zeros((img.shape[0], img.shape[1]))\n",
        "        for mask_path in glob(os.path.join(path, 'masks', '*')):\n",
        "            mask_ = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE) > 127\n",
        "            mask[mask_] = 1\n",
        "        if len(img.shape) == 2:\n",
        "            img = np.tile(img[..., None], (1, 1, 3))\n",
        "        if img.shape[2] == 4:\n",
        "            img = img[..., :3]\n",
        "        img = cv2.resize(img, (img_size, img_size))\n",
        "        mask = cv2.resize(mask, (img_size, img_size))\n",
        "        cv2.imwrite(os.path.join('inputs/dsb2018_%d/images' % img_size,\n",
        "                    os.path.basename(path) + '.png'), img)\n",
        "        cv2.imwrite(os.path.join('inputs/dsb2018_%d/masks/0' % img_size,\n",
        "                    os.path.basename(path) + '.png'), (mask * 255).astype('uint8'))\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    main()\n"
      ],
      "metadata": {
        "id": "sTPpHGovGvX2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Helper functions:"
      ],
      "metadata": {
        "id": "J4WjjtBLgAcg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import cv2\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.utils.data\n",
        "\n",
        "\n",
        "class Dataset(torch.utils.data.Dataset):\n",
        "    def __init__(self, img_ids, img_dir, mask_dir, img_ext, mask_ext, num_classes, transform=None):\n",
        "        \"\"\"\n",
        "        Args:\n",
        "            img_ids (list): Image ids.\n",
        "            img_dir: Image file directory.\n",
        "            mask_dir: Mask file directory.\n",
        "            img_ext (str): Image file extension.\n",
        "            mask_ext (str): Mask file extension.\n",
        "            num_classes (int): Number of classes.\n",
        "            transform (Compose, optional): Compose transforms of albumentations. Defaults to None.\n",
        "\n",
        "        Note:\n",
        "            Make sure to put the files as the following structure:\n",
        "            <dataset name>\n",
        "            ├── images\n",
        "            |   ├── 0a7e06.jpg\n",
        "            │   ├── 0aab0a.jpg\n",
        "            │   ├── 0b1761.jpg\n",
        "            │   ├── ...\n",
        "            |\n",
        "            └── masks\n",
        "                ├── 0\n",
        "                |   ├── 0a7e06.png\n",
        "                |   ├── 0aab0a.png\n",
        "                |   ├── 0b1761.png\n",
        "                |   ├── ...\n",
        "                |\n",
        "                ├── 1\n",
        "                |   ├── 0a7e06.png\n",
        "                |   ├── 0aab0a.png\n",
        "                |   ├── 0b1761.png\n",
        "                |   ├── ...\n",
        "                ...\n",
        "        \"\"\"\n",
        "        self.img_ids = img_ids\n",
        "        self.img_dir = img_dir\n",
        "        self.mask_dir = mask_dir\n",
        "        self.img_ext = img_ext\n",
        "        self.mask_ext = mask_ext\n",
        "        self.num_classes = num_classes\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.img_ids)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        img_id = self.img_ids[idx]\n",
        "\n",
        "        img = cv2.imread(os.path.join(self.img_dir, img_id + self.img_ext))\n",
        "\n",
        "        mask = []\n",
        "        for i in range(self.num_classes):\n",
        "            mask.append(cv2.imread(os.path.join(self.mask_dir, str(i),\n",
        "                        img_id + self.mask_ext), cv2.IMREAD_GRAYSCALE)[..., None])\n",
        "        mask = np.dstack(mask)\n",
        "\n",
        "        if self.transform is not None:\n",
        "            augmented = self.transform(image=img, mask=mask)\n",
        "            img = augmented['image']\n",
        "            mask = augmented['mask']\n",
        "\n",
        "        img = img.astype('float32') / 255\n",
        "        img = img.transpose(2, 0, 1)\n",
        "        mask = mask.astype('float32') / 255\n",
        "        mask = mask.transpose(2, 0, 1)\n",
        "\n",
        "        return img, mask, {'img_id': img_id}"
      ],
      "metadata": {
        "id": "msHL3n3DGvZy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Metric functions\n"
      ],
      "metadata": {
        "id": "FX01faBbgF13"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "def iou_score(output, target):\n",
        "    smooth = 1e-5\n",
        "\n",
        "    if torch.is_tensor(output):\n",
        "        output = torch.sigmoid(output).data.cpu().numpy()\n",
        "    if torch.is_tensor(target):\n",
        "        target = target.data.cpu().numpy()\n",
        "    output_ = output > 0.5\n",
        "    target_ = target > 0.5\n",
        "    intersection = (output_ & target_).sum()\n",
        "    union = (output_ | target_).sum()\n",
        "\n",
        "    return (intersection + smooth) / (union + smooth)\n",
        "\n",
        "\n",
        "def dice_coef(output, target):\n",
        "    smooth = 1e-5\n",
        "\n",
        "    output = torch.sigmoid(output).view(-1).data.cpu().numpy()\n",
        "    target = target.view(-1).data.cpu().numpy()\n",
        "    intersection = (output * target).sum()\n",
        "\n",
        "    return (2. * intersection + smooth) / \\\n",
        "        (output.sum() + target.sum() + smooth)"
      ],
      "metadata": {
        "id": "IBXBInw2Gvci"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import argparse\n",
        "\n",
        "\n",
        "def str2bool(v):\n",
        "    if v.lower() in ['true', 1]:\n",
        "        return True\n",
        "    elif v.lower() in ['false', 0]:\n",
        "        return False\n",
        "    else:\n",
        "        raise argparse.ArgumentTypeError('Boolean value expected.')\n",
        "\n",
        "\n",
        "def count_params(model):\n",
        "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
        "\n",
        "\n",
        "class AverageMeter(object):\n",
        "    \"\"\"Computes and stores the average and current value\"\"\"\n",
        "\n",
        "    def __init__(self):\n",
        "        self.reset()\n",
        "\n",
        "    def reset(self):\n",
        "        self.val = 0\n",
        "        self.avg = 0\n",
        "        self.sum = 0\n",
        "        self.count = 0\n",
        "\n",
        "    def update(self, val, n=1):\n",
        "        self.val = val\n",
        "        self.sum += val * n\n",
        "        self.count += n\n",
        "        self.avg = self.sum / self.count"
      ],
      "metadata": {
        "id": "OoDjgZF5GvvY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Loss functions"
      ],
      "metadata": {
        "id": "wx4zp_YAgNjb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "try:\n",
        "    from LovaszSoftmax.pytorch.lovasz_losses import lovasz_hinge\n",
        "except ImportError:\n",
        "    pass\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "class BCEDiceLoss(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "    def forward(self, input, target):\n",
        "        bce = F.binary_cross_entropy_with_logits(input, target)\n",
        "        smooth = 1e-5\n",
        "        input = torch.sigmoid(input)\n",
        "        num = target.size(0)\n",
        "        input = input.view(num, -1)\n",
        "        target = target.view(num, -1)\n",
        "        intersection = (input * target)\n",
        "        dice = (2. * intersection.sum(1) + smooth) / (input.sum(1) + target.sum(1) + smooth)\n",
        "        dice = 1 - dice.sum() / num\n",
        "        return 0.5 * bce + dice\n",
        "\n",
        "\n",
        "class LovaszHingeLoss(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "    def forward(self, input, target):\n",
        "        input = input.squeeze(1)\n",
        "        target = target.squeeze(1)\n",
        "        loss = lovasz_hinge(input, target, per_image=True)\n",
        "\n",
        "        return loss"
      ],
      "metadata": {
        "id": "dIlgXExlGvxb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Configuration of parameters:"
      ],
      "metadata": {
        "id": "BxQp3JPTgRbV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "config = {\n",
        "        'spatial_dims': 2,  # it's 2 for 2D images; would be 3 for 3D images\n",
        "        'in_channels': 3,   # e.g., 3 for RGB input images\n",
        "        'out_channels': 1,  # e.g., 1 for binary segmentation tasks\n",
        "        'channels': (16, 32, 64, 128, 256), # Number of channels in the inner layers\n",
        "        'strides': (2, 2, 2, 2),\n",
        "        'name': None,\n",
        "        'epochs': 200,\n",
        "        'batch_size': 64,\n",
        "        'arch': 'UNet',\n",
        "        'deep_supervision': False,\n",
        "        'input_channels': 3,\n",
        "        'num_classes': 1,\n",
        "        'input_w': 96,\n",
        "        'input_h': 96,\n",
        "        'loss': 'BCEDiceLoss',\n",
        "        'dataset': 'dsb2018_96',\n",
        "        'img_ext': '.png',\n",
        "        'mask_ext': '.png',\n",
        "        'optimizer': 'SGD',\n",
        "        'lr': 1e-3,\n",
        "        'momentum': 0.9,\n",
        "        'weight_decay': 1e-4,\n",
        "        'nesterov': False,\n",
        "        'scheduler': 'CosineAnnealingLR',\n",
        "        'min_lr': 1e-5,\n",
        "        'factor': 0.1,\n",
        "        'patience': 2,\n",
        "        'milestones': '1,2',\n",
        "        'gamma': 2/3,\n",
        "        'early_stopping': -1,\n",
        "        'num_workers': 4\n",
        "    }\n"
      ],
      "metadata": {
        "id": "59KiNnLsGvzw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training of digital model"
      ],
      "metadata": {
        "id": "HuBxoahVgZTJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import argparse\n",
        "import os\n",
        "from collections import OrderedDict\n",
        "from glob import glob\n",
        "\n",
        "import pandas as pd\n",
        "import torch\n",
        "import torch.backends.cudnn as cudnn\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import yaml\n",
        "from albumentations.augmentations import transforms\n",
        "from albumentations.core.composition import Compose, OneOf\n",
        "from sklearn.model_selection import train_test_split\n",
        "from torch.optim import lr_scheduler\n",
        "from tqdm import tqdm\n",
        "from albumentations.augmentations.geometric.rotate import RandomRotate90\n",
        "from albumentations.augmentations.geometric import Flip, Resize\n",
        "\n",
        "\n",
        "\n",
        "ARCH_NAMES = ['UNet', 'NestedUNet']\n",
        "LOSS_NAMES = ['BCEDiceLoss', 'LovaszHingeLoss']\n",
        "LOSS_NAMES.append('BCEWithLogitsLoss')\n",
        "\n",
        "\n",
        "\n",
        "def train(config, train_loader, model, criterion, optimizer):\n",
        "    avg_meters = {'loss': AverageMeter(),\n",
        "                  'iou': AverageMeter()}\n",
        "\n",
        "    model.train()\n",
        "\n",
        "    pbar = tqdm(total=len(train_loader))\n",
        "    for input, target, _ in train_loader:\n",
        "        input = input.cuda()\n",
        "        target = target.cuda()\n",
        "\n",
        "        # compute output\n",
        "        if config['deep_supervision']:\n",
        "            outputs = model(input)\n",
        "            loss = 0\n",
        "            for output in outputs:\n",
        "                loss += criterion(output, target)\n",
        "            loss /= len(outputs)\n",
        "            iou = iou_score(outputs[-1], target)\n",
        "        else:\n",
        "            output = model(input)\n",
        "            loss = criterion(output, target)\n",
        "            iou = iou_score(output, target)\n",
        "\n",
        "        # compute gradient and do optimizing step\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        avg_meters['loss'].update(loss.item(), input.size(0))\n",
        "        avg_meters['iou'].update(iou, input.size(0))\n",
        "\n",
        "        postfix = OrderedDict([\n",
        "            ('loss', avg_meters['loss'].avg),\n",
        "            ('iou', avg_meters['iou'].avg),\n",
        "        ])\n",
        "        pbar.set_postfix(postfix)\n",
        "        pbar.update(1)\n",
        "    pbar.close()\n",
        "\n",
        "    return OrderedDict([('loss', avg_meters['loss'].avg),\n",
        "                        ('iou', avg_meters['iou'].avg)])\n",
        "\n",
        "\n",
        "def validate(config, val_loader, model, criterion):\n",
        "    avg_meters = {'loss': AverageMeter(),\n",
        "                  'iou': AverageMeter()}\n",
        "\n",
        "    # switch to evaluate mode\n",
        "    model.eval()\n",
        "\n",
        "    with torch.no_grad():\n",
        "        pbar = tqdm(total=len(val_loader))\n",
        "        for input, target, _ in val_loader:\n",
        "            input = input.cuda()\n",
        "            target = target.cuda()\n",
        "\n",
        "            # compute output\n",
        "            if config['deep_supervision']:\n",
        "                outputs = model(input)\n",
        "                loss = 0\n",
        "                for output in outputs:\n",
        "                    loss += criterion(output, target)\n",
        "                loss /= len(outputs)\n",
        "                iou = iou_score(outputs[-1], target)\n",
        "            else:\n",
        "                output = model(input)\n",
        "                loss = criterion(output, target)\n",
        "                iou = iou_score(output, target)\n",
        "\n",
        "            avg_meters['loss'].update(loss.item(), input.size(0))\n",
        "            avg_meters['iou'].update(iou, input.size(0))\n",
        "\n",
        "            postfix = OrderedDict([\n",
        "                ('loss', avg_meters['loss'].avg),\n",
        "                ('iou', avg_meters['iou'].avg),\n",
        "            ])\n",
        "            pbar.set_postfix(postfix)\n",
        "            pbar.update(1)\n",
        "        pbar.close()\n",
        "\n",
        "    return OrderedDict([('loss', avg_meters['loss'].avg),\n",
        "                        ('iou', avg_meters['iou'].avg)])\n",
        "\n",
        "\n",
        "if config['name'] is None:\n",
        "    if config['deep_supervision']:\n",
        "        config['name'] = '%s_%s_wDS' % (config['dataset'], config['arch'])\n",
        "    else:\n",
        "        config['name'] = '%s_%s_woDS' % (config['dataset'], config['arch'])\n",
        "os.makedirs('models/%s' % config['name'], exist_ok=True)\n",
        "\n",
        "print('-' * 20)\n",
        "for key in config:\n",
        "    print('%s: %s' % (key, config[key]))\n",
        "print('-' * 20)\n",
        "\n",
        "with open('models/%s/config.yml' % config['name'], 'w') as f:\n",
        "    yaml.dump(config, f)\n",
        "\n",
        "# define loss function (criterion)\n",
        "if config['loss'] == 'BCEWithLogitsLoss':\n",
        "    criterion = nn.BCEWithLogitsLoss().cuda()\n",
        "elif config['loss'] == 'BCEDiceLoss':\n",
        "    criterion = BCEDiceLoss().cuda()\n",
        "else:\n",
        "    criterion = LovaszHingeLoss().cuda()\n",
        "\n",
        "cudnn.benchmark = True\n",
        "\n",
        "# create model ----------------------------------------------------------------------------------------------------\n",
        "# -----------------------------------------------------------------------------------------------------------------\n",
        "import monai\n",
        "from monai.networks.nets import UNet\n",
        "\n",
        "model = UNet(\n",
        "    spatial_dims=config['spatial_dims'],\n",
        "    in_channels=config['in_channels'],\n",
        "    out_channels=config['out_channels'],\n",
        "    channels=config['channels'],\n",
        "    strides=config['strides'],                 # number of residual units, making the network deeper\n",
        ")\n",
        "\n",
        "\n",
        "# If you have a specific task in mind, like segmentation, you might want to add a final activation layer\n",
        "# model.add_module('final_activation', torch.nn.Softmax(dim=1))  # For multi-class segmentation\n",
        "\n",
        "# Now, `model` is ready to be used in your training loop, and you can proceed with your regular training steps.\n",
        "\n",
        "\n",
        "model = model.cuda()\n",
        "\n",
        "params = filter(lambda p: p.requires_grad, model.parameters())\n",
        "if config['optimizer'] == 'Adam':\n",
        "    optimizer = optim.Adam(\n",
        "        params, lr=config['lr'], weight_decay=config['weight_decay'])\n",
        "elif config['optimizer'] == 'SGD':\n",
        "    optimizer = optim.SGD(params, lr=config['lr'], momentum=config['momentum'],\n",
        "                          nesterov=config['nesterov'], weight_decay=config['weight_decay'])\n",
        "else:\n",
        "    raise NotImplementedError\n",
        "\n",
        "if config['scheduler'] == 'CosineAnnealingLR':\n",
        "    scheduler = lr_scheduler.CosineAnnealingLR(\n",
        "        optimizer, T_max=config['epochs'], eta_min=config['min_lr'])\n",
        "elif config['scheduler'] == 'ReduceLROnPlateau':\n",
        "    scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, factor=config['factor'], patience=config['patience'],\n",
        "                                                verbose=1, min_lr=config['min_lr'])\n",
        "elif config['scheduler'] == 'MultiStepLR':\n",
        "    scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[int(e) for e in config['milestones'].split(',')], gamma=config['gamma'])\n",
        "elif config['scheduler'] == 'ConstantLR':\n",
        "    scheduler = None\n",
        "else:\n",
        "    raise NotImplementedError\n",
        "\n",
        "# Data loading code\n",
        "img_ids = glob(os.path.join('inputs', config['dataset'], 'images', '*' + config['img_ext']))\n",
        "img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]\n",
        "\n",
        "train_img_ids, val_img_ids = train_test_split(img_ids, test_size=0.2, random_state=41)\n",
        "\n",
        "train_transform = Compose([\n",
        "    RandomRotate90(),\n",
        "    Flip(),\n",
        "    OneOf([\n",
        "        transforms.HueSaturationValue(),\n",
        "        transforms.RandomBrightness(),\n",
        "        transforms.RandomContrast(),\n",
        "    ], p=1),\n",
        "    Resize(config['input_h'], config['input_w']),\n",
        "    transforms.Normalize(),\n",
        "])\n",
        "\n",
        "val_transform = Compose([\n",
        "    Resize(config['input_h'], config['input_w']),\n",
        "    transforms.Normalize(),\n",
        "])\n",
        "\n",
        "train_dataset = Dataset(\n",
        "    img_ids=train_img_ids,\n",
        "    img_dir=os.path.join('inputs', config['dataset'], 'images'),\n",
        "    mask_dir=os.path.join('inputs', config['dataset'], 'masks'),\n",
        "    img_ext=config['img_ext'],\n",
        "    mask_ext=config['mask_ext'],\n",
        "    num_classes=config['num_classes'],\n",
        "    transform=train_transform)\n",
        "val_dataset = Dataset(\n",
        "    img_ids=val_img_ids,\n",
        "    img_dir=os.path.join('inputs', config['dataset'], 'images'),\n",
        "    mask_dir=os.path.join('inputs', config['dataset'], 'masks'),\n",
        "    img_ext=config['img_ext'],\n",
        "    mask_ext=config['mask_ext'],\n",
        "    num_classes=config['num_classes'],\n",
        "    transform=val_transform)\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(\n",
        "    train_dataset,\n",
        "    batch_size=config['batch_size'],\n",
        "    shuffle=True,\n",
        "    num_workers=config['num_workers'],\n",
        "    drop_last=True)\n",
        "val_loader = torch.utils.data.DataLoader(\n",
        "    val_dataset,\n",
        "    batch_size=config['batch_size'],\n",
        "    shuffle=False,\n",
        "    num_workers=config['num_workers'],\n",
        "    drop_last=False)\n",
        "\n",
        "log = OrderedDict([\n",
        "    ('epoch', []),\n",
        "    ('lr', []),\n",
        "    ('loss', []),\n",
        "    ('iou', []),\n",
        "    ('val_loss', []),\n",
        "    ('val_iou', []),\n",
        "])\n",
        "\n",
        "best_iou = 0\n",
        "trigger = 0\n",
        "for epoch in range(config['epochs']):\n",
        "    print('Epoch [%d/%d]' % (epoch, config['epochs']))\n",
        "\n",
        "    # train for one epoch\n",
        "    train_log = train(config, train_loader, model, criterion, optimizer)\n",
        "    # evaluate on validation set\n",
        "    val_log = validate(config, val_loader, model, criterion)\n",
        "\n",
        "    if config['scheduler'] == 'CosineAnnealingLR':\n",
        "        scheduler.step()\n",
        "    elif config['scheduler'] == 'ReduceLROnPlateau':\n",
        "        scheduler.step(val_log['loss'])\n",
        "\n",
        "    print('loss %.4f - iou %.4f - val_loss %.4f - val_iou %.4f'\n",
        "          % (train_log['loss'], train_log['iou'], val_log['loss'], val_log['iou']))\n",
        "\n",
        "    log['epoch'].append(epoch)\n",
        "    log['lr'].append(config['lr'])\n",
        "    log['loss'].append(train_log['loss'])\n",
        "    log['iou'].append(train_log['iou'])\n",
        "    log['val_loss'].append(val_log['loss'])\n",
        "    log['val_iou'].append(val_log['iou'])\n",
        "\n",
        "    pd.DataFrame(log).to_csv('models/%s/log.csv' %\n",
        "                              config['name'], index=False)\n",
        "\n",
        "    trigger += 1\n",
        "\n",
        "    if val_log['iou'] > best_iou:\n",
        "        torch.save(model.state_dict(), 'models/%s/model.pth' %\n",
        "                    config['name'])\n",
        "        best_iou = val_log['iou']\n",
        "        print(\"=> saved best model\")\n",
        "        trigger = 0\n",
        "\n",
        "    # early stopping\n",
        "    if config['early_stopping'] >= 0 and trigger >= config['early_stopping']:\n",
        "        print(\"=> early stopping\")\n",
        "        break\n",
        "\n",
        "    torch.cuda.empty_cache()\n",
        "\n"
      ],
      "metadata": {
        "id": "hKHwveTDGv2W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "658591ca-e85b-4f15-bc6d-a67fe2295e82"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--------------------\n",
            "spatial_dims: 2\n",
            "in_channels: 3\n",
            "out_channels: 1\n",
            "channels: (16, 32, 64, 128, 256)\n",
            "strides: (2, 2, 2, 2)\n",
            "name: dsb2018_96_UNet_woDS\n",
            "epochs: 200\n",
            "batch_size: 64\n",
            "arch: UNet\n",
            "deep_supervision: False\n",
            "input_channels: 3\n",
            "num_classes: 1\n",
            "input_w: 96\n",
            "input_h: 96\n",
            "loss: BCEDiceLoss\n",
            "dataset: dsb2018_96\n",
            "img_ext: .png\n",
            "mask_ext: .png\n",
            "optimizer: SGD\n",
            "lr: 0.001\n",
            "momentum: 0.9\n",
            "weight_decay: 0.0001\n",
            "nesterov: False\n",
            "scheduler: CosineAnnealingLR\n",
            "min_lr: 1e-05\n",
            "factor: 0.1\n",
            "patience: 2\n",
            "milestones: 1,2\n",
            "gamma: 0.6666666666666666\n",
            "early_stopping: -1\n",
            "num_workers: 4\n",
            "--------------------\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/albumentations/augmentations/transforms.py:1258: FutureWarning: This class has been deprecated. Please use RandomBrightnessContrast\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/albumentations/augmentations/transforms.py:1284: FutureWarning: RandomContrast has been deprecated. Please use RandomBrightnessContrast\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [0/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 8/8 [00:07<00:00,  1.11it/s, loss=1.22, iou=0.107]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.46it/s, loss=1.21, iou=0.11]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.2224 - iou 0.1070 - val_loss 1.2141 - val_iou 0.1101\n",
            "=> saved best model\n",
            "Epoch [1/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.29it/s, loss=1.21, iou=0.111]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.21it/s, loss=1.2, iou=0.114]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.2138 - iou 0.1112 - val_loss 1.2045 - val_iou 0.1144\n",
            "=> saved best model\n",
            "Epoch [2/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.05it/s, loss=1.2, iou=0.115]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.96it/s, loss=1.19, iou=0.12]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.2047 - iou 0.1149 - val_loss 1.1933 - val_iou 0.1199\n",
            "=> saved best model\n",
            "Epoch [3/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.85it/s, loss=1.19, iou=0.122]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.20it/s, loss=1.18, iou=0.126]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1906 - iou 0.1217 - val_loss 1.1815 - val_iou 0.1263\n",
            "=> saved best model\n",
            "Epoch [4/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.98it/s, loss=1.18, iou=0.127]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.01it/s, loss=1.17, iou=0.133]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1812 - iou 0.1266 - val_loss 1.1704 - val_iou 0.1327\n",
            "=> saved best model\n",
            "Epoch [5/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.27it/s, loss=1.17, iou=0.132]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.63it/s, loss=1.16, iou=0.139]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1720 - iou 0.1317 - val_loss 1.1604 - val_iou 0.1386\n",
            "=> saved best model\n",
            "Epoch [6/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.23it/s, loss=1.16, iou=0.137]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.95it/s, loss=1.15, iou=0.144]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1628 - iou 0.1369 - val_loss 1.1513 - val_iou 0.1443\n",
            "=> saved best model\n",
            "Epoch [7/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.24it/s, loss=1.15, iou=0.144]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.83it/s, loss=1.14, iou=0.15]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1513 - iou 0.1440 - val_loss 1.1431 - val_iou 0.1496\n",
            "=> saved best model\n",
            "Epoch [8/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.31it/s, loss=1.14, iou=0.148]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.32it/s, loss=1.14, iou=0.155]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1446 - iou 0.1479 - val_loss 1.1354 - val_iou 0.1548\n",
            "=> saved best model\n",
            "Epoch [9/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.10it/s, loss=1.13, iou=0.155]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.16it/s, loss=1.13, iou=0.16]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1334 - iou 0.1553 - val_loss 1.1282 - val_iou 0.1602\n",
            "=> saved best model\n",
            "Epoch [10/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.18it/s, loss=1.13, iou=0.16]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.72it/s, loss=1.12, iou=0.165]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1274 - iou 0.1604 - val_loss 1.1214 - val_iou 0.1653\n",
            "=> saved best model\n",
            "Epoch [11/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.75it/s, loss=1.12, iou=0.164]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.90it/s, loss=1.11, iou=0.17]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1215 - iou 0.1641 - val_loss 1.1148 - val_iou 0.1705\n",
            "=> saved best model\n",
            "Epoch [12/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.84it/s, loss=1.12, iou=0.169]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.06it/s, loss=1.11, iou=0.176]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1151 - iou 0.1686 - val_loss 1.1085 - val_iou 0.1756\n",
            "=> saved best model\n",
            "Epoch [13/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.18it/s, loss=1.11, iou=0.176]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.16it/s, loss=1.1, iou=0.181]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1074 - iou 0.1755 - val_loss 1.1024 - val_iou 0.1807\n",
            "=> saved best model\n",
            "Epoch [14/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.02it/s, loss=1.11, iou=0.176]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.85it/s, loss=1.1, iou=0.186]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.1054 - iou 0.1762 - val_loss 1.0965 - val_iou 0.1857\n",
            "=> saved best model\n",
            "Epoch [15/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.14it/s, loss=1.1, iou=0.184]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.93it/s, loss=1.09, iou=0.191]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0962 - iou 0.1838 - val_loss 1.0908 - val_iou 0.1911\n",
            "=> saved best model\n",
            "Epoch [16/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.07it/s, loss=1.09, iou=0.186]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.27it/s, loss=1.09, iou=0.197]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0935 - iou 0.1860 - val_loss 1.0851 - val_iou 0.1966\n",
            "=> saved best model\n",
            "Epoch [17/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.98it/s, loss=1.09, iou=0.191]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.04it/s, loss=1.08, iou=0.202]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0875 - iou 0.1914 - val_loss 1.0796 - val_iou 0.2023\n",
            "=> saved best model\n",
            "Epoch [18/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.94it/s, loss=1.08, iou=0.2]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.92it/s, loss=1.07, iou=0.208]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0799 - iou 0.2000 - val_loss 1.0742 - val_iou 0.2083\n",
            "=> saved best model\n",
            "Epoch [19/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.54it/s, loss=1.07, iou=0.205]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.13it/s, loss=1.07, iou=0.214]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0743 - iou 0.2054 - val_loss 1.0689 - val_iou 0.2141\n",
            "=> saved best model\n",
            "Epoch [20/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.85it/s, loss=1.07, iou=0.209]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.99it/s, loss=1.06, iou=0.22]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0706 - iou 0.2091 - val_loss 1.0636 - val_iou 0.2203\n",
            "=> saved best model\n",
            "Epoch [21/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.71it/s, loss=1.07, iou=0.209]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.91it/s, loss=1.06, iou=0.226]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0690 - iou 0.2095 - val_loss 1.0584 - val_iou 0.2265\n",
            "=> saved best model\n",
            "Epoch [22/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.95it/s, loss=1.06, iou=0.22]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.89it/s, loss=1.05, iou=0.233]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0610 - iou 0.2200 - val_loss 1.0534 - val_iou 0.2328\n",
            "=> saved best model\n",
            "Epoch [23/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.91it/s, loss=1.05, iou=0.226]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.98it/s, loss=1.05, iou=0.239]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0535 - iou 0.2262 - val_loss 1.0483 - val_iou 0.2391\n",
            "=> saved best model\n",
            "Epoch [24/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.97it/s, loss=1.05, iou=0.236]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.83it/s, loss=1.04, iou=0.245]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0464 - iou 0.2362 - val_loss 1.0433 - val_iou 0.2454\n",
            "=> saved best model\n",
            "Epoch [25/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.91it/s, loss=1.04, iou=0.243]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.01it/s, loss=1.04, iou=0.252]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0408 - iou 0.2434 - val_loss 1.0383 - val_iou 0.2518\n",
            "=> saved best model\n",
            "Epoch [26/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.24it/s, loss=1.04, iou=0.247]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.34it/s, loss=1.03, iou=0.258]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0372 - iou 0.2471 - val_loss 1.0334 - val_iou 0.2581\n",
            "=> saved best model\n",
            "Epoch [27/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.20it/s, loss=1.03, iou=0.252]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.77it/s, loss=1.03, iou=0.265]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0341 - iou 0.2517 - val_loss 1.0285 - val_iou 0.2645\n",
            "=> saved best model\n",
            "Epoch [28/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.91it/s, loss=1.03, iou=0.259]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.12it/s, loss=1.02, iou=0.271]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0286 - iou 0.2590 - val_loss 1.0236 - val_iou 0.2707\n",
            "=> saved best model\n",
            "Epoch [29/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.44it/s, loss=1.02, iou=0.263]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.03it/s, loss=1.02, iou=0.277]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0244 - iou 0.2632 - val_loss 1.0188 - val_iou 0.2773\n",
            "=> saved best model\n",
            "Epoch [30/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.13it/s, loss=1.02, iou=0.271]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.21it/s, loss=1.01, iou=0.283]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0195 - iou 0.2709 - val_loss 1.0141 - val_iou 0.2833\n",
            "=> saved best model\n",
            "Epoch [31/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.22it/s, loss=1.01, iou=0.272]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.04it/s, loss=1.01, iou=0.289]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0145 - iou 0.2724 - val_loss 1.0093 - val_iou 0.2895\n",
            "=> saved best model\n",
            "Epoch [32/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.11it/s, loss=1.01, iou=0.283]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.23it/s, loss=1, iou=0.296]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0077 - iou 0.2829 - val_loss 1.0046 - val_iou 0.2956\n",
            "=> saved best model\n",
            "Epoch [33/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.04it/s, loss=1.01, iou=0.278]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.73it/s, loss=1, iou=0.302]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0097 - iou 0.2778 - val_loss 1.0000 - val_iou 0.3018\n",
            "=> saved best model\n",
            "Epoch [34/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.06it/s, loss=1, iou=0.287]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.00it/s, loss=0.995, iou=0.308]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0020 - iou 0.2873 - val_loss 0.9954 - val_iou 0.3078\n",
            "=> saved best model\n",
            "Epoch [35/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.35it/s, loss=1, iou=0.289]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.77it/s, loss=0.991, iou=0.313]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 1.0000 - iou 0.2894 - val_loss 0.9909 - val_iou 0.3135\n",
            "=> saved best model\n",
            "Epoch [36/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.68it/s, loss=0.993, iou=0.302]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.03it/s, loss=0.986, iou=0.319]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9931 - iou 0.3017 - val_loss 0.9865 - val_iou 0.3191\n",
            "=> saved best model\n",
            "Epoch [37/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.72it/s, loss=0.989, iou=0.303]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.54it/s, loss=0.982, iou=0.325]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9889 - iou 0.3034 - val_loss 0.9821 - val_iou 0.3245\n",
            "=> saved best model\n",
            "Epoch [38/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.29it/s, loss=0.987, iou=0.308]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.96it/s, loss=0.978, iou=0.33]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9866 - iou 0.3080 - val_loss 0.9777 - val_iou 0.3300\n",
            "=> saved best model\n",
            "Epoch [39/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.34it/s, loss=0.979, iou=0.318]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.78it/s, loss=0.973, iou=0.335]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9789 - iou 0.3182 - val_loss 0.9733 - val_iou 0.3354\n",
            "=> saved best model\n",
            "Epoch [40/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.01it/s, loss=0.981, iou=0.312]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.69it/s, loss=0.969, iou=0.341]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9812 - iou 0.3115 - val_loss 0.9689 - val_iou 0.3407\n",
            "=> saved best model\n",
            "Epoch [41/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.85it/s, loss=0.974, iou=0.322]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.94it/s, loss=0.965, iou=0.346]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9735 - iou 0.3218 - val_loss 0.9647 - val_iou 0.3459\n",
            "=> saved best model\n",
            "Epoch [42/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.86it/s, loss=0.969, iou=0.327]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.05it/s, loss=0.96, iou=0.351]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9694 - iou 0.3268 - val_loss 0.9604 - val_iou 0.3511\n",
            "=> saved best model\n",
            "Epoch [43/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.97it/s, loss=0.96, iou=0.343]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.71it/s, loss=0.956, iou=0.356]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9602 - iou 0.3429 - val_loss 0.9562 - val_iou 0.3561\n",
            "=> saved best model\n",
            "Epoch [44/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.53it/s, loss=0.963, iou=0.33]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.87it/s, loss=0.952, iou=0.361]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9631 - iou 0.3304 - val_loss 0.9520 - val_iou 0.3610\n",
            "=> saved best model\n",
            "Epoch [45/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.99it/s, loss=0.956, iou=0.337]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.05it/s, loss=0.948, iou=0.366]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9559 - iou 0.3373 - val_loss 0.9479 - val_iou 0.3659\n",
            "=> saved best model\n",
            "Epoch [46/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.77it/s, loss=0.952, iou=0.344]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.03it/s, loss=0.944, iou=0.371]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9518 - iou 0.3440 - val_loss 0.9438 - val_iou 0.3705\n",
            "=> saved best model\n",
            "Epoch [47/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.11it/s, loss=0.949, iou=0.348]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.90it/s, loss=0.94, iou=0.375]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9495 - iou 0.3476 - val_loss 0.9397 - val_iou 0.3752\n",
            "=> saved best model\n",
            "Epoch [48/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.23it/s, loss=0.941, iou=0.358]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.74it/s, loss=0.936, iou=0.38]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9412 - iou 0.3578 - val_loss 0.9357 - val_iou 0.3796\n",
            "=> saved best model\n",
            "Epoch [49/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.83it/s, loss=0.941, iou=0.358]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.78it/s, loss=0.932, iou=0.384]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9407 - iou 0.3580 - val_loss 0.9317 - val_iou 0.3839\n",
            "=> saved best model\n",
            "Epoch [50/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.94it/s, loss=0.94, iou=0.354]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.05it/s, loss=0.928, iou=0.388]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9397 - iou 0.3536 - val_loss 0.9277 - val_iou 0.3879\n",
            "=> saved best model\n",
            "Epoch [51/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.11it/s, loss=0.937, iou=0.358]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.96it/s, loss=0.924, iou=0.392]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9366 - iou 0.3581 - val_loss 0.9238 - val_iou 0.3920\n",
            "=> saved best model\n",
            "Epoch [52/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.24it/s, loss=0.928, iou=0.372]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.80it/s, loss=0.92, iou=0.396]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9284 - iou 0.3724 - val_loss 0.9199 - val_iou 0.3959\n",
            "=> saved best model\n",
            "Epoch [53/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.99it/s, loss=0.927, iou=0.368]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.84it/s, loss=0.916, iou=0.4]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9270 - iou 0.3680 - val_loss 0.9161 - val_iou 0.3998\n",
            "=> saved best model\n",
            "Epoch [54/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.06it/s, loss=0.924, iou=0.369]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.00it/s, loss=0.912, iou=0.403]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9244 - iou 0.3694 - val_loss 0.9123 - val_iou 0.4035\n",
            "=> saved best model\n",
            "Epoch [55/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.13it/s, loss=0.922, iou=0.371]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.91it/s, loss=0.909, iou=0.407]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9216 - iou 0.3713 - val_loss 0.9085 - val_iou 0.4072\n",
            "=> saved best model\n",
            "Epoch [56/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.86it/s, loss=0.916, iou=0.378]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.14it/s, loss=0.905, iou=0.411]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9164 - iou 0.3781 - val_loss 0.9048 - val_iou 0.4109\n",
            "=> saved best model\n",
            "Epoch [57/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.95it/s, loss=0.912, iou=0.382]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.65it/s, loss=0.901, iou=0.415]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9124 - iou 0.3825 - val_loss 0.9011 - val_iou 0.4145\n",
            "=> saved best model\n",
            "Epoch [58/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.90it/s, loss=0.909, iou=0.383]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.83it/s, loss=0.897, iou=0.418]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9091 - iou 0.3828 - val_loss 0.8974 - val_iou 0.4180\n",
            "=> saved best model\n",
            "Epoch [59/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.06it/s, loss=0.909, iou=0.383]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.77it/s, loss=0.894, iou=0.421]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9085 - iou 0.3825 - val_loss 0.8938 - val_iou 0.4213\n",
            "=> saved best model\n",
            "Epoch [60/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.87it/s, loss=0.902, iou=0.391]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.57it/s, loss=0.89, iou=0.425]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.9023 - iou 0.3914 - val_loss 0.8902 - val_iou 0.4246\n",
            "=> saved best model\n",
            "Epoch [61/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.51it/s, loss=0.897, iou=0.401]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.85it/s, loss=0.887, iou=0.428]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8968 - iou 0.4007 - val_loss 0.8866 - val_iou 0.4279\n",
            "=> saved best model\n",
            "Epoch [62/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.58it/s, loss=0.898, iou=0.391]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.57it/s, loss=0.883, iou=0.431]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8976 - iou 0.3913 - val_loss 0.8830 - val_iou 0.4312\n",
            "=> saved best model\n",
            "Epoch [63/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.82it/s, loss=0.889, iou=0.402]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.93it/s, loss=0.88, iou=0.434]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8892 - iou 0.4025 - val_loss 0.8795 - val_iou 0.4344\n",
            "=> saved best model\n",
            "Epoch [64/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.17it/s, loss=0.887, iou=0.402]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.90it/s, loss=0.876, iou=0.437]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8867 - iou 0.4023 - val_loss 0.8761 - val_iou 0.4373\n",
            "=> saved best model\n",
            "Epoch [65/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.01it/s, loss=0.887, iou=0.404]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.88it/s, loss=0.873, iou=0.44]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8867 - iou 0.4040 - val_loss 0.8727 - val_iou 0.4401\n",
            "=> saved best model\n",
            "Epoch [66/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.81it/s, loss=0.878, iou=0.418]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.01it/s, loss=0.869, iou=0.443]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8776 - iou 0.4176 - val_loss 0.8693 - val_iou 0.4431\n",
            "=> saved best model\n",
            "Epoch [67/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.38it/s, loss=0.881, iou=0.409]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.19it/s, loss=0.866, iou=0.446]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8812 - iou 0.4087 - val_loss 0.8660 - val_iou 0.4459\n",
            "=> saved best model\n",
            "Epoch [68/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.66it/s, loss=0.871, iou=0.418]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.61it/s, loss=0.863, iou=0.448]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8715 - iou 0.4179 - val_loss 0.8627 - val_iou 0.4483\n",
            "=> saved best model\n",
            "Epoch [69/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.53it/s, loss=0.874, iou=0.414]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.05it/s, loss=0.859, iou=0.451]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8735 - iou 0.4141 - val_loss 0.8595 - val_iou 0.4510\n",
            "=> saved best model\n",
            "Epoch [70/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.94it/s, loss=0.87, iou=0.417]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.03it/s, loss=0.856, iou=0.454]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8704 - iou 0.4175 - val_loss 0.8563 - val_iou 0.4536\n",
            "=> saved best model\n",
            "Epoch [71/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.02it/s, loss=0.86, iou=0.431]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.80it/s, loss=0.853, iou=0.456]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8598 - iou 0.4309 - val_loss 0.8531 - val_iou 0.4560\n",
            "=> saved best model\n",
            "Epoch [72/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.82it/s, loss=0.861, iou=0.424]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.90it/s, loss=0.85, iou=0.458]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8611 - iou 0.4244 - val_loss 0.8500 - val_iou 0.4585\n",
            "=> saved best model\n",
            "Epoch [73/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.19it/s, loss=0.858, iou=0.43]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.19it/s, loss=0.847, iou=0.461]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8577 - iou 0.4303 - val_loss 0.8469 - val_iou 0.4609\n",
            "=> saved best model\n",
            "Epoch [74/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.97it/s, loss=0.86, iou=0.429]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.02it/s, loss=0.844, iou=0.463]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8604 - iou 0.4287 - val_loss 0.8439 - val_iou 0.4634\n",
            "=> saved best model\n",
            "Epoch [75/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.11it/s, loss=0.857, iou=0.426]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.90it/s, loss=0.841, iou=0.466]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8575 - iou 0.4263 - val_loss 0.8410 - val_iou 0.4659\n",
            "=> saved best model\n",
            "Epoch [76/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.06it/s, loss=0.851, iou=0.433]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.57it/s, loss=0.838, iou=0.468]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8512 - iou 0.4334 - val_loss 0.8381 - val_iou 0.4679\n",
            "=> saved best model\n",
            "Epoch [77/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.12it/s, loss=0.851, iou=0.431]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.19it/s, loss=0.835, iou=0.47]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8511 - iou 0.4312 - val_loss 0.8353 - val_iou 0.4704\n",
            "=> saved best model\n",
            "Epoch [78/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.87it/s, loss=0.85, iou=0.432]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.10it/s, loss=0.832, iou=0.473]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8498 - iou 0.4316 - val_loss 0.8325 - val_iou 0.4726\n",
            "=> saved best model\n",
            "Epoch [79/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.45it/s, loss=0.844, iou=0.434]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.98it/s, loss=0.83, iou=0.475]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8438 - iou 0.4339 - val_loss 0.8297 - val_iou 0.4746\n",
            "=> saved best model\n",
            "Epoch [80/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.07it/s, loss=0.84, iou=0.436]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.95it/s, loss=0.827, iou=0.476]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8402 - iou 0.4360 - val_loss 0.8270 - val_iou 0.4765\n",
            "=> saved best model\n",
            "Epoch [81/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.17it/s, loss=0.836, iou=0.445]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.84it/s, loss=0.824, iou=0.478]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8362 - iou 0.4446 - val_loss 0.8243 - val_iou 0.4783\n",
            "=> saved best model\n",
            "Epoch [82/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.91it/s, loss=0.836, iou=0.443]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.85it/s, loss=0.822, iou=0.48]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8360 - iou 0.4427 - val_loss 0.8216 - val_iou 0.4803\n",
            "=> saved best model\n",
            "Epoch [83/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.97it/s, loss=0.834, iou=0.445]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.78it/s, loss=0.819, iou=0.482]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8342 - iou 0.4453 - val_loss 0.8190 - val_iou 0.4822\n",
            "=> saved best model\n",
            "Epoch [84/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.33it/s, loss=0.83, iou=0.45]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.06it/s, loss=0.816, iou=0.484]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8299 - iou 0.4495 - val_loss 0.8165 - val_iou 0.4840\n",
            "=> saved best model\n",
            "Epoch [85/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.40it/s, loss=0.83, iou=0.449]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.80it/s, loss=0.814, iou=0.486]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8297 - iou 0.4494 - val_loss 0.8140 - val_iou 0.4859\n",
            "=> saved best model\n",
            "Epoch [86/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.66it/s, loss=0.83, iou=0.445]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.15it/s, loss=0.811, iou=0.488]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8296 - iou 0.4451 - val_loss 0.8115 - val_iou 0.4878\n",
            "=> saved best model\n",
            "Epoch [87/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.69it/s, loss=0.824, iou=0.45]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.40it/s, loss=0.809, iou=0.49]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8239 - iou 0.4503 - val_loss 0.8091 - val_iou 0.4895\n",
            "=> saved best model\n",
            "Epoch [88/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.90it/s, loss=0.82, iou=0.456]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.87it/s, loss=0.807, iou=0.491]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8199 - iou 0.4563 - val_loss 0.8067 - val_iou 0.4912\n",
            "=> saved best model\n",
            "Epoch [89/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.87it/s, loss=0.816, iou=0.458]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.88it/s, loss=0.804, iou=0.493]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8164 - iou 0.4584 - val_loss 0.8043 - val_iou 0.4930\n",
            "=> saved best model\n",
            "Epoch [90/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.86it/s, loss=0.818, iou=0.454]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.96it/s, loss=0.802, iou=0.495]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8181 - iou 0.4543 - val_loss 0.8020 - val_iou 0.4946\n",
            "=> saved best model\n",
            "Epoch [91/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.97it/s, loss=0.811, iou=0.461]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.81it/s, loss=0.8, iou=0.496]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8114 - iou 0.4613 - val_loss 0.7998 - val_iou 0.4961\n",
            "=> saved best model\n",
            "Epoch [92/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.93it/s, loss=0.817, iou=0.452]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.75it/s, loss=0.798, iou=0.498]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8173 - iou 0.4518 - val_loss 0.7975 - val_iou 0.4977\n",
            "=> saved best model\n",
            "Epoch [93/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.68it/s, loss=0.812, iou=0.46]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.68it/s, loss=0.795, iou=0.499]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8125 - iou 0.4601 - val_loss 0.7954 - val_iou 0.4993\n",
            "=> saved best model\n",
            "Epoch [94/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.54it/s, loss=0.813, iou=0.454]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.06it/s, loss=0.793, iou=0.501]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8127 - iou 0.4539 - val_loss 0.7932 - val_iou 0.5009\n",
            "=> saved best model\n",
            "Epoch [95/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.01it/s, loss=0.806, iou=0.466]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.98it/s, loss=0.791, iou=0.502]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8057 - iou 0.4657 - val_loss 0.7912 - val_iou 0.5023\n",
            "=> saved best model\n",
            "Epoch [96/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.17it/s, loss=0.804, iou=0.467]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.69it/s, loss=0.789, iou=0.504]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8043 - iou 0.4665 - val_loss 0.7892 - val_iou 0.5036\n",
            "=> saved best model\n",
            "Epoch [97/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.93it/s, loss=0.804, iou=0.463]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.96it/s, loss=0.787, iou=0.505]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8045 - iou 0.4627 - val_loss 0.7872 - val_iou 0.5050\n",
            "=> saved best model\n",
            "Epoch [98/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.97it/s, loss=0.803, iou=0.459]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.72it/s, loss=0.785, iou=0.506]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8033 - iou 0.4587 - val_loss 0.7853 - val_iou 0.5064\n",
            "=> saved best model\n",
            "Epoch [99/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.39it/s, loss=0.803, iou=0.462]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.43it/s, loss=0.783, iou=0.508]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8032 - iou 0.4618 - val_loss 0.7834 - val_iou 0.5078\n",
            "=> saved best model\n",
            "Epoch [100/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.95it/s, loss=0.801, iou=0.465]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.54it/s, loss=0.782, iou=0.509]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.8008 - iou 0.4651 - val_loss 0.7816 - val_iou 0.5091\n",
            "=> saved best model\n",
            "Epoch [101/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.49it/s, loss=0.799, iou=0.467]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.67it/s, loss=0.78, iou=0.51]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7991 - iou 0.4669 - val_loss 0.7798 - val_iou 0.5103\n",
            "=> saved best model\n",
            "Epoch [102/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.38it/s, loss=0.79, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.01it/s, loss=0.778, iou=0.512]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7901 - iou 0.4763 - val_loss 0.7781 - val_iou 0.5115\n",
            "=> saved best model\n",
            "Epoch [103/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.68it/s, loss=0.798, iou=0.467]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.15it/s, loss=0.776, iou=0.513]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7983 - iou 0.4668 - val_loss 0.7764 - val_iou 0.5128\n",
            "=> saved best model\n",
            "Epoch [104/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.82it/s, loss=0.796, iou=0.466]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.62it/s, loss=0.775, iou=0.514]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7963 - iou 0.4655 - val_loss 0.7747 - val_iou 0.5138\n",
            "=> saved best model\n",
            "Epoch [105/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.88it/s, loss=0.799, iou=0.463]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.89it/s, loss=0.773, iou=0.515]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7988 - iou 0.4627 - val_loss 0.7731 - val_iou 0.5148\n",
            "=> saved best model\n",
            "Epoch [106/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.96it/s, loss=0.791, iou=0.471]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.74it/s, loss=0.772, iou=0.516]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7911 - iou 0.4714 - val_loss 0.7716 - val_iou 0.5157\n",
            "=> saved best model\n",
            "Epoch [107/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.68it/s, loss=0.782, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.92it/s, loss=0.77, iou=0.517]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7824 - iou 0.4848 - val_loss 0.7700 - val_iou 0.5168\n",
            "=> saved best model\n",
            "Epoch [108/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.99it/s, loss=0.791, iou=0.473]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.48it/s, loss=0.768, iou=0.518]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7908 - iou 0.4729 - val_loss 0.7685 - val_iou 0.5179\n",
            "=> saved best model\n",
            "Epoch [109/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.88it/s, loss=0.776, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.37it/s, loss=0.767, iou=0.519]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7760 - iou 0.4878 - val_loss 0.7670 - val_iou 0.5189\n",
            "=> saved best model\n",
            "Epoch [110/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.28it/s, loss=0.78, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.88it/s, loss=0.766, iou=0.52]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7801 - iou 0.4837 - val_loss 0.7655 - val_iou 0.5197\n",
            "=> saved best model\n",
            "Epoch [111/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.84it/s, loss=0.784, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.02it/s, loss=0.764, iou=0.521]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7838 - iou 0.4765 - val_loss 0.7641 - val_iou 0.5207\n",
            "=> saved best model\n",
            "Epoch [112/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.11it/s, loss=0.778, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.93it/s, loss=0.763, iou=0.522]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7777 - iou 0.4845 - val_loss 0.7627 - val_iou 0.5215\n",
            "=> saved best model\n",
            "Epoch [113/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.07it/s, loss=0.775, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.65it/s, loss=0.761, iou=0.522]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7747 - iou 0.4884 - val_loss 0.7614 - val_iou 0.5224\n",
            "=> saved best model\n",
            "Epoch [114/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.38it/s, loss=0.778, iou=0.482]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.68it/s, loss=0.76, iou=0.523]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7777 - iou 0.4824 - val_loss 0.7600 - val_iou 0.5235\n",
            "=> saved best model\n",
            "Epoch [115/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.94it/s, loss=0.777, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.88it/s, loss=0.759, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7771 - iou 0.4776 - val_loss 0.7588 - val_iou 0.5244\n",
            "=> saved best model\n",
            "Epoch [116/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.00it/s, loss=0.778, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.71it/s, loss=0.758, iou=0.525]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7782 - iou 0.4805 - val_loss 0.7575 - val_iou 0.5252\n",
            "=> saved best model\n",
            "Epoch [117/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.98it/s, loss=0.779, iou=0.473]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.23it/s, loss=0.756, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7788 - iou 0.4730 - val_loss 0.7564 - val_iou 0.5259\n",
            "=> saved best model\n",
            "Epoch [118/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.02it/s, loss=0.78, iou=0.475]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.75it/s, loss=0.755, iou=0.527]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7800 - iou 0.4752 - val_loss 0.7552 - val_iou 0.5267\n",
            "=> saved best model\n",
            "Epoch [119/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.85it/s, loss=0.772, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.93it/s, loss=0.754, iou=0.527]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7718 - iou 0.4844 - val_loss 0.7540 - val_iou 0.5275\n",
            "=> saved best model\n",
            "Epoch [120/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.54it/s, loss=0.766, iou=0.491]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.61it/s, loss=0.753, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7659 - iou 0.4908 - val_loss 0.7529 - val_iou 0.5282\n",
            "=> saved best model\n",
            "Epoch [121/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.94it/s, loss=0.774, iou=0.48]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.79it/s, loss=0.752, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7737 - iou 0.4801 - val_loss 0.7518 - val_iou 0.5290\n",
            "=> saved best model\n",
            "Epoch [122/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.90it/s, loss=0.769, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.71it/s, loss=0.751, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7694 - iou 0.4831 - val_loss 0.7507 - val_iou 0.5297\n",
            "=> saved best model\n",
            "Epoch [123/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.12it/s, loss=0.771, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.85it/s, loss=0.75, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7710 - iou 0.4853 - val_loss 0.7497 - val_iou 0.5303\n",
            "=> saved best model\n",
            "Epoch [124/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.72it/s, loss=0.761, iou=0.497]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.82it/s, loss=0.749, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7612 - iou 0.4973 - val_loss 0.7487 - val_iou 0.5310\n",
            "=> saved best model\n",
            "Epoch [125/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.92it/s, loss=0.765, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.88it/s, loss=0.748, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7655 - iou 0.4894 - val_loss 0.7477 - val_iou 0.5317\n",
            "=> saved best model\n",
            "Epoch [126/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.59it/s, loss=0.77, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.77it/s, loss=0.747, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7699 - iou 0.4808 - val_loss 0.7467 - val_iou 0.5323\n",
            "=> saved best model\n",
            "Epoch [127/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.61it/s, loss=0.761, iou=0.493]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.00it/s, loss=0.746, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7612 - iou 0.4927 - val_loss 0.7458 - val_iou 0.5329\n",
            "=> saved best model\n",
            "Epoch [128/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.72it/s, loss=0.765, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.49it/s, loss=0.745, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7649 - iou 0.4921 - val_loss 0.7449 - val_iou 0.5335\n",
            "=> saved best model\n",
            "Epoch [129/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.16it/s, loss=0.766, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.57it/s, loss=0.744, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7663 - iou 0.4833 - val_loss 0.7439 - val_iou 0.5340\n",
            "=> saved best model\n",
            "Epoch [130/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.77it/s, loss=0.762, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.79it/s, loss=0.743, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7624 - iou 0.4905 - val_loss 0.7431 - val_iou 0.5345\n",
            "=> saved best model\n",
            "Epoch [131/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.83it/s, loss=0.758, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.88it/s, loss=0.742, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7576 - iou 0.4958 - val_loss 0.7423 - val_iou 0.5351\n",
            "=> saved best model\n",
            "Epoch [132/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.91it/s, loss=0.76, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.67it/s, loss=0.741, iou=0.536]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7601 - iou 0.4915 - val_loss 0.7414 - val_iou 0.5355\n",
            "=> saved best model\n",
            "Epoch [133/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.07it/s, loss=0.763, iou=0.486]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.46it/s, loss=0.741, iou=0.536]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7634 - iou 0.4856 - val_loss 0.7406 - val_iou 0.5360\n",
            "=> saved best model\n",
            "Epoch [134/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.25it/s, loss=0.763, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.75it/s, loss=0.74, iou=0.537]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7630 - iou 0.4894 - val_loss 0.7399 - val_iou 0.5365\n",
            "=> saved best model\n",
            "Epoch [135/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.81it/s, loss=0.762, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.90it/s, loss=0.739, iou=0.537]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7618 - iou 0.4846 - val_loss 0.7392 - val_iou 0.5371\n",
            "=> saved best model\n",
            "Epoch [136/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.74it/s, loss=0.756, iou=0.495]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.68it/s, loss=0.738, iou=0.537]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7560 - iou 0.4946 - val_loss 0.7384 - val_iou 0.5375\n",
            "=> saved best model\n",
            "Epoch [137/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.89it/s, loss=0.757, iou=0.495]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.57it/s, loss=0.738, iou=0.538]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7567 - iou 0.4954 - val_loss 0.7377 - val_iou 0.5380\n",
            "=> saved best model\n",
            "Epoch [138/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.70it/s, loss=0.749, iou=0.508]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.56it/s, loss=0.737, iou=0.538]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7495 - iou 0.5078 - val_loss 0.7370 - val_iou 0.5384\n",
            "=> saved best model\n",
            "Epoch [139/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.61it/s, loss=0.758, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  6.17it/s, loss=0.736, iou=0.539]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7582 - iou 0.4893 - val_loss 0.7364 - val_iou 0.5389\n",
            "=> saved best model\n",
            "Epoch [140/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.89it/s, loss=0.746, iou=0.508]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.74it/s, loss=0.736, iou=0.539]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7455 - iou 0.5080 - val_loss 0.7357 - val_iou 0.5393\n",
            "=> saved best model\n",
            "Epoch [141/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.93it/s, loss=0.751, iou=0.498]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.63it/s, loss=0.735, iou=0.54]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7513 - iou 0.4980 - val_loss 0.7351 - val_iou 0.5397\n",
            "=> saved best model\n",
            "Epoch [142/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.46it/s, loss=0.752, iou=0.495]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.65it/s, loss=0.734, iou=0.54]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7522 - iou 0.4948 - val_loss 0.7345 - val_iou 0.5401\n",
            "=> saved best model\n",
            "Epoch [143/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.33it/s, loss=0.75, iou=0.499]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.89it/s, loss=0.734, iou=0.54]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7500 - iou 0.4985 - val_loss 0.7339 - val_iou 0.5404\n",
            "=> saved best model\n",
            "Epoch [144/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.79it/s, loss=0.752, iou=0.493]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.06it/s, loss=0.733, iou=0.541]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7518 - iou 0.4934 - val_loss 0.7333 - val_iou 0.5408\n",
            "=> saved best model\n",
            "Epoch [145/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.86it/s, loss=0.754, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.97it/s, loss=0.733, iou=0.541]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7543 - iou 0.4923 - val_loss 0.7328 - val_iou 0.5412\n",
            "=> saved best model\n",
            "Epoch [146/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.90it/s, loss=0.76, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.77it/s, loss=0.732, iou=0.542]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7600 - iou 0.4841 - val_loss 0.7323 - val_iou 0.5415\n",
            "=> saved best model\n",
            "Epoch [147/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.89it/s, loss=0.74, iou=0.509]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.86it/s, loss=0.732, iou=0.542]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7402 - iou 0.5093 - val_loss 0.7318 - val_iou 0.5419\n",
            "=> saved best model\n",
            "Epoch [148/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.81it/s, loss=0.749, iou=0.498]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.77it/s, loss=0.731, iou=0.542]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7494 - iou 0.4979 - val_loss 0.7313 - val_iou 0.5421\n",
            "=> saved best model\n",
            "Epoch [149/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.82it/s, loss=0.752, iou=0.495]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.77it/s, loss=0.731, iou=0.542]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7517 - iou 0.4947 - val_loss 0.7308 - val_iou 0.5424\n",
            "=> saved best model\n",
            "Epoch [150/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.09it/s, loss=0.754, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.78it/s, loss=0.73, iou=0.543]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7544 - iou 0.4891 - val_loss 0.7304 - val_iou 0.5428\n",
            "=> saved best model\n",
            "Epoch [151/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.42it/s, loss=0.75, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.81it/s, loss=0.73, iou=0.543]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7504 - iou 0.4958 - val_loss 0.7299 - val_iou 0.5430\n",
            "=> saved best model\n",
            "Epoch [152/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.76it/s, loss=0.748, iou=0.504]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.58it/s, loss=0.73, iou=0.543]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7480 - iou 0.5038 - val_loss 0.7295 - val_iou 0.5433\n",
            "=> saved best model\n",
            "Epoch [153/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.76it/s, loss=0.752, iou=0.494]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.85it/s, loss=0.729, iou=0.544]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7516 - iou 0.4944 - val_loss 0.7291 - val_iou 0.5435\n",
            "=> saved best model\n",
            "Epoch [154/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.80it/s, loss=0.748, iou=0.499]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.65it/s, loss=0.729, iou=0.544]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7483 - iou 0.4986 - val_loss 0.7287 - val_iou 0.5438\n",
            "=> saved best model\n",
            "Epoch [155/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.60it/s, loss=0.747, iou=0.505]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.48it/s, loss=0.728, iou=0.544]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7474 - iou 0.5052 - val_loss 0.7283 - val_iou 0.5440\n",
            "=> saved best model\n",
            "Epoch [156/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.74it/s, loss=0.75, iou=0.501]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.71it/s, loss=0.728, iou=0.544]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7497 - iou 0.5006 - val_loss 0.7280 - val_iou 0.5442\n",
            "=> saved best model\n",
            "Epoch [157/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.68it/s, loss=0.754, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.51it/s, loss=0.728, iou=0.544]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7538 - iou 0.4896 - val_loss 0.7277 - val_iou 0.5444\n",
            "=> saved best model\n",
            "Epoch [158/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.78it/s, loss=0.744, iou=0.505]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.77it/s, loss=0.727, iou=0.545]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7438 - iou 0.5051 - val_loss 0.7273 - val_iou 0.5447\n",
            "=> saved best model\n",
            "Epoch [159/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.21it/s, loss=0.75, iou=0.497]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.61it/s, loss=0.727, iou=0.545]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7498 - iou 0.4967 - val_loss 0.7270 - val_iou 0.5448\n",
            "=> saved best model\n",
            "Epoch [160/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.75it/s, loss=0.743, iou=0.503]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.92it/s, loss=0.727, iou=0.545]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7426 - iou 0.5033 - val_loss 0.7267 - val_iou 0.5450\n",
            "=> saved best model\n",
            "Epoch [161/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.57it/s, loss=0.74, iou=0.512]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.72it/s, loss=0.726, iou=0.545]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7402 - iou 0.5122 - val_loss 0.7264 - val_iou 0.5452\n",
            "=> saved best model\n",
            "Epoch [162/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.82it/s, loss=0.747, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.67it/s, loss=0.726, iou=0.545]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7472 - iou 0.4960 - val_loss 0.7262 - val_iou 0.5454\n",
            "=> saved best model\n",
            "Epoch [163/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.62it/s, loss=0.745, iou=0.504]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.63it/s, loss=0.726, iou=0.546]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7455 - iou 0.5044 - val_loss 0.7259 - val_iou 0.5456\n",
            "=> saved best model\n",
            "Epoch [164/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.66it/s, loss=0.744, iou=0.502]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.42it/s, loss=0.726, iou=0.546]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7442 - iou 0.5023 - val_loss 0.7256 - val_iou 0.5458\n",
            "=> saved best model\n",
            "Epoch [165/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.57it/s, loss=0.747, iou=0.5]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.43it/s, loss=0.725, iou=0.546]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7475 - iou 0.5003 - val_loss 0.7254 - val_iou 0.5459\n",
            "=> saved best model\n",
            "Epoch [166/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.78it/s, loss=0.746, iou=0.501]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.63it/s, loss=0.725, iou=0.546]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7460 - iou 0.5008 - val_loss 0.7252 - val_iou 0.5461\n",
            "=> saved best model\n",
            "Epoch [167/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.22it/s, loss=0.737, iou=0.516]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.74it/s, loss=0.725, iou=0.546]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7365 - iou 0.5161 - val_loss 0.7250 - val_iou 0.5461\n",
            "=> saved best model\n",
            "Epoch [168/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.57it/s, loss=0.739, iou=0.501]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.42it/s, loss=0.725, iou=0.546]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7395 - iou 0.5010 - val_loss 0.7247 - val_iou 0.5463\n",
            "=> saved best model\n",
            "Epoch [169/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.76it/s, loss=0.737, iou=0.509]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.67it/s, loss=0.725, iou=0.546]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7371 - iou 0.5091 - val_loss 0.7246 - val_iou 0.5464\n",
            "=> saved best model\n",
            "Epoch [170/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.75it/s, loss=0.748, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.63it/s, loss=0.724, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7481 - iou 0.4961 - val_loss 0.7244 - val_iou 0.5466\n",
            "=> saved best model\n",
            "Epoch [171/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.80it/s, loss=0.745, iou=0.501]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.44it/s, loss=0.724, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7449 - iou 0.5006 - val_loss 0.7242 - val_iou 0.5466\n",
            "=> saved best model\n",
            "Epoch [172/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.73it/s, loss=0.744, iou=0.499]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.62it/s, loss=0.724, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7442 - iou 0.4986 - val_loss 0.7240 - val_iou 0.5467\n",
            "=> saved best model\n",
            "Epoch [173/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.91it/s, loss=0.741, iou=0.505]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.74it/s, loss=0.724, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7413 - iou 0.5045 - val_loss 0.7239 - val_iou 0.5468\n",
            "=> saved best model\n",
            "Epoch [174/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.23it/s, loss=0.741, iou=0.503]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.60it/s, loss=0.724, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7415 - iou 0.5027 - val_loss 0.7237 - val_iou 0.5469\n",
            "=> saved best model\n",
            "Epoch [175/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.33it/s, loss=0.734, iou=0.517]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.81it/s, loss=0.724, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7336 - iou 0.5173 - val_loss 0.7236 - val_iou 0.5470\n",
            "=> saved best model\n",
            "Epoch [176/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.69it/s, loss=0.746, iou=0.498]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.98it/s, loss=0.723, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7458 - iou 0.4984 - val_loss 0.7235 - val_iou 0.5472\n",
            "=> saved best model\n",
            "Epoch [177/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.68it/s, loss=0.736, iou=0.508]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.75it/s, loss=0.723, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7360 - iou 0.5083 - val_loss 0.7234 - val_iou 0.5472\n",
            "=> saved best model\n",
            "Epoch [178/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.84it/s, loss=0.749, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.74it/s, loss=0.723, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7494 - iou 0.4916 - val_loss 0.7232 - val_iou 0.5473\n",
            "=> saved best model\n",
            "Epoch [179/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.66it/s, loss=0.746, iou=0.499]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.52it/s, loss=0.723, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7462 - iou 0.4987 - val_loss 0.7231 - val_iou 0.5473\n",
            "=> saved best model\n",
            "Epoch [180/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.67it/s, loss=0.735, iou=0.511]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.62it/s, loss=0.723, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7352 - iou 0.5107 - val_loss 0.7230 - val_iou 0.5474\n",
            "=> saved best model\n",
            "Epoch [181/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.89it/s, loss=0.742, iou=0.501]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.81it/s, loss=0.723, iou=0.547]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7417 - iou 0.5012 - val_loss 0.7230 - val_iou 0.5475\n",
            "=> saved best model\n",
            "Epoch [182/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.39it/s, loss=0.742, iou=0.502]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.43it/s, loss=0.723, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7424 - iou 0.5019 - val_loss 0.7229 - val_iou 0.5475\n",
            "=> saved best model\n",
            "Epoch [183/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.29it/s, loss=0.745, iou=0.498]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.72it/s, loss=0.723, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7447 - iou 0.4983 - val_loss 0.7228 - val_iou 0.5476\n",
            "=> saved best model\n",
            "Epoch [184/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.66it/s, loss=0.737, iou=0.506]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.80it/s, loss=0.723, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7374 - iou 0.5060 - val_loss 0.7227 - val_iou 0.5477\n",
            "=> saved best model\n",
            "Epoch [185/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.59it/s, loss=0.749, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.64it/s, loss=0.723, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7492 - iou 0.4962 - val_loss 0.7227 - val_iou 0.5477\n",
            "=> saved best model\n",
            "Epoch [186/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.91it/s, loss=0.74, iou=0.506]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.67it/s, loss=0.723, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7404 - iou 0.5062 - val_loss 0.7226 - val_iou 0.5477\n",
            "=> saved best model\n",
            "Epoch [187/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.76it/s, loss=0.738, iou=0.507]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.75it/s, loss=0.723, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7383 - iou 0.5074 - val_loss 0.7225 - val_iou 0.5478\n",
            "=> saved best model\n",
            "Epoch [188/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.91it/s, loss=0.738, iou=0.509]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.73it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7379 - iou 0.5094 - val_loss 0.7225 - val_iou 0.5478\n",
            "=> saved best model\n",
            "Epoch [189/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.75it/s, loss=0.743, iou=0.501]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.47it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7434 - iou 0.5010 - val_loss 0.7224 - val_iou 0.5479\n",
            "=> saved best model\n",
            "Epoch [190/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.41it/s, loss=0.742, iou=0.502]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.63it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7421 - iou 0.5019 - val_loss 0.7224 - val_iou 0.5479\n",
            "=> saved best model\n",
            "Epoch [191/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.33it/s, loss=0.746, iou=0.502]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.79it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7457 - iou 0.5019 - val_loss 0.7223 - val_iou 0.5479\n",
            "=> saved best model\n",
            "Epoch [192/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.78it/s, loss=0.739, iou=0.508]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.80it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7386 - iou 0.5080 - val_loss 0.7223 - val_iou 0.5479\n",
            "=> saved best model\n",
            "Epoch [193/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.80it/s, loss=0.746, iou=0.494]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.37it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7462 - iou 0.4936 - val_loss 0.7223 - val_iou 0.5480\n",
            "=> saved best model\n",
            "Epoch [194/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.91it/s, loss=0.736, iou=0.511]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.75it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7363 - iou 0.5107 - val_loss 0.7222 - val_iou 0.5480\n",
            "=> saved best model\n",
            "Epoch [195/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.56it/s, loss=0.733, iou=0.517]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.71it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7328 - iou 0.5167 - val_loss 0.7222 - val_iou 0.5480\n",
            "=> saved best model\n",
            "Epoch [196/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.76it/s, loss=0.746, iou=0.498]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.74it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7465 - iou 0.4983 - val_loss 0.7222 - val_iou 0.5480\n",
            "=> saved best model\n",
            "Epoch [197/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  7.04it/s, loss=0.744, iou=0.501]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.88it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7443 - iou 0.5009 - val_loss 0.7221 - val_iou 0.5480\n",
            "=> saved best model\n",
            "Epoch [198/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.84it/s, loss=0.733, iou=0.513]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.81it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7331 - iou 0.5133 - val_loss 0.7221 - val_iou 0.5481\n",
            "=> saved best model\n",
            "Epoch [199/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.29it/s, loss=0.745, iou=0.498]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.01it/s, loss=0.722, iou=0.548]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7451 - iou 0.4979 - val_loss 0.7221 - val_iou 0.5481\n",
            "=> saved best model\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Analog training"
      ],
      "metadata": {
        "id": "d_sECpRQHv31"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from aihwkit.nn import AnalogConv2d, AnalogLinear, AnalogSequential\n",
        "from aihwkit.nn.conversion import convert_to_analog_mapped, convert_to_analog\n",
        "from aihwkit.optim import AnalogSGD\n",
        "from torch.optim import SGD\n",
        "from aihwkit.simulator.configs import FloatingPointRPUConfig, SingleRPUConfig, UnitCellRPUConfig, InferenceRPUConfig, DigitalRankUpdateRPUConfig\n",
        "from aihwkit.simulator.configs.devices import *\n",
        "from aihwkit.simulator.configs.utils import PulseType\n",
        "# from aihwkit.simulator.rpu_base import cuda\n",
        "from aihwkit.inference import BaseNoiseModel, PCMLikeNoiseModel, StateIndependentNoiseModel\n",
        "from aihwkit.simulator.configs.utils import WeightClipType,WeightModifierType, IOParameters\n",
        "from aihwkit.inference.compensation.drift import GlobalDriftCompensation\n",
        "\n",
        "from aihwkit.simulator.configs.utils import BoundManagementType\n",
        "from aihwkit.simulator.presets.utils import PresetIOParameters\n",
        "import math"
      ],
      "metadata": {
        "id": "NwK0Dnr2Hk12"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def create_rpu_config_new():\n",
        "    rpu_config = InferenceRPUConfig()\n",
        "\n",
        "    rpu_config.clip.type = WeightClipType.FIXED_VALUE\n",
        "    rpu_config.clip.fixed_value = 1.0\n",
        "    rpu_config.modifier.pdrop = 0  # Drop connect.\n",
        "\n",
        "    rpu_config.modifier.std_dev = 0.5\n",
        "\n",
        "    rpu_config.modifier.rel_to_actual_wmax = True\n",
        "    rpu_config.mapping.digital_bias = True\n",
        "    rpu_config.mapping.weight_scaling_omega = 0.4\n",
        "    rpu_config.mapping.weight_scaling_omega = True\n",
        "    rpu_config.mapping.max_input_size = 256\n",
        "    rpu_config.mapping.max_output_size = 256\n",
        "\n",
        "    rpu_config.mapping.learn_out_scaling_alpha = True\n",
        "\n",
        "    rpu_config.forward = PresetIOParameters()\n",
        "    rpu_config.forward.inp_res = 1/256  # 8-bit DAC discretization.\n",
        "    rpu_config.forward.out_res = 1/256  # 8-bit ADC discretization.\n",
        "    rpu_config.forward.bound_management = BoundManagementType.NONE\n",
        "\n",
        "    # Inference noise model.\n",
        "    rpu_config.noise_model = PCMLikeNoiseModel(g_max=25)\n",
        "\n",
        "    # drift compensation\n",
        "    rpu_config.drift_compensation = GlobalDriftCompensation()\n",
        "    return rpu_config\n",
        "\n",
        "def create_analog_optimizer(model, lr):\n",
        "    \"\"\"Create the analog-aware optimizer.\n",
        "\n",
        "    Args:\n",
        "        model (nn.Module): model to be trained\n",
        "\n",
        "    Returns:\n",
        "        Optimizer: created analog optimizer\n",
        "    \"\"\"\n",
        "\n",
        "    optimizer = AnalogSGD(model.parameters(), lr) # we will use a learning rate of 0.01 as in the paper\n",
        "    optimizer.regroup_param_groups(model)\n",
        "\n",
        "    return optimizer"
      ],
      "metadata": {
        "id": "9FBWQ9gnHk4K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Converting the model to analog\n",
        "- We use the rpu_config that defines the hardware and the type of noise that is applied\n"
      ],
      "metadata": {
        "id": "5XZ_Ib_tggZ2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "rpu_config = create_rpu_config_new()\n",
        "model_analog = convert_to_analog_mapped(model, rpu_config)"
      ],
      "metadata": {
        "id": "UC9zO5bMHk6g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_analog"
      ],
      "metadata": {
        "id": "6PRiM8JTHk81",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a8159eb1-c042-4bde-f880-562fa2647031"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "AnalogWrapper(\n",
              "  (module): UNet(\n",
              "    (model): AnalogSequential(\n",
              "      (0): Convolution(\n",
              "        (conv): AnalogConv2dMapped(\n",
              "          3, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), InferenceRPUConfig\n",
              "          (array): ModuleList(\n",
              "            (0): ModuleList(\n",
              "              (0): InferenceTile(RPUCudaPulsed<float>[SimpleRPUDevice](16,27))\n",
              "            )\n",
              "          )\n",
              "        )\n",
              "        (adn): ADN(\n",
              "          (N): InstanceNorm2d(16, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)\n",
              "          (D): Dropout(p=0.0, inplace=False)\n",
              "          (A): PReLU(num_parameters=1)\n",
              "        )\n",
              "      )\n",
              "      (1): SkipConnection(\n",
              "        (submodule): AnalogSequential(\n",
              "          (0): Convolution(\n",
              "            (conv): AnalogConv2dMapped(\n",
              "              16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), InferenceRPUConfig\n",
              "              (array): ModuleList(\n",
              "                (0): ModuleList(\n",
              "                  (0): InferenceTile(RPUCudaPulsed<float>[SimpleRPUDevice](32,144))\n",
              "                )\n",
              "              )\n",
              "            )\n",
              "            (adn): ADN(\n",
              "              (N): InstanceNorm2d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)\n",
              "              (D): Dropout(p=0.0, inplace=False)\n",
              "              (A): PReLU(num_parameters=1)\n",
              "            )\n",
              "          )\n",
              "          (1): SkipConnection(\n",
              "            (submodule): AnalogSequential(\n",
              "              (0): Convolution(\n",
              "                (conv): AnalogConv2dMapped(\n",
              "                  32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), InferenceRPUConfig\n",
              "                  (array): ModuleList(\n",
              "                    (0-1): 2 x ModuleList(\n",
              "                      (0): InferenceTile(RPUCudaPulsed<float>[SimpleRPUDevice](64,144))\n",
              "                    )\n",
              "                  )\n",
              "                )\n",
              "                (adn): ADN(\n",
              "                  (N): InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)\n",
              "                  (D): Dropout(p=0.0, inplace=False)\n",
              "                  (A): PReLU(num_parameters=1)\n",
              "                )\n",
              "              )\n",
              "              (1): SkipConnection(\n",
              "                (submodule): AnalogSequential(\n",
              "                  (0): Convolution(\n",
              "                    (conv): AnalogConv2dMapped(\n",
              "                      64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), InferenceRPUConfig\n",
              "                      (array): ModuleList(\n",
              "                        (0): ModuleList(\n",
              "                          (0): InferenceTile(RPUCudaPulsed<float>[SimpleRPUDevice](128,198))\n",
              "                        )\n",
              "                        (1-2): 2 x ModuleList(\n",
              "                          (0): InferenceTile(RPUCudaPulsed<float>[SimpleRPUDevice](128,189))\n",
              "                        )\n",
              "                      )\n",
              "                    )\n",
              "                    (adn): ADN(\n",
              "                      (N): InstanceNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)\n",
              "                      (D): Dropout(p=0.0, inplace=False)\n",
              "                      (A): PReLU(num_parameters=1)\n",
              "                    )\n",
              "                  )\n",
              "                  (1): SkipConnection(\n",
              "                    (submodule): Convolution(\n",
              "                      (conv): AnalogConv2dMapped(\n",
              "                        128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), InferenceRPUConfig\n",
              "                        (array): ModuleList(\n",
              "                          (0-2): 3 x ModuleList(\n",
              "                            (0): InferenceTile(RPUCudaPulsed<float>[SimpleRPUDevice](256,234))\n",
              "                          )\n",
              "                          (3-4): 2 x ModuleList(\n",
              "                            (0): InferenceTile(RPUCudaPulsed<float>[SimpleRPUDevice](256,225))\n",
              "                          )\n",
              "                        )\n",
              "                      )\n",
              "                      (adn): ADN(\n",
              "                        (N): InstanceNorm2d(256, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)\n",
              "                        (D): Dropout(p=0.0, inplace=False)\n",
              "                        (A): PReLU(num_parameters=1)\n",
              "                      )\n",
              "                    )\n",
              "                  )\n",
              "                  (2): Convolution(\n",
              "                    (conv): ConvTranspose2d(384, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "                    (adn): ADN(\n",
              "                      (N): InstanceNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)\n",
              "                      (D): Dropout(p=0.0, inplace=False)\n",
              "                      (A): PReLU(num_parameters=1)\n",
              "                    )\n",
              "                  )\n",
              "                )\n",
              "              )\n",
              "              (2): Convolution(\n",
              "                (conv): ConvTranspose2d(128, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "                (adn): ADN(\n",
              "                  (N): InstanceNorm2d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)\n",
              "                  (D): Dropout(p=0.0, inplace=False)\n",
              "                  (A): PReLU(num_parameters=1)\n",
              "                )\n",
              "              )\n",
              "            )\n",
              "          )\n",
              "          (2): Convolution(\n",
              "            (conv): ConvTranspose2d(64, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "            (adn): ADN(\n",
              "              (N): InstanceNorm2d(16, eps=1e-05, momentum=0.1, affine=False, track_running_stats=False)\n",
              "              (D): Dropout(p=0.0, inplace=False)\n",
              "              (A): PReLU(num_parameters=1)\n",
              "            )\n",
              "          )\n",
              "        )\n",
              "      )\n",
              "      (2): Convolution(\n",
              "        (conv): ConvTranspose2d(32, 1, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
              "      )\n",
              "    )\n",
              "  )\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from aihwkit.utils.analog_info import analog_summary\n",
        "\n",
        "analog_summary(model_analog,(64, 3, 96, 96))"
      ],
      "metadata": {
        "id": "p29TMPGnHk_P",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "639f9ac2-b88e-46b5-bc9e-e1ce0cc5431e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "========================================================================================================================================================================================================\n",
              "Model Name: AnalogWrapper\n",
              "========================================================================================================================================================================================================\n",
              "Per-layer Information\n",
              "========================================================================================================================================================================================================\n",
              "Layer Information                                                     | Tile Information              \n",
              "========================================================================================================================================================================================================\n",
              "Layer Name          Is Analog           In Shape            Out Shape           Kernel Shape        # of Tiles          Reuse Factor        Log. tile shape     Phys. tile shape    utilization (%)     \n",
              "AnalogConv2dMapped  analog              [64, 3, 96, 96]     [64, 16, 48, 48]    (3, 3)              1                   147456              -                   -                   -                   \n",
              "                                                                                                                                            (16, 27)            (256, 256)          0.66                \n",
              "InstanceNorm2d      digital             [64, 16, 48, 48]    [64, 16, 48, 48]    -                   0                   0                   -                   -                   -                   \n",
              "Dropout             digital             [64, 16, 48, 48]    [64, 16, 48, 48]    -                   0                   0                   -                   -                   -                   \n",
              "PReLU               digital             [64, 16, 48, 48]    [64, 16, 48, 48]    -                   0                   0                   -                   -                   -                   \n",
              "AnalogConv2dMapped  analog              [64, 16, 48, 48]    [64, 32, 24, 24]    (3, 3)              1                   36864               -                   -                   -                   \n",
              "                                                                                                                                            (32, 144)           (256, 256)          7.03                \n",
              "InstanceNorm2d      digital             [64, 32, 24, 24]    [64, 32, 24, 24]    -                   0                   0                   -                   -                   -                   \n",
              "Dropout             digital             [64, 32, 24, 24]    [64, 32, 24, 24]    -                   0                   0                   -                   -                   -                   \n",
              "PReLU               digital             [64, 32, 24, 24]    [64, 32, 24, 24]    -                   0                   0                   -                   -                   -                   \n",
              "AnalogConv2dMapped  analog              [64, 32, 24, 24]    [64, 64, 12, 12]    (3, 3)              2                   9216                -                   -                   -                   \n",
              "                                                                                                                                            (64, 144)           (256, 256)          14.06               \n",
              "                                                                                                                                            (64, 144)           (256, 256)          14.06               \n",
              "InstanceNorm2d      digital             [64, 64, 12, 12]    [64, 64, 12, 12]    -                   0                   0                   -                   -                   -                   \n",
              "Dropout             digital             [64, 64, 12, 12]    [64, 64, 12, 12]    -                   0                   0                   -                   -                   -                   \n",
              "PReLU               digital             [64, 64, 12, 12]    [64, 64, 12, 12]    -                   0                   0                   -                   -                   -                   \n",
              "AnalogConv2dMapped  analog              [64, 64, 12, 12]    [64, 128, 6, 6]     (3, 3)              3                   2304                -                   -                   -                   \n",
              "                                                                                                                                            (128, 198)          (256, 256)          38.67               \n",
              "                                                                                                                                            (128, 189)          (256, 256)          36.91               \n",
              "                                                                                                                                            (128, 189)          (256, 256)          36.91               \n",
              "InstanceNorm2d      digital             [64, 128, 6, 6]     [64, 128, 6, 6]     -                   0                   0                   -                   -                   -                   \n",
              "Dropout             digital             [64, 128, 6, 6]     [64, 128, 6, 6]     -                   0                   0                   -                   -                   -                   \n",
              "PReLU               digital             [64, 128, 6, 6]     [64, 128, 6, 6]     -                   0                   0                   -                   -                   -                   \n",
              "AnalogConv2dMapped  analog              [64, 128, 6, 6]     [64, 256, 6, 6]     (3, 3)              5                   2304                -                   -                   -                   \n",
              "                                                                                                                                            (256, 234)          (256, 256)          91.41               \n",
              "                                                                                                                                            (256, 234)          (256, 256)          91.41               \n",
              "                                                                                                                                            (256, 234)          (256, 256)          91.41               \n",
              "                                                                                                                                            (256, 225)          (256, 256)          87.89               \n",
              "                                                                                                                                            (256, 225)          (256, 256)          87.89               \n",
              "InstanceNorm2d      digital             [64, 256, 6, 6]     [64, 256, 6, 6]     -                   0                   0                   -                   -                   -                   \n",
              "Dropout             digital             [64, 256, 6, 6]     [64, 256, 6, 6]     -                   0                   0                   -                   -                   -                   \n",
              "PReLU               digital             [64, 256, 6, 6]     [64, 256, 6, 6]     -                   0                   0                   -                   -                   -                   \n",
              "ConvTranspose2d     digital             [64, 384, 6, 6]     [64, 64, 12, 12]    (3, 3)              0                   0                   -                   -                   -                   \n",
              "InstanceNorm2d      digital             [64, 64, 12, 12]    [64, 64, 12, 12]    -                   0                   0                   -                   -                   -                   \n",
              "Dropout             digital             [64, 64, 12, 12]    [64, 64, 12, 12]    -                   0                   0                   -                   -                   -                   \n",
              "PReLU               digital             [64, 64, 12, 12]    [64, 64, 12, 12]    -                   0                   0                   -                   -                   -                   \n",
              "ConvTranspose2d     digital             [64, 128, 12, 12]   [64, 32, 24, 24]    (3, 3)              0                   0                   -                   -                   -                   \n",
              "InstanceNorm2d      digital             [64, 32, 24, 24]    [64, 32, 24, 24]    -                   0                   0                   -                   -                   -                   \n",
              "Dropout             digital             [64, 32, 24, 24]    [64, 32, 24, 24]    -                   0                   0                   -                   -                   -                   \n",
              "PReLU               digital             [64, 32, 24, 24]    [64, 32, 24, 24]    -                   0                   0                   -                   -                   -                   \n",
              "ConvTranspose2d     digital             [64, 64, 24, 24]    [64, 16, 48, 48]    (3, 3)              0                   0                   -                   -                   -                   \n",
              "InstanceNorm2d      digital             [64, 16, 48, 48]    [64, 16, 48, 48]    -                   0                   0                   -                   -                   -                   \n",
              "Dropout             digital             [64, 16, 48, 48]    [64, 16, 48, 48]    -                   0                   0                   -                   -                   -                   \n",
              "PReLU               digital             [64, 16, 48, 48]    [64, 16, 48, 48]    -                   0                   0                   -                   -                   -                   \n",
              "ConvTranspose2d     digital             [64, 32, 48, 48]    [64, 1, 96, 96]     (3, 3)              0                   0                   -                   -                   -                   \n",
              "========================================================================================================================================================================================================\n",
              "General Information\n",
              "========================================================================================================================================================================================================\n",
              "Total number of tiles: 12\n",
              "Total number of analog layers: 5"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Analog training loop\n"
      ],
      "metadata": {
        "id": "-cUfQ4POg5Ip"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "if config['name'] is None:\n",
        "    if config['deep_supervision']:\n",
        "        config['name'] = '%s_%s_wDS' % (config['dataset'], config['arch'])\n",
        "    else:\n",
        "        config['name'] = '%s_%s_woDS' % (config['dataset'], config['arch'])\n",
        "os.makedirs('models/%s' % config['name'], exist_ok=True)\n",
        "\n",
        "print('-' * 20)\n",
        "for key in config:\n",
        "    print('%s: %s' % (key, config[key]))\n",
        "print('-' * 20)\n",
        "\n",
        "with open('models/%s/config.yml' % config['name'], 'w') as f:\n",
        "    yaml.dump(config, f)\n",
        "\n",
        "# define loss function (criterion)\n",
        "if config['loss'] == 'BCEWithLogitsLoss':\n",
        "    criterion = nn.BCEWithLogitsLoss().cuda()\n",
        "elif config['loss'] == 'BCEDiceLoss':\n",
        "    criterion = BCEDiceLoss().cuda()\n",
        "else:\n",
        "    criterion = LovaszHingeLoss().cuda()\n",
        "\n",
        "cudnn.benchmark = True\n",
        "\n",
        "# create model\n",
        "print(\"=> creating model %s\" % config['arch'])\n",
        "\n",
        "params = filter(lambda p: p.requires_grad, model_analog.parameters())\n",
        "if config['optimizer'] == 'Adam':\n",
        "    optimizer = optim.Adam(\n",
        "        params, lr=config['lr'], weight_decay=config['weight_decay'])\n",
        "elif config['optimizer'] == 'SGD':\n",
        "    optimizer = optim.SGD(params, lr=config['lr'], momentum=config['momentum'],\n",
        "                          nesterov=config['nesterov'], weight_decay=config['weight_decay'])\n",
        "\n",
        "# Create an analog optimizer\n",
        "optimizer = create_analog_optimizer(model_analog, lr= config['lr'])\n",
        "\n",
        "if config['scheduler'] == 'CosineAnnealingLR':\n",
        "    scheduler = lr_scheduler.CosineAnnealingLR(\n",
        "        optimizer, T_max=config['epochs'], eta_min=config['min_lr'])\n",
        "elif config['scheduler'] == 'ReduceLROnPlateau':\n",
        "    scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, factor=config['factor'], patience=config['patience'],\n",
        "                                                verbose=1, min_lr=config['min_lr'])\n",
        "elif config['scheduler'] == 'MultiStepLR':\n",
        "    scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[int(e) for e in config['milestones'].split(',')], gamma=config['gamma'])\n",
        "elif config['scheduler'] == 'ConstantLR':\n",
        "    scheduler = None\n",
        "else:\n",
        "    raise NotImplementedError\n",
        "\n",
        "# Data loading code\n",
        "img_ids = glob(os.path.join('inputs', config['dataset'], 'images', '*' + config['img_ext']))\n",
        "img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]\n",
        "\n",
        "train_img_ids, val_img_ids = train_test_split(img_ids, test_size=0.2, random_state=41)\n",
        "\n",
        "train_transform = Compose([\n",
        "    RandomRotate90(),\n",
        "    Flip(),\n",
        "    OneOf([\n",
        "        transforms.HueSaturationValue(),\n",
        "        transforms.RandomBrightness(),\n",
        "        transforms.RandomContrast(),\n",
        "    ], p=1),\n",
        "    Resize(config['input_h'], config['input_w']),\n",
        "    transforms.Normalize(),\n",
        "])\n",
        "\n",
        "val_transform = Compose([\n",
        "    Resize(config['input_h'], config['input_w']),\n",
        "    transforms.Normalize(),\n",
        "])\n",
        "\n",
        "train_dataset = Dataset(\n",
        "    img_ids=train_img_ids,\n",
        "    img_dir=os.path.join('inputs', config['dataset'], 'images'),\n",
        "    mask_dir=os.path.join('inputs', config['dataset'], 'masks'),\n",
        "    img_ext=config['img_ext'],\n",
        "    mask_ext=config['mask_ext'],\n",
        "    num_classes=config['num_classes'],\n",
        "    transform=train_transform)\n",
        "val_dataset = Dataset(\n",
        "    img_ids=val_img_ids,\n",
        "    img_dir=os.path.join('inputs', config['dataset'], 'images'),\n",
        "    mask_dir=os.path.join('inputs', config['dataset'], 'masks'),\n",
        "    img_ext=config['img_ext'],\n",
        "    mask_ext=config['mask_ext'],\n",
        "    num_classes=config['num_classes'],\n",
        "    transform=val_transform)\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(\n",
        "    train_dataset,\n",
        "    batch_size=config['batch_size'],\n",
        "    shuffle=True,\n",
        "    num_workers=config['num_workers'],\n",
        "    drop_last=True)\n",
        "val_loader = torch.utils.data.DataLoader(\n",
        "    val_dataset,\n",
        "    batch_size=config['batch_size'],\n",
        "    shuffle=False,\n",
        "    num_workers=config['num_workers'],\n",
        "    drop_last=False)\n",
        "\n",
        "log = OrderedDict([\n",
        "    ('epoch', []),\n",
        "    ('lr', []),\n",
        "    ('loss', []),\n",
        "    ('iou', []),\n",
        "    ('val_loss', []),\n",
        "    ('val_iou', []),\n",
        "])\n",
        "\n",
        "best_iou = 0\n",
        "trigger = 0\n",
        "for epoch in range(config['epochs']):\n",
        "    print('Epoch [%d/%d]' % (epoch, config['epochs']))\n",
        "\n",
        "    # train for one epoch\n",
        "    train_log = train(config, train_loader, model_analog, criterion, optimizer)\n",
        "    # evaluate on validation set\n",
        "    val_log = validate(config, val_loader, model_analog, criterion)\n",
        "\n",
        "    if config['scheduler'] == 'CosineAnnealingLR':\n",
        "        scheduler.step()\n",
        "    elif config['scheduler'] == 'ReduceLROnPlateau':\n",
        "        scheduler.step(val_log['loss'])\n",
        "\n",
        "    print('loss %.4f - iou %.4f - val_loss %.4f - val_iou %.4f'\n",
        "          % (train_log['loss'], train_log['iou'], val_log['loss'], val_log['iou']))\n",
        "\n",
        "    log['epoch'].append(epoch)\n",
        "    log['lr'].append(config['lr'])\n",
        "    log['loss'].append(train_log['loss'])\n",
        "    log['iou'].append(train_log['iou'])\n",
        "    log['val_loss'].append(val_log['loss'])\n",
        "    log['val_iou'].append(val_log['iou'])\n",
        "\n",
        "    pd.DataFrame(log).to_csv('models/%s/log.csv' %\n",
        "                              config['name'], index=False)\n",
        "\n",
        "    trigger += 1\n",
        "\n",
        "    if val_log['iou'] > best_iou:\n",
        "        torch.save(model_analog.state_dict(), 'models/%s/model2.pth' %\n",
        "                    config['name'])\n",
        "        best_iou = val_log['iou']\n",
        "        print(\"=> saved best model\")\n",
        "        trigger = 0\n",
        "\n",
        "    # early stopping\n",
        "    if config['early_stopping'] >= 0 and trigger >= config['early_stopping']:\n",
        "        print(\"=> early stopping\")\n",
        "        break\n",
        "\n",
        "    torch.cuda.empty_cache()\n",
        "\n"
      ],
      "metadata": {
        "id": "jMcMp1CNHlBv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c11f5eb8-82e3-4519-c2f8-8ccf5c7eb791"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/albumentations/augmentations/transforms.py:1258: FutureWarning: This class has been deprecated. Please use RandomBrightnessContrast\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/albumentations/augmentations/transforms.py:1284: FutureWarning: RandomContrast has been deprecated. Please use RandomBrightnessContrast\n",
            "  warnings.warn(\n",
            "/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "--------------------\n",
            "spatial_dims: 2\n",
            "in_channels: 3\n",
            "out_channels: 1\n",
            "channels: (16, 32, 64, 128, 256)\n",
            "strides: (2, 2, 2, 2)\n",
            "name: dsb2018_96_UNet_woDS\n",
            "epochs: 200\n",
            "batch_size: 64\n",
            "arch: UNet\n",
            "deep_supervision: False\n",
            "input_channels: 3\n",
            "num_classes: 1\n",
            "input_w: 96\n",
            "input_h: 96\n",
            "loss: BCEDiceLoss\n",
            "dataset: dsb2018_96\n",
            "img_ext: .png\n",
            "mask_ext: .png\n",
            "optimizer: SGD\n",
            "lr: 0.001\n",
            "momentum: 0.9\n",
            "weight_decay: 0.0001\n",
            "nesterov: False\n",
            "scheduler: CosineAnnealingLR\n",
            "min_lr: 1e-05\n",
            "factor: 0.1\n",
            "patience: 2\n",
            "milestones: 1,2\n",
            "gamma: 0.6666666666666666\n",
            "early_stopping: -1\n",
            "num_workers: 4\n",
            "--------------------\n",
            "=> creating model UNet\n",
            "Epoch [0/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 8/8 [00:01<00:00,  4.85it/s, loss=0.763, iou=0.477]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.40it/s, loss=0.745, iou=0.516]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7633 - iou 0.4775 - val_loss 0.7453 - val_iou 0.5156\n",
            "=> saved best model\n",
            "Epoch [1/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.15it/s, loss=0.766, iou=0.475]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.37it/s, loss=0.744, iou=0.516]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7661 - iou 0.4748 - val_loss 0.7441 - val_iou 0.5164\n",
            "=> saved best model\n",
            "Epoch [2/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.16it/s, loss=0.768, iou=0.469]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.33it/s, loss=0.744, iou=0.517]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7675 - iou 0.4693 - val_loss 0.7436 - val_iou 0.5171\n",
            "=> saved best model\n",
            "Epoch [3/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.33it/s, loss=0.761, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.43it/s, loss=0.742, iou=0.518]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7613 - iou 0.4775 - val_loss 0.7425 - val_iou 0.5184\n",
            "=> saved best model\n",
            "Epoch [4/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.12it/s, loss=0.759, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.36it/s, loss=0.742, iou=0.519]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7585 - iou 0.4809 - val_loss 0.7417 - val_iou 0.5192\n",
            "=> saved best model\n",
            "Epoch [5/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.08it/s, loss=0.761, iou=0.479]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.41it/s, loss=0.741, iou=0.52]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7610 - iou 0.4794 - val_loss 0.7412 - val_iou 0.5197\n",
            "=> saved best model\n",
            "Epoch [6/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.96it/s, loss=0.759, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.62it/s, loss=0.74, iou=0.521]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7589 - iou 0.4761 - val_loss 0.7405 - val_iou 0.5207\n",
            "=> saved best model\n",
            "Epoch [7/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.39it/s, loss=0.762, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.00it/s, loss=0.74, iou=0.52]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7619 - iou 0.4781 - val_loss 0.7402 - val_iou 0.5196\n",
            "Epoch [8/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.05it/s, loss=0.756, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.13it/s, loss=0.74, iou=0.52]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7563 - iou 0.4834 - val_loss 0.7398 - val_iou 0.5198\n",
            "Epoch [9/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.02it/s, loss=0.758, iou=0.482]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.17it/s, loss=0.739, iou=0.521]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7580 - iou 0.4820 - val_loss 0.7391 - val_iou 0.5207\n",
            "=> saved best model\n",
            "Epoch [10/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.94it/s, loss=0.759, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.10it/s, loss=0.739, iou=0.521]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7595 - iou 0.4757 - val_loss 0.7387 - val_iou 0.5207\n",
            "=> saved best model\n",
            "Epoch [11/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.02it/s, loss=0.752, iou=0.486]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.38it/s, loss=0.738, iou=0.521]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7521 - iou 0.4862 - val_loss 0.7383 - val_iou 0.5212\n",
            "=> saved best model\n",
            "Epoch [12/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.22it/s, loss=0.765, iou=0.467]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.82it/s, loss=0.738, iou=0.522]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7655 - iou 0.4668 - val_loss 0.7379 - val_iou 0.5220\n",
            "=> saved best model\n",
            "Epoch [13/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.82it/s, loss=0.759, iou=0.474]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.36it/s, loss=0.737, iou=0.521]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7591 - iou 0.4743 - val_loss 0.7374 - val_iou 0.5214\n",
            "Epoch [14/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.19it/s, loss=0.757, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.44it/s, loss=0.737, iou=0.521]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7571 - iou 0.4833 - val_loss 0.7369 - val_iou 0.5212\n",
            "Epoch [15/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.10it/s, loss=0.754, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.01it/s, loss=0.737, iou=0.521]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7538 - iou 0.4837 - val_loss 0.7367 - val_iou 0.5214\n",
            "Epoch [16/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.90it/s, loss=0.757, iou=0.479]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.14it/s, loss=0.736, iou=0.522]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7567 - iou 0.4791 - val_loss 0.7361 - val_iou 0.5222\n",
            "=> saved best model\n",
            "Epoch [17/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.01it/s, loss=0.76, iou=0.472]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.13it/s, loss=0.736, iou=0.522]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7595 - iou 0.4725 - val_loss 0.7360 - val_iou 0.5223\n",
            "=> saved best model\n",
            "Epoch [18/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.09it/s, loss=0.762, iou=0.469]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.28it/s, loss=0.735, iou=0.523]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7622 - iou 0.4689 - val_loss 0.7354 - val_iou 0.5229\n",
            "=> saved best model\n",
            "Epoch [19/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.17it/s, loss=0.752, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.89it/s, loss=0.735, iou=0.523]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7523 - iou 0.4839 - val_loss 0.7350 - val_iou 0.5232\n",
            "=> saved best model\n",
            "Epoch [20/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.75it/s, loss=0.748, iou=0.486]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.29it/s, loss=0.735, iou=0.523]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7479 - iou 0.4860 - val_loss 0.7350 - val_iou 0.5232\n",
            "Epoch [21/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.07it/s, loss=0.757, iou=0.471]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.76it/s, loss=0.734, iou=0.523]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7570 - iou 0.4711 - val_loss 0.7345 - val_iou 0.5233\n",
            "=> saved best model\n",
            "Epoch [22/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.98it/s, loss=0.753, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.46it/s, loss=0.734, iou=0.523]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7529 - iou 0.4829 - val_loss 0.7342 - val_iou 0.5234\n",
            "=> saved best model\n",
            "Epoch [23/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.32it/s, loss=0.752, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.12it/s, loss=0.734, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7515 - iou 0.4810 - val_loss 0.7339 - val_iou 0.5235\n",
            "=> saved best model\n",
            "Epoch [24/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.21it/s, loss=0.758, iou=0.474]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.31it/s, loss=0.734, iou=0.525]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7583 - iou 0.4744 - val_loss 0.7336 - val_iou 0.5248\n",
            "=> saved best model\n",
            "Epoch [25/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.25it/s, loss=0.76, iou=0.467]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.23it/s, loss=0.734, iou=0.523]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7597 - iou 0.4668 - val_loss 0.7337 - val_iou 0.5235\n",
            "Epoch [26/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.14it/s, loss=0.748, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.20it/s, loss=0.733, iou=0.523]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7482 - iou 0.4829 - val_loss 0.7333 - val_iou 0.5235\n",
            "Epoch [27/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.08it/s, loss=0.754, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.35it/s, loss=0.733, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7542 - iou 0.4806 - val_loss 0.7329 - val_iou 0.5240\n",
            "Epoch [28/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.19it/s, loss=0.756, iou=0.469]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.55it/s, loss=0.733, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7565 - iou 0.4694 - val_loss 0.7327 - val_iou 0.5238\n",
            "Epoch [29/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.98it/s, loss=0.753, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.36it/s, loss=0.732, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7527 - iou 0.4780 - val_loss 0.7324 - val_iou 0.5241\n",
            "Epoch [30/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.33it/s, loss=0.75, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.45it/s, loss=0.732, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7503 - iou 0.4852 - val_loss 0.7323 - val_iou 0.5244\n",
            "Epoch [31/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.12it/s, loss=0.756, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.27it/s, loss=0.732, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7565 - iou 0.4761 - val_loss 0.7319 - val_iou 0.5241\n",
            "Epoch [32/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.21it/s, loss=0.756, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.20it/s, loss=0.731, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7562 - iou 0.4780 - val_loss 0.7311 - val_iou 0.5260\n",
            "=> saved best model\n",
            "Epoch [33/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.29it/s, loss=0.759, iou=0.474]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.40it/s, loss=0.732, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7593 - iou 0.4740 - val_loss 0.7316 - val_iou 0.5241\n",
            "Epoch [34/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.89it/s, loss=0.745, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.42it/s, loss=0.731, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7450 - iou 0.4878 - val_loss 0.7312 - val_iou 0.5244\n",
            "Epoch [35/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.88it/s, loss=0.755, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.61it/s, loss=0.731, iou=0.524]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7549 - iou 0.4779 - val_loss 0.7311 - val_iou 0.5239\n",
            "Epoch [36/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.19it/s, loss=0.754, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.27it/s, loss=0.73, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7545 - iou 0.4764 - val_loss 0.7303 - val_iou 0.5258\n",
            "Epoch [37/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.20it/s, loss=0.75, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.14it/s, loss=0.73, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7504 - iou 0.4834 - val_loss 0.7300 - val_iou 0.5255\n",
            "Epoch [38/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.09it/s, loss=0.755, iou=0.475]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.07it/s, loss=0.73, iou=0.525]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7545 - iou 0.4750 - val_loss 0.7302 - val_iou 0.5254\n",
            "Epoch [39/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.24it/s, loss=0.76, iou=0.464]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.10it/s, loss=0.73, iou=0.525]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7596 - iou 0.4639 - val_loss 0.7298 - val_iou 0.5248\n",
            "Epoch [40/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.07it/s, loss=0.747, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.14it/s, loss=0.73, iou=0.525]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7475 - iou 0.4843 - val_loss 0.7297 - val_iou 0.5253\n",
            "Epoch [41/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.10it/s, loss=0.754, iou=0.473]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.22it/s, loss=0.729, iou=0.527]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7540 - iou 0.4729 - val_loss 0.7290 - val_iou 0.5266\n",
            "=> saved best model\n",
            "Epoch [42/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.75it/s, loss=0.752, iou=0.477]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.36it/s, loss=0.729, iou=0.525]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7515 - iou 0.4769 - val_loss 0.7293 - val_iou 0.5249\n",
            "Epoch [43/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.05it/s, loss=0.741, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.27it/s, loss=0.729, iou=0.527]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7409 - iou 0.4955 - val_loss 0.7285 - val_iou 0.5267\n",
            "=> saved best model\n",
            "Epoch [44/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.79it/s, loss=0.746, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.83it/s, loss=0.728, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7460 - iou 0.4815 - val_loss 0.7284 - val_iou 0.5261\n",
            "Epoch [45/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.13it/s, loss=0.751, iou=0.48]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.27it/s, loss=0.728, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7511 - iou 0.4805 - val_loss 0.7277 - val_iou 0.5278\n",
            "=> saved best model\n",
            "Epoch [46/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.43it/s, loss=0.753, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.12it/s, loss=0.728, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7531 - iou 0.4755 - val_loss 0.7282 - val_iou 0.5259\n",
            "Epoch [47/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.98it/s, loss=0.746, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.15it/s, loss=0.728, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7457 - iou 0.4875 - val_loss 0.7275 - val_iou 0.5263\n",
            "Epoch [48/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.18it/s, loss=0.756, iou=0.474]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.21it/s, loss=0.728, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7555 - iou 0.4737 - val_loss 0.7275 - val_iou 0.5265\n",
            "Epoch [49/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.65it/s, loss=0.752, iou=0.479]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.69it/s, loss=0.727, iou=0.527]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7525 - iou 0.4793 - val_loss 0.7271 - val_iou 0.5270\n",
            "Epoch [50/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.07it/s, loss=0.753, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.80it/s, loss=0.727, iou=0.526]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7534 - iou 0.4765 - val_loss 0.7270 - val_iou 0.5261\n",
            "Epoch [51/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.80it/s, loss=0.746, iou=0.482]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.06it/s, loss=0.727, iou=0.527]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7463 - iou 0.4824 - val_loss 0.7265 - val_iou 0.5273\n",
            "Epoch [52/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.92it/s, loss=0.752, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.05it/s, loss=0.726, iou=0.527]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7525 - iou 0.4757 - val_loss 0.7264 - val_iou 0.5275\n",
            "Epoch [53/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.88it/s, loss=0.748, iou=0.48]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.03it/s, loss=0.726, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7475 - iou 0.4799 - val_loss 0.7261 - val_iou 0.5280\n",
            "=> saved best model\n",
            "Epoch [54/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.95it/s, loss=0.744, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.13it/s, loss=0.726, iou=0.527]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7443 - iou 0.4886 - val_loss 0.7260 - val_iou 0.5271\n",
            "Epoch [55/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.19it/s, loss=0.744, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.70it/s, loss=0.726, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7440 - iou 0.4878 - val_loss 0.7258 - val_iou 0.5275\n",
            "Epoch [56/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.60it/s, loss=0.744, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.28it/s, loss=0.726, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7440 - iou 0.4837 - val_loss 0.7257 - val_iou 0.5278\n",
            "Epoch [57/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.28it/s, loss=0.749, iou=0.479]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.44it/s, loss=0.725, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7491 - iou 0.4789 - val_loss 0.7252 - val_iou 0.5280\n",
            "=> saved best model\n",
            "Epoch [58/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.76it/s, loss=0.745, iou=0.486]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.05it/s, loss=0.725, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7445 - iou 0.4857 - val_loss 0.7252 - val_iou 0.5280\n",
            "Epoch [59/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.88it/s, loss=0.744, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.02it/s, loss=0.725, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7443 - iou 0.4849 - val_loss 0.7252 - val_iou 0.5278\n",
            "Epoch [60/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.16it/s, loss=0.741, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.01it/s, loss=0.725, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7408 - iou 0.4874 - val_loss 0.7248 - val_iou 0.5286\n",
            "=> saved best model\n",
            "Epoch [61/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.12it/s, loss=0.748, iou=0.479]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.10it/s, loss=0.724, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7480 - iou 0.4786 - val_loss 0.7244 - val_iou 0.5290\n",
            "=> saved best model\n",
            "Epoch [62/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.99it/s, loss=0.745, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.96it/s, loss=0.724, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7455 - iou 0.4840 - val_loss 0.7243 - val_iou 0.5296\n",
            "=> saved best model\n",
            "Epoch [63/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.73it/s, loss=0.746, iou=0.48]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.32it/s, loss=0.724, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7457 - iou 0.4801 - val_loss 0.7244 - val_iou 0.5275\n",
            "Epoch [64/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.99it/s, loss=0.745, iou=0.486]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.43it/s, loss=0.724, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7448 - iou 0.4860 - val_loss 0.7239 - val_iou 0.5283\n",
            "Epoch [65/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.80it/s, loss=0.745, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.17it/s, loss=0.724, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7446 - iou 0.4872 - val_loss 0.7236 - val_iou 0.5289\n",
            "Epoch [66/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.76it/s, loss=0.739, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.95it/s, loss=0.723, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7388 - iou 0.4924 - val_loss 0.7233 - val_iou 0.5295\n",
            "Epoch [67/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.96it/s, loss=0.742, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.02it/s, loss=0.723, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7418 - iou 0.4873 - val_loss 0.7232 - val_iou 0.5292\n",
            "Epoch [68/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.02it/s, loss=0.746, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.98it/s, loss=0.723, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7457 - iou 0.4825 - val_loss 0.7229 - val_iou 0.5301\n",
            "=> saved best model\n",
            "Epoch [69/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.07it/s, loss=0.741, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.90it/s, loss=0.723, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7409 - iou 0.4878 - val_loss 0.7226 - val_iou 0.5298\n",
            "Epoch [70/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.82it/s, loss=0.74, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.36it/s, loss=0.723, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7400 - iou 0.4879 - val_loss 0.7230 - val_iou 0.5283\n",
            "Epoch [71/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.05it/s, loss=0.743, iou=0.486]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.52it/s, loss=0.722, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7429 - iou 0.4865 - val_loss 0.7224 - val_iou 0.5302\n",
            "=> saved best model\n",
            "Epoch [72/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.63it/s, loss=0.742, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.18it/s, loss=0.723, iou=0.528]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7423 - iou 0.4881 - val_loss 0.7227 - val_iou 0.5282\n",
            "Epoch [73/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.95it/s, loss=0.743, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.09it/s, loss=0.722, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7427 - iou 0.4853 - val_loss 0.7221 - val_iou 0.5295\n",
            "Epoch [74/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.40it/s, loss=0.738, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.66it/s, loss=0.722, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7383 - iou 0.4922 - val_loss 0.7222 - val_iou 0.5291\n",
            "Epoch [75/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.78it/s, loss=0.745, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.11it/s, loss=0.722, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7452 - iou 0.4812 - val_loss 0.7220 - val_iou 0.5290\n",
            "Epoch [76/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.03it/s, loss=0.739, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.50it/s, loss=0.722, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7391 - iou 0.4880 - val_loss 0.7217 - val_iou 0.5301\n",
            "Epoch [77/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.59it/s, loss=0.738, iou=0.493]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.29it/s, loss=0.722, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7383 - iou 0.4929 - val_loss 0.7216 - val_iou 0.5302\n",
            "Epoch [78/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.99it/s, loss=0.749, iou=0.473]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.18it/s, loss=0.721, iou=0.529]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7486 - iou 0.4734 - val_loss 0.7214 - val_iou 0.5292\n",
            "Epoch [79/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.82it/s, loss=0.742, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.00it/s, loss=0.721, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7416 - iou 0.4870 - val_loss 0.7215 - val_iou 0.5303\n",
            "=> saved best model\n",
            "Epoch [80/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.96it/s, loss=0.749, iou=0.473]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.02it/s, loss=0.721, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7487 - iou 0.4728 - val_loss 0.7209 - val_iou 0.5301\n",
            "Epoch [81/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.12it/s, loss=0.74, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.91it/s, loss=0.721, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7396 - iou 0.4866 - val_loss 0.7211 - val_iou 0.5295\n",
            "Epoch [82/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.87it/s, loss=0.743, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.76it/s, loss=0.721, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7427 - iou 0.4842 - val_loss 0.7205 - val_iou 0.5297\n",
            "Epoch [83/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.04it/s, loss=0.745, iou=0.479]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.48it/s, loss=0.721, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7445 - iou 0.4792 - val_loss 0.7205 - val_iou 0.5301\n",
            "Epoch [84/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.67it/s, loss=0.745, iou=0.48]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.43it/s, loss=0.72, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7445 - iou 0.4805 - val_loss 0.7202 - val_iou 0.5311\n",
            "=> saved best model\n",
            "Epoch [85/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.98it/s, loss=0.738, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.11it/s, loss=0.72, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7384 - iou 0.4899 - val_loss 0.7204 - val_iou 0.5301\n",
            "Epoch [86/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.80it/s, loss=0.747, iou=0.473]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.87it/s, loss=0.72, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7471 - iou 0.4733 - val_loss 0.7201 - val_iou 0.5300\n",
            "Epoch [87/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.91it/s, loss=0.743, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.02it/s, loss=0.72, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7430 - iou 0.4815 - val_loss 0.7198 - val_iou 0.5303\n",
            "Epoch [88/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.00it/s, loss=0.737, iou=0.493]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.93it/s, loss=0.719, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7366 - iou 0.4929 - val_loss 0.7195 - val_iou 0.5321\n",
            "=> saved best model\n",
            "Epoch [89/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.79it/s, loss=0.739, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.92it/s, loss=0.72, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7386 - iou 0.4887 - val_loss 0.7200 - val_iou 0.5300\n",
            "Epoch [90/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.11it/s, loss=0.729, iou=0.499]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.52it/s, loss=0.72, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7295 - iou 0.4990 - val_loss 0.7196 - val_iou 0.5301\n",
            "Epoch [91/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.64it/s, loss=0.735, iou=0.495]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.39it/s, loss=0.719, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7348 - iou 0.4946 - val_loss 0.7193 - val_iou 0.5311\n",
            "Epoch [92/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.94it/s, loss=0.744, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.99it/s, loss=0.719, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7441 - iou 0.4845 - val_loss 0.7195 - val_iou 0.5303\n",
            "Epoch [93/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.87it/s, loss=0.741, iou=0.482]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.82it/s, loss=0.719, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7410 - iou 0.4823 - val_loss 0.7192 - val_iou 0.5309\n",
            "Epoch [94/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.62it/s, loss=0.737, iou=0.491]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.87it/s, loss=0.719, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7374 - iou 0.4910 - val_loss 0.7186 - val_iou 0.5318\n",
            "Epoch [95/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.77it/s, loss=0.743, iou=0.482]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.00it/s, loss=0.719, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7432 - iou 0.4816 - val_loss 0.7187 - val_iou 0.5315\n",
            "Epoch [96/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  6.16it/s, loss=0.746, iou=0.477]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.87it/s, loss=0.719, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7458 - iou 0.4768 - val_loss 0.7187 - val_iou 0.5312\n",
            "Epoch [97/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.64it/s, loss=0.742, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.35it/s, loss=0.719, iou=0.53]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7418 - iou 0.4849 - val_loss 0.7188 - val_iou 0.5302\n",
            "Epoch [98/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.59it/s, loss=0.743, iou=0.482]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.28it/s, loss=0.719, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7433 - iou 0.4819 - val_loss 0.7186 - val_iou 0.5311\n",
            "Epoch [99/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.92it/s, loss=0.742, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.38it/s, loss=0.718, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7421 - iou 0.4830 - val_loss 0.7183 - val_iou 0.5322\n",
            "=> saved best model\n",
            "Epoch [100/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.82it/s, loss=0.744, iou=0.477]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.84it/s, loss=0.718, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7443 - iou 0.4773 - val_loss 0.7183 - val_iou 0.5316\n",
            "Epoch [101/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.93it/s, loss=0.732, iou=0.497]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.98it/s, loss=0.718, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7317 - iou 0.4971 - val_loss 0.7179 - val_iou 0.5315\n",
            "Epoch [102/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.96it/s, loss=0.737, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  5.04it/s, loss=0.718, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7370 - iou 0.4885 - val_loss 0.7177 - val_iou 0.5322\n",
            "=> saved best model\n",
            "Epoch [103/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.84it/s, loss=0.738, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.92it/s, loss=0.718, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7376 - iou 0.4882 - val_loss 0.7177 - val_iou 0.5317\n",
            "Epoch [104/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.97it/s, loss=0.739, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.40it/s, loss=0.718, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7386 - iou 0.4846 - val_loss 0.7177 - val_iou 0.5316\n",
            "Epoch [105/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.57it/s, loss=0.74, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.28it/s, loss=0.717, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7400 - iou 0.4835 - val_loss 0.7175 - val_iou 0.5320\n",
            "Epoch [106/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.93it/s, loss=0.739, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.86it/s, loss=0.717, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7388 - iou 0.4889 - val_loss 0.7175 - val_iou 0.5312\n",
            "Epoch [107/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.67it/s, loss=0.743, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.80it/s, loss=0.718, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7429 - iou 0.4834 - val_loss 0.7175 - val_iou 0.5322\n",
            "Epoch [108/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.91it/s, loss=0.736, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.81it/s, loss=0.717, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7360 - iou 0.4886 - val_loss 0.7172 - val_iou 0.5309\n",
            "Epoch [109/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.87it/s, loss=0.749, iou=0.47]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.68it/s, loss=0.717, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7488 - iou 0.4701 - val_loss 0.7174 - val_iou 0.5317\n",
            "Epoch [110/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.97it/s, loss=0.738, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.53it/s, loss=0.717, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7376 - iou 0.4876 - val_loss 0.7171 - val_iou 0.5319\n",
            "Epoch [111/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.15it/s, loss=0.745, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.08it/s, loss=0.717, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7448 - iou 0.4756 - val_loss 0.7166 - val_iou 0.5324\n",
            "=> saved best model\n",
            "Epoch [112/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.73it/s, loss=0.734, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.21it/s, loss=0.717, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7337 - iou 0.4963 - val_loss 0.7166 - val_iou 0.5322\n",
            "Epoch [113/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.50it/s, loss=0.737, iou=0.491]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.84it/s, loss=0.717, iou=0.531]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7366 - iou 0.4908 - val_loss 0.7170 - val_iou 0.5315\n",
            "Epoch [114/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.64it/s, loss=0.728, iou=0.499]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.91it/s, loss=0.717, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7283 - iou 0.4995 - val_loss 0.7169 - val_iou 0.5329\n",
            "=> saved best model\n",
            "Epoch [115/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.71it/s, loss=0.74, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.99it/s, loss=0.717, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7398 - iou 0.4843 - val_loss 0.7165 - val_iou 0.5325\n",
            "Epoch [116/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.86it/s, loss=0.746, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.86it/s, loss=0.716, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7457 - iou 0.4780 - val_loss 0.7164 - val_iou 0.5323\n",
            "Epoch [117/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.38it/s, loss=0.734, iou=0.494]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.83it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7337 - iou 0.4939 - val_loss 0.7160 - val_iou 0.5334\n",
            "=> saved best model\n",
            "Epoch [118/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.99it/s, loss=0.74, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.06it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7405 - iou 0.4835 - val_loss 0.7161 - val_iou 0.5328\n",
            "Epoch [119/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.88it/s, loss=0.731, iou=0.496]\n",
            "100%|██████████| 3/3 [00:01<00:00,  3.00it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7310 - iou 0.4962 - val_loss 0.7160 - val_iou 0.5329\n",
            "Epoch [120/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.12it/s, loss=0.736, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.86it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7359 - iou 0.4872 - val_loss 0.7162 - val_iou 0.5330\n",
            "Epoch [121/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.86it/s, loss=0.738, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.88it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7375 - iou 0.4852 - val_loss 0.7159 - val_iou 0.5332\n",
            "Epoch [122/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.67it/s, loss=0.738, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.83it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7376 - iou 0.4895 - val_loss 0.7156 - val_iou 0.5333\n",
            "Epoch [123/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.42it/s, loss=0.732, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.90it/s, loss=0.716, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7324 - iou 0.4964 - val_loss 0.7156 - val_iou 0.5335\n",
            "=> saved best model\n",
            "Epoch [124/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.82it/s, loss=0.745, iou=0.472]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.64it/s, loss=0.715, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7450 - iou 0.4720 - val_loss 0.7152 - val_iou 0.5337\n",
            "=> saved best model\n",
            "Epoch [125/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.72it/s, loss=0.733, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.16it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7332 - iou 0.4902 - val_loss 0.7156 - val_iou 0.5333\n",
            "Epoch [126/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.88it/s, loss=0.736, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.43it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7364 - iou 0.4888 - val_loss 0.7157 - val_iou 0.5327\n",
            "Epoch [127/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.61it/s, loss=0.735, iou=0.491]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.96it/s, loss=0.716, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7346 - iou 0.4911 - val_loss 0.7156 - val_iou 0.5329\n",
            "Epoch [128/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.78it/s, loss=0.745, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.57it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7454 - iou 0.4757 - val_loss 0.7152 - val_iou 0.5328\n",
            "Epoch [129/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.76it/s, loss=0.732, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.79it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7322 - iou 0.4955 - val_loss 0.7152 - val_iou 0.5330\n",
            "Epoch [130/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.85it/s, loss=0.736, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.85it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7358 - iou 0.4873 - val_loss 0.7152 - val_iou 0.5333\n",
            "Epoch [131/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.77it/s, loss=0.734, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.36it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7342 - iou 0.4895 - val_loss 0.7152 - val_iou 0.5330\n",
            "Epoch [132/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.64it/s, loss=0.732, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.04it/s, loss=0.715, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7316 - iou 0.4917 - val_loss 0.7152 - val_iou 0.5319\n",
            "Epoch [133/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.88it/s, loss=0.736, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.58it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7362 - iou 0.4849 - val_loss 0.7150 - val_iou 0.5331\n",
            "Epoch [134/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.69it/s, loss=0.744, iou=0.48]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.84it/s, loss=0.715, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7441 - iou 0.4805 - val_loss 0.7147 - val_iou 0.5345\n",
            "=> saved best model\n",
            "Epoch [135/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.70it/s, loss=0.736, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.61it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7358 - iou 0.4903 - val_loss 0.7148 - val_iou 0.5335\n",
            "Epoch [136/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.77it/s, loss=0.738, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.74it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7385 - iou 0.4850 - val_loss 0.7149 - val_iou 0.5331\n",
            "Epoch [137/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.74it/s, loss=0.731, iou=0.493]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.78it/s, loss=0.715, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7308 - iou 0.4929 - val_loss 0.7152 - val_iou 0.5323\n",
            "Epoch [138/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.44it/s, loss=0.742, iou=0.477]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.13it/s, loss=0.715, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7424 - iou 0.4767 - val_loss 0.7146 - val_iou 0.5340\n",
            "Epoch [139/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.80it/s, loss=0.734, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.20it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7343 - iou 0.4919 - val_loss 0.7145 - val_iou 0.5343\n",
            "Epoch [140/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.09it/s, loss=0.741, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.87it/s, loss=0.715, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7411 - iou 0.4813 - val_loss 0.7147 - val_iou 0.5341\n",
            "Epoch [141/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.55it/s, loss=0.746, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.77it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7456 - iou 0.4780 - val_loss 0.7144 - val_iou 0.5345\n",
            "=> saved best model\n",
            "Epoch [142/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.71it/s, loss=0.741, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.75it/s, loss=0.715, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7407 - iou 0.4828 - val_loss 0.7147 - val_iou 0.5324\n",
            "Epoch [143/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.62it/s, loss=0.729, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.74it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7290 - iou 0.4955 - val_loss 0.7145 - val_iou 0.5330\n",
            "Epoch [144/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.69it/s, loss=0.741, iou=0.482]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.77it/s, loss=0.715, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7415 - iou 0.4819 - val_loss 0.7149 - val_iou 0.5332\n",
            "Epoch [145/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.62it/s, loss=0.738, iou=0.483]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.99it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7379 - iou 0.4827 - val_loss 0.7143 - val_iou 0.5347\n",
            "=> saved best model\n",
            "Epoch [146/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.58it/s, loss=0.733, iou=0.493]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.04it/s, loss=0.715, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7334 - iou 0.4928 - val_loss 0.7145 - val_iou 0.5337\n",
            "Epoch [147/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.00it/s, loss=0.732, iou=0.491]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.80it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7322 - iou 0.4910 - val_loss 0.7144 - val_iou 0.5338\n",
            "Epoch [148/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.35it/s, loss=0.74, iou=0.478]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.89it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7399 - iou 0.4785 - val_loss 0.7143 - val_iou 0.5342\n",
            "Epoch [149/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.76it/s, loss=0.737, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.80it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7365 - iou 0.4879 - val_loss 0.7142 - val_iou 0.5341\n",
            "Epoch [150/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.52it/s, loss=0.73, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.78it/s, loss=0.714, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7295 - iou 0.4962 - val_loss 0.7143 - val_iou 0.5333\n",
            "Epoch [151/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.72it/s, loss=0.732, iou=0.494]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.30it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7322 - iou 0.4939 - val_loss 0.7144 - val_iou 0.5337\n",
            "Epoch [152/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.53it/s, loss=0.739, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.10it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7390 - iou 0.4841 - val_loss 0.7141 - val_iou 0.5339\n",
            "Epoch [153/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.81it/s, loss=0.728, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.73it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7281 - iou 0.4958 - val_loss 0.7140 - val_iou 0.5346\n",
            "Epoch [154/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.61it/s, loss=0.735, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.62it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7345 - iou 0.4922 - val_loss 0.7140 - val_iou 0.5339\n",
            "Epoch [155/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.64it/s, loss=0.734, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.62it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7343 - iou 0.4882 - val_loss 0.7140 - val_iou 0.5339\n",
            "Epoch [156/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.66it/s, loss=0.732, iou=0.492]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.72it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7324 - iou 0.4916 - val_loss 0.7141 - val_iou 0.5342\n",
            "Epoch [157/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.82it/s, loss=0.734, iou=0.491]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.69it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7345 - iou 0.4905 - val_loss 0.7141 - val_iou 0.5338\n",
            "Epoch [158/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.62it/s, loss=0.732, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.04it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7323 - iou 0.4896 - val_loss 0.7136 - val_iou 0.5339\n",
            "Epoch [159/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.70it/s, loss=0.738, iou=0.485]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.87it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7383 - iou 0.4853 - val_loss 0.7141 - val_iou 0.5340\n",
            "Epoch [160/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.06it/s, loss=0.737, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.27it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7365 - iou 0.4813 - val_loss 0.7136 - val_iou 0.5349\n",
            "=> saved best model\n",
            "Epoch [161/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.73it/s, loss=0.737, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.54it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7374 - iou 0.4839 - val_loss 0.7138 - val_iou 0.5350\n",
            "=> saved best model\n",
            "Epoch [162/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.61it/s, loss=0.738, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.58it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7379 - iou 0.4867 - val_loss 0.7138 - val_iou 0.5341\n",
            "Epoch [163/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.61it/s, loss=0.737, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.50it/s, loss=0.714, iou=0.532]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7368 - iou 0.4853 - val_loss 0.7144 - val_iou 0.5324\n",
            "Epoch [164/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.53it/s, loss=0.737, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.62it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7365 - iou 0.4854 - val_loss 0.7135 - val_iou 0.5354\n",
            "=> saved best model\n",
            "Epoch [165/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.06it/s, loss=0.744, iou=0.479]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.97it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7440 - iou 0.4787 - val_loss 0.7139 - val_iou 0.5341\n",
            "Epoch [166/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.87it/s, loss=0.727, iou=0.496]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.90it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7273 - iou 0.4965 - val_loss 0.7139 - val_iou 0.5338\n",
            "Epoch [167/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.22it/s, loss=0.737, iou=0.484]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.70it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7374 - iou 0.4836 - val_loss 0.7137 - val_iou 0.5349\n",
            "Epoch [168/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.52it/s, loss=0.736, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.56it/s, loss=0.713, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7362 - iou 0.4850 - val_loss 0.7133 - val_iou 0.5351\n",
            "Epoch [169/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.44it/s, loss=0.736, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.51it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7356 - iou 0.4880 - val_loss 0.7135 - val_iou 0.5347\n",
            "Epoch [170/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.59it/s, loss=0.734, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.69it/s, loss=0.714, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7343 - iou 0.4882 - val_loss 0.7141 - val_iou 0.5332\n",
            "Epoch [171/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.50it/s, loss=0.731, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.06it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7314 - iou 0.4961 - val_loss 0.7139 - val_iou 0.5339\n",
            "Epoch [172/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.72it/s, loss=0.734, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.15it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7341 - iou 0.4896 - val_loss 0.7139 - val_iou 0.5337\n",
            "Epoch [173/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.75it/s, loss=0.734, iou=0.488]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.69it/s, loss=0.714, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7339 - iou 0.4880 - val_loss 0.7141 - val_iou 0.5333\n",
            "Epoch [174/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.10it/s, loss=0.733, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.13it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7335 - iou 0.4887 - val_loss 0.7137 - val_iou 0.5336\n",
            "Epoch [175/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.66it/s, loss=0.729, iou=0.5]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.47it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7291 - iou 0.4998 - val_loss 0.7136 - val_iou 0.5350\n",
            "Epoch [176/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.51it/s, loss=0.74, iou=0.48]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.55it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7400 - iou 0.4796 - val_loss 0.7139 - val_iou 0.5344\n",
            "Epoch [177/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.54it/s, loss=0.74, iou=0.479]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.64it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7398 - iou 0.4790 - val_loss 0.7137 - val_iou 0.5340\n",
            "Epoch [178/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.55it/s, loss=0.739, iou=0.48]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.96it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7393 - iou 0.4800 - val_loss 0.7138 - val_iou 0.5338\n",
            "Epoch [179/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.87it/s, loss=0.735, iou=0.493]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.10it/s, loss=0.713, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7347 - iou 0.4934 - val_loss 0.7133 - val_iou 0.5350\n",
            "Epoch [180/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.66it/s, loss=0.735, iou=0.487]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.15it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7348 - iou 0.4873 - val_loss 0.7135 - val_iou 0.5344\n",
            "Epoch [181/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.11it/s, loss=0.739, iou=0.483]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.45it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7388 - iou 0.4831 - val_loss 0.7140 - val_iou 0.5338\n",
            "Epoch [182/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.63it/s, loss=0.735, iou=0.486]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.59it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7355 - iou 0.4860 - val_loss 0.7136 - val_iou 0.5343\n",
            "Epoch [183/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.51it/s, loss=0.733, iou=0.495]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.53it/s, loss=0.713, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7329 - iou 0.4949 - val_loss 0.7135 - val_iou 0.5337\n",
            "Epoch [184/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.86it/s, loss=0.736, iou=0.486]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.79it/s, loss=0.714, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7358 - iou 0.4860 - val_loss 0.7139 - val_iou 0.5329\n",
            "Epoch [185/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.68it/s, loss=0.734, iou=0.486]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.92it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7335 - iou 0.4862 - val_loss 0.7136 - val_iou 0.5339\n",
            "Epoch [186/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.60it/s, loss=0.735, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.71it/s, loss=0.714, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7346 - iou 0.4851 - val_loss 0.7136 - val_iou 0.5335\n",
            "Epoch [187/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.56it/s, loss=0.736, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.62it/s, loss=0.714, iou=0.533]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7356 - iou 0.4904 - val_loss 0.7139 - val_iou 0.5327\n",
            "Epoch [188/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.57it/s, loss=0.734, iou=0.49]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.57it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7337 - iou 0.4898 - val_loss 0.7135 - val_iou 0.5343\n",
            "Epoch [189/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.50it/s, loss=0.733, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.64it/s, loss=0.714, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7329 - iou 0.4961 - val_loss 0.7138 - val_iou 0.5348\n",
            "Epoch [190/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.61it/s, loss=0.743, iou=0.476]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.39it/s, loss=0.713, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7430 - iou 0.4759 - val_loss 0.7132 - val_iou 0.5349\n",
            "Epoch [191/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.28it/s, loss=0.736, iou=0.487]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.89it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7358 - iou 0.4865 - val_loss 0.7137 - val_iou 0.5342\n",
            "Epoch [192/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.73it/s, loss=0.74, iou=0.481]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.48it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7404 - iou 0.4815 - val_loss 0.7137 - val_iou 0.5340\n",
            "Epoch [193/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.55it/s, loss=0.741, iou=0.48]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.51it/s, loss=0.713, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7409 - iou 0.4799 - val_loss 0.7134 - val_iou 0.5344\n",
            "Epoch [194/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.77it/s, loss=0.732, iou=0.496]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.51it/s, loss=0.713, iou=0.535]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7317 - iou 0.4963 - val_loss 0.7133 - val_iou 0.5352\n",
            "Epoch [195/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.74it/s, loss=0.724, iou=0.505]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.70it/s, loss=0.713, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7241 - iou 0.5048 - val_loss 0.7135 - val_iou 0.5344\n",
            "Epoch [196/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.77it/s, loss=0.737, iou=0.485]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.57it/s, loss=0.713, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7367 - iou 0.4853 - val_loss 0.7134 - val_iou 0.5345\n",
            "Epoch [197/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  5.27it/s, loss=0.734, iou=0.489]\n",
            "100%|██████████| 3/3 [00:01<00:00,  2.83it/s, loss=0.713, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7340 - iou 0.4894 - val_loss 0.7133 - val_iou 0.5344\n",
            "Epoch [198/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:02<00:00,  3.68it/s, loss=0.734, iou=0.489]\n",
            "100%|██████████| 3/3 [00:00<00:00,  3.08it/s, loss=0.714, iou=0.534]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7337 - iou 0.4885 - val_loss 0.7138 - val_iou 0.5338\n",
            "Epoch [199/200]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\r  0%|          | 0/8 [00:00<?, ?it/s]/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:560: 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",
            "  warnings.warn(_create_warning_msg(\n",
            "100%|██████████| 8/8 [00:01<00:00,  4.13it/s, loss=0.734, iou=0.491]\n",
            "100%|██████████| 3/3 [00:00<00:00,  4.51it/s, loss=0.713, iou=0.535]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss 0.7335 - iou 0.4908 - val_loss 0.7133 - val_iou 0.5350\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Test the model after different days\n",
        "- We test the drift after 1 second, 1 hour, 1 day and 30 days\n"
      ],
      "metadata": {
        "id": "uaIvedzUhCfc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import OrderedDict\n",
        "from tqdm import tqdm\n",
        "\n",
        "def test_inference(config, model, criterion, test_loader):\n",
        "    #model.eval()  # ensure the model is in evaluation mode\n",
        "\n",
        "    # Initializing metric trackers\n",
        "    avg_meters = {'loss': AverageMeter(),\n",
        "                  'iou': AverageMeter(),\n",
        "                  'accuracy': AverageMeter(),\n",
        "                  'error': AverageMeter()}\n",
        "\n",
        "    with torch.no_grad():\n",
        "        pbar = tqdm(total=len(test_loader))\n",
        "\n",
        "        # Simulation of inference at different times after training.\n",
        "        for t_inference in [1, 3600,3600*24, 3600*24*30]:  # Example: Simulate the drift for 1 day.\n",
        "            print(t_inference)\n",
        "            model.drift_analog_weights(t_inference)  # Apply the drift simulation if applicable.\n",
        "\n",
        "            for data_batch in test_loader:\n",
        "                # Adjust the unpacking to account for the third item in the batch.\n",
        "                images, labels, _ = data_batch  # The third item is ignored as in training.\n",
        "\n",
        "                images = images.cuda()\n",
        "                labels = labels.cuda()\n",
        "\n",
        "                # Compute model output\n",
        "                if config['deep_supervision']:\n",
        "                    outputs = model(images)\n",
        "                    loss = 0\n",
        "                    for output in outputs:\n",
        "                        loss += criterion(output, labels)\n",
        "                    loss /= len(outputs)\n",
        "                    iou = iou_score(outputs[-1], labels)\n",
        "                else:\n",
        "                    output = model(images)\n",
        "                    loss = criterion(output, labels)\n",
        "                    iou = iou_score(output, labels)\n",
        "\n",
        "                # Calculate accuracy and error\n",
        "                _, predicted = torch.max(output.data, 1)\n",
        "                total = labels.size(0)\n",
        "                correct = (predicted == labels).sum().item()\n",
        "                accuracy = correct / total\n",
        "                error = 1 - accuracy\n",
        "\n",
        "                # Update tracking variables\n",
        "                avg_meters['loss'].update(loss.item(), total)\n",
        "                avg_meters['iou'].update(iou, total)\n",
        "\n",
        "                pbar.update(1)\n",
        "\n",
        "            # Displaying statistics after inference\n",
        "            print(f'Inference Time: {t_inference: .2e} seconds')\n",
        "            print(f'Average Loss: {avg_meters[\"loss\"].avg:.4f}\\tAverage IoU: {avg_meters[\"iou\"].avg:.4f}')\n",
        "\n",
        "            pbar.close()\n",
        "\n",
        "            # Resetting the average meters for the next inference time point\n",
        "            for meter in avg_meters.values():\n",
        "                meter.reset()\n",
        "\n",
        "    return OrderedDict([('loss', avg_meters['loss'].avg),\n",
        "                        ('iou', avg_meters['iou'].avg)])\n",
        "\n",
        "test_inference(config, model_analog,criterion, val_loader )"
      ],
      "metadata": {
        "id": "6lnrY3jKH9cc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def dice_score(pred, target, epsilon=1e-6):\n",
        "    \"\"\"\n",
        "    Compute the Dice score.\n",
        "\n",
        "    Args:\n",
        "    - pred (torch.Tensor): the predicted tensor\n",
        "    - target (torch.Tensor): the ground truth tensor\n",
        "    - epsilon (float): a small value to avoid division by zero\n",
        "\n",
        "    Returns:\n",
        "    - dice (torch.Tensor): computed Dice score\n",
        "    \"\"\"\n",
        "    pred_flat = pred.contiguous().view(-1)\n",
        "    target_flat = target.contiguous().view(-1)\n",
        "\n",
        "    intersection = (pred_flat * target_flat).sum()\n",
        "    denominator = pred_flat.sum() + target_flat.sum()\n",
        "\n",
        "    dice = (2 * intersection + epsilon) / (denominator + epsilon)\n",
        "    return dice"
      ],
      "metadata": {
        "id": "zqWHg1ZoR2oK"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}