diff --git a/demo/MMPose_Tutorial.ipynb b/demo/MMPose_Tutorial.ipynb new file mode 100644 index 0000000000..4893c1ccbc --- /dev/null +++ b/demo/MMPose_Tutorial.ipynb @@ -0,0 +1,4232 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "F77yOqgkX8p4" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bfKI5TJRs_Db" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8xX3YewOtqV0" + }, + "source": [ + "# MMPose Tutorial\n", + "\n", + "Welcome to MMPose colab tutorial! In this tutorial, we will show you how to\n", + "\n", + "- install MMPose 1.x\n", + "- perform inference with an MMPose model\n", + "- train a new mmpose model with your own datasets\n", + "\n", + "Let's start!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bkw-kUD8t3t8" + }, + "source": [ + "## Install MMPose\n", + "\n", + "We recommend to use a conda environment to install mmpose and its dependencies. And compilers `nvcc` and `gcc` are required." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0f_Ebb2otWtd", + "outputId": "95a1c9bb-2092-41da-c308-5d1751178bdf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nvcc: NVIDIA (R) Cuda compiler driver\n", + "Copyright (c) 2005-2020 NVIDIA Corporation\n", + "Built on Mon_Oct_12_20:09:46_PDT_2020\n", + "Cuda compilation tools, release 11.1, V11.1.105\n", + "Build cuda_11.1.TC455_06.29190527_0\n", + "gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0\n", + "Copyright (C) 2017 Free Software Foundation, Inc.\n", + "This is free software; see the source for copying conditions. There is NO\n", + "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n", + "\n", + "/usr/local/bin/python\n" + ] + } + ], + "source": [ + "# check NVCC version\n", + "!nvcc -V\n", + "\n", + "# check GCC version\n", + "!gcc --version\n", + "\n", + "# check python in conda environment\n", + "!which python" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MLcoZr3ot9iw", + "outputId": "6f486798-00bb-48d9-90e5-c63ccadd0113" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Looking in links: https://download.pytorch.org/whl/torch_stable.html\n", + "Collecting torch==1.10.0+cu111\n", + " Downloading https://download.pytorch.org/whl/cu111/torch-1.10.0%2Bcu111-cp37-cp37m-linux_x86_64.whl (2137.6 MB)\n", + "\u001b[K |████████████▌ | 834.1 MB 1.3 MB/s eta 0:16:42tcmalloc: large alloc 1147494400 bytes == 0x3935e000 @ 0x7f955b2e9615 0x592b76 0x4df71e 0x59afff 0x515655 0x549576 0x593fce 0x548ae9 0x51566f 0x549576 0x593fce 0x548ae9 0x5127f1 0x598e3b 0x511f68 0x598e3b 0x511f68 0x598e3b 0x511f68 0x4bc98a 0x532e76 0x594b72 0x515600 0x549576 0x593fce 0x548ae9 0x5127f1 0x549576 0x593fce 0x5118f8 0x593dd7\n", + "\u001b[K |███████████████▉ | 1055.7 MB 1.3 MB/s eta 0:13:59tcmalloc: large alloc 1434370048 bytes == 0x7d9b4000 @ 0x7f955b2e9615 0x592b76 0x4df71e 0x59afff 0x515655 0x549576 0x593fce 0x548ae9 0x51566f 0x549576 0x593fce 0x548ae9 0x5127f1 0x598e3b 0x511f68 0x598e3b 0x511f68 0x598e3b 0x511f68 0x4bc98a 0x532e76 0x594b72 0x515600 0x549576 0x593fce 0x548ae9 0x5127f1 0x549576 0x593fce 0x5118f8 0x593dd7\n", + "\u001b[K |████████████████████ | 1336.2 MB 1.3 MB/s eta 0:10:21tcmalloc: large alloc 1792966656 bytes == 0x27e6000 @ 0x7f955b2e9615 0x592b76 0x4df71e 0x59afff 0x515655 0x549576 0x593fce 0x548ae9 0x51566f 0x549576 0x593fce 0x548ae9 0x5127f1 0x598e3b 0x511f68 0x598e3b 0x511f68 0x598e3b 0x511f68 0x4bc98a 0x532e76 0x594b72 0x515600 0x549576 0x593fce 0x548ae9 0x5127f1 0x549576 0x593fce 0x5118f8 0x593dd7\n", + "\u001b[K |█████████████████████████▎ | 1691.1 MB 1.2 MB/s eta 0:05:58tcmalloc: large alloc 2241208320 bytes == 0x6d5ce000 @ 0x7f955b2e9615 0x592b76 0x4df71e 0x59afff 0x515655 0x549576 0x593fce 0x548ae9 0x51566f 0x549576 0x593fce 0x548ae9 0x5127f1 0x598e3b 0x511f68 0x598e3b 0x511f68 0x598e3b 0x511f68 0x4bc98a 0x532e76 0x594b72 0x515600 0x549576 0x593fce 0x548ae9 0x5127f1 0x549576 0x593fce 0x5118f8 0x593dd7\n", + "\u001b[K |████████████████████████████████| 2137.6 MB 1.2 MB/s eta 0:00:01tcmalloc: large alloc 2137645056 bytes == 0xf2f30000 @ 0x7f955b2e81e7 0x4a3940 0x4a39cc 0x592b76 0x4df71e 0x59afff 0x515655 0x549576 0x593fce 0x511e2c 0x549576 0x593fce 0x511e2c 0x549576 0x593fce 0x511e2c 0x549576 0x593fce 0x511e2c 0x549576 0x593fce 0x511e2c 0x593dd7 0x511e2c 0x549576 0x593fce 0x548ae9 0x5127f1 0x549576 0x593fce 0x548ae9\n", + "tcmalloc: large alloc 2672058368 bytes == 0x1e6a8a000 @ 0x7f955b2e9615 0x592b76 0x4df71e 0x59afff 0x515655 0x549576 0x593fce 0x511e2c 0x549576 0x593fce 0x511e2c 0x549576 0x593fce 0x511e2c 0x549576 0x593fce 0x511e2c 0x549576 0x593fce 0x511e2c 0x593dd7 0x511e2c 0x549576 0x593fce 0x548ae9 0x5127f1 0x549576 0x593fce 0x548ae9 0x5127f1 0x549576\n", + "\u001b[K |████████████████████████████████| 2137.6 MB 413 bytes/s \n", + "\u001b[?25hCollecting torchvision==0.11.0+cu111\n", + " Downloading https://download.pytorch.org/whl/cu111/torchvision-0.11.0%2Bcu111-cp37-cp37m-linux_x86_64.whl (21.9 MB)\n", + "\u001b[K |████████████████████████████████| 21.9 MB 4.4 MB/s \n", + "\u001b[?25hRequirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch==1.10.0+cu111) (4.1.1)\n", + "Requirement already satisfied: pillow!=8.3.0,>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision==0.11.0+cu111) (7.1.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision==0.11.0+cu111) (1.21.6)\n", + "Installing collected packages: torch, torchvision\n", + " Attempting uninstall: torch\n", + " Found existing installation: torch 1.12.1+cu113\n", + " Uninstalling torch-1.12.1+cu113:\n", + " Successfully uninstalled torch-1.12.1+cu113\n", + " Attempting uninstall: torchvision\n", + " Found existing installation: torchvision 0.13.1+cu113\n", + " Uninstalling torchvision-0.13.1+cu113:\n", + " Successfully uninstalled torchvision-0.13.1+cu113\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torchtext 0.13.1 requires torch==1.12.1, but you have torch 1.10.0+cu111 which is incompatible.\n", + "torchaudio 0.12.1+cu113 requires torch==1.12.1, but you have torch 1.10.0+cu111 which is incompatible.\u001b[0m\n", + "Successfully installed torch-1.10.0+cu111 torchvision-0.11.0+cu111\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting openmim\n", + " Downloading openmim-0.3.1-py2.py3-none-any.whl (50 kB)\n", + "\u001b[K |████████████████████████████████| 50 kB 5.7 MB/s \n", + "\u001b[?25hRequirement already satisfied: pip>=19.3 in /usr/local/lib/python3.7/dist-packages (from openmim) (21.1.3)\n", + "Requirement already satisfied: tabulate in /usr/local/lib/python3.7/dist-packages (from openmim) (0.8.10)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from openmim) (1.3.5)\n", + "Collecting model-index\n", + " Downloading model_index-0.1.11-py3-none-any.whl (34 kB)\n", + "Requirement already satisfied: Click in /usr/local/lib/python3.7/dist-packages (from openmim) (7.1.2)\n", + "Collecting colorama\n", + " Downloading colorama-0.4.5-py2.py3-none-any.whl (16 kB)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from openmim) (2.23.0)\n", + "Collecting rich\n", + " Downloading rich-12.5.1-py3-none-any.whl (235 kB)\n", + "\u001b[K |████████████████████████████████| 235 kB 60.9 MB/s \n", + "\u001b[?25hRequirement already satisfied: markdown in /usr/local/lib/python3.7/dist-packages (from model-index->openmim) (3.4.1)\n", + "Collecting ordered-set\n", + " Downloading ordered_set-4.1.0-py3-none-any.whl (7.6 kB)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from model-index->openmim) (6.0)\n", + "Requirement already satisfied: importlib-metadata>=4.4 in /usr/local/lib/python3.7/dist-packages (from markdown->model-index->openmim) (4.12.0)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown->model-index->openmim) (3.8.1)\n", + "Requirement already satisfied: typing-extensions>=3.6.4 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata>=4.4->markdown->model-index->openmim) (4.1.1)\n", + "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas->openmim) (2.8.2)\n", + "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.7/dist-packages (from pandas->openmim) (1.21.6)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->openmim) (2022.2.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas->openmim) (1.15.0)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->openmim) (1.24.3)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->openmim) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->openmim) (2022.6.15)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->openmim) (3.0.4)\n", + "Collecting commonmark<0.10.0,>=0.9.0\n", + " Downloading commonmark-0.9.1-py2.py3-none-any.whl (51 kB)\n", + "\u001b[K |████████████████████████████████| 51 kB 6.5 MB/s \n", + "\u001b[?25hRequirement already satisfied: pygments<3.0.0,>=2.6.0 in /usr/local/lib/python3.7/dist-packages (from rich->openmim) (2.6.1)\n", + "Installing collected packages: ordered-set, commonmark, rich, model-index, colorama, openmim\n", + "Successfully installed colorama-0.4.5 commonmark-0.9.1 model-index-0.1.11 openmim-0.3.1 ordered-set-4.1.0 rich-12.5.1\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Looking in links: https://download.openmmlab.com/mmcv/dist/cu111/torch1.10.0/index.html\n", + "Collecting mmengine\n", + " Downloading mmengine-0.1.0-py3-none-any.whl (280 kB)\n", + "\u001b[K |████████████████████████████████| 280 kB 29.0 MB/s \n", + "\u001b[?25hRequirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from mmengine) (3.2.2)\n", + "Collecting addict\n", + " Downloading addict-2.4.0-py3-none-any.whl (3.8 kB)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from mmengine) (1.21.6)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from mmengine) (6.0)\n", + "Collecting yapf\n", + " Downloading yapf-0.32.0-py2.py3-none-any.whl (190 kB)\n", + "\u001b[K |████████████████████████████████| 190 kB 82.8 MB/s \n", + "\u001b[?25hRequirement already satisfied: opencv-python>=3 in /usr/local/lib/python3.7/dist-packages (from mmengine) (4.6.0.66)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.7/dist-packages (from mmengine) (1.1.0)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmengine) (3.0.9)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmengine) (0.11.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmengine) (1.4.4)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmengine) (2.8.2)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib->mmengine) (4.1.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->mmengine) (1.15.0)\n", + "Installing collected packages: yapf, addict, mmengine\n", + "Successfully installed addict-2.4.0 mmengine-0.1.0 yapf-0.32.0\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Looking in links: https://download.openmmlab.com/mmcv/dist/cu111/torch1.10.0/index.html\n", + "Collecting mmcv>=2.0.0rc1\n", + " Downloading https://download.openmmlab.com/mmcv/dist/cu111/torch1.10.0/mmcv-2.0.0rc1-cp37-cp37m-manylinux1_x86_64.whl (47.5 MB)\n", + "\u001b[K |████████████████████████████████| 47.5 MB 11.3 MB/s \n", + "\u001b[?25hRequirement already satisfied: addict in /usr/local/lib/python3.7/dist-packages (from mmcv>=2.0.0rc1) (2.4.0)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from mmcv>=2.0.0rc1) (6.0)\n", + "Requirement already satisfied: yapf in /usr/local/lib/python3.7/dist-packages (from mmcv>=2.0.0rc1) (0.32.0)\n", + "Requirement already satisfied: opencv-python>=3 in /usr/local/lib/python3.7/dist-packages (from mmcv>=2.0.0rc1) (4.6.0.66)\n", + "Requirement already satisfied: mmengine in /usr/local/lib/python3.7/dist-packages (from mmcv>=2.0.0rc1) (0.1.0)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from mmcv>=2.0.0rc1) (21.3)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from mmcv>=2.0.0rc1) (7.1.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from mmcv>=2.0.0rc1) (1.21.6)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.7/dist-packages (from mmengine->mmcv>=2.0.0rc1) (1.1.0)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from mmengine->mmcv>=2.0.0rc1) (3.2.2)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmengine->mmcv>=2.0.0rc1) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmengine->mmcv>=2.0.0rc1) (2.8.2)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmengine->mmcv>=2.0.0rc1) (3.0.9)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmengine->mmcv>=2.0.0rc1) (1.4.4)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib->mmengine->mmcv>=2.0.0rc1) (4.1.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->mmengine->mmcv>=2.0.0rc1) (1.15.0)\n", + "Installing collected packages: mmcv\n", + "Successfully installed mmcv-2.0.0rc1\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Looking in links: https://download.openmmlab.com/mmcv/dist/cu111/torch1.10.0/index.html\n", + "Collecting mmdet>=3.0.0rc0\n", + " Downloading mmdet-3.0.0rc0-py3-none-any.whl (1.5 MB)\n", + "\u001b[K |████████████████████████████████| 1.5 MB 27.0 MB/s \n", + "\u001b[?25hLooking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting mmdet==3.0.0rc0\n", + " Downloading mmdet-3.0.0rc0.tar.gz (810 kB)\n", + "\u001b[K |████████████████████████████████| 810 kB 27.2 MB/s \n", + "\u001b[?25hSaved /tmp/tmp92449vla/mmdet-3.0.0rc0.tar.gz\n", + "Successfully downloaded mmdet\n", + "\u001b[33mGet 'mim' extra requirements from `mminstall.txt` for mmdet 3.0.0rc0: ['mmcv<2.1.0,>=2.0.0rc1', 'mmengine'].\u001b[0m\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from mmdet>=3.0.0rc0) (3.2.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from mmdet>=3.0.0rc0) (1.21.6)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from mmdet>=3.0.0rc0) (1.15.0)\n", + "Requirement already satisfied: pycocotools in /usr/local/lib/python3.7/dist-packages (from mmdet>=3.0.0rc0) (2.0.4)\n", + "Collecting terminaltables\n", + " Downloading terminaltables-3.1.10-py2.py3-none-any.whl (15 kB)\n", + "Requirement already satisfied: mmcv<2.1.0,>=2.0.0rc1 in /usr/local/lib/python3.7/dist-packages (from mmdet>=3.0.0rc0) (2.0.0rc1)\n", + "Requirement already satisfied: mmengine in /usr/local/lib/python3.7/dist-packages (from mmdet>=3.0.0rc0) (0.1.0)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from mmcv<2.1.0,>=2.0.0rc1->mmdet>=3.0.0rc0) (21.3)\n", + "Requirement already satisfied: addict in /usr/local/lib/python3.7/dist-packages (from mmcv<2.1.0,>=2.0.0rc1->mmdet>=3.0.0rc0) (2.4.0)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from mmcv<2.1.0,>=2.0.0rc1->mmdet>=3.0.0rc0) (7.1.2)\n", + "Requirement already satisfied: opencv-python>=3 in /usr/local/lib/python3.7/dist-packages (from mmcv<2.1.0,>=2.0.0rc1->mmdet>=3.0.0rc0) (4.6.0.66)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from mmcv<2.1.0,>=2.0.0rc1->mmdet>=3.0.0rc0) (6.0)\n", + "Requirement already satisfied: yapf in /usr/local/lib/python3.7/dist-packages (from mmcv<2.1.0,>=2.0.0rc1->mmdet>=3.0.0rc0) (0.32.0)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmdet>=3.0.0rc0) (3.0.9)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmdet>=3.0.0rc0) (1.4.4)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmdet>=3.0.0rc0) (2.8.2)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmdet>=3.0.0rc0) (0.11.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib->mmdet>=3.0.0rc0) (4.1.1)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.7/dist-packages (from mmengine->mmdet>=3.0.0rc0) (1.1.0)\n", + "\u001b[33mUsing cached `mminstall.txt` for mmdet==3.0.0rc0: /root/.cache/mim/mminstall/mmdet==3.0.0rc0.txt\u001b[0m\n", + "\u001b[33mGet 'mim' extra requirements from `mminstall.txt` for mmdet 3.0.0rc0: ['mmcv<2.1.0,>=2.0.0rc1', 'mmengine'].\u001b[0m\n", + "Installing collected packages: terminaltables, mmdet\n", + "Successfully installed mmdet-3.0.0rc0 terminaltables-3.1.10\n" + ] + } + ], + "source": [ + "# install dependencies: (use cu111 because colab has CUDA 11.1)\n", + "%pip install torch==1.10.0+cu111 torchvision==0.11.0+cu111 -f https://download.pytorch.org/whl/torch_stable.html\n", + "\n", + "# install MMEngine, MMCV and MMDetection using MIM\n", + "%pip install -U openmim\n", + "!mim install mmengine\n", + "!mim install \"mmcv>=2.0.0rc1\"\n", + "!mim install \"mmdet>=3.0.0rc0\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lzuSKOjMvJZu", + "outputId": "97f7e562-a645-4457-a042-46f4fcf6a93f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cloning into 'mmpose'...\n", + "remote: Enumerating objects: 21717, done.\u001b[K\n", + "remote: Counting objects: 100% (773/773), done.\u001b[K\n", + "remote: Compressing objects: 100% (492/492), done.\u001b[K\n", + "remote: Total 21717 (delta 451), reused 482 (delta 259), pack-reused 20944\u001b[K\n", + "Receiving objects: 100% (21717/21717), 25.74 MiB | 37.98 MiB/s, done.\n", + "Resolving deltas: 100% (15347/15347), done.\n", + "/content/mmpose\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Ignoring dataclasses: markers 'python_version == \"3.6\"' don't match your environment\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from -r requirements/build.txt (line 2)) (1.21.6)\n", + "Requirement already satisfied: torch>=1.6 in /usr/local/lib/python3.7/dist-packages (from -r requirements/build.txt (line 3)) (1.10.0+cu111)\n", + "Collecting chumpy\n", + " Downloading chumpy-0.70.tar.gz (50 kB)\n", + "\u001b[K |████████████████████████████████| 50 kB 2.7 MB/s \n", + "\u001b[?25hCollecting json_tricks\n", + " Downloading json_tricks-3.15.5-py2.py3-none-any.whl (26 kB)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from -r requirements/runtime.txt (line 4)) (3.2.2)\n", + "Collecting munkres\n", + " Downloading munkres-1.1.4-py2.py3-none-any.whl (7.0 kB)\n", + "Requirement already satisfied: opencv-python in /usr/local/lib/python3.7/dist-packages (from -r requirements/runtime.txt (line 7)) (4.6.0.66)\n", + "Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from -r requirements/runtime.txt (line 8)) (7.1.2)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from -r requirements/runtime.txt (line 9)) (1.7.3)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from -r requirements/runtime.txt (line 10)) (0.11.0+cu111)\n", + "Collecting xtcocotools>=1.12\n", + " Downloading xtcocotools-1.12-cp37-cp37m-manylinux1_x86_64.whl (276 kB)\n", + "\u001b[K |████████████████████████████████| 276 kB 31.0 MB/s \n", + "\u001b[?25hCollecting coverage\n", + " Downloading coverage-6.4.4-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (209 kB)\n", + "\u001b[K |████████████████████████████████| 209 kB 69.7 MB/s \n", + "\u001b[?25hCollecting flake8\n", + " Downloading flake8-5.0.4-py2.py3-none-any.whl (61 kB)\n", + "\u001b[K |████████████████████████████████| 61 kB 392 kB/s \n", + "\u001b[?25hCollecting interrogate\n", + " Downloading interrogate-1.5.0-py3-none-any.whl (45 kB)\n", + "\u001b[K |████████████████████████████████| 45 kB 3.0 MB/s \n", + "\u001b[?25hCollecting isort==4.3.21\n", + " Downloading isort-4.3.21-py2.py3-none-any.whl (42 kB)\n", + "\u001b[K |████████████████████████████████| 42 kB 876 kB/s \n", + "\u001b[?25hCollecting parameterized\n", + " Downloading parameterized-0.8.1-py2.py3-none-any.whl (26 kB)\n", + "Requirement already satisfied: pytest in /usr/local/lib/python3.7/dist-packages (from -r requirements/tests.txt (line 6)) (3.6.4)\n", + "Collecting pytest-runner\n", + " Downloading pytest_runner-6.0.0-py3-none-any.whl (7.2 kB)\n", + "Collecting xdoctest>=0.10.0\n", + " Downloading xdoctest-1.1.0-py3-none-any.whl (135 kB)\n", + "\u001b[K |████████████████████████████████| 135 kB 43.8 MB/s \n", + "\u001b[?25hRequirement already satisfied: yapf in /usr/local/lib/python3.7/dist-packages (from -r requirements/tests.txt (line 9)) (0.32.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from -r requirements/optional.txt (line 1)) (2.23.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=1.6->-r requirements/build.txt (line 3)) (4.1.1)\n", + "Requirement already satisfied: setuptools>=18.0 in /usr/local/lib/python3.7/dist-packages (from xtcocotools>=1.12->-r requirements/runtime.txt (line 11)) (57.4.0)\n", + "Requirement already satisfied: cython>=0.27.3 in /usr/local/lib/python3.7/dist-packages (from xtcocotools>=1.12->-r requirements/runtime.txt (line 11)) (0.29.32)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->-r requirements/runtime.txt (line 4)) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->-r requirements/runtime.txt (line 4)) (2.8.2)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->-r requirements/runtime.txt (line 4)) (3.0.9)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->-r requirements/runtime.txt (line 4)) (1.4.4)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from xdoctest>=0.10.0->-r requirements/tests.txt (line 8)) (1.15.0)\n", + "Collecting pycodestyle<2.10.0,>=2.9.0\n", + " Downloading pycodestyle-2.9.1-py2.py3-none-any.whl (41 kB)\n", + "\u001b[K |████████████████████████████████| 41 kB 379 kB/s \n", + "\u001b[?25hCollecting pyflakes<2.6.0,>=2.5.0\n", + " Downloading pyflakes-2.5.0-py2.py3-none-any.whl (66 kB)\n", + "\u001b[K |████████████████████████████████| 66 kB 3.1 MB/s \n", + "\u001b[?25hCollecting importlib-metadata<4.3,>=1.1.0\n", + " Downloading importlib_metadata-4.2.0-py3-none-any.whl (16 kB)\n", + "Collecting mccabe<0.8.0,>=0.7.0\n", + " Downloading mccabe-0.7.0-py2.py3-none-any.whl (7.3 kB)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata<4.3,>=1.1.0->flake8->-r requirements/tests.txt (line 2)) (3.8.1)\n", + "Requirement already satisfied: tabulate in /usr/local/lib/python3.7/dist-packages (from interrogate->-r requirements/tests.txt (line 3)) (0.8.10)\n", + "Requirement already satisfied: colorama in /usr/local/lib/python3.7/dist-packages (from interrogate->-r requirements/tests.txt (line 3)) (0.4.5)\n", + "Requirement already satisfied: py in /usr/local/lib/python3.7/dist-packages (from interrogate->-r requirements/tests.txt (line 3)) (1.11.0)\n", + "Requirement already satisfied: attrs in /usr/local/lib/python3.7/dist-packages (from interrogate->-r requirements/tests.txt (line 3)) (22.1.0)\n", + "Requirement already satisfied: click>=7.1 in /usr/local/lib/python3.7/dist-packages (from interrogate->-r requirements/tests.txt (line 3)) (7.1.2)\n", + "Requirement already satisfied: toml in /usr/local/lib/python3.7/dist-packages (from interrogate->-r requirements/tests.txt (line 3)) (0.10.2)\n", + "Requirement already satisfied: pluggy<0.8,>=0.5 in /usr/local/lib/python3.7/dist-packages (from pytest->-r requirements/tests.txt (line 6)) (0.7.1)\n", + "Requirement already satisfied: atomicwrites>=1.0 in /usr/local/lib/python3.7/dist-packages (from pytest->-r requirements/tests.txt (line 6)) (1.4.1)\n", + "Requirement already satisfied: more-itertools>=4.0.0 in /usr/local/lib/python3.7/dist-packages (from pytest->-r requirements/tests.txt (line 6)) (8.14.0)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->-r requirements/optional.txt (line 1)) (3.0.4)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->-r requirements/optional.txt (line 1)) (2022.6.15)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->-r requirements/optional.txt (line 1)) (2.10)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->-r requirements/optional.txt (line 1)) (1.24.3)\n", + "Building wheels for collected packages: chumpy\n", + " Building wheel for chumpy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for chumpy: filename=chumpy-0.70-py3-none-any.whl size=58285 sha256=1f1b6753e54dfbc86e01aba0f525a7d5771d73387934b07d29505242475908a1\n", + " Stored in directory: /root/.cache/pip/wheels/59/68/de/5e0c5d77e573e8c150e69e07a25035e6b6a04952d6e1814dbc\n", + "Successfully built chumpy\n", + "Installing collected packages: pyflakes, pycodestyle, mccabe, importlib-metadata, xtcocotools, xdoctest, pytest-runner, parameterized, munkres, json-tricks, isort, interrogate, flake8, coverage, chumpy\n", + " Attempting uninstall: importlib-metadata\n", + " Found existing installation: importlib-metadata 4.12.0\n", + " Uninstalling importlib-metadata-4.12.0:\n", + " Successfully uninstalled importlib-metadata-4.12.0\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "markdown 3.4.1 requires importlib-metadata>=4.4; python_version < \"3.10\", but you have importlib-metadata 4.2.0 which is incompatible.\n", + "gym 0.25.2 requires importlib-metadata>=4.8.0; python_version < \"3.10\", but you have importlib-metadata 4.2.0 which is incompatible.\u001b[0m\n", + "Successfully installed chumpy-0.70 coverage-6.4.4 flake8-5.0.4 importlib-metadata-4.2.0 interrogate-1.5.0 isort-4.3.21 json-tricks-3.15.5 mccabe-0.7.0 munkres-1.1.4 parameterized-0.8.1 pycodestyle-2.9.1 pyflakes-2.5.0 pytest-runner-6.0.0 xdoctest-1.1.0 xtcocotools-1.12\n", + "Using pip 21.1.3 from /usr/local/lib/python3.7/dist-packages/pip (python 3.7)\n", + "Value for scheme.platlib does not match. Please report this to \n", + "distutils: /usr/local/lib/python3.7/dist-packages\n", + "sysconfig: /usr/lib/python3.7/site-packages\n", + "Value for scheme.purelib does not match. Please report this to \n", + "distutils: /usr/local/lib/python3.7/dist-packages\n", + "sysconfig: /usr/lib/python3.7/site-packages\n", + "Value for scheme.headers does not match. Please report this to \n", + "distutils: /usr/local/include/python3.7/UNKNOWN\n", + "sysconfig: /usr/include/python3.7m/UNKNOWN\n", + "Value for scheme.scripts does not match. Please report this to \n", + "distutils: /usr/local/bin\n", + "sysconfig: /usr/bin\n", + "Value for scheme.data does not match. Please report this to \n", + "distutils: /usr/local\n", + "sysconfig: /usr\n", + "Additional context:\n", + "user = False\n", + "home = None\n", + "root = None\n", + "prefix = None\n", + "Non-user install because site-packages writeable\n", + "Created temporary directory: /tmp/pip-ephem-wheel-cache-6spdtpz_\n", + "Created temporary directory: /tmp/pip-req-tracker-pdrld3yb\n", + "Initialized build tracking at /tmp/pip-req-tracker-pdrld3yb\n", + "Created build tracker: /tmp/pip-req-tracker-pdrld3yb\n", + "Entered build tracker: /tmp/pip-req-tracker-pdrld3yb\n", + "Created temporary directory: /tmp/pip-install-llx1o5zd\n", + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Obtaining file:///content/mmpose\n", + " Added file:///content/mmpose to build tracker '/tmp/pip-req-tracker-pdrld3yb'\n", + " Running setup.py (path:/content/mmpose/setup.py) egg_info for package from file:///content/mmpose\n", + " Created temporary directory: /tmp/pip-pip-egg-info-e9ps6kvl\n", + " Running command python setup.py egg_info\n", + " running egg_info\n", + " creating /tmp/pip-pip-egg-info-e9ps6kvl/mmpose.egg-info\n", + " writing /tmp/pip-pip-egg-info-e9ps6kvl/mmpose.egg-info/PKG-INFO\n", + " writing dependency_links to /tmp/pip-pip-egg-info-e9ps6kvl/mmpose.egg-info/dependency_links.txt\n", + " writing requirements to /tmp/pip-pip-egg-info-e9ps6kvl/mmpose.egg-info/requires.txt\n", + " writing top-level names to /tmp/pip-pip-egg-info-e9ps6kvl/mmpose.egg-info/top_level.txt\n", + " writing manifest file '/tmp/pip-pip-egg-info-e9ps6kvl/mmpose.egg-info/SOURCES.txt'\n", + " reading manifest template 'MANIFEST.in'\n", + " warning: no files found matching 'mmpose/.mim/model-index.yml'\n", + " warning: no files found matching '*.py' under directory 'mmpose/.mim/configs'\n", + " warning: no files found matching '*.yml' under directory 'mmpose/.mim/configs'\n", + " warning: no files found matching '*.py' under directory 'mmpose/.mim/tools'\n", + " warning: no files found matching '*.sh' under directory 'mmpose/.mim/tools'\n", + " warning: no files found matching '*.py' under directory 'mmpose/.mim/demo'\n", + " adding license file 'LICENSE'\n", + " writing manifest file '/tmp/pip-pip-egg-info-e9ps6kvl/mmpose.egg-info/SOURCES.txt'\n", + " Source in /content/mmpose has version 1.0.0b0, which satisfies requirement mmpose==1.0.0b0 from file:///content/mmpose\n", + " Removed mmpose==1.0.0b0 from file:///content/mmpose from build tracker '/tmp/pip-req-tracker-pdrld3yb'\n", + "Requirement already satisfied: chumpy in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (0.70)\n", + "Requirement already satisfied: json_tricks in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (3.15.5)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (3.2.2)\n", + "Requirement already satisfied: munkres in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (1.1.4)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (1.21.6)\n", + "Requirement already satisfied: opencv-python in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (4.6.0.66)\n", + "Requirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (7.1.2)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (1.7.3)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (0.11.0+cu111)\n", + "Requirement already satisfied: xtcocotools>=1.12 in /usr/local/lib/python3.7/dist-packages (from mmpose==1.0.0b0) (1.12)\n", + "Requirement already satisfied: cython>=0.27.3 in /usr/local/lib/python3.7/dist-packages (from xtcocotools>=1.12->mmpose==1.0.0b0) (0.29.32)\n", + "Requirement already satisfied: setuptools>=18.0 in /usr/local/lib/python3.7/dist-packages (from xtcocotools>=1.12->mmpose==1.0.0b0) (57.4.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmpose==1.0.0b0) (0.11.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmpose==1.0.0b0) (1.4.4)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmpose==1.0.0b0) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->mmpose==1.0.0b0) (2.8.2)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib->mmpose==1.0.0b0) (4.1.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->mmpose==1.0.0b0) (1.15.0)\n", + "Requirement already satisfied: torch==1.10.0+cu111 in /usr/local/lib/python3.7/dist-packages (from torchvision->mmpose==1.0.0b0) (1.10.0+cu111)\n", + "Created temporary directory: /tmp/pip-unpack-tkpwtsgw\n", + "Installing collected packages: mmpose\n", + " Value for scheme.platlib does not match. Please report this to \n", + " distutils: /usr/local/lib/python3.7/dist-packages\n", + " sysconfig: /usr/lib/python3.7/site-packages\n", + " Value for scheme.purelib does not match. Please report this to \n", + " distutils: /usr/local/lib/python3.7/dist-packages\n", + " sysconfig: /usr/lib/python3.7/site-packages\n", + " Value for scheme.headers does not match. Please report this to \n", + " distutils: /usr/local/include/python3.7/mmpose\n", + " sysconfig: /usr/include/python3.7m/mmpose\n", + " Value for scheme.scripts does not match. Please report this to \n", + " distutils: /usr/local/bin\n", + " sysconfig: /usr/bin\n", + " Value for scheme.data does not match. Please report this to \n", + " distutils: /usr/local\n", + " sysconfig: /usr\n", + " Additional context:\n", + " user = False\n", + " home = None\n", + " root = None\n", + " prefix = None\n", + " Running setup.py develop for mmpose\n", + " Running command /usr/bin/python3 -c 'import io, os, sys, setuptools, tokenize; sys.argv[0] = '\"'\"'/content/mmpose/setup.py'\"'\"'; __file__='\"'\"'/content/mmpose/setup.py'\"'\"';f = getattr(tokenize, '\"'\"'open'\"'\"', open)(__file__) if os.path.exists(__file__) else io.StringIO('\"'\"'from setuptools import setup; setup()'\"'\"');code = f.read().replace('\"'\"'\\r\\n'\"'\"', '\"'\"'\\n'\"'\"');f.close();exec(compile(code, __file__, '\"'\"'exec'\"'\"'))' develop --no-deps\n", + " running develop\n", + " running egg_info\n", + " creating mmpose.egg-info\n", + " writing mmpose.egg-info/PKG-INFO\n", + " writing dependency_links to mmpose.egg-info/dependency_links.txt\n", + " writing requirements to mmpose.egg-info/requires.txt\n", + " writing top-level names to mmpose.egg-info/top_level.txt\n", + " writing manifest file 'mmpose.egg-info/SOURCES.txt'\n", + " reading manifest template 'MANIFEST.in'\n", + " warning: no files found matching '*.yml' under directory 'mmpose/.mim/configs'\n", + " adding license file 'LICENSE'\n", + " writing manifest file 'mmpose.egg-info/SOURCES.txt'\n", + " running build_ext\n", + " Creating /usr/local/lib/python3.7/dist-packages/mmpose.egg-link (link to .)\n", + " Adding mmpose 1.0.0b0 to easy-install.pth file\n", + "\n", + " Installed /content/mmpose\n", + "Value for scheme.platlib does not match. Please report this to \n", + "distutils: /usr/local/lib/python3.7/dist-packages\n", + "sysconfig: /usr/lib/python3.7/site-packages\n", + "Value for scheme.purelib does not match. Please report this to \n", + "distutils: /usr/local/lib/python3.7/dist-packages\n", + "sysconfig: /usr/lib/python3.7/site-packages\n", + "Value for scheme.headers does not match. Please report this to \n", + "distutils: /usr/local/include/python3.7/UNKNOWN\n", + "sysconfig: /usr/include/python3.7m/UNKNOWN\n", + "Value for scheme.scripts does not match. Please report this to \n", + "distutils: /usr/local/bin\n", + "sysconfig: /usr/bin\n", + "Value for scheme.data does not match. Please report this to \n", + "distutils: /usr/local\n", + "sysconfig: /usr\n", + "Additional context:\n", + "user = False\n", + "home = None\n", + "root = None\n", + "prefix = None\n", + "Successfully installed mmpose-1.0.0b0\n", + "Removed build tracker: '/tmp/pip-req-tracker-pdrld3yb'\n" + ] + } + ], + "source": [ + "!git clone https://github.com/open-mmlab/mmpose.git -b 1.x\n", + "# \"-b 1.x\" means checkout to the `1.x` branch.\n", + "%cd mmpose\n", + "%pip install -r requirements.txt\n", + "%pip install -v -e .\n", + "# \"-v\" means verbose, or more output\n", + "# \"-e\" means installing a project in editable mode,\n", + "# thus any local modifications made to the code will take effect without reinstallation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Miy2zVRcw6kL", + "outputId": "7cd77092-31ab-49f6-a0bd-1749db488164" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch version: 1.10.0+cu111 False\n", + "torchvision version: 0.11.0+cu111\n", + "mmpose version: 1.0.0b0\n", + "No CUDA runtime is found, using CUDA_HOME='/usr/local/cuda'\n", + "cuda version: 11.1\n", + "compiler information: GCC 7.3\n" + ] + } + ], + "source": [ + "# Check Pytorch installation\n", + "import torch, torchvision\n", + "\n", + "print('torch version:', torch.__version__, torch.cuda.is_available())\n", + "print('torchvision version:', torchvision.__version__)\n", + "\n", + "# Check MMPose installation\n", + "import mmpose\n", + "\n", + "print('mmpose version:', mmpose.__version__)\n", + "\n", + "# Check mmcv installation\n", + "from mmcv.ops import get_compiling_cuda_version, get_compiler_version\n", + "\n", + "print('cuda version:', get_compiling_cuda_version())\n", + "print('compiler information:', get_compiler_version())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r2bf94XpyFnk" + }, + "source": [ + "## Inference with an MMPose model\n", + "\n", + "MMPose provides high-level APIs for model inference and training." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 643, + "referenced_widgets": [ + "13ac80b3ee9d4ce1bc1405a3d69c3c73", + "7abbd13654ff480183deb3d71dddf3e0", + "59c9f043983849e19df8cc2f4253b04a", + "990e4db4f7824bc994eff6ef91d4675b", + "d227d12439aa449cb267f393e43a1eff", + "21afdf2781cd45c3b541a769bfca494b", + "305bb5675d1a4a71ae47614db0c96b67", + "c06dc4651af24be3ba658102043658f9", + "7811af5efbc34360b06eb795ff9e7a6c", + "214f964729e140d5b8ab6ca5f342d416", + "6674d0f99ac94805840a1f7a216606c8" + ] + }, + "id": "JjTt4LZAx_lK", + "outputId": "5b1af791-bd17-44bc-c7ac-2e36fa18eb53" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "http loads checkpoint from path: https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth\n", + "http loads checkpoint from path: https://download.openmmlab.com/mmpose/top_down/hrnet/hrnet_w32_coco_256x192-c78dce93_20200708.pth\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/PJLAB/jiangtao/Documents/git-clone/mmengine/mmengine/visualization/visualizer.py:170: UserWarning: `Visualizer` backend is not initialized because save_dir is None.\n", + " warnings.warn('`Visualizer` backend is not initialized '\n" + ] + } + ], + "source": [ + "import mmcv\n", + "from mmcv import imread\n", + "import mmengine\n", + "import numpy as np\n", + "\n", + "from mmpose.apis import inference_topdown\n", + "from mmpose.apis import init_model as init_pose_estimator\n", + "from mmpose.evaluation.functional import nms\n", + "from mmpose.registry import VISUALIZERS\n", + "from mmpose.structures import merge_data_samples\n", + "from mmpose.utils import register_all_modules as register_mmpose_modules\n", + "\n", + "try:\n", + " from mmdet.apis import inference_detector, init_detector\n", + " from mmdet.utils import register_all_modules as register_mmdet_modules\n", + " has_mmdet = True\n", + "except (ImportError, ModuleNotFoundError):\n", + " has_mmdet = False\n", + "\n", + "local_runtime = False\n", + "\n", + "try:\n", + " from google.colab.patches import cv2_imshow # for image visualization in colab\n", + "except:\n", + " local_runtime = True\n", + "\n", + "img = 'tests/data/coco/000000197388.jpg'\n", + "pose_config = 'configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192.py'\n", + "pose_checkpoint = 'https://download.openmmlab.com/mmpose/top_down/hrnet/hrnet_w32_coco_256x192-c78dce93_20200708.pth'\n", + "det_config = 'demo/mmdetection_cfg/faster_rcnn_r50_fpn_coco.py'\n", + "det_checkpoint = 'https://download.openmmlab.com/mmdetection/v2.0/faster_rcnn/faster_rcnn_r50_fpn_1x_coco/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth'\n", + "\n", + "device = 'cuda:0'\n", + "cfg_options = dict(model=dict(test_cfg=dict(output_heatmaps=True)))\n", + "\n", + "\n", + "# build detector\n", + "register_mmdet_modules()\n", + "detector = init_detector(\n", + " det_config,\n", + " det_checkpoint,\n", + " device=device\n", + ")\n", + "\n", + "\n", + "# build pose estimator\n", + "register_mmpose_modules()\n", + "pose_estimator = init_pose_estimator(\n", + " pose_config,\n", + " pose_checkpoint,\n", + " device=device,\n", + " cfg_options=cfg_options\n", + ")\n", + "\n", + "# init visualizer\n", + "pose_estimator.cfg.visualizer.radius = 3\n", + "pose_estimator.cfg.visualizer.line_width = 1\n", + "visualizer = VISUALIZERS.build(pose_estimator.cfg.visualizer)\n", + "# the dataset_meta is loaded from the checkpoint and\n", + "# then pass to the model in init_pose_estimator\n", + "visualizer.set_dataset_meta(pose_estimator.dataset_meta)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "tsSM0NRPEG1Z" + }, + "outputs": [], + "source": [ + "\n", + "def visualize_img(img_path, detector, pose_estimator, visualizer,\n", + " show_interval, out_file):\n", + " \"\"\"Visualize predicted keypoints (and heatmaps) of one image.\"\"\"\n", + "\n", + " # predict bbox\n", + " register_mmdet_modules()\n", + " detect_result = inference_detector(detector, img_path)\n", + " pred_instance = detect_result.pred_instances.cpu().numpy()\n", + " bboxes = np.concatenate(\n", + " (pred_instance.bboxes, pred_instance.scores[:, None]), axis=1)\n", + " bboxes = bboxes[np.logical_and(pred_instance.labels == 0,\n", + " pred_instance.scores > 0.3)]\n", + " bboxes = bboxes[nms(bboxes, 0.3)][:, :4]\n", + "\n", + " # predict keypoints\n", + " register_mmpose_modules()\n", + " pose_results = inference_topdown(pose_estimator, img_path, bboxes)\n", + " data_samples = merge_data_samples(pose_results)\n", + "\n", + " # show the results\n", + " img = mmcv.imread(img_path)\n", + " img = mmcv.imconvert(img, 'bgr', 'rgb')\n", + "\n", + " visualizer.add_datasample(\n", + " 'result',\n", + " img,\n", + " data_sample=data_samples,\n", + " draw_gt=False,\n", + " draw_heatmap=True,\n", + " draw_bbox=True,\n", + " show=False,\n", + " wait_time=show_interval,\n", + " out_file=out_file,\n", + " kpt_score_thr=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ogj5h9x-HiMA", + "outputId": "3a32c96c-6ba4-41bf-c006-49152054bbf7" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/PJLAB/jiangtao/anaconda3/envs/pt19cu113/lib/python3.7/site-packages/mmdet/utils/setup_env.py:83: UserWarning: The current default scope \"mmpose\" is not \"mmdet\", `register_all_modules` will force the currentdefault scope to be \"mmdet\". If this is not expected, please set `init_default_scope=False`.\n", + " warnings.warn('The current default scope '\n", + "/home/PJLAB/jiangtao/Documents/git-clone/mmpose/mmpose/utils/setup_env.py:79: UserWarning: The current default scope \"mmdet\" is not \"mmpose\", `register_all_modules` will force the currentdefault scope to be \"mmpose\". If this is not expected, please set `init_default_scope=False`.\n", + " warnings.warn('The current default scope '\n", + "/home/PJLAB/jiangtao/Documents/git-clone/mmengine/mmengine/visualization/visualizer.py:632: UserWarning: Warning: The circle is out of bounds, the drawn circle may not be in the image\n", + " ' the drawn circle may not be in the image', UserWarning)\n", + "/home/PJLAB/jiangtao/Documents/git-clone/mmengine/mmengine/visualization/visualizer.py:709: UserWarning: Warning: The bbox is out of bounds, the drawn bbox may not be in the image\n", + " ' the drawn bbox may not be in the image', UserWarning)\n", + "/home/PJLAB/jiangtao/Documents/git-clone/mmengine/mmengine/visualization/visualizer.py:779: UserWarning: Warning: The polygon is out of bounds, the drawn polygon may not be in the image\n", + " ' the drawn polygon may not be in the image', UserWarning)\n" + ] + } + ], + "source": [ + "visualize_img(\n", + " img,\n", + " detector,\n", + " pose_estimator,\n", + " visualizer,\n", + " show_interval=0,\n", + " out_file=None)\n", + "\n", + "vis_result = visualizer.get_image()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 954 + }, + "id": "CEYxupWT3aJY", + "outputId": "9e131e02-453c-4a4c-fe83-731b28e3d8ef" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if local_runtime:\n", + " from IPython.display import Image, display\n", + " import tempfile\n", + " import os.path as osp\n", + " import cv2\n", + " with tempfile.TemporaryDirectory() as tmpdir:\n", + " file_name = osp.join(tmpdir, 'pose_results.png')\n", + " cv2.imwrite(file_name, vis_result[:,:,::-1])\n", + " display(Image(file_name))\n", + "else:\n", + " cv2_imshow(vis_result)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "42HG6DSNI0Ke" + }, + "source": [ + "### Add a new dataset\n", + "\n", + "There are two methods to support a customized dataset in MMPose. The first one is to convert the data to a supported format (e.g. COCO) and use the corresponding dataset class (e.g. BaseCocoStyleDataset), as described in the [document](https://mmpose.readthedocs.io/en/1.x/user_guides/prepare_datasets.html). The second one is to add a new dataset class. In this tutorial, we give an example of the second method.\n", + "\n", + "We first download the demo dataset, which contains 100 samples (75 for training and 25 for validation) selected from COCO train2017 dataset. The annotations are stored in a different format from the original COCO format.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qGzSb0Rm-p3V", + "outputId": "2e7ec2ba-88e1-490f-cd5a-66ef06ec3e52" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/content/mmpose/data\n", + "--2022-09-14 10:39:37-- https://download.openmmlab.com/mmpose/datasets/coco_tiny.tar\n", + "Resolving download.openmmlab.com (download.openmmlab.com)... 47.89.140.71\n", + "Connecting to download.openmmlab.com (download.openmmlab.com)|47.89.140.71|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 16558080 (16M) [application/x-tar]\n", + "Saving to: ‘coco_tiny.tar’\n", + "\n", + "coco_tiny.tar 100%[===================>] 15.79M 9.14MB/s in 1.7s \n", + "\n", + "2022-09-14 10:39:40 (9.14 MB/s) - ‘coco_tiny.tar’ saved [16558080/16558080]\n", + "\n", + "/content/mmpose\n" + ] + } + ], + "source": [ + "# download dataset\n", + "%mkdir data\n", + "%cd data\n", + "!wget https://download.openmmlab.com/mmpose/datasets/coco_tiny.tar\n", + "!tar -xf coco_tiny.tar\n", + "%cd .." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fL6S62JWJls0", + "outputId": "fe4cf7c9-5a8c-4542-f0b1-fe01908ca3e4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading package lists...\n", + "Building dependency tree...\n", + "Reading state information...\n", + "The following package was automatically installed and is no longer required:\n", + " libnvidia-common-460\n", + "Use 'apt autoremove' to remove it.\n", + "The following NEW packages will be installed:\n", + " tree\n", + "0 upgraded, 1 newly installed, 0 to remove and 32 not upgraded.\n", + "Need to get 40.7 kB of archives.\n", + "After this operation, 105 kB of additional disk space will be used.\n", + "Get:1 http://archive.ubuntu.com/ubuntu bionic/universe amd64 tree amd64 1.7.0-5 [40.7 kB]\n", + "Fetched 40.7 kB in 0s (161 kB/s)\n", + "Selecting previously unselected package tree.\n", + "(Reading database ... 155685 files and directories currently installed.)\n", + "Preparing to unpack .../tree_1.7.0-5_amd64.deb ...\n", + "Unpacking tree (1.7.0-5) ...\n", + "Setting up tree (1.7.0-5) ...\n", + "Processing triggers for man-db (2.8.3-2ubuntu0.1) ...\n", + "data/coco_tiny\n", + "├── images\n", + "│   ├── 000000012754.jpg\n", + "│   ├── 000000017741.jpg\n", + "│   ├── 000000019157.jpg\n", + "│   ├── 000000019523.jpg\n", + "│   ├── 000000019608.jpg\n", + "│   ├── 000000022816.jpg\n", + "│   ├── 000000031092.jpg\n", + "│   ├── 000000032124.jpg\n", + "│   ├── 000000037209.jpg\n", + "│   ├── 000000050713.jpg\n", + "│   ├── 000000057703.jpg\n", + "│   ├── 000000064909.jpg\n", + "│   ├── 000000076942.jpg\n", + "│   ├── 000000079754.jpg\n", + "│   ├── 000000083935.jpg\n", + "│   ├── 000000085316.jpg\n", + "│   ├── 000000101013.jpg\n", + "│   ├── 000000101172.jpg\n", + "│   ├── 000000103134.jpg\n", + "│   ├── 000000103163.jpg\n", + "│   ├── 000000105647.jpg\n", + "│   ├── 000000107960.jpg\n", + "│   ├── 000000117891.jpg\n", + "│   ├── 000000118181.jpg\n", + "│   ├── 000000120021.jpg\n", + "│   ├── 000000128119.jpg\n", + "│   ├── 000000143908.jpg\n", + "│   ├── 000000145025.jpg\n", + "│   ├── 000000147386.jpg\n", + "│   ├── 000000147979.jpg\n", + "│   ├── 000000154222.jpg\n", + "│   ├── 000000160190.jpg\n", + "│   ├── 000000161112.jpg\n", + "│   ├── 000000175737.jpg\n", + "│   ├── 000000177069.jpg\n", + "│   ├── 000000184659.jpg\n", + "│   ├── 000000209468.jpg\n", + "│   ├── 000000210060.jpg\n", + "│   ├── 000000215867.jpg\n", + "│   ├── 000000216861.jpg\n", + "│   ├── 000000227224.jpg\n", + "│   ├── 000000246265.jpg\n", + "│   ├── 000000254919.jpg\n", + "│   ├── 000000263687.jpg\n", + "│   ├── 000000264628.jpg\n", + "│   ├── 000000268927.jpg\n", + "│   ├── 000000271177.jpg\n", + "│   ├── 000000275219.jpg\n", + "│   ├── 000000277542.jpg\n", + "│   ├── 000000279140.jpg\n", + "│   ├── 000000286813.jpg\n", + "│   ├── 000000297980.jpg\n", + "│   ├── 000000301641.jpg\n", + "│   ├── 000000312341.jpg\n", + "│   ├── 000000325768.jpg\n", + "│   ├── 000000332221.jpg\n", + "│   ├── 000000345071.jpg\n", + "│   ├── 000000346965.jpg\n", + "│   ├── 000000347836.jpg\n", + "│   ├── 000000349437.jpg\n", + "│   ├── 000000360735.jpg\n", + "│   ├── 000000362343.jpg\n", + "│   ├── 000000364079.jpg\n", + "│   ├── 000000364113.jpg\n", + "│   ├── 000000386279.jpg\n", + "│   ├── 000000386968.jpg\n", + "│   ├── 000000388619.jpg\n", + "│   ├── 000000390137.jpg\n", + "│   ├── 000000390241.jpg\n", + "│   ├── 000000390298.jpg\n", + "│   ├── 000000390348.jpg\n", + "│   ├── 000000398606.jpg\n", + "│   ├── 000000400456.jpg\n", + "│   ├── 000000402514.jpg\n", + "│   ├── 000000403255.jpg\n", + "│   ├── 000000403432.jpg\n", + "│   ├── 000000410350.jpg\n", + "│   ├── 000000453065.jpg\n", + "│   ├── 000000457254.jpg\n", + "│   ├── 000000464153.jpg\n", + "│   ├── 000000464515.jpg\n", + "│   ├── 000000465418.jpg\n", + "│   ├── 000000480591.jpg\n", + "│   ├── 000000484279.jpg\n", + "│   ├── 000000494014.jpg\n", + "│   ├── 000000515289.jpg\n", + "│   ├── 000000516805.jpg\n", + "│   ├── 000000521994.jpg\n", + "│   ├── 000000528962.jpg\n", + "│   ├── 000000534736.jpg\n", + "│   ├── 000000535588.jpg\n", + "│   ├── 000000537548.jpg\n", + "│   ├── 000000553698.jpg\n", + "│   ├── 000000555622.jpg\n", + "│   ├── 000000566456.jpg\n", + "│   ├── 000000567171.jpg\n", + "│   └── 000000568961.jpg\n", + "├── train.json\n", + "└── val.json\n", + "\n", + "1 directory, 99 files\n" + ] + } + ], + "source": [ + "# check the directory structure\n", + "!apt-get -q install tree\n", + "!tree data/coco_tiny" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Hl09rtA4Jn5b", + "outputId": "e94e84ea-7192-4d2f-9747-716931953d6d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 75\n", + "{'bbox': [267.03, 104.32, 229.19, 320],\n", + " 'image_file': '000000537548.jpg',\n", + " 'image_size': [640, 480],\n", + " 'keypoints': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 325, 160, 2, 398,\n", + " 177, 2, 0, 0, 0, 437, 238, 2, 0, 0, 0, 477, 270, 2, 287, 255, 1,\n", + " 339, 267, 2, 0, 0, 0, 423, 314, 2, 0, 0, 0, 355, 367, 2]}\n" + ] + } + ], + "source": [ + "# check the annotation format\n", + "import json\n", + "import pprint\n", + "\n", + "anns = json.load(open('data/coco_tiny/train.json'))\n", + "\n", + "print(type(anns), len(anns))\n", + "pprint.pprint(anns[0], compact=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H-dMbjgnJzbH" + }, + "source": [ + "After downloading the data, we implement a new dataset class to load data samples for model training and validation. Assume that we are going to train a top-down pose estimation model, the new dataset class inherits `BaseCocoStyleDataset`.\n", + "\n", + "We have already implemented a `CocoDataset` so that we can take it as an example." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jCu4npV2rl_Q" + }, + "source": [ + "#### Note\n", + "If you meet the following error:\n", + "```shell\n", + "AssertionError: class `PoseLocalVisualizer` in mmpose/visualization/local_visualizer.py: instance named of visualizer has been created, the method `get_instance` should not access any other arguments\n", + "```\n", + "Please reboot your jupyter kernel and start running from here." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3I66Pi5Er94J", + "outputId": "5873af68-4090-42bb-e4b2-fe6f94818609" + }, + "outputs": [], + "source": [ + "%cd mmpose" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "rRNq50dytJki" + }, + "outputs": [], + "source": [ + "# Copyright (c) OpenMMLab. All rights reserved.\n", + "import json\n", + "import os.path as osp\n", + "from typing import Callable, List, Optional, Sequence, Union\n", + "\n", + "import numpy as np\n", + "from mmengine.utils import check_file_exist\n", + "\n", + "from mmpose.registry import DATASETS\n", + "from mmpose.datasets.datasets.base import BaseCocoStyleDataset\n", + "\n", + "\n", + "@DATASETS.register_module()\n", + "class TinyCocoDataset(BaseCocoStyleDataset):\n", + " METAINFO: dict = dict(from_file='configs/_base_/datasets/coco.py')\n", + "\n", + " def _load_annotations(self) -> List[dict]:\n", + " \"\"\"Load data from annotations in MPII format.\"\"\"\n", + "\n", + " check_file_exist(self.ann_file)\n", + " with open(self.ann_file) as anno_file:\n", + " anns = json.load(anno_file)\n", + "\n", + " data_list = []\n", + " ann_id = 0\n", + "\n", + " for idx, ann in enumerate(anns):\n", + " img_h, img_w = ann['image_size']\n", + "\n", + " # get bbox in shape [1, 4], formatted as xywh\n", + " x, y, w, h = ann['bbox']\n", + " x1 = np.clip(x, 0, img_w - 1)\n", + " y1 = np.clip(y, 0, img_h - 1)\n", + " x2 = np.clip(x + w, 0, img_w - 1)\n", + " y2 = np.clip(y + h, 0, img_h - 1)\n", + "\n", + " bbox = np.array([x1, y1, x2, y2], dtype=np.float32).reshape(1, 4)\n", + "\n", + " # load keypoints in shape [1, K, 2] and keypoints_visible in [1, K]\n", + " joints_3d = np.array(ann['keypoints']).reshape(1, -1, 3)\n", + " num_joints = joints_3d.shape[1]\n", + " keypoints = np.zeros((1, num_joints, 2), dtype=np.float32)\n", + " keypoints[:, :, :2] = joints_3d[:, :, :2]\n", + " keypoints_visible = np.minimum(1, joints_3d[:, :, 2:3])\n", + " keypoints_visible = keypoints_visible.reshape(1, -1)\n", + "\n", + " data_info = {\n", + " 'id': ann_id,\n", + " 'img_id': int(ann['image_file'].split('.')[0]),\n", + " 'img_path': osp.join(self.data_prefix['img'], ann['image_file']),\n", + " 'bbox': bbox,\n", + " 'bbox_score': np.ones(1, dtype=np.float32),\n", + " 'keypoints': keypoints,\n", + " 'keypoints_visible': keypoints_visible,\n", + " }\n", + "\n", + " data_list.append(data_info)\n", + " ann_id = ann_id + 1\n", + "\n", + " return data_list\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UmGitQZkUnom" + }, + "source": [ + "### Create a config file\n", + "\n", + "In the next step, we create a config file which configures the model, dataset and runtime settings. More information can be found at [Configs](https://mmpose.readthedocs.io/en/1.x/user_guides/configs.html). A common practice to create a config file is deriving from a existing one. In this tutorial, we load a config file that trains a HRNet on COCO dataset, and modify it to adapt to the COCOTiny dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sMbVVHPXK87s", + "outputId": "a23a1ed9-a2ee-4a6a-93da-3c1968c8a2ec" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "default_scope = 'mmpose'\n", + "default_hooks = dict(\n", + " timer=dict(type='IterTimerHook'),\n", + " logger=dict(type='LoggerHook', interval=50),\n", + " param_scheduler=dict(type='ParamSchedulerHook'),\n", + " checkpoint=dict(\n", + " type='CheckpointHook',\n", + " interval=1,\n", + " save_best='pck/PCK@0.05',\n", + " rule='greater',\n", + " max_keep_ckpts=1),\n", + " sampler_seed=dict(type='DistSamplerSeedHook'),\n", + " visualization=dict(type='PoseVisualizationHook', enable=False))\n", + "custom_hooks = [dict(type='SyncBuffersHook')]\n", + "env_cfg = dict(\n", + " cudnn_benchmark=False,\n", + " mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),\n", + " dist_cfg=dict(backend='nccl'))\n", + "vis_backends = [dict(type='LocalVisBackend')]\n", + "visualizer = dict(\n", + " type='PoseLocalVisualizer',\n", + " vis_backends=[dict(type='LocalVisBackend')],\n", + " name='visualizer')\n", + "log_processor = dict(\n", + " type='LogProcessor', window_size=50, by_epoch=True, num_digits=6)\n", + "log_level = 'INFO'\n", + "load_from = None\n", + "resume = False\n", + "file_client_args = dict(backend='disk')\n", + "train_cfg = dict(by_epoch=True, max_epochs=40, val_interval=1)\n", + "val_cfg = dict()\n", + "test_cfg = dict()\n", + "optim_wrapper = dict(optimizer=dict(type='Adam', lr=0.0005))\n", + "param_scheduler = [\n", + " dict(type='LinearLR', begin=0, end=10, start_factor=0.001, by_epoch=False),\n", + " dict(\n", + " type='MultiStepLR',\n", + " begin=0,\n", + " end=40,\n", + " milestones=[17, 35],\n", + " gamma=0.1,\n", + " by_epoch=True)\n", + "]\n", + "auto_scale_lr = dict(base_batch_size=512)\n", + "codec = dict(\n", + " type='MSRAHeatmap', input_size=(192, 256), heatmap_size=(48, 64), sigma=2)\n", + "model = dict(\n", + " type='TopdownPoseEstimator',\n", + " data_preprocessor=dict(\n", + " type='PoseDataPreprocessor',\n", + " mean=[123.675, 116.28, 103.53],\n", + " std=[58.395, 57.12, 57.375],\n", + " bgr_to_rgb=True),\n", + " backbone=dict(\n", + " type='HRNet',\n", + " in_channels=3,\n", + " extra=dict(\n", + " stage1=dict(\n", + " num_modules=1,\n", + " num_branches=1,\n", + " block='BOTTLENECK',\n", + " num_blocks=(4, ),\n", + " num_channels=(64, )),\n", + " stage2=dict(\n", + " num_modules=1,\n", + " num_branches=2,\n", + " block='BASIC',\n", + " num_blocks=(4, 4),\n", + " num_channels=(32, 64)),\n", + " stage3=dict(\n", + " num_modules=4,\n", + " num_branches=3,\n", + " block='BASIC',\n", + " num_blocks=(4, 4, 4),\n", + " num_channels=(32, 64, 128)),\n", + " stage4=dict(\n", + " num_modules=3,\n", + " num_branches=4,\n", + " block='BASIC',\n", + " num_blocks=(4, 4, 4, 4),\n", + " num_channels=(32, 64, 128, 256))),\n", + " init_cfg=dict(\n", + " type='Pretrained',\n", + " checkpoint=\n", + " 'https://download.openmmlab.com/mmpose/pretrain_models/hrnet_w32-36af842e.pth'\n", + " )),\n", + " head=dict(\n", + " type='HeatmapHead',\n", + " in_channels=32,\n", + " out_channels=17,\n", + " deconv_out_channels=None,\n", + " loss=dict(type='KeypointMSELoss', use_target_weight=True),\n", + " decoder=dict(\n", + " type='MSRAHeatmap',\n", + " input_size=(192, 256),\n", + " heatmap_size=(48, 64),\n", + " sigma=2)),\n", + " test_cfg=dict(flip_test=True, flip_mode='heatmap', shift_heatmap=True))\n", + "dataset_type = 'TinyCocoDataset'\n", + "data_mode = 'topdown'\n", + "data_root = 'data/coco_tiny'\n", + "train_pipeline = [\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='RandomFlip', direction='horizontal'),\n", + " dict(type='RandomHalfBody'),\n", + " dict(type='RandomBBoxTransform'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(\n", + " type='GenerateTarget',\n", + " target_type='heatmap',\n", + " encoder=dict(\n", + " type='MSRAHeatmap',\n", + " input_size=(192, 256),\n", + " heatmap_size=(48, 64),\n", + " sigma=2)),\n", + " dict(type='PackPoseInputs')\n", + "]\n", + "test_pipeline = [\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(type='PackPoseInputs')\n", + "]\n", + "train_dataloader = dict(\n", + " batch_size=16,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(type='DefaultSampler', shuffle=True),\n", + " dataset=dict(\n", + " type='TinyCocoDataset',\n", + " data_root='data/coco_tiny',\n", + " data_mode='topdown',\n", + " ann_file='train.json',\n", + " data_prefix=dict(img='images/'),\n", + " pipeline=[\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='RandomFlip', direction='horizontal'),\n", + " dict(type='RandomHalfBody'),\n", + " dict(type='RandomBBoxTransform'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(\n", + " type='GenerateTarget',\n", + " target_type='heatmap',\n", + " encoder=dict(\n", + " type='MSRAHeatmap',\n", + " input_size=(192, 256),\n", + " heatmap_size=(48, 64),\n", + " sigma=2)),\n", + " dict(type='PackPoseInputs')\n", + " ]))\n", + "val_dataloader = dict(\n", + " batch_size=16,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " drop_last=False,\n", + " sampler=dict(type='DefaultSampler', shuffle=False, round_up=False),\n", + " dataset=dict(\n", + " type='TinyCocoDataset',\n", + " data_root='data/coco_tiny',\n", + " data_mode='topdown',\n", + " ann_file='val.json',\n", + " bbox_file=None,\n", + " data_prefix=dict(img='images/'),\n", + " test_mode=True,\n", + " pipeline=[\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(type='PackPoseInputs')\n", + " ]))\n", + "test_dataloader = dict(\n", + " batch_size=16,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " drop_last=False,\n", + " sampler=dict(type='DefaultSampler', shuffle=False, round_up=False),\n", + " dataset=dict(\n", + " type='TinyCocoDataset',\n", + " data_root='data/coco_tiny',\n", + " data_mode='topdown',\n", + " ann_file='val.json',\n", + " bbox_file=None,\n", + " data_prefix=dict(img='images/'),\n", + " test_mode=True,\n", + " pipeline=[\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(type='PackPoseInputs')\n", + " ]))\n", + "val_evaluator = dict(type='PCKAccuracy')\n", + "test_evaluator = dict(type='PCKAccuracy')\n", + "work_dir = 'work_dirs/hrnet_w32_coco_tiny_256x192'\n", + "randomness = dict(seed=0)\n", + "\n" + ] + } + ], + "source": [ + "from mmengine import Config\n", + "\n", + "cfg = Config.fromfile(\n", + " './configs/body_2d_keypoint/topdown_heatmap/coco/td-hm_hrnet-w32_8xb64-210e_coco-256x192.py'\n", + ")\n", + "\n", + "# set basic configs\n", + "cfg.data_root = 'data/coco_tiny'\n", + "cfg.work_dir = 'work_dirs/hrnet_w32_coco_tiny_256x192'\n", + "cfg.randomness = dict(seed=0)\n", + "\n", + "# set log interval\n", + "cfg.train_cfg.val_interval = 1\n", + "\n", + "# set num of epoch\n", + "cfg.train_cfg.max_epochs = 40\n", + "\n", + "# set optimizer\n", + "cfg.optim_wrapper = dict(optimizer=dict(\n", + " type='Adam',\n", + " lr=5e-4,\n", + "))\n", + "\n", + "# set learning rate policy\n", + "cfg.param_scheduler = [\n", + " dict(\n", + " type='LinearLR', begin=0, end=10, start_factor=0.001,\n", + " by_epoch=False), # warm-up\n", + " dict(\n", + " type='MultiStepLR',\n", + " begin=0,\n", + " end=cfg.train_cfg.max_epochs,\n", + " milestones=[17, 35],\n", + " gamma=0.1,\n", + " by_epoch=True)\n", + "]\n", + "\n", + "\n", + "# set batch size\n", + "cfg.train_dataloader.batch_size = 16\n", + "cfg.val_dataloader.batch_size = 16\n", + "cfg.test_dataloader.batch_size = 16\n", + "\n", + "# set dataset configs\n", + "cfg.dataset_type = 'TinyCocoDataset'\n", + "cfg.train_dataloader.dataset.type = cfg.dataset_type\n", + "cfg.train_dataloader.dataset.ann_file = 'train.json'\n", + "cfg.train_dataloader.dataset.data_root = cfg.data_root\n", + "cfg.train_dataloader.dataset.data_prefix = dict(img='images/')\n", + "\n", + "\n", + "cfg.val_dataloader.dataset.type = cfg.dataset_type\n", + "cfg.val_dataloader.dataset.bbox_file = None\n", + "cfg.val_dataloader.dataset.ann_file = 'val.json'\n", + "cfg.val_dataloader.dataset.data_root = cfg.data_root\n", + "cfg.val_dataloader.dataset.data_prefix = dict(img='images/')\n", + "\n", + "cfg.test_dataloader.dataset.type = cfg.dataset_type\n", + "cfg.test_dataloader.dataset.bbox_file = None\n", + "cfg.test_dataloader.dataset.ann_file = 'val.json'\n", + "cfg.test_dataloader.dataset.data_root = cfg.data_root\n", + "cfg.test_dataloader.dataset.data_prefix = dict(img='images/')\n", + "\n", + "# set evaluator\n", + "cfg.val_evaluator = dict(type='PCKAccuracy')\n", + "cfg.test_evaluator = cfg.val_evaluator\n", + "\n", + "cfg.default_hooks.checkpoint.save_best = 'pck/PCK@0.05'\n", + "cfg.default_hooks.checkpoint.max_keep_ckpts = 1\n", + "\n", + "print(cfg.pretty_text)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "or you can create a config file like follows:\n", + "```Python3\n", + "_base_ = ['../../../_base_/default_runtime.py']\n", + "\n", + "# runtime\n", + "train_cfg = dict(max_epochs=40, val_interval=1)\n", + "\n", + "# optimizer\n", + "optim_wrapper = dict(optimizer=dict(\n", + " type='Adam',\n", + " lr=5e-4,\n", + "))\n", + "\n", + "# learning policy\n", + "param_scheduler = [\n", + " dict(\n", + " type='LinearLR', begin=0, end=500, start_factor=0.001,\n", + " by_epoch=False), # warm-up\n", + " dict(\n", + " type='MultiStepLR',\n", + " begin=0,\n", + " end=train_cfg.max_epochs,\n", + " milestones=[17, 35],\n", + " gamma=0.1,\n", + " by_epoch=True)\n", + "]\n", + "\n", + "# automatically scaling LR based on the actual training batch size\n", + "auto_scale_lr = dict(base_batch_size=512)\n", + "\n", + "# codec settings\n", + "codec = dict(\n", + " type='MSRAHeatmap', input_size=(192, 256), heatmap_size=(48, 64), sigma=2)\n", + "\n", + "# model settings\n", + "model = dict(\n", + " type='TopdownPoseEstimator',\n", + " data_preprocessor=dict(\n", + " type='PoseDataPreprocessor',\n", + " mean=[123.675, 116.28, 103.53],\n", + " std=[58.395, 57.12, 57.375],\n", + " bgr_to_rgb=True),\n", + " backbone=dict(\n", + " type='HRNet',\n", + " in_channels=3,\n", + " extra=dict(\n", + " stage1=dict(\n", + " num_modules=1,\n", + " num_branches=1,\n", + " block='BOTTLENECK',\n", + " num_blocks=(4, ),\n", + " num_channels=(64, )),\n", + " stage2=dict(\n", + " num_modules=1,\n", + " num_branches=2,\n", + " block='BASIC',\n", + " num_blocks=(4, 4),\n", + " num_channels=(32, 64)),\n", + " stage3=dict(\n", + " num_modules=4,\n", + " num_branches=3,\n", + " block='BASIC',\n", + " num_blocks=(4, 4, 4),\n", + " num_channels=(32, 64, 128)),\n", + " stage4=dict(\n", + " num_modules=3,\n", + " num_branches=4,\n", + " block='BASIC',\n", + " num_blocks=(4, 4, 4, 4),\n", + " num_channels=(32, 64, 128, 256))),\n", + " init_cfg=dict(\n", + " type='Pretrained',\n", + " checkpoint='https://download.openmmlab.com/mmpose/'\n", + " 'pretrain_models/hrnet_w32-36af842e.pth'),\n", + " ),\n", + " head=dict(\n", + " type='HeatmapHead',\n", + " in_channels=32,\n", + " out_channels=17,\n", + " deconv_out_channels=None,\n", + " loss=dict(type='KeypointMSELoss', use_target_weight=True),\n", + " decoder=codec),\n", + " test_cfg=dict(\n", + " flip_test=True,\n", + " flip_mode='heatmap',\n", + " shift_heatmap=True,\n", + " ))\n", + "\n", + "# base dataset settings\n", + "dataset_type = 'TinyCocoDataset'\n", + "data_mode = 'topdown'\n", + "data_root = 'data/coco_tiny'\n", + "work_dir = 'work_dirs/hrnet_w32_coco_tiny_256x192'\n", + "randomness = dict(seed=0)\n", + "\n", + "file_client_args = dict(backend='disk')\n", + "\n", + "# pipelines\n", + "train_pipeline = [\n", + " dict(type='LoadImage', file_client_args=file_client_args),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='RandomFlip', direction='horizontal'),\n", + " dict(type='RandomHalfBody'),\n", + " dict(type='RandomBBoxTransform'),\n", + " dict(type='TopdownAffine', input_size=codec['input_size']),\n", + " dict(type='GenerateTarget', target_type='heatmap', encoder=codec),\n", + " dict(type='PackPoseInputs')\n", + "]\n", + "test_pipeline = [\n", + " dict(type='LoadImage', file_client_args=file_client_args),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='TopdownAffine', input_size=codec['input_size']),\n", + " dict(type='PackPoseInputs')\n", + "]\n", + "\n", + "# data loaders\n", + "train_dataloader = dict(\n", + " batch_size=16,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(type='DefaultSampler', shuffle=True),\n", + " dataset=dict(\n", + " type=dataset_type,\n", + " data_root=data_root,\n", + " data_mode=data_mode,\n", + " ann_file='train.json',\n", + " data_prefix=dict(img='images/'),\n", + " pipeline=train_pipeline,\n", + " ))\n", + "val_dataloader = dict(\n", + " batch_size=16,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " drop_last=False,\n", + " sampler=dict(type='DefaultSampler', shuffle=False, round_up=False),\n", + " dataset=dict(\n", + " type=dataset_type,\n", + " data_root=data_root,\n", + " data_mode=data_mode,\n", + " ann_file='val.json',\n", + " data_prefix=dict(img='images/'),\n", + " test_mode=True,\n", + " pipeline=test_pipeline,\n", + " ))\n", + "test_dataloader = val_dataloader\n", + "\n", + "# evaluators\n", + "val_evaluator = dict(\n", + " type='PCKAccuracy')\n", + "test_evaluator = val_evaluator\n", + "\n", + "# hooks\n", + "default_hooks = dict(checkpoint=dict(save_best='coco/AP', rule='greater'))\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ChVqB1oYncmo" + }, + "source": [ + "### Train and Evaluation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "2a079d9c0b9845318e6c612ca9601b86", + "3554753622334094961a47daf9362c59", + "08e0412b8dd54d28a26c232e75ea6088", + "558a9420b0b34be2a2ca8a8b8af9cbfc", + "a9bd3e477f07449788f0e95e3cd13ddc", + "5b2ee1f3e78d4cd993009d04baf76b24", + "a3e5aa31c3f644b5a677ec49fe2e0832", + "d2ee56f920a245d9875de8e37596a5c8", + "b5f8c86d48a04afa997fc137e1acd716", + "1c1b09d91dec4e3dadefe953daf50745", + "6af448aebdb744b98a2807f66b1d6e5d" + ] + }, + "id": "Ab3xsUdPlXuJ", + "outputId": "c07394b8-21f4-4766-af2b-87d2caa6e74c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "09/15 12:42:06 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"log_processor\" registry tree. As a workaround, the current \"log_processor\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:06 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - \n", + "------------------------------------------------------------\n", + "System environment:\n", + " sys.platform: linux\n", + " Python: 3.7.13 (default, Mar 29 2022, 02:18:16) [GCC 7.5.0]\n", + " CUDA available: True\n", + " numpy_random_seed: 0\n", + " GPU 0: NVIDIA GeForce GTX 1660 Ti\n", + " CUDA_HOME: /usr/local/cuda\n", + " NVCC: Cuda compilation tools, release 11.3, V11.3.109\n", + " GCC: gcc (Ubuntu 5.4.0-6ubuntu1~16.04.12) 5.4.0 20160609\n", + " PyTorch: 1.12.0+cu113\n", + " PyTorch compiling details: PyTorch built with:\n", + " - GCC 9.3\n", + " - C++ Version: 201402\n", + " - Intel(R) Math Kernel Library Version 2020.0.0 Product Build 20191122 for Intel(R) 64 architecture applications\n", + " - Intel(R) MKL-DNN v2.6.0 (Git Hash 52b5f107dd9cf10910aaa19cb47f3abf9b349815)\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 11.3\n", + " - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-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\n", + " - CuDNN 8.3.2 (built against CUDA 11.5)\n", + " - Magma 2.5.2\n", + " - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.3, CUDNN_VERSION=8.3.2, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_KINETO -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -DEDGE_PROFILER_USE_KINETO -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-unused-local-typedefs -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -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_VERSION=1.12.0, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=OFF, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n", + "\n", + " TorchVision: 0.13.0+cu113\n", + " OpenCV: 4.6.0\n", + " MMEngine: 0.1.0\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: 0\n", + " Distributed launcher: none\n", + " Distributed training: False\n", + " GPU number: 1\n", + "------------------------------------------------------------\n", + "\n", + "09/15 12:42:06 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Config:\n", + "default_scope = 'mmpose'\n", + "default_hooks = dict(\n", + " timer=dict(type='IterTimerHook'),\n", + " logger=dict(type='LoggerHook', interval=50),\n", + " param_scheduler=dict(type='ParamSchedulerHook'),\n", + " checkpoint=dict(\n", + " type='CheckpointHook',\n", + " interval=1,\n", + " save_best='pck/PCK@0.05',\n", + " rule='greater',\n", + " max_keep_ckpts=1),\n", + " sampler_seed=dict(type='DistSamplerSeedHook'),\n", + " visualization=dict(type='PoseVisualizationHook', enable=False))\n", + "custom_hooks = [dict(type='SyncBuffersHook')]\n", + "env_cfg = dict(\n", + " cudnn_benchmark=False,\n", + " mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),\n", + " dist_cfg=dict(backend='nccl'))\n", + "vis_backends = [dict(type='LocalVisBackend')]\n", + "visualizer = dict(\n", + " type='PoseLocalVisualizer',\n", + " vis_backends=[dict(type='LocalVisBackend')],\n", + " name='visualizer')\n", + "log_processor = dict(\n", + " type='LogProcessor', window_size=50, by_epoch=True, num_digits=6)\n", + "log_level = 'INFO'\n", + "load_from = None\n", + "resume = False\n", + "file_client_args = dict(backend='disk')\n", + "train_cfg = dict(by_epoch=True, max_epochs=40, val_interval=1)\n", + "val_cfg = dict()\n", + "test_cfg = dict()\n", + "optim_wrapper = dict(optimizer=dict(type='Adam', lr=0.0005))\n", + "param_scheduler = [\n", + " dict(type='LinearLR', begin=0, end=10, start_factor=0.001, by_epoch=False),\n", + " dict(\n", + " type='MultiStepLR',\n", + " begin=0,\n", + " end=40,\n", + " milestones=[17, 35],\n", + " gamma=0.1,\n", + " by_epoch=True)\n", + "]\n", + "auto_scale_lr = dict(base_batch_size=512)\n", + "codec = dict(\n", + " type='MSRAHeatmap', input_size=(192, 256), heatmap_size=(48, 64), sigma=2)\n", + "model = dict(\n", + " type='TopdownPoseEstimator',\n", + " data_preprocessor=dict(\n", + " type='PoseDataPreprocessor',\n", + " mean=[123.675, 116.28, 103.53],\n", + " std=[58.395, 57.12, 57.375],\n", + " bgr_to_rgb=True),\n", + " backbone=dict(\n", + " type='HRNet',\n", + " in_channels=3,\n", + " extra=dict(\n", + " stage1=dict(\n", + " num_modules=1,\n", + " num_branches=1,\n", + " block='BOTTLENECK',\n", + " num_blocks=(4, ),\n", + " num_channels=(64, )),\n", + " stage2=dict(\n", + " num_modules=1,\n", + " num_branches=2,\n", + " block='BASIC',\n", + " num_blocks=(4, 4),\n", + " num_channels=(32, 64)),\n", + " stage3=dict(\n", + " num_modules=4,\n", + " num_branches=3,\n", + " block='BASIC',\n", + " num_blocks=(4, 4, 4),\n", + " num_channels=(32, 64, 128)),\n", + " stage4=dict(\n", + " num_modules=3,\n", + " num_branches=4,\n", + " block='BASIC',\n", + " num_blocks=(4, 4, 4, 4),\n", + " num_channels=(32, 64, 128, 256))),\n", + " init_cfg=dict(\n", + " type='Pretrained',\n", + " checkpoint=\n", + " 'https://download.openmmlab.com/mmpose/pretrain_models/hrnet_w32-36af842e.pth'\n", + " )),\n", + " head=dict(\n", + " type='HeatmapHead',\n", + " in_channels=32,\n", + " out_channels=17,\n", + " deconv_out_channels=None,\n", + " loss=dict(type='KeypointMSELoss', use_target_weight=True),\n", + " decoder=dict(\n", + " type='MSRAHeatmap',\n", + " input_size=(192, 256),\n", + " heatmap_size=(48, 64),\n", + " sigma=2)),\n", + " test_cfg=dict(flip_test=True, flip_mode='heatmap', shift_heatmap=True))\n", + "dataset_type = 'TinyCocoDataset'\n", + "data_mode = 'topdown'\n", + "data_root = 'data/coco_tiny'\n", + "train_pipeline = [\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='RandomFlip', direction='horizontal'),\n", + " dict(type='RandomHalfBody'),\n", + " dict(type='RandomBBoxTransform'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(\n", + " type='GenerateTarget',\n", + " target_type='heatmap',\n", + " encoder=dict(\n", + " type='MSRAHeatmap',\n", + " input_size=(192, 256),\n", + " heatmap_size=(48, 64),\n", + " sigma=2)),\n", + " dict(type='PackPoseInputs')\n", + "]\n", + "test_pipeline = [\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(type='PackPoseInputs')\n", + "]\n", + "train_dataloader = dict(\n", + " batch_size=16,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " sampler=dict(type='DefaultSampler', shuffle=True),\n", + " dataset=dict(\n", + " type='TinyCocoDataset',\n", + " data_root='data/coco_tiny',\n", + " data_mode='topdown',\n", + " ann_file='train.json',\n", + " data_prefix=dict(img='images/'),\n", + " pipeline=[\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='RandomFlip', direction='horizontal'),\n", + " dict(type='RandomHalfBody'),\n", + " dict(type='RandomBBoxTransform'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(\n", + " type='GenerateTarget',\n", + " target_type='heatmap',\n", + " encoder=dict(\n", + " type='MSRAHeatmap',\n", + " input_size=(192, 256),\n", + " heatmap_size=(48, 64),\n", + " sigma=2)),\n", + " dict(type='PackPoseInputs')\n", + " ]))\n", + "val_dataloader = dict(\n", + " batch_size=16,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " drop_last=False,\n", + " sampler=dict(type='DefaultSampler', shuffle=False, round_up=False),\n", + " dataset=dict(\n", + " type='TinyCocoDataset',\n", + " data_root='data/coco_tiny',\n", + " data_mode='topdown',\n", + " ann_file='val.json',\n", + " bbox_file=None,\n", + " data_prefix=dict(img='images/'),\n", + " test_mode=True,\n", + " pipeline=[\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(type='PackPoseInputs')\n", + " ]))\n", + "test_dataloader = dict(\n", + " batch_size=16,\n", + " num_workers=2,\n", + " persistent_workers=True,\n", + " drop_last=False,\n", + " sampler=dict(type='DefaultSampler', shuffle=False, round_up=False),\n", + " dataset=dict(\n", + " type='TinyCocoDataset',\n", + " data_root='data/coco_tiny',\n", + " data_mode='topdown',\n", + " ann_file='val.json',\n", + " bbox_file=None,\n", + " data_prefix=dict(img='images/'),\n", + " test_mode=True,\n", + " pipeline=[\n", + " dict(type='LoadImage', file_client_args=dict(backend='disk')),\n", + " dict(type='GetBBoxCenterScale'),\n", + " dict(type='TopdownAffine', input_size=(192, 256)),\n", + " dict(type='PackPoseInputs')\n", + " ]))\n", + "val_evaluator = dict(type='PCKAccuracy')\n", + "test_evaluator = dict(type='PCKAccuracy')\n", + "work_dir = 'work_dirs/hrnet_w32_coco_tiny_256x192'\n", + "randomness = dict(seed=0)\n", + "\n", + "Result has been saved to /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/modules_statistic_results.json\n", + "09/15 12:42:07 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Distributed training is not used, all SyncBatchNorm (SyncBN) layers in the model will be automatically reverted to BatchNormXd layers if they are used.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"data sampler\" registry tree. As a workaround, the current \"data sampler\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"optimizer wrapper constructor\" registry tree. As a workaround, the current \"optimizer wrapper constructor\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"optimizer\" registry tree. As a workaround, the current \"optimizer\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"optim_wrapper\" registry tree. As a workaround, the current \"optim_wrapper\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"parameter scheduler\" registry tree. As a workaround, the current \"parameter scheduler\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"parameter scheduler\" registry tree. As a workaround, the current \"parameter scheduler\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"parameter scheduler\" registry tree. As a workaround, the current \"parameter scheduler\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"parameter scheduler\" registry tree. As a workaround, the current \"parameter scheduler\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"data sampler\" registry tree. As a workaround, the current \"data sampler\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"weight initializer\" registry tree. As a workaround, the current \"weight initializer\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:08 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - load model from: https://download.openmmlab.com/mmpose/pretrain_models/hrnet_w32-36af842e.pth\n", + "09/15 12:42:08 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - http loads checkpoint from path: https://download.openmmlab.com/mmpose/pretrain_models/hrnet_w32-36af842e.pth\n", + "09/15 12:42:09 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - The model and loaded state dict do not match exactly\n", + "\n", + "unexpected key in source state_dict: head.0.0.0.conv1.weight, head.0.0.0.bn1.weight, head.0.0.0.bn1.bias, head.0.0.0.bn1.running_mean, head.0.0.0.bn1.running_var, head.0.0.0.bn1.num_batches_tracked, head.0.0.0.conv2.weight, head.0.0.0.bn2.weight, head.0.0.0.bn2.bias, head.0.0.0.bn2.running_mean, head.0.0.0.bn2.running_var, head.0.0.0.bn2.num_batches_tracked, head.0.0.0.conv3.weight, head.0.0.0.bn3.weight, head.0.0.0.bn3.bias, head.0.0.0.bn3.running_mean, head.0.0.0.bn3.running_var, head.0.0.0.bn3.num_batches_tracked, head.0.0.0.downsample.0.weight, head.0.0.0.downsample.1.weight, head.0.0.0.downsample.1.bias, head.0.0.0.downsample.1.running_mean, head.0.0.0.downsample.1.running_var, head.0.0.0.downsample.1.num_batches_tracked, head.0.1.0.conv1.weight, head.0.1.0.bn1.weight, head.0.1.0.bn1.bias, head.0.1.0.bn1.running_mean, head.0.1.0.bn1.running_var, head.0.1.0.bn1.num_batches_tracked, head.0.1.0.conv2.weight, head.0.1.0.bn2.weight, head.0.1.0.bn2.bias, head.0.1.0.bn2.running_mean, head.0.1.0.bn2.running_var, head.0.1.0.bn2.num_batches_tracked, head.0.1.0.conv3.weight, head.0.1.0.bn3.weight, head.0.1.0.bn3.bias, head.0.1.0.bn3.running_mean, head.0.1.0.bn3.running_var, head.0.1.0.bn3.num_batches_tracked, head.0.1.0.downsample.0.weight, head.0.1.0.downsample.1.weight, head.0.1.0.downsample.1.bias, head.0.1.0.downsample.1.running_mean, head.0.1.0.downsample.1.running_var, head.0.1.0.downsample.1.num_batches_tracked, head.0.2.0.conv1.weight, head.0.2.0.bn1.weight, head.0.2.0.bn1.bias, head.0.2.0.bn1.running_mean, head.0.2.0.bn1.running_var, head.0.2.0.bn1.num_batches_tracked, head.0.2.0.conv2.weight, head.0.2.0.bn2.weight, head.0.2.0.bn2.bias, head.0.2.0.bn2.running_mean, head.0.2.0.bn2.running_var, head.0.2.0.bn2.num_batches_tracked, head.0.2.0.conv3.weight, head.0.2.0.bn3.weight, head.0.2.0.bn3.bias, head.0.2.0.bn3.running_mean, head.0.2.0.bn3.running_var, head.0.2.0.bn3.num_batches_tracked, head.0.2.0.downsample.0.weight, head.0.2.0.downsample.1.weight, head.0.2.0.downsample.1.bias, head.0.2.0.downsample.1.running_mean, head.0.2.0.downsample.1.running_var, head.0.2.0.downsample.1.num_batches_tracked, head.1.0.0.conv1.weight, head.1.0.0.bn1.weight, head.1.0.0.bn1.bias, head.1.0.0.bn1.running_mean, head.1.0.0.bn1.running_var, head.1.0.0.bn1.num_batches_tracked, head.1.0.0.conv2.weight, head.1.0.0.bn2.weight, head.1.0.0.bn2.bias, head.1.0.0.bn2.running_mean, head.1.0.0.bn2.running_var, head.1.0.0.bn2.num_batches_tracked, head.1.0.0.conv3.weight, head.1.0.0.bn3.weight, head.1.0.0.bn3.bias, head.1.0.0.bn3.running_mean, head.1.0.0.bn3.running_var, head.1.0.0.bn3.num_batches_tracked, head.1.0.0.downsample.0.weight, head.1.0.0.downsample.1.weight, head.1.0.0.downsample.1.bias, head.1.0.0.downsample.1.running_mean, head.1.0.0.downsample.1.running_var, head.1.0.0.downsample.1.num_batches_tracked, head.1.1.0.conv1.weight, head.1.1.0.bn1.weight, head.1.1.0.bn1.bias, head.1.1.0.bn1.running_mean, head.1.1.0.bn1.running_var, head.1.1.0.bn1.num_batches_tracked, head.1.1.0.conv2.weight, head.1.1.0.bn2.weight, head.1.1.0.bn2.bias, head.1.1.0.bn2.running_mean, head.1.1.0.bn2.running_var, head.1.1.0.bn2.num_batches_tracked, head.1.1.0.conv3.weight, head.1.1.0.bn3.weight, head.1.1.0.bn3.bias, head.1.1.0.bn3.running_mean, head.1.1.0.bn3.running_var, head.1.1.0.bn3.num_batches_tracked, head.1.1.0.downsample.0.weight, head.1.1.0.downsample.1.weight, head.1.1.0.downsample.1.bias, head.1.1.0.downsample.1.running_mean, head.1.1.0.downsample.1.running_var, head.1.1.0.downsample.1.num_batches_tracked, head.2.0.0.conv1.weight, head.2.0.0.bn1.weight, head.2.0.0.bn1.bias, head.2.0.0.bn1.running_mean, head.2.0.0.bn1.running_var, head.2.0.0.bn1.num_batches_tracked, head.2.0.0.conv2.weight, head.2.0.0.bn2.weight, head.2.0.0.bn2.bias, head.2.0.0.bn2.running_mean, head.2.0.0.bn2.running_var, head.2.0.0.bn2.num_batches_tracked, head.2.0.0.conv3.weight, head.2.0.0.bn3.weight, head.2.0.0.bn3.bias, head.2.0.0.bn3.running_mean, head.2.0.0.bn3.running_var, head.2.0.0.bn3.num_batches_tracked, head.2.0.0.downsample.0.weight, head.2.0.0.downsample.1.weight, head.2.0.0.downsample.1.bias, head.2.0.0.downsample.1.running_mean, head.2.0.0.downsample.1.running_var, head.2.0.0.downsample.1.num_batches_tracked, head.3.0.0.conv1.weight, head.3.0.0.bn1.weight, head.3.0.0.bn1.bias, head.3.0.0.bn1.running_mean, head.3.0.0.bn1.running_var, head.3.0.0.bn1.num_batches_tracked, head.3.0.0.conv2.weight, head.3.0.0.bn2.weight, head.3.0.0.bn2.bias, head.3.0.0.bn2.running_mean, head.3.0.0.bn2.running_var, head.3.0.0.bn2.num_batches_tracked, head.3.0.0.conv3.weight, head.3.0.0.bn3.weight, head.3.0.0.bn3.bias, head.3.0.0.bn3.running_mean, head.3.0.0.bn3.running_var, head.3.0.0.bn3.num_batches_tracked, head.3.0.0.downsample.0.weight, head.3.0.0.downsample.1.weight, head.3.0.0.downsample.1.bias, head.3.0.0.downsample.1.running_mean, head.3.0.0.downsample.1.running_var, head.3.0.0.downsample.1.num_batches_tracked, fc.weight, fc.bias, stage4.2.fuse_layers.1.0.0.0.weight, stage4.2.fuse_layers.1.0.0.1.weight, stage4.2.fuse_layers.1.0.0.1.bias, stage4.2.fuse_layers.1.0.0.1.running_mean, stage4.2.fuse_layers.1.0.0.1.running_var, stage4.2.fuse_layers.1.0.0.1.num_batches_tracked, stage4.2.fuse_layers.1.2.0.weight, stage4.2.fuse_layers.1.2.1.weight, stage4.2.fuse_layers.1.2.1.bias, stage4.2.fuse_layers.1.2.1.running_mean, stage4.2.fuse_layers.1.2.1.running_var, stage4.2.fuse_layers.1.2.1.num_batches_tracked, stage4.2.fuse_layers.1.3.0.weight, stage4.2.fuse_layers.1.3.1.weight, stage4.2.fuse_layers.1.3.1.bias, stage4.2.fuse_layers.1.3.1.running_mean, stage4.2.fuse_layers.1.3.1.running_var, stage4.2.fuse_layers.1.3.1.num_batches_tracked, stage4.2.fuse_layers.2.0.0.0.weight, stage4.2.fuse_layers.2.0.0.1.weight, stage4.2.fuse_layers.2.0.0.1.bias, stage4.2.fuse_layers.2.0.0.1.running_mean, stage4.2.fuse_layers.2.0.0.1.running_var, stage4.2.fuse_layers.2.0.0.1.num_batches_tracked, stage4.2.fuse_layers.2.0.1.0.weight, stage4.2.fuse_layers.2.0.1.1.weight, stage4.2.fuse_layers.2.0.1.1.bias, stage4.2.fuse_layers.2.0.1.1.running_mean, stage4.2.fuse_layers.2.0.1.1.running_var, stage4.2.fuse_layers.2.0.1.1.num_batches_tracked, stage4.2.fuse_layers.2.1.0.0.weight, stage4.2.fuse_layers.2.1.0.1.weight, stage4.2.fuse_layers.2.1.0.1.bias, stage4.2.fuse_layers.2.1.0.1.running_mean, stage4.2.fuse_layers.2.1.0.1.running_var, stage4.2.fuse_layers.2.1.0.1.num_batches_tracked, stage4.2.fuse_layers.2.3.0.weight, stage4.2.fuse_layers.2.3.1.weight, stage4.2.fuse_layers.2.3.1.bias, stage4.2.fuse_layers.2.3.1.running_mean, stage4.2.fuse_layers.2.3.1.running_var, stage4.2.fuse_layers.2.3.1.num_batches_tracked, stage4.2.fuse_layers.3.0.0.0.weight, stage4.2.fuse_layers.3.0.0.1.weight, stage4.2.fuse_layers.3.0.0.1.bias, stage4.2.fuse_layers.3.0.0.1.running_mean, stage4.2.fuse_layers.3.0.0.1.running_var, stage4.2.fuse_layers.3.0.0.1.num_batches_tracked, stage4.2.fuse_layers.3.0.1.0.weight, stage4.2.fuse_layers.3.0.1.1.weight, stage4.2.fuse_layers.3.0.1.1.bias, stage4.2.fuse_layers.3.0.1.1.running_mean, stage4.2.fuse_layers.3.0.1.1.running_var, stage4.2.fuse_layers.3.0.1.1.num_batches_tracked, stage4.2.fuse_layers.3.0.2.0.weight, stage4.2.fuse_layers.3.0.2.1.weight, stage4.2.fuse_layers.3.0.2.1.bias, stage4.2.fuse_layers.3.0.2.1.running_mean, stage4.2.fuse_layers.3.0.2.1.running_var, stage4.2.fuse_layers.3.0.2.1.num_batches_tracked, stage4.2.fuse_layers.3.1.0.0.weight, stage4.2.fuse_layers.3.1.0.1.weight, stage4.2.fuse_layers.3.1.0.1.bias, stage4.2.fuse_layers.3.1.0.1.running_mean, stage4.2.fuse_layers.3.1.0.1.running_var, stage4.2.fuse_layers.3.1.0.1.num_batches_tracked, stage4.2.fuse_layers.3.1.1.0.weight, stage4.2.fuse_layers.3.1.1.1.weight, stage4.2.fuse_layers.3.1.1.1.bias, stage4.2.fuse_layers.3.1.1.1.running_mean, stage4.2.fuse_layers.3.1.1.1.running_var, stage4.2.fuse_layers.3.1.1.1.num_batches_tracked, stage4.2.fuse_layers.3.2.0.0.weight, stage4.2.fuse_layers.3.2.0.1.weight, stage4.2.fuse_layers.3.2.0.1.bias, stage4.2.fuse_layers.3.2.0.1.running_mean, stage4.2.fuse_layers.3.2.0.1.running_var, stage4.2.fuse_layers.3.2.0.1.num_batches_tracked\n", + "\n", + "09/15 12:42:09 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"weight initializer\" registry tree. As a workaround, the current \"weight initializer\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:09 - mmengine - \u001b[5m\u001b[4m\u001b[33mWARNING\u001b[0m - Failed to search registry with scope \"mmpose\" in the \"weight initializer\" registry tree. As a workaround, the current \"weight initializer\" registry in \"mmengine\" is used to build instance. This may cause unexpected failure when running the built modules. Please check whether \"mmpose\" is a correct scope, or whether the registry is initialized.\n", + "09/15 12:42:09 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Checkpoints will be saved to /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192 by HardDiskBackend.\n", + "09/15 12:42:12 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:12 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 1 epochs\n", + "09/15 12:42:13 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:13 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [1][2/2] pck/PCK@0.05: 0.009035\n", + "09/15 12:42:14 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.0090 pck/PCK@0.05 at 1 epoch is saved to best_pck/PCK@0.05_epoch_1.pth.\n", + "09/15 12:42:16 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:16 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 2 epochs\n", + "09/15 12:42:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [2][2/2] pck/PCK@0.05: 0.163666\n", + "09/15 12:42:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_1.pth is removed\n", + "09/15 12:42:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.1637 pck/PCK@0.05 at 2 epoch is saved to best_pck/PCK@0.05_epoch_2.pth.\n", + "09/15 12:42:19 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:19 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 3 epochs\n", + "09/15 12:42:21 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:21 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [3][2/2] pck/PCK@0.05: 0.201942\n", + "09/15 12:42:21 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_2.pth is removed\n", + "09/15 12:42:21 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.2019 pck/PCK@0.05 at 3 epoch is saved to best_pck/PCK@0.05_epoch_3.pth.\n", + "09/15 12:42:23 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:23 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 4 epochs\n", + "09/15 12:42:24 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:24 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [4][2/2] pck/PCK@0.05: 0.247750\n", + "09/15 12:42:24 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_3.pth is removed\n", + "09/15 12:42:25 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.2477 pck/PCK@0.05 at 4 epoch is saved to best_pck/PCK@0.05_epoch_4.pth.\n", + "09/15 12:42:27 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:27 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 5 epochs\n", + "09/15 12:42:28 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:28 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [5][2/2] pck/PCK@0.05: 0.296205\n", + "09/15 12:42:28 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_4.pth is removed\n", + "09/15 12:42:29 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.2962 pck/PCK@0.05 at 5 epoch is saved to best_pck/PCK@0.05_epoch_5.pth.\n", + "09/15 12:42:31 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:31 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 6 epochs\n", + "09/15 12:42:32 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:32 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [6][2/2] pck/PCK@0.05: 0.316309\n", + "09/15 12:42:32 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_5.pth is removed\n", + "09/15 12:42:33 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.3163 pck/PCK@0.05 at 6 epoch is saved to best_pck/PCK@0.05_epoch_6.pth.\n", + "09/15 12:42:35 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:35 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 7 epochs\n", + "09/15 12:42:36 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:36 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [7][2/2] pck/PCK@0.05: 0.290834\n", + "09/15 12:42:38 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:38 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 8 epochs\n", + "09/15 12:42:39 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:39 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [8][2/2] pck/PCK@0.05: 0.335645\n", + "09/15 12:42:39 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_6.pth is removed\n", + "09/15 12:42:40 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.3356 pck/PCK@0.05 at 8 epoch is saved to best_pck/PCK@0.05_epoch_8.pth.\n", + "09/15 12:42:42 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:42 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 9 epochs\n", + "09/15 12:42:43 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:43 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [9][2/2] pck/PCK@0.05: 0.348761\n", + "09/15 12:42:43 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_8.pth is removed\n", + "09/15 12:42:44 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.3488 pck/PCK@0.05 at 9 epoch is saved to best_pck/PCK@0.05_epoch_9.pth.\n", + "09/15 12:42:46 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:46 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 10 epochs\n", + "09/15 12:42:47 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:47 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [10][2/2] pck/PCK@0.05: 0.310204\n", + "09/15 12:42:49 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:49 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 11 epochs\n", + "09/15 12:42:50 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:50 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [11][2/2] pck/PCK@0.05: 0.338200\n", + "09/15 12:42:52 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:52 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 12 epochs\n", + "09/15 12:42:53 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:53 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [12][2/2] pck/PCK@0.05: 0.356559\n", + "09/15 12:42:53 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_9.pth is removed\n", + "09/15 12:42:54 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.3566 pck/PCK@0.05 at 12 epoch is saved to best_pck/PCK@0.05_epoch_12.pth.\n", + "09/15 12:42:56 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:42:56 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 13 epochs\n", + "09/15 12:42:57 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:42:57 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [13][2/2] pck/PCK@0.05: 0.384718\n", + "09/15 12:42:57 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_12.pth is removed\n", + "09/15 12:42:58 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.3847 pck/PCK@0.05 at 13 epoch is saved to best_pck/PCK@0.05_epoch_13.pth.\n", + "09/15 12:43:00 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:00 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 14 epochs\n", + "09/15 12:43:01 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:01 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [14][2/2] pck/PCK@0.05: 0.372036\n", + "09/15 12:43:03 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:03 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 15 epochs\n", + "09/15 12:43:04 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:04 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [15][2/2] pck/PCK@0.05: 0.331702\n", + "09/15 12:43:06 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:06 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 16 epochs\n", + "09/15 12:43:07 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:07 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [16][2/2] pck/PCK@0.05: 0.350346\n", + "09/15 12:43:09 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:09 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 17 epochs\n", + "09/15 12:43:10 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:10 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [17][2/2] pck/PCK@0.05: 0.358399\n", + "09/15 12:43:12 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:12 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 18 epochs\n", + "09/15 12:43:14 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:14 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [18][2/2] pck/PCK@0.05: 0.377378\n", + "09/15 12:43:15 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:15 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 19 epochs\n", + "09/15 12:43:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [19][2/2] pck/PCK@0.05: 0.392675\n", + "09/15 12:43:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_13.pth is removed\n", + "09/15 12:43:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.3927 pck/PCK@0.05 at 19 epoch is saved to best_pck/PCK@0.05_epoch_19.pth.\n", + "09/15 12:43:19 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:19 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 20 epochs\n", + "09/15 12:43:21 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:21 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [20][2/2] pck/PCK@0.05: 0.413536\n", + "09/15 12:43:21 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_19.pth is removed\n", + "09/15 12:43:21 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.4135 pck/PCK@0.05 at 20 epoch is saved to best_pck/PCK@0.05_epoch_20.pth.\n", + "09/15 12:43:23 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:23 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 21 epochs\n", + "09/15 12:43:24 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:24 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [21][2/2] pck/PCK@0.05: 0.422105\n", + "09/15 12:43:24 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_20.pth is removed\n", + "09/15 12:43:25 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.4221 pck/PCK@0.05 at 21 epoch is saved to best_pck/PCK@0.05_epoch_21.pth.\n", + "09/15 12:43:27 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:27 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 22 epochs\n", + "09/15 12:43:28 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:28 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [22][2/2] pck/PCK@0.05: 0.430300\n", + "09/15 12:43:28 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_21.pth is removed\n", + "09/15 12:43:29 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.4303 pck/PCK@0.05 at 22 epoch is saved to best_pck/PCK@0.05_epoch_22.pth.\n", + "09/15 12:43:31 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:31 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 23 epochs\n", + "09/15 12:43:32 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:32 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [23][2/2] pck/PCK@0.05: 0.440251\n", + "09/15 12:43:32 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_22.pth is removed\n", + "09/15 12:43:33 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.4403 pck/PCK@0.05 at 23 epoch is saved to best_pck/PCK@0.05_epoch_23.pth.\n", + "09/15 12:43:34 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:34 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 24 epochs\n", + "09/15 12:43:36 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:36 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [24][2/2] pck/PCK@0.05: 0.433262\n", + "09/15 12:43:38 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:38 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 25 epochs\n", + "09/15 12:43:39 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:39 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [25][2/2] pck/PCK@0.05: 0.429440\n", + "09/15 12:43:41 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:41 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 26 epochs\n", + "09/15 12:43:42 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:42 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [26][2/2] pck/PCK@0.05: 0.423034\n", + "09/15 12:43:44 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:44 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 27 epochs\n", + "09/15 12:43:45 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:45 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [27][2/2] pck/PCK@0.05: 0.440554\n", + "09/15 12:43:45 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_23.pth is removed\n", + "09/15 12:43:46 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.4406 pck/PCK@0.05 at 27 epoch is saved to best_pck/PCK@0.05_epoch_27.pth.\n", + "09/15 12:43:48 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:48 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 28 epochs\n", + "09/15 12:43:49 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:49 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [28][2/2] pck/PCK@0.05: 0.454103\n", + "09/15 12:43:49 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The previous best checkpoint /home/PJLAB/jiangtao/Documents/git-clone/mmpose/work_dirs/hrnet_w32_coco_tiny_256x192/best_pck/PCK@0.05_epoch_27.pth is removed\n", + "09/15 12:43:50 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - The best checkpoint with 0.4541 pck/PCK@0.05 at 28 epoch is saved to best_pck/PCK@0.05_epoch_28.pth.\n", + "09/15 12:43:52 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:52 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 29 epochs\n", + "09/15 12:43:53 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:53 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [29][2/2] pck/PCK@0.05: 0.434462\n", + "09/15 12:43:55 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:55 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 30 epochs\n", + "09/15 12:43:56 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:56 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [30][2/2] pck/PCK@0.05: 0.434963\n", + "09/15 12:43:58 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:43:58 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 31 epochs\n", + "09/15 12:43:59 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:43:59 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [31][2/2] pck/PCK@0.05: 0.445667\n", + "09/15 12:44:01 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:01 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 32 epochs\n", + "09/15 12:44:03 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:03 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [32][2/2] pck/PCK@0.05: 0.445784\n", + "09/15 12:44:04 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:04 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 33 epochs\n", + "09/15 12:44:06 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:06 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [33][2/2] pck/PCK@0.05: 0.434502\n", + "09/15 12:44:08 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:08 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 34 epochs\n", + "09/15 12:44:09 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:09 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [34][2/2] pck/PCK@0.05: 0.435661\n", + "09/15 12:44:11 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:11 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 35 epochs\n", + "09/15 12:44:12 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:12 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [35][2/2] pck/PCK@0.05: 0.425407\n", + "09/15 12:44:14 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:14 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 36 epochs\n", + "09/15 12:44:15 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:15 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [36][2/2] pck/PCK@0.05: 0.428712\n", + "09/15 12:44:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:17 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 37 epochs\n", + "09/15 12:44:18 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:18 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [37][2/2] pck/PCK@0.05: 0.423183\n", + "09/15 12:44:20 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:20 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 38 epochs\n", + "09/15 12:44:22 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:22 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [38][2/2] pck/PCK@0.05: 0.432350\n", + "09/15 12:44:23 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:23 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 39 epochs\n", + "09/15 12:44:25 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:25 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [39][2/2] pck/PCK@0.05: 0.423967\n", + "09/15 12:44:27 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Exp name: td-hm_hrnet-w32_8xb64-210e_coco-256x192_20220915_124206\n", + "09/15 12:44:27 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Saving checkpoint at 40 epochs\n", + "09/15 12:44:28 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Evaluating PCKAccuracy (normalized by ``\"bbox_size\"``)...\n", + "09/15 12:44:28 - mmengine - \u001b[4m\u001b[37mINFO\u001b[0m - Epoch(val) [40][2/2] pck/PCK@0.05: 0.429198\n" + ] + }, + { + "data": { + "text/plain": [ + "TopdownPoseEstimator(\n", + " (data_preprocessor): PoseDataPreprocessor()\n", + " (backbone): HRNet(\n", + " (conv1): Conv2d(3, 64, kernel_size=(3, 3), stride=(2, 2), padding=(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=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (layer1): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): 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", + " (transition1): ModuleList(\n", + " (0): Sequential(\n", + " (0): Conv2d(256, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(256, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (stage2): Sequential(\n", + " (0): HRModule(\n", + " (branches): ModuleList(\n", + " (0): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fuse_layers): ModuleList(\n", + " (0): ModuleList(\n", + " (0): None\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): None\n", + " )\n", + " )\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (transition2): ModuleList(\n", + " (0): None\n", + " (1): None\n", + " (2): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (stage3): Sequential(\n", + " (0): HRModule(\n", + " (branches): ModuleList(\n", + " (0): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fuse_layers): ModuleList(\n", + " (0): ModuleList(\n", + " (0): None\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): None\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " )\n", + " (2): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(32, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (2): None\n", + " )\n", + " )\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): HRModule(\n", + " (branches): ModuleList(\n", + " (0): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fuse_layers): ModuleList(\n", + " (0): ModuleList(\n", + " (0): None\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): None\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " )\n", + " (2): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(32, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (2): None\n", + " )\n", + " )\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): HRModule(\n", + " (branches): ModuleList(\n", + " (0): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fuse_layers): ModuleList(\n", + " (0): ModuleList(\n", + " (0): None\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): None\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " )\n", + " (2): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(32, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (2): None\n", + " )\n", + " )\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): HRModule(\n", + " (branches): ModuleList(\n", + " (0): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fuse_layers): ModuleList(\n", + " (0): ModuleList(\n", + " (0): None\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): None\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " )\n", + " (2): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(32, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (2): None\n", + " )\n", + " )\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (transition3): ModuleList(\n", + " (0): None\n", + " (1): None\n", + " (2): None\n", + " (3): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (stage4): Sequential(\n", + " (0): HRModule(\n", + " (branches): ModuleList(\n", + " (0): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (3): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fuse_layers): ModuleList(\n", + " (0): ModuleList(\n", + " (0): None\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " (3): Sequential(\n", + " (0): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=8.0, mode=nearest)\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): None\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (3): Sequential(\n", + " (0): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " )\n", + " (2): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(32, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (2): None\n", + " (3): Sequential(\n", + " (0): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " )\n", + " (3): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(32, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (3): None\n", + " )\n", + " )\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): HRModule(\n", + " (branches): ModuleList(\n", + " (0): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (3): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fuse_layers): ModuleList(\n", + " (0): ModuleList(\n", + " (0): None\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " (3): Sequential(\n", + " (0): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=8.0, mode=nearest)\n", + " )\n", + " )\n", + " (1): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): None\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (3): Sequential(\n", + " (0): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " )\n", + " (2): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(32, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (2): None\n", + " (3): Sequential(\n", + " (0): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " )\n", + " (3): ModuleList(\n", + " (0): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(32, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(32, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): ReLU(inplace=True)\n", + " )\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): Sequential(\n", + " (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (3): None\n", + " )\n", + " )\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): HRModule(\n", + " (branches): ModuleList(\n", + " (0): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (2): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (3): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): BasicBlock(\n", + " (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(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", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fuse_layers): ModuleList(\n", + " (0): ModuleList(\n", + " (0): None\n", + " (1): Sequential(\n", + " (0): Conv2d(64, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=2.0, mode=nearest)\n", + " )\n", + " (2): Sequential(\n", + " (0): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=4.0, mode=nearest)\n", + " )\n", + " (3): Sequential(\n", + " (0): Conv2d(256, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (2): Upsample(scale_factor=8.0, mode=nearest)\n", + " )\n", + " )\n", + " )\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " init_cfg={'type': 'Pretrained', 'checkpoint': 'https://download.openmmlab.com/mmpose/pretrain_models/hrnet_w32-36af842e.pth'}\n", + " (head): HeatmapHead(\n", + " (loss_module): KeypointMSELoss(\n", + " (criterion): MSELoss()\n", + " )\n", + " (deconv_layers): Identity()\n", + " (conv_layers): Identity()\n", + " (final_layer): Conv2d(32, 17, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " init_cfg=[{'type': 'Normal', 'layer': ['Conv2d', 'ConvTranspose2d'], 'std': 0.001}, {'type': 'Constant', 'layer': 'BatchNorm2d', 'val': 1}]\n", + ")" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from mmengine.config import Config, DictAction\n", + "from mmengine.runner import Runner\n", + "from mmpose.utils import register_all_modules\n", + "\n", + "# register all modules in mmpose into the registries\n", + "# do not init the default scope here because it will be init in the runner\n", + "register_all_modules(init_default_scope=False)\n", + "\n", + "# set preprocess configs to model\n", + "cfg.model.setdefault('data_preprocessor', cfg.get('preprocess_cfg', {}))\n", + "\n", + "# build the runner from config\n", + "runner = Runner.from_cfg(cfg)\n", + "\n", + "# start training\n", + "runner.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Note\n", + "The recommended best practice is to convert your customized data into COCO format." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zJyteZNGqwNk" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3.7.13 ('pt19cu113')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.13" + }, + "vscode": { + "interpreter": { + "hash": "da739a86cd93f7808d44852bc442711db64702daf7deb8b8d6704b313da8028c" + } + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "08e0412b8dd54d28a26c232e75ea6088": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_d2ee56f920a245d9875de8e37596a5c8", + "max": 132594821, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_b5f8c86d48a04afa997fc137e1acd716", + "value": 132594821 + } + }, + "13ac80b3ee9d4ce1bc1405a3d69c3c73": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_7abbd13654ff480183deb3d71dddf3e0", + "IPY_MODEL_59c9f043983849e19df8cc2f4253b04a", + "IPY_MODEL_990e4db4f7824bc994eff6ef91d4675b" + ], + "layout": "IPY_MODEL_d227d12439aa449cb267f393e43a1eff" + } + }, + "1c1b09d91dec4e3dadefe953daf50745": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "214f964729e140d5b8ab6ca5f342d416": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "21afdf2781cd45c3b541a769bfca494b": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2a079d9c0b9845318e6c612ca9601b86": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_3554753622334094961a47daf9362c59", + "IPY_MODEL_08e0412b8dd54d28a26c232e75ea6088", + "IPY_MODEL_558a9420b0b34be2a2ca8a8b8af9cbfc" + ], + "layout": "IPY_MODEL_a9bd3e477f07449788f0e95e3cd13ddc" + } + }, + "305bb5675d1a4a71ae47614db0c96b67": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3554753622334094961a47daf9362c59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_5b2ee1f3e78d4cd993009d04baf76b24", + "placeholder": "​", + "style": "IPY_MODEL_a3e5aa31c3f644b5a677ec49fe2e0832", + "value": "100%" + } + }, + "558a9420b0b34be2a2ca8a8b8af9cbfc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1c1b09d91dec4e3dadefe953daf50745", + "placeholder": "​", + "style": "IPY_MODEL_6af448aebdb744b98a2807f66b1d6e5d", + "value": " 126M/126M [00:14<00:00, 9.32MB/s]" + } + }, + "59c9f043983849e19df8cc2f4253b04a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c06dc4651af24be3ba658102043658f9", + "max": 167287506, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_7811af5efbc34360b06eb795ff9e7a6c", + "value": 167287506 + } + }, + "5b2ee1f3e78d4cd993009d04baf76b24": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6674d0f99ac94805840a1f7a216606c8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "6af448aebdb744b98a2807f66b1d6e5d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7811af5efbc34360b06eb795ff9e7a6c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7abbd13654ff480183deb3d71dddf3e0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_21afdf2781cd45c3b541a769bfca494b", + "placeholder": "​", + "style": "IPY_MODEL_305bb5675d1a4a71ae47614db0c96b67", + "value": "100%" + } + }, + "990e4db4f7824bc994eff6ef91d4675b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_214f964729e140d5b8ab6ca5f342d416", + "placeholder": "​", + "style": "IPY_MODEL_6674d0f99ac94805840a1f7a216606c8", + "value": " 160M/160M [00:18<00:00, 9.52MB/s]" + } + }, + "a3e5aa31c3f644b5a677ec49fe2e0832": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "DescriptionStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a9bd3e477f07449788f0e95e3cd13ddc": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b5f8c86d48a04afa997fc137e1acd716": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "1.5.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c06dc4651af24be3ba658102043658f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d227d12439aa449cb267f393e43a1eff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d2ee56f920a245d9875de8e37596a5c8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "1.2.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + } + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}