From fe6873b8e45a8ac3da53ed8b6d9ee60d295d1072 Mon Sep 17 00:00:00 2001 From: Karam Mawas Date: Mon, 19 Feb 2024 01:55:11 +0100 Subject: [PATCH] Created using Colaboratory --- Lab2_DeepLearning_InstanceSegmentation.ipynb | 3441 ++++++++++++++++++ 1 file changed, 3441 insertions(+) create mode 100644 Lab2_DeepLearning_InstanceSegmentation.ipynb diff --git a/Lab2_DeepLearning_InstanceSegmentation.ipynb b/Lab2_DeepLearning_InstanceSegmentation.ipynb new file mode 100644 index 0000000..c6b5681 --- /dev/null +++ b/Lab2_DeepLearning_InstanceSegmentation.ipynb @@ -0,0 +1,3441 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "**GeoGroup Deep Learning Lab 2**\n", + "\n", + "[](https://www.tu-braunschweig.de/en/)\n", + "\n", + "[Dr. Pedro M. Achanccaray Diaz](https://www.tu-braunschweig.de/en/igp/staff/pedro-diaz) (p.diaz@tu-bs.de)\n", + "\n", + "[Technical University of Braunschweig](https://www.tu-braunschweig.de/en/) \n", + "[Institute of Geodesy and Photogrammetry](https://www.tu-braunschweig.de/igp)" + ], + "metadata": { + "id": "g19zwb_BqS5m" + } + }, + { + "cell_type": "markdown", + "source": [ + "# **Lab 2: Instance segmentation using MMDetection**" + ], + "metadata": { + "id": "0qcwrx6xqZQ5" + } + }, + { + "cell_type": "markdown", + "source": [ + "In this lab session, we will cover the following topics:\n", + "- Installation of MMDetection\n", + "- Train a model with a custom dataset\n", + "- Test a trained model with new images\n", + "\n", + "For this purpose, we will use two datasets: **UAV_images** and **Halls**.\n", + "\n", + "The **UAV_images** were acquired in a previous session using a drone:\n", + "\n", + "
\n", + "\n", + "\n", + "\n", + "
\n", + "\n", + "The **Halls** dataset are part of the images used in the project [SPP 2255 - C3](https://www.tu-braunschweig.de/en/igp/projects/spp2255-c3) for\n", + " system hall detection.\n", + "\n", + "You can download both dataset from the GeoGroup folder in nextcloud: `GeoGroup/Workshops/Workshop_Series_Deep_Learning/15012024_DeepLearning_InstanceSegmentation`" + ], + "metadata": { + "id": "3vFefVEHqeZi" + } + }, + { + "cell_type": "markdown", + "source": [ + "# **Working environment set up**" + ], + "metadata": { + "id": "l1YME9G-5Dc5" + } + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FzTZ4GxuTavC" + }, + "source": [ + "## **Mount Google Drive to Google Colab**" + ] + }, + { + "cell_type": "markdown", + "source": [ + "First, mount your Google Drive to Gooble Colab." + ], + "metadata": { + "id": "Uv05R5mR4vE9" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pbVhDuWpz5oI", + "outputId": "53c087cd-a922-4cd0-c428-17b5b189ff59" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Then, go to your working directory. In this case: `Colabs/IGP/GeoGroup/DL_2/`" + ], + "metadata": { + "id": "Wf9mZ7UY4ysM" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KV60vSVf0lhB", + "outputId": "c1fa2fd3-4540-42aa-b31f-74bb5057a811" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content/drive/MyDrive/InstanceSegmentation\n" + ] + } + ], + "source": [ + "%cd drive/MyDrive/InstanceSegmentation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hR2_0Gb89EAQ" + }, + "source": [ + "## **Install MMDetection**" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Run the following lines to install [MMDetection](https://github.com/open-mmlab/mmdetection/tree/main).\n", + "\n", + "_This might take a couple of minutes, so it is a good time to go for a cup of coffee or tea._\n", + "\n", + "**Important:** The following lines should be executed **only the first time** you install MMDetection:\n", + "\n", + "```\n", + "!rm -rf mmdetection\n", + "!git clone https://github.com/open-mmlab/mmdetection.git\n", + "```\n", + "\n", + "Then, everytime you start a new Colab session, you have to execute the other lines.\n", + "\n", + "\n", + "---\n", + "\n", + "Once the installation has finished, you will see the following message:\n", + "\n", + "![](https://drive.google.com/uc?export=view&id=1074cHmM9qecqQTpFQd0e7amiy2vgOG27)\n", + "\n", + "So, you need to click on `RESTART SESSION` to complete the MMDetection installation.\n", + "\n", + "**Important:** After you restart the session, it might be necessary to mount your Google Drive again." + ], + "metadata": { + "id": "AzXd_T_K5bGu" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eO2xtRPs-cR2", + "outputId": "de39854f-a83d-4dd1-b5d5-95de7d355879" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: openmim in /usr/local/lib/python3.10/dist-packages (0.3.9)\n", + "Requirement already satisfied: Click in /usr/local/lib/python3.10/dist-packages (from openmim) (8.1.7)\n", + "Requirement already satisfied: colorama in /usr/local/lib/python3.10/dist-packages (from openmim) (0.4.6)\n", + "Requirement already satisfied: model-index in /usr/local/lib/python3.10/dist-packages (from openmim) (0.1.11)\n", + "Requirement already satisfied: opendatalab in /usr/local/lib/python3.10/dist-packages (from openmim) (0.0.10)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from openmim) (1.5.3)\n", + "Requirement already satisfied: pip>=19.3 in /usr/local/lib/python3.10/dist-packages (from openmim) (23.1.2)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from openmim) (2.28.2)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.10/dist-packages (from openmim) (13.4.2)\n", + "Requirement already satisfied: tabulate in /usr/local/lib/python3.10/dist-packages (from openmim) (0.9.0)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from model-index->openmim) (6.0.1)\n", + "Requirement already satisfied: markdown in /usr/local/lib/python3.10/dist-packages (from model-index->openmim) (3.5.1)\n", + "Requirement already satisfied: ordered-set in /usr/local/lib/python3.10/dist-packages (from model-index->openmim) (4.1.0)\n", + "Requirement already satisfied: pycryptodome in /usr/local/lib/python3.10/dist-packages (from opendatalab->openmim) (3.20.0)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from opendatalab->openmim) (4.65.2)\n", + "Requirement already satisfied: openxlab in /usr/local/lib/python3.10/dist-packages (from opendatalab->openmim) (0.0.34)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->openmim) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->openmim) (3.6)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->openmim) (1.26.18)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->openmim) (2023.11.17)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas->openmim) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->openmim) (2023.3.post1)\n", + "Requirement already satisfied: numpy>=1.21.0 in /usr/local/lib/python3.10/dist-packages (from pandas->openmim) (1.23.5)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/dist-packages (from rich->openmim) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from rich->openmim) (2.16.1)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/dist-packages (from markdown-it-py>=2.2.0->rich->openmim) (0.1.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.1->pandas->openmim) (1.16.0)\n", + "Requirement already satisfied: oss2~=2.17.0 in /usr/local/lib/python3.10/dist-packages (from openxlab->opendatalab->openmim) (2.17.0)\n", + "Requirement already satisfied: setuptools~=60.2.0 in /usr/local/lib/python3.10/dist-packages (from openxlab->opendatalab->openmim) (60.2.0)\n", + "Requirement already satisfied: crcmod>=1.7 in /usr/local/lib/python3.10/dist-packages (from oss2~=2.17.0->openxlab->opendatalab->openmim) (1.7)\n", + "Requirement already satisfied: aliyun-python-sdk-kms>=2.4.1 in /usr/local/lib/python3.10/dist-packages (from oss2~=2.17.0->openxlab->opendatalab->openmim) (2.16.2)\n", + "Requirement already satisfied: aliyun-python-sdk-core>=2.13.12 in /usr/local/lib/python3.10/dist-packages (from oss2~=2.17.0->openxlab->opendatalab->openmim) (2.14.0)\n", + "Requirement already satisfied: jmespath<1.0.0,>=0.9.3 in /usr/local/lib/python3.10/dist-packages (from aliyun-python-sdk-core>=2.13.12->oss2~=2.17.0->openxlab->opendatalab->openmim) (0.10.0)\n", + "Requirement already satisfied: cryptography>=2.6.0 in /usr/local/lib/python3.10/dist-packages (from aliyun-python-sdk-core>=2.13.12->oss2~=2.17.0->openxlab->opendatalab->openmim) (41.0.7)\n", + "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.10/dist-packages (from cryptography>=2.6.0->aliyun-python-sdk-core>=2.13.12->oss2~=2.17.0->openxlab->opendatalab->openmim) (1.16.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from cffi>=1.12->cryptography>=2.6.0->aliyun-python-sdk-core>=2.13.12->oss2~=2.17.0->openxlab->opendatalab->openmim) (2.21)\n", + "Looking in links: https://download.openmmlab.com/mmcv/dist/cu121/torch2.1.0/index.html\n", + "Requirement already satisfied: mmengine>=0.7.0 in /usr/local/lib/python3.10/dist-packages (0.10.2)\n", + "Requirement already satisfied: addict in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.7.0) (2.4.0)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.7.0) (3.7.1)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.7.0) (1.23.5)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.7.0) (6.0.1)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.7.0) (13.4.2)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.7.0) (2.4.0)\n", + "Requirement already satisfied: yapf in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.7.0) (0.40.2)\n", + "Requirement already satisfied: opencv-python>=3 in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.7.0) (4.8.0.76)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.7.0) (1.2.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.7.0) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.7.0) (4.47.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.7.0) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.7.0) (23.2)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.7.0) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.7.0) (3.1.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.7.0) (2.8.2)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/dist-packages (from rich->mmengine>=0.7.0) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from rich->mmengine>=0.7.0) (2.16.1)\n", + "Requirement already satisfied: importlib-metadata>=6.6.0 in /usr/local/lib/python3.10/dist-packages (from yapf->mmengine>=0.7.0) (7.0.1)\n", + "Requirement already satisfied: platformdirs>=3.5.1 in /usr/local/lib/python3.10/dist-packages (from yapf->mmengine>=0.7.0) (4.1.0)\n", + "Requirement already satisfied: tomli>=2.0.1 in /usr/local/lib/python3.10/dist-packages (from yapf->mmengine>=0.7.0) (2.0.1)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.10/dist-packages (from importlib-metadata>=6.6.0->yapf->mmengine>=0.7.0) (3.17.0)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/dist-packages (from markdown-it-py>=2.2.0->rich->mmengine>=0.7.0) (0.1.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->mmengine>=0.7.0) (1.16.0)\n", + "Looking in links: https://download.openmmlab.com/mmcv/dist/cu121/torch2.1.0/index.html\n", + "Requirement already satisfied: mmcv>=2.0.0rc4 in /usr/local/lib/python3.10/dist-packages (2.1.0)\n", + "Requirement already satisfied: addict in /usr/local/lib/python3.10/dist-packages (from mmcv>=2.0.0rc4) (2.4.0)\n", + "Requirement already satisfied: mmengine>=0.3.0 in /usr/local/lib/python3.10/dist-packages (from mmcv>=2.0.0rc4) (0.10.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from mmcv>=2.0.0rc4) (1.23.5)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from mmcv>=2.0.0rc4) (23.2)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.10/dist-packages (from mmcv>=2.0.0rc4) (9.4.0)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from mmcv>=2.0.0rc4) (6.0.1)\n", + "Requirement already satisfied: yapf in /usr/local/lib/python3.10/dist-packages (from mmcv>=2.0.0rc4) (0.40.2)\n", + "Requirement already satisfied: opencv-python>=3 in /usr/local/lib/python3.10/dist-packages (from mmcv>=2.0.0rc4) (4.8.0.76)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.3.0->mmcv>=2.0.0rc4) (3.7.1)\n", + "Requirement already satisfied: rich in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.3.0->mmcv>=2.0.0rc4) (13.4.2)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.10/dist-packages (from mmengine>=0.3.0->mmcv>=2.0.0rc4) (2.4.0)\n", + "Requirement already satisfied: importlib-metadata>=6.6.0 in /usr/local/lib/python3.10/dist-packages (from yapf->mmcv>=2.0.0rc4) (7.0.1)\n", + "Requirement already satisfied: platformdirs>=3.5.1 in /usr/local/lib/python3.10/dist-packages (from yapf->mmcv>=2.0.0rc4) (4.1.0)\n", + "Requirement already satisfied: tomli>=2.0.1 in /usr/local/lib/python3.10/dist-packages (from yapf->mmcv>=2.0.0rc4) (2.0.1)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.10/dist-packages (from importlib-metadata>=6.6.0->yapf->mmcv>=2.0.0rc4) (3.17.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.3.0->mmcv>=2.0.0rc4) (1.2.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.3.0->mmcv>=2.0.0rc4) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.3.0->mmcv>=2.0.0rc4) (4.47.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.3.0->mmcv>=2.0.0rc4) (1.4.5)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.3.0->mmcv>=2.0.0rc4) (3.1.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmengine>=0.3.0->mmcv>=2.0.0rc4) (2.8.2)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in /usr/local/lib/python3.10/dist-packages (from rich->mmengine>=0.3.0->mmcv>=2.0.0rc4) (3.0.0)\n", + "Requirement already satisfied: pygments<3.0.0,>=2.13.0 in /usr/local/lib/python3.10/dist-packages (from rich->mmengine>=0.3.0->mmcv>=2.0.0rc4) (2.16.1)\n", + "Requirement already satisfied: mdurl~=0.1 in /usr/local/lib/python3.10/dist-packages (from markdown-it-py>=2.2.0->rich->mmengine>=0.3.0->mmcv>=2.0.0rc4) (0.1.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->mmengine>=0.3.0->mmcv>=2.0.0rc4) (1.16.0)\n", + "/content/drive/MyDrive/InstanceSegmentation/mmdetection\n", + "Obtaining file:///content/drive/MyDrive/InstanceSegmentation/mmdetection\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from mmdet==3.3.0) (3.7.1)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from mmdet==3.3.0) (1.23.5)\n", + "Requirement already satisfied: pycocotools in /usr/local/lib/python3.10/dist-packages (from mmdet==3.3.0) (2.0.7)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from mmdet==3.3.0) (1.11.4)\n", + "Requirement already satisfied: shapely in /usr/local/lib/python3.10/dist-packages (from mmdet==3.3.0) (2.0.2)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from mmdet==3.3.0) (1.16.0)\n", + "Requirement already satisfied: terminaltables in /usr/local/lib/python3.10/dist-packages (from mmdet==3.3.0) (3.1.10)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from mmdet==3.3.0) (4.65.2)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmdet==3.3.0) (1.2.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmdet==3.3.0) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmdet==3.3.0) (4.47.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmdet==3.3.0) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmdet==3.3.0) (23.2)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmdet==3.3.0) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmdet==3.3.0) (3.1.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->mmdet==3.3.0) (2.8.2)\n", + "Installing collected packages: mmdet\n", + " Attempting uninstall: mmdet\n", + " Found existing installation: mmdet 3.3.0\n", + " Uninstalling mmdet-3.3.0:\n", + " Successfully uninstalled mmdet-3.3.0\n", + " Running setup.py develop for mmdet\n", + "Successfully installed mmdet-3.3.0\n" + ] + } + ], + "source": [ + "# install dependencies: (use cu111 because colab has CUDA 11.1)\n", + "%pip install -U openmim\n", + "!mim install \"mmengine>=0.7.0\"\n", + "!mim install \"mmcv>=2.0.0rc4\"\n", + "\n", + "# Install mmdetection\n", + "# Important: run the following two lines only the\n", + "# first time to install mmdetection\n", + "#!rm -rf mmdetection\n", + "#!git clone https://github.com/open-mmlab/mmdetection.git\n", + "\n", + "%cd mmdetection\n", + "%pip install -e ." + ] + }, + { + "cell_type": "markdown", + "source": [ + "## **Check MMDetection installation**" + ], + "metadata": { + "id": "eaxaKjLh7a6k" + } + }, + { + "cell_type": "markdown", + "source": [ + "The following lines will help us to verify the installation." + ], + "metadata": { + "id": "HlJSwroF7fmq" + } + }, + { + "cell_type": "code", + "source": [ + "# Check Pytorch installation\n", + "import torch, torchvision\n", + "print(\"torch version:\",torch.__version__, \"cuda:\",torch.cuda.is_available())\n", + "\n", + "# Check MMDetection installation\n", + "import mmdet\n", + "print(\"mmdetection:\",mmdet.__version__)\n", + "\n", + "# Check mmcv installation\n", + "import mmcv\n", + "print(\"mmcv:\",mmcv.__version__)\n", + "\n", + "# Check mmengine installation\n", + "import mmengine\n", + "print(\"mmengine:\",mmengine.__version__)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "x5J6lW96rCV8", + "outputId": "e1dbc417-04d5-4993-9bb0-61de9f5bae72" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "torch version: 2.1.0+cu121 cuda: True\n", + "mmdetection: 3.3.0\n", + "mmcv: 2.1.0\n", + "mmengine: 0.10.2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jZXtJO4STmZh" + }, + "source": [ + "# **Run inference with demo image**" + ] + }, + { + "cell_type": "markdown", + "source": [ + "To execute the following lines, **we must be located in the `mmdetection` directory**.\n", + "\n", + "You can change the directory using the `cd`command:\n", + "\n", + "```\n", + "%cd mmdetection\n", + "```\n", + "\n" + ], + "metadata": { + "id": "NhA__E7K7y-K" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D_2j-Q22DVhK", + "outputId": "0c16b895-c198-4636-abee-af887d1de1d7" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "processing mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco...\n", + "\u001b[2Kdownloading \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m169.6/169.6 MiB\u001b[0m \u001b[31m9.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h\u001b[32mSuccessfully downloaded mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth to /content/drive/MyDrive/InstanceSegmentation/mmdetection/checkpoints\u001b[0m\n", + "\u001b[32mSuccessfully dumped mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py to /content/drive/MyDrive/InstanceSegmentation/mmdetection/checkpoints\u001b[0m\n" + ] + } + ], + "source": [ + "# %cd mmdetection\n", + "# download the model then load it then check the inference with an image\n", + "!mim download mmdet --config mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco --dest ./checkpoints" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nBA7MQoSDdlS", + "outputId": "ca755128-1b1d-4163-c871-e776fa97c306" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Loads checkpoint by local backend from path: checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth\n" + ] + } + ], + "source": [ + "import mmcv\n", + "import mmengine\n", + "from mmdet.apis import init_detector, inference_detector\n", + "from mmdet.utils import register_all_modules\n", + "# Choose to use a config and initialize the detector\n", + "config_file = 'configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-3x_coco.py'\n", + "# Setup a checkpoint file to load\n", + "checkpoint_file = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'\n", + "\n", + "# register all modules in mmdet into the registries\n", + "register_all_modules()\n", + "\n", + "# build the model from a config file and a checkpoint file\n", + "model = init_detector(config_file, checkpoint_file, device='cuda:0') # or device='cuda:0'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "e8QLNK1ADitb" + }, + "outputs": [], + "source": [ + "image = mmcv.imread('demo/demo.jpg',channel_order='rgb')\n", + "result = inference_detector(model, image)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 520 + }, + "id": "K3YPs9LWEHMb", + "outputId": "8e83762d-6f0b-4bf8-c250-d9a6c1d013d4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/mmengine/visualization/visualizer.py:196: UserWarning: Failed to add , please provide the `save_dir` argument.\n", + " warnings.warn(f'Failed to add {vis_backend.__class__}, '\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "from mmdet.registry import VISUALIZERS\n", + "# init visualizer(run the block only once in jupyter notebook)\n", + "visualizer = VISUALIZERS.build(model.cfg.visualizer)\n", + "# the dataset_meta is loaded from the checkpoint and\n", + "# then pass to the model in init_detector\n", + "visualizer.dataset_meta = model.dataset_meta\n", + "\n", + "# show the results\n", + "visualizer.add_datasample(\n", + " 'result',\n", + " image,\n", + " data_sample=result,\n", + " draw_gt = None,\n", + " wait_time=0,\n", + ")\n", + "visualizer.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5urHifZT2pVK" + }, + "source": [ + "# **Train with custom datasets - UAV images**" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Let's import the necessary packages" + ], + "metadata": { + "id": "bf-HEKqb9--T" + } + }, + { + "cell_type": "code", + "source": [ + "from mmengine import Config\n", + "from mmengine.runner import set_random_seed\n", + "from mmengine.runner import Runner\n", + "from mmengine.visualization import Visualizer\n", + "import mmcv\n", + "from mmdet.apis import init_detector, inference_detector\n", + "\n", + "from glob import glob\n", + "from os.path import join,basename\n", + "from os import makedirs" + ], + "metadata": { + "id": "So6_IbfrM42w" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "This is an auxiliary function to save the obtained results after training the model." + ], + "metadata": { + "id": "jzTofCYG8i29" + } + }, + { + "cell_type": "code", + "source": [ + "def save_results(TEST_PATH,\n", + " work_dir,\n", + " epoch,\n", + " threshold,\n", + " format):\n", + " list_test = glob(join(TEST_PATH, format))\n", + " checkpoint_file = join(work_dir,\"epoch_{}.pth\".format(epoch))\n", + " results_dir = join(work_dir, \"results\")\n", + " makedirs(results_dir, exist_ok=True)\n", + "\n", + " model = init_detector(cfg,\n", + " checkpoint_file,\n", + " device='cuda:0')\n", + "\n", + " for idx, img_path in enumerate(list_test):\n", + " img = mmcv.imread(img_path, channel_order='rgb')\n", + " new_result = inference_detector(model, img)\n", + "\n", + " visualizer_now = Visualizer.get_current_instance()\n", + " visualizer_now.dataset_meta = model.dataset_meta\n", + " # show the results\n", + " visualizer_now.add_datasample(\n", + " 'new_result',\n", + " img,\n", + " data_sample=new_result,\n", + " draw_gt=False,\n", + " wait_time=0,\n", + " out_file=join(results_dir, basename(img_path)),\n", + " pred_score_thr=threshold\n", + " )" + ], + "metadata": { + "id": "X7iTen3QaNsc" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8hu8JIRDXQR6" + }, + "source": [ + "## **Instance segmentation model**" + ] + }, + { + "cell_type": "markdown", + "source": [ + "We will use the Mask R-CNN architecture with ResNet 50 as backbone.\n", + "\n", + "MMDetection offers many different architecture. You can see the Model Zoo [here](https://github.com/open-mmlab/mmdetection/tree/main?tab=readme-ov-file#overview-of-benchmark-and-model-zoo).\n", + "\n", + "Now, we need to create the configuration file with information about our dataset and the selected architecture.\n", + "\n", + "**Important:** Depending on the selected architecture, the configuration file might be different as each architecture has specific parameters.\n", + "\n", + "\n" + ], + "metadata": { + "id": "P1YfFZtW-hnn" + } + }, + { + "cell_type": "markdown", + "source": [ + "The most important parameters are the ones related to our dataset:\n", + "- `cfg.metainfo`: information about the existing classes in our dataset and the palette to be used for visualization. Remember, the class names must be exactly the same used during annotation (including capital letters).\n", + "- `cfg.data_root`, `cfg.train_dataloader`,...: information about the path of images for train, validation, and test." + ], + "metadata": { + "id": "Ym4D5uUZFjDt" + } + }, + { + "cell_type": "markdown", + "source": [ + "\n", + "At this point, upload your dataset to the `mmdetection` folder. You can create a subfolder called `data` to upload your dataset. You should have a folder structure similar to the following:\n", + "\n", + " ```\n", + " mmdetection\n", + " ├── checkpoints\n", + " ├── CITATION.cff\n", + " ├── configs\n", + " ├── data\n", + " ├── Halls\n", + " └── UAV_images\n", + " └── train\n", + " ├── DJI_20231023132057_0001_V.JPG\n", + " ├── DJI_20231023132058_0002_V.JPG\n", + " ├── DJI_20231023132059_0003_V.JPG\n", + " ├── DJI_20231023132100_0004_V.JPG\n", + " ├── DJI_20231023132108_0014_V.JPG\n", + " ├── DJI_20231023132111_0017_V.JPG\n", + " └── train_annotations.json\n", + " ├── [...]\n", + " ```" + ], + "metadata": { + "id": "ZDKIdeLcFkwT" + } + }, + { + "cell_type": "code", + "source": [ + "def create_config(base_config,\n", + " checkpoint,\n", + " work_dir):\n", + " cfg = Config.fromfile(base_config)\n", + "\n", + " # Modify dataset classes and color | should be exactly the same as json file same order and typing\n", + " cfg.metainfo = {\n", + " 'classes': ('Person', 'Car'),\n", + " 'palette': [\n", + " (220, 20, 60),\n", + " (20, 220, 60),\n", + " ]\n", + " }\n", + "\n", + " # Modify dataset type and path\n", + " cfg.data_root = './data/UAV_images/'\n", + "\n", + " cfg.train_dataloader.dataset.ann_file = 'train/train_annotations.json'\n", + " cfg.train_dataloader.dataset.data_root = cfg.data_root\n", + " cfg.train_dataloader.dataset.data_prefix.img = 'train/'\n", + " cfg.train_dataloader.dataset.metainfo = cfg.metainfo\n", + "\n", + " # cfg.train_cfg.max_epochs = 20 # default is 12 in case we would like to change training epochs!\n", + "\n", + " cfg.val_dataloader.dataset.ann_file = 'train/train_annotations.json'\n", + " cfg.val_dataloader.dataset.data_root = cfg.data_root\n", + " cfg.val_dataloader.dataset.data_prefix.img = 'train/'\n", + " cfg.val_dataloader.dataset.metainfo = cfg.metainfo\n", + "\n", + " cfg.test_dataloader.dataset.ann_file = 'train/train_annotations.json'\n", + " cfg.test_dataloader.dataset.data_root = cfg.data_root\n", + " cfg.test_dataloader.dataset.data_prefix.img = 'train/'\n", + " cfg.test_dataloader.dataset.metainfo = cfg.metainfo\n", + "\n", + " # Modify metric config\n", + " cfg.val_evaluator.ann_file = cfg.data_root+'train/train_annotations.json'\n", + " cfg.test_evaluator.ann_file = cfg.data_root+'train/train_annotations.json'\n", + "\n", + " # Modify num classes of the model in box head and mask head\n", + " cfg.model.roi_head.bbox_head.num_classes = 2 # number of classes\n", + " cfg.model.roi_head.mask_head.num_classes = 2\n", + "\n", + " # We can still the pre-trained Mask RCNN model to obtain a higher performance\n", + " cfg.load_from = checkpoint\n", + "\n", + " # Set up working dir to save files and logs.\n", + " cfg.work_dir = work_dir\n", + "\n", + " # We can set the evaluation interval to reduce the evaluation times\n", + " cfg.train_cfg.val_interval = 3\n", + " # We can set the checkpoint saving interval to reduce the storage cost\n", + " cfg.default_hooks.checkpoint.interval = 3\n", + "\n", + " # The original learning rate (LR) is set for 8-GPU training.\n", + " # We divide it by 8 since we only use one GPU.\n", + " cfg.optim_wrapper.optimizer.lr = 0.02 / 8\n", + " cfg.default_hooks.logger.interval = 10\n", + "\n", + " # Set seed thus the results are more reproducible\n", + " # cfg.seed = 0\n", + " set_random_seed(0, deterministic=False)\n", + "\n", + " # We can also use tensorboard to log the training process\n", + " cfg.visualizer.vis_backends.append({\"type\":'TensorboardVisBackend'})\n", + "\n", + " return cfg" + ], + "metadata": { + "id": "gHWgsqU_OJ7c" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "##**Configuration file**" + ], + "metadata": { + "id": "LhWtKKRcASPk" + } + }, + { + "cell_type": "markdown", + "source": [ + "Now, we need to create the configuration file.\n", + "\n", + "For this purpose, we can take the available examples provided by MMDetection in the folder: `mmdetection/configs/`. There are configuration files for all available models (you can see the repository too: [configs](https://github.com/open-mmlab/mmdetection/tree/main/configs).\n", + "\n", + "Then, we will fine tune a pre-trained model. Thus, we need to provide the `checkpoint`with the pre-trained model. You can see the model zoo to get the checkpoints.\n", + "\n", + "For instance, for Mask RCNN, we have the following checkpoints: [Pre-trained Models](https://github.com/open-mmlab/mmdetection/tree/main/configs/mask_rcnn#pre-trained-models)\n", + "\n", + "Finally, we need to provide a directory to save the model outcomes: trained model (checkpoint), logs, and results (inference)." + ], + "metadata": { + "id": "xm9PPruHAYAa" + } + }, + { + "cell_type": "code", + "source": [ + "base_config = './configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py' # define the config with the model\n", + "checkpoint = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth' # define the model\n", + "work_dir = './UAV_results' # this directory must be created before\n", + "\n", + "cfg = create_config(base_config=base_config,\n", + " checkpoint=checkpoint,\n", + " work_dir=work_dir)" + ], + "metadata": { + "id": "KrTjt7cFOfX4" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "##**Train**" + ], + "metadata": { + "id": "lql1_4o7BgNB" + } + }, + { + "cell_type": "markdown", + "source": [ + "Now, we can train the model using the configuration file created before.\n", + "\n", + "_This step can take several minutes, depending on the size of your dataset. Thus, again, it is a good oportunity to go for a cup of coffee or tea!._" + ], + "metadata": { + "id": "aEx094zQBhov" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "3ZGdq-UJXW1N", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c79e10c4-2922-48de-9361-bc3d441fe35b" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "01/15 14:02:57 - mmengine - INFO - \n", + "------------------------------------------------------------\n", + "System environment:\n", + " sys.platform: linux\n", + " Python: 3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0]\n", + " CUDA available: True\n", + " numpy_random_seed: 209652396\n", + " GPU 0: Tesla T4\n", + " CUDA_HOME: /usr/local/cuda\n", + " NVCC: Cuda compilation tools, release 12.2, V12.2.140\n", + " GCC: x86_64-linux-gnu-gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0\n", + " PyTorch: 2.1.0+cu121\n", + " PyTorch compiling details: PyTorch built with:\n", + " - GCC 9.3\n", + " - C++ Version: 201703\n", + " - Intel(R) oneAPI Math Kernel Library Version 2022.2-Product Build 20220804 for Intel(R) 64 architecture applications\n", + " - Intel(R) MKL-DNN v3.1.1 (Git Hash 64f6bcbcbab628e96f33a62c3e975f8535a7bde4)\n", + " - OpenMP 201511 (a.k.a. OpenMP 4.5)\n", + " - LAPACK is enabled (usually provided by MKL)\n", + " - NNPACK is enabled\n", + " - CPU capability usage: AVX2\n", + " - CUDA Runtime 12.1\n", + " - NVCC architecture flags: -gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90\n", + " - CuDNN 8.9.2\n", + " - Magma 2.6.1\n", + " - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=12.1, CUDNN_VERSION=8.9.2, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=old-style-cast -Wno-invalid-partial-specialization -Wno-unused-private-field -Wno-aligned-allocation-unavailable -Wno-missing-braces -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.1.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n", + "\n", + " TorchVision: 0.16.0+cu121\n", + " OpenCV: 4.8.0\n", + " MMEngine: 0.10.2\n", + "\n", + "Runtime environment:\n", + " cudnn_benchmark: False\n", + " mp_cfg: {'mp_start_method': 'fork', 'opencv_num_threads': 0}\n", + " dist_cfg: {'backend': 'nccl'}\n", + " seed: 209652396\n", + " Distributed launcher: none\n", + " Distributed training: False\n", + " GPU number: 1\n", + "------------------------------------------------------------\n", + "\n", + "01/15 14:02:57 - mmengine - INFO - Config:\n", + "auto_scale_lr = dict(base_batch_size=16, enable=False)\n", + "backend_args = None\n", + "data_root = './data/UAV_images/'\n", + "dataset_type = 'CocoDataset'\n", + "default_hooks = dict(\n", + " checkpoint=dict(interval=3, type='CheckpointHook'),\n", + " logger=dict(interval=10, type='LoggerHook'),\n", + " param_scheduler=dict(type='ParamSchedulerHook'),\n", + " sampler_seed=dict(type='DistSamplerSeedHook'),\n", + " timer=dict(type='IterTimerHook'),\n", + " visualization=dict(type='DetVisualizationHook'))\n", + "default_scope = 'mmdet'\n", + "env_cfg = dict(\n", + " cudnn_benchmark=False,\n", + " dist_cfg=dict(backend='nccl'),\n", + " mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))\n", + "load_from = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'\n", + "log_level = 'INFO'\n", + "log_processor = dict(by_epoch=True, type='LogProcessor', window_size=50)\n", + "metainfo = dict(\n", + " classes=(\n", + " 'Person',\n", + " 'Car',\n", + " ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " (\n", + " 20,\n", + " 220,\n", + " 60,\n", + " ),\n", + " ])\n", + "model = dict(\n", + " backbone=dict(\n", + " depth=50,\n", + " frozen_stages=1,\n", + " init_cfg=dict(\n", + " checkpoint='open-mmlab://detectron2/resnet50_caffe',\n", + " type='Pretrained'),\n", + " norm_cfg=dict(requires_grad=False, type='BN'),\n", + " norm_eval=True,\n", + " num_stages=4,\n", + " out_indices=(\n", + " 0,\n", + " 1,\n", + " 2,\n", + " 3,\n", + " ),\n", + " style='caffe',\n", + " type='ResNet'),\n", + " data_preprocessor=dict(\n", + " bgr_to_rgb=False,\n", + " mean=[\n", + " 103.53,\n", + " 116.28,\n", + " 123.675,\n", + " ],\n", + " pad_mask=True,\n", + " pad_size_divisor=32,\n", + " std=[\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " ],\n", + " type='DetDataPreprocessor'),\n", + " neck=dict(\n", + " in_channels=[\n", + " 256,\n", + " 512,\n", + " 1024,\n", + " 2048,\n", + " ],\n", + " num_outs=5,\n", + " out_channels=256,\n", + " type='FPN'),\n", + " roi_head=dict(\n", + " bbox_head=dict(\n", + " bbox_coder=dict(\n", + " target_means=[\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " ],\n", + " target_stds=[\n", + " 0.1,\n", + " 0.1,\n", + " 0.2,\n", + " 0.2,\n", + " ],\n", + " type='DeltaXYWHBBoxCoder'),\n", + " fc_out_channels=1024,\n", + " in_channels=256,\n", + " loss_bbox=dict(loss_weight=1.0, type='L1Loss'),\n", + " loss_cls=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=False),\n", + " num_classes=2,\n", + " reg_class_agnostic=False,\n", + " roi_feat_size=7,\n", + " type='Shared2FCBBoxHead'),\n", + " bbox_roi_extractor=dict(\n", + " featmap_strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " ],\n", + " out_channels=256,\n", + " roi_layer=dict(output_size=7, sampling_ratio=0, type='RoIAlign'),\n", + " type='SingleRoIExtractor'),\n", + " mask_head=dict(\n", + " conv_out_channels=256,\n", + " in_channels=256,\n", + " loss_mask=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_mask=True),\n", + " num_classes=2,\n", + " num_convs=4,\n", + " type='FCNMaskHead'),\n", + " mask_roi_extractor=dict(\n", + " featmap_strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " ],\n", + " out_channels=256,\n", + " roi_layer=dict(output_size=14, sampling_ratio=0, type='RoIAlign'),\n", + " type='SingleRoIExtractor'),\n", + " type='StandardRoIHead'),\n", + " rpn_head=dict(\n", + " anchor_generator=dict(\n", + " ratios=[\n", + " 0.5,\n", + " 1.0,\n", + " 2.0,\n", + " ],\n", + " scales=[\n", + " 8,\n", + " ],\n", + " strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " 64,\n", + " ],\n", + " type='AnchorGenerator'),\n", + " bbox_coder=dict(\n", + " target_means=[\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " ],\n", + " target_stds=[\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " ],\n", + " type='DeltaXYWHBBoxCoder'),\n", + " feat_channels=256,\n", + " in_channels=256,\n", + " loss_bbox=dict(loss_weight=1.0, type='L1Loss'),\n", + " loss_cls=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=True),\n", + " type='RPNHead'),\n", + " test_cfg=dict(\n", + " rcnn=dict(\n", + " mask_thr_binary=0.5,\n", + " max_per_img=100,\n", + " nms=dict(iou_threshold=0.5, type='nms'),\n", + " score_thr=0.05),\n", + " rpn=dict(\n", + " max_per_img=1000,\n", + " min_bbox_size=0,\n", + " nms=dict(iou_threshold=0.7, type='nms'),\n", + " nms_pre=1000)),\n", + " train_cfg=dict(\n", + " rcnn=dict(\n", + " assigner=dict(\n", + " ignore_iof_thr=-1,\n", + " match_low_quality=True,\n", + " min_pos_iou=0.5,\n", + " neg_iou_thr=0.5,\n", + " pos_iou_thr=0.5,\n", + " type='MaxIoUAssigner'),\n", + " debug=False,\n", + " mask_size=28,\n", + " pos_weight=-1,\n", + " sampler=dict(\n", + " add_gt_as_proposals=True,\n", + " neg_pos_ub=-1,\n", + " num=512,\n", + " pos_fraction=0.25,\n", + " type='RandomSampler')),\n", + " rpn=dict(\n", + " allowed_border=-1,\n", + " assigner=dict(\n", + " ignore_iof_thr=-1,\n", + " match_low_quality=True,\n", + " min_pos_iou=0.3,\n", + " neg_iou_thr=0.3,\n", + " pos_iou_thr=0.7,\n", + " type='MaxIoUAssigner'),\n", + " debug=False,\n", + " pos_weight=-1,\n", + " sampler=dict(\n", + " add_gt_as_proposals=False,\n", + " neg_pos_ub=-1,\n", + " num=256,\n", + " pos_fraction=0.5,\n", + " type='RandomSampler')),\n", + " rpn_proposal=dict(\n", + " max_per_img=1000,\n", + " min_bbox_size=0,\n", + " nms=dict(iou_threshold=0.7, type='nms'),\n", + " nms_pre=2000)),\n", + " type='MaskRCNN')\n", + "optim_wrapper = dict(\n", + " optimizer=dict(lr=0.0025, momentum=0.9, type='SGD', weight_decay=0.0001),\n", + " type='OptimWrapper')\n", + "param_scheduler = [\n", + " dict(\n", + " begin=0, by_epoch=False, end=500, start_factor=0.001, type='LinearLR'),\n", + " dict(\n", + " begin=0,\n", + " by_epoch=True,\n", + " end=12,\n", + " gamma=0.1,\n", + " milestones=[\n", + " 8,\n", + " 11,\n", + " ],\n", + " type='MultiStepLR'),\n", + "]\n", + "resume = False\n", + "test_cfg = dict(type='TestLoop')\n", + "test_dataloader = dict(\n", + " batch_size=1,\n", + " dataset=dict(\n", + " ann_file='train/train_annotations.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='train/'),\n", + " data_root='./data/UAV_images/',\n", + " metainfo=dict(\n", + " classes=(\n", + " 'Person',\n", + " 'Car',\n", + " ),\n", + " palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " (\n", + " 20,\n", + " 220,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + " ],\n", + " test_mode=True,\n", + " type='CocoDataset'),\n", + " drop_last=False,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=False, type='DefaultSampler'))\n", + "test_evaluator = dict(\n", + " ann_file='./data/UAV_images/train/train_annotations.json',\n", + " backend_args=None,\n", + " format_only=False,\n", + " metric=[\n", + " 'bbox',\n", + " 'segm',\n", + " ],\n", + " type='CocoMetric')\n", + "test_pipeline = [\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + "]\n", + "train_cfg = dict(max_epochs=12, type='EpochBasedTrainLoop', val_interval=3)\n", + "train_dataloader = dict(\n", + " batch_sampler=dict(type='AspectRatioBatchSampler'),\n", + " batch_size=2,\n", + " dataset=dict(\n", + " ann_file='train/train_annotations.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='train/'),\n", + " data_root='./data/UAV_images/',\n", + " filter_cfg=dict(filter_empty_gt=True, min_size=32),\n", + " metainfo=dict(\n", + " classes=(\n", + " 'Person',\n", + " 'Car',\n", + " ),\n", + " palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " (\n", + " 20,\n", + " 220,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(\n", + " poly2mask=False,\n", + " type='LoadAnnotations',\n", + " with_bbox=True,\n", + " with_mask=True),\n", + " dict(\n", + " keep_ratio=True,\n", + " scales=[\n", + " (\n", + " 1333,\n", + " 640,\n", + " ),\n", + " (\n", + " 1333,\n", + " 672,\n", + " ),\n", + " (\n", + " 1333,\n", + " 704,\n", + " ),\n", + " (\n", + " 1333,\n", + " 736,\n", + " ),\n", + " (\n", + " 1333,\n", + " 768,\n", + " ),\n", + " (\n", + " 1333,\n", + " 800,\n", + " ),\n", + " ],\n", + " type='RandomChoiceResize'),\n", + " dict(prob=0.5, type='RandomFlip'),\n", + " dict(type='PackDetInputs'),\n", + " ],\n", + " type='CocoDataset'),\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=True, type='DefaultSampler'))\n", + "train_pipeline = [\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(\n", + " poly2mask=False,\n", + " type='LoadAnnotations',\n", + " with_bbox=True,\n", + " with_mask=True),\n", + " dict(\n", + " keep_ratio=True,\n", + " scales=[\n", + " (\n", + " 1333,\n", + " 640,\n", + " ),\n", + " (\n", + " 1333,\n", + " 672,\n", + " ),\n", + " (\n", + " 1333,\n", + " 704,\n", + " ),\n", + " (\n", + " 1333,\n", + " 736,\n", + " ),\n", + " (\n", + " 1333,\n", + " 768,\n", + " ),\n", + " (\n", + " 1333,\n", + " 800,\n", + " ),\n", + " ],\n", + " type='RandomChoiceResize'),\n", + " dict(prob=0.5, type='RandomFlip'),\n", + " dict(type='PackDetInputs'),\n", + "]\n", + "val_cfg = dict(type='ValLoop')\n", + "val_dataloader = dict(\n", + " batch_size=1,\n", + " dataset=dict(\n", + " ann_file='train/train_annotations.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='train/'),\n", + " data_root='./data/UAV_images/',\n", + " metainfo=dict(\n", + " classes=(\n", + " 'Person',\n", + " 'Car',\n", + " ),\n", + " palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " (\n", + " 20,\n", + " 220,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + " ],\n", + " test_mode=True,\n", + " type='CocoDataset'),\n", + " drop_last=False,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=False, type='DefaultSampler'))\n", + "val_evaluator = dict(\n", + " ann_file='./data/UAV_images/train/train_annotations.json',\n", + " backend_args=None,\n", + " format_only=False,\n", + " metric=[\n", + " 'bbox',\n", + " 'segm',\n", + " ],\n", + " type='CocoMetric')\n", + "vis_backends = [\n", + " dict(type='LocalVisBackend'),\n", + "]\n", + "visualizer = dict(\n", + " name='visualizer',\n", + " type='DetLocalVisualizer',\n", + " vis_backends=[\n", + " dict(type='LocalVisBackend'),\n", + " dict(type='TensorboardVisBackend'),\n", + " ])\n", + "work_dir = './UAV_results'\n", + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/mmengine/utils/manager.py:113: UserWarning: instance named of visualizer has been created, the method `get_instance` should not accept any other arguments\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "01/15 14:02:58 - mmengine - INFO - Distributed training is not used, all SyncBatchNorm (SyncBN) layers in the model will be automatically reverted to BatchNormXd layers if they are used.\n", + "01/15 14:02:58 - mmengine - INFO - Hooks will be executed in the following order:\n", + "before_run:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "before_train:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_train_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DistSamplerSeedHook \n", + " -------------------- \n", + "before_train_iter:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_train_iter:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "after_train_epoch:\n", + "(NORMAL ) IterTimerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_val:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "before_val_epoch:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "before_val_iter:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_val_iter:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DetVisualizationHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_val_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "after_val:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "after_train:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_test:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "before_test_epoch:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "before_test_iter:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_test_iter:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DetVisualizationHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_test_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_test:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "after_run:\n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "loading annotations into memory...\n", + "Done (t=0.50s)\n", + "creating index...\n", + "index created!\n", + "loading annotations into memory...\n", + "Done (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "loading annotations into memory...\n", + "Done (t=0.01s)\n", + "creating index...\n", + "index created!\n", + "01/15 14:03:00 - mmengine - INFO - load model from: open-mmlab://detectron2/resnet50_caffe\n", + "01/15 14:03:00 - mmengine - INFO - Loads checkpoint by openmmlab backend from path: open-mmlab://detectron2/resnet50_caffe\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Downloading: \"https://download.openmmlab.com/pretrain/third_party/resnet50_msra-5891d200.pth\" to /root/.cache/torch/hub/checkpoints/resnet50_msra-5891d200.pth\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "01/15 14:03:12 - mmengine - WARNING - The model and loaded state dict do not match exactly\n", + "\n", + "unexpected key in source state_dict: conv1.bias\n", + "\n", + "Loads checkpoint by local backend from path: checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth\n", + "The model and loaded state dict do not match exactly\n", + "\n", + "size mismatch for roi_head.bbox_head.fc_cls.weight: copying a param with shape torch.Size([81, 1024]) from checkpoint, the shape in current model is torch.Size([3, 1024]).\n", + "size mismatch for roi_head.bbox_head.fc_cls.bias: copying a param with shape torch.Size([81]) from checkpoint, the shape in current model is torch.Size([3]).\n", + "size mismatch for roi_head.bbox_head.fc_reg.weight: copying a param with shape torch.Size([320, 1024]) from checkpoint, the shape in current model is torch.Size([8, 1024]).\n", + "size mismatch for roi_head.bbox_head.fc_reg.bias: copying a param with shape torch.Size([320]) from checkpoint, the shape in current model is torch.Size([8]).\n", + "size mismatch for roi_head.mask_head.conv_logits.weight: copying a param with shape torch.Size([80, 256, 1, 1]) from checkpoint, the shape in current model is torch.Size([2, 256, 1, 1]).\n", + "size mismatch for roi_head.mask_head.conv_logits.bias: copying a param with shape torch.Size([80]) from checkpoint, the shape in current model is torch.Size([2]).\n", + "01/15 14:03:12 - mmengine - INFO - Load checkpoint from checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth\n", + "01/15 14:03:12 - mmengine - WARNING - \"FileClient\" will be deprecated in future. Please use io functions in https://mmengine.readthedocs.io/en/latest/api/fileio.html#file-io\n", + "01/15 14:03:12 - mmengine - WARNING - \"HardDiskBackend\" is the alias of \"LocalBackend\" and the former will be deprecated in future.\n", + "01/15 14:03:12 - mmengine - INFO - Checkpoints will be saved to /content/drive/MyDrive/InstanceSegmentation/mmdetection/UAV_results.\n", + "01/15 14:03:17 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:03:17 - mmengine - INFO - Epoch(train) [1][3/3] lr: 1.2510e-05 eta: 0:00:54 time: 1.6532 data_time: 0.7633 memory: 2817 loss: 7.9864 loss_rpn_cls: 0.1516 loss_rpn_bbox: 0.0331 loss_cls: 1.0453 acc: 34.7656 loss_bbox: 0.4491 loss_mask: 6.3073\n", + "01/15 14:03:21 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:03:21 - mmengine - INFO - Epoch(train) [2][3/3] lr: 2.7525e-05 eta: 0:00:46 time: 1.5570 data_time: 0.8047 memory: 2868 loss: 8.0456 loss_rpn_cls: 0.2046 loss_rpn_bbox: 0.0377 loss_cls: 1.0434 acc: 39.1602 loss_bbox: 0.4364 loss_mask: 6.3235\n", + "01/15 14:03:24 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:03:25 - mmengine - INFO - Epoch(train) [3][3/3] lr: 4.2540e-05 eta: 0:00:37 time: 1.3717 data_time: 0.7001 memory: 3158 loss: 7.8030 loss_rpn_cls: 0.1496 loss_rpn_bbox: 0.0362 loss_cls: 1.0330 acc: 65.0391 loss_bbox: 0.4578 loss_mask: 6.1264\n", + "01/15 14:03:25 - mmengine - INFO - Saving checkpoint at 3 epochs\n", + "01/15 14:05:52 - mmengine - INFO - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.03s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.002\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.001\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.060\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.060\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.060\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.008\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.113\n", + "01/15 14:05:52 - mmengine - INFO - bbox_mAP_copypaste: 0.002 0.011 0.000 -1.000 0.011 0.001\n", + "01/15 14:05:52 - mmengine - INFO - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.02s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.05s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.019\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.019\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.019\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.037\n", + "01/15 14:05:52 - mmengine - INFO - segm_mAP_copypaste: 0.000 0.001 0.000 -1.000 0.000 0.000\n", + "01/15 14:05:52 - mmengine - INFO - Epoch(val) [3][6/6] coco/bbox_mAP: 0.0020 coco/bbox_mAP_50: 0.0110 coco/bbox_mAP_75: 0.0000 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: 0.0110 coco/bbox_mAP_l: 0.0010 coco/segm_mAP: 0.0000 coco/segm_mAP_50: 0.0010 coco/segm_mAP_75: 0.0000 coco/segm_mAP_s: -1.0000 coco/segm_mAP_m: 0.0000 coco/segm_mAP_l: 0.0000 data_time: 2.4771 time: 24.1591\n", + "01/15 14:05:56 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:05:56 - mmengine - INFO - Epoch(train) [4][3/3] lr: 5.7555e-05 eta: 0:00:32 time: 1.3474 data_time: 0.6878 memory: 6000 loss: 7.2596 loss_rpn_cls: 0.1206 loss_rpn_bbox: 0.0374 loss_cls: 1.0164 acc: 81.7383 loss_bbox: 0.4794 loss_mask: 5.6058\n", + "01/15 14:06:00 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:06:00 - mmengine - INFO - Epoch(train) [5][3/3] lr: 7.2570e-05 eta: 0:00:28 time: 1.3560 data_time: 0.7172 memory: 3158 loss: 6.6246 loss_rpn_cls: 0.1016 loss_rpn_bbox: 0.0347 loss_cls: 0.9905 acc: 84.4727 loss_bbox: 0.4722 loss_mask: 5.0256\n", + "01/15 14:06:03 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:06:03 - mmengine - INFO - Epoch(train) [6][3/3] lr: 8.7585e-05 eta: 0:00:23 time: 1.3000 data_time: 0.6838 memory: 2986 loss: 6.0357 loss_rpn_cls: 0.0867 loss_rpn_bbox: 0.0348 loss_cls: 0.9611 acc: 88.7695 loss_bbox: 0.4719 loss_mask: 4.4813\n", + "01/15 14:06:03 - mmengine - INFO - Saving checkpoint at 6 epochs\n", + "01/15 14:08:31 - mmengine - INFO - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.09s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.02s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.028\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.106\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.011\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.133\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.013\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.326\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.326\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.326\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.265\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.388\n", + "01/15 14:08:32 - mmengine - INFO - bbox_mAP_copypaste: 0.028 0.106 0.011 -1.000 0.133 0.013\n", + "01/15 14:08:32 - mmengine - INFO - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.01s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.10s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.005\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.021\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.002\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.011\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.150\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.150\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.150\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.300\n", + "01/15 14:08:32 - mmengine - INFO - segm_mAP_copypaste: 0.005 0.021 0.002 -1.000 0.000 0.011\n", + "01/15 14:08:32 - mmengine - INFO - Epoch(val) [6][6/6] coco/bbox_mAP: 0.0280 coco/bbox_mAP_50: 0.1060 coco/bbox_mAP_75: 0.0110 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: 0.1330 coco/bbox_mAP_l: 0.0130 coco/segm_mAP: 0.0050 coco/segm_mAP_50: 0.0210 coco/segm_mAP_75: 0.0020 coco/segm_mAP_s: -1.0000 coco/segm_mAP_m: 0.0000 coco/segm_mAP_l: 0.0110 data_time: 2.1153 time: 23.8909\n", + "01/15 14:08:35 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:08:35 - mmengine - INFO - Epoch(train) [7][3/3] lr: 1.0260e-04 eta: 0:00:19 time: 1.2891 data_time: 0.6732 memory: 6000 loss: 5.5270 loss_rpn_cls: 0.0786 loss_rpn_bbox: 0.0371 loss_cls: 0.9278 acc: 88.8672 loss_bbox: 0.4691 loss_mask: 4.0144\n", + "01/15 14:08:40 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:08:40 - mmengine - INFO - Epoch(train) [8][3/3] lr: 1.1762e-04 eta: 0:00:15 time: 1.3167 data_time: 0.7054 memory: 3032 loss: 5.0877 loss_rpn_cls: 0.0725 loss_rpn_bbox: 0.0376 loss_cls: 0.8920 acc: 88.1836 loss_bbox: 0.4692 loss_mask: 3.6164\n", + "01/15 14:08:43 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:08:43 - mmengine - INFO - Epoch(train) [9][3/3] lr: 1.3263e-05 eta: 0:00:11 time: 1.2876 data_time: 0.6825 memory: 3169 loss: 4.7365 loss_rpn_cls: 0.0673 loss_rpn_bbox: 0.0386 loss_cls: 0.8598 acc: 87.3047 loss_bbox: 0.4731 loss_mask: 3.2977\n", + "01/15 14:08:43 - mmengine - INFO - Saving checkpoint at 9 epochs\n", + "01/15 14:11:12 - mmengine - INFO - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.09s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.099\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.283\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.044\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.204\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.077\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.390\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.390\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.390\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.379\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.400\n", + "01/15 14:11:12 - mmengine - INFO - bbox_mAP_copypaste: 0.099 0.283 0.044 -1.000 0.204 0.077\n", + "01/15 14:11:12 - mmengine - INFO - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.01s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.10s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.007\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.027\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.006\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.001\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.023\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.129\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.129\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.129\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.021\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.237\n", + "01/15 14:11:12 - mmengine - INFO - segm_mAP_copypaste: 0.007 0.027 0.006 -1.000 0.001 0.023\n", + "01/15 14:11:12 - mmengine - INFO - Epoch(val) [9][6/6] coco/bbox_mAP: 0.0990 coco/bbox_mAP_50: 0.2830 coco/bbox_mAP_75: 0.0440 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: 0.2040 coco/bbox_mAP_l: 0.0770 coco/segm_mAP: 0.0070 coco/segm_mAP_50: 0.0270 coco/segm_mAP_75: 0.0060 coco/segm_mAP_s: -1.0000 coco/segm_mAP_m: 0.0010 coco/segm_mAP_l: 0.0230 data_time: 2.1372 time: 23.9858\n", + "01/15 14:11:17 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:11:17 - mmengine - INFO - Epoch(train) [10][3/3] lr: 1.4765e-05 eta: 0:00:07 time: 1.3267 data_time: 0.7169 memory: 6000 loss: 4.4539 loss_rpn_cls: 0.0621 loss_rpn_bbox: 0.0381 loss_cls: 0.8313 acc: 79.1016 loss_bbox: 0.4700 loss_mask: 3.0525\n", + "01/15 14:11:21 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:11:21 - mmengine - INFO - Epoch(train) [11][3/3] lr: 1.6266e-05 eta: 0:00:03 time: 1.3269 data_time: 0.7220 memory: 3158 loss: 4.2089 loss_rpn_cls: 0.0582 loss_rpn_bbox: 0.0373 loss_cls: 0.8060 acc: 89.9414 loss_bbox: 0.4665 loss_mask: 2.8409\n", + "01/15 14:11:25 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240115_140257\n", + "01/15 14:11:25 - mmengine - INFO - Epoch(train) [12][3/3] lr: 1.7768e-06 eta: 0:00:00 time: 1.3034 data_time: 0.7032 memory: 3202 loss: 4.0103 loss_rpn_cls: 0.0561 loss_rpn_bbox: 0.0381 loss_cls: 0.7874 acc: 87.9883 loss_bbox: 0.4705 loss_mask: 2.6581\n", + "01/15 14:11:25 - mmengine - INFO - Saving checkpoint at 12 epochs\n", + "01/15 14:13:50 - mmengine - INFO - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.07s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.112\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.314\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.054\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.217\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.098\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.479\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.479\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.479\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.383\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.575\n", + "01/15 14:13:50 - mmengine - INFO - bbox_mAP_copypaste: 0.112 0.314 0.054 -1.000 0.217 0.098\n", + "01/15 14:13:50 - mmengine - INFO - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.01s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.10s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.015\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.067\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.010\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.008\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.039\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.227\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.227\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.227\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = 0.054\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.400\n", + "01/15 14:13:50 - mmengine - INFO - segm_mAP_copypaste: 0.015 0.067 0.010 -1.000 0.008 0.039\n", + "01/15 14:13:50 - mmengine - INFO - Epoch(val) [12][6/6] coco/bbox_mAP: 0.1120 coco/bbox_mAP_50: 0.3140 coco/bbox_mAP_75: 0.0540 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: 0.2170 coco/bbox_mAP_l: 0.0980 coco/segm_mAP: 0.0150 coco/segm_mAP_50: 0.0670 coco/segm_mAP_75: 0.0100 coco/segm_mAP_s: -1.0000 coco/segm_mAP_m: 0.0080 coco/segm_mAP_l: 0.0390 data_time: 1.8012 time: 23.5545\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MaskRCNN(\n", + " (data_preprocessor): DetDataPreprocessor()\n", + " (backbone): ResNet(\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): ResLayer(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): ResLayer(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): ResLayer(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): ResLayer(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " init_cfg={'type': 'Pretrained', 'checkpoint': 'open-mmlab://detectron2/resnet50_caffe'}\n", + " (neck): FPN(\n", + " (lateral_convs): ModuleList(\n", + " (0): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (1): ConvModule(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (2): ConvModule(\n", + " (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (3): ConvModule(\n", + " (conv): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " (fpn_convs): ModuleList(\n", + " (0-3): 4 x ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " )\n", + " )\n", + " )\n", + " init_cfg={'type': 'Xavier', 'layer': 'Conv2d', 'distribution': 'uniform'}\n", + " (rpn_head): RPNHead(\n", + " (loss_cls): CrossEntropyLoss(avg_non_ignore=False)\n", + " (loss_bbox): L1Loss()\n", + " (rpn_conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (rpn_cls): Conv2d(256, 3, kernel_size=(1, 1), stride=(1, 1))\n", + " (rpn_reg): Conv2d(256, 12, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " init_cfg={'type': 'Normal', 'layer': 'Conv2d', 'std': 0.01}\n", + " (roi_head): StandardRoIHead(\n", + " (bbox_roi_extractor): SingleRoIExtractor(\n", + " (roi_layers): ModuleList(\n", + " (0): RoIAlign(output_size=(7, 7), spatial_scale=0.25, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (1): RoIAlign(output_size=(7, 7), spatial_scale=0.125, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (2): RoIAlign(output_size=(7, 7), spatial_scale=0.0625, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (3): RoIAlign(output_size=(7, 7), spatial_scale=0.03125, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " )\n", + " )\n", + " (bbox_head): Shared2FCBBoxHead(\n", + " (loss_cls): CrossEntropyLoss(avg_non_ignore=False)\n", + " (loss_bbox): L1Loss()\n", + " (fc_cls): Linear(in_features=1024, out_features=3, bias=True)\n", + " (fc_reg): Linear(in_features=1024, out_features=8, bias=True)\n", + " (shared_convs): ModuleList()\n", + " (shared_fcs): ModuleList(\n", + " (0): Linear(in_features=12544, out_features=1024, bias=True)\n", + " (1): Linear(in_features=1024, out_features=1024, bias=True)\n", + " )\n", + " (cls_convs): ModuleList()\n", + " (cls_fcs): ModuleList()\n", + " (reg_convs): ModuleList()\n", + " (reg_fcs): ModuleList()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " init_cfg=[{'type': 'Normal', 'std': 0.01, 'override': {'name': 'fc_cls'}}, {'type': 'Normal', 'std': 0.001, 'override': {'name': 'fc_reg'}}, {'type': 'Xavier', 'distribution': 'uniform', 'override': [{'name': 'shared_fcs'}, {'name': 'cls_fcs'}, {'name': 'reg_fcs'}]}]\n", + " (mask_roi_extractor): SingleRoIExtractor(\n", + " (roi_layers): ModuleList(\n", + " (0): RoIAlign(output_size=(14, 14), spatial_scale=0.25, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (1): RoIAlign(output_size=(14, 14), spatial_scale=0.125, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (2): RoIAlign(output_size=(14, 14), spatial_scale=0.0625, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (3): RoIAlign(output_size=(14, 14), spatial_scale=0.03125, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " )\n", + " )\n", + " (mask_head): FCNMaskHead(\n", + " (loss_mask): CrossEntropyLoss(avg_non_ignore=False)\n", + " (convs): ModuleList(\n", + " (0-3): 4 x ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (upsample): ConvTranspose2d(256, 256, kernel_size=(2, 2), stride=(2, 2))\n", + " (conv_logits): Conv2d(256, 2, kernel_size=(1, 1), stride=(1, 1))\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ], + "source": [ + "runner = Runner.from_cfg(cfg)\n", + "runner.train()" + ] + }, + { + "cell_type": "markdown", + "source": [ + "##**Test**" + ], + "metadata": { + "id": "l1AZqES2B1_B" + } + }, + { + "cell_type": "markdown", + "source": [ + "Once the model is trained, we can test it with new images.\n", + "\n", + "In this case, we will use the same images that were used for training.\n", + "\n", + "In a real scenario, we should create three sets from our dataset: train, validation, and test, where we just need annotations for train and validation. Annotations for test can be created to compute accuracy metrics too.\n", + "\n", + "The results are saved in the working directory. In this case: `mmdetection/UAV_results/`" + ], + "metadata": { + "id": "pC03WJyuB4Ok" + } + }, + { + "cell_type": "code", + "source": [ + "TEST_PATH = \"./data/UAV_images/train/\"" + ], + "metadata": { + "id": "WATqUxkcODKC" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "save_results(TEST_PATH=TEST_PATH,\n", + " work_dir=work_dir,\n", + " epoch=12,\n", + " threshold=0.25,\n", + " format=\"*.JPG\")" + ], + "metadata": { + "id": "zz46pO0vajcS", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c513339e-c3e1-42af-c96d-221c80607df6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Loads checkpoint by local backend from path: ./UAV_results/epoch_12.pth\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# **Train with custom datasets - Halls dataset**" + ], + "metadata": { + "id": "w55SiMeS8ypH" + } + }, + { + "cell_type": "code", + "source": [ + "def create_config(base_config,\n", + " checkpoint,\n", + " work_dir):\n", + " cfg = Config.fromfile(base_config)\n", + "\n", + " # Modify dataset classes and color\n", + " cfg.metainfo = {\n", + " 'classes': ('system_hall',),\n", + " 'palette': [\n", + " (220, 20, 60),\n", + " ]\n", + " }\n", + "\n", + " # Modify dataset type and path\n", + " cfg.data_root = './data/Halls/'\n", + "\n", + " cfg.train_dataloader.dataset.ann_file = 'val/annotation_coco.json'\n", + " cfg.train_dataloader.dataset.data_root = cfg.data_root\n", + " cfg.train_dataloader.dataset.data_prefix.img = 'val/'\n", + " cfg.train_dataloader.dataset.metainfo = cfg.metainfo\n", + "\n", + " cfg.val_dataloader.dataset.ann_file = 'val/annotation_coco.json'\n", + " cfg.val_dataloader.dataset.data_root = cfg.data_root\n", + " cfg.val_dataloader.dataset.data_prefix.img = 'val/'\n", + " cfg.val_dataloader.dataset.metainfo = cfg.metainfo\n", + "\n", + " cfg.test_dataloader.dataset.ann_file = 'val/annotation_coco.json'\n", + " cfg.test_dataloader.dataset.data_root = cfg.data_root\n", + " cfg.test_dataloader.dataset.data_prefix.img = 'val/'\n", + " cfg.test_dataloader.dataset.metainfo = cfg.metainfo\n", + "\n", + " # Modify metric config\n", + " cfg.val_evaluator.ann_file = cfg.data_root+'val/annotation_coco.json'\n", + " cfg.test_evaluator.ann_file = cfg.data_root+'val/annotation_coco.json'\n", + "\n", + " # Modify num classes of the model in box head and mask head\n", + " cfg.model.roi_head.bbox_head.num_classes = 1\n", + " cfg.model.roi_head.mask_head.num_classes = 1\n", + "\n", + " # We can still the pre-trained Mask RCNN model to obtain a higher performance\n", + " cfg.load_from = checkpoint\n", + "\n", + " # Set up working dir to save files and logs.\n", + " cfg.work_dir = work_dir\n", + "\n", + " # We can set the evaluation interval to reduce the evaluation times\n", + " cfg.train_cfg.val_interval = 3\n", + " # We can set the checkpoint saving interval to reduce the storage cost\n", + " cfg.default_hooks.checkpoint.interval = 3\n", + "\n", + " # The original learning rate (LR) is set for 8-GPU training.\n", + " # We divide it by 8 since we only use one GPU.\n", + " cfg.optim_wrapper.optimizer.lr = 0.02 / 8\n", + " cfg.default_hooks.logger.interval = 10\n", + "\n", + " # Set seed thus the results are more reproducible\n", + " # cfg.seed = 0\n", + " set_random_seed(0, deterministic=False)\n", + "\n", + " # We can also use tensorboard to log the training process\n", + " cfg.visualizer.vis_backends.append({\"type\":'TensorboardVisBackend'})\n", + "\n", + " return cfg" + ], + "metadata": { + "id": "zsuF6qlq8312" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "TEST_PATH = \"./data/Halls/val/\"" + ], + "metadata": { + "id": "WqC321-c9Vuh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "base_config = './configs/mask_rcnn/mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco.py'\n", + "checkpoint = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'\n", + "work_dir = './Halls_results' # this directory must be created before\n", + "\n", + "cfg = create_config(base_config=base_config,\n", + " checkpoint=checkpoint,\n", + " work_dir=work_dir)" + ], + "metadata": { + "id": "DHAdtsoJ9ZTh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "runner = Runner.from_cfg(cfg)\n", + "runner.train()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f-h2TPyx9nMg", + "outputId": "027438bd-2e40-46bb-f6f7-833e7ad0c78e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "01/10 10:42:32 - mmengine - INFO - \n", + "------------------------------------------------------------\n", + "System environment:\n", + " sys.platform: linux\n", + " Python: 3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0]\n", + " CUDA available: True\n", + " numpy_random_seed: 209652396\n", + " GPU 0: Tesla T4\n", + " CUDA_HOME: /usr/local/cuda\n", + " NVCC: Cuda compilation tools, release 12.2, V12.2.140\n", + " GCC: x86_64-linux-gnu-gcc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0\n", + " PyTorch: 2.1.0+cu121\n", + " PyTorch compiling details: PyTorch built with:\n", + " - GCC 9.3\n", + " - C++ Version: 201703\n", + " - Intel(R) oneAPI Math Kernel Library Version 2022.2-Product Build 20220804 for Intel(R) 64 architecture applications\n", + " - Intel(R) MKL-DNN v3.1.1 (Git Hash 64f6bcbcbab628e96f33a62c3e975f8535a7bde4)\n", + " - OpenMP 201511 (a.k.a. OpenMP 4.5)\n", + " - LAPACK is enabled (usually provided by MKL)\n", + " - NNPACK is enabled\n", + " - CPU capability usage: AVX2\n", + " - CUDA Runtime 12.1\n", + " - NVCC architecture flags: -gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_90,code=sm_90\n", + " - CuDNN 8.9.2\n", + " - Magma 2.6.1\n", + " - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=12.1, CUDNN_VERSION=8.9.2, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -D_GLIBCXX_USE_CXX11_ABI=0 -fabi-version=11 -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -DNDEBUG -DUSE_KINETO -DLIBKINETO_NOROCTRACER -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -O2 -fPIC -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Werror=bool-operation -Wnarrowing -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=old-style-cast -Wno-invalid-partial-specialization -Wno-unused-private-field -Wno-aligned-allocation-unavailable -Wno-missing-braces -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_DISABLE_GPU_ASSERTS=ON, TORCH_VERSION=2.1.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=1, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n", + "\n", + " TorchVision: 0.16.0+cu121\n", + " OpenCV: 4.8.0\n", + " MMEngine: 0.10.2\n", + "\n", + "Runtime environment:\n", + " cudnn_benchmark: False\n", + " mp_cfg: {'mp_start_method': 'fork', 'opencv_num_threads': 0}\n", + " dist_cfg: {'backend': 'nccl'}\n", + " seed: 209652396\n", + " Distributed launcher: none\n", + " Distributed training: False\n", + " GPU number: 1\n", + "------------------------------------------------------------\n", + "\n", + "01/10 10:42:53 - mmengine - INFO - Config:\n", + "auto_scale_lr = dict(base_batch_size=16, enable=False)\n", + "backend_args = None\n", + "data_root = './data/Halls/'\n", + "dataset_type = 'CocoDataset'\n", + "default_hooks = dict(\n", + " checkpoint=dict(interval=3, type='CheckpointHook'),\n", + " logger=dict(interval=10, type='LoggerHook'),\n", + " param_scheduler=dict(type='ParamSchedulerHook'),\n", + " sampler_seed=dict(type='DistSamplerSeedHook'),\n", + " timer=dict(type='IterTimerHook'),\n", + " visualization=dict(type='DetVisualizationHook'))\n", + "default_scope = 'mmdet'\n", + "env_cfg = dict(\n", + " cudnn_benchmark=False,\n", + " dist_cfg=dict(backend='nccl'),\n", + " mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0))\n", + "load_from = 'checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth'\n", + "log_level = 'INFO'\n", + "log_processor = dict(by_epoch=True, type='LogProcessor', window_size=50)\n", + "metainfo = dict(\n", + " classes=('system_hall', ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " ])\n", + "model = dict(\n", + " backbone=dict(\n", + " depth=50,\n", + " frozen_stages=1,\n", + " init_cfg=dict(\n", + " checkpoint='open-mmlab://detectron2/resnet50_caffe',\n", + " type='Pretrained'),\n", + " norm_cfg=dict(requires_grad=False, type='BN'),\n", + " norm_eval=True,\n", + " num_stages=4,\n", + " out_indices=(\n", + " 0,\n", + " 1,\n", + " 2,\n", + " 3,\n", + " ),\n", + " style='caffe',\n", + " type='ResNet'),\n", + " data_preprocessor=dict(\n", + " bgr_to_rgb=False,\n", + " mean=[\n", + " 103.53,\n", + " 116.28,\n", + " 123.675,\n", + " ],\n", + " pad_mask=True,\n", + " pad_size_divisor=32,\n", + " std=[\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " ],\n", + " type='DetDataPreprocessor'),\n", + " neck=dict(\n", + " in_channels=[\n", + " 256,\n", + " 512,\n", + " 1024,\n", + " 2048,\n", + " ],\n", + " num_outs=5,\n", + " out_channels=256,\n", + " type='FPN'),\n", + " roi_head=dict(\n", + " bbox_head=dict(\n", + " bbox_coder=dict(\n", + " target_means=[\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " ],\n", + " target_stds=[\n", + " 0.1,\n", + " 0.1,\n", + " 0.2,\n", + " 0.2,\n", + " ],\n", + " type='DeltaXYWHBBoxCoder'),\n", + " fc_out_channels=1024,\n", + " in_channels=256,\n", + " loss_bbox=dict(loss_weight=1.0, type='L1Loss'),\n", + " loss_cls=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=False),\n", + " num_classes=1,\n", + " reg_class_agnostic=False,\n", + " roi_feat_size=7,\n", + " type='Shared2FCBBoxHead'),\n", + " bbox_roi_extractor=dict(\n", + " featmap_strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " ],\n", + " out_channels=256,\n", + " roi_layer=dict(output_size=7, sampling_ratio=0, type='RoIAlign'),\n", + " type='SingleRoIExtractor'),\n", + " mask_head=dict(\n", + " conv_out_channels=256,\n", + " in_channels=256,\n", + " loss_mask=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_mask=True),\n", + " num_classes=1,\n", + " num_convs=4,\n", + " type='FCNMaskHead'),\n", + " mask_roi_extractor=dict(\n", + " featmap_strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " ],\n", + " out_channels=256,\n", + " roi_layer=dict(output_size=14, sampling_ratio=0, type='RoIAlign'),\n", + " type='SingleRoIExtractor'),\n", + " type='StandardRoIHead'),\n", + " rpn_head=dict(\n", + " anchor_generator=dict(\n", + " ratios=[\n", + " 0.5,\n", + " 1.0,\n", + " 2.0,\n", + " ],\n", + " scales=[\n", + " 8,\n", + " ],\n", + " strides=[\n", + " 4,\n", + " 8,\n", + " 16,\n", + " 32,\n", + " 64,\n", + " ],\n", + " type='AnchorGenerator'),\n", + " bbox_coder=dict(\n", + " target_means=[\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " 0.0,\n", + " ],\n", + " target_stds=[\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " 1.0,\n", + " ],\n", + " type='DeltaXYWHBBoxCoder'),\n", + " feat_channels=256,\n", + " in_channels=256,\n", + " loss_bbox=dict(loss_weight=1.0, type='L1Loss'),\n", + " loss_cls=dict(\n", + " loss_weight=1.0, type='CrossEntropyLoss', use_sigmoid=True),\n", + " type='RPNHead'),\n", + " test_cfg=dict(\n", + " rcnn=dict(\n", + " mask_thr_binary=0.5,\n", + " max_per_img=100,\n", + " nms=dict(iou_threshold=0.5, type='nms'),\n", + " score_thr=0.05),\n", + " rpn=dict(\n", + " max_per_img=1000,\n", + " min_bbox_size=0,\n", + " nms=dict(iou_threshold=0.7, type='nms'),\n", + " nms_pre=1000)),\n", + " train_cfg=dict(\n", + " rcnn=dict(\n", + " assigner=dict(\n", + " ignore_iof_thr=-1,\n", + " match_low_quality=True,\n", + " min_pos_iou=0.5,\n", + " neg_iou_thr=0.5,\n", + " pos_iou_thr=0.5,\n", + " type='MaxIoUAssigner'),\n", + " debug=False,\n", + " mask_size=28,\n", + " pos_weight=-1,\n", + " sampler=dict(\n", + " add_gt_as_proposals=True,\n", + " neg_pos_ub=-1,\n", + " num=512,\n", + " pos_fraction=0.25,\n", + " type='RandomSampler')),\n", + " rpn=dict(\n", + " allowed_border=-1,\n", + " assigner=dict(\n", + " ignore_iof_thr=-1,\n", + " match_low_quality=True,\n", + " min_pos_iou=0.3,\n", + " neg_iou_thr=0.3,\n", + " pos_iou_thr=0.7,\n", + " type='MaxIoUAssigner'),\n", + " debug=False,\n", + " pos_weight=-1,\n", + " sampler=dict(\n", + " add_gt_as_proposals=False,\n", + " neg_pos_ub=-1,\n", + " num=256,\n", + " pos_fraction=0.5,\n", + " type='RandomSampler')),\n", + " rpn_proposal=dict(\n", + " max_per_img=1000,\n", + " min_bbox_size=0,\n", + " nms=dict(iou_threshold=0.7, type='nms'),\n", + " nms_pre=2000)),\n", + " type='MaskRCNN')\n", + "optim_wrapper = dict(\n", + " optimizer=dict(lr=0.0025, momentum=0.9, type='SGD', weight_decay=0.0001),\n", + " type='OptimWrapper')\n", + "param_scheduler = [\n", + " dict(\n", + " begin=0, by_epoch=False, end=500, start_factor=0.001, type='LinearLR'),\n", + " dict(\n", + " begin=0,\n", + " by_epoch=True,\n", + " end=12,\n", + " gamma=0.1,\n", + " milestones=[\n", + " 8,\n", + " 11,\n", + " ],\n", + " type='MultiStepLR'),\n", + "]\n", + "resume = False\n", + "test_cfg = dict(type='TestLoop')\n", + "test_dataloader = dict(\n", + " batch_size=1,\n", + " dataset=dict(\n", + " ann_file='val/annotation_coco.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='val/'),\n", + " data_root='./data/Halls/',\n", + " metainfo=dict(classes=('system_hall', ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + " ],\n", + " test_mode=True,\n", + " type='CocoDataset'),\n", + " drop_last=False,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=False, type='DefaultSampler'))\n", + "test_evaluator = dict(\n", + " ann_file='./data/Halls/val/annotation_coco.json',\n", + " backend_args=None,\n", + " format_only=False,\n", + " metric=[\n", + " 'bbox',\n", + " 'segm',\n", + " ],\n", + " type='CocoMetric')\n", + "test_pipeline = [\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + "]\n", + "train_cfg = dict(max_epochs=12, type='EpochBasedTrainLoop', val_interval=3)\n", + "train_dataloader = dict(\n", + " batch_sampler=dict(type='AspectRatioBatchSampler'),\n", + " batch_size=2,\n", + " dataset=dict(\n", + " ann_file='val/annotation_coco.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='val/'),\n", + " data_root='./data/Halls/',\n", + " filter_cfg=dict(filter_empty_gt=True, min_size=32),\n", + " metainfo=dict(classes=('system_hall', ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(\n", + " poly2mask=False,\n", + " type='LoadAnnotations',\n", + " with_bbox=True,\n", + " with_mask=True),\n", + " dict(\n", + " keep_ratio=True,\n", + " scales=[\n", + " (\n", + " 1333,\n", + " 640,\n", + " ),\n", + " (\n", + " 1333,\n", + " 672,\n", + " ),\n", + " (\n", + " 1333,\n", + " 704,\n", + " ),\n", + " (\n", + " 1333,\n", + " 736,\n", + " ),\n", + " (\n", + " 1333,\n", + " 768,\n", + " ),\n", + " (\n", + " 1333,\n", + " 800,\n", + " ),\n", + " ],\n", + " type='RandomChoiceResize'),\n", + " dict(prob=0.5, type='RandomFlip'),\n", + " dict(type='PackDetInputs'),\n", + " ],\n", + " type='CocoDataset'),\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=True, type='DefaultSampler'))\n", + "train_pipeline = [\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(\n", + " poly2mask=False,\n", + " type='LoadAnnotations',\n", + " with_bbox=True,\n", + " with_mask=True),\n", + " dict(\n", + " keep_ratio=True,\n", + " scales=[\n", + " (\n", + " 1333,\n", + " 640,\n", + " ),\n", + " (\n", + " 1333,\n", + " 672,\n", + " ),\n", + " (\n", + " 1333,\n", + " 704,\n", + " ),\n", + " (\n", + " 1333,\n", + " 736,\n", + " ),\n", + " (\n", + " 1333,\n", + " 768,\n", + " ),\n", + " (\n", + " 1333,\n", + " 800,\n", + " ),\n", + " ],\n", + " type='RandomChoiceResize'),\n", + " dict(prob=0.5, type='RandomFlip'),\n", + " dict(type='PackDetInputs'),\n", + "]\n", + "val_cfg = dict(type='ValLoop')\n", + "val_dataloader = dict(\n", + " batch_size=1,\n", + " dataset=dict(\n", + " ann_file='val/annotation_coco.json',\n", + " backend_args=None,\n", + " data_prefix=dict(img='val/'),\n", + " data_root='./data/Halls/',\n", + " metainfo=dict(classes=('system_hall', ), palette=[\n", + " (\n", + " 220,\n", + " 20,\n", + " 60,\n", + " ),\n", + " ]),\n", + " pipeline=[\n", + " dict(backend_args=None, type='LoadImageFromFile'),\n", + " dict(keep_ratio=True, scale=(\n", + " 1333,\n", + " 800,\n", + " ), type='Resize'),\n", + " dict(type='LoadAnnotations', with_bbox=True, with_mask=True),\n", + " dict(\n", + " meta_keys=(\n", + " 'img_id',\n", + " 'img_path',\n", + " 'ori_shape',\n", + " 'img_shape',\n", + " 'scale_factor',\n", + " ),\n", + " type='PackDetInputs'),\n", + " ],\n", + " test_mode=True,\n", + " type='CocoDataset'),\n", + " drop_last=False,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(shuffle=False, type='DefaultSampler'))\n", + "val_evaluator = dict(\n", + " ann_file='./data/Halls/val/annotation_coco.json',\n", + " backend_args=None,\n", + " format_only=False,\n", + " metric=[\n", + " 'bbox',\n", + " 'segm',\n", + " ],\n", + " type='CocoMetric')\n", + "vis_backends = [\n", + " dict(type='LocalVisBackend'),\n", + "]\n", + "visualizer = dict(\n", + " name='visualizer',\n", + " type='DetLocalVisualizer',\n", + " vis_backends=[\n", + " dict(type='LocalVisBackend'),\n", + " dict(type='TensorboardVisBackend'),\n", + " ])\n", + "work_dir = './Halls_results'\n", + "\n", + "01/10 10:42:54 - mmengine - INFO - Distributed training is not used, all SyncBatchNorm (SyncBN) layers in the model will be automatically reverted to BatchNormXd layers if they are used.\n", + "01/10 10:42:54 - mmengine - INFO - Hooks will be executed in the following order:\n", + "before_run:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "before_train:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_train_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DistSamplerSeedHook \n", + " -------------------- \n", + "before_train_iter:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_train_iter:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "after_train_epoch:\n", + "(NORMAL ) IterTimerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_val:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "before_val_epoch:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "before_val_iter:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_val_iter:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DetVisualizationHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_val_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + "(LOW ) ParamSchedulerHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "after_val:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "after_train:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(VERY_LOW ) CheckpointHook \n", + " -------------------- \n", + "before_test:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "before_test_epoch:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "before_test_iter:\n", + "(NORMAL ) IterTimerHook \n", + " -------------------- \n", + "after_test_iter:\n", + "(NORMAL ) IterTimerHook \n", + "(NORMAL ) DetVisualizationHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_test_epoch:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + "(NORMAL ) IterTimerHook \n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "after_test:\n", + "(VERY_HIGH ) RuntimeInfoHook \n", + " -------------------- \n", + "after_run:\n", + "(BELOW_NORMAL) LoggerHook \n", + " -------------------- \n", + "loading annotations into memory...\n", + "Done (t=0.02s)\n", + "creating index...\n", + "index created!\n", + "loading annotations into memory...\n", + "Done (t=0.03s)\n", + "creating index...\n", + "index created!\n", + "loading annotations into memory...\n", + "Done (t=0.04s)\n", + "creating index...\n", + "index created!\n", + "01/10 10:42:56 - mmengine - INFO - load model from: open-mmlab://detectron2/resnet50_caffe\n", + "01/10 10:42:56 - mmengine - INFO - Loads checkpoint by openmmlab backend from path: open-mmlab://detectron2/resnet50_caffe\n", + "01/10 10:42:57 - mmengine - WARNING - The model and loaded state dict do not match exactly\n", + "\n", + "unexpected key in source state_dict: conv1.bias\n", + "\n", + "Loads checkpoint by local backend from path: checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth\n", + "The model and loaded state dict do not match exactly\n", + "\n", + "size mismatch for roi_head.bbox_head.fc_cls.weight: copying a param with shape torch.Size([81, 1024]) from checkpoint, the shape in current model is torch.Size([2, 1024]).\n", + "size mismatch for roi_head.bbox_head.fc_cls.bias: copying a param with shape torch.Size([81]) from checkpoint, the shape in current model is torch.Size([2]).\n", + "size mismatch for roi_head.bbox_head.fc_reg.weight: copying a param with shape torch.Size([320, 1024]) from checkpoint, the shape in current model is torch.Size([4, 1024]).\n", + "size mismatch for roi_head.bbox_head.fc_reg.bias: copying a param with shape torch.Size([320]) from checkpoint, the shape in current model is torch.Size([4]).\n", + "size mismatch for roi_head.mask_head.conv_logits.weight: copying a param with shape torch.Size([80, 256, 1, 1]) from checkpoint, the shape in current model is torch.Size([1, 256, 1, 1]).\n", + "size mismatch for roi_head.mask_head.conv_logits.bias: copying a param with shape torch.Size([80]) from checkpoint, the shape in current model is torch.Size([1]).\n", + "01/10 10:42:57 - mmengine - INFO - Load checkpoint from checkpoints/mask_rcnn_r50_caffe_fpn_mstrain-poly_3x_coco_bbox_mAP-0.408__segm_mAP-0.37_20200504_163245-42aa3d00.pth\n", + "01/10 10:42:57 - mmengine - WARNING - \"FileClient\" will be deprecated in future. Please use io functions in https://mmengine.readthedocs.io/en/latest/api/fileio.html#file-io\n", + "01/10 10:42:57 - mmengine - INFO - Checkpoints will be saved to /content/drive/MyDrive/Colabs/IGP/GeoGroup/DL_2/mmdetection/Halls_results.\n", + "01/10 10:43:03 - mmengine - INFO - Epoch(train) [1][10/54] lr: 4.7545e-05 eta: 0:05:52 time: 0.5517 data_time: 0.1796 memory: 10322 loss: 9.4172 loss_rpn_cls: 0.0474 loss_rpn_bbox: 0.0063 loss_cls: 0.5871 acc: 97.5586 loss_bbox: 0.0247 loss_mask: 8.7517\n", + "01/10 10:43:08 - mmengine - INFO - Epoch(train) [1][20/54] lr: 9.7595e-05 eta: 0:05:31 time: 0.5282 data_time: 0.1530 memory: 2824 loss: 5.7642 loss_rpn_cls: 0.0748 loss_rpn_bbox: 0.0067 loss_cls: 0.4541 acc: 99.3164 loss_bbox: 0.0168 loss_mask: 5.2118\n", + "01/10 10:43:13 - mmengine - INFO - Epoch(train) [1][30/54] lr: 1.4765e-04 eta: 0:05:34 time: 0.5405 data_time: 0.1480 memory: 2823 loss: 4.0500 loss_rpn_cls: 0.0919 loss_rpn_bbox: 0.0085 loss_cls: 0.3322 acc: 99.8047 loss_bbox: 0.0161 loss_mask: 3.6013\n", + "01/10 10:43:18 - mmengine - INFO - Epoch(train) [1][40/54] lr: 1.9770e-04 eta: 0:05:19 time: 0.5257 data_time: 0.1419 memory: 2823 loss: 3.1544 loss_rpn_cls: 0.0921 loss_rpn_bbox: 0.0087 loss_cls: 0.2610 acc: 99.3164 loss_bbox: 0.0164 loss_mask: 2.7762\n", + "01/10 10:43:23 - mmengine - INFO - Epoch(train) [1][50/54] lr: 2.4775e-04 eta: 0:05:13 time: 0.5237 data_time: 0.1422 memory: 2823 loss: 2.6035 loss_rpn_cls: 0.0899 loss_rpn_bbox: 0.0092 loss_cls: 0.2162 acc: 98.8281 loss_bbox: 0.0163 loss_mask: 2.2718\n", + "01/10 10:43:26 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:43:30 - mmengine - INFO - Epoch(train) [2][10/54] lr: 3.1782e-04 eta: 0:05:02 time: 0.5126 data_time: 0.1224 memory: 2825 loss: 0.6011 loss_rpn_cls: 0.0845 loss_rpn_bbox: 0.0109 loss_cls: 0.0835 acc: 98.4375 loss_bbox: 0.0258 loss_mask: 0.3962\n", + "01/10 10:43:34 - mmengine - INFO - Epoch(train) [2][20/54] lr: 3.6787e-04 eta: 0:04:47 time: 0.4835 data_time: 0.0969 memory: 2823 loss: 0.4444 loss_rpn_cls: 0.0673 loss_rpn_bbox: 0.0104 loss_cls: 0.0667 acc: 95.7031 loss_bbox: 0.0446 loss_mask: 0.2554\n", + "01/10 10:43:38 - mmengine - INFO - Epoch(train) [2][30/54] lr: 4.1792e-04 eta: 0:04:35 time: 0.4573 data_time: 0.0721 memory: 2823 loss: 0.4356 loss_rpn_cls: 0.0492 loss_rpn_bbox: 0.0102 loss_cls: 0.0780 acc: 97.9492 loss_bbox: 0.0677 loss_mask: 0.2305\n", + "01/10 10:43:42 - mmengine - INFO - Epoch(train) [2][40/54] lr: 4.6797e-04 eta: 0:04:26 time: 0.4460 data_time: 0.0495 memory: 2822 loss: 0.4480 loss_rpn_cls: 0.0342 loss_rpn_bbox: 0.0093 loss_cls: 0.0966 acc: 95.2148 loss_bbox: 0.0988 loss_mask: 0.2092\n", + "01/10 10:43:46 - mmengine - INFO - Epoch(train) [2][50/54] lr: 5.1802e-04 eta: 0:04:17 time: 0.4142 data_time: 0.0164 memory: 2823 loss: 0.4634 loss_rpn_cls: 0.0214 loss_rpn_bbox: 0.0078 loss_cls: 0.1153 acc: 93.7500 loss_bbox: 0.1351 loss_mask: 0.1838\n", + "01/10 10:43:48 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:43:52 - mmengine - INFO - Epoch(train) [3][10/54] lr: 5.8809e-04 eta: 0:04:06 time: 0.4003 data_time: 0.0121 memory: 2824 loss: 0.4784 loss_rpn_cls: 0.0153 loss_rpn_bbox: 0.0081 loss_cls: 0.1242 acc: 94.6289 loss_bbox: 0.1632 loss_mask: 0.1675\n", + "01/10 10:43:56 - mmengine - INFO - Epoch(train) [3][20/54] lr: 6.3814e-04 eta: 0:03:59 time: 0.4041 data_time: 0.0126 memory: 2823 loss: 0.4740 loss_rpn_cls: 0.0119 loss_rpn_bbox: 0.0074 loss_cls: 0.1210 acc: 96.0938 loss_bbox: 0.1703 loss_mask: 0.1634\n", + "01/10 10:44:01 - mmengine - INFO - Epoch(train) [3][30/54] lr: 6.8819e-04 eta: 0:03:56 time: 0.4251 data_time: 0.0135 memory: 2823 loss: 0.4705 loss_rpn_cls: 0.0084 loss_rpn_bbox: 0.0067 loss_cls: 0.1183 acc: 94.2383 loss_bbox: 0.1777 loss_mask: 0.1593\n", + "01/10 10:44:06 - mmengine - INFO - Epoch(train) [3][40/54] lr: 7.3824e-04 eta: 0:03:50 time: 0.4290 data_time: 0.0131 memory: 2824 loss: 0.4584 loss_rpn_cls: 0.0076 loss_rpn_bbox: 0.0062 loss_cls: 0.1122 acc: 95.9961 loss_bbox: 0.1812 loss_mask: 0.1513\n", + "01/10 10:44:10 - mmengine - INFO - Epoch(train) [3][50/54] lr: 7.8829e-04 eta: 0:03:44 time: 0.4351 data_time: 0.0131 memory: 2824 loss: 0.4349 loss_rpn_cls: 0.0061 loss_rpn_bbox: 0.0056 loss_cls: 0.1033 acc: 94.5312 loss_bbox: 0.1796 loss_mask: 0.1402\n", + "01/10 10:44:11 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:44:11 - mmengine - INFO - Saving checkpoint at 3 epochs\n", + "01/10 10:44:18 - mmengine - INFO - Epoch(val) [3][ 10/107] eta: 0:00:29 time: 0.2999 data_time: 0.0445 memory: 2823 \n", + "01/10 10:44:21 - mmengine - INFO - Epoch(val) [3][ 20/107] eta: 0:00:25 time: 0.2922 data_time: 0.0267 memory: 2146 \n", + "01/10 10:44:25 - mmengine - INFO - Epoch(val) [3][ 30/107] eta: 0:00:25 time: 0.3279 data_time: 0.0226 memory: 2259 \n", + "01/10 10:44:32 - mmengine - INFO - Epoch(val) [3][ 40/107] eta: 0:00:28 time: 0.4322 data_time: 0.0268 memory: 3665 \n", + "01/10 10:44:37 - mmengine - INFO - Epoch(val) [3][ 50/107] eta: 0:00:25 time: 0.4446 data_time: 0.0262 memory: 3495 \n", + "01/10 10:44:40 - mmengine - INFO - Epoch(val) [3][ 60/107] eta: 0:00:19 time: 0.4452 data_time: 0.0193 memory: 2006 \n", + "01/10 10:44:43 - mmengine - INFO - Epoch(val) [3][ 70/107] eta: 0:00:15 time: 0.4510 data_time: 0.0205 memory: 1668 \n", + "01/10 10:44:47 - mmengine - INFO - Epoch(val) [3][ 80/107] eta: 0:00:10 time: 0.4421 data_time: 0.0205 memory: 2062 \n", + "01/10 10:44:50 - mmengine - INFO - Epoch(val) [3][ 90/107] eta: 0:00:06 time: 0.3490 data_time: 0.0163 memory: 2231 \n", + "01/10 10:44:53 - mmengine - INFO - Epoch(val) [3][100/107] eta: 0:00:02 time: 0.3221 data_time: 0.0134 memory: 2203 \n", + "01/10 10:44:55 - mmengine - INFO - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.17s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.05s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.275\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.615\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.209\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.289\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.551\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.551\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.551\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.551\n", + "01/10 10:44:56 - mmengine - INFO - bbox_mAP_copypaste: 0.275 0.615 0.209 -1.000 -1.000 0.289\n", + "01/10 10:44:56 - mmengine - INFO - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.04s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.32s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.09s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.438\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.614\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.490\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.464\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.800\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.800\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.800\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.800\n", + "01/10 10:44:56 - mmengine - INFO - segm_mAP_copypaste: 0.438 0.614 0.490 -1.000 -1.000 0.464\n", + "01/10 10:44:56 - mmengine - INFO - Epoch(val) [3][107/107] coco/bbox_mAP: 0.2750 coco/bbox_mAP_50: 0.6150 coco/bbox_mAP_75: 0.2090 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: -1.0000 coco/bbox_mAP_l: 0.2890 coco/segm_mAP: 0.4380 coco/segm_mAP_50: 0.6140 coco/segm_mAP_75: 0.4900 coco/segm_mAP_s: -1.0000 coco/segm_mAP_m: -1.0000 coco/segm_mAP_l: 0.4640 data_time: 0.0190 time: 0.3729\n", + "01/10 10:45:01 - mmengine - INFO - Epoch(train) [4][10/54] lr: 8.5836e-04 eta: 0:03:37 time: 0.4457 data_time: 0.0167 memory: 2822 loss: 0.4113 loss_rpn_cls: 0.0054 loss_rpn_bbox: 0.0056 loss_cls: 0.0934 acc: 97.4609 loss_bbox: 0.1771 loss_mask: 0.1298\n", + "01/10 10:45:06 - mmengine - INFO - Epoch(train) [4][20/54] lr: 9.0841e-04 eta: 0:03:33 time: 0.4495 data_time: 0.0175 memory: 2823 loss: 0.3897 loss_rpn_cls: 0.0041 loss_rpn_bbox: 0.0054 loss_cls: 0.0870 acc: 95.7031 loss_bbox: 0.1809 loss_mask: 0.1121\n", + "01/10 10:45:10 - mmengine - INFO - Epoch(train) [4][30/54] lr: 9.5846e-04 eta: 0:03:27 time: 0.4392 data_time: 0.0164 memory: 2824 loss: 0.3716 loss_rpn_cls: 0.0033 loss_rpn_bbox: 0.0059 loss_cls: 0.0803 acc: 97.6562 loss_bbox: 0.1778 loss_mask: 0.1043\n", + "01/10 10:45:14 - mmengine - INFO - Epoch(train) [4][40/54] lr: 1.0085e-03 eta: 0:03:22 time: 0.4379 data_time: 0.0159 memory: 2824 loss: 0.3546 loss_rpn_cls: 0.0022 loss_rpn_bbox: 0.0056 loss_cls: 0.0721 acc: 98.6328 loss_bbox: 0.1728 loss_mask: 0.1019\n", + "01/10 10:45:18 - mmengine - INFO - Epoch(train) [4][50/54] lr: 1.0586e-03 eta: 0:03:17 time: 0.4462 data_time: 0.0172 memory: 2823 loss: 0.3329 loss_rpn_cls: 0.0019 loss_rpn_bbox: 0.0050 loss_cls: 0.0655 acc: 98.4375 loss_bbox: 0.1641 loss_mask: 0.0964\n", + "01/10 10:45:20 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:45:24 - mmengine - INFO - Epoch(train) [5][10/54] lr: 1.1286e-03 eta: 0:03:10 time: 0.4262 data_time: 0.0130 memory: 2823 loss: 0.2985 loss_rpn_cls: 0.0011 loss_rpn_bbox: 0.0050 loss_cls: 0.0561 acc: 98.9258 loss_bbox: 0.1463 loss_mask: 0.0900\n", + "01/10 10:45:28 - mmengine - INFO - Epoch(train) [5][20/54] lr: 1.1787e-03 eta: 0:03:05 time: 0.4177 data_time: 0.0121 memory: 2822 loss: 0.2777 loss_rpn_cls: 0.0009 loss_rpn_bbox: 0.0049 loss_cls: 0.0525 acc: 97.8516 loss_bbox: 0.1325 loss_mask: 0.0869\n", + "01/10 10:45:33 - mmengine - INFO - Epoch(train) [5][30/54] lr: 1.2287e-03 eta: 0:03:01 time: 0.4373 data_time: 0.0132 memory: 2822 loss: 0.2514 loss_rpn_cls: 0.0009 loss_rpn_bbox: 0.0050 loss_cls: 0.0491 acc: 97.0703 loss_bbox: 0.1158 loss_mask: 0.0808\n", + "01/10 10:45:38 - mmengine - INFO - Epoch(train) [5][40/54] lr: 1.2788e-03 eta: 0:02:56 time: 0.4364 data_time: 0.0139 memory: 2824 loss: 0.2290 loss_rpn_cls: 0.0008 loss_rpn_bbox: 0.0050 loss_cls: 0.0462 acc: 97.3633 loss_bbox: 0.0993 loss_mask: 0.0777\n", + "01/10 10:45:42 - mmengine - INFO - Epoch(train) [5][50/54] lr: 1.3288e-03 eta: 0:02:51 time: 0.4355 data_time: 0.0128 memory: 2823 loss: 0.2244 loss_rpn_cls: 0.0008 loss_rpn_bbox: 0.0048 loss_cls: 0.0453 acc: 97.8516 loss_bbox: 0.0909 loss_mask: 0.0826\n", + "01/10 10:45:43 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:45:48 - mmengine - INFO - Epoch(train) [6][10/54] lr: 1.3989e-03 eta: 0:02:44 time: 0.4342 data_time: 0.0128 memory: 2823 loss: 0.2085 loss_rpn_cls: 0.0009 loss_rpn_bbox: 0.0047 loss_cls: 0.0436 acc: 97.6562 loss_bbox: 0.0781 loss_mask: 0.0813\n", + "01/10 10:45:52 - mmengine - INFO - Epoch(train) [6][20/54] lr: 1.4489e-03 eta: 0:02:39 time: 0.4252 data_time: 0.0129 memory: 2822 loss: 0.2104 loss_rpn_cls: 0.0009 loss_rpn_bbox: 0.0048 loss_cls: 0.0426 acc: 98.9258 loss_bbox: 0.0735 loss_mask: 0.0887\n", + "01/10 10:45:56 - mmengine - INFO - Epoch(train) [6][30/54] lr: 1.4990e-03 eta: 0:02:34 time: 0.4113 data_time: 0.0116 memory: 2822 loss: 0.2095 loss_rpn_cls: 0.0009 loss_rpn_bbox: 0.0046 loss_cls: 0.0415 acc: 98.8281 loss_bbox: 0.0722 loss_mask: 0.0903\n", + "01/10 10:46:00 - mmengine - INFO - Epoch(train) [6][40/54] lr: 1.5490e-03 eta: 0:02:29 time: 0.4080 data_time: 0.0116 memory: 2824 loss: 0.2052 loss_rpn_cls: 0.0010 loss_rpn_bbox: 0.0049 loss_cls: 0.0414 acc: 98.6328 loss_bbox: 0.0705 loss_mask: 0.0875\n", + "01/10 10:46:04 - mmengine - INFO - Epoch(train) [6][50/54] lr: 1.5991e-03 eta: 0:02:25 time: 0.4207 data_time: 0.0135 memory: 2823 loss: 0.1854 loss_rpn_cls: 0.0008 loss_rpn_bbox: 0.0044 loss_cls: 0.0371 acc: 99.3164 loss_bbox: 0.0632 loss_mask: 0.0798\n", + "01/10 10:46:05 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:46:05 - mmengine - INFO - Saving checkpoint at 6 epochs\n", + "01/10 10:46:08 - mmengine - INFO - Epoch(val) [6][ 10/107] eta: 0:00:12 time: 0.2756 data_time: 0.0146 memory: 2676 \n", + "01/10 10:46:10 - mmengine - INFO - Epoch(val) [6][ 20/107] eta: 0:00:10 time: 0.2221 data_time: 0.0132 memory: 1139 \n", + "01/10 10:46:11 - mmengine - INFO - Epoch(val) [6][ 30/107] eta: 0:00:09 time: 0.1895 data_time: 0.0132 memory: 1139 \n", + "01/10 10:46:12 - mmengine - INFO - Epoch(val) [6][ 40/107] eta: 0:00:08 time: 0.1420 data_time: 0.0139 memory: 1139 \n", + "01/10 10:46:13 - mmengine - INFO - Epoch(val) [6][ 50/107] eta: 0:00:06 time: 0.1207 data_time: 0.0174 memory: 1139 \n", + "01/10 10:46:14 - mmengine - INFO - Epoch(val) [6][ 60/107] eta: 0:00:05 time: 0.1187 data_time: 0.0156 memory: 1139 \n", + "01/10 10:46:16 - mmengine - INFO - Epoch(val) [6][ 70/107] eta: 0:00:04 time: 0.1182 data_time: 0.0155 memory: 1139 \n", + "01/10 10:46:18 - mmengine - INFO - Epoch(val) [6][ 80/107] eta: 0:00:03 time: 0.1445 data_time: 0.0204 memory: 1139 \n", + "01/10 10:46:21 - mmengine - INFO - Epoch(val) [6][ 90/107] eta: 0:00:02 time: 0.1705 data_time: 0.0271 memory: 1139 \n", + "01/10 10:46:22 - mmengine - INFO - Epoch(val) [6][100/107] eta: 0:00:01 time: 0.1744 data_time: 0.0261 memory: 1163 \n", + "01/10 10:46:23 - mmengine - INFO - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.04s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.789\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.971\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.956\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.790\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.845\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.845\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.845\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.845\n", + "01/10 10:46:23 - mmengine - INFO - bbox_mAP_copypaste: 0.789 0.971 0.956 -1.000 -1.000 0.790\n", + "01/10 10:46:23 - mmengine - INFO - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.08s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.887\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.971\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.940\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.889\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.936\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.936\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.936\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.936\n", + "01/10 10:46:23 - mmengine - INFO - segm_mAP_copypaste: 0.887 0.971 0.940 -1.000 -1.000 0.889\n", + "01/10 10:46:23 - mmengine - INFO - Epoch(val) [6][107/107] coco/bbox_mAP: 0.7890 coco/bbox_mAP_50: 0.9710 coco/bbox_mAP_75: 0.9560 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: -1.0000 coco/bbox_mAP_l: 0.7900 coco/segm_mAP: 0.8870 coco/segm_mAP_50: 0.9710 coco/segm_mAP_75: 0.9400 coco/segm_mAP_s: -1.0000 coco/segm_mAP_m: -1.0000 coco/segm_mAP_l: 0.8890 data_time: 0.0208 time: 0.1455\n", + "01/10 10:46:27 - mmengine - INFO - Epoch(train) [7][10/54] lr: 1.6692e-03 eta: 0:02:18 time: 0.3980 data_time: 0.0131 memory: 2823 loss: 0.1783 loss_rpn_cls: 0.0006 loss_rpn_bbox: 0.0044 loss_cls: 0.0331 acc: 99.3164 loss_bbox: 0.0610 loss_mask: 0.0791\n", + "01/10 10:46:31 - mmengine - INFO - Epoch(train) [7][20/54] lr: 1.7192e-03 eta: 0:02:13 time: 0.3935 data_time: 0.0127 memory: 2823 loss: 0.1697 loss_rpn_cls: 0.0009 loss_rpn_bbox: 0.0042 loss_cls: 0.0316 acc: 99.0234 loss_bbox: 0.0565 loss_mask: 0.0764\n", + "01/10 10:46:35 - mmengine - INFO - Epoch(train) [7][30/54] lr: 1.7693e-03 eta: 0:02:08 time: 0.4036 data_time: 0.0140 memory: 2821 loss: 0.1593 loss_rpn_cls: 0.0009 loss_rpn_bbox: 0.0040 loss_cls: 0.0298 acc: 99.2188 loss_bbox: 0.0526 loss_mask: 0.0719\n", + "01/10 10:46:39 - mmengine - INFO - Epoch(train) [7][40/54] lr: 1.8193e-03 eta: 0:02:04 time: 0.4029 data_time: 0.0136 memory: 2822 loss: 0.1528 loss_rpn_cls: 0.0008 loss_rpn_bbox: 0.0036 loss_cls: 0.0279 acc: 98.9258 loss_bbox: 0.0509 loss_mask: 0.0696\n", + "01/10 10:46:43 - mmengine - INFO - Epoch(train) [7][50/54] lr: 1.8694e-03 eta: 0:01:59 time: 0.4006 data_time: 0.0123 memory: 2823 loss: 0.1489 loss_rpn_cls: 0.0009 loss_rpn_bbox: 0.0034 loss_cls: 0.0267 acc: 98.5352 loss_bbox: 0.0491 loss_mask: 0.0688\n", + "01/10 10:46:44 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:46:48 - mmengine - INFO - Epoch(train) [8][10/54] lr: 1.9394e-03 eta: 0:01:52 time: 0.3962 data_time: 0.0120 memory: 2822 loss: 0.1383 loss_rpn_cls: 0.0007 loss_rpn_bbox: 0.0029 loss_cls: 0.0252 acc: 99.3164 loss_bbox: 0.0462 loss_mask: 0.0634\n", + "01/10 10:46:53 - mmengine - INFO - Epoch(train) [8][20/54] lr: 1.9895e-03 eta: 0:01:48 time: 0.4051 data_time: 0.0126 memory: 2821 loss: 0.1313 loss_rpn_cls: 0.0004 loss_rpn_bbox: 0.0027 loss_cls: 0.0238 acc: 99.2188 loss_bbox: 0.0431 loss_mask: 0.0612\n", + "01/10 10:46:57 - mmengine - INFO - Epoch(train) [8][30/54] lr: 2.0395e-03 eta: 0:01:44 time: 0.3974 data_time: 0.0114 memory: 2825 loss: 0.1277 loss_rpn_cls: 0.0004 loss_rpn_bbox: 0.0025 loss_cls: 0.0234 acc: 99.3164 loss_bbox: 0.0419 loss_mask: 0.0594\n", + "01/10 10:47:01 - mmengine - INFO - Epoch(train) [8][40/54] lr: 2.0896e-03 eta: 0:01:39 time: 0.4010 data_time: 0.0115 memory: 2822 loss: 0.1247 loss_rpn_cls: 0.0004 loss_rpn_bbox: 0.0025 loss_cls: 0.0231 acc: 99.2188 loss_bbox: 0.0408 loss_mask: 0.0579\n", + "01/10 10:47:05 - mmengine - INFO - Epoch(train) [8][50/54] lr: 2.1396e-03 eta: 0:01:35 time: 0.4169 data_time: 0.0126 memory: 2824 loss: 0.1230 loss_rpn_cls: 0.0003 loss_rpn_bbox: 0.0026 loss_cls: 0.0229 acc: 99.2188 loss_bbox: 0.0406 loss_mask: 0.0567\n", + "01/10 10:47:06 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:47:11 - mmengine - INFO - Epoch(train) [9][10/54] lr: 2.2097e-04 eta: 0:01:29 time: 0.4238 data_time: 0.0169 memory: 2823 loss: 0.1174 loss_rpn_cls: 0.0003 loss_rpn_bbox: 0.0028 loss_cls: 0.0223 acc: 99.3164 loss_bbox: 0.0406 loss_mask: 0.0514\n", + "01/10 10:47:16 - mmengine - INFO - Epoch(train) [9][20/54] lr: 2.2598e-04 eta: 0:01:24 time: 0.4229 data_time: 0.0166 memory: 2824 loss: 0.1084 loss_rpn_cls: 0.0003 loss_rpn_bbox: 0.0025 loss_cls: 0.0216 acc: 99.0234 loss_bbox: 0.0375 loss_mask: 0.0466\n", + "01/10 10:47:20 - mmengine - INFO - Epoch(train) [9][30/54] lr: 2.3098e-04 eta: 0:01:20 time: 0.4255 data_time: 0.0177 memory: 2824 loss: 0.1066 loss_rpn_cls: 0.0003 loss_rpn_bbox: 0.0025 loss_cls: 0.0213 acc: 99.6094 loss_bbox: 0.0355 loss_mask: 0.0471\n", + "01/10 10:47:24 - mmengine - INFO - Epoch(train) [9][40/54] lr: 2.3599e-04 eta: 0:01:16 time: 0.4388 data_time: 0.0193 memory: 2823 loss: 0.1019 loss_rpn_cls: 0.0003 loss_rpn_bbox: 0.0024 loss_cls: 0.0203 acc: 99.4141 loss_bbox: 0.0321 loss_mask: 0.0467\n", + "01/10 10:47:28 - mmengine - INFO - Epoch(train) [9][50/54] lr: 2.4099e-04 eta: 0:01:11 time: 0.4351 data_time: 0.0187 memory: 2823 loss: 0.0978 loss_rpn_cls: 0.0003 loss_rpn_bbox: 0.0022 loss_cls: 0.0198 acc: 98.9258 loss_bbox: 0.0299 loss_mask: 0.0457\n", + "01/10 10:47:29 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:47:29 - mmengine - INFO - Saving checkpoint at 9 epochs\n", + "01/10 10:47:33 - mmengine - INFO - Epoch(val) [9][ 10/107] eta: 0:00:12 time: 0.1759 data_time: 0.0275 memory: 2675 \n", + "01/10 10:47:34 - mmengine - INFO - Epoch(val) [9][ 20/107] eta: 0:00:10 time: 0.1560 data_time: 0.0241 memory: 1139 \n", + "01/10 10:47:36 - mmengine - INFO - Epoch(val) [9][ 30/107] eta: 0:00:10 time: 0.1446 data_time: 0.0232 memory: 1139 \n", + "01/10 10:47:38 - mmengine - INFO - Epoch(val) [9][ 40/107] eta: 0:00:10 time: 0.1404 data_time: 0.0205 memory: 1139 \n", + "01/10 10:47:40 - mmengine - INFO - Epoch(val) [9][ 50/107] eta: 0:00:09 time: 0.1611 data_time: 0.0269 memory: 1139 \n", + "01/10 10:47:41 - mmengine - INFO - Epoch(val) [9][ 60/107] eta: 0:00:07 time: 0.1600 data_time: 0.0264 memory: 1139 \n", + "01/10 10:47:42 - mmengine - INFO - Epoch(val) [9][ 70/107] eta: 0:00:05 time: 0.1598 data_time: 0.0273 memory: 1139 \n", + "01/10 10:47:43 - mmengine - INFO - Epoch(val) [9][ 80/107] eta: 0:00:03 time: 0.1499 data_time: 0.0247 memory: 1139 \n", + "01/10 10:47:45 - mmengine - INFO - Epoch(val) [9][ 90/107] eta: 0:00:02 time: 0.1409 data_time: 0.0217 memory: 1139 \n", + "01/10 10:47:46 - mmengine - INFO - Epoch(val) [9][100/107] eta: 0:00:00 time: 0.1220 data_time: 0.0163 memory: 1139 \n", + "01/10 10:47:47 - mmengine - INFO - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.05s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.910\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.988\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.988\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.910\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.941\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.941\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.941\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.941\n", + "01/10 10:47:47 - mmengine - INFO - bbox_mAP_copypaste: 0.910 0.988 0.988 -1.000 -1.000 0.910\n", + "01/10 10:47:47 - mmengine - INFO - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.04s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.01s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.955\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.988\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.988\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.955\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.969\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.969\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.969\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.969\n", + "01/10 10:47:47 - mmengine - INFO - segm_mAP_copypaste: 0.955 0.988 0.988 -1.000 -1.000 0.955\n", + "01/10 10:47:47 - mmengine - INFO - Epoch(val) [9][107/107] coco/bbox_mAP: 0.9100 coco/bbox_mAP_50: 0.9880 coco/bbox_mAP_75: 0.9880 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: -1.0000 coco/bbox_mAP_l: 0.9100 coco/segm_mAP: 0.9550 coco/segm_mAP_50: 0.9880 coco/segm_mAP_75: 0.9880 coco/segm_mAP_s: -1.0000 coco/segm_mAP_m: -1.0000 coco/segm_mAP_l: 0.9550 data_time: 0.0206 time: 0.1383\n", + "01/10 10:47:51 - mmengine - INFO - Epoch(train) [10][10/54] lr: 2.4800e-04 eta: 0:01:05 time: 0.4168 data_time: 0.0143 memory: 2824 loss: 0.0942 loss_rpn_cls: 0.0002 loss_rpn_bbox: 0.0022 loss_cls: 0.0191 acc: 99.7070 loss_bbox: 0.0274 loss_mask: 0.0453\n", + "01/10 10:47:55 - mmengine - INFO - Epoch(train) [10][20/54] lr: 2.5000e-04 eta: 0:01:01 time: 0.4184 data_time: 0.0147 memory: 2823 loss: 0.0921 loss_rpn_cls: 0.0005 loss_rpn_bbox: 0.0021 loss_cls: 0.0188 acc: 99.5117 loss_bbox: 0.0274 loss_mask: 0.0434\n", + "01/10 10:47:59 - mmengine - INFO - Epoch(train) [10][30/54] lr: 2.5000e-04 eta: 0:00:56 time: 0.4082 data_time: 0.0132 memory: 2823 loss: 0.0890 loss_rpn_cls: 0.0005 loss_rpn_bbox: 0.0021 loss_cls: 0.0180 acc: 99.4141 loss_bbox: 0.0268 loss_mask: 0.0415\n", + "01/10 10:48:03 - mmengine - INFO - Epoch(train) [10][40/54] lr: 2.5000e-04 eta: 0:00:52 time: 0.4042 data_time: 0.0122 memory: 2823 loss: 0.0942 loss_rpn_cls: 0.0005 loss_rpn_bbox: 0.0023 loss_cls: 0.0187 acc: 99.0234 loss_bbox: 0.0278 loss_mask: 0.0450\n", + "01/10 10:48:07 - mmengine - INFO - Epoch(train) [10][50/54] lr: 2.5000e-04 eta: 0:00:48 time: 0.4115 data_time: 0.0121 memory: 2822 loss: 0.0929 loss_rpn_cls: 0.0005 loss_rpn_bbox: 0.0022 loss_cls: 0.0187 acc: 99.7070 loss_bbox: 0.0272 loss_mask: 0.0443\n", + "01/10 10:48:09 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:48:13 - mmengine - INFO - Epoch(train) [11][10/54] lr: 2.5000e-04 eta: 0:00:42 time: 0.4097 data_time: 0.0137 memory: 2822 loss: 0.0921 loss_rpn_cls: 0.0005 loss_rpn_bbox: 0.0023 loss_cls: 0.0189 acc: 99.4141 loss_bbox: 0.0266 loss_mask: 0.0438\n", + "01/10 10:48:17 - mmengine - INFO - Epoch(train) [11][20/54] lr: 2.5000e-04 eta: 0:00:37 time: 0.4092 data_time: 0.0133 memory: 2822 loss: 0.0917 loss_rpn_cls: 0.0002 loss_rpn_bbox: 0.0022 loss_cls: 0.0188 acc: 99.7070 loss_bbox: 0.0265 loss_mask: 0.0440\n", + "01/10 10:48:21 - mmengine - INFO - Epoch(train) [11][30/54] lr: 2.5000e-04 eta: 0:00:33 time: 0.4046 data_time: 0.0133 memory: 2824 loss: 0.0924 loss_rpn_cls: 0.0002 loss_rpn_bbox: 0.0020 loss_cls: 0.0194 acc: 99.2188 loss_bbox: 0.0270 loss_mask: 0.0438\n", + "01/10 10:48:26 - mmengine - INFO - Epoch(train) [11][40/54] lr: 2.5000e-04 eta: 0:00:29 time: 0.4250 data_time: 0.0153 memory: 2823 loss: 0.0874 loss_rpn_cls: 0.0005 loss_rpn_bbox: 0.0020 loss_cls: 0.0180 acc: 99.5117 loss_bbox: 0.0259 loss_mask: 0.0411\n", + "01/10 10:48:30 - mmengine - INFO - Epoch(train) [11][50/54] lr: 2.5000e-04 eta: 0:00:24 time: 0.4303 data_time: 0.0152 memory: 2824 loss: 0.0883 loss_rpn_cls: 0.0006 loss_rpn_bbox: 0.0020 loss_cls: 0.0182 acc: 98.9258 loss_bbox: 0.0263 loss_mask: 0.0411\n", + "01/10 10:48:32 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:48:36 - mmengine - INFO - Epoch(train) [12][10/54] lr: 2.5000e-05 eta: 0:00:18 time: 0.4235 data_time: 0.0126 memory: 2824 loss: 0.0860 loss_rpn_cls: 0.0006 loss_rpn_bbox: 0.0018 loss_cls: 0.0180 acc: 98.8281 loss_bbox: 0.0258 loss_mask: 0.0398\n", + "01/10 10:48:41 - mmengine - INFO - Epoch(train) [12][20/54] lr: 2.5000e-05 eta: 0:00:14 time: 0.4421 data_time: 0.0140 memory: 2823 loss: 0.0864 loss_rpn_cls: 0.0006 loss_rpn_bbox: 0.0018 loss_cls: 0.0183 acc: 99.6094 loss_bbox: 0.0259 loss_mask: 0.0398\n", + "01/10 10:48:45 - mmengine - INFO - Epoch(train) [12][30/54] lr: 2.5000e-05 eta: 0:00:10 time: 0.4387 data_time: 0.0132 memory: 2822 loss: 0.0835 loss_rpn_cls: 0.0005 loss_rpn_bbox: 0.0017 loss_cls: 0.0179 acc: 99.5117 loss_bbox: 0.0243 loss_mask: 0.0392\n", + "01/10 10:48:49 - mmengine - INFO - Epoch(train) [12][40/54] lr: 2.5000e-05 eta: 0:00:05 time: 0.4188 data_time: 0.0122 memory: 2821 loss: 0.0847 loss_rpn_cls: 0.0005 loss_rpn_bbox: 0.0017 loss_cls: 0.0183 acc: 99.5117 loss_bbox: 0.0246 loss_mask: 0.0396\n", + "01/10 10:48:53 - mmengine - INFO - Epoch(train) [12][50/54] lr: 2.5000e-05 eta: 0:00:01 time: 0.4183 data_time: 0.0122 memory: 2823 loss: 0.0856 loss_rpn_cls: 0.0004 loss_rpn_bbox: 0.0018 loss_cls: 0.0182 acc: 99.5117 loss_bbox: 0.0246 loss_mask: 0.0406\n", + "01/10 10:48:54 - mmengine - INFO - Exp name: mask-rcnn_r50-caffe_fpn_ms-poly-1x_coco_20240110_104232\n", + "01/10 10:48:54 - mmengine - INFO - Saving checkpoint at 12 epochs\n", + "01/10 10:48:59 - mmengine - INFO - Epoch(val) [12][ 10/107] eta: 0:00:15 time: 0.1268 data_time: 0.0199 memory: 2822 \n", + "01/10 10:49:00 - mmengine - INFO - Epoch(val) [12][ 20/107] eta: 0:00:11 time: 0.1254 data_time: 0.0191 memory: 1139 \n", + "01/10 10:49:01 - mmengine - INFO - Epoch(val) [12][ 30/107] eta: 0:00:09 time: 0.1210 data_time: 0.0195 memory: 1139 \n", + "01/10 10:49:03 - mmengine - INFO - Epoch(val) [12][ 40/107] eta: 0:00:08 time: 0.1242 data_time: 0.0201 memory: 1139 \n", + "01/10 10:49:04 - mmengine - INFO - Epoch(val) [12][ 50/107] eta: 0:00:07 time: 0.1305 data_time: 0.0228 memory: 1139 \n", + "01/10 10:49:05 - mmengine - INFO - Epoch(val) [12][ 60/107] eta: 0:00:05 time: 0.1202 data_time: 0.0173 memory: 1139 \n", + "01/10 10:49:07 - mmengine - INFO - Epoch(val) [12][ 70/107] eta: 0:00:04 time: 0.1317 data_time: 0.0189 memory: 1139 \n", + "01/10 10:49:08 - mmengine - INFO - Epoch(val) [12][ 80/107] eta: 0:00:03 time: 0.1409 data_time: 0.0197 memory: 1139 \n", + "01/10 10:49:10 - mmengine - INFO - Epoch(val) [12][ 90/107] eta: 0:00:02 time: 0.1484 data_time: 0.0214 memory: 1240 \n", + "01/10 10:49:12 - mmengine - INFO - Epoch(val) [12][100/107] eta: 0:00:01 time: 0.1557 data_time: 0.0241 memory: 1139 \n", + "01/10 10:49:13 - mmengine - INFO - Evaluating bbox...\n", + "Loading and preparing results...\n", + "DONE (t=0.00s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *bbox*\n", + "DONE (t=0.07s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.02s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.942\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.989\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.989\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.942\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.960\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.960\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.960\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.960\n", + "01/10 10:49:13 - mmengine - INFO - bbox_mAP_copypaste: 0.942 0.989 0.989 -1.000 -1.000 0.942\n", + "01/10 10:49:13 - mmengine - INFO - Evaluating segm...\n", + "Loading and preparing results...\n", + "DONE (t=0.01s)\n", + "creating index...\n", + "index created!\n", + "Running per image evaluation...\n", + "Evaluate annotation type *segm*\n", + "DONE (t=0.07s).\n", + "Accumulating evaluation results...\n", + "DONE (t=0.02s).\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.968\n", + " Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=1000 ] = 0.989\n", + " Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=1000 ] = 0.989\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.968\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.975\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=300 ] = 0.975\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=1000 ] = 0.975\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=1000 ] = -1.000\n", + " Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=1000 ] = 0.975\n", + "01/10 10:49:13 - mmengine - INFO - segm_mAP_copypaste: 0.968 0.989 0.989 -1.000 -1.000 0.968\n", + "01/10 10:49:13 - mmengine - INFO - Epoch(val) [12][107/107] coco/bbox_mAP: 0.9420 coco/bbox_mAP_50: 0.9890 coco/bbox_mAP_75: 0.9890 coco/bbox_mAP_s: -1.0000 coco/bbox_mAP_m: -1.0000 coco/bbox_mAP_l: 0.9420 coco/segm_mAP: 0.9680 coco/segm_mAP_50: 0.9890 coco/segm_mAP_75: 0.9890 coco/segm_mAP_s: -1.0000 coco/segm_mAP_m: -1.0000 coco/segm_mAP_l: 0.9680 data_time: 0.0226 time: 0.1429\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MaskRCNN(\n", + " (data_preprocessor): DetDataPreprocessor()\n", + " (backbone): ResNet(\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): ResLayer(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): ResLayer(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): ResLayer(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): ResLayer(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " init_cfg={'type': 'Pretrained', 'checkpoint': 'open-mmlab://detectron2/resnet50_caffe'}\n", + " (neck): FPN(\n", + " (lateral_convs): ModuleList(\n", + " (0): ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (1): ConvModule(\n", + " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (2): ConvModule(\n", + " (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (3): ConvModule(\n", + " (conv): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " (fpn_convs): ModuleList(\n", + " (0-3): 4 x ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " )\n", + " )\n", + " )\n", + " init_cfg={'type': 'Xavier', 'layer': 'Conv2d', 'distribution': 'uniform'}\n", + " (rpn_head): RPNHead(\n", + " (loss_cls): CrossEntropyLoss(avg_non_ignore=False)\n", + " (loss_bbox): L1Loss()\n", + " (rpn_conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (rpn_cls): Conv2d(256, 3, kernel_size=(1, 1), stride=(1, 1))\n", + " (rpn_reg): Conv2d(256, 12, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " init_cfg={'type': 'Normal', 'layer': 'Conv2d', 'std': 0.01}\n", + " (roi_head): StandardRoIHead(\n", + " (bbox_roi_extractor): SingleRoIExtractor(\n", + " (roi_layers): ModuleList(\n", + " (0): RoIAlign(output_size=(7, 7), spatial_scale=0.25, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (1): RoIAlign(output_size=(7, 7), spatial_scale=0.125, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (2): RoIAlign(output_size=(7, 7), spatial_scale=0.0625, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (3): RoIAlign(output_size=(7, 7), spatial_scale=0.03125, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " )\n", + " )\n", + " (bbox_head): Shared2FCBBoxHead(\n", + " (loss_cls): CrossEntropyLoss(avg_non_ignore=False)\n", + " (loss_bbox): L1Loss()\n", + " (fc_cls): Linear(in_features=1024, out_features=2, bias=True)\n", + " (fc_reg): Linear(in_features=1024, out_features=4, bias=True)\n", + " (shared_convs): ModuleList()\n", + " (shared_fcs): ModuleList(\n", + " (0): Linear(in_features=12544, out_features=1024, bias=True)\n", + " (1): Linear(in_features=1024, out_features=1024, bias=True)\n", + " )\n", + " (cls_convs): ModuleList()\n", + " (cls_fcs): ModuleList()\n", + " (reg_convs): ModuleList()\n", + " (reg_fcs): ModuleList()\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " init_cfg=[{'type': 'Normal', 'std': 0.01, 'override': {'name': 'fc_cls'}}, {'type': 'Normal', 'std': 0.001, 'override': {'name': 'fc_reg'}}, {'type': 'Xavier', 'distribution': 'uniform', 'override': [{'name': 'shared_fcs'}, {'name': 'cls_fcs'}, {'name': 'reg_fcs'}]}]\n", + " (mask_roi_extractor): SingleRoIExtractor(\n", + " (roi_layers): ModuleList(\n", + " (0): RoIAlign(output_size=(14, 14), spatial_scale=0.25, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (1): RoIAlign(output_size=(14, 14), spatial_scale=0.125, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (2): RoIAlign(output_size=(14, 14), spatial_scale=0.0625, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " (3): RoIAlign(output_size=(14, 14), spatial_scale=0.03125, sampling_ratio=0, pool_mode=avg, aligned=True, use_torchvision=False)\n", + " )\n", + " )\n", + " (mask_head): FCNMaskHead(\n", + " (loss_mask): CrossEntropyLoss(avg_non_ignore=False)\n", + " (convs): ModuleList(\n", + " (0-3): 4 x ConvModule(\n", + " (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (activate): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (upsample): ConvTranspose2d(256, 256, kernel_size=(2, 2), stride=(2, 2))\n", + " (conv_logits): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1))\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ] + }, + { + "cell_type": "code", + "source": [ + "save_results(TEST_PATH=TEST_PATH,\n", + " work_dir=work_dir,\n", + " epoch=12,\n", + " threshold=0.5,\n", + " format=\"*.png\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sDWNj4Mm-Tls", + "outputId": "893acfab-a820-49bc-c762-36424f23a3bf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Loads checkpoint by local backend from path: ./Halls_results/epoch_12.pth\n" + ] + } + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [ + "w55SiMeS8ypH" + ], + "provenance": [], + "gpuType": "T4", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file