YOLOv5 Character is an object detection model trained on the 日本古典籍くずし字データセット.
" - -examples = [['『源氏物語』(東京大学総合図書館所蔵).jpg'], ['『源氏物語』(京都大学所蔵).jpg'], ['『平家物語』(国文学研究資料館提供).jpg']] -gr.Interface(yolo, inputs, outputs, title=title, description=description, article=article, examples=examples, theme="huggingface").launch(enable_queue=True) # cache_examples=True, \ No newline at end of file diff --git a/best.pt b/best.pt deleted file mode 100644 index b3e35840f3c7f4f701caf46e3dedd9a390988063..0000000000000000000000000000000000000000 --- a/best.pt +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:772f81467ecfbf27a5c9e2b5b1b8b783b94c1db6d56b41b4e7c83996365afc8e -size 691395070 diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index ad0bcd1da7860ea3c1dd94bf2878da0ea36a5886..0000000000000000000000000000000000000000 --- a/requirements.txt +++ /dev/null @@ -1,33 +0,0 @@ -# pip install -r requirements.txt - -# base ---------------------------------------- -matplotlib>=3.2.2 -numpy>=1.18.5 -opencv-python-headless -Pillow -PyYAML>=5.3.1 -scipy>=1.4.1 -torch>=1.7.0 -torchvision>=0.8.1 -tqdm>=4.41.0 - -# logging ------------------------------------- -tensorboard>=2.4.1 -# wandb - -# plotting ------------------------------------ -seaborn>=0.11.0 -pandas - -# export -------------------------------------- -# coremltools>=4.1 -# onnx>=1.9.0 -# scikit-learn==0.19.2 # for coreml quantization - -# extras -------------------------------------- -# Cython # for pycocotools https://github.com/cocodataset/cocoapi/issues/172 -# pycocotools>=2.0 # COCO mAP -# albumentations>=1.0.3 -thop # FLOPs computation - -gdown \ No newline at end of file diff --git a/ultralytics/yolov5/.dockerignore b/ultralytics/yolov5/.dockerignore deleted file mode 100644 index af51ccc3d8df7681ca03ea6f5b669bac37e6baa6..0000000000000000000000000000000000000000 --- a/ultralytics/yolov5/.dockerignore +++ /dev/null @@ -1,222 +0,0 @@ -# Repo-specific DockerIgnore ------------------------------------------------------------------------------------------- -#.git -.cache -.idea -runs -output -coco -storage.googleapis.com - -data/samples/* -**/results*.csv -*.jpg - -# Neural Network weights ----------------------------------------------------------------------------------------------- -**/*.pt -**/*.pth -**/*.onnx -**/*.engine -**/*.mlmodel -**/*.torchscript -**/*.torchscript.pt -**/*.tflite -**/*.h5 -**/*.pb -*_saved_model/ -*_web_model/ -*_openvino_model/ - -# Below Copied From .gitignore ----------------------------------------------------------------------------------------- -# Below Copied From .gitignore ----------------------------------------------------------------------------------------- - - -# GitHub Python GitIgnore ---------------------------------------------------------------------------------------------- -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -env/ -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -*.egg-info/ -wandb/ -.installed.cfg -*.egg - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -.hypothesis/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# pyenv -.python-version - -# celery beat schedule file -celerybeat-schedule - -# SageMath parsed files -*.sage.py - -# dotenv -.env - -# virtualenv -.venv* -venv*/ -ENV*/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ - - -# https://github.com/github/gitignore/blob/master/Global/macOS.gitignore ----------------------------------------------- - -# General -.DS_Store -.AppleDouble -.LSOverride - -# Icon must end with two \r -Icon -Icon? - -# Thumbnails -._* - -# Files that might appear in the root of a volume -.DocumentRevisions-V100 -.fseventsd -.Spotlight-V100 -.TemporaryItems -.Trashes -.VolumeIcon.icns -.com.apple.timemachine.donotpresent - -# Directories potentially created on remote AFP share -.AppleDB -.AppleDesktop -Network Trash Folder -Temporary Items -.apdisk - - -# https://github.com/github/gitignore/blob/master/Global/JetBrains.gitignore -# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm -# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 - -# User-specific stuff: -.idea/* -.idea/**/workspace.xml -.idea/**/tasks.xml -.idea/dictionaries -.html # Bokeh Plots -.pg # TensorFlow Frozen Graphs -.avi # videos - -# Sensitive or high-churn files: -.idea/**/dataSources/ -.idea/**/dataSources.ids -.idea/**/dataSources.local.xml -.idea/**/sqlDataSources.xml -.idea/**/dynamic.xml -.idea/**/uiDesigner.xml - -# Gradle: -.idea/**/gradle.xml -.idea/**/libraries - -# CMake -cmake-build-debug/ -cmake-build-release/ - -# Mongo Explorer plugin: -.idea/**/mongoSettings.xml - -## File-based project format: -*.iws - -## Plugin-specific files: - -# IntelliJ -out/ - -# mpeltonen/sbt-idea plugin -.idea_modules/ - -# JIRA plugin -atlassian-ide-plugin.xml - -# Cursive Clojure plugin -.idea/replstate.xml - -# Crashlytics plugin (for Android Studio and IntelliJ) -com_crashlytics_export_strings.xml -crashlytics.properties -crashlytics-build.properties -fabric.properties diff --git a/ultralytics/yolov5/.gitattributes b/ultralytics/yolov5/.gitattributes deleted file mode 100644 index dad4239ebad5b72917cbc4bba95206c1e55d519e..0000000000000000000000000000000000000000 --- a/ultralytics/yolov5/.gitattributes +++ /dev/null @@ -1,2 +0,0 @@ -# this drop notebooks from GitHub language stats -*.ipynb linguist-vendored diff --git a/ultralytics/yolov5/.gitignore b/ultralytics/yolov5/.gitignore deleted file mode 100644 index 69a00843ea42547a6e616ff78aff60f0dfdfa9cd..0000000000000000000000000000000000000000 --- a/ultralytics/yolov5/.gitignore +++ /dev/null @@ -1,256 +0,0 @@ -# Repo-specific GitIgnore ---------------------------------------------------------------------------------------------- -*.jpg -*.jpeg -*.png -*.bmp -*.tif -*.tiff -*.heic -*.JPG -*.JPEG -*.PNG -*.BMP -*.TIF -*.TIFF -*.HEIC -*.mp4 -*.mov -*.MOV -*.avi -*.data -*.json -*.cfg -!setup.cfg -!cfg/yolov3*.cfg - -storage.googleapis.com -runs/* -data/* -data/images/* -!data/*.yaml -!data/hyps -!data/scripts -!data/images -!data/images/zidane.jpg -!data/images/bus.jpg -!data/*.sh - -results*.csv - -# Datasets ------------------------------------------------------------------------------------------------------------- -coco/ -coco128/ -VOC/ - -# MATLAB GitIgnore ----------------------------------------------------------------------------------------------------- -*.m~ -*.mat -!targets*.mat - -# Neural Network weights ----------------------------------------------------------------------------------------------- -*.weights -*.pt -*.pb -*.onnx -*.engine -*.mlmodel -*.torchscript -*.tflite -*.h5 -*_saved_model/ -*_web_model/ -*_openvino_model/ -darknet53.conv.74 -yolov3-tiny.conv.15 - -# GitHub Python GitIgnore ---------------------------------------------------------------------------------------------- -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] -*$py.class - -# C extensions -*.so - -# Distribution / packaging -.Python -env/ -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -*.egg-info/ -/wandb/ -.installed.cfg -*.egg - - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*.cover -.hypothesis/ - -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -target/ - -# Jupyter Notebook -.ipynb_checkpoints - -# pyenv -.python-version - -# celery beat schedule file -celerybeat-schedule - -# SageMath parsed files -*.sage.py - -# dotenv -.env - -# virtualenv -.venv* -venv*/ -ENV*/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ - - -# https://github.com/github/gitignore/blob/master/Global/macOS.gitignore ----------------------------------------------- - -# General -.DS_Store -.AppleDouble -.LSOverride - -# Icon must end with two \r -Icon -Icon? - -# Thumbnails -._* - -# Files that might appear in the root of a volume -.DocumentRevisions-V100 -.fseventsd -.Spotlight-V100 -.TemporaryItems -.Trashes -.VolumeIcon.icns -.com.apple.timemachine.donotpresent - -# Directories potentially created on remote AFP share -.AppleDB -.AppleDesktop -Network Trash Folder -Temporary Items -.apdisk - - -# https://github.com/github/gitignore/blob/master/Global/JetBrains.gitignore -# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm -# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 - -# User-specific stuff: -.idea/* -.idea/**/workspace.xml -.idea/**/tasks.xml -.idea/dictionaries -.html # Bokeh Plots -.pg # TensorFlow Frozen Graphs -.avi # videos - -# Sensitive or high-churn files: -.idea/**/dataSources/ -.idea/**/dataSources.ids -.idea/**/dataSources.local.xml -.idea/**/sqlDataSources.xml -.idea/**/dynamic.xml -.idea/**/uiDesigner.xml - -# Gradle: -.idea/**/gradle.xml -.idea/**/libraries - -# CMake -cmake-build-debug/ -cmake-build-release/ - -# Mongo Explorer plugin: -.idea/**/mongoSettings.xml - -## File-based project format: -*.iws - -## Plugin-specific files: - -# IntelliJ -out/ - -# mpeltonen/sbt-idea plugin -.idea_modules/ - -# JIRA plugin -atlassian-ide-plugin.xml - -# Cursive Clojure plugin -.idea/replstate.xml - -# Crashlytics plugin (for Android Studio and IntelliJ) -com_crashlytics_export_strings.xml -crashlytics.properties -crashlytics-build.properties -fabric.properties diff --git a/ultralytics/yolov5/.pre-commit-config.yaml b/ultralytics/yolov5/.pre-commit-config.yaml deleted file mode 100644 index 526a5609fdd7e02720ee160c8ffb39813c7a2770..0000000000000000000000000000000000000000 --- a/ultralytics/yolov5/.pre-commit-config.yaml +++ /dev/null @@ -1,66 +0,0 @@ -# Define hooks for code formations -# Will be applied on any updated commit files if a user has installed and linked commit hook - -default_language_version: - python: python3.8 - -# Define bot property if installed via https://github.com/marketplace/pre-commit-ci -ci: - autofix_prs: true - autoupdate_commit_msg: '[pre-commit.ci] pre-commit suggestions' - autoupdate_schedule: quarterly - # submodules: true - -repos: - - repo: https://github.com/pre-commit/pre-commit-hooks - rev: v4.1.0 - hooks: - - id: end-of-file-fixer - - id: trailing-whitespace - - id: check-case-conflict - - id: check-yaml - - id: check-toml - - id: pretty-format-json - - id: check-docstring-first - - - repo: https://github.com/asottile/pyupgrade - rev: v2.31.0 - hooks: - - id: pyupgrade - args: [--py36-plus] - name: Upgrade code - - - repo: https://github.com/PyCQA/isort - rev: 5.10.1 - hooks: - - id: isort - name: Sort imports - - # TODO - #- repo: https://github.com/pre-commit/mirrors-yapf - # rev: v0.31.0 - # hooks: - # - id: yapf - # name: formatting - - # TODO - #- repo: https://github.com/executablebooks/mdformat - # rev: 0.7.7 - # hooks: - # - id: mdformat - # additional_dependencies: - # - mdformat-gfm - # - mdformat-black - # - mdformat_frontmatter - - # TODO - #- repo: https://github.com/asottile/yesqa - # rev: v1.2.3 - # hooks: - # - id: yesqa - - - repo: https://github.com/PyCQA/flake8 - rev: 4.0.1 - hooks: - - id: flake8 - name: PEP8 diff --git a/ultralytics/yolov5/CONTRIBUTING.md b/ultralytics/yolov5/CONTRIBUTING.md deleted file mode 100644 index ebde03a562a0bb263202632a504c8cac0d10cf17..0000000000000000000000000000000000000000 --- a/ultralytics/yolov5/CONTRIBUTING.md +++ /dev/null @@ -1,94 +0,0 @@ -## Contributing to YOLOv5 🚀 - -We love your input! We want to make contributing to YOLOv5 as easy and transparent as possible, whether it's: - -- Reporting a bug -- Discussing the current state of the code -- Submitting a fix -- Proposing a new feature -- Becoming a maintainer - -YOLOv5 works so well due to our combined community effort, and for every small improvement you contribute you will be -helping push the frontiers of what's possible in AI 😃! - -## Submitting a Pull Request (PR) 🛠️ - -Submitting a PR is easy! This example shows how to submit a PR for updating `requirements.txt` in 4 steps: - -### 1. Select File to Update - -Select `requirements.txt` to update by clicking on it in GitHub. -
-
- 
-
- 
- 
- 
- 
- 
--YOLOv5 🚀 is a family of object detection architectures and models pretrained on the COCO dataset, and represents Ultralytics - open-source research into future vision AI methods, incorporating lessons learned and best practices evolved over thousands of hours of research and development. -
- - - - - -
-
-
-
-## ![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "t6MPjfT5NrKQ"
- },
- "source": [
- "\n",
- "![](\"https://user-images.githubusercontent.com/26833433/125273437-35b3fc00-e30d-11eb-9079-46f313325424.png\")
\n",
- "\n",
- "This is the **official YOLOv5 🚀 notebook** by **Ultralytics**, and is freely available for redistribution under the [GPL-3.0 license](https://choosealicense.com/licenses/gpl-3.0/). \n",
- "For more information please visit https://github.com/ultralytics/yolov5 and https://ultralytics.com. Thank you!"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "7mGmQbAO5pQb"
- },
- "source": [
- "# Setup\n",
- "\n",
- "Clone repo, install dependencies and check PyTorch and GPU."
- ]
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "wbvMlHd_QwMG",
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "outputId": "3809e5a9-dd41-4577-fe62-5531abf7cca2"
- },
- "source": [
- "!git clone https://github.com/ultralytics/yolov5 # clone\n",
- "%cd yolov5\n",
- "%pip install -qr requirements.txt # install\n",
- "\n",
- "import torch\n",
- "from yolov5 import utils\n",
- "display = utils.notebook_init() # checks"
- ],
- "execution_count": null,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "YOLOv5 🚀 v6.0-48-g84a8099 torch 1.10.0+cu102 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)\n",
- "Setup complete ✅ (2 CPUs, 12.7 GB RAM, 42.2/166.8 GB disk)\n"
- ]
- }
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "4JnkELT0cIJg"
- },
- "source": [
- "# 1. Inference\n",
- "\n",
- "`detect.py` runs YOLOv5 inference on a variety of sources, downloading models automatically from the [latest YOLOv5 release](https://github.com/ultralytics/yolov5/releases), and saving results to `runs/detect`. Example inference sources are:\n",
- "\n",
- "```shell\n",
- "python detect.py --source 0 # webcam\n",
- " img.jpg # image \n",
- " vid.mp4 # video\n",
- " path/ # directory\n",
- " path/*.jpg # glob\n",
- " 'https://youtu.be/Zgi9g1ksQHc' # YouTube\n",
- " 'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP stream\n",
- "```"
- ]
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "zR9ZbuQCH7FX",
- "colab": {
- "base_uri": "https://localhost:8080/"
- },
- "outputId": "8f7e6588-215d-4ebd-93af-88b871e770a7"
- },
- "source": [
- "!python detect.py --weights yolov5s.pt --img 640 --conf 0.25 --source data/images\n",
- "display.Image(filename='runs/detect/exp/zidane.jpg', width=600)"
- ],
- "execution_count": null,
- "outputs": [
- {
- "output_type": "stream",
- "name": "stdout",
- "text": [
- "\u001b[34m\u001b[1mdetect: \u001b[0mweights=['yolov5s.pt'], source=data/images, imgsz=[640, 640], conf_thres=0.25, iou_thres=0.45, max_det=1000, device=, view_img=False, save_txt=False, save_conf=False, save_crop=False, nosave=False, classes=None, agnostic_nms=False, augment=False, visualize=False, update=False, project=runs/detect, name=exp, exist_ok=False, line_thickness=3, hide_labels=False, hide_conf=False, half=False, dnn=False\n",
- "YOLOv5 🚀 v6.0-48-g84a8099 torch 1.10.0+cu102 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)\n",
- "\n",
- "Fusing layers... \n",
- "Model Summary: 213 layers, 7225885 parameters, 0 gradients\n",
- "image 1/2 /content/yolov5/data/images/bus.jpg: 640x480 4 persons, 1 bus, Done. (0.007s)\n",
- "image 2/2 /content/yolov5/data/images/zidane.jpg: 384x640 2 persons, 1 tie, Done. (0.007s)\n",
- "Speed: 0.5ms pre-process, 6.9ms inference, 1.3ms NMS per image at shape (1, 3, 640, 640)\n",
- "Results saved to \u001b[1mruns/detect/exp\u001b[0m\n"
- ]
- }
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "hkAzDWJ7cWTr"
- },
- "source": [
- " \n",
- "![](\"https://user-images.githubusercontent.com/26833433/127574988-6a558aa1-d268-44b9-bf6b-62d4c605cc72.jpg\")
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "0eq1SMWl6Sfn"
- },
- "source": [
- "# 2. Validate\n",
- "Validate a model's accuracy on [COCO](https://cocodataset.org/#home) val or test-dev datasets. Models are downloaded automatically from the [latest YOLOv5 release](https://github.com/ultralytics/yolov5/releases). To show results by class use the `--verbose` flag. Note that `pycocotools` metrics may be ~1% better than the equivalent repo metrics, as is visible below, due to slight differences in mAP computation."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "eyTZYGgRjnMc"
- },
- "source": [
- "## COCO val\n",
- "Download [COCO val 2017](https://github.com/ultralytics/yolov5/blob/74b34872fdf41941cddcf243951cdb090fbac17b/data/coco.yaml#L14) dataset (1GB - 5000 images), and test model accuracy."
- ]
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "WQPtK1QYVaD_",
- "colab": {
- "base_uri": "https://localhost:8080/",
- "height": 48,
- "referenced_widgets": [
- "eb95db7cae194218b3fcefb439b6352f",
- "769ecde6f2e64bacb596ce972f8d3d2d",
- "384a001876054c93b0af45cd1e960bfe",
- "dded0aeae74440f7ba2ffa0beb8dd612",
- "5296d28be75740b2892ae421bbec3657",
- "9f09facb2a6c4a7096810d327c8b551c",
- "25621cff5d16448cb7260e839fd0f543",
- "0ce7164fc0c74bb9a2b5c7037375a727",
- "c4c4593c10904cb5b8a5724d60c7e181",
- "473371611126476c88d5d42ec7031ed6",
- "65efdfd0d26c46e79c8c5ff3b77126cc"
- ]
- },
- "outputId": "bcf9a448-1f9b-4a41-ad49-12f181faf05a"
- },
- "source": [
- "# Download COCO val\n",
- "torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip')\n",
- "!unzip -q tmp.zip -d ../datasets && rm tmp.zip"
- ],
- "execution_count": null,
- "outputs": [
- {
- "output_type": "display_data",
- "data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "eb95db7cae194218b3fcefb439b6352f",
- "version_minor": 0,
- "version_major": 2
- },
- "text/plain": [
- " 0%| | 0.00/780M [00:00![](\"https://uploads-ssl.webflow.com/5f6bc60e665f54545a1e52a5/615627e5824c9c6195abfda9_computer-vision-cycle.png\"/)
\n",
- "Close the active learning loop by sampling images from your inference conditions with the `roboflow` pip package\n",
- "![](\"https://uploads-ssl.webflow.com/5f6bc60e665f54545a1e52a5/6152a275ad4b4ac20cd2e21a_roboflow-annotate.gif\"/)
![\"Weights](\"https://user-images.githubusercontent.com/26833433/135390767-c28b050f-8455-4004-adb0-3b730386e2b2.png\")
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "-WPvRbS5Swl6"
- },
- "source": [
- "## Local Logging\n",
- "\n",
- "All results are logged by default to `runs/train`, with a new experiment directory created for each new training as `runs/train/exp2`, `runs/train/exp3`, etc. View train and val jpgs to see mosaics, labels, predictions and augmentation effects. Note an Ultralytics **Mosaic Dataloader** is used for training (shown below), which combines 4 images into 1 mosaic during training.\n",
- "\n",
- "> ![](\"https://user-images.githubusercontent.com/26833433/131255960-b536647f-7c61-4f60-bbc5-cb2544d71b2a.jpg\")
\n",
- "`train_batch0.jpg` shows train batch 0 mosaics and labels\n",
- "\n",
- "> ![](\"https://user-images.githubusercontent.com/26833433/131256748-603cafc7-55d1-4e58-ab26-83657761aed9.jpg\")
\n",
- "`test_batch0_labels.jpg` shows val batch 0 labels\n",
- "\n",
- "> ![](\"https://user-images.githubusercontent.com/26833433/131256752-3f25d7a5-7b0f-4bb3-ab78-46343c3800fe.jpg\")
\n",
- "`test_batch0_pred.jpg` shows val batch 0 _predictions_\n",
- "\n",
- "Training results are automatically logged to [Tensorboard](https://www.tensorflow.org/tensorboard) and [CSV](https://github.com/ultralytics/yolov5/pull/4148) as `results.csv`, which is plotted as `results.png` (below) after training completes. You can also plot any `results.csv` file manually:\n",
- "\n",
- "```python\n",
- "from utils.plots import plot_results \n",
- "plot_results('path/to/results.csv') # plot 'results.csv' as 'results.png'\n",
- "```\n",
- "\n",
- "![\"COCO128](\"https://user-images.githubusercontent.com/26833433/126906780-8c5e2990-6116-4de6-b78a-367244a33ccf.png\")
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "Zelyeqbyt3GD"
- },
- "source": [
- "# Environments\n",
- "\n",
- "YOLOv5 may be run in any of the following up-to-date verified environments (with all dependencies including [CUDA](https://developer.nvidia.com/cuda)/[CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/) and [PyTorch](https://pytorch.org/) preinstalled):\n",
- "\n",
- "- **Google Colab and Kaggle** notebooks with free GPU: ![\"Open](\"https://kaggle.com/static/images/open-in-kaggle.svg\")
\n",
- "- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/GCP-Quickstart)\n",
- "- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/AWS-Quickstart)\n",
- "- **Docker Image**. See [Docker Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/Docker-Quickstart) ![\"Docker](\"https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker\")
\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "6Qu7Iesl0p54"
- },
- "source": [
- "# Status\n",
- "\n",
- "\n",
- "\n",
- "If this badge is green, all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are currently passing. CI tests verify correct operation of YOLOv5 training ([train.py](https://github.com/ultralytics/yolov5/blob/master/train.py)), testing ([val.py](https://github.com/ultralytics/yolov5/blob/master/val.py)), inference ([detect.py](https://github.com/ultralytics/yolov5/blob/master/detect.py)) and export ([export.py](https://github.com/ultralytics/yolov5/blob/master/export.py)) on MacOS, Windows, and Ubuntu every 24 hours and on every commit.\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "id": "IEijrePND_2I"
- },
- "source": [
- "# Appendix\n",
- "\n",
- "Optional extras below. Unit tests validate repo functionality and should be run on any PRs submitted.\n"
- ]
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "mcKoSIK2WSzj"
- },
- "source": [
- "# Reproduce\n",
- "for x in 'yolov5n', 'yolov5s', 'yolov5m', 'yolov5l', 'yolov5x':\n",
- " !python val.py --weights {x}.pt --data coco.yaml --img 640 --task speed # speed\n",
- " !python val.py --weights {x}.pt --data coco.yaml --img 640 --conf 0.001 --iou 0.65 # mAP"
- ],
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "GMusP4OAxFu6"
- },
- "source": [
- "# PyTorch Hub\n",
- "import torch\n",
- "\n",
- "# Model\n",
- "model = torch.hub.load('ultralytics/yolov5', 'yolov5s')\n",
- "\n",
- "# Images\n",
- "dir = 'https://ultralytics.com/images/'\n",
- "imgs = [dir + f for f in ('zidane.jpg', 'bus.jpg')] # batch of images\n",
- "\n",
- "# Inference\n",
- "results = model(imgs)\n",
- "results.print() # or .show(), .save()"
- ],
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "FGH0ZjkGjejy"
- },
- "source": [
- "# CI Checks\n",
- "%%shell\n",
- "export PYTHONPATH=\"$PWD\" # to run *.py. files in subdirectories\n",
- "rm -rf runs # remove runs/\n",
- "for m in yolov5n; do # models\n",
- " python train.py --img 64 --batch 32 --weights $m.pt --epochs 1 --device 0 # train pretrained\n",
- " python train.py --img 64 --batch 32 --weights '' --cfg $m.yaml --epochs 1 --device 0 # train scratch\n",
- " for d in 0 cpu; do # devices\n",
- " python val.py --weights $m.pt --device $d # val official\n",
- " python val.py --weights runs/train/exp/weights/best.pt --device $d # val custom\n",
- " python detect.py --weights $m.pt --device $d # detect official\n",
- " python detect.py --weights runs/train/exp/weights/best.pt --device $d # detect custom\n",
- " done\n",
- " python hubconf.py # hub\n",
- " python models/yolo.py --cfg $m.yaml # build PyTorch model\n",
- " python models/tf.py --weights $m.pt # build TensorFlow model\n",
- " python export.py --img 64 --batch 1 --weights $m.pt --include torchscript onnx # export\n",
- "done"
- ],
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "gogI-kwi3Tye"
- },
- "source": [
- "# Profile\n",
- "from utils.torch_utils import profile\n",
- "\n",
- "m1 = lambda x: x * torch.sigmoid(x)\n",
- "m2 = torch.nn.SiLU()\n",
- "results = profile(input=torch.randn(16, 3, 640, 640), ops=[m1, m2], n=100)"
- ],
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "RVRSOhEvUdb5"
- },
- "source": [
- "# Evolve\n",
- "!python train.py --img 640 --batch 64 --epochs 100 --data coco128.yaml --weights yolov5s.pt --cache --noautoanchor --evolve\n",
- "!d=runs/train/evolve && cp evolve.* $d && zip -r evolve.zip $d && gsutil mv evolve.zip gs://bucket # upload results (optional)"
- ],
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "BSgFCAcMbk1R"
- },
- "source": [
- "# VOC\n",
- "for b, m in zip([64, 64, 32, 16], ['yolov5s', 'yolov5m', 'yolov5l', 'yolov5x']): # zip(batch_size, model)\n",
- " !python train.py --batch {b} --weights {m}.pt --data VOC.yaml --epochs 50 --cache --img 512 --nosave --hyp hyp.VOC.yaml --project VOC --name {m}"
- ],
- "execution_count": null,
- "outputs": []
- },
- {
- "cell_type": "code",
- "metadata": {
- "id": "VTRwsvA9u7ln"
- },
- "source": [
- "# TensorRT \n",
- "# https://docs.nvidia.com/deeplearning/tensorrt/install-guide/index.html#installing-pip\n",
- "!pip install -U nvidia-tensorrt --index-url https://pypi.ngc.nvidia.com # install\n",
- "!python export.py --weights yolov5s.pt --include engine --imgsz 640 640 --device 0 # export\n",
- "!python detect.py --weights yolov5s.engine --imgsz 640 640 --device 0 # inference"
- ],
- "execution_count": null,
- "outputs": []
- }
- ]
-}
diff --git a/ultralytics/yolov5/utils/__init__.py b/ultralytics/yolov5/utils/__init__.py
deleted file mode 100644
index a63c473a4340473f1036d483c165ece673b631e5..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/__init__.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-utils/initialization
-"""
-
-
-def notebook_init(verbose=True):
- # Check system software and hardware
- print('Checking setup...')
-
- import os
- import shutil
-
- from utils.general import check_requirements, emojis, is_colab
- from utils.torch_utils import select_device # imports
-
- check_requirements(('psutil', 'IPython'))
- import psutil
- from IPython import display # to display images and clear console output
-
- if is_colab():
- shutil.rmtree('/content/sample_data', ignore_errors=True) # remove colab /sample_data directory
-
- # System info
- if verbose:
- gb = 1 << 30 # bytes to GiB (1024 ** 3)
- ram = psutil.virtual_memory().total
- total, used, free = shutil.disk_usage("/")
- display.clear_output()
- s = f'({os.cpu_count()} CPUs, {ram / gb:.1f} GB RAM, {(total - free) / gb:.1f}/{total / gb:.1f} GB disk)'
- else:
- s = ''
-
- select_device(newline=False)
- print(emojis(f'Setup complete ✅ {s}'))
- return display
diff --git a/ultralytics/yolov5/utils/activations.py b/ultralytics/yolov5/utils/activations.py
deleted file mode 100644
index a4ff789cf336b4564e99198e0995bf39b8c79c15..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/activations.py
+++ /dev/null
@@ -1,101 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Activation functions
-"""
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-# SiLU https://arxiv.org/pdf/1606.08415.pdf ----------------------------------------------------------------------------
-class SiLU(nn.Module): # export-friendly version of nn.SiLU()
- @staticmethod
- def forward(x):
- return x * torch.sigmoid(x)
-
-
-class Hardswish(nn.Module): # export-friendly version of nn.Hardswish()
- @staticmethod
- def forward(x):
- # return x * F.hardsigmoid(x) # for TorchScript and CoreML
- return x * F.hardtanh(x + 3, 0.0, 6.0) / 6.0 # for TorchScript, CoreML and ONNX
-
-
-# Mish https://github.com/digantamisra98/Mish --------------------------------------------------------------------------
-class Mish(nn.Module):
- @staticmethod
- def forward(x):
- return x * F.softplus(x).tanh()
-
-
-class MemoryEfficientMish(nn.Module):
- class F(torch.autograd.Function):
- @staticmethod
- def forward(ctx, x):
- ctx.save_for_backward(x)
- return x.mul(torch.tanh(F.softplus(x))) # x * tanh(ln(1 + exp(x)))
-
- @staticmethod
- def backward(ctx, grad_output):
- x = ctx.saved_tensors[0]
- sx = torch.sigmoid(x)
- fx = F.softplus(x).tanh()
- return grad_output * (fx + x * sx * (1 - fx * fx))
-
- def forward(self, x):
- return self.F.apply(x)
-
-
-# FReLU https://arxiv.org/abs/2007.11824 -------------------------------------------------------------------------------
-class FReLU(nn.Module):
- def __init__(self, c1, k=3): # ch_in, kernel
- super().__init__()
- self.conv = nn.Conv2d(c1, c1, k, 1, 1, groups=c1, bias=False)
- self.bn = nn.BatchNorm2d(c1)
-
- def forward(self, x):
- return torch.max(x, self.bn(self.conv(x)))
-
-
-# ACON https://arxiv.org/pdf/2009.04759.pdf ----------------------------------------------------------------------------
-class AconC(nn.Module):
- r""" ACON activation (activate or not).
- AconC: (p1*x-p2*x) * sigmoid(beta*(p1*x-p2*x)) + p2*x, beta is a learnable parameter
- according to "Activate or Not: Learning Customized Activation"
-
-
-
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- $ python train.py --upload_data val
-
-
- {dataset}_wandb.yaml file which can be used to train from dataset artifact.
- $ python utils/logger/wandb/log_dataset.py --project ... --name ... --data ..
-
- 
- $ python train.py --data {data}_wandb.yaml
-
-
- $ python train.py --save_period 1
-
-
- --resume argument starts with wandb-artifact:// prefix followed by the run path, i.e, wandb-artifact://username/project/runid . This doesn't require the model checkpoint to be present on the local system.
-
- $ python train.py --resume wandb-artifact://{run_path}
-
-
- --upload_dataset or
- train from _wandb.yaml file and set --save_period
-
- $ python train.py --resume wandb-artifact://{run_path}
-
-
- 
-
-
-## Environments
-
-YOLOv5 may be run in any of the following up-to-date verified environments (with all dependencies including [CUDA](https://developer.nvidia.com/cuda)/[CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/) and [PyTorch](https://pytorch.org/) preinstalled):
-
-- **Google Colab and Kaggle** notebooks with free GPU:
-- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/GCP-Quickstart)
-- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/AWS-Quickstart)
-- **Docker Image**. See [Docker Quickstart Guide](https://github.com/ultralytics/yolov5/wiki/Docker-Quickstart)
-
-
-## Status
-
-
-
-If this badge is green, all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are currently passing. CI tests verify correct operation of YOLOv5 training ([train.py](https://github.com/ultralytics/yolov5/blob/master/train.py)), validation ([val.py](https://github.com/ultralytics/yolov5/blob/master/val.py)), inference ([detect.py](https://github.com/ultralytics/yolov5/blob/master/detect.py)) and export ([export.py](https://github.com/ultralytics/yolov5/blob/master/export.py)) on MacOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/yolov5/utils/loggers/wandb/__init__.py b/ultralytics/yolov5/utils/loggers/wandb/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/ultralytics/yolov5/utils/loggers/wandb/log_dataset.py b/ultralytics/yolov5/utils/loggers/wandb/log_dataset.py
deleted file mode 100644
index 06e81fb693072c99703e5c52b169892b7fd9a8cc..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/loggers/wandb/log_dataset.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import argparse
-
-from wandb_utils import WandbLogger
-
-from utils.general import LOGGER
-
-WANDB_ARTIFACT_PREFIX = 'wandb-artifact://'
-
-
-def create_dataset_artifact(opt):
- logger = WandbLogger(opt, None, job_type='Dataset Creation') # TODO: return value unused
- if not logger.wandb:
- LOGGER.info("install wandb using `pip install wandb` to log the dataset")
-
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser()
- parser.add_argument('--data', type=str, default='data/coco128.yaml', help='data.yaml path')
- parser.add_argument('--single-cls', action='store_true', help='train as single-class dataset')
- parser.add_argument('--project', type=str, default='YOLOv5', help='name of W&B Project')
- parser.add_argument('--entity', default=None, help='W&B entity')
- parser.add_argument('--name', type=str, default='log dataset', help='name of W&B run')
-
- opt = parser.parse_args()
- opt.resume = False # Explicitly disallow resume check for dataset upload job
-
- create_dataset_artifact(opt)
diff --git a/ultralytics/yolov5/utils/loggers/wandb/sweep.py b/ultralytics/yolov5/utils/loggers/wandb/sweep.py
deleted file mode 100644
index 206059bc30bff425fd3a7b2ee83a40a642a8e8c6..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/loggers/wandb/sweep.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import sys
-from pathlib import Path
-
-import wandb
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[3] # YOLOv5 root directory
-if str(ROOT) not in sys.path:
- sys.path.append(str(ROOT)) # add ROOT to PATH
-
-from train import parse_opt, train
-from utils.callbacks import Callbacks
-from utils.general import increment_path
-from utils.torch_utils import select_device
-
-
-def sweep():
- wandb.init()
- # Get hyp dict from sweep agent
- hyp_dict = vars(wandb.config).get("_items")
-
- # Workaround: get necessary opt args
- opt = parse_opt(known=True)
- opt.batch_size = hyp_dict.get("batch_size")
- opt.save_dir = str(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok or opt.evolve))
- opt.epochs = hyp_dict.get("epochs")
- opt.nosave = True
- opt.data = hyp_dict.get("data")
- opt.weights = str(opt.weights)
- opt.cfg = str(opt.cfg)
- opt.data = str(opt.data)
- opt.hyp = str(opt.hyp)
- opt.project = str(opt.project)
- device = select_device(opt.device, batch_size=opt.batch_size)
-
- # train
- train(hyp_dict, opt, device, callbacks=Callbacks())
-
-
-if __name__ == "__main__":
- sweep()
diff --git a/ultralytics/yolov5/utils/loggers/wandb/sweep.yaml b/ultralytics/yolov5/utils/loggers/wandb/sweep.yaml
deleted file mode 100644
index 688b1ea0285f42e779d301ba910bf4e9fe50305c..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/loggers/wandb/sweep.yaml
+++ /dev/null
@@ -1,143 +0,0 @@
-# Hyperparameters for training
-# To set range-
-# Provide min and max values as:
-# parameter:
-#
-# min: scalar
-# max: scalar
-# OR
-#
-# Set a specific list of search space-
-# parameter:
-# values: [scalar1, scalar2, scalar3...]
-#
-# You can use grid, bayesian and hyperopt search strategy
-# For more info on configuring sweeps visit - https://docs.wandb.ai/guides/sweeps/configuration
-
-program: utils/loggers/wandb/sweep.py
-method: random
-metric:
- name: metrics/mAP_0.5
- goal: maximize
-
-parameters:
- # hyperparameters: set either min, max range or values list
- data:
- value: "data/coco128.yaml"
- batch_size:
- values: [64]
- epochs:
- values: [10]
-
- lr0:
- distribution: uniform
- min: 1e-5
- max: 1e-1
- lrf:
- distribution: uniform
- min: 0.01
- max: 1.0
- momentum:
- distribution: uniform
- min: 0.6
- max: 0.98
- weight_decay:
- distribution: uniform
- min: 0.0
- max: 0.001
- warmup_epochs:
- distribution: uniform
- min: 0.0
- max: 5.0
- warmup_momentum:
- distribution: uniform
- min: 0.0
- max: 0.95
- warmup_bias_lr:
- distribution: uniform
- min: 0.0
- max: 0.2
- box:
- distribution: uniform
- min: 0.02
- max: 0.2
- cls:
- distribution: uniform
- min: 0.2
- max: 4.0
- cls_pw:
- distribution: uniform
- min: 0.5
- max: 2.0
- obj:
- distribution: uniform
- min: 0.2
- max: 4.0
- obj_pw:
- distribution: uniform
- min: 0.5
- max: 2.0
- iou_t:
- distribution: uniform
- min: 0.1
- max: 0.7
- anchor_t:
- distribution: uniform
- min: 2.0
- max: 8.0
- fl_gamma:
- distribution: uniform
- min: 0.0
- max: 4.0
- hsv_h:
- distribution: uniform
- min: 0.0
- max: 0.1
- hsv_s:
- distribution: uniform
- min: 0.0
- max: 0.9
- hsv_v:
- distribution: uniform
- min: 0.0
- max: 0.9
- degrees:
- distribution: uniform
- min: 0.0
- max: 45.0
- translate:
- distribution: uniform
- min: 0.0
- max: 0.9
- scale:
- distribution: uniform
- min: 0.0
- max: 0.9
- shear:
- distribution: uniform
- min: 0.0
- max: 10.0
- perspective:
- distribution: uniform
- min: 0.0
- max: 0.001
- flipud:
- distribution: uniform
- min: 0.0
- max: 1.0
- fliplr:
- distribution: uniform
- min: 0.0
- max: 1.0
- mosaic:
- distribution: uniform
- min: 0.0
- max: 1.0
- mixup:
- distribution: uniform
- min: 0.0
- max: 1.0
- copy_paste:
- distribution: uniform
- min: 0.0
- max: 1.0
diff --git a/ultralytics/yolov5/utils/loggers/wandb/wandb_utils.py b/ultralytics/yolov5/utils/loggers/wandb/wandb_utils.py
deleted file mode 100644
index 786e58a1997298417a5a971cee48f290ea173544..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/loggers/wandb/wandb_utils.py
+++ /dev/null
@@ -1,562 +0,0 @@
-"""Utilities and tools for tracking runs with Weights & Biases."""
-
-import logging
-import os
-import sys
-from contextlib import contextmanager
-from pathlib import Path
-from typing import Dict
-
-import yaml
-from tqdm import tqdm
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[3] # YOLOv5 root directory
-if str(ROOT) not in sys.path:
- sys.path.append(str(ROOT)) # add ROOT to PATH
-
-from utils.datasets import LoadImagesAndLabels, img2label_paths
-from utils.general import LOGGER, check_dataset, check_file
-
-try:
- import wandb
-
- assert hasattr(wandb, '__version__') # verify package import not local dir
-except (ImportError, AssertionError):
- wandb = None
-
-RANK = int(os.getenv('RANK', -1))
-WANDB_ARTIFACT_PREFIX = 'wandb-artifact://'
-
-
-def remove_prefix(from_string, prefix=WANDB_ARTIFACT_PREFIX):
- return from_string[len(prefix):]
-
-
-def check_wandb_config_file(data_config_file):
- wandb_config = '_wandb.'.join(data_config_file.rsplit('.', 1)) # updated data.yaml path
- if Path(wandb_config).is_file():
- return wandb_config
- return data_config_file
-
-
-def check_wandb_dataset(data_file):
- is_trainset_wandb_artifact = False
- is_valset_wandb_artifact = False
- if check_file(data_file) and data_file.endswith('.yaml'):
- with open(data_file, errors='ignore') as f:
- data_dict = yaml.safe_load(f)
- is_trainset_wandb_artifact = (isinstance(data_dict['train'], str) and
- data_dict['train'].startswith(WANDB_ARTIFACT_PREFIX))
- is_valset_wandb_artifact = (isinstance(data_dict['val'], str) and
- data_dict['val'].startswith(WANDB_ARTIFACT_PREFIX))
- if is_trainset_wandb_artifact or is_valset_wandb_artifact:
- return data_dict
- else:
- return check_dataset(data_file)
-
-
-def get_run_info(run_path):
- run_path = Path(remove_prefix(run_path, WANDB_ARTIFACT_PREFIX))
- run_id = run_path.stem
- project = run_path.parent.stem
- entity = run_path.parent.parent.stem
- model_artifact_name = 'run_' + run_id + '_model'
- return entity, project, run_id, model_artifact_name
-
-
-def check_wandb_resume(opt):
- process_wandb_config_ddp_mode(opt) if RANK not in [-1, 0] else None
- if isinstance(opt.resume, str):
- if opt.resume.startswith(WANDB_ARTIFACT_PREFIX):
- if RANK not in [-1, 0]: # For resuming DDP runs
- entity, project, run_id, model_artifact_name = get_run_info(opt.resume)
- api = wandb.Api()
- artifact = api.artifact(entity + '/' + project + '/' + model_artifact_name + ':latest')
- modeldir = artifact.download()
- opt.weights = str(Path(modeldir) / "last.pt")
- return True
- return None
-
-
-def process_wandb_config_ddp_mode(opt):
- with open(check_file(opt.data), errors='ignore') as f:
- data_dict = yaml.safe_load(f) # data dict
- train_dir, val_dir = None, None
- if isinstance(data_dict['train'], str) and data_dict['train'].startswith(WANDB_ARTIFACT_PREFIX):
- api = wandb.Api()
- train_artifact = api.artifact(remove_prefix(data_dict['train']) + ':' + opt.artifact_alias)
- train_dir = train_artifact.download()
- train_path = Path(train_dir) / 'data/images/'
- data_dict['train'] = str(train_path)
-
- if isinstance(data_dict['val'], str) and data_dict['val'].startswith(WANDB_ARTIFACT_PREFIX):
- api = wandb.Api()
- val_artifact = api.artifact(remove_prefix(data_dict['val']) + ':' + opt.artifact_alias)
- val_dir = val_artifact.download()
- val_path = Path(val_dir) / 'data/images/'
- data_dict['val'] = str(val_path)
- if train_dir or val_dir:
- ddp_data_path = str(Path(val_dir) / 'wandb_local_data.yaml')
- with open(ddp_data_path, 'w') as f:
- yaml.safe_dump(data_dict, f)
- opt.data = ddp_data_path
-
-
-class WandbLogger():
- """Log training runs, datasets, models, and predictions to Weights & Biases.
-
- This logger sends information to W&B at wandb.ai. By default, this information
- includes hyperparameters, system configuration and metrics, model metrics,
- and basic data metrics and analyses.
-
- By providing additional command line arguments to train.py, datasets,
- models and predictions can also be logged.
-
- For more on how this logger is used, see the Weights & Biases documentation:
- https://docs.wandb.com/guides/integrations/yolov5
- """
-
- def __init__(self, opt, run_id=None, job_type='Training'):
- """
- - Initialize WandbLogger instance
- - Upload dataset if opt.upload_dataset is True
- - Setup trainig processes if job_type is 'Training'
-
- arguments:
- opt (namespace) -- Commandline arguments for this run
- run_id (str) -- Run ID of W&B run to be resumed
- job_type (str) -- To set the job_type for this run
-
- """
- # Pre-training routine --
- self.job_type = job_type
- self.wandb, self.wandb_run = wandb, None if not wandb else wandb.run
- self.val_artifact, self.train_artifact = None, None
- self.train_artifact_path, self.val_artifact_path = None, None
- self.result_artifact = None
- self.val_table, self.result_table = None, None
- self.bbox_media_panel_images = []
- self.val_table_path_map = None
- self.max_imgs_to_log = 16
- self.wandb_artifact_data_dict = None
- self.data_dict = None
- # It's more elegant to stick to 1 wandb.init call,
- # but useful config data is overwritten in the WandbLogger's wandb.init call
- if isinstance(opt.resume, str): # checks resume from artifact
- if opt.resume.startswith(WANDB_ARTIFACT_PREFIX):
- entity, project, run_id, model_artifact_name = get_run_info(opt.resume)
- model_artifact_name = WANDB_ARTIFACT_PREFIX + model_artifact_name
- assert wandb, 'install wandb to resume wandb runs'
- # Resume wandb-artifact:// runs here| workaround for not overwriting wandb.config
- self.wandb_run = wandb.init(id=run_id,
- project=project,
- entity=entity,
- resume='allow',
- allow_val_change=True)
- opt.resume = model_artifact_name
- elif self.wandb:
- self.wandb_run = wandb.init(config=opt,
- resume="allow",
- project='YOLOv5' if opt.project == 'runs/train' else Path(opt.project).stem,
- entity=opt.entity,
- name=opt.name if opt.name != 'exp' else None,
- job_type=job_type,
- id=run_id,
- allow_val_change=True) if not wandb.run else wandb.run
- if self.wandb_run:
- if self.job_type == 'Training':
- if opt.upload_dataset:
- if not opt.resume:
- self.wandb_artifact_data_dict = self.check_and_upload_dataset(opt)
-
- if opt.resume:
- # resume from artifact
- if isinstance(opt.resume, str) and opt.resume.startswith(WANDB_ARTIFACT_PREFIX):
- self.data_dict = dict(self.wandb_run.config.data_dict)
- else: # local resume
- self.data_dict = check_wandb_dataset(opt.data)
- else:
- self.data_dict = check_wandb_dataset(opt.data)
- self.wandb_artifact_data_dict = self.wandb_artifact_data_dict or self.data_dict
-
- # write data_dict to config. useful for resuming from artifacts. Do this only when not resuming.
- self.wandb_run.config.update({'data_dict': self.wandb_artifact_data_dict},
- allow_val_change=True)
- self.setup_training(opt)
-
- if self.job_type == 'Dataset Creation':
- self.wandb_run.config.update({"upload_dataset": True})
- self.data_dict = self.check_and_upload_dataset(opt)
-
- def check_and_upload_dataset(self, opt):
- """
- Check if the dataset format is compatible and upload it as W&B artifact
-
- arguments:
- opt (namespace)-- Commandline arguments for current run
-
- returns:
- Updated dataset info dictionary where local dataset paths are replaced by WAND_ARFACT_PREFIX links.
- """
- assert wandb, 'Install wandb to upload dataset'
- config_path = self.log_dataset_artifact(opt.data,
- opt.single_cls,
- 'YOLOv5' if opt.project == 'runs/train' else Path(opt.project).stem)
- with open(config_path, errors='ignore') as f:
- wandb_data_dict = yaml.safe_load(f)
- return wandb_data_dict
-
- def setup_training(self, opt):
- """
- Setup the necessary processes for training YOLO models:
- - Attempt to download model checkpoint and dataset artifacts if opt.resume stats with WANDB_ARTIFACT_PREFIX
- - Update data_dict, to contain info of previous run if resumed and the paths of dataset artifact if downloaded
- - Setup log_dict, initialize bbox_interval
-
- arguments:
- opt (namespace) -- commandline arguments for this run
-
- """
- self.log_dict, self.current_epoch = {}, 0
- self.bbox_interval = opt.bbox_interval
- if isinstance(opt.resume, str):
- modeldir, _ = self.download_model_artifact(opt)
- if modeldir:
- self.weights = Path(modeldir) / "last.pt"
- config = self.wandb_run.config
- opt.weights, opt.save_period, opt.batch_size, opt.bbox_interval, opt.epochs, opt.hyp, opt.imgsz = str(
- self.weights), config.save_period, config.batch_size, config.bbox_interval, config.epochs,\
- config.hyp, config.imgsz
- data_dict = self.data_dict
- if self.val_artifact is None: # If --upload_dataset is set, use the existing artifact, don't download
- self.train_artifact_path, self.train_artifact = self.download_dataset_artifact(data_dict.get('train'),
- opt.artifact_alias)
- self.val_artifact_path, self.val_artifact = self.download_dataset_artifact(data_dict.get('val'),
- opt.artifact_alias)
-
- if self.train_artifact_path is not None:
- train_path = Path(self.train_artifact_path) / 'data/images/'
- data_dict['train'] = str(train_path)
- if self.val_artifact_path is not None:
- val_path = Path(self.val_artifact_path) / 'data/images/'
- data_dict['val'] = str(val_path)
-
- if self.val_artifact is not None:
- self.result_artifact = wandb.Artifact("run_" + wandb.run.id + "_progress", "evaluation")
- columns = ["epoch", "id", "ground truth", "prediction"]
- columns.extend(self.data_dict['names'])
- self.result_table = wandb.Table(columns)
- self.val_table = self.val_artifact.get("val")
- if self.val_table_path_map is None:
- self.map_val_table_path()
- if opt.bbox_interval == -1:
- self.bbox_interval = opt.bbox_interval = (opt.epochs // 10) if opt.epochs > 10 else 1
- if opt.evolve:
- self.bbox_interval = opt.bbox_interval = opt.epochs + 1
- train_from_artifact = self.train_artifact_path is not None and self.val_artifact_path is not None
- # Update the the data_dict to point to local artifacts dir
- if train_from_artifact:
- self.data_dict = data_dict
-
- def download_dataset_artifact(self, path, alias):
- """
- download the model checkpoint artifact if the path starts with WANDB_ARTIFACT_PREFIX
-
- arguments:
- path -- path of the dataset to be used for training
- alias (str)-- alias of the artifact to be download/used for training
-
- returns:
- (str, wandb.Artifact) -- path of the downladed dataset and it's corresponding artifact object if dataset
- is found otherwise returns (None, None)
- """
- if isinstance(path, str) and path.startswith(WANDB_ARTIFACT_PREFIX):
- artifact_path = Path(remove_prefix(path, WANDB_ARTIFACT_PREFIX) + ":" + alias)
- dataset_artifact = wandb.use_artifact(artifact_path.as_posix().replace("\\", "/"))
- assert dataset_artifact is not None, "'Error: W&B dataset artifact doesn\'t exist'"
- datadir = dataset_artifact.download()
- return datadir, dataset_artifact
- return None, None
-
- def download_model_artifact(self, opt):
- """
- download the model checkpoint artifact if the resume path starts with WANDB_ARTIFACT_PREFIX
-
- arguments:
- opt (namespace) -- Commandline arguments for this run
- """
- if opt.resume.startswith(WANDB_ARTIFACT_PREFIX):
- model_artifact = wandb.use_artifact(remove_prefix(opt.resume, WANDB_ARTIFACT_PREFIX) + ":latest")
- assert model_artifact is not None, 'Error: W&B model artifact doesn\'t exist'
- modeldir = model_artifact.download()
- # epochs_trained = model_artifact.metadata.get('epochs_trained')
- total_epochs = model_artifact.metadata.get('total_epochs')
- is_finished = total_epochs is None
- assert not is_finished, 'training is finished, can only resume incomplete runs.'
- return modeldir, model_artifact
- return None, None
-
- def log_model(self, path, opt, epoch, fitness_score, best_model=False):
- """
- Log the model checkpoint as W&B artifact
-
- arguments:
- path (Path) -- Path of directory containing the checkpoints
- opt (namespace) -- Command line arguments for this run
- epoch (int) -- Current epoch number
- fitness_score (float) -- fitness score for current epoch
- best_model (boolean) -- Boolean representing if the current checkpoint is the best yet.
- """
- model_artifact = wandb.Artifact('run_' + wandb.run.id + '_model', type='model', metadata={
- 'original_url': str(path),
- 'epochs_trained': epoch + 1,
- 'save period': opt.save_period,
- 'project': opt.project,
- 'total_epochs': opt.epochs,
- 'fitness_score': fitness_score
- })
- model_artifact.add_file(str(path / 'last.pt'), name='last.pt')
- wandb.log_artifact(model_artifact,
- aliases=['latest', 'last', 'epoch ' + str(self.current_epoch), 'best' if best_model else ''])
- LOGGER.info(f"Saving model artifact on epoch {epoch + 1}")
-
- def log_dataset_artifact(self, data_file, single_cls, project, overwrite_config=False):
- """
- Log the dataset as W&B artifact and return the new data file with W&B links
-
- arguments:
- data_file (str) -- the .yaml file with information about the dataset like - path, classes etc.
- single_class (boolean) -- train multi-class data as single-class
- project (str) -- project name. Used to construct the artifact path
- overwrite_config (boolean) -- overwrites the data.yaml file if set to true otherwise creates a new
- file with _wandb postfix. Eg -> data_wandb.yaml
-
- returns:
- the new .yaml file with artifact links. it can be used to start training directly from artifacts
- """
- upload_dataset = self.wandb_run.config.upload_dataset
- log_val_only = isinstance(upload_dataset, str) and upload_dataset == 'val'
- self.data_dict = check_dataset(data_file) # parse and check
- data = dict(self.data_dict)
- nc, names = (1, ['item']) if single_cls else (int(data['nc']), data['names'])
- names = {k: v for k, v in enumerate(names)} # to index dictionary
-
- # log train set
- if not log_val_only:
- self.train_artifact = self.create_dataset_table(LoadImagesAndLabels(
- data['train'], rect=True, batch_size=1), names, name='train') if data.get('train') else None
- if data.get('train'):
- data['train'] = WANDB_ARTIFACT_PREFIX + str(Path(project) / 'train')
-
- self.val_artifact = self.create_dataset_table(LoadImagesAndLabels(
- data['val'], rect=True, batch_size=1), names, name='val') if data.get('val') else None
- if data.get('val'):
- data['val'] = WANDB_ARTIFACT_PREFIX + str(Path(project) / 'val')
-
- path = Path(data_file)
- # create a _wandb.yaml file with artifacts links if both train and test set are logged
- if not log_val_only:
- path = (path.stem if overwrite_config else path.stem + '_wandb') + '.yaml' # updated data.yaml path
- path = ROOT / 'data' / path
- data.pop('download', None)
- data.pop('path', None)
- with open(path, 'w') as f:
- yaml.safe_dump(data, f)
- LOGGER.info(f"Created dataset config file {path}")
-
- if self.job_type == 'Training': # builds correct artifact pipeline graph
- if not log_val_only:
- self.wandb_run.log_artifact(
- self.train_artifact) # calling use_artifact downloads the dataset. NOT NEEDED!
- self.wandb_run.use_artifact(self.val_artifact)
- self.val_artifact.wait()
- self.val_table = self.val_artifact.get('val')
- self.map_val_table_path()
- else:
- self.wandb_run.log_artifact(self.train_artifact)
- self.wandb_run.log_artifact(self.val_artifact)
- return path
-
- def map_val_table_path(self):
- """
- Map the validation dataset Table like name of file -> it's id in the W&B Table.
- Useful for - referencing artifacts for evaluation.
- """
- self.val_table_path_map = {}
- LOGGER.info("Mapping dataset")
- for i, data in enumerate(tqdm(self.val_table.data)):
- self.val_table_path_map[data[3]] = data[0]
-
- def create_dataset_table(self, dataset: LoadImagesAndLabels, class_to_id: Dict[int, str], name: str = 'dataset'):
- """
- Create and return W&B artifact containing W&B Table of the dataset.
-
- arguments:
- dataset -- instance of LoadImagesAndLabels class used to iterate over the data to build Table
- class_to_id -- hash map that maps class ids to labels
- name -- name of the artifact
-
- returns:
- dataset artifact to be logged or used
- """
- # TODO: Explore multiprocessing to slpit this loop parallely| This is essential for speeding up the the logging
- artifact = wandb.Artifact(name=name, type="dataset")
- img_files = tqdm([dataset.path]) if isinstance(dataset.path, str) and Path(dataset.path).is_dir() else None
- img_files = tqdm(dataset.im_files) if not img_files else img_files
- for img_file in img_files:
- if Path(img_file).is_dir():
- artifact.add_dir(img_file, name='data/images')
- labels_path = 'labels'.join(dataset.path.rsplit('images', 1))
- artifact.add_dir(labels_path, name='data/labels')
- else:
- artifact.add_file(img_file, name='data/images/' + Path(img_file).name)
- label_file = Path(img2label_paths([img_file])[0])
- artifact.add_file(str(label_file),
- name='data/labels/' + label_file.name) if label_file.exists() else None
- table = wandb.Table(columns=["id", "train_image", "Classes", "name"])
- class_set = wandb.Classes([{'id': id, 'name': name} for id, name in class_to_id.items()])
- for si, (img, labels, paths, shapes) in enumerate(tqdm(dataset)):
- box_data, img_classes = [], {}
- for cls, *xywh in labels[:, 1:].tolist():
- cls = int(cls)
- box_data.append({"position": {"middle": [xywh[0], xywh[1]], "width": xywh[2], "height": xywh[3]},
- "class_id": cls,
- "box_caption": "%s" % (class_to_id[cls])})
- img_classes[cls] = class_to_id[cls]
- boxes = {"ground_truth": {"box_data": box_data, "class_labels": class_to_id}} # inference-space
- table.add_data(si, wandb.Image(paths, classes=class_set, boxes=boxes), list(img_classes.values()),
- Path(paths).name)
- artifact.add(table, name)
- return artifact
-
- def log_training_progress(self, predn, path, names):
- """
- Build evaluation Table. Uses reference from validation dataset table.
-
- arguments:
- predn (list): list of predictions in the native space in the format - [xmin, ymin, xmax, ymax, confidence, class]
- path (str): local path of the current evaluation image
- names (dict(int, str)): hash map that maps class ids to labels
- """
- class_set = wandb.Classes([{'id': id, 'name': name} for id, name in names.items()])
- box_data = []
- avg_conf_per_class = [0] * len(self.data_dict['names'])
- pred_class_count = {}
- for *xyxy, conf, cls in predn.tolist():
- if conf >= 0.25:
- cls = int(cls)
- box_data.append(
- {"position": {"minX": xyxy[0], "minY": xyxy[1], "maxX": xyxy[2], "maxY": xyxy[3]},
- "class_id": cls,
- "box_caption": f"{names[cls]} {conf:.3f}",
- "scores": {"class_score": conf},
- "domain": "pixel"})
- avg_conf_per_class[cls] += conf
-
- if cls in pred_class_count:
- pred_class_count[cls] += 1
- else:
- pred_class_count[cls] = 1
-
- for pred_class in pred_class_count.keys():
- avg_conf_per_class[pred_class] = avg_conf_per_class[pred_class] / pred_class_count[pred_class]
-
- boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space
- id = self.val_table_path_map[Path(path).name]
- self.result_table.add_data(self.current_epoch,
- id,
- self.val_table.data[id][1],
- wandb.Image(self.val_table.data[id][1], boxes=boxes, classes=class_set),
- *avg_conf_per_class
- )
-
- def val_one_image(self, pred, predn, path, names, im):
- """
- Log validation data for one image. updates the result Table if validation dataset is uploaded and log bbox media panel
-
- arguments:
- pred (list): list of scaled predictions in the format - [xmin, ymin, xmax, ymax, confidence, class]
- predn (list): list of predictions in the native space - [xmin, ymin, xmax, ymax, confidence, class]
- path (str): local path of the current evaluation image
- """
- if self.val_table and self.result_table: # Log Table if Val dataset is uploaded as artifact
- self.log_training_progress(predn, path, names)
-
- if len(self.bbox_media_panel_images) < self.max_imgs_to_log and self.current_epoch > 0:
- if self.current_epoch % self.bbox_interval == 0:
- box_data = [{"position": {"minX": xyxy[0], "minY": xyxy[1], "maxX": xyxy[2], "maxY": xyxy[3]},
- "class_id": int(cls),
- "box_caption": f"{names[int(cls)]} {conf:.3f}",
- "scores": {"class_score": conf},
- "domain": "pixel"} for *xyxy, conf, cls in pred.tolist()]
- boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space
- self.bbox_media_panel_images.append(wandb.Image(im, boxes=boxes, caption=path.name))
-
- def log(self, log_dict):
- """
- save the metrics to the logging dictionary
-
- arguments:
- log_dict (Dict) -- metrics/media to be logged in current step
- """
- if self.wandb_run:
- for key, value in log_dict.items():
- self.log_dict[key] = value
-
- def end_epoch(self, best_result=False):
- """
- commit the log_dict, model artifacts and Tables to W&B and flush the log_dict.
-
- arguments:
- best_result (boolean): Boolean representing if the result of this evaluation is best or not
- """
- if self.wandb_run:
- with all_logging_disabled():
- if self.bbox_media_panel_images:
- self.log_dict["BoundingBoxDebugger"] = self.bbox_media_panel_images
- try:
- wandb.log(self.log_dict)
- except BaseException as e:
- LOGGER.info(
- f"An error occurred in wandb logger. The training will proceed without interruption. More info\n{e}")
- self.wandb_run.finish()
- self.wandb_run = None
-
- self.log_dict = {}
- self.bbox_media_panel_images = []
- if self.result_artifact:
- self.result_artifact.add(self.result_table, 'result')
- wandb.log_artifact(self.result_artifact, aliases=['latest', 'last', 'epoch ' + str(self.current_epoch),
- ('best' if best_result else '')])
-
- wandb.log({"evaluation": self.result_table})
- columns = ["epoch", "id", "ground truth", "prediction"]
- columns.extend(self.data_dict['names'])
- self.result_table = wandb.Table(columns)
- self.result_artifact = wandb.Artifact("run_" + wandb.run.id + "_progress", "evaluation")
-
- def finish_run(self):
- """
- Log metrics if any and finish the current W&B run
- """
- if self.wandb_run:
- if self.log_dict:
- with all_logging_disabled():
- wandb.log(self.log_dict)
- wandb.run.finish()
-
-
-@contextmanager
-def all_logging_disabled(highest_level=logging.CRITICAL):
- """ source - https://gist.github.com/simon-weber/7853144
- A context manager that will prevent any logging messages triggered during the body from being processed.
- :param highest_level: the maximum logging level in use.
- This would only need to be changed if a custom level greater than CRITICAL is defined.
- """
- previous_level = logging.root.manager.disable
- logging.disable(highest_level)
- try:
- yield
- finally:
- logging.disable(previous_level)
diff --git a/ultralytics/yolov5/utils/loss.py b/ultralytics/yolov5/utils/loss.py
deleted file mode 100644
index bf9b592d4ad27f897cf154c75fd2767acf828a08..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/loss.py
+++ /dev/null
@@ -1,228 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Loss functions
-"""
-
-import torch
-import torch.nn as nn
-
-from utils.metrics import bbox_iou
-from utils.torch_utils import de_parallel
-
-
-def smooth_BCE(eps=0.1): # https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441
- # return positive, negative label smoothing BCE targets
- return 1.0 - 0.5 * eps, 0.5 * eps
-
-
-class BCEBlurWithLogitsLoss(nn.Module):
- # BCEwithLogitLoss() with reduced missing label effects.
- def __init__(self, alpha=0.05):
- super().__init__()
- self.loss_fcn = nn.BCEWithLogitsLoss(reduction='none') # must be nn.BCEWithLogitsLoss()
- self.alpha = alpha
-
- def forward(self, pred, true):
- loss = self.loss_fcn(pred, true)
- pred = torch.sigmoid(pred) # prob from logits
- dx = pred - true # reduce only missing label effects
- # dx = (pred - true).abs() # reduce missing label and false label effects
- alpha_factor = 1 - torch.exp((dx - 1) / (self.alpha + 1e-4))
- loss *= alpha_factor
- return loss.mean()
-
-
-class FocalLoss(nn.Module):
- # Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)
- def __init__(self, loss_fcn, gamma=1.5, alpha=0.25):
- super().__init__()
- self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss()
- self.gamma = gamma
- self.alpha = alpha
- self.reduction = loss_fcn.reduction
- self.loss_fcn.reduction = 'none' # required to apply FL to each element
-
- def forward(self, pred, true):
- loss = self.loss_fcn(pred, true)
- # p_t = torch.exp(-loss)
- # loss *= self.alpha * (1.000001 - p_t) ** self.gamma # non-zero power for gradient stability
-
- # TF implementation https://github.com/tensorflow/addons/blob/v0.7.1/tensorflow_addons/losses/focal_loss.py
- pred_prob = torch.sigmoid(pred) # prob from logits
- p_t = true * pred_prob + (1 - true) * (1 - pred_prob)
- alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha)
- modulating_factor = (1.0 - p_t) ** self.gamma
- loss *= alpha_factor * modulating_factor
-
- if self.reduction == 'mean':
- return loss.mean()
- elif self.reduction == 'sum':
- return loss.sum()
- else: # 'none'
- return loss
-
-
-class QFocalLoss(nn.Module):
- # Wraps Quality focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)
- def __init__(self, loss_fcn, gamma=1.5, alpha=0.25):
- super().__init__()
- self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss()
- self.gamma = gamma
- self.alpha = alpha
- self.reduction = loss_fcn.reduction
- self.loss_fcn.reduction = 'none' # required to apply FL to each element
-
- def forward(self, pred, true):
- loss = self.loss_fcn(pred, true)
-
- pred_prob = torch.sigmoid(pred) # prob from logits
- alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha)
- modulating_factor = torch.abs(true - pred_prob) ** self.gamma
- loss *= alpha_factor * modulating_factor
-
- if self.reduction == 'mean':
- return loss.mean()
- elif self.reduction == 'sum':
- return loss.sum()
- else: # 'none'
- return loss
-
-
-class ComputeLoss:
- sort_obj_iou = False
-
- # Compute losses
- def __init__(self, model, autobalance=False):
- device = next(model.parameters()).device # get model device
- h = model.hyp # hyperparameters
-
- # Define criteria
- BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['cls_pw']], device=device))
- BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['obj_pw']], device=device))
-
- # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3
- self.cp, self.cn = smooth_BCE(eps=h.get('label_smoothing', 0.0)) # positive, negative BCE targets
-
- # Focal loss
- g = h['fl_gamma'] # focal loss gamma
- if g > 0:
- BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g)
-
- m = de_parallel(model).model[-1] # Detect() module
- self.balance = {3: [4.0, 1.0, 0.4]}.get(m.nl, [4.0, 1.0, 0.25, 0.06, 0.02]) # P3-P7
- self.ssi = list(m.stride).index(16) if autobalance else 0 # stride 16 index
- self.BCEcls, self.BCEobj, self.gr, self.hyp, self.autobalance = BCEcls, BCEobj, 1.0, h, autobalance
- self.na = m.na # number of anchors
- self.nc = m.nc # number of classes
- self.nl = m.nl # number of layers
- self.anchors = m.anchors
- self.device = device
-
- def __call__(self, p, targets): # predictions, targets
- lcls = torch.zeros(1, device=self.device) # class loss
- lbox = torch.zeros(1, device=self.device) # box loss
- lobj = torch.zeros(1, device=self.device) # object loss
- tcls, tbox, indices, anchors = self.build_targets(p, targets) # targets
-
- # Losses
- for i, pi in enumerate(p): # layer index, layer predictions
- b, a, gj, gi = indices[i] # image, anchor, gridy, gridx
- tobj = torch.zeros(pi.shape[:4], dtype=pi.dtype, device=self.device) # target obj
-
- n = b.shape[0] # number of targets
- if n:
- # pxy, pwh, _, pcls = pi[b, a, gj, gi].tensor_split((2, 4, 5), dim=1) # faster, requires torch 1.8.0
- pxy, pwh, _, pcls = pi[b, a, gj, gi].split((2, 2, 1, self.nc), 1) # target-subset of predictions
-
- # Regression
- pxy = pxy.sigmoid() * 2 - 0.5
- pwh = (pwh.sigmoid() * 2) ** 2 * anchors[i]
- pbox = torch.cat((pxy, pwh), 1) # predicted box
- iou = bbox_iou(pbox.T, tbox[i], x1y1x2y2=False, CIoU=True) # iou(prediction, target)
- lbox += (1.0 - iou).mean() # iou loss
-
- # Objectness
- iou = iou.detach().clamp(0).type(tobj.dtype)
- if self.sort_obj_iou:
- j = iou.argsort()
- b, a, gj, gi, iou = b[j], a[j], gj[j], gi[j], iou[j]
- if self.gr < 1:
- iou = (1.0 - self.gr) + self.gr * iou
- tobj[b, a, gj, gi] = iou # iou ratio
-
- # Classification
- if self.nc > 1: # cls loss (only if multiple classes)
- t = torch.full_like(pcls, self.cn, device=self.device) # targets
- t[range(n), tcls[i]] = self.cp
- lcls += self.BCEcls(pcls, t) # BCE
-
- # Append targets to text file
- # with open('targets.txt', 'a') as file:
- # [file.write('%11.5g ' * 4 % tuple(x) + '\n') for x in torch.cat((txy[i], twh[i]), 1)]
-
- obji = self.BCEobj(pi[..., 4], tobj)
- lobj += obji * self.balance[i] # obj loss
- if self.autobalance:
- self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item()
-
- if self.autobalance:
- self.balance = [x / self.balance[self.ssi] for x in self.balance]
- lbox *= self.hyp['box']
- lobj *= self.hyp['obj']
- lcls *= self.hyp['cls']
- bs = tobj.shape[0] # batch size
-
- return (lbox + lobj + lcls) * bs, torch.cat((lbox, lobj, lcls)).detach()
-
- def build_targets(self, p, targets):
- # Build targets for compute_loss(), input targets(image,class,x,y,w,h)
- na, nt = self.na, targets.shape[0] # number of anchors, targets
- tcls, tbox, indices, anch = [], [], [], []
- gain = torch.ones(7, device=self.device) # normalized to gridspace gain
- ai = torch.arange(na, device=self.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt)
- targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices
-
- g = 0.5 # bias
- off = torch.tensor([[0, 0],
- [1, 0], [0, 1], [-1, 0], [0, -1], # j,k,l,m
- # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm
- ], device=self.device).float() * g # offsets
-
- for i in range(self.nl):
- anchors = self.anchors[i]
- gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain
-
- # Match targets to anchors
- t = targets * gain
- if nt:
- # Matches
- r = t[:, :, 4:6] / anchors[:, None] # wh ratio
- j = torch.max(r, 1 / r).max(2)[0] < self.hyp['anchor_t'] # compare
- # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
- t = t[j] # filter
-
- # Offsets
- gxy = t[:, 2:4] # grid xy
- gxi = gain[[2, 3]] - gxy # inverse
- j, k = ((gxy % 1 < g) & (gxy > 1)).T
- l, m = ((gxi % 1 < g) & (gxi > 1)).T
- j = torch.stack((torch.ones_like(j), j, k, l, m))
- t = t.repeat((5, 1, 1))[j]
- offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
- else:
- t = targets[0]
- offsets = 0
-
- # Define
- bc, gxy, gwh, a = t.unsafe_chunk(4, dim=1) # (image, class), grid xy, grid wh, anchors
- a, (b, c) = a.long().view(-1), bc.long().T # anchors, image, class
- gij = (gxy - offsets).long()
- gi, gj = gij.T # grid indices
-
- # Append
- indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) # image, anchor, grid indices
- tbox.append(torch.cat((gxy - gij, gwh), 1)) # box
- anch.append(anchors[a]) # anchors
- tcls.append(c) # class
-
- return tcls, tbox, indices, anch
diff --git a/ultralytics/yolov5/utils/metrics.py b/ultralytics/yolov5/utils/metrics.py
deleted file mode 100644
index 857fa5d81f91879238b9182d2318cca85ae94e27..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/metrics.py
+++ /dev/null
@@ -1,342 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Model validation metrics
-"""
-
-import math
-import warnings
-from pathlib import Path
-
-import matplotlib.pyplot as plt
-import numpy as np
-import torch
-
-
-def fitness(x):
- # Model fitness as a weighted combination of metrics
- w = [0.0, 0.0, 0.1, 0.9] # weights for [P, R, mAP@0.5, mAP@0.5:0.95]
- return (x[:, :4] * w).sum(1)
-
-
-def ap_per_class(tp, conf, pred_cls, target_cls, plot=False, save_dir='.', names=(), eps=1e-16):
- """ Compute the average precision, given the recall and precision curves.
- Source: https://github.com/rafaelpadilla/Object-Detection-Metrics.
- # Arguments
- tp: True positives (nparray, nx1 or nx10).
- conf: Objectness value from 0-1 (nparray).
- pred_cls: Predicted object classes (nparray).
- target_cls: True object classes (nparray).
- plot: Plot precision-recall curve at mAP@0.5
- save_dir: Plot save directory
- # Returns
- The average precision as computed in py-faster-rcnn.
- """
-
- # Sort by objectness
- i = np.argsort(-conf)
- tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]
-
- # Find unique classes
- unique_classes, nt = np.unique(target_cls, return_counts=True)
- nc = unique_classes.shape[0] # number of classes, number of detections
-
- # Create Precision-Recall curve and compute AP for each class
- px, py = np.linspace(0, 1, 1000), [] # for plotting
- ap, p, r = np.zeros((nc, tp.shape[1])), np.zeros((nc, 1000)), np.zeros((nc, 1000))
- for ci, c in enumerate(unique_classes):
- i = pred_cls == c
- n_l = nt[ci] # number of labels
- n_p = i.sum() # number of predictions
-
- if n_p == 0 or n_l == 0:
- continue
- else:
- # Accumulate FPs and TPs
- fpc = (1 - tp[i]).cumsum(0)
- tpc = tp[i].cumsum(0)
-
- # Recall
- recall = tpc / (n_l + eps) # recall curve
- r[ci] = np.interp(-px, -conf[i], recall[:, 0], left=0) # negative x, xp because xp decreases
-
- # Precision
- precision = tpc / (tpc + fpc) # precision curve
- p[ci] = np.interp(-px, -conf[i], precision[:, 0], left=1) # p at pr_score
-
- # AP from recall-precision curve
- for j in range(tp.shape[1]):
- ap[ci, j], mpre, mrec = compute_ap(recall[:, j], precision[:, j])
- if plot and j == 0:
- py.append(np.interp(px, mrec, mpre)) # precision at mAP@0.5
-
- # Compute F1 (harmonic mean of precision and recall)
- f1 = 2 * p * r / (p + r + eps)
- names = [v for k, v in names.items() if k in unique_classes] # list: only classes that have data
- names = {i: v for i, v in enumerate(names)} # to dict
- if plot:
- plot_pr_curve(px, py, ap, Path(save_dir) / 'PR_curve.png', names)
- plot_mc_curve(px, f1, Path(save_dir) / 'F1_curve.png', names, ylabel='F1')
- plot_mc_curve(px, p, Path(save_dir) / 'P_curve.png', names, ylabel='Precision')
- plot_mc_curve(px, r, Path(save_dir) / 'R_curve.png', names, ylabel='Recall')
-
- i = f1.mean(0).argmax() # max F1 index
- p, r, f1 = p[:, i], r[:, i], f1[:, i]
- tp = (r * nt).round() # true positives
- fp = (tp / (p + eps) - tp).round() # false positives
- return tp, fp, p, r, f1, ap, unique_classes.astype('int32')
-
-
-def compute_ap(recall, precision):
- """ Compute the average precision, given the recall and precision curves
- # Arguments
- recall: The recall curve (list)
- precision: The precision curve (list)
- # Returns
- Average precision, precision curve, recall curve
- """
-
- # Append sentinel values to beginning and end
- mrec = np.concatenate(([0.0], recall, [1.0]))
- mpre = np.concatenate(([1.0], precision, [0.0]))
-
- # Compute the precision envelope
- mpre = np.flip(np.maximum.accumulate(np.flip(mpre)))
-
- # Integrate area under curve
- method = 'interp' # methods: 'continuous', 'interp'
- if method == 'interp':
- x = np.linspace(0, 1, 101) # 101-point interp (COCO)
- ap = np.trapz(np.interp(x, mrec, mpre), x) # integrate
- else: # 'continuous'
- i = np.where(mrec[1:] != mrec[:-1])[0] # points where x axis (recall) changes
- ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) # area under curve
-
- return ap, mpre, mrec
-
-
-class ConfusionMatrix:
- # Updated version of https://github.com/kaanakan/object_detection_confusion_matrix
- def __init__(self, nc, conf=0.25, iou_thres=0.45):
- self.matrix = np.zeros((nc + 1, nc + 1))
- self.nc = nc # number of classes
- self.conf = conf
- self.iou_thres = iou_thres
-
- def process_batch(self, detections, labels):
- """
- Return intersection-over-union (Jaccard index) of boxes.
- Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
- Arguments:
- detections (Array[N, 6]), x1, y1, x2, y2, conf, class
- labels (Array[M, 5]), class, x1, y1, x2, y2
- Returns:
- None, updates confusion matrix accordingly
- """
- detections = detections[detections[:, 4] > self.conf]
- gt_classes = labels[:, 0].int()
- detection_classes = detections[:, 5].int()
- iou = box_iou(labels[:, 1:], detections[:, :4])
-
- x = torch.where(iou > self.iou_thres)
- if x[0].shape[0]:
- matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy()
- if x[0].shape[0] > 1:
- matches = matches[matches[:, 2].argsort()[::-1]]
- matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
- matches = matches[matches[:, 2].argsort()[::-1]]
- matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
- else:
- matches = np.zeros((0, 3))
-
- n = matches.shape[0] > 0
- m0, m1, _ = matches.transpose().astype(np.int16)
- for i, gc in enumerate(gt_classes):
- j = m0 == i
- if n and sum(j) == 1:
- self.matrix[detection_classes[m1[j]], gc] += 1 # correct
- else:
- self.matrix[self.nc, gc] += 1 # background FP
-
- if n:
- for i, dc in enumerate(detection_classes):
- if not any(m1 == i):
- self.matrix[dc, self.nc] += 1 # background FN
-
- def matrix(self):
- return self.matrix
-
- def tp_fp(self):
- tp = self.matrix.diagonal() # true positives
- fp = self.matrix.sum(1) - tp # false positives
- # fn = self.matrix.sum(0) - tp # false negatives (missed detections)
- return tp[:-1], fp[:-1] # remove background class
-
- def plot(self, normalize=True, save_dir='', names=()):
- try:
- import seaborn as sn
-
- array = self.matrix / ((self.matrix.sum(0).reshape(1, -1) + 1E-9) if normalize else 1) # normalize columns
- array[array < 0.005] = np.nan # don't annotate (would appear as 0.00)
-
- fig = plt.figure(figsize=(12, 9), tight_layout=True)
- nc, nn = self.nc, len(names) # number of classes, names
- sn.set(font_scale=1.0 if nc < 50 else 0.8) # for label size
- labels = (0 < nn < 99) and (nn == nc) # apply names to ticklabels
- with warnings.catch_warnings():
- warnings.simplefilter('ignore') # suppress empty matrix RuntimeWarning: All-NaN slice encountered
- sn.heatmap(array, annot=nc < 30, annot_kws={"size": 8}, cmap='Blues', fmt='.2f', square=True, vmin=0.0,
- xticklabels=names + ['background FP'] if labels else "auto",
- yticklabels=names + ['background FN'] if labels else "auto").set_facecolor((1, 1, 1))
- fig.axes[0].set_xlabel('True')
- fig.axes[0].set_ylabel('Predicted')
- fig.savefig(Path(save_dir) / 'confusion_matrix.png', dpi=250)
- plt.close()
- except Exception as e:
- print(f'WARNING: ConfusionMatrix plot failure: {e}')
-
- def print(self):
- for i in range(self.nc + 1):
- print(' '.join(map(str, self.matrix[i])))
-
-
-def bbox_iou(box1, box2, x1y1x2y2=True, GIoU=False, DIoU=False, CIoU=False, eps=1e-7):
- # Returns the IoU of box1 to box2. box1 is 4, box2 is nx4
- box2 = box2.T
-
- # Get the coordinates of bounding boxes
- if x1y1x2y2: # x1, y1, x2, y2 = box1
- b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
- b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
- else: # transform from xywh to xyxy
- b1_x1, b1_x2 = box1[0] - box1[2] / 2, box1[0] + box1[2] / 2
- b1_y1, b1_y2 = box1[1] - box1[3] / 2, box1[1] + box1[3] / 2
- b2_x1, b2_x2 = box2[0] - box2[2] / 2, box2[0] + box2[2] / 2
- b2_y1, b2_y2 = box2[1] - box2[3] / 2, box2[1] + box2[3] / 2
-
- # Intersection area
- inter = (torch.min(b1_x2, b2_x2) - torch.max(b1_x1, b2_x1)).clamp(0) * \
- (torch.min(b1_y2, b2_y2) - torch.max(b1_y1, b2_y1)).clamp(0)
-
- # Union Area
- w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
- w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
- union = w1 * h1 + w2 * h2 - inter + eps
-
- iou = inter / union
- if CIoU or DIoU or GIoU:
- cw = torch.max(b1_x2, b2_x2) - torch.min(b1_x1, b2_x1) # convex (smallest enclosing box) width
- ch = torch.max(b1_y2, b2_y2) - torch.min(b1_y1, b2_y1) # convex height
- if CIoU or DIoU: # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1
- c2 = cw ** 2 + ch ** 2 + eps # convex diagonal squared
- rho2 = ((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 +
- (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4 # center distance squared
- if CIoU: # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47
- v = (4 / math.pi ** 2) * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)
- with torch.no_grad():
- alpha = v / (v - iou + (1 + eps))
- return iou - (rho2 / c2 + v * alpha) # CIoU
- return iou - rho2 / c2 # DIoU
- c_area = cw * ch + eps # convex area
- return iou - (c_area - union) / c_area # GIoU https://arxiv.org/pdf/1902.09630.pdf
- return iou # IoU
-
-
-def box_iou(box1, box2):
- # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py
- """
- Return intersection-over-union (Jaccard index) of boxes.
- Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
- Arguments:
- box1 (Tensor[N, 4])
- box2 (Tensor[M, 4])
- Returns:
- iou (Tensor[N, M]): the NxM matrix containing the pairwise
- IoU values for every element in boxes1 and boxes2
- """
-
- def box_area(box):
- # box = 4xn
- return (box[2] - box[0]) * (box[3] - box[1])
-
- area1 = box_area(box1.T)
- area2 = box_area(box2.T)
-
- # inter(N,M) = (rb(N,M,2) - lt(N,M,2)).clamp(0).prod(2)
- inter = (torch.min(box1[:, None, 2:], box2[:, 2:]) - torch.max(box1[:, None, :2], box2[:, :2])).clamp(0).prod(2)
- return inter / (area1[:, None] + area2 - inter) # iou = inter / (area1 + area2 - inter)
-
-
-def bbox_ioa(box1, box2, eps=1E-7):
- """ Returns the intersection over box2 area given box1, box2. Boxes are x1y1x2y2
- box1: np.array of shape(4)
- box2: np.array of shape(nx4)
- returns: np.array of shape(n)
- """
-
- box2 = box2.transpose()
-
- # Get the coordinates of bounding boxes
- b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3]
- b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3]
-
- # Intersection area
- inter_area = (np.minimum(b1_x2, b2_x2) - np.maximum(b1_x1, b2_x1)).clip(0) * \
- (np.minimum(b1_y2, b2_y2) - np.maximum(b1_y1, b2_y1)).clip(0)
-
- # box2 area
- box2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1) + eps
-
- # Intersection over box2 area
- return inter_area / box2_area
-
-
-def wh_iou(wh1, wh2):
- # Returns the nxm IoU matrix. wh1 is nx2, wh2 is mx2
- wh1 = wh1[:, None] # [N,1,2]
- wh2 = wh2[None] # [1,M,2]
- inter = torch.min(wh1, wh2).prod(2) # [N,M]
- return inter / (wh1.prod(2) + wh2.prod(2) - inter) # iou = inter / (area1 + area2 - inter)
-
-
-# Plots ----------------------------------------------------------------------------------------------------------------
-
-def plot_pr_curve(px, py, ap, save_dir='pr_curve.png', names=()):
- # Precision-recall curve
- fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
- py = np.stack(py, axis=1)
-
- if 0 < len(names) < 21: # display per-class legend if < 21 classes
- for i, y in enumerate(py.T):
- ax.plot(px, y, linewidth=1, label=f'{names[i]} {ap[i, 0]:.3f}') # plot(recall, precision)
- else:
- ax.plot(px, py, linewidth=1, color='grey') # plot(recall, precision)
-
- ax.plot(px, py.mean(1), linewidth=3, color='blue', label='all classes %.3f mAP@0.5' % ap[:, 0].mean())
- ax.set_xlabel('Recall')
- ax.set_ylabel('Precision')
- ax.set_xlim(0, 1)
- ax.set_ylim(0, 1)
- plt.legend(bbox_to_anchor=(1.04, 1), loc="upper left")
- fig.savefig(Path(save_dir), dpi=250)
- plt.close()
-
-
-def plot_mc_curve(px, py, save_dir='mc_curve.png', names=(), xlabel='Confidence', ylabel='Metric'):
- # Metric-confidence curve
- fig, ax = plt.subplots(1, 1, figsize=(9, 6), tight_layout=True)
-
- if 0 < len(names) < 21: # display per-class legend if < 21 classes
- for i, y in enumerate(py):
- ax.plot(px, y, linewidth=1, label=f'{names[i]}') # plot(confidence, metric)
- else:
- ax.plot(px, py.T, linewidth=1, color='grey') # plot(confidence, metric)
-
- y = py.mean(0)
- ax.plot(px, y, linewidth=3, color='blue', label=f'all classes {y.max():.2f} at {px[y.argmax()]:.3f}')
- ax.set_xlabel(xlabel)
- ax.set_ylabel(ylabel)
- ax.set_xlim(0, 1)
- ax.set_ylim(0, 1)
- plt.legend(bbox_to_anchor=(1.04, 1), loc="upper left")
- fig.savefig(Path(save_dir), dpi=250)
- plt.close()
diff --git a/ultralytics/yolov5/utils/plots.py b/ultralytics/yolov5/utils/plots.py
deleted file mode 100644
index a30c0faf962a1515c25ccd1e0433ec20dd08c33a..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/plots.py
+++ /dev/null
@@ -1,476 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Plotting utils
-"""
-
-import math
-import os
-from copy import copy
-from pathlib import Path
-from urllib.error import URLError
-
-import cv2
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import seaborn as sn
-import torch
-from PIL import Image, ImageDraw, ImageFont
-
-from utils.general import (CONFIG_DIR, FONT, LOGGER, Timeout, check_font, check_requirements, clip_coords,
- increment_path, is_ascii, is_chinese, try_except, xywh2xyxy, xyxy2xywh)
-from utils.metrics import fitness
-
-# Settings
-RANK = int(os.getenv('RANK', -1))
-matplotlib.rc('font', **{'size': 11})
-matplotlib.use('Agg') # for writing to files only
-
-
-class Colors:
- # Ultralytics color palette https://ultralytics.com/
- def __init__(self):
- # hex = matplotlib.colors.TABLEAU_COLORS.values()
- hex = ('FF3838', 'FF9D97', 'FF701F', 'FFB21D', 'CFD231', '48F90A', '92CC17', '3DDB86', '1A9334', '00D4BB',
- '2C99A8', '00C2FF', '344593', '6473FF', '0018EC', '8438FF', '520085', 'CB38FF', 'FF95C8', 'FF37C7')
- self.palette = [self.hex2rgb('#' + c) for c in hex]
- self.n = len(self.palette)
-
- def __call__(self, i, bgr=False):
- c = self.palette[int(i) % self.n]
- return (c[2], c[1], c[0]) if bgr else c
-
- @staticmethod
- def hex2rgb(h): # rgb order (PIL)
- return tuple(int(h[1 + i:1 + i + 2], 16) for i in (0, 2, 4))
-
-
-colors = Colors() # create instance for 'from utils.plots import colors'
-
-
-def check_pil_font(font=FONT, size=10):
- # Return a PIL TrueType Font, downloading to CONFIG_DIR if necessary
- font = Path(font)
- font = font if font.exists() else (CONFIG_DIR / font.name)
- try:
- return ImageFont.truetype(str(font) if font.exists() else font.name, size)
- except Exception: # download if missing
- try:
- check_font(font)
- return ImageFont.truetype(str(font), size)
- except TypeError:
- check_requirements('Pillow>=8.4.0') # known issue https://github.com/ultralytics/yolov5/issues/5374
- except URLError: # not online
- return ImageFont.load_default()
-
-
-class Annotator:
- if RANK in (-1, 0):
- check_pil_font() # download TTF if necessary
-
- # YOLOv5 Annotator for train/val mosaics and jpgs and detect/hub inference annotations
- def __init__(self, im, line_width=None, font_size=None, font='Arial.ttf', pil=False, example='abc'):
- assert im.data.contiguous, 'Image not contiguous. Apply np.ascontiguousarray(im) to Annotator() input images.'
- self.pil = pil or not is_ascii(example) or is_chinese(example)
- if self.pil: # use PIL
- self.im = im if isinstance(im, Image.Image) else Image.fromarray(im)
- self.draw = ImageDraw.Draw(self.im)
- self.font = check_pil_font(font='Arial.Unicode.ttf' if is_chinese(example) else font,
- size=font_size or max(round(sum(self.im.size) / 2 * 0.035), 12))
- else: # use cv2
- self.im = im
- self.lw = line_width or max(round(sum(im.shape) / 2 * 0.003), 2) # line width
-
- def box_label(self, box, label='', color=(128, 128, 128), txt_color=(255, 255, 255)):
- # Add one xyxy box to image with label
- if self.pil or not is_ascii(label):
- self.draw.rectangle(box, width=self.lw, outline=color) # box
- if label:
- w, h = self.font.getsize(label) # text width, height
- outside = box[1] - h >= 0 # label fits outside box
- self.draw.rectangle((box[0],
- box[1] - h if outside else box[1],
- box[0] + w + 1,
- box[1] + 1 if outside else box[1] + h + 1), fill=color)
- # self.draw.text((box[0], box[1]), label, fill=txt_color, font=self.font, anchor='ls') # for PIL>8.0
- self.draw.text((box[0], box[1] - h if outside else box[1]), label, fill=txt_color, font=self.font)
- else: # cv2
- p1, p2 = (int(box[0]), int(box[1])), (int(box[2]), int(box[3]))
- cv2.rectangle(self.im, p1, p2, color, thickness=self.lw, lineType=cv2.LINE_AA)
- if label:
- tf = max(self.lw - 1, 1) # font thickness
- w, h = cv2.getTextSize(label, 0, fontScale=self.lw / 3, thickness=tf)[0] # text width, height
- outside = p1[1] - h - 3 >= 0 # label fits outside box
- p2 = p1[0] + w, p1[1] - h - 3 if outside else p1[1] + h + 3
- cv2.rectangle(self.im, p1, p2, color, -1, cv2.LINE_AA) # filled
- cv2.putText(self.im, label, (p1[0], p1[1] - 2 if outside else p1[1] + h + 2), 0, self.lw / 3, txt_color,
- thickness=tf, lineType=cv2.LINE_AA)
-
- def rectangle(self, xy, fill=None, outline=None, width=1):
- # Add rectangle to image (PIL-only)
- self.draw.rectangle(xy, fill, outline, width)
-
- def text(self, xy, text, txt_color=(255, 255, 255)):
- # Add text to image (PIL-only)
- w, h = self.font.getsize(text) # text width, height
- self.draw.text((xy[0], xy[1] - h + 1), text, fill=txt_color, font=self.font)
-
- def result(self):
- # Return annotated image as array
- return np.asarray(self.im)
-
-
-def feature_visualization(x, module_type, stage, n=32, save_dir=Path('runs/detect/exp')):
- """
- x: Features to be visualized
- module_type: Module type
- stage: Module stage within model
- n: Maximum number of feature maps to plot
- save_dir: Directory to save results
- """
- if 'Detect' not in module_type:
- batch, channels, height, width = x.shape # batch, channels, height, width
- if height > 1 and width > 1:
- f = save_dir / f"stage{stage}_{module_type.split('.')[-1]}_features.png" # filename
-
- blocks = torch.chunk(x[0].cpu(), channels, dim=0) # select batch index 0, block by channels
- n = min(n, channels) # number of plots
- fig, ax = plt.subplots(math.ceil(n / 8), 8, tight_layout=True) # 8 rows x n/8 cols
- ax = ax.ravel()
- plt.subplots_adjust(wspace=0.05, hspace=0.05)
- for i in range(n):
- ax[i].imshow(blocks[i].squeeze()) # cmap='gray'
- ax[i].axis('off')
-
- LOGGER.info(f'Saving {f}... ({n}/{channels})')
- plt.savefig(f, dpi=300, bbox_inches='tight')
- plt.close()
- np.save(str(f.with_suffix('.npy')), x[0].cpu().numpy()) # npy save
-
-
-def hist2d(x, y, n=100):
- # 2d histogram used in labels.png and evolve.png
- xedges, yedges = np.linspace(x.min(), x.max(), n), np.linspace(y.min(), y.max(), n)
- hist, xedges, yedges = np.histogram2d(x, y, (xedges, yedges))
- xidx = np.clip(np.digitize(x, xedges) - 1, 0, hist.shape[0] - 1)
- yidx = np.clip(np.digitize(y, yedges) - 1, 0, hist.shape[1] - 1)
- return np.log(hist[xidx, yidx])
-
-
-def butter_lowpass_filtfilt(data, cutoff=1500, fs=50000, order=5):
- from scipy.signal import butter, filtfilt
-
- # https://stackoverflow.com/questions/28536191/how-to-filter-smooth-with-scipy-numpy
- def butter_lowpass(cutoff, fs, order):
- nyq = 0.5 * fs
- normal_cutoff = cutoff / nyq
- return butter(order, normal_cutoff, btype='low', analog=False)
-
- b, a = butter_lowpass(cutoff, fs, order=order)
- return filtfilt(b, a, data) # forward-backward filter
-
-
-def output_to_target(output):
- # Convert model output to target format [batch_id, class_id, x, y, w, h, conf]
- targets = []
- for i, o in enumerate(output):
- for *box, conf, cls in o.cpu().numpy():
- targets.append([i, cls, *list(*xyxy2xywh(np.array(box)[None])), conf])
- return np.array(targets)
-
-
-def plot_images(images, targets, paths=None, fname='images.jpg', names=None, max_size=1920, max_subplots=16):
- # Plot image grid with labels
- if isinstance(images, torch.Tensor):
- images = images.cpu().float().numpy()
- if isinstance(targets, torch.Tensor):
- targets = targets.cpu().numpy()
- if np.max(images[0]) <= 1:
- images *= 255 # de-normalise (optional)
- bs, _, h, w = images.shape # batch size, _, height, width
- bs = min(bs, max_subplots) # limit plot images
- ns = np.ceil(bs ** 0.5) # number of subplots (square)
-
- # Build Image
- mosaic = np.full((int(ns * h), int(ns * w), 3), 255, dtype=np.uint8) # init
- for i, im in enumerate(images):
- if i == max_subplots: # if last batch has fewer images than we expect
- break
- x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin
- im = im.transpose(1, 2, 0)
- mosaic[y:y + h, x:x + w, :] = im
-
- # Resize (optional)
- scale = max_size / ns / max(h, w)
- if scale < 1:
- h = math.ceil(scale * h)
- w = math.ceil(scale * w)
- mosaic = cv2.resize(mosaic, tuple(int(x * ns) for x in (w, h)))
-
- # Annotate
- fs = int((h + w) * ns * 0.01) # font size
- annotator = Annotator(mosaic, line_width=round(fs / 10), font_size=fs, pil=True, example=names)
- for i in range(i + 1):
- x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin
- annotator.rectangle([x, y, x + w, y + h], None, (255, 255, 255), width=2) # borders
- if paths:
- annotator.text((x + 5, y + 5 + h), text=Path(paths[i]).name[:40], txt_color=(220, 220, 220)) # filenames
- if len(targets) > 0:
- ti = targets[targets[:, 0] == i] # image targets
- boxes = xywh2xyxy(ti[:, 2:6]).T
- classes = ti[:, 1].astype('int')
- labels = ti.shape[1] == 6 # labels if no conf column
- conf = None if labels else ti[:, 6] # check for confidence presence (label vs pred)
-
- if boxes.shape[1]:
- if boxes.max() <= 1.01: # if normalized with tolerance 0.01
- boxes[[0, 2]] *= w # scale to pixels
- boxes[[1, 3]] *= h
- elif scale < 1: # absolute coords need scale if image scales
- boxes *= scale
- boxes[[0, 2]] += x
- boxes[[1, 3]] += y
- for j, box in enumerate(boxes.T.tolist()):
- cls = classes[j]
- color = colors(cls)
- cls = names[cls] if names else cls
- if labels or conf[j] > 0.25: # 0.25 conf thresh
- label = f'{cls}' if labels else f'{cls} {conf[j]:.1f}'
- annotator.box_label(box, label, color=color)
- annotator.im.save(fname) # save
-
-
-def plot_lr_scheduler(optimizer, scheduler, epochs=300, save_dir=''):
- # Plot LR simulating training for full epochs
- optimizer, scheduler = copy(optimizer), copy(scheduler) # do not modify originals
- y = []
- for _ in range(epochs):
- scheduler.step()
- y.append(optimizer.param_groups[0]['lr'])
- plt.plot(y, '.-', label='LR')
- plt.xlabel('epoch')
- plt.ylabel('LR')
- plt.grid()
- plt.xlim(0, epochs)
- plt.ylim(0)
- plt.savefig(Path(save_dir) / 'LR.png', dpi=200)
- plt.close()
-
-
-def plot_val_txt(): # from utils.plots import *; plot_val()
- # Plot val.txt histograms
- x = np.loadtxt('val.txt', dtype=np.float32)
- box = xyxy2xywh(x[:, :4])
- cx, cy = box[:, 0], box[:, 1]
-
- fig, ax = plt.subplots(1, 1, figsize=(6, 6), tight_layout=True)
- ax.hist2d(cx, cy, bins=600, cmax=10, cmin=0)
- ax.set_aspect('equal')
- plt.savefig('hist2d.png', dpi=300)
-
- fig, ax = plt.subplots(1, 2, figsize=(12, 6), tight_layout=True)
- ax[0].hist(cx, bins=600)
- ax[1].hist(cy, bins=600)
- plt.savefig('hist1d.png', dpi=200)
-
-
-def plot_targets_txt(): # from utils.plots import *; plot_targets_txt()
- # Plot targets.txt histograms
- x = np.loadtxt('targets.txt', dtype=np.float32).T
- s = ['x targets', 'y targets', 'width targets', 'height targets']
- fig, ax = plt.subplots(2, 2, figsize=(8, 8), tight_layout=True)
- ax = ax.ravel()
- for i in range(4):
- ax[i].hist(x[i], bins=100, label=f'{x[i].mean():.3g} +/- {x[i].std():.3g}')
- ax[i].legend()
- ax[i].set_title(s[i])
- plt.savefig('targets.jpg', dpi=200)
-
-
-def plot_val_study(file='', dir='', x=None): # from utils.plots import *; plot_val_study()
- # Plot file=study.txt generated by val.py (or plot all study*.txt in dir)
- save_dir = Path(file).parent if file else Path(dir)
- plot2 = False # plot additional results
- if plot2:
- ax = plt.subplots(2, 4, figsize=(10, 6), tight_layout=True)[1].ravel()
-
- fig2, ax2 = plt.subplots(1, 1, figsize=(8, 4), tight_layout=True)
- # for f in [save_dir / f'study_coco_{x}.txt' for x in ['yolov5n6', 'yolov5s6', 'yolov5m6', 'yolov5l6', 'yolov5x6']]:
- for f in sorted(save_dir.glob('study*.txt')):
- y = np.loadtxt(f, dtype=np.float32, usecols=[0, 1, 2, 3, 7, 8, 9], ndmin=2).T
- x = np.arange(y.shape[1]) if x is None else np.array(x)
- if plot2:
- s = ['P', 'R', 'mAP@.5', 'mAP@.5:.95', 't_preprocess (ms/img)', 't_inference (ms/img)', 't_NMS (ms/img)']
- for i in range(7):
- ax[i].plot(x, y[i], '.-', linewidth=2, markersize=8)
- ax[i].set_title(s[i])
-
- j = y[3].argmax() + 1
- ax2.plot(y[5, 1:j], y[3, 1:j] * 1E2, '.-', linewidth=2, markersize=8,
- label=f.stem.replace('study_coco_', '').replace('yolo', 'YOLO'))
-
- ax2.plot(1E3 / np.array([209, 140, 97, 58, 35, 18]), [34.6, 40.5, 43.0, 47.5, 49.7, 51.5],
- 'k.-', linewidth=2, markersize=8, alpha=.25, label='EfficientDet')
-
- ax2.grid(alpha=0.2)
- ax2.set_yticks(np.arange(20, 60, 5))
- ax2.set_xlim(0, 57)
- ax2.set_ylim(25, 55)
- ax2.set_xlabel('GPU Speed (ms/img)')
- ax2.set_ylabel('COCO AP val')
- ax2.legend(loc='lower right')
- f = save_dir / 'study.png'
- print(f'Saving {f}...')
- plt.savefig(f, dpi=300)
-
-
-@try_except # known issue https://github.com/ultralytics/yolov5/issues/5395
-@Timeout(30) # known issue https://github.com/ultralytics/yolov5/issues/5611
-def plot_labels(labels, names=(), save_dir=Path('')):
- # plot dataset labels
- LOGGER.info(f"Plotting labels to {save_dir / 'labels.jpg'}... ")
- c, b = labels[:, 0], labels[:, 1:].transpose() # classes, boxes
- nc = int(c.max() + 1) # number of classes
- x = pd.DataFrame(b.transpose(), columns=['x', 'y', 'width', 'height'])
-
- # seaborn correlogram
- sn.pairplot(x, corner=True, diag_kind='auto', kind='hist', diag_kws=dict(bins=50), plot_kws=dict(pmax=0.9))
- plt.savefig(save_dir / 'labels_correlogram.jpg', dpi=200)
- plt.close()
-
- # matplotlib labels
- matplotlib.use('svg') # faster
- ax = plt.subplots(2, 2, figsize=(8, 8), tight_layout=True)[1].ravel()
- y = ax[0].hist(c, bins=np.linspace(0, nc, nc + 1) - 0.5, rwidth=0.8)
- try: # color histogram bars by class
- [y[2].patches[i].set_color([x / 255 for x in colors(i)]) for i in range(nc)] # known issue #3195
- except Exception:
- pass
- ax[0].set_ylabel('instances')
- if 0 < len(names) < 30:
- ax[0].set_xticks(range(len(names)))
- ax[0].set_xticklabels(names, rotation=90, fontsize=10)
- else:
- ax[0].set_xlabel('classes')
- sn.histplot(x, x='x', y='y', ax=ax[2], bins=50, pmax=0.9)
- sn.histplot(x, x='width', y='height', ax=ax[3], bins=50, pmax=0.9)
-
- # rectangles
- labels[:, 1:3] = 0.5 # center
- labels[:, 1:] = xywh2xyxy(labels[:, 1:]) * 2000
- img = Image.fromarray(np.ones((2000, 2000, 3), dtype=np.uint8) * 255)
- for cls, *box in labels[:1000]:
- ImageDraw.Draw(img).rectangle(box, width=1, outline=colors(cls)) # plot
- ax[1].imshow(img)
- ax[1].axis('off')
-
- for a in [0, 1, 2, 3]:
- for s in ['top', 'right', 'left', 'bottom']:
- ax[a].spines[s].set_visible(False)
-
- plt.savefig(save_dir / 'labels.jpg', dpi=200)
- matplotlib.use('Agg')
- plt.close()
-
-
-def plot_evolve(evolve_csv='path/to/evolve.csv'): # from utils.plots import *; plot_evolve()
- # Plot evolve.csv hyp evolution results
- evolve_csv = Path(evolve_csv)
- data = pd.read_csv(evolve_csv)
- keys = [x.strip() for x in data.columns]
- x = data.values
- f = fitness(x)
- j = np.argmax(f) # max fitness index
- plt.figure(figsize=(10, 12), tight_layout=True)
- matplotlib.rc('font', **{'size': 8})
- print(f'Best results from row {j} of {evolve_csv}:')
- for i, k in enumerate(keys[7:]):
- v = x[:, 7 + i]
- mu = v[j] # best single result
- plt.subplot(6, 5, i + 1)
- plt.scatter(v, f, c=hist2d(v, f, 20), cmap='viridis', alpha=.8, edgecolors='none')
- plt.plot(mu, f.max(), 'k+', markersize=15)
- plt.title(f'{k} = {mu:.3g}', fontdict={'size': 9}) # limit to 40 characters
- if i % 5 != 0:
- plt.yticks([])
- print(f'{k:>15}: {mu:.3g}')
- f = evolve_csv.with_suffix('.png') # filename
- plt.savefig(f, dpi=200)
- plt.close()
- print(f'Saved {f}')
-
-
-def plot_results(file='path/to/results.csv', dir=''):
- # Plot training results.csv. Usage: from utils.plots import *; plot_results('path/to/results.csv')
- save_dir = Path(file).parent if file else Path(dir)
- fig, ax = plt.subplots(2, 5, figsize=(12, 6), tight_layout=True)
- ax = ax.ravel()
- files = list(save_dir.glob('results*.csv'))
- assert len(files), f'No results.csv files found in {save_dir.resolve()}, nothing to plot.'
- for fi, f in enumerate(files):
- try:
- data = pd.read_csv(f)
- s = [x.strip() for x in data.columns]
- x = data.values[:, 0]
- for i, j in enumerate([1, 2, 3, 4, 5, 8, 9, 10, 6, 7]):
- y = data.values[:, j]
- # y[y == 0] = np.nan # don't show zero values
- ax[i].plot(x, y, marker='.', label=f.stem, linewidth=2, markersize=8)
- ax[i].set_title(s[j], fontsize=12)
- # if j in [8, 9, 10]: # share train and val loss y axes
- # ax[i].get_shared_y_axes().join(ax[i], ax[i - 5])
- except Exception as e:
- LOGGER.info(f'Warning: Plotting error for {f}: {e}')
- ax[1].legend()
- fig.savefig(save_dir / 'results.png', dpi=200)
- plt.close()
-
-
-def profile_idetection(start=0, stop=0, labels=(), save_dir=''):
- # Plot iDetection '*.txt' per-image logs. from utils.plots import *; profile_idetection()
- ax = plt.subplots(2, 4, figsize=(12, 6), tight_layout=True)[1].ravel()
- s = ['Images', 'Free Storage (GB)', 'RAM Usage (GB)', 'Battery', 'dt_raw (ms)', 'dt_smooth (ms)', 'real-world FPS']
- files = list(Path(save_dir).glob('frames*.txt'))
- for fi, f in enumerate(files):
- try:
- results = np.loadtxt(f, ndmin=2).T[:, 90:-30] # clip first and last rows
- n = results.shape[1] # number of rows
- x = np.arange(start, min(stop, n) if stop else n)
- results = results[:, x]
- t = (results[0] - results[0].min()) # set t0=0s
- results[0] = x
- for i, a in enumerate(ax):
- if i < len(results):
- label = labels[fi] if len(labels) else f.stem.replace('frames_', '')
- a.plot(t, results[i], marker='.', label=label, linewidth=1, markersize=5)
- a.set_title(s[i])
- a.set_xlabel('time (s)')
- # if fi == len(files) - 1:
- # a.set_ylim(bottom=0)
- for side in ['top', 'right']:
- a.spines[side].set_visible(False)
- else:
- a.remove()
- except Exception as e:
- print(f'Warning: Plotting error for {f}; {e}')
- ax[1].legend()
- plt.savefig(Path(save_dir) / 'idetection_profile.png', dpi=200)
-
-
-def save_one_box(xyxy, im, file=Path('im.jpg'), gain=1.02, pad=10, square=False, BGR=False, save=True):
- # Save image crop as {file} with crop size multiple {gain} and {pad} pixels. Save and/or return crop
- xyxy = torch.tensor(xyxy).view(-1, 4)
- b = xyxy2xywh(xyxy) # boxes
- if square:
- b[:, 2:] = b[:, 2:].max(1)[0].unsqueeze(1) # attempt rectangle to square
- b[:, 2:] = b[:, 2:] * gain + pad # box wh * gain + pad
- xyxy = xywh2xyxy(b).long()
- clip_coords(xyxy, im.shape)
- crop = im[int(xyxy[0, 1]):int(xyxy[0, 3]), int(xyxy[0, 0]):int(xyxy[0, 2]), ::(1 if BGR else -1)]
- if save:
- file.parent.mkdir(parents=True, exist_ok=True) # make directory
- f = str(increment_path(file).with_suffix('.jpg'))
- # cv2.imwrite(f, crop) # https://github.com/ultralytics/yolov5/issues/7007 chroma subsampling issue
- Image.fromarray(cv2.cvtColor(crop, cv2.COLOR_BGR2RGB)).save(f, quality=95, subsampling=0)
- return crop
diff --git a/ultralytics/yolov5/utils/torch_utils.py b/ultralytics/yolov5/utils/torch_utils.py
deleted file mode 100644
index 72f8a0fd1659784ca6dcacc3fc061dea4e560b22..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/utils/torch_utils.py
+++ /dev/null
@@ -1,312 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-PyTorch utils
-"""
-
-import math
-import os
-import platform
-import subprocess
-import time
-import warnings
-from contextlib import contextmanager
-from copy import deepcopy
-from pathlib import Path
-
-import torch
-import torch.distributed as dist
-import torch.nn as nn
-import torch.nn.functional as F
-
-from utils.general import LOGGER, file_update_date, git_describe
-
-try:
- import thop # for FLOPs computation
-except ImportError:
- thop = None
-
-# Suppress PyTorch warnings
-warnings.filterwarnings('ignore', message='User provided device_type of \'cuda\', but CUDA is not available. Disabling')
-
-
-@contextmanager
-def torch_distributed_zero_first(local_rank: int):
- # Decorator to make all processes in distributed training wait for each local_master to do something
- if local_rank not in [-1, 0]:
- dist.barrier(device_ids=[local_rank])
- yield
- if local_rank == 0:
- dist.barrier(device_ids=[0])
-
-
-def device_count():
- # Returns number of CUDA devices available. Safe version of torch.cuda.device_count(). Only works on Linux.
- assert platform.system() == 'Linux', 'device_count() function only works on Linux'
- try:
- cmd = 'nvidia-smi -L | wc -l'
- return int(subprocess.run(cmd, shell=True, capture_output=True, check=True).stdout.decode().split()[-1])
- except Exception:
- return 0
-
-
-def select_device(device='', batch_size=0, newline=True):
- # device = 'cpu' or '0' or '0,1,2,3'
- s = f'YOLOv5 🚀 {git_describe() or file_update_date()} torch {torch.__version__} ' # string
- device = str(device).strip().lower().replace('cuda:', '') # to string, 'cuda:0' to '0'
- cpu = device == 'cpu'
- if cpu:
- os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # force torch.cuda.is_available() = False
- elif device: # non-cpu device requested
- os.environ['CUDA_VISIBLE_DEVICES'] = device # set environment variable - must be before assert is_available()
- assert torch.cuda.is_available() and torch.cuda.device_count() >= len(device.replace(',', '')), \
- f"Invalid CUDA '--device {device}' requested, use '--device cpu' or pass valid CUDA device(s)"
-
- cuda = not cpu and torch.cuda.is_available()
- if cuda:
- devices = device.split(',') if device else '0' # range(torch.cuda.device_count()) # i.e. 0,1,6,7
- n = len(devices) # device count
- if n > 1 and batch_size > 0: # check batch_size is divisible by device_count
- assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'
- space = ' ' * (len(s) + 1)
- for i, d in enumerate(devices):
- p = torch.cuda.get_device_properties(i)
- s += f"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / (1 << 20):.0f}MiB)\n" # bytes to MB
- else:
- s += 'CPU\n'
-
- if not newline:
- s = s.rstrip()
- LOGGER.info(s.encode().decode('ascii', 'ignore') if platform.system() == 'Windows' else s) # emoji-safe
- return torch.device('cuda:0' if cuda else 'cpu')
-
-
-def time_sync():
- # PyTorch-accurate time
- if torch.cuda.is_available():
- torch.cuda.synchronize()
- return time.time()
-
-
-def profile(input, ops, n=10, device=None):
- # YOLOv5 speed/memory/FLOPs profiler
- #
- # Usage:
- # input = torch.randn(16, 3, 640, 640)
- # m1 = lambda x: x * torch.sigmoid(x)
- # m2 = nn.SiLU()
- # profile(input, [m1, m2], n=100) # profile over 100 iterations
-
- results = []
- device = device or select_device()
- print(f"{'Params':>12s}{'GFLOPs':>12s}{'GPU_mem (GB)':>14s}{'forward (ms)':>14s}{'backward (ms)':>14s}"
- f"{'input':>24s}{'output':>24s}")
-
- for x in input if isinstance(input, list) else [input]:
- x = x.to(device)
- x.requires_grad = True
- for m in ops if isinstance(ops, list) else [ops]:
- m = m.to(device) if hasattr(m, 'to') else m # device
- m = m.half() if hasattr(m, 'half') and isinstance(x, torch.Tensor) and x.dtype is torch.float16 else m
- tf, tb, t = 0, 0, [0, 0, 0] # dt forward, backward
- try:
- flops = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 # GFLOPs
- except Exception:
- flops = 0
-
- try:
- for _ in range(n):
- t[0] = time_sync()
- y = m(x)
- t[1] = time_sync()
- try:
- _ = (sum(yi.sum() for yi in y) if isinstance(y, list) else y).sum().backward()
- t[2] = time_sync()
- except Exception: # no backward method
- # print(e) # for debug
- t[2] = float('nan')
- tf += (t[1] - t[0]) * 1000 / n # ms per op forward
- tb += (t[2] - t[1]) * 1000 / n # ms per op backward
- mem = torch.cuda.memory_reserved() / 1E9 if torch.cuda.is_available() else 0 # (GB)
- s_in = tuple(x.shape) if isinstance(x, torch.Tensor) else 'list'
- s_out = tuple(y.shape) if isinstance(y, torch.Tensor) else 'list'
- p = sum(list(x.numel() for x in m.parameters())) if isinstance(m, nn.Module) else 0 # parameters
- print(f'{p:12}{flops:12.4g}{mem:>14.3f}{tf:14.4g}{tb:14.4g}{str(s_in):>24s}{str(s_out):>24s}')
- results.append([p, flops, mem, tf, tb, s_in, s_out])
- except Exception as e:
- print(e)
- results.append(None)
- torch.cuda.empty_cache()
- return results
-
-
-def is_parallel(model):
- # Returns True if model is of type DP or DDP
- return type(model) in (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel)
-
-
-def de_parallel(model):
- # De-parallelize a model: returns single-GPU model if model is of type DP or DDP
- return model.module if is_parallel(model) else model
-
-
-def initialize_weights(model):
- for m in model.modules():
- t = type(m)
- if t is nn.Conv2d:
- pass # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
- elif t is nn.BatchNorm2d:
- m.eps = 1e-3
- m.momentum = 0.03
- elif t in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6, nn.SiLU]:
- m.inplace = True
-
-
-def find_modules(model, mclass=nn.Conv2d):
- # Finds layer indices matching module class 'mclass'
- return [i for i, m in enumerate(model.module_list) if isinstance(m, mclass)]
-
-
-def sparsity(model):
- # Return global model sparsity
- a, b = 0, 0
- for p in model.parameters():
- a += p.numel()
- b += (p == 0).sum()
- return b / a
-
-
-def prune(model, amount=0.3):
- # Prune model to requested global sparsity
- import torch.nn.utils.prune as prune
- print('Pruning model... ', end='')
- for name, m in model.named_modules():
- if isinstance(m, nn.Conv2d):
- prune.l1_unstructured(m, name='weight', amount=amount) # prune
- prune.remove(m, 'weight') # make permanent
- print(' %.3g global sparsity' % sparsity(model))
-
-
-def fuse_conv_and_bn(conv, bn):
- # Fuse Conv2d() and BatchNorm2d() layers https://tehnokv.com/posts/fusing-batchnorm-and-conv/
- fusedconv = nn.Conv2d(conv.in_channels,
- conv.out_channels,
- kernel_size=conv.kernel_size,
- stride=conv.stride,
- padding=conv.padding,
- groups=conv.groups,
- bias=True).requires_grad_(False).to(conv.weight.device)
-
- # Prepare filters
- w_conv = conv.weight.clone().view(conv.out_channels, -1)
- w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var)))
- fusedconv.weight.copy_(torch.mm(w_bn, w_conv).view(fusedconv.weight.shape))
-
- # Prepare spatial bias
- b_conv = torch.zeros(conv.weight.size(0), device=conv.weight.device) if conv.bias is None else conv.bias
- b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps))
- fusedconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn)
-
- return fusedconv
-
-
-def model_info(model, verbose=False, img_size=640):
- # Model information. img_size may be int or list, i.e. img_size=640 or img_size=[640, 320]
- n_p = sum(x.numel() for x in model.parameters()) # number parameters
- n_g = sum(x.numel() for x in model.parameters() if x.requires_grad) # number gradients
- if verbose:
- print(f"{'layer':>5} {'name':>40} {'gradient':>9} {'parameters':>12} {'shape':>20} {'mu':>10} {'sigma':>10}")
- for i, (name, p) in enumerate(model.named_parameters()):
- name = name.replace('module_list.', '')
- print('%5g %40s %9s %12g %20s %10.3g %10.3g' %
- (i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std()))
-
- try: # FLOPs
- from thop import profile
- stride = max(int(model.stride.max()), 32) if hasattr(model, 'stride') else 32
- img = torch.zeros((1, model.yaml.get('ch', 3), stride, stride), device=next(model.parameters()).device) # input
- flops = profile(deepcopy(model), inputs=(img,), verbose=False)[0] / 1E9 * 2 # stride GFLOPs
- img_size = img_size if isinstance(img_size, list) else [img_size, img_size] # expand if int/float
- fs = ', %.1f GFLOPs' % (flops * img_size[0] / stride * img_size[1] / stride) # 640x640 GFLOPs
- except (ImportError, Exception):
- fs = ''
-
- name = Path(model.yaml_file).stem.replace('yolov5', 'YOLOv5') if hasattr(model, 'yaml_file') else 'Model'
- LOGGER.info(f"{name} summary: {len(list(model.modules()))} layers, {n_p} parameters, {n_g} gradients{fs}")
-
-
-def scale_img(img, ratio=1.0, same_shape=False, gs=32): # img(16,3,256,416)
- # Scales img(bs,3,y,x) by ratio constrained to gs-multiple
- if ratio == 1.0:
- return img
- else:
- h, w = img.shape[2:]
- s = (int(h * ratio), int(w * ratio)) # new size
- img = F.interpolate(img, size=s, mode='bilinear', align_corners=False) # resize
- if not same_shape: # pad/crop img
- h, w = (math.ceil(x * ratio / gs) * gs for x in (h, w))
- return F.pad(img, [0, w - s[1], 0, h - s[0]], value=0.447) # value = imagenet mean
-
-
-def copy_attr(a, b, include=(), exclude=()):
- # Copy attributes from b to a, options to only include [...] and to exclude [...]
- for k, v in b.__dict__.items():
- if (len(include) and k not in include) or k.startswith('_') or k in exclude:
- continue
- else:
- setattr(a, k, v)
-
-
-class EarlyStopping:
- # YOLOv5 simple early stopper
- def __init__(self, patience=30):
- self.best_fitness = 0.0 # i.e. mAP
- self.best_epoch = 0
- self.patience = patience or float('inf') # epochs to wait after fitness stops improving to stop
- self.possible_stop = False # possible stop may occur next epoch
-
- def __call__(self, epoch, fitness):
- if fitness >= self.best_fitness: # >= 0 to allow for early zero-fitness stage of training
- self.best_epoch = epoch
- self.best_fitness = fitness
- delta = epoch - self.best_epoch # epochs without improvement
- self.possible_stop = delta >= (self.patience - 1) # possible stop may occur next epoch
- stop = delta >= self.patience # stop training if patience exceeded
- if stop:
- LOGGER.info(f'Stopping training early as no improvement observed in last {self.patience} epochs. '
- f'Best results observed at epoch {self.best_epoch}, best model saved as best.pt.\n'
- f'To update EarlyStopping(patience={self.patience}) pass a new patience value, '
- f'i.e. `python train.py --patience 300` or use `--patience 0` to disable EarlyStopping.')
- return stop
-
-
-class ModelEMA:
- """ Updated Exponential Moving Average (EMA) from https://github.com/rwightman/pytorch-image-models
- Keeps a moving average of everything in the model state_dict (parameters and buffers)
- For EMA details see https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage
- """
-
- def __init__(self, model, decay=0.9999, tau=2000, updates=0):
- # Create EMA
- self.ema = deepcopy(de_parallel(model)).eval() # FP32 EMA
- # if next(model.parameters()).device.type != 'cpu':
- # self.ema.half() # FP16 EMA
- self.updates = updates # number of EMA updates
- self.decay = lambda x: decay * (1 - math.exp(-x / tau)) # decay exponential ramp (to help early epochs)
- for p in self.ema.parameters():
- p.requires_grad_(False)
-
- def update(self, model):
- # Update EMA parameters
- with torch.no_grad():
- self.updates += 1
- d = self.decay(self.updates)
-
- msd = de_parallel(model).state_dict() # model state_dict
- for k, v in self.ema.state_dict().items():
- if v.dtype.is_floating_point:
- v *= d
- v += (1 - d) * msd[k].detach()
-
- def update_attr(self, model, include=(), exclude=('process_group', 'reducer')):
- # Update EMA attributes
- copy_attr(self.ema, model, include, exclude)
diff --git a/ultralytics/yolov5/val.py b/ultralytics/yolov5/val.py
deleted file mode 100644
index 2dd2aec679f96e36ba11222f462b700e3b24df4d..0000000000000000000000000000000000000000
--- a/ultralytics/yolov5/val.py
+++ /dev/null
@@ -1,381 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Validate a trained YOLOv5 model accuracy on a custom dataset
-
-Usage:
- $ python path/to/val.py --weights yolov5s.pt --data coco128.yaml --img 640
-
-Usage - formats:
- $ python path/to/val.py --weights yolov5s.pt # PyTorch
- yolov5s.torchscript # TorchScript
- yolov5s.onnx # ONNX Runtime or OpenCV DNN with --dnn
- yolov5s.xml # OpenVINO
- yolov5s.engine # TensorRT
- yolov5s.mlmodel # CoreML (MacOS-only)
- yolov5s_saved_model # TensorFlow SavedModel
- yolov5s.pb # TensorFlow GraphDef
- yolov5s.tflite # TensorFlow Lite
- yolov5s_edgetpu.tflite # TensorFlow Edge TPU
-"""
-
-import argparse
-import json
-import os
-import sys
-from pathlib import Path
-from threading import Thread
-
-import numpy as np
-import torch
-from tqdm import tqdm
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[0] # YOLOv5 root directory
-if str(ROOT) not in sys.path:
- sys.path.append(str(ROOT)) # add ROOT to PATH
-ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
-
-from models.common import DetectMultiBackend
-from utils.callbacks import Callbacks
-from utils.datasets import create_dataloader
-from utils.general import (LOGGER, box_iou, check_dataset, check_img_size, check_requirements, check_yaml,
- coco80_to_coco91_class, colorstr, increment_path, non_max_suppression, print_args,
- scale_coords, xywh2xyxy, xyxy2xywh)
-from utils.metrics import ConfusionMatrix, ap_per_class
-from utils.plots import output_to_target, plot_images, plot_val_study
-from utils.torch_utils import select_device, time_sync
-
-
-def save_one_txt(predn, save_conf, shape, file):
- # Save one txt result
- gn = torch.tensor(shape)[[1, 0, 1, 0]] # normalization gain whwh
- for *xyxy, conf, cls in predn.tolist():
- xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
- line = (cls, *xywh, conf) if save_conf else (cls, *xywh) # label format
- with open(file, 'a') as f:
- f.write(('%g ' * len(line)).rstrip() % line + '\n')
-
-
-def save_one_json(predn, jdict, path, class_map):
- # Save one JSON result {"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}
- image_id = int(path.stem) if path.stem.isnumeric() else path.stem
- box = xyxy2xywh(predn[:, :4]) # xywh
- box[:, :2] -= box[:, 2:] / 2 # xy center to top-left corner
- for p, b in zip(predn.tolist(), box.tolist()):
- jdict.append({'image_id': image_id,
- 'category_id': class_map[int(p[5])],
- 'bbox': [round(x, 3) for x in b],
- 'score': round(p[4], 5)})
-
-
-def process_batch(detections, labels, iouv):
- """
- Return correct predictions matrix. Both sets of boxes are in (x1, y1, x2, y2) format.
- Arguments:
- detections (Array[N, 6]), x1, y1, x2, y2, conf, class
- labels (Array[M, 5]), class, x1, y1, x2, y2
- Returns:
- correct (Array[N, 10]), for 10 IoU levels
- """
- correct = torch.zeros(detections.shape[0], iouv.shape[0], dtype=torch.bool, device=iouv.device)
- iou = box_iou(labels[:, 1:], detections[:, :4])
- x = torch.where((iou >= iouv[0]) & (labels[:, 0:1] == detections[:, 5])) # IoU above threshold and classes match
- if x[0].shape[0]:
- matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy() # [label, detection, iou]
- if x[0].shape[0] > 1:
- matches = matches[matches[:, 2].argsort()[::-1]]
- matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
- # matches = matches[matches[:, 2].argsort()[::-1]]
- matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
- matches = torch.from_numpy(matches).to(iouv.device)
- correct[matches[:, 1].long()] = matches[:, 2:3] >= iouv
- return correct
-
-
-@torch.no_grad()
-def run(data,
- weights=None, # model.pt path(s)
- batch_size=32, # batch size
- imgsz=640, # inference size (pixels)
- conf_thres=0.001, # confidence threshold
- iou_thres=0.6, # NMS IoU threshold
- task='val', # train, val, test, speed or study
- device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
- workers=8, # max dataloader workers (per RANK in DDP mode)
- single_cls=False, # treat as single-class dataset
- augment=False, # augmented inference
- verbose=False, # verbose output
- save_txt=False, # save results to *.txt
- save_hybrid=False, # save label+prediction hybrid results to *.txt
- save_conf=False, # save confidences in --save-txt labels
- save_json=False, # save a COCO-JSON results file
- project=ROOT / 'runs/val', # save to project/name
- name='exp', # save to project/name
- exist_ok=False, # existing project/name ok, do not increment
- half=True, # use FP16 half-precision inference
- dnn=False, # use OpenCV DNN for ONNX inference
- model=None,
- dataloader=None,
- save_dir=Path(''),
- plots=True,
- callbacks=Callbacks(),
- compute_loss=None,
- ):
- # Initialize/load model and set device
- training = model is not None
- if training: # called by train.py
- device, pt, jit, engine = next(model.parameters()).device, True, False, False # get model device, PyTorch model
- half &= device.type != 'cpu' # half precision only supported on CUDA
- model.half() if half else model.float()
- else: # called directly
- device = select_device(device, batch_size=batch_size)
-
- # Directories
- save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
- (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
-
- # Load model
- model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)
- stride, pt, jit, engine = model.stride, model.pt, model.jit, model.engine
- imgsz = check_img_size(imgsz, s=stride) # check image size
- half = model.fp16 # FP16 supported on limited backends with CUDA
- if engine:
- batch_size = model.batch_size
- else:
- device = model.device
- if not (pt or jit):
- batch_size = 1 # export.py models default to batch-size 1
- LOGGER.info(f'Forcing --batch-size 1 square inference (1,3,{imgsz},{imgsz}) for non-PyTorch models')
-
- # Data
- data = check_dataset(data) # check
-
- # Configure
- model.eval()
- cuda = device.type != 'cpu'
- is_coco = isinstance(data.get('val'), str) and data['val'].endswith('coco/val2017.txt') # COCO dataset
- nc = 1 if single_cls else int(data['nc']) # number of classes
- iouv = torch.linspace(0.5, 0.95, 10, device=device) # iou vector for mAP@0.5:0.95
- niou = iouv.numel()
-
- # Dataloader
- if not training:
- model.warmup(imgsz=(1 if pt else batch_size, 3, imgsz, imgsz)) # warmup
- pad = 0.0 if task in ('speed', 'benchmark') else 0.5
- rect = False if task == 'benchmark' else pt # square inference for benchmarks
- task = task if task in ('train', 'val', 'test') else 'val' # path to train/val/test images
- dataloader = create_dataloader(data[task], imgsz, batch_size, stride, single_cls, pad=pad, rect=rect,
- workers=workers, prefix=colorstr(f'{task}: '))[0]
-
- seen = 0
- confusion_matrix = ConfusionMatrix(nc=nc)
- names = {k: v for k, v in enumerate(model.names if hasattr(model, 'names') else model.module.names)}
- class_map = coco80_to_coco91_class() if is_coco else list(range(1000))
- s = ('%20s' + '%11s' * 6) % ('Class', 'Images', 'Labels', 'P', 'R', 'mAP@.5', 'mAP@.5:.95')
- dt, p, r, f1, mp, mr, map50, map = [0.0, 0.0, 0.0], 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
- loss = torch.zeros(3, device=device)
- jdict, stats, ap, ap_class = [], [], [], []
- pbar = tqdm(dataloader, desc=s, bar_format='{l_bar}{bar:10}{r_bar}{bar:-10b}') # progress bar
- for batch_i, (im, targets, paths, shapes) in enumerate(pbar):
- t1 = time_sync()
- if cuda:
- im = im.to(device, non_blocking=True)
- targets = targets.to(device)
- im = im.half() if half else im.float() # uint8 to fp16/32
- im /= 255 # 0 - 255 to 0.0 - 1.0
- nb, _, height, width = im.shape # batch size, channels, height, width
- t2 = time_sync()
- dt[0] += t2 - t1
-
- # Inference
- out, train_out = model(im) if training else model(im, augment=augment, val=True) # inference, loss outputs
- dt[1] += time_sync() - t2
-
- # Loss
- if compute_loss:
- loss += compute_loss([x.float() for x in train_out], targets)[1] # box, obj, cls
-
- # NMS
- targets[:, 2:] *= torch.tensor((width, height, width, height), device=device) # to pixels
- lb = [targets[targets[:, 0] == i, 1:] for i in range(nb)] if save_hybrid else [] # for autolabelling
- t3 = time_sync()
- out = non_max_suppression(out, conf_thres, iou_thres, labels=lb, multi_label=True, agnostic=single_cls)
- dt[2] += time_sync() - t3
-
- # Metrics
- for si, pred in enumerate(out):
- labels = targets[targets[:, 0] == si, 1:]
- nl = len(labels)
- tcls = labels[:, 0].tolist() if nl else [] # target class
- path, shape = Path(paths[si]), shapes[si][0]
- seen += 1
-
- if len(pred) == 0:
- if nl:
- stats.append((torch.zeros(0, niou, dtype=torch.bool), torch.Tensor(), torch.Tensor(), tcls))
- continue
-
- # Predictions
- if single_cls:
- pred[:, 5] = 0
- predn = pred.clone()
- scale_coords(im[si].shape[1:], predn[:, :4], shape, shapes[si][1]) # native-space pred
-
- # Evaluate
- if nl:
- tbox = xywh2xyxy(labels[:, 1:5]) # target boxes
- scale_coords(im[si].shape[1:], tbox, shape, shapes[si][1]) # native-space labels
- labelsn = torch.cat((labels[:, 0:1], tbox), 1) # native-space labels
- correct = process_batch(predn, labelsn, iouv)
- if plots:
- confusion_matrix.process_batch(predn, labelsn)
- else:
- correct = torch.zeros(pred.shape[0], niou, dtype=torch.bool)
- stats.append((correct.cpu(), pred[:, 4].cpu(), pred[:, 5].cpu(), tcls)) # (correct, conf, pcls, tcls)
-
- # Save/log
- if save_txt:
- save_one_txt(predn, save_conf, shape, file=save_dir / 'labels' / (path.stem + '.txt'))
- if save_json:
- save_one_json(predn, jdict, path, class_map) # append to COCO-JSON dictionary
- callbacks.run('on_val_image_end', pred, predn, path, names, im[si])
-
- # Plot images
- if plots and batch_i < 3:
- f = save_dir / f'val_batch{batch_i}_labels.jpg' # labels
- Thread(target=plot_images, args=(im, targets, paths, f, names), daemon=True).start()
- f = save_dir / f'val_batch{batch_i}_pred.jpg' # predictions
- Thread(target=plot_images, args=(im, output_to_target(out), paths, f, names), daemon=True).start()
-
- # Compute metrics
- stats = [np.concatenate(x, 0) for x in zip(*stats)] # to numpy
- if len(stats) and stats[0].any():
- tp, fp, p, r, f1, ap, ap_class = ap_per_class(*stats, plot=plots, save_dir=save_dir, names=names)
- ap50, ap = ap[:, 0], ap.mean(1) # AP@0.5, AP@0.5:0.95
- mp, mr, map50, map = p.mean(), r.mean(), ap50.mean(), ap.mean()
- nt = np.bincount(stats[3].astype(np.int64), minlength=nc) # number of targets per class
- else:
- nt = torch.zeros(1)
-
- # Print results
- pf = '%20s' + '%11i' * 2 + '%11.3g' * 4 # print format
- LOGGER.info(pf % ('all', seen, nt.sum(), mp, mr, map50, map))
-
- # Print results per class
- if (verbose or (nc < 50 and not training)) and nc > 1 and len(stats):
- for i, c in enumerate(ap_class):
- LOGGER.info(pf % (names[c], seen, nt[c], p[i], r[i], ap50[i], ap[i]))
-
- # Print speeds
- t = tuple(x / seen * 1E3 for x in dt) # speeds per image
- if not training:
- shape = (batch_size, 3, imgsz, imgsz)
- LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {shape}' % t)
-
- # Plots
- if plots:
- confusion_matrix.plot(save_dir=save_dir, names=list(names.values()))
- callbacks.run('on_val_end')
-
- # Save JSON
- if save_json and len(jdict):
- w = Path(weights[0] if isinstance(weights, list) else weights).stem if weights is not None else '' # weights
- anno_json = str(Path(data.get('path', '../coco')) / 'annotations/instances_val2017.json') # annotations json
- pred_json = str(save_dir / f"{w}_predictions.json") # predictions json
- LOGGER.info(f'\nEvaluating pycocotools mAP... saving {pred_json}...')
- with open(pred_json, 'w') as f:
- json.dump(jdict, f)
-
- try: # https://github.com/cocodataset/cocoapi/blob/master/PythonAPI/pycocoEvalDemo.ipynb
- check_requirements(['pycocotools'])
- from pycocotools.coco import COCO
- from pycocotools.cocoeval import COCOeval
-
- anno = COCO(anno_json) # init annotations api
- pred = anno.loadRes(pred_json) # init predictions api
- eval = COCOeval(anno, pred, 'bbox')
- if is_coco:
- eval.params.imgIds = [int(Path(x).stem) for x in dataloader.dataset.im_files] # image IDs to evaluate
- eval.evaluate()
- eval.accumulate()
- eval.summarize()
- map, map50 = eval.stats[:2] # update results (mAP@0.5:0.95, mAP@0.5)
- except Exception as e:
- LOGGER.info(f'pycocotools unable to run: {e}')
-
- # Return results
- model.float() # for training
- if not training:
- s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
- LOGGER.info(f"Results saved to {colorstr('bold', save_dir)}{s}")
- maps = np.zeros(nc) + map
- for i, c in enumerate(ap_class):
- maps[c] = ap[i]
- return (mp, mr, map50, map, *(loss.cpu() / len(dataloader)).tolist()), maps, t
-
-
-def parse_opt():
- parser = argparse.ArgumentParser()
- parser.add_argument('--data', type=str, default=ROOT / 'data/coco128.yaml', help='dataset.yaml path')
- parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'yolov5s.pt', help='model.pt path(s)')
- parser.add_argument('--batch-size', type=int, default=32, help='batch size')
- parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='inference size (pixels)')
- parser.add_argument('--conf-thres', type=float, default=0.001, help='confidence threshold')
- parser.add_argument('--iou-thres', type=float, default=0.6, help='NMS IoU threshold')
- parser.add_argument('--task', default='val', help='train, val, test, speed or study')
- parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
- parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')
- parser.add_argument('--single-cls', action='store_true', help='treat as single-class dataset')
- parser.add_argument('--augment', action='store_true', help='augmented inference')
- parser.add_argument('--verbose', action='store_true', help='report mAP by class')
- parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
- parser.add_argument('--save-hybrid', action='store_true', help='save label+prediction hybrid results to *.txt')
- parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
- parser.add_argument('--save-json', action='store_true', help='save a COCO-JSON results file')
- parser.add_argument('--project', default=ROOT / 'runs/val', help='save to project/name')
- parser.add_argument('--name', default='exp', help='save to project/name')
- parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
- parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
- parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')
- opt = parser.parse_args()
- opt.data = check_yaml(opt.data) # check YAML
- opt.save_json |= opt.data.endswith('coco.yaml')
- opt.save_txt |= opt.save_hybrid
- print_args(FILE.stem, opt)
- return opt
-
-
-def main(opt):
- check_requirements(requirements=ROOT / 'requirements.txt', exclude=('tensorboard', 'thop'))
-
- if opt.task in ('train', 'val', 'test'): # run normally
- if opt.conf_thres > 0.001: # https://github.com/ultralytics/yolov5/issues/1466
- LOGGER.info(f'WARNING: confidence threshold {opt.conf_thres} >> 0.001 will produce invalid mAP values.')
- run(**vars(opt))
-
- else:
- weights = opt.weights if isinstance(opt.weights, list) else [opt.weights]
- opt.half = True # FP16 for fastest results
- if opt.task == 'speed': # speed benchmarks
- # python val.py --task speed --data coco.yaml --batch 1 --weights yolov5n.pt yolov5s.pt...
- opt.conf_thres, opt.iou_thres, opt.save_json = 0.25, 0.45, False
- for opt.weights in weights:
- run(**vars(opt), plots=False)
-
- elif opt.task == 'study': # speed vs mAP benchmarks
- # python val.py --task study --data coco.yaml --iou 0.7 --weights yolov5n.pt yolov5s.pt...
- for opt.weights in weights:
- f = f'study_{Path(opt.data).stem}_{Path(opt.weights).stem}.txt' # filename to save to
- x, y = list(range(256, 1536 + 128, 128)), [] # x axis (image sizes), y axis
- for opt.imgsz in x: # img-size
- LOGGER.info(f'\nRunning {f} --imgsz {opt.imgsz}...')
- r, _, t = run(**vars(opt), plots=False)
- y.append(r + t) # results and times
- np.savetxt(f, y, fmt='%10.4g') # save
- os.system('zip -r study.zip study_*.txt')
- plot_val_study(x=x) # plot
-
-
-if __name__ == "__main__":
- opt = parse_opt()
- main(opt)
diff --git "a/\343\200\216\345\271\263\345\256\266\347\211\251\350\252\236\343\200\217(\345\233\275\346\226\207\345\255\246\347\240\224\347\251\266\350\263\207\346\226\231\351\244\250\346\217\220\344\276\233).jpg" "b/\343\200\216\345\271\263\345\256\266\347\211\251\350\252\236\343\200\217(\345\233\275\346\226\207\345\255\246\347\240\224\347\251\266\350\263\207\346\226\231\351\244\250\346\217\220\344\276\233).jpg"
deleted file mode 100644
index 6bf61d4c54c8a88ef2af8766faf7374fc4535ca4..0000000000000000000000000000000000000000
Binary files "a/\343\200\216\345\271\263\345\256\266\347\211\251\350\252\236\343\200\217(\345\233\275\346\226\207\345\255\246\347\240\224\347\251\266\350\263\207\346\226\231\351\244\250\346\217\220\344\276\233).jpg" and /dev/null differ
diff --git "a/\343\200\216\346\272\220\346\260\217\347\211\251\350\252\236\343\200\217(\344\272\254\351\203\275\345\244\247\345\255\246\346\211\200\350\224\265).jpg" "b/\343\200\216\346\272\220\346\260\217\347\211\251\350\252\236\343\200\217(\344\272\254\351\203\275\345\244\247\345\255\246\346\211\200\350\224\265).jpg"
deleted file mode 100644
index 16d4886797b27e7aa2303b1d27e66933ccfaf004..0000000000000000000000000000000000000000
Binary files "a/\343\200\216\346\272\220\346\260\217\347\211\251\350\252\236\343\200\217(\344\272\254\351\203\275\345\244\247\345\255\246\346\211\200\350\224\265).jpg" and /dev/null differ
diff --git "a/\343\200\216\346\272\220\346\260\217\347\211\251\350\252\236\343\200\217(\346\235\261\344\272\254\345\244\247\345\255\246\347\267\217\345\220\210\345\233\263\346\233\270\351\244\250\346\211\200\350\224\265).jpg" "b/\343\200\216\346\272\220\346\260\217\347\211\251\350\252\236\343\200\217(\346\235\261\344\272\254\345\244\247\345\255\246\347\267\217\345\220\210\345\233\263\346\233\270\351\244\250\346\211\200\350\224\265).jpg"
deleted file mode 100644
index e4321d3b86ca2bb4fc1a7c5d6e3cd749c3c14e7d..0000000000000000000000000000000000000000
Binary files "a/\343\200\216\346\272\220\346\260\217\347\211\251\350\252\236\343\200\217(\346\235\261\344\272\254\345\244\247\345\255\246\347\267\217\345\220\210\345\233\263\346\233\270\351\244\250\346\211\200\350\224\265).jpg" and /dev/null differ