+ - **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+ - **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+ - **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/) 
+
+ ## Status
+
+ 
+
+ If this badge is green, all [Ultralytics CI](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml?query=event%3Aschedule) tests are currently passing. CI tests verify correct operation of all YOLOv8 [Modes](https://docs.ultralytics.com/modes/) and [Tasks](https://docs.ultralytics.com/tasks/) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/.github/workflows/links.yml b/ultralytics/.github/workflows/links.yml
new file mode 100644
index 0000000000000000000000000000000000000000..05408fd6227b2e0cb1eb3788a69b0aa6d089c520
--- /dev/null
+++ b/ultralytics/.github/workflows/links.yml
@@ -0,0 +1,45 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Continuous Integration (CI) GitHub Actions tests broken link checker using https://github.com/lycheeverse/lychee
+# Ignores the following status codes to reduce false positives:
+# - 403(OpenVINO, 'forbidden')
+# - 429(Instagram, 'too many requests')
+# - 500(Zenodo, 'cached')
+# - 502(Zenodo, 'bad gateway')
+# - 999(LinkedIn, 'unknown status code')
+
+name: Check Broken links
+
+on:
+ workflow_dispatch:
+ schedule:
+ - cron: '0 0 * * *' # runs at 00:00 UTC every day
+
+jobs:
+ Links:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Download and install lychee
+ run: |
+ LYCHEE_URL=$(curl -s https://api.github.com/repos/lycheeverse/lychee/releases/latest | grep "browser_download_url" | grep "x86_64-unknown-linux-gnu.tar.gz" | cut -d '"' -f 4)
+ curl -L $LYCHEE_URL -o lychee.tar.gz
+ tar xzf lychee.tar.gz
+ sudo mv lychee /usr/local/bin
+
+ - name: Test Markdown and HTML links with retry
+ uses: nick-invision/retry@v2
+ with:
+ timeout_minutes: 5
+ retry_wait_seconds: 60
+ max_attempts: 3
+ command: lychee --accept 403,429,500,502,999 --exclude-loopback --exclude 'https?://(www\.)?(linkedin\.com|twitter\.com|instagram\.com|kaggle\.com|fonts\.gstatic\.com|url\.com)' --exclude-path '**/ci.yaml' --exclude-mail --github-token ${{ secrets.GITHUB_TOKEN }} './**/*.md' './**/*.html'
+
+ - name: Test Markdown, HTML, YAML, Python and Notebook links with retry
+ if: github.event_name == 'workflow_dispatch'
+ uses: nick-invision/retry@v2
+ with:
+ timeout_minutes: 5
+ retry_wait_seconds: 60
+ max_attempts: 3
+ command: lychee --accept 429,999 --exclude-loopback --exclude 'https?://(www\.)?(linkedin\.com|twitter\.com|instagram\.com|kaggle\.com|fonts\.gstatic\.com|url\.com)' --exclude-path '**/ci.yaml' --exclude-mail --github-token ${{ secrets.GITHUB_TOKEN }} './**/*.md' './**/*.html' './**/*.yml' './**/*.yaml' './**/*.py' './**/*.ipynb'
diff --git a/ultralytics/.github/workflows/publish.yml b/ultralytics/.github/workflows/publish.yml
new file mode 100644
index 0000000000000000000000000000000000000000..01e48775e4c1433299a0aaf5e5684ae0ff1d4597
--- /dev/null
+++ b/ultralytics/.github/workflows/publish.yml
@@ -0,0 +1,109 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Publish pip package to PyPI https://pypi.org/project/ultralytics/ and Docs to https://docs.ultralytics.com
+
+name: Publish to PyPI and Deploy Docs
+
+on:
+ push:
+ branches: [main]
+ workflow_dispatch:
+ inputs:
+ pypi:
+ type: boolean
+ description: Publish to PyPI
+ docs:
+ type: boolean
+ description: Deploy Docs
+
+jobs:
+ publish:
+ if: github.repository == 'ultralytics/ultralytics' && github.actor == 'glenn-jocher'
+ name: Publish
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@v4
+ with:
+ fetch-depth: "0" # pulls all commits (needed correct last updated dates in Docs)
+ - name: Set up Python environment
+ uses: actions/setup-python@v4
+ with:
+ python-version: '3.10'
+ cache: 'pip' # caching pip dependencies
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip wheel build twine
+ pip install -e ".[dev]" --extra-index-url https://download.pytorch.org/whl/cpu
+ - name: Check PyPI version
+ shell: python
+ run: |
+ import os
+ import ultralytics
+ from ultralytics.utils.checks import check_latest_pypi_version
+
+ v_local = tuple(map(int, ultralytics.__version__.split('.')))
+ v_pypi = tuple(map(int, check_latest_pypi_version().split('.')))
+ print(f'Local version is {v_local}')
+ print(f'PyPI version is {v_pypi}')
+ d = [a - b for a, b in zip(v_local, v_pypi)] # diff
+ increment = (d[0] == d[1] == 0) and (0 < d[2] < 3) # only publish if patch version increments by 1 or 2
+ os.system(f'echo "increment={increment}" >> $GITHUB_OUTPUT')
+ os.system(f'echo "version={ultralytics.__version__}" >> $GITHUB_OUTPUT')
+ if increment:
+ print('Local version is higher than PyPI version. Publishing new version to PyPI ✅.')
+ id: check_pypi
+ - name: Publish to PyPI
+ continue-on-error: true
+ if: (github.event_name == 'push' || github.event.inputs.pypi == 'true') && steps.check_pypi.outputs.increment == 'True'
+ env:
+ PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+ run: |
+ python -m build
+ python -m twine upload dist/* -u __token__ -p $PYPI_TOKEN
+ - name: Deploy Docs
+ continue-on-error: true
+ if: (github.event_name == 'push' || github.event.inputs.docs == 'true') && github.repository == 'ultralytics/ultralytics' && github.actor == 'glenn-jocher'
+ env:
+ PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+ run: |
+ mkdocs build
+ git config --global user.name "Glenn Jocher"
+ git config --global user.email "glenn.jocher@ultralytics.com"
+ git clone https://github.com/ultralytics/docs.git docs-repo
+ cd docs-repo
+ git checkout gh-pages || git checkout -b gh-pages
+ rm -rf *
+ cp -R ../site/* .
+ git add .
+ git commit -m "Update Docs for 'ultralytics ${{ steps.check_pypi.outputs.version }}'"
+ git push https://${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/ultralytics/docs.git gh-pages
+ - name: Extract PR Details
+ run: |
+ if [ "${{ github.event_name }}" = "pull_request" ]; then
+ PR_JSON=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" https://api.github.com/repos/${{ github.repository }}/pulls/${{ github.event.pull_request.number }})
+ PR_NUMBER=${{ github.event.pull_request.number }}
+ PR_TITLE=$(echo $PR_JSON | jq -r '.title')
+ else
+ COMMIT_SHA=${{ github.event.after }}
+ PR_JSON=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" "https://api.github.com/search/issues?q=repo:${{ github.repository }}+is:pr+is:merged+sha:$COMMIT_SHA")
+ PR_NUMBER=$(echo $PR_JSON | jq -r '.items[0].number')
+ PR_TITLE=$(echo $PR_JSON | jq -r '.items[0].title')
+ fi
+ echo "PR_NUMBER=$PR_NUMBER" >> $GITHUB_ENV
+ echo "PR_TITLE=$PR_TITLE" >> $GITHUB_ENV
+ - name: Notify on Slack (Success)
+ if: success() && github.event_name == 'push' && steps.check_pypi.outputs.increment == 'True'
+ uses: slackapi/slack-github-action@v1.24.0
+ with:
+ payload: |
+ {"text": " GitHub Actions success for ${{ github.workflow }} ✅\n\n\n*Repository:* https://github.com/${{ github.repository }}\n*Action:* https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}\n*Author:* ${{ github.actor }}\n*Event:* NEW 'ultralytics ${{ steps.check_pypi.outputs.version }}' pip package published 😃\n*Job Status:* ${{ job.status }}\n*Pull Request:* 
+
+ 
+
+ 
+ 
+
+
+
+
+ 
+
+
+ 
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+All [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+
+
+
+## 
+
+##
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+所有[模型](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)在首次使用时会自动从最新的Ultralytics [发布版本](https://github.com/ultralytics/assets/releases)下载。
+
+
+
+
+##
+
+##
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
+
+The example showcases the variety and complexity of the images in the COCO8 dataset and the benefits of using mosaicing during the training process.
+
+## Citations and Acknowledgments
+
+If you use the COCO dataset in your research or development work, please cite the following paper:
+
+!!! note ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{lin2015microsoft,
+ title={Microsoft COCO: Common Objects in Context},
+ author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
+ year={2015},
+ eprint={1405.0312},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the computer vision community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
diff --git a/ultralytics/docs/datasets/detect/globalwheat2020.md b/ultralytics/docs/datasets/detect/globalwheat2020.md
new file mode 100644
index 0000000000000000000000000000000000000000..0f0d7c0a80e9f409557c327d2d73ad0fa1d0df42
--- /dev/null
+++ b/ultralytics/docs/datasets/detect/globalwheat2020.md
@@ -0,0 +1,91 @@
+---
+comments: true
+description: Understand how to utilize the vast Global Wheat Head Dataset for building wheat head detection models. Features, structure, applications, usage, sample data, and citation.
+keywords: Ultralytics, YOLO, Global Wheat Head Dataset, wheat head detection, plant phenotyping, crop management, deep learning, outdoor images, annotations, YAML configuration
+---
+
+# Global Wheat Head Dataset
+
+The [Global Wheat Head Dataset](http://www.global-wheat.com/) is a collection of images designed to support the development of accurate wheat head detection models for applications in wheat phenotyping and crop management. Wheat heads, also known as spikes, are the grain-bearing parts of the wheat plant. Accurate estimation of wheat head density and size is essential for assessing crop health, maturity, and yield potential. The dataset, created by a collaboration of nine research institutes from seven countries, covers multiple growing regions to ensure models generalize well across different environments.
+
+## Key Features
+
+- The dataset contains over 3,000 training images from Europe (France, UK, Switzerland) and North America (Canada).
+- It includes approximately 1,000 test images from Australia, Japan, and China.
+- Images are outdoor field images, capturing the natural variability in wheat head appearances.
+- Annotations include wheat head bounding boxes to support object detection tasks.
+
+## Dataset Structure
+
+The Global Wheat Head Dataset is organized into two main subsets:
+
+1. **Training Set**: This subset contains over 3,000 images from Europe and North America. The images are labeled with wheat head bounding boxes, providing ground truth for training object detection models.
+2. **Test Set**: This subset consists of approximately 1,000 images from Australia, Japan, and China. These images are used for evaluating the performance of trained models on unseen genotypes, environments, and observational conditions.
+
+## Applications
+
+The Global Wheat Head Dataset is widely used for training and evaluating deep learning models in wheat head detection tasks. The dataset's diverse set of images, capturing a wide range of appearances, environments, and conditions, make it a valuable resource for researchers and practitioners in the field of plant phenotyping and crop management.
+
+## Dataset YAML
+
+A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the case of the Global Wheat Head Dataset, the `GlobalWheat2020.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/GlobalWheat2020.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/GlobalWheat2020.yaml).
+
+!!! example "ultralytics/cfg/datasets/GlobalWheat2020.yaml"
+
+ ```yaml
+ --8<-- "ultralytics/cfg/datasets/GlobalWheat2020.yaml"
+ ```
+
+## Usage
+
+To train a YOLOv8n model on the Global Wheat Head Dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
+
+!!! example "Train Example"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load a pretrained model (recommended for training)
+
+ # Train the model
+ results = model.train(data='GlobalWheat2020.yaml', epochs=100, imgsz=640)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Start training from a pretrained *.pt model
+ yolo detect train data=GlobalWheat2020.yaml model=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+## Sample Data and Annotations
+
+The Global Wheat Head Dataset contains a diverse set of outdoor field images, capturing the natural variability in wheat head appearances, environments, and conditions. Here are some examples of data from the dataset, along with their corresponding annotations:
+
+
+
+- **Wheat Head Detection**: This image demonstrates an example of wheat head detection, where wheat heads are annotated with bounding boxes. The dataset provides a variety of images to facilitate the development of models for this task.
+
+The example showcases the variety and complexity of the data in the Global Wheat Head Dataset and highlights the importance of accurate wheat head detection for applications in wheat phenotyping and crop management.
+
+## Citations and Acknowledgments
+
+If you use the Global Wheat Head Dataset in your research or development work, please cite the following paper:
+
+!!! note ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @article{david2020global,
+ title={Global Wheat Head Detection (GWHD) Dataset: A Large and Diverse Dataset of High-Resolution RGB-Labelled Images to Develop and Benchmark Wheat Head Detection Methods},
+ author={David, Etienne and Madec, Simon and Sadeghi-Tehran, Pouria and Aasen, Helge and Zheng, Bangyou and Liu, Shouyang and Kirchgessner, Norbert and Ishikawa, Goro and Nagasawa, Koichi and Badhon, Minhajul and others},
+ journal={arXiv preprint arXiv:2005.02162},
+ year={2020}
+ }
+ ```
+
+We would like to acknowledge the researchers and institutions that contributed to the creation and maintenance of the Global Wheat Head Dataset as a valuable resource for the plant phenotyping and crop management research community. For more information about the dataset and its creators, visit the [Global Wheat Head Dataset website](http://www.global-wheat.com/).
diff --git a/ultralytics/docs/datasets/detect/index.md b/ultralytics/docs/datasets/detect/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..20dcaac1b37da89898584f888c21ed7cc72926fe
--- /dev/null
+++ b/ultralytics/docs/datasets/detect/index.md
@@ -0,0 +1,108 @@
+---
+comments: true
+description: Navigate through supported dataset formats, methods to utilize them and how to add your own datasets. Get insights on porting or converting label formats.
+keywords: Ultralytics, YOLO, datasets, object detection, dataset formats, label formats, data conversion
+---
+
+# Object Detection Datasets Overview
+
+Training a robust and accurate object detection model requires a comprehensive dataset. This guide introduces various formats of datasets that are compatible with the Ultralytics YOLO model and provides insights into their structure, usage, and how to convert between different formats.
+
+## Supported Dataset Formats
+
+### Ultralytics YOLO format
+
+The Ultralytics YOLO format is a dataset configuration format that allows you to define the dataset root directory, the relative paths to training/validation/testing image directories or *.txt files containing image paths, and a dictionary of class names. Here is an example:
+
+```yaml
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco8 # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+test: # test images (optional)
+
+# Classes (80 COCO classes)
+names:
+ 0: person
+ 1: bicycle
+ 2: car
+ ...
+ 77: teddy bear
+ 78: hair drier
+ 79: toothbrush
+```
+
+Labels for this format should be exported to YOLO format with one `*.txt` file per image. If there are no objects in an image, no `*.txt` file is required. The `*.txt` file should be formatted with one row per object in `class x_center y_center width height` format. Box coordinates must be in **normalized xywh** format (from 0 to 1). If your boxes are in pixels, you should divide `x_center` and `width` by image width, and `y_center` and `height` by image height. Class numbers should be zero-indexed (start with 0).
+
+
+
+- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
+
+The example showcases the variety and complexity of the images in the COCO8-Pose dataset and the benefits of using mosaicing during the training process.
+
+## Citations and Acknowledgments
+
+If you use the COCO dataset in your research or development work, please cite the following paper:
+
+!!! note ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{lin2015microsoft,
+ title={Microsoft COCO: Common Objects in Context},
+ author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
+ year={2015},
+ eprint={1405.0312},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the computer vision community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
diff --git a/ultralytics/docs/datasets/pose/index.md b/ultralytics/docs/datasets/pose/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..aea573fec3fe24c1c1ce7c640d141cfb8f99b791
--- /dev/null
+++ b/ultralytics/docs/datasets/pose/index.md
@@ -0,0 +1,138 @@
+---
+comments: true
+description: Understand the YOLO pose dataset format and learn to use Ultralytics datasets to train your pose estimation models effectively.
+keywords: Ultralytics, YOLO, pose estimation, datasets, training, YAML, keypoints, COCO-Pose, COCO8-Pose, data conversion
+---
+
+# Pose Estimation Datasets Overview
+
+## Supported Dataset Formats
+
+### Ultralytics YOLO format
+
+The dataset label format used for training YOLO pose models is as follows:
+
+1. One text file per image: Each image in the dataset has a corresponding text file with the same name as the image file and the ".txt" extension.
+2. One row per object: Each row in the text file corresponds to one object instance in the image.
+3. Object information per row: Each row contains the following information about the object instance:
+ - Object class index: An integer representing the class of the object (e.g., 0 for person, 1 for car, etc.).
+ - Object center coordinates: The x and y coordinates of the center of the object, normalized to be between 0 and 1.
+ - Object width and height: The width and height of the object, normalized to be between 0 and 1.
+ - Object keypoint coordinates: The keypoints of the object, normalized to be between 0 and 1.
+
+Here is an example of the label format for pose estimation task:
+
+Format with Dim = 2
+
+```
+
+
+- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
+
+The example showcases the variety and complexity of the images in the Tiger-Pose dataset and the benefits of using mosaicing during the training process.
+
+## Inference Example
+
+!!! example "Inference Example"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('path/to/best.pt') # load a tiger-pose trained model
+
+ # Run inference
+ results = model.predict(source="https://www.youtube.com/watch?v=MIBAT6BGE6U&pp=ygUYdGlnZXIgd2Fsa2luZyByZWZlcmVuY2Ug" show=True)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Run inference using a tiger-pose trained model
+ yolo task=pose mode=predict source="https://www.youtube.com/watch?v=MIBAT6BGE6U&pp=ygUYdGlnZXIgd2Fsa2luZyByZWZlcmVuY2Ug" show=True model="path/to/best.pt"
+ ```
+
+## Citations and Acknowledgments
+
+The dataset has been released available under the [AGPL-3.0 License](https://github.com/ultralytics/ultralytics/blob/main/LICENSE).
diff --git a/ultralytics/docs/datasets/segment/coco.md b/ultralytics/docs/datasets/segment/coco.md
new file mode 100644
index 0000000000000000000000000000000000000000..c1810fd0260afbac0608885b09198b79af7b5617
--- /dev/null
+++ b/ultralytics/docs/datasets/segment/coco.md
@@ -0,0 +1,94 @@
+---
+comments: true
+description: Explore the possibilities of the COCO-Seg dataset, designed for object instance segmentation and YOLO model training. Discover key features, dataset structure, applications, and usage.
+keywords: Ultralytics, YOLO, COCO-Seg, dataset, instance segmentation, model training, deep learning, computer vision
+---
+
+# COCO-Seg Dataset
+
+The [COCO-Seg](https://cocodataset.org/#home) dataset, an extension of the COCO (Common Objects in Context) dataset, is specially designed to aid research in object instance segmentation. It uses the same images as COCO but introduces more detailed segmentation annotations. This dataset is a crucial resource for researchers and developers working on instance segmentation tasks, especially for training YOLO models.
+
+## Key Features
+
+- COCO-Seg retains the original 330K images from COCO.
+- The dataset consists of the same 80 object categories found in the original COCO dataset.
+- Annotations now include more detailed instance segmentation masks for each object in the images.
+- COCO-Seg provides standardized evaluation metrics like mean Average Precision (mAP) for object detection, and mean Average Recall (mAR) for instance segmentation tasks, enabling effective comparison of model performance.
+
+## Dataset Structure
+
+The COCO-Seg dataset is partitioned into three subsets:
+
+1. **Train2017**: This subset contains 118K images for training instance segmentation models.
+2. **Val2017**: This subset includes 5K images used for validation purposes during model training.
+3. **Test2017**: This subset encompasses 20K images used for testing and benchmarking the trained models. Ground truth annotations for this subset are not publicly available, and the results are submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7383) for performance evaluation.
+
+## Applications
+
+COCO-Seg is widely used for training and evaluating deep learning models in instance segmentation, such as the YOLO models. The large number of annotated images, the diversity of object categories, and the standardized evaluation metrics make it an indispensable resource for computer vision researchers and practitioners.
+
+## Dataset YAML
+
+A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO-Seg dataset, the `coco.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
+
+!!! example "ultralytics/cfg/datasets/coco.yaml"
+
+ ```yaml
+ --8<-- "ultralytics/cfg/datasets/coco.yaml"
+ ```
+
+## Usage
+
+To train a YOLOv8n-seg model on the COCO-Seg dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
+
+!!! example "Train Example"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-seg.pt') # load a pretrained model (recommended for training)
+
+ # Train the model
+ results = model.train(data='coco-seg.yaml', epochs=100, imgsz=640)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Start training from a pretrained *.pt model
+ yolo detect train data=coco-seg.yaml model=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+## Sample Images and Annotations
+
+COCO-Seg, like its predecessor COCO, contains a diverse set of images with various object categories and complex scenes. However, COCO-Seg introduces more detailed instance segmentation masks for each object in the images. Here are some examples of images from the dataset, along with their corresponding instance segmentation masks:
+
+
+
+- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This aids the model's ability to generalize to different object sizes, aspect ratios, and contexts.
+
+The example showcases the variety and complexity of the images in the COCO-Seg dataset and the benefits of using mosaicing during the training process.
+
+## Citations and Acknowledgments
+
+If you use the COCO-Seg dataset in your research or development work, please cite the original COCO paper and acknowledge the extension to COCO-Seg:
+
+!!! note ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{lin2015microsoft,
+ title={Microsoft COCO: Common Objects in Context},
+ author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
+ year={2015},
+ eprint={1405.0312},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+We extend our thanks to the COCO Consortium for creating and maintaining this invaluable resource for the computer vision community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
diff --git a/ultralytics/docs/datasets/segment/coco8-seg.md b/ultralytics/docs/datasets/segment/coco8-seg.md
new file mode 100644
index 0000000000000000000000000000000000000000..46f2a4c99da84e8d53b883e637be6312b87ecf55
--- /dev/null
+++ b/ultralytics/docs/datasets/segment/coco8-seg.md
@@ -0,0 +1,80 @@
+---
+comments: true
+description: 'Discover the COCO8-Seg: a compact but versatile instance segmentation dataset ideal for testing Ultralytics YOLOv8 detection approaches. Complete usage guide included.'
+keywords: COCO8-Seg dataset, Ultralytics, YOLOv8, instance segmentation, dataset configuration, YAML, YOLOv8n-seg model, mosaiced dataset images
+---
+
+# COCO8-Seg Dataset
+
+## Introduction
+
+[Ultralytics](https://ultralytics.com) COCO8-Seg is a small, but versatile instance segmentation dataset composed of the first 8 images of the COCO train 2017 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging segmentation models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
+
+This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com)
+and [YOLOv8](https://github.com/ultralytics/ultralytics).
+
+## Dataset YAML
+
+A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. In the case of the COCO8-Seg dataset, the `coco8-seg.yaml` file is maintained at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-seg.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-seg.yaml).
+
+!!! example "ultralytics/cfg/datasets/coco8-seg.yaml"
+
+ ```yaml
+ --8<-- "ultralytics/cfg/datasets/coco8-seg.yaml"
+ ```
+
+## Usage
+
+To train a YOLOv8n-seg model on the COCO8-Seg dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
+
+!!! example "Train Example"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n-seg.pt') # load a pretrained model (recommended for training)
+
+ # Train the model
+ results = model.train(data='coco8-seg.yaml', epochs=100, imgsz=640)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Start training from a pretrained *.pt model
+ yolo detect train data=coco8-seg.yaml model=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+## Sample Images and Annotations
+
+Here are some examples of images from the COCO8-Seg dataset, along with their corresponding annotations:
+
+
+
+- **Mosaiced Image**: This image demonstrates a training batch composed of mosaiced dataset images. Mosaicing is a technique used during training that combines multiple images into a single image to increase the variety of objects and scenes within each training batch. This helps improve the model's ability to generalize to different object sizes, aspect ratios, and contexts.
+
+The example showcases the variety and complexity of the images in the COCO8-Seg dataset and the benefits of using mosaicing during the training process.
+
+## Citations and Acknowledgments
+
+If you use the COCO dataset in your research or development work, please cite the following paper:
+
+!!! note ""
+
+ === "BibTeX"
+
+ ```bibtex
+ @misc{lin2015microsoft,
+ title={Microsoft COCO: Common Objects in Context},
+ author={Tsung-Yi Lin and Michael Maire and Serge Belongie and Lubomir Bourdev and Ross Girshick and James Hays and Pietro Perona and Deva Ramanan and C. Lawrence Zitnick and Piotr Dollár},
+ year={2015},
+ eprint={1405.0312},
+ archivePrefix={arXiv},
+ primaryClass={cs.CV}
+ }
+ ```
+
+We would like to acknowledge the COCO Consortium for creating and maintaining this valuable resource for the computer vision community. For more information about the COCO dataset and its creators, visit the [COCO dataset website](https://cocodataset.org/#home).
diff --git a/ultralytics/docs/datasets/segment/index.md b/ultralytics/docs/datasets/segment/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb9497bdfd59f9118faa871331fa3cae185c8c7c
--- /dev/null
+++ b/ultralytics/docs/datasets/segment/index.md
@@ -0,0 +1,148 @@
+---
+comments: true
+description: Learn how Ultralytics YOLO supports various dataset formats for instance segmentation. This guide includes information on data conversions, auto-annotations, and dataset usage.
+keywords: Ultralytics, YOLO, Instance Segmentation, Dataset, YAML, COCO, Auto-Annotation, Image Segmentation
+---
+
+# Instance Segmentation Datasets Overview
+
+## Supported Dataset Formats
+
+### Ultralytics YOLO format
+
+The dataset label format used for training YOLO segmentation models is as follows:
+
+1. One text file per image: Each image in the dataset has a corresponding text file with the same name as the image file and the ".txt" extension.
+2. One row per object: Each row in the text file corresponds to one object instance in the image.
+3. Object information per row: Each row contains the following information about the object instance:
+ - Object class index: An integer representing the class of the object (e.g., 0 for person, 1 for car, etc.).
+ - Object bounding coordinates: The bounding coordinates around the mask area, normalized to be between 0 and 1.
+
+The format for a single row in the segmentation dataset file is as follows:
+
+```
+
+
+
+
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+
+ Watch: Raspberry Pi 5 updates and improvements.
+
+ 
+
| YOLOv8 without SAHI | +YOLOv8 with SAHI | +
|---|---|
 |
+  |
+
+
+
+
+ Watch: Getting Started with NVIDIA Triton Inference Server.
+
+ 
+
+ 
+
+
diff --git a/ultralytics/docs/help/CLA.md b/ultralytics/docs/help/CLA.md
new file mode 100644
index 0000000000000000000000000000000000000000..b33b4880f5b95b35c00705d3560da005cfcd0057
--- /dev/null
+++ b/ultralytics/docs/help/CLA.md
@@ -0,0 +1,31 @@
+---
+description: Understand terms governing contributions to Ultralytics projects including source code, bug fixes, documentation and more. Read our Contributor License Agreement.
+keywords: Ultralytics, Contributor License Agreement, Open Source Software, Contributions, Copyright License, Patent License, Moral Rights
+---
+
+# Ultralytics Individual Contributor License Agreement
+
+Thank you for your interest in contributing to open source software projects (“Projects”) made available by Ultralytics SE or its affiliates (“Ultralytics”). This Individual Contributor License Agreement (“Agreement”) sets out the terms governing any source code, object code, bug fixes, configuration changes, tools, specifications, documentation, data, materials, feedback, information or other works of authorship that you submit or have submitted, in any form and in any manner, to Ultralytics in respect of any of the Projects (collectively “Contributions”). If you have any questions respecting this Agreement, please contact hello@ultralytics.com.
+
+You agree that the following terms apply to all of your past, present and future Contributions. Except for the licenses granted in this Agreement, you retain all of your right, title and interest in and to your Contributions.
+
+**Copyright License.** You hereby grant, and agree to grant, to Ultralytics a non-exclusive, perpetual, irrevocable, worldwide, fully-paid, royalty-free, transferable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, and distribute your Contributions and such derivative works, with the right to sublicense the foregoing rights through multiple tiers of sublicensees.
+
+**Patent License.** You hereby grant, and agree to grant, to Ultralytics a non-exclusive, perpetual, irrevocable, worldwide, fully-paid, royalty-free, transferable patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer your Contributions, where such license applies only to those patent claims licensable by you that are necessarily infringed by your Contributions alone or by combination of your Contributions with the Project to which such Contributions were submitted, with the right to sublicense the foregoing rights through multiple tiers of sublicensees.
+
+**Moral Rights.** To the fullest extent permitted under applicable law, you hereby waive, and agree not to assert, all of your “moral rights” in or relating to your Contributions for the benefit of Ultralytics, its assigns, and their respective direct and indirect sublicensees.
+
+**Third Party Content/Rights.
+** If your Contribution includes or is based on any source code, object code, bug fixes, configuration changes, tools, specifications, documentation, data, materials, feedback, information or other works of authorship that were not authored by you (“Third Party Content”) or if you are aware of any third party intellectual property or proprietary rights associated with your Contribution (“Third Party Rights”), then you agree to include with the submission of your Contribution full details respecting such Third Party Content and Third Party Rights, including, without limitation, identification of which aspects of your Contribution contain Third Party Content or are associated with Third Party Rights, the owner/author of the Third Party Content and Third Party Rights, where you obtained the Third Party Content, and any applicable third party license terms or restrictions respecting the Third Party Content and Third Party Rights. For greater certainty, the foregoing obligations respecting the identification of Third Party Content and Third Party Rights do not apply to any portion of a Project that is incorporated into your Contribution to that same Project.
+
+**Representations.** You represent that, other than the Third Party Content and Third Party Rights identified by you in accordance with this Agreement, you are the sole author of your Contributions and are legally entitled to grant the foregoing licenses and waivers in respect of your Contributions. If your Contributions were created in the course of your employment with your past or present employer(s), you represent that such employer(s) has authorized you to make your Contributions on behalf of such employer(s) or such employer
+(s) has waived all of their right, title or interest in or to your Contributions.
+
+**Disclaimer.** To the fullest extent permitted under applicable law, your Contributions are provided on an "asis"
+basis, without any warranties or conditions, express or implied, including, without limitation, any implied warranties or conditions of non-infringement, merchantability or fitness for a particular purpose. You are not required to provide support for your Contributions, except to the extent you desire to provide support.
+
+**No Obligation.** You acknowledge that Ultralytics is under no obligation to use or incorporate your Contributions into any of the Projects. The decision to use or incorporate your Contributions into any of the Projects will be made at the sole discretion of Ultralytics or its authorized delegates ..
+
+**Disputes.** This Agreement shall be governed by and construed in accordance with the laws of the State of New York, United States of America, without giving effect to its principles or rules regarding conflicts of laws, other than such principles directing application of New York law. The parties hereby submit to venue in, and jurisdiction of the courts located in New York, New York for purposes relating to this Agreement. In the event that any of the provisions of this Agreement shall be held by a court or other tribunal of competent jurisdiction to be unenforceable, the remaining portions hereof shall remain in full force and effect.
+
+**Assignment.** You agree that Ultralytics may assign this Agreement, and all of its rights, obligations and licenses hereunder.
diff --git a/ultralytics/docs/help/FAQ.md b/ultralytics/docs/help/FAQ.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e4430a80aad054e7b658af5bb979d505598dfaa
--- /dev/null
+++ b/ultralytics/docs/help/FAQ.md
@@ -0,0 +1,39 @@
+---
+comments: true
+description: Find solutions to your common Ultralytics YOLO related queries. Learn about hardware requirements, fine-tuning YOLO models, conversion to ONNX/TensorFlow, and more.
+keywords: Ultralytics, YOLO, FAQ, hardware requirements, ONNX, TensorFlow, real-time detection, YOLO accuracy
+---
+
+# Ultralytics YOLO Frequently Asked Questions (FAQ)
+
+This FAQ section addresses some common questions and issues users might encounter while working with Ultralytics YOLO repositories.
+
+## 1. What are the hardware requirements for running Ultralytics YOLO?
+
+Ultralytics YOLO can be run on a variety of hardware configurations, including CPUs, GPUs, and even some edge devices. However, for optimal performance and faster training and inference, we recommend using a GPU with a minimum of 8GB of memory. NVIDIA GPUs with CUDA support are ideal for this purpose.
+
+## 2. How do I fine-tune a pre-trained YOLO model on my custom dataset?
+
+To fine-tune a pre-trained YOLO model on your custom dataset, you'll need to create a dataset configuration file (YAML) that defines the dataset's properties, such as the path to the images, the number of classes, and class names. Next, you'll need to modify the model configuration file to match the number of classes in your dataset. Finally, use the `train.py` script to start the training process with your custom dataset and the pre-trained model. You can find a detailed guide on fine-tuning YOLO in the Ultralytics documentation.
+
+## 3. How do I convert a YOLO model to ONNX or TensorFlow format?
+
+Ultralytics provides built-in support for converting YOLO models to ONNX format. You can use the `export.py` script to convert a saved model to ONNX format. If you need to convert the model to TensorFlow format, you can use the ONNX model as an intermediary and then use the ONNX-TensorFlow converter to convert the ONNX model to TensorFlow format.
+
+## 4. Can I use Ultralytics YOLO for real-time object detection?
+
+Yes, Ultralytics YOLO is designed to be efficient and fast, making it suitable for real-time object detection tasks. The actual performance will depend on your hardware configuration and the complexity of the model. Using a GPU and optimizing the model for your specific use case can help achieve real-time performance.
+
+## 5. How can I improve the accuracy of my YOLO model?
+
+Improving the accuracy of a YOLO model may involve several strategies, such as:
+
+- Fine-tuning the model on more annotated data
+- Data augmentation to increase the variety of training samples
+- Using a larger or more complex model architecture
+- Adjusting the learning rate, batch size, and other hyperparameters
+- Using techniques like transfer learning or knowledge distillation
+
+Remember that there's often a trade-off between accuracy and inference speed, so finding the right balance is crucial for your specific application.
+
+If you have any more questions or need assistance, don't hesitate to consult the Ultralytics documentation or reach out to the community through GitHub Issues or the official discussion forum.
diff --git a/ultralytics/docs/help/code_of_conduct.md b/ultralytics/docs/help/code_of_conduct.md
new file mode 100644
index 0000000000000000000000000000000000000000..c8c7cdc66ed90843164fbf40c3dfc63007feabd4
--- /dev/null
+++ b/ultralytics/docs/help/code_of_conduct.md
@@ -0,0 +1,88 @@
+---
+comments: true
+description: Explore Ultralytics community’s Code of Conduct, ensuring a supportive, inclusive environment for contributors & members at all levels. Find our guidelines on acceptable behavior & enforcement.
+keywords: Ultralytics, code of conduct, community, contribution, behavior guidelines, enforcement, open source contributions
+---
+
+# Ultralytics Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email address, without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at hello@ultralytics.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.
+
+[homepage]: https://www.contributor-covenant.org
diff --git a/ultralytics/docs/help/contributing.md b/ultralytics/docs/help/contributing.md
new file mode 100644
index 0000000000000000000000000000000000000000..b798e9c2010baac98df7111eeff87acc34c82d5b
--- /dev/null
+++ b/ultralytics/docs/help/contributing.md
@@ -0,0 +1,76 @@
+---
+comments: true
+description: Learn how to contribute to Ultralytics YOLO projects – guidelines for pull requests, reporting bugs, code conduct and CLA signing.
+keywords: Ultralytics, YOLO, open-source, contribute, pull request, bug report, coding guidelines, CLA, code of conduct, GitHub
+---
+
+# Contributing to Ultralytics Open-Source YOLO Repositories
+
+First of all, thank you for your interest in contributing to Ultralytics open-source YOLO repositories! Your contributions will help improve the project and benefit the community. This document provides guidelines and best practices to get you started.
+
+## Table of Contents
+
+- [Code of Conduct](#code-of-conduct)
+- [Pull Requests](#pull-requests)
+ - [CLA Signing](#cla-signing)
+ - [Google-Style Docstrings](#google-style-docstrings)
+ - [GitHub Actions CI Tests](#github-actions-ci-tests)
+- [Bug Reports](#bug-reports)
+ - [Minimum Reproducible Example](#minimum-reproducible-example)
+- [License and Copyright](#license-and-copyright)
+
+## Code of Conduct
+
+All contributors are expected to adhere to the [Code of Conduct](code_of_conduct.md) to ensure a welcoming and inclusive environment for everyone.
+
+## Pull Requests
+
+We welcome contributions in the form of pull requests. To make the review process smoother, please follow these guidelines:
+
+1. **Fork the repository**: Fork the Ultralytics YOLO repository to your own GitHub account.
+
+2. **Create a branch**: Create a new branch in your forked repository with a descriptive name for your changes.
+
+3. **Make your changes**: Make the changes you want to contribute. Ensure that your changes follow the coding style of the project and do not introduce new errors or warnings.
+
+4. **Test your changes**: Test your changes locally to ensure that they work as expected and do not introduce new issues.
+
+5. **Commit your changes**: Commit your changes with a descriptive commit message. Make sure to include any relevant issue numbers in your commit message.
+
+6. **Create a pull request**: Create a pull request from your forked repository to the main Ultralytics YOLO repository. In the pull request description, provide a clear explanation of your changes and how they improve the project.
+
+### CLA Signing
+
+Before we can accept your pull request, you need to sign a [Contributor License Agreement (CLA)](CLA.md). This is a legal document stating that you agree to the terms of contributing to the Ultralytics YOLO repositories. The CLA ensures that your contributions are properly licensed and that the project can continue to be distributed under the AGPL-3.0 license.
+
+To sign the CLA, follow the instructions provided by the CLA bot after you submit your PR.
+
+### Google-Style Docstrings
+
+When adding new functions or classes, please include a [Google-style docstring](https://google.github.io/styleguide/pyguide.html) to provide clear and concise documentation for other developers. This will help ensure that your contributions are easy to understand and maintain.
+
+Example Google-style docstring:
+
+```python
+def example_function(arg1: int, arg2: int) -> bool:
+ """
+ Example function that demonstrates Google-style docstrings.
+
+ Args:
+ arg1 (int): The first argument.
+ arg2 (int): The second argument.
+
+ Returns:
+ (bool): True if successful, False otherwise.
+
+ Examples:
+ >>> result = example_function(1, 2) # returns False
+ """
+ if arg1 == arg2:
+ return True
+ return False
+```
+
+### GitHub Actions CI Tests
+
+Before your pull request can be merged, all GitHub Actions Continuous Integration (CI) tests must pass. These tests include linting, unit tests, and other checks to ensure that your changes meet the quality standards of the project. Make sure to review the output of the GitHub Actions and fix any issues
diff --git a/ultralytics/docs/help/environmental-health-safety.md b/ultralytics/docs/help/environmental-health-safety.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fee240b48f94a00e3af36f96bd8f1ef4a92214e
--- /dev/null
+++ b/ultralytics/docs/help/environmental-health-safety.md
@@ -0,0 +1,37 @@
+---
+comments: false
+description: Discover Ultralytics’ EHS policy principles and implementation measures. Committed to safety, environment, and continuous improvement for a sustainable future.
+keywords: Ultralytics policy, EHS, environment, health and safety, compliance, prevention, continuous improvement, risk management, emergency preparedness, resource allocation, communication
+---
+
+# Ultralytics Environmental, Health and Safety (EHS) Policy
+
+At Ultralytics, we recognize that the long-term success of our company relies not only on the products and services we offer, but also the manner in which we conduct our business. We are committed to ensuring the safety and well-being of our employees, stakeholders, and the environment, and we will continuously strive to mitigate our impact on the environment while promoting health and safety.
+
+## Policy Principles
+
+1. **Compliance**: We will comply with all applicable laws, regulations, and standards related to EHS, and we will strive to exceed these standards where possible.
+
+2. **Prevention**: We will work to prevent accidents, injuries, and environmental harm by implementing risk management measures and ensuring all our operations and procedures are safe.
+
+3. **Continuous Improvement**: We will continuously improve our EHS performance by setting measurable objectives, monitoring our performance, auditing our operations, and revising our policies and procedures as needed.
+
+4. **Communication**: We will communicate openly about our EHS performance and will engage with stakeholders to understand and address their concerns and expectations.
+
+5. **Education and Training**: We will educate and train our employees and contractors in appropriate EHS procedures and practices.
+
+## Implementation Measures
+
+1. **Responsibility and Accountability**: Every employee and contractor working at or with Ultralytics is responsible for adhering to this policy. Managers and supervisors are accountable for ensuring this policy is implemented within their areas of control.
+
+2. **Risk Management**: We will identify, assess, and manage EHS risks associated with our operations and activities to prevent accidents, injuries, and environmental harm.
+
+3. **Resource Allocation**: We will allocate the necessary resources to ensure the effective implementation of our EHS policy, including the necessary equipment, personnel, and training.
+
+4. **Emergency Preparedness and Response**: We will develop, maintain, and test emergency preparedness and response plans to ensure we can respond effectively to EHS incidents.
+
+5. **Monitoring and Review**: We will monitor and review our EHS performance regularly to identify opportunities for improvement and ensure we are meeting our objectives.
+
+This policy reflects our commitment to minimizing our environmental footprint, ensuring the safety and well-being of our employees, and continuously improving our performance.
+
+Please remember that the implementation of an effective EHS policy requires the involvement and commitment of everyone working at or with Ultralytics. We encourage you to take personal responsibility for your safety and the safety of others, and to take care of the environment in which we live and work.
diff --git a/ultralytics/docs/help/index.md b/ultralytics/docs/help/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..a64b60cccc333bf0236bddc77897e258b41ed42b
--- /dev/null
+++ b/ultralytics/docs/help/index.md
@@ -0,0 +1,19 @@
+---
+comments: true
+description: Find comprehensive guides and documents on Ultralytics YOLO tasks. Includes FAQs, contributing guides, CI guide, CLA, MRE guide, code of conduct & more.
+keywords: Ultralytics, YOLO, guides, documents, FAQ, contributing, CI guide, CLA, MRE guide, code of conduct, EHS policy, security policy, privacy policy
+---
+
+Welcome to the Ultralytics Help page! We are dedicated to providing you with detailed resources to enhance your experience with the Ultralytics YOLO models and repositories. This page serves as your portal to guides and documentation designed to assist you with various tasks and answer questions you may encounter while engaging with our repositories.
+
+- [Frequently Asked Questions (FAQ)](FAQ.md): Find answers to common questions and issues encountered by the community of Ultralytics YOLO users and contributors.
+- [Contributing Guide](contributing.md): Discover the protocols for making contributions, including how to submit pull requests, report bugs, and more.
+- [Continuous Integration (CI) Guide](CI.md): Gain insights into the CI processes we employ, complete with status reports for each Ultralytics repository.
+- [Contributor License Agreement (CLA)](CLA.md): Review the CLA to understand the rights and responsibilities associated with contributing to Ultralytics projects.
+- [Minimum Reproducible Example (MRE) Guide](minimum_reproducible_example.md): Learn the process for creating an MRE, which is crucial for the timely and effective resolution of bug reports.
+- [Code of Conduct](code_of_conduct.md): Our community guidelines support a respectful and open atmosphere for all collaborators.
+- [Environmental, Health and Safety (EHS) Policy](environmental-health-safety.md): Delve into our commitment to sustainability and the well-being of all our stakeholders.
+- [Security Policy](../SECURITY.md): Familiarize yourself with our security protocols and the procedure for reporting vulnerabilities.
+- [Privacy Policy](privacy.md): Read our privacy policy to understand how we protect your data and respect your privacy in all our services and operations.
+
+We encourage you to review these resources for a seamless and productive experience. Our aim is to foster a helpful and friendly environment for everyone in the Ultralytics community. Should you require additional support, please feel free to reach out via GitHub Issues or our official discussion forums. Happy coding!
diff --git a/ultralytics/docs/help/minimum_reproducible_example.md b/ultralytics/docs/help/minimum_reproducible_example.md
new file mode 100644
index 0000000000000000000000000000000000000000..47a0cdf0e736070a274fdc7b9899d5f3ea8c4cdd
--- /dev/null
+++ b/ultralytics/docs/help/minimum_reproducible_example.md
@@ -0,0 +1,78 @@
+---
+comments: true
+description: Learn how to create minimum reproducible examples (MRE) for efficient bug reporting in Ultralytics YOLO repositories with this step-by-step guide.
+keywords: Ultralytics, YOLO, minimum reproducible example, MRE, bug reports, guide, dependencies, code, troubleshooting
+---
+
+# Creating a Minimum Reproducible Example for Bug Reports in Ultralytics YOLO Repositories
+
+When submitting a bug report for Ultralytics YOLO repositories, it's essential to provide a [minimum reproducible example](https://docs.ultralytics.com/help/minimum_reproducible_example/) (MRE). An MRE is a small, self-contained piece of code that demonstrates the problem you're experiencing. Providing an MRE helps maintainers and contributors understand the issue and work on a fix more efficiently. This guide explains how to create an MRE when submitting bug reports to Ultralytics YOLO repositories.
+
+## 1. Isolate the Problem
+
+The first step in creating an MRE is to isolate the problem. This means removing any unnecessary code or dependencies that are not directly related to the issue. Focus on the specific part of the code that is causing the problem and remove any irrelevant code.
+
+## 2. Use Public Models and Datasets
+
+When creating an MRE, use publicly available models and datasets to reproduce the issue. For example, use the 'yolov8n.pt' model and the 'coco8.yaml' dataset. This ensures that the maintainers and contributors can easily run your example and investigate the problem without needing access to proprietary data or custom models.
+
+## 3. Include All Necessary Dependencies
+
+Make sure to include all the necessary dependencies in your MRE. If your code relies on external libraries, specify the required packages and their versions. Ideally, provide a `requirements.txt` file or list the dependencies in your bug report.
+
+## 4. Write a Clear Description of the Issue
+
+Provide a clear and concise description of the issue you're experiencing. Explain the expected behavior and the actual behavior you're encountering. If applicable, include any relevant error messages or logs.
+
+## 5. Format Your Code Properly
+
+When submitting an MRE, format your code properly using code blocks in the issue description. This makes it easier for others to read and understand your code. In GitHub, you can create a code block by wrapping your code with triple backticks (\```) and specifying the language:
+
++```python +# Your Python code goes here +``` ++ +## 6. Test Your MRE + +Before submitting your MRE, test it to ensure that it accurately reproduces the issue. Make sure that others can run your example without any issues or modifications. + +## Example of an MRE + +Here's an example of an MRE for a hypothetical bug report: + +**Bug description:** + +When running the `detect.py` script on the sample image from the 'coco8.yaml' dataset, I get an error related to the dimensions of the input tensor. + +**MRE:** + +```python +import torch +from ultralytics import YOLO + +# Load the model +model = YOLO("yolov8n.pt") + +# Load a 0-channel image +image = torch.rand(1, 0, 640, 640) + +# Run the model +results = model(image) +``` + +**Error message:** + +``` +RuntimeError: Expected input[1, 0, 640, 640] to have 3 channels, but got 0 channels instead +``` + +**Dependencies:** + +- torch==2.0.0 +- ultralytics==8.0.90 + +In this example, the MRE demonstrates the issue with a minimal amount of code, uses a public model ('yolov8n.pt'), includes all necessary dependencies, and provides a clear description of the problem along with the error message. + +By following these guidelines, you'll help the maintainers and contributors of Ultralytics YOLO repositories to understand and resolve your issue more efficiently. diff --git a/ultralytics/docs/help/privacy.md b/ultralytics/docs/help/privacy.md new file mode 100644 index 0000000000000000000000000000000000000000..dfd8137ef562ca0a6f5422854b77950dfde425b2 --- /dev/null +++ b/ultralytics/docs/help/privacy.md @@ -0,0 +1,137 @@ +--- +description: Learn about how Ultralytics collects and uses data to improve user experience, ensure software stability, and address privacy concerns, with options to opt-out. +keywords: Ultralytics, Data Collection, User Privacy, Google Analytics, Sentry, Crash Reporting, Anonymized Data, Privacy Settings, Opt-Out +--- + +# Data Collection for Ultralytics Python Package + +## Overview + +[Ultralytics](https://ultralytics.com) is dedicated to the continuous enhancement of the user experience and the capabilities of our Python package, including the advanced YOLO models we develop. Our approach involves the gathering of anonymized usage statistics and crash reports, helping us identify opportunities for improvement and ensuring the reliability of our software. This transparency document outlines what data we collect, its purpose, and the choice you have regarding this data collection. + +## Anonymized Google Analytics + +[Google Analytics](https://developers.google.com/analytics) is a web analytics service offered by Google that tracks and reports website traffic. It allows us to collect data about how our Python package is used, which is crucial for making informed decisions about design and functionality. + +### What We Collect + +- **Usage Metrics**: These metrics help us understand how frequently and in what ways the package is utilized, what features are favored, and the typical command-line arguments that are used. +- **System Information**: We collect general non-identifiable information about your computing environment to ensure our package performs well across various systems. +- **Performance Data**: Understanding the performance of our models during training, validation, and inference helps us in identifying optimization opportunities. + +For more information about Google Analytics and data privacy, visit [Google Analytics Privacy](https://support.google.com/analytics/answer/6004245). + +### How We Use This Data + +- **Feature Improvement**: Insights from usage metrics guide us in enhancing user satisfaction and interface design. +- **Optimization**: Performance data assist us in fine-tuning our models for better efficiency and speed across diverse hardware and software configurations. +- **Trend Analysis**: By studying usage trends, we can predict and respond to the evolving needs of our community. + +### Privacy Considerations + +We take several measures to ensure the privacy and security of the data you entrust to us: + +- **Anonymization**: We configure Google Analytics to anonymize the data collected, which means no personally identifiable information (PII) is gathered. You can use our services with the assurance that your personal details remain private. +- **Aggregation**: Data is analyzed only in aggregate form. This practice ensures that patterns can be observed without revealing any individual user's activity. +- **No Image Data Collection**: Ultralytics does not collect, process, or view any training or inference images. + +## Sentry Crash Reporting + +[Sentry](https://sentry.io/) is a developer-centric error tracking software that aids in identifying, diagnosing, and resolving issues in real-time, ensuring the robustness and reliability of applications. Within our package, it plays a crucial role by providing insights through crash reporting, significantly contributing to the stability and ongoing refinement of our software. + +!!! note + + Crash reporting via Sentry is activated only if the `sentry-sdk` Python package is pre-installed on your system. This package isn't included in the `ultralytics` prerequisites and won't be installed automatically by Ultralytics. + +### What We Collect + +If the `sentry-sdk` Python package is pre-installed on your system a crash event may send the following information: + +- **Crash Logs**: Detailed reports on the application's condition at the time of a crash, which are vital for our debugging efforts. +- **Error Messages**: We record error messages generated during the operation of our package to understand and resolve potential issues quickly. + +To learn more about how Sentry handles data, please visit [Sentry's Privacy Policy](https://sentry.io/privacy/). + +### How We Use This Data + +- **Debugging**: Analyzing crash logs and error messages enables us to swiftly identify and correct software bugs. +- **Stability Metrics**: By constantly monitoring for crashes, we aim to improve the stability and reliability of our package. + +### Privacy Considerations + +- **Sensitive Information**: We ensure that crash logs are scrubbed of any personally identifiable or sensitive user data, safeguarding the confidentiality of your information. +- **Controlled Collection**: Our crash reporting mechanism is meticulously calibrated to gather only what is essential for troubleshooting while respecting user privacy. + +By detailing the tools used for data collection and offering additional background information with URLs to their respective privacy pages, users are provided with a comprehensive view of our practices, emphasizing transparency and respect for user privacy. + +## Disabling Data Collection + +We believe in providing our users with full control over their data. By default, our package is configured to collect analytics and crash reports to help improve the experience for all users. However, we respect that some users may prefer to opt out of this data collection. + +To opt out of sending analytics and crash reports, you can simply set `sync=False` in your YOLO settings. This ensures that no data is transmitted from your machine to our analytics tools. + +### Inspecting Settings + +To gain insight into the current configuration of your settings, you can view them directly: + +!!! example "View settings" + + === "Python" + You can use Python to view your settings. Start by importing the `settings` object from the `ultralytics` module. Print and return settings using the following commands: + ```python + from ultralytics import settings + + # View all settings + print(settings) + + # Return analytics and crash reporting setting + value = settings['sync'] + ``` + + === "CLI" + Alternatively, the command-line interface allows you to check your settings with a simple command: + ```bash + yolo settings + ``` + +### Modifying Settings + +Ultralytics allows users to easily modify their settings. Changes can be performed in the following ways: + +!!! example "Update settings" + + === "Python" + Within the Python environment, call the `update` method on the `settings` object to change your settings: + ```python + from ultralytics import settings + + # Disable analytics and crash reporting + settings.update({'sync': False}) + + # Reset settings to default values + settings.reset() + ``` + + === "CLI" + If you prefer using the command-line interface, the following commands will allow you to modify your settings: + ```bash + # Disable analytics and crash reporting + yolo settings sync=False + + # Reset settings to default values + yolo settings reset + ``` + +The `sync=False` setting will prevent any data from being sent to Google Analytics or Sentry. Your settings will be respected across all sessions using the Ultralytics package and saved to disk for future sessions. + +## Commitment to Privacy + +Ultralytics takes user privacy seriously. We design our data collection practices with the following principles: + +- **Transparency**: We are open about the data we collect and how it is used. +- **Control**: We give users full control over their data. +- **Security**: We employ industry-standard security measures to protect the data we collect. + +## Questions or Concerns + +If you have any questions or concerns about our data collection practices, please reach out to us via our [contact form](https://ultralytics.com/contact) or via [support@ultralytics.com](mailto:support@ultralytics.com). We are dedicated to ensuring our users feel informed and confident in their privacy when using our package. diff --git a/ultralytics/docs/hub/app/android.md b/ultralytics/docs/hub/app/android.md new file mode 100644 index 0000000000000000000000000000000000000000..e6acfaf5beb11cd77ca69ed80e61ac97eb2e6ef0 --- /dev/null +++ b/ultralytics/docs/hub/app/android.md @@ -0,0 +1,89 @@ +--- +comments: true +description: Learn about the Ultralytics Android App, enabling real-time object detection using YOLO models. Discover in-app features, quantization methods, and delegate options for optimal performance. +keywords: Ultralytics, Android App, real-time object detection, YOLO models, TensorFlow Lite, FP16 quantization, INT8 quantization, CPU, GPU, Hexagon, NNAPI +--- + +# Ultralytics Android App: Real-time Object Detection with YOLO Models + + +
+
+
+
+ 
+
+
+
+
+
+ Watch: Train Your Custom YOLO Models In A Few Clicks with Ultralytics HUB.
+
+
+
+
+ Watch: Train Your Custom YOLO Models In A Few Clicks with Ultralytics HUB.
+
+
+
+When the training starts, you can click **Done** and monitor the training progress on the Model page.
+
+
+
+
+
+??? note "Note"
+
+ In case the training stops and a checkpoint was saved, you can resume training your model from the Model page.
+
+ 
+
+## Preview Model
+
+Ultralytics HUB offers a variety of ways to preview your trained model.
+
+You can preview your model if you click on the **Preview** tab and upload an image in the **Test** card.
+
+
+
+You can also use our Ultralytics Cloud API to effortlessly [run inference](https://docs.ultralytics.com/hub/inference_api) with your custom model.
+
+
+
+Furthermore, you can preview your model in real-time directly on your [iOS](https://apps.apple.com/xk/app/ultralytics/id1583935240) or [Android](https://play.google.com/store/apps/details?id=com.ultralytics.ultralytics_app) mobile device by [downloading](https://ultralytics.com/app_install) our [Ultralytics HUB Mobile Application](./app/index.md).
+
+
+
+## Deploy Model
+
+You can export your model to 13 different formats, including ONNX, OpenVINO, CoreML, TensorFlow, Paddle and many others.
+
+
+
+??? tip "Tip"
+
+ You can customize the export options of each format if you open the export actions dropdown and click on the **Advanced** option.
+
+ 
+
+## Share Model
+
+!!! info "Info"
+
+ Ultralytics HUB's sharing functionality provides a convenient way to share models with others. This feature is designed to accommodate both existing Ultralytics HUB users and those who have yet to create an account.
+
+??? note "Note"
+
+ You have control over the general access of your models.
+
+ You can choose to set the general access to "Private", in which case, only you will have access to it. Alternatively, you can set the general access to "Unlisted" which grants viewing access to anyone who has the direct link to the model, regardless of whether they have an Ultralytics HUB account or not.
+
+Navigate to the Model page of the model you want to share, open the model actions dropdown and click on the **Share** option. This action will trigger the **Share Model** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also share a model directly from the [Models](https://hub.ultralytics.com/models) page or from the Project page of the project where your model is located.
+
+ 
+
+Set the general access to "Unlisted" and click **Save**.
+
+
+
+Now, anyone who has the direct link to your model can view it.
+
+??? tip "Tip"
+
+ You can easily click on the model's link shown in the **Share Model** dialog to copy it.
+
+ 
+
+## Edit Model
+
+Navigate to the Model page of the model you want to edit, open the model actions dropdown and click on the **Edit** option. This action will trigger the **Update Model** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also edit a model directly from the [Models](https://hub.ultralytics.com/models) page or from the Project page of the project where your model is located.
+
+ 
+
+Apply the desired modifications to your model and then confirm the changes by clicking **Save**.
+
+
+
+## Delete Model
+
+Navigate to the Model page of the model you want to delete, open the model actions dropdown and click on the **Delete** option. This action will delete the model.
+
+
+
+??? tip "Tip"
+
+ You can also delete a model directly from the [Models](https://hub.ultralytics.com/models) page or from the Project page of the project where your model is located.
+
+ 
+
+??? note "Note"
+
+ If you change your mind, you can restore the model from the [Trash](https://hub.ultralytics.com/trash) page.
+
+ 
diff --git a/ultralytics/docs/hub/projects.md b/ultralytics/docs/hub/projects.md
new file mode 100644
index 0000000000000000000000000000000000000000..b11aee62b147774dd01950bd85c5df179b67e002
--- /dev/null
+++ b/ultralytics/docs/hub/projects.md
@@ -0,0 +1,169 @@
+---
+comments: true
+description: Learn how to manage Ultralytics HUB projects. Understand effective strategies to create, share, edit, delete, and compare models in an organized workspace.
+keywords: Ultralytics, HUB projects, Create project, Edit project, Share project, Delete project, Compare Models, Model Management
+---
+
+# Ultralytics HUB Projects
+
+[Ultralytics HUB](https://hub.ultralytics.com/) projects provide an effective solution for consolidating and managing your models. If you are working with several models that perform similar tasks or have related purposes, Ultralytics HUB projects allow you to group these models together.
+
+This creates a unified and organized workspace that facilitates easier model management, comparison and development. Having similar models or various iterations together can facilitate rapid benchmarking, as you can compare their effectiveness. This can lead to faster, more insightful iterative development and refinement of your models.
+
+## Create Project
+
+Navigate to the [Projects](https://hub.ultralytics.com/projects) page by clicking on the **Projects** button in the sidebar.
+
+
+
+??? tip "Tip"
+
+ You can also create a project directly from the [Home](https://hub.ultralytics.com/home) page.
+
+ 
+
+Click on the **Create Project** button on the top right of the page. This action will trigger the **Create Project** dialog, opening up a suite of options for tailoring your project to your needs.
+
+
+
+Type the name of your project in the _Project name_ field or keep the default name and finalize the project creation with a single click.
+
+You have the additional option to enrich your project with a description and a unique image, enhancing its recognizability on the Projects page.
+
+When you're happy with your project configuration, click **Create**.
+
+
+
+After your project is created, you will be able to access it from the Projects page.
+
+
+
+Next, [train a model](https://docs.ultralytics.com/hub/models/#train-model) inside your project.
+
+
+
+## Share Project
+
+!!! info "Info"
+
+ Ultralytics HUB's sharing functionality provides a convenient way to share projects with others. This feature is designed to accommodate both existing Ultralytics HUB users and those who have yet to create an account.
+
+??? note "Note"
+
+ You have control over the general access of your projects.
+
+ You can choose to set the general access to "Private", in which case, only you will have access to it. Alternatively, you can set the general access to "Unlisted" which grants viewing access to anyone who has the direct link to the project, regardless of whether they have an Ultralytics HUB account or not.
+
+Navigate to the Project page of the project you want to share, open the project actions dropdown and click on the **Share** option. This action will trigger the **Share Project** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also share a project directly from the [Projects](https://hub.ultralytics.com/projects) page.
+
+ 
+
+Set the general access to "Unlisted" and click **Save**.
+
+
+
+!!! warning "Warning"
+
+ When changing the general access of a project, the general access of the models inside the project will be changed as well.
+
+Now, anyone who has the direct link to your project can view it.
+
+??? tip "Tip"
+
+ You can easily click on the project's link shown in the **Share Project** dialog to copy it.
+
+ 
+
+## Edit Project
+
+Navigate to the Project page of the project you want to edit, open the project actions dropdown and click on the **Edit** option. This action will trigger the **Update Project** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also edit a project directly from the [Projects](https://hub.ultralytics.com/projects) page.
+
+ 
+
+Apply the desired modifications to your project and then confirm the changes by clicking **Save**.
+
+
+
+## Delete Project
+
+Navigate to the Project page of the project you want to delete, open the project actions dropdown and click on the **Delete** option. This action will delete the project.
+
+
+
+??? tip "Tip"
+
+ You can also delete a project directly from the [Projects](https://hub.ultralytics.com/projects) page.
+
+ 
+
+!!! warning "Warning"
+
+ When deleting a project, the models inside the project will be deleted as well.
+
+??? note "Note"
+
+ If you change your mind, you can restore the project from the [Trash](https://hub.ultralytics.com/trash) page.
+
+ 
+
+## Compare Models
+
+Navigate to the Project page of the project where the models you want to compare are located. To use the model comparison feature, click on the **Charts** tab.
+
+
+
+This will display all the relevant charts. Each chart corresponds to a different metric and contains the performance of each model for that metric. The models are represented by different colors and you can hover over each data point to get more information.
+
+
+
+??? tip "Tip"
+
+ Each chart can be enlarged for better visualization.
+
+ 
+
+ 
+
+??? tip "Tip"
+
+ You have the flexibility to customize your view by selectively hiding certain models. This feature allows you to concentrate on the models of interest.
+
+ 
+
+## Reorder Models
+
+??? note "Note"
+
+ Ultralytics HUB's reordering functionality works only inside projects you own.
+
+Navigate to the Project page of the project where the models you want to reorder are located. Click on the designated reorder icon of the model you want to move and drag it to the desired location.
+
+
+
+## Transfer Models
+
+Navigate to the Project page of the project where the model you want to mode is located, open the project actions dropdown and click on the **Transfer** option. This action will trigger the **Transfer Model** dialog.
+
+
+
+??? tip "Tip"
+
+ You can also transfer a model directly from the [Models](https://hub.ultralytics.com/models) page.
+
+ 
+
+Select the project you want to transfer the model to and click **Save**.
+
+
diff --git a/ultralytics/docs/hub/quickstart.md b/ultralytics/docs/hub/quickstart.md
new file mode 100644
index 0000000000000000000000000000000000000000..3728dc4bdafaf7bb8203843f00467cc69aebb5ef
--- /dev/null
+++ b/ultralytics/docs/hub/quickstart.md
@@ -0,0 +1,52 @@
+---
+comments: true
+description: Kickstart your journey with Ultralytics HUB. Learn how to train and deploy YOLOv5 and YOLOv8 models in seconds with our Quickstart guide.
+keywords: Ultralytics HUB, Quickstart, YOLOv5, YOLOv8, model training, quick deployment, drag-and-drop interface, real-time object detection
+---
+
+# Quickstart Guide for Ultralytics HUB
+
+🚧 **Under Construction** 🚧
+
+Thank you for visiting the Quickstart guide for [Ultralytics HUB](https://hub.ultralytics.com/)! We're currently hard at work building out this page to provide you with step-by-step instructions on how to get up and running with HUB in no time.
+
+
+
+
+
+ Watch: Train Your Custom YOLO Models In A Few Clicks with Ultralytics HUB.
+
+
+
+
+ Watch: How to Train a YOLOv8 model on Your Custom Dataset in Google Colab.
+
+
+## Datasets Integrations
+
+- [Roboflow](roboflow.md): Facilitate seamless dataset management for Ultralytics models, offering robust annotation, preprocessing, and augmentation capabilities.
+
+## Training Integrations
+
+- [Comet ML](https://www.comet.ml/): Enhance your model development with Ultralytics by tracking, comparing, and optimizing your machine learning experiments.
+
+- [ClearML](https://clear.ml/): Automate your Ultralytics ML workflows, monitor experiments, and foster team collaboration.
+
+- [DVC](https://dvc.org/): Implement version control for your Ultralytics machine learning projects, synchronizing data, code, and models effectively.
+
+- [Ultralytics HUB](https://hub.ultralytics.com): Access and contribute to a community of pre-trained Ultralytics models.
+
+- [MLFlow](mlflow.md): Streamline the entire ML lifecycle of Ultralytics models, from experimentation and reproducibility to deployment.
+
+- [Neptune](https://neptune.ai/): Maintain a comprehensive log of your ML experiments with Ultralytics in this metadata store designed for MLOps.
+
+- [Ray Tune](ray-tune.md): Optimize the hyperparameters of your Ultralytics models at any scale.
+
+- [TensorBoard](https://tensorboard.dev/): Visualize your Ultralytics ML workflows, monitor model metrics, and foster team collaboration.
+
+- [Weights & Biases (W&B)](https://wandb.ai/site): Monitor experiments, visualize metrics, and foster reproducibility and collaboration on Ultralytics projects.
+
+## Deployment Integrations
+
+- [Neural Magic](https://neuralmagic.com/): Leverage Quantization Aware Training (QAT) and pruning techniques to optimize Ultralytics models for superior performance and leaner size.
+
+### Export Formats
+
+We also support a variety of model export formats for deployment in different environments. Here are the available formats:
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|---------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](openvino.md) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
+| [NCNN](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
+
+Explore the links to learn more about each integration and how to get the most out of them with Ultralytics.
+
+## Contribute to Our Integrations
+
+We're always excited to see how the community integrates Ultralytics YOLO with other technologies, tools, and platforms! If you have successfully integrated YOLO with a new system or have valuable insights to share, consider contributing to our Integrations Docs.
+
+By writing a guide or tutorial, you can help expand our documentation and provide real-world examples that benefit the community. It's an excellent way to contribute to the growing ecosystem around Ultralytics YOLO.
+
+To contribute, please check out our [Contributing Guide](https://docs.ultralytics.com/help/contributing) for instructions on how to submit a Pull Request (PR) 🛠️. We eagerly await your contributions!
+
+Let's collaborate to make the Ultralytics YOLO ecosystem more expansive and feature-rich 🙏!
diff --git a/ultralytics/docs/integrations/mlflow.md b/ultralytics/docs/integrations/mlflow.md
new file mode 100644
index 0000000000000000000000000000000000000000..4da3ce1d4c7352dd8566730b2220104f9e9afc38
--- /dev/null
+++ b/ultralytics/docs/integrations/mlflow.md
@@ -0,0 +1,112 @@
+---
+comments: true
+description: Uncover the utility of MLflow for effective experiment logging in your Ultralytics YOLO projects.
+keywords: ultralytics docs, YOLO, MLflow, experiment logging, metrics tracking, parameter logging, artifact logging
+---
+
+# MLflow Integration for Ultralytics YOLO
+
+
+
+## Introduction
+
+Experiment logging is a crucial aspect of machine learning workflows that enables tracking of various metrics, parameters, and artifacts. It helps to enhance model reproducibility, debug issues, and improve model performance. [Ultralytics](https://ultralytics.com) YOLO, known for its real-time object detection capabilities, now offers integration with [MLflow](https://mlflow.org/), an open-source platform for complete machine learning lifecycle management.
+
+This documentation page is a comprehensive guide to setting up and utilizing the MLflow logging capabilities for your Ultralytics YOLO project.
+
+## What is MLflow?
+
+[MLflow](https://mlflow.org/) is an open-source platform developed by [Databricks](https://www.databricks.com/) for managing the end-to-end machine learning lifecycle. It includes tools for tracking experiments, packaging code into reproducible runs, and sharing and deploying models. MLflow is designed to work with any machine learning library and programming language.
+
+## Features
+
+- **Metrics Logging**: Logs metrics at the end of each epoch and at the end of the training.
+- **Parameter Logging**: Logs all the parameters used in the training.
+- **Artifacts Logging**: Logs model artifacts, including weights and configuration files, at the end of the training.
+
+## Setup and Prerequisites
+
+Ensure MLflow is installed. If not, install it using pip:
+
+```bash
+pip install mlflow
+```
+
+Make sure that MLflow logging is enabled in Ultralytics settings. Usually, this is controlled by the settings `mflow` key. See the [settings](https://docs.ultralytics.com/quickstart/#ultralytics-settings) page for more info.
+
+!!! example "Update Ultralytics MLflow Settings"
+
+ === "Python"
+ Within the Python environment, call the `update` method on the `settings` object to change your settings:
+ ```python
+ from ultralytics import settings
+
+ # Update a setting
+ settings.update({'mlflow': True})
+
+ # Reset settings to default values
+ settings.reset()
+ ```
+
+ === "CLI"
+ If you prefer using the command-line interface, the following commands will allow you to modify your settings:
+ ```bash
+ # Update a setting
+ yolo settings runs_dir='/path/to/runs'
+
+ # Reset settings to default values
+ yolo settings reset
+ ```
+
+## How to Use
+
+### Commands
+
+1. **Set a Project Name**: You can set the project name via an environment variable:
+ ```bash
+ export MLFLOW_EXPERIMENT_NAME=
+
+3. **View Run**: Runs are individual models inside an experiment. Click on a Run and see the Run details, including uploaded artifacts and model weights.
+ 
+
+## Disabling MLflow
+
+To turn off MLflow logging:
+
+```bash
+yolo settings mlflow=False
+```
+
+## Conclusion
+
+MLflow logging integration with Ultralytics YOLO offers a streamlined way to keep track of your machine learning experiments. It empowers you to monitor performance metrics and manage artifacts effectively, thus aiding in robust model development and deployment. For further details please visit the MLflow [official documentation](https://mlflow.org/docs/latest/index.html).
diff --git a/ultralytics/docs/integrations/openvino.md b/ultralytics/docs/integrations/openvino.md
new file mode 100644
index 0000000000000000000000000000000000000000..c54cd1898ba0865627c0d49b99e68b4657af37da
--- /dev/null
+++ b/ultralytics/docs/integrations/openvino.md
@@ -0,0 +1,284 @@
+---
+comments: true
+description: Discover the power of deploying your Ultralytics YOLOv8 model using OpenVINO format for up to 10x speedup vs PyTorch.
+keywords: ultralytics docs, YOLOv8, export YOLOv8, YOLOv8 model deployment, exporting YOLOv8, OpenVINO, OpenVINO format
+---
+
+# Intel OpenVINO Export
+
+
+
+In this guide, we cover exporting YOLOv8 models to the [OpenVINO](https://docs.openvino.ai/) format, which can provide up to 3x [CPU](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_supported_plugins_CPU.html) speedup as well as accelerating on other Intel hardware ([iGPU](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_supported_plugins_GPU.html), [dGPU](https://docs.openvino.ai/2023.0/openvino_docs_OV_UG_supported_plugins_GPU.html), [VPU](https://docs.openvino.ai/2022.3/openvino_docs_OV_UG_supported_plugins_VPU.html), etc.).
+
+OpenVINO, short for Open Visual Inference & Neural Network Optimization toolkit, is a comprehensive toolkit for optimizing and deploying AI inference models. Even though the name contains Visual, OpenVINO also supports various additional tasks including language, audio, time series, etc.
+
+
+
+
+
+ Watch: How To Export and Optimize an Ultralytics YOLOv8 Model for Inference with OpenVINO.
+
+
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Watch: Run Ultralytics YOLO models in just a few lines of code.
+
+
+## Introduction
+
+Once your model is trained and validated, the next logical step is to evaluate its performance in various real-world scenarios. Benchmark mode in Ultralytics YOLOv8 serves this purpose by providing a robust framework for assessing the speed and accuracy of your model across a range of export formats.
+
+## Why Is Benchmarking Crucial?
+
+- **Informed Decisions:** Gain insights into the trade-offs between speed and accuracy.
+- **Resource Allocation:** Understand how different export formats perform on different hardware.
+- **Optimization:** Learn which export format offers the best performance for your specific use case.
+- **Cost Efficiency:** Make more efficient use of hardware resources based on benchmark results.
+
+### Key Metrics in Benchmark Mode
+
+- **mAP50-95:** For object detection, segmentation, and pose estimation.
+- **accuracy_top5:** For image classification.
+- **Inference Time:** Time taken for each image in milliseconds.
+
+### Supported Export Formats
+
+- **ONNX:** For optimal CPU performance
+- **TensorRT:** For maximal GPU efficiency
+- **OpenVINO:** For Intel hardware optimization
+- **CoreML, TensorFlow SavedModel, and More:** For diverse deployment needs.
+
+!!! tip "Tip"
+
+ * Export to ONNX or OpenVINO for up to 3x CPU speedup.
+ * Export to TensorRT for up to 5x GPU speedup.
+
+## Usage Examples
+
+Run YOLOv8n benchmarks on all supported export formats including ONNX, TensorRT etc. See Arguments section below for a full list of export arguments.
+
+!!! example ""
+
+ === "Python"
+
+ ```python
+ from ultralytics.utils.benchmarks import benchmark
+
+ # Benchmark on GPU
+ benchmark(model='yolov8n.pt', data='coco8.yaml', imgsz=640, half=False, device=0)
+ ```
+ === "CLI"
+
+ ```bash
+ yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
+ ```
+
+## Arguments
+
+Arguments such as `model`, `data`, `imgsz`, `half`, `device`, and `verbose` provide users with the flexibility to fine-tune the benchmarks to their specific needs and compare the performance of different export formats with ease.
+
+| Key | Value | Description |
+|-----------|---------|-----------------------------------------------------------------------|
+| `model` | `None` | path to model file, i.e. yolov8n.pt, yolov8n.yaml |
+| `data` | `None` | path to YAML referencing the benchmarking dataset (under `val` label) |
+| `imgsz` | `640` | image size as scalar or (h, w) list, i.e. (640, 480) |
+| `half` | `False` | FP16 quantization |
+| `int8` | `False` | INT8 quantization |
+| `device` | `None` | device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu |
+| `verbose` | `False` | do not continue on error (bool), or val floor threshold (float) |
+
+## Export Formats
+
+Benchmarks will attempt to run automatically on all possible export formats below.
+
+| Format | `format` Argument | Model | Metadata | Arguments |
+|--------------------------------------------------------------------|-------------------|---------------------------|----------|-----------------------------------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov8n.pt` | ✅ | - |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov8n.torchscript` | ✅ | `imgsz`, `optimize` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov8n.onnx` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `opset` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov8n_openvino_model/` | ✅ | `imgsz`, `half` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov8n.engine` | ✅ | `imgsz`, `half`, `dynamic`, `simplify`, `workspace` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov8n.mlpackage` | ✅ | `imgsz`, `half`, `int8`, `nms` |
+| [TF SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov8n_saved_model/` | ✅ | `imgsz`, `keras` |
+| [TF GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov8n.pb` | ❌ | `imgsz` |
+| [TF Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov8n.tflite` | ✅ | `imgsz`, `half`, `int8` |
+| [TF Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov8n_edgetpu.tflite` | ✅ | `imgsz` |
+| [TF.js](https://www.tensorflow.org/js) | `tfjs` | `yolov8n_web_model/` | ✅ | `imgsz` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov8n_paddle_model/` | ✅ | `imgsz` |
+| [ncnn](https://github.com/Tencent/ncnn) | `ncnn` | `yolov8n_ncnn_model/` | ✅ | `imgsz`, `half` |
+
+See full `export` details in the [Export](https://docs.ultralytics.com/modes/export/) page.
diff --git a/ultralytics/docs/modes/export.md b/ultralytics/docs/modes/export.md
new file mode 100644
index 0000000000000000000000000000000000000000..d0c2da00f0dd9a6b9d5ad80e09c94de80287f7a7
--- /dev/null
+++ b/ultralytics/docs/modes/export.md
@@ -0,0 +1,108 @@
+---
+comments: true
+description: Step-by-step guide on exporting your YOLOv8 models to various format like ONNX, TensorRT, CoreML and more for deployment. Explore now!.
+keywords: YOLO, YOLOv8, Ultralytics, Model export, ONNX, TensorRT, CoreML, TensorFlow SavedModel, OpenVINO, PyTorch, export model
+---
+
+# Model Export with Ultralytics YOLO
+
+
+
+## Introduction
+
+The ultimate goal of training a model is to deploy it for real-world applications. Export mode in Ultralytics YOLOv8 offers a versatile range of options for exporting your trained model to different formats, making it deployable across various platforms and devices. This comprehensive guide aims to walk you through the nuances of model exporting, showcasing how to achieve maximum compatibility and performance.
+
+
+
+
+
+ Watch: How To Export Custom Trained Ultralytics YOLOv8 Model and Run Live Inference on Webcam.
+
+
+## Introduction
+
+Ultralytics YOLOv8 is not just another object detection model; it's a versatile framework designed to cover the entire lifecycle of machine learning models—from data ingestion and model training to validation, deployment, and real-world tracking. Each mode serves a specific purpose and is engineered to offer you the flexibility and efficiency required for different tasks and use-cases.
+
+
+
+
+
+ Watch: Ultralytics Modes Tutorial: Train, Validate, Predict, Export & Benchmark.
+
+
+## Introduction
+
+In the world of machine learning and computer vision, the process of making sense out of visual data is called 'inference' or 'prediction'. Ultralytics YOLOv8 offers a powerful feature known as **predict mode** that is tailored for high-performance, real-time inference on a wide range of data sources.
+
+
+
+
+
+ Watch: How to Extract the Outputs from Ultralytics YOLOv8 Model for Custom Projects.
+
+
+Object tracking in the realm of video analytics is a critical task that not only identifies the location and class of objects within the frame but also maintains a unique ID for each detected object as the video progresses. The applications are limitless—ranging from surveillance and security to real-time sports analytics.
+
+## Why Choose Ultralytics YOLO for Object Tracking?
+
+The output from Ultralytics trackers is consistent with standard object detection but has the added value of object IDs. This makes it easy to track objects in video streams and perform subsequent analytics. Here's why you should consider using Ultralytics YOLO for your object tracking needs:
+
+- **Efficiency:** Process video streams in real-time without compromising accuracy.
+- **Flexibility:** Supports multiple tracking algorithms and configurations.
+- **Ease of Use:** Simple Python API and CLI options for quick integration and deployment.
+- **Customizability:** Easy to use with custom trained YOLO models, allowing integration into domain-specific applications.
+
+
+
+
+
+ Watch: Object Detection and Tracking with Ultralytics YOLOv8.
+
+
+## Introduction
+
+Training a deep learning model involves feeding it data and adjusting its parameters so that it can make accurate predictions. Train mode in Ultralytics YOLOv8 is engineered for effective and efficient training of object detection models, fully utilizing modern hardware capabilities. This guide aims to cover all the details you need to get started with training your own models using YOLOv8's robust set of features.
+
+
+
+
+
+ Watch: How to Train a YOLOv8 model on Your Custom Dataset in Google Colab.
+
+
+## Introduction
+
+Validation is a critical step in the machine learning pipeline, allowing you to assess the quality of your trained models. Val mode in Ultralytics YOLOv8 provides a robust suite of tools and metrics for evaluating the performance of your object detection models. This guide serves as a complete resource for understanding how to effectively use the Val mode to ensure that your models are both accurate and reliable.
+
+## Why Validate with Ultralytics YOLO?
+
+Here's why using YOLOv8's Val mode is advantageous:
+
+- **Precision:** Get accurate metrics like mAP50, mAP75, and mAP50-95 to comprehensively evaluate your model.
+- **Convenience:** Utilize built-in features that remember training settings, simplifying the validation process.
+- **Flexibility:** Validate your model with the same or different datasets and image sizes.
+- **Hyperparameter Tuning:** Use validation metrics to fine-tune your model for better performance.
+
+### Key Features of Val Mode
+
+These are the notable functionalities offered by YOLOv8's Val mode:
+
+- **Automated Settings:** Models remember their training configurations for straightforward validation.
+- **Multi-Metric Support:** Evaluate your model based on a range of accuracy metrics.
+- **CLI and Python API:** Choose from command-line interface or Python API based on your preference for validation.
+- **Data Compatibility:** Works seamlessly with datasets used during the training phase as well as custom datasets.
+
+!!! tip "Tip"
+
+ * YOLOv8 models automatically remember their training settings, so you can validate a model at the same image size and on the original dataset easily with just `yolo val model=yolov8n.pt` or `model('yolov8n.pt').val()`
+
+## Usage Examples
+
+Validate trained YOLOv8n model accuracy on the COCO128 dataset. No argument need to passed as the `model` retains it's training `data` and arguments as model attributes. See Arguments section below for a full list of export arguments.
+
+!!! example ""
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.pt') # load an official model
+ model = YOLO('path/to/best.pt') # load a custom model
+
+ # Validate the model
+ metrics = model.val() # no arguments needed, dataset and settings remembered
+ metrics.box.map # map50-95
+ metrics.box.map50 # map50
+ metrics.box.map75 # map75
+ metrics.box.maps # a list contains map50-95 of each category
+ ```
+ === "CLI"
+
+ ```bash
+ yolo detect val model=yolov8n.pt # val official model
+ yolo detect val model=path/to/best.pt # val custom model
+ ```
+
+## Arguments
+
+Validation settings for YOLO models refer to the various hyperparameters and configurations used to evaluate the model's performance on a validation dataset. These settings can affect the model's performance, speed, and accuracy. Some common YOLO validation settings include the batch size, the frequency with which validation is performed during training, and the metrics used to evaluate the model's performance. Other factors that may affect the validation process include the size and composition of the validation dataset and the specific task the model is being used for. It is important to carefully tune and experiment with these settings to ensure that the model is performing well on the validation dataset and to detect and prevent overfitting.
+
+| Key | Value | Description |
+|---------------|---------|--------------------------------------------------------------------|
+| `data` | `None` | path to data file, i.e. coco128.yaml |
+| `imgsz` | `640` | size of input images as integer |
+| `batch` | `16` | number of images per batch (-1 for AutoBatch) |
+| `save_json` | `False` | save results to JSON file |
+| `save_hybrid` | `False` | save hybrid version of labels (labels + additional predictions) |
+| `conf` | `0.001` | object confidence threshold for detection |
+| `iou` | `0.6` | intersection over union (IoU) threshold for NMS |
+| `max_det` | `300` | maximum number of detections per image |
+| `half` | `True` | use half precision (FP16) |
+| `device` | `None` | device to run on, i.e. cuda device=0/1/2/3 or device=cpu |
+| `dnn` | `False` | use OpenCV DNN for ONNX inference |
+| `plots` | `False` | show plots during training |
+| `rect` | `False` | rectangular val with each batch collated for minimum padding |
+| `split` | `val` | dataset split to use for validation, i.e. 'val', 'test' or 'train' |
+|
diff --git a/ultralytics/docs/overrides/partials/comments.html b/ultralytics/docs/overrides/partials/comments.html
new file mode 100644
index 0000000000000000000000000000000000000000..dcee5a9f14e1b0f2c386fee3a7fbf8a0addb6a82
--- /dev/null
+++ b/ultralytics/docs/overrides/partials/comments.html
@@ -0,0 +1,50 @@
+{% if page.meta.comments %}
+
+
+ - **Dockerfile:** GPU image recommended for training.
+ - **Dockerfile-arm64:** Optimized for ARM64 architecture, allowing deployment on devices like Raspberry Pi and other ARM64-based platforms.
+ - **Dockerfile-cpu:** Ubuntu-based CPU-only version suitable for inference and environments without GPUs.
+ - **Dockerfile-jetson:** Tailored for NVIDIA Jetson devices, integrating GPU support optimized for these platforms.
+ - **Dockerfile-python:** Minimal image with just Python and necessary dependencies, ideal for lightweight applications and development.
+ - **Dockerfile-conda:** Based on Miniconda3 with conda installation of ultralytics package.
+
+ Below are the commands to get the latest image and execute it:
+
+ ```bash
+ # Set image name as a variable
+ t=ultralytics/ultralytics:latest
+
+ # Pull the latest ultralytics image from Docker Hub
+ sudo docker pull $t
+
+ # Run the ultralytics image in a container with GPU support
+ sudo docker run -it --ipc=host --gpus all $t # all GPUs
+ sudo docker run -it --ipc=host --gpus '"device=2,3"' $t # specify GPUs
+ ```
+
+ The above command initializes a Docker container with the latest `ultralytics` image. The `-it` flag assigns a pseudo-TTY and maintains stdin open, enabling you to interact with the container. The `--ipc=host` flag sets the IPC (Inter-Process Communication) namespace to the host, which is essential for sharing memory between processes. The `--gpus all` flag enables access to all available GPUs inside the container, which is crucial for tasks that require GPU computation.
+
+ Note: To work with files on your local machine within the container, use Docker volumes for mounting a local directory into the container:
+
+ ```bash
+ # Mount local directory to a directory inside the container
+ sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
+ ```
+
+ Alter `/path/on/host` with the directory path on your local machine, and `/path/in/container` with the desired path inside the Docker container for accessibility.
+
+ For advanced Docker usage, feel free to explore the [Ultralytics Docker Guide](https://docs.ultralytics.com/guides/docker-quickstart/).
+
+See the `ultralytics` [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/requirements.txt) file for a list of dependencies. Note that all examples above install all required dependencies.
+
+!!! tip "Tip"
+
+ PyTorch requirements vary by operating system and CUDA requirements, so it's recommended to install PyTorch first following instructions at [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
+
+
+ 
+
+
+## Use Ultralytics with CLI
+
+The Ultralytics command line interface (CLI) allows for simple single-line commands without the need for a Python environment. CLI requires no customization or Python code. You can simply run all tasks from the terminal with the `yolo` command. Check out the [CLI Guide](usage/cli.md) to learn more about using YOLOv8 from the command line.
+
+!!! example
+
+ === "Syntax"
+
+ Ultralytics `yolo` commands use the following syntax:
+ ```bash
+ yolo TASK MODE ARGS
+
+ Where TASK (optional) is one of [detect, segment, classify]
+ MODE (required) is one of [train, val, predict, export, track]
+ ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
+ ```
+ See all ARGS in the full [Configuration Guide](usage/cfg.md) or with `yolo cfg`
+
+ === "Train"
+
+ Train a detection model for 10 epochs with an initial learning_rate of 0.01
+ ```bash
+ yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+ ```
+
+ === "Predict"
+
+ Predict a YouTube video using a pretrained segmentation model at image size 320:
+ ```bash
+ yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+ ```
+
+ === "Val"
+
+ Val a pretrained detection model at batch-size 1 and image size 640:
+ ```bash
+ yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
+ ```
+
+ === "Export"
+
+ Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
+ ```bash
+ yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+ ```
+
+ === "Special"
+
+ Run special commands to see version, view settings, run checks and more:
+ ```bash
+ yolo help
+ yolo checks
+ yolo version
+ yolo settings
+ yolo copy-cfg
+ yolo cfg
+ ```
+
+!!! warning "Warning"
+
+ Arguments must be passed as `arg=val` pairs, split by an equals `=` sign and delimited by spaces ` ` between pairs. Do not use `--` argument prefixes or commas `,` between arguments.
+
+ - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` ✅
+ - `yolo predict model yolov8n.pt imgsz 640 conf 0.25` ❌
+ - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` ❌
+
+[CLI Guide](usage/cli.md){ .md-button .md-button--primary}
+
+## Use Ultralytics with Python
+
+YOLOv8's Python interface allows for seamless integration into your Python projects, making it easy to load, run, and process the model's output. Designed with simplicity and ease of use in mind, the Python interface enables users to quickly implement object detection, segmentation, and classification in their projects. This makes YOLOv8's Python interface an invaluable tool for anyone looking to incorporate these functionalities into their Python projects.
+
+For example, users can load a model, train it, evaluate its performance on a validation set, and even export it to ONNX format with just a few lines of code. Check out the [Python Guide](usage/python.md) to learn more about using YOLOv8 within your Python projects.
+
+!!! example
+
+ ```python
+ from ultralytics import YOLO
+
+ # Create a new YOLO model from scratch
+ model = YOLO('yolov8n.yaml')
+
+ # Load a pretrained YOLO model (recommended for training)
+ model = YOLO('yolov8n.pt')
+
+ # Train the model using the 'coco128.yaml' dataset for 3 epochs
+ results = model.train(data='coco128.yaml', epochs=3)
+
+ # Evaluate the model's performance on the validation set
+ results = model.val()
+
+ # Perform object detection on an image using the model
+ results = model('https://ultralytics.com/images/bus.jpg')
+
+ # Export the model to ONNX format
+ success = model.export(format='onnx')
+ ```
+
+[Python Guide](usage/python.md){.md-button .md-button--primary}
+
+## Ultralytics Settings
+
+The Ultralytics library provides a powerful settings management system to enable fine-grained control over your experiments. By making use of the `SettingsManager` housed within the `ultralytics.utils` module, users can readily access and alter their settings. These are stored in a YAML file and can be viewed or modified either directly within the Python environment or via the Command-Line Interface (CLI).
+
+### Inspecting Settings
+
+To gain insight into the current configuration of your settings, you can view them directly:
+
+!!! example "View settings"
+
+ === "Python"
+ You can use Python to view your settings. Start by importing the `settings` object from the `ultralytics` module. Print and return settings using the following commands:
+ ```python
+ from ultralytics import settings
+
+ # View all settings
+ print(settings)
+
+ # Return a specific setting
+ value = settings['runs_dir']
+ ```
+
+ === "CLI"
+ Alternatively, the command-line interface allows you to check your settings with a simple command:
+ ```bash
+ yolo settings
+ ```
+
+### Modifying Settings
+
+Ultralytics allows users to easily modify their settings. Changes can be performed in the following ways:
+
+!!! example "Update settings"
+
+ === "Python"
+ Within the Python environment, call the `update` method on the `settings` object to change your settings:
+ ```python
+ from ultralytics import settings
+
+ # Update a setting
+ settings.update({'runs_dir': '/path/to/runs'})
+
+ # Update multiple settings
+ settings.update({'runs_dir': '/path/to/runs', 'tensorboard': False})
+
+ # Reset settings to default values
+ settings.reset()
+ ```
+
+ === "CLI"
+ If you prefer using the command-line interface, the following commands will allow you to modify your settings:
+ ```bash
+ # Update a setting
+ yolo settings runs_dir='/path/to/runs'
+
+ # Update multiple settings
+ yolo settings runs_dir='/path/to/runs' tensorboard=False
+
+ # Reset settings to default values
+ yolo settings reset
+ ```
+
+### Understanding Settings
+
+The table below provides an overview of the settings available for adjustment within Ultralytics. Each setting is outlined along with an example value, the data type, and a brief description.
+
+| Name | Example Value | Data Type | Description |
+|--------------------|-----------------------|-----------|------------------------------------------------------------------------------------------------------------------|
+| `settings_version` | `'0.0.4'` | `str` | Ultralytics _settings_ version (different from Ultralytics [pip](https://pypi.org/project/ultralytics/) version) |
+| `datasets_dir` | `'/path/to/datasets'` | `str` | The directory where the datasets are stored |
+| `weights_dir` | `'/path/to/weights'` | `str` | The directory where the model weights are stored |
+| `runs_dir` | `'/path/to/runs'` | `str` | The directory where the experiment runs are stored |
+| `uuid` | `'a1b2c3d4'` | `str` | The unique identifier for the current settings |
+| `sync` | `True` | `bool` | Whether to sync analytics and crashes to HUB |
+| `api_key` | `''` | `str` | Ultralytics HUB [API Key](https://hub.ultralytics.com/settings?tab=api+keys) |
+| `clearml` | `True` | `bool` | Whether to use ClearML logging |
+| `comet` | `True` | `bool` | Whether to use [Comet ML](https://bit.ly/yolov8-readme-comet) for experiment tracking and visualization |
+| `dvc` | `True` | `bool` | Whether to use [DVC for experiment tracking](https://dvc.org/doc/dvclive/ml-frameworks/yolo) and version control |
+| `hub` | `True` | `bool` | Whether to use [Ultralytics HUB](https://hub.ultralytics.com) integration |
+| `mlflow` | `True` | `bool` | Whether to use MLFlow for experiment tracking |
+| `neptune` | `True` | `bool` | Whether to use Neptune for experiment tracking |
+| `raytune` | `True` | `bool` | Whether to use Ray Tune for hyperparameter tuning |
+| `tensorboard` | `True` | `bool` | Whether to use TensorBoard for visualization |
+| `wandb` | `True` | `bool` | Whether to use Weights & Biases logging |
+
+As you navigate through your projects or experiments, be sure to revisit these settings to ensure that they are optimally configured for your needs.
diff --git a/ultralytics/docs/reference/cfg/__init__.md b/ultralytics/docs/reference/cfg/__init__.md
new file mode 100644
index 0000000000000000000000000000000000000000..e439dd52191a913940d580e92def655dbfdafdd2
--- /dev/null
+++ b/ultralytics/docs/reference/cfg/__init__.md
@@ -0,0 +1,58 @@
+---
+description: Explore Ultralytics cfg functions like cfg2dict, handle_deprecation, merge_equal_args & more to handle YOLO settings and configurations efficiently.
+keywords: Ultralytics, YOLO, Configuration, cfg2dict, handle_deprecation, merge_equals_args, handle_yolo_settings, copy_default_cfg, Image Detection
+---
+
+# Reference for `ultralytics/cfg/__init__.py`
+
+!!! note
+
+ Full source code for this file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/__init__.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/__init__.py). Help us fix any issues you see by submitting a [Pull Request](https://docs.ultralytics.com/help/contributing/) 🛠️. Thank you 🙏!
+
+---
+## ::: ultralytics.cfg.cfg2dict
+
+
+Image classification is the simplest of the three tasks and involves classifying an entire image into one of a set of predefined classes.
+
+The output of an image classifier is a single class label and a confidence score. Image classification is useful when you need to know only what class an image belongs to and don't need to know where objects of that class are located or what their exact shape is.
+
+!!! tip "Tip"
+
+ YOLOv8 Classify models use the `-cls` suffix, i.e. `yolov8n-cls.pt` and are pretrained on [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml).
+
+## [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/v8)
+
+YOLOv8 pretrained Classify models are shown here. Detect, Segment and Pose models are pretrained on the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) dataset, while Classify models are pretrained on the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) dataset.
+
+[Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+| Model | size
+
+Object detection is a task that involves identifying the location and class of objects in an image or video stream.
+
+The output of an object detector is a set of bounding boxes that enclose the objects in the image, along with class labels and confidence scores for each box. Object detection is a good choice when you need to identify objects of interest in a scene, but don't need to know exactly where the object is or its exact shape.
+
+
+
+
+
+ Watch: Object Detection with Pre-trained Ultralytics YOLOv8 Model.
+
+
+YOLOv8 is an AI framework that supports multiple computer vision **tasks**. The framework can be used to perform [detection](detect.md), [segmentation](segment.md), [classification](classify.md), and [pose](pose.md) estimation. Each of these tasks has a different objective and use case.
+
+
+
+
+
+ Watch: Explore Ultralytics YOLO Tasks: Object Detection, Segmentation, Tracking, and Pose Estimation.
+
+
+Pose estimation is a task that involves identifying the location of specific points in an image, usually referred to as keypoints. The keypoints can represent various parts of the object such as joints, landmarks, or other distinctive features. The locations of the keypoints are usually represented as a set of 2D `[x, y]` or 3D `[x, y, visible]`
+coordinates.
+
+The output of a pose estimation model is a set of points that represent the keypoints on an object in the image, usually along with the confidence scores for each point. Pose estimation is a good choice when you need to identify specific parts of an object in a scene, and their location in relation to each other.
+
+
+
+
+
+ Watch: Pose Estimation with Ultralytics YOLOv8.
+
+
+Instance segmentation goes a step further than object detection and involves identifying individual objects in an image and segmenting them from the rest of the image.
+
+The output of an instance segmentation model is a set of masks or contours that outline each object in the image, along with class labels and confidence scores for each object. Instance segmentation is useful when you need to know not only where objects are in an image, but also what their exact shape is.
+
+
+
+
+
+ Watch: Run Segmentation with Pre-Trained Ultralytics YOLOv8 Model in Python.
+
+
+
+
+ Watch: Mastering Ultralytics YOLOv8: CLI & Python Usage and Live Inference
+
, [GCP Deep Learning VM](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial), and our Docker image at [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) 
. *Updated: 21 April 2023*.
+
+## 1. AWS Console Sign-in
+
+Create an account or sign in to the AWS console at [https://aws.amazon.com/console/](https://aws.amazon.com/console/) and select the **EC2** service.
+
+
+
+## 2. Launch Instance
+
+In the EC2 section of the AWS console, click the **Launch instance** button.
+
+
+
+### Choose an Amazon Machine Image (AMI)
+
+Enter 'Deep Learning' in the search field and select the most recent Ubuntu Deep Learning AMI (recommended), or an alternative Deep Learning AMI. For more information on selecting an AMI, see [Choosing Your DLAMI](https://docs.aws.amazon.com/dlami/latest/devguide/options.html).
+
+
+
+### Select an Instance Type
+
+A GPU instance is recommended for most deep learning purposes. Training new models will be faster on a GPU instance than a CPU instance. Multi-GPU instances or distributed training across multiple instances with GPUs can offer sub-linear scaling. To set up distributed training, see [Distributed Training](https://docs.aws.amazon.com/dlami/latest/devguide/distributed-training.html).
+
+**Note:** The size of your model should be a factor in selecting an instance. If your model exceeds an instance's available RAM, select a different instance type with enough memory for your application.
+
+Refer to [EC2 Instance Types](https://aws.amazon.com/ec2/instance-types/) and choose Accelerated Computing to see the different GPU instance options.
+
+
+
+For more information on GPU monitoring and optimization, see [GPU Monitoring and Optimization](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-gpu.html). For pricing, see [On-Demand Pricing](https://aws.amazon.com/ec2/pricing/on-demand/) and [Spot Pricing](https://aws.amazon.com/ec2/spot/pricing/).
+
+### Configure Instance Details
+
+Amazon EC2 Spot Instances let you take advantage of unused EC2 capacity in the AWS cloud. Spot Instances are available at up to a 70% discount compared to On-Demand prices. We recommend a persistent spot instance, which will save your data and restart automatically when spot instance availability returns after spot instance termination. For full-price On-Demand instances, leave these settings at their default values.
+
+
+
+Complete Steps 4-7 to finalize your instance hardware and security settings, and then launch the instance.
+
+## 3. Connect to Instance
+
+Select the checkbox next to your running instance, and then click Connect. Copy and paste the SSH terminal command into a terminal of your choice to connect to your instance.
+
+
+
+## 4. Run YOLOv5
+
+Once you have logged in to your instance, clone the repository and install the dependencies in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+Then, start training, testing, detecting, and exporting YOLOv5 models:
+
+```bash
+python train.py # train a model
+python val.py --weights yolov5s.pt # validate a model for Precision, Recall, and mAP
+python detect.py --weights yolov5s.pt --source path/to/images # run inference on images and videos
+python export.py --weights yolov5s.pt --include onnx coreml tflite # export models to other formats
+```
+
+## Optional Extras
+
+Add 64GB of swap memory (to `--cache` large datasets):
+
+```bash
+sudo fallocate -l 64G /swapfile
+sudo chmod 600 /swapfile
+sudo mkswap /swapfile
+sudo swapon /swapfile
+free -h # check memory
+```
+
+Now you have successfully set up and run YOLOv5 on an AWS Deep Learning instance. Enjoy training, testing, and deploying your object detection models!
diff --git a/ultralytics/docs/yolov5/environments/azureml_quickstart_tutorial.md b/ultralytics/docs/yolov5/environments/azureml_quickstart_tutorial.md
new file mode 100644
index 0000000000000000000000000000000000000000..e1e58a4ef2fc1a6356dd80ac12560ca508550423
--- /dev/null
+++ b/ultralytics/docs/yolov5/environments/azureml_quickstart_tutorial.md
@@ -0,0 +1,95 @@
+---
+comments: true
+description: Azure Machine Learning YOLOv5 quickstart
+keywords: Ultralytics, YOLO, Deep Learning, Object detection, quickstart, Azure, AzureML
+---
+
+# YOLOv5 🚀 on AzureML
+
+This guide provides a quickstart to use YOLOv5 from an AzureML compute instance.
+
+Note that this guide is a quickstart for quick trials. If you want to unlock the full power AzureML, you can find the documentation to:
+
+- [Create a data asset](https://learn.microsoft.com/azure/machine-learning/how-to-create-data-assets)
+- [Create an AzureML job](https://learn.microsoft.com/azure/machine-learning/how-to-train-model)
+- [Register a model](https://learn.microsoft.com/azure/machine-learning/how-to-manage-models)
+
+## Prerequisites
+
+You need an [AzureML workspace](https://learn.microsoft.com/azure/machine-learning/concept-workspace?view=azureml-api-2).
+
+## Create a compute instance
+
+From your AzureML workspace, select Compute > Compute instances > New, select the instance with the resources you need.
+
+ , [GCP Deep Learning VM](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial), and [Amazon AWS](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial). *Updated: 21 April 2023*.
+
+## Prerequisites
+
+1. **Nvidia Driver**: Version 455.23 or higher. Download from [Nvidia's website](https://www.nvidia.com/Download/index.aspx).
+2. **Nvidia-Docker**: Allows Docker to interact with your local GPU. Installation instructions are available on the [Nvidia-Docker GitHub repository](https://github.com/NVIDIA/nvidia-docker).
+3. **Docker Engine - CE**: Version 19.03 or higher. Download and installation instructions can be found on the [Docker website](https://docs.docker.com/install/).
+
+## Step 1: Pull the YOLOv5 Docker Image
+
+The Ultralytics YOLOv5 DockerHub repository is available at [https://hub.docker.com/r/ultralytics/yolov5](https://hub.docker.com/r/ultralytics/yolov5). Docker Autobuild ensures that the `ultralytics/yolov5:latest` image is always in sync with the most recent repository commit. To pull the latest image, run the following command:
+
+```bash
+sudo docker pull ultralytics/yolov5:latest
+```
+
+## Step 2: Run the Docker Container
+
+### Basic container:
+
+Run an interactive instance of the YOLOv5 Docker image (called a "container") using the `-it` flag:
+
+```bash
+sudo docker run --ipc=host -it ultralytics/yolov5:latest
+```
+
+### Container with local file access:
+
+To run a container with access to local files (e.g., COCO training data in `/datasets`), use the `-v` flag:
+
+```bash
+sudo docker run --ipc=host -it -v "$(pwd)"/datasets:/usr/src/datasets ultralytics/yolov5:latest
+```
+
+### Container with GPU access:
+
+To run a container with GPU access, use the `--gpus all` flag:
+
+```bash
+sudo docker run --ipc=host -it --gpus all ultralytics/yolov5:latest
+```
+
+## Step 3: Use YOLOv5 🚀 within the Docker Container
+
+Now you can train, test, detect, and export YOLOv5 models within the running Docker container:
+
+```bash
+python train.py # train a model
+python val.py --weights yolov5s.pt # validate a model for Precision, Recall, and mAP
+python detect.py --weights yolov5s.pt --source path/to/images # run inference on images and videos
+python export.py --weights yolov5s.pt --include onnx coreml tflite # export models to other formats
+```
+
+
, [Amazon AWS](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial) and our Docker image at [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) . *Updated: 21 April 2023*.
+
+**Last Updated**: 6 May 2022
+
+## Step 1: Create a Deep Learning VM
+
+1. Go to the [GCP marketplace](https://console.cloud.google.com/marketplace/details/click-to-deploy-images/deeplearning) and select a **Deep Learning VM**.
+2. Choose an **n1-standard-8** instance (with 8 vCPUs and 30 GB memory).
+3. Add a GPU of your choice.
+4. Check 'Install NVIDIA GPU driver automatically on first startup?'
+5. Select a 300 GB SSD Persistent Disk for sufficient I/O speed.
+6. Click 'Deploy'.
+
+The preinstalled [Anaconda](https://docs.anaconda.com/anaconda/packages/pkg-docs/) Python environment includes all dependencies.
+
+
+
+## Step 2: Set Up the VM
+
+Clone the YOLOv5 repository and install the [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) will be downloaded automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Step 3: Run YOLOv5 🚀 on the VM
+
+You can now train, test, detect, and export YOLOv5 models on your VM:
+
+```bash
+python train.py # train a model
+python val.py --weights yolov5s.pt # validate a model for Precision, Recall, and mAP
+python detect.py --weights yolov5s.pt --source path/to/images # run inference on images and videos
+python export.py --weights yolov5s.pt --include onnx coreml tflite # export models to other formats
+```
+
+
diff --git a/ultralytics/docs/yolov5/index.md b/ultralytics/docs/yolov5/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fb8e38103499df43a84b36847146b077d929b7b
--- /dev/null
+++ b/ultralytics/docs/yolov5/index.md
@@ -0,0 +1,83 @@
+---
+comments: true
+description: Deep dive into Ultralytics' YOLOv5. Learn about object detection model - YOLOv5, how to train it on custom data, multi-GPU training and more.
+keywords: Ultralytics, YOLOv5, Deep Learning, Object detection, PyTorch, Tutorial, Multi-GPU training, Custom data training
+---
+
+# Comprehensive Guide to Ultralytics YOLOv5
+
+
+
+ 
+
+
+
+
+
+
+
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](environments/google_cloud_quickstart_tutorial.md)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](environments/aws_quickstart_tutorial.md)
+- **Azure** Azure Machine Learning. See [AzureML Quickstart Guide](environments/azureml_quickstart_tutorial.md)
+- **Docker Image**. See [Docker Quickstart Guide](environments/docker_image_quickstart_tutorial.md)
+
+## Status
+
+
+
+This badge signifies that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are currently passing. CI tests verify the correct operation of YOLOv5 [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and with every new commit.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ultralytics/docs/yolov5/tutorials/architecture_description.md b/ultralytics/docs/yolov5/tutorials/architecture_description.md
new file mode 100644
index 0000000000000000000000000000000000000000..cdd79292def4f64456862843920622dadd457eac
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/architecture_description.md
@@ -0,0 +1,223 @@
+---
+comments: true
+description: Explore the architecture of YOLOv5, an object detection algorithm by Ultralytics. Understand the model structure, data augmentation methods, training strategies, and loss computation techniques.
+keywords: Ultralytics, YOLOv5, Object Detection, Architecture, Model Structure, Data Augmentation, Training Strategies, Loss Computation
+---
+
+# Ultralytics YOLOv5 Architecture
+
+YOLOv5 (v6.0/6.1) is a powerful object detection algorithm developed by Ultralytics. This article dives deep into the YOLOv5 architecture, data augmentation strategies, training methodologies, and loss computation techniques. This comprehensive understanding will help improve your practical application of object detection in various fields, including surveillance, autonomous vehicles, and image recognition.
+
+## 1. Model Structure
+
+YOLOv5's architecture consists of three main parts:
+
+- **Backbone**: This is the main body of the network. For YOLOv5, the backbone is designed using the `New CSP-Darknet53` structure, a modification of the Darknet architecture used in previous versions.
+- **Neck**: This part connects the backbone and the head. In YOLOv5, `SPPF` and `New CSP-PAN` structures are utilized.
+- **Head**: This part is responsible for generating the final output. YOLOv5 uses the `YOLOv3 Head` for this purpose.
+
+The structure of the model is depicted in the image below. The model structure details can be found in `yolov5l.yaml`.
+
+
+
+YOLOv5 introduces some minor changes compared to its predecessors:
+
+1. The `Focus` structure, found in earlier versions, is replaced with a `6x6 Conv2d` structure. This change boosts efficiency [#4825](https://github.com/ultralytics/yolov5/issues/4825).
+2. The `SPP` structure is replaced with `SPPF`. This alteration more than doubles the speed of processing.
+
+To test the speed of `SPP` and `SPPF`, the following code can be used:
+
+
+
+However, in YOLOv5, the formula for predicting the box coordinates has been updated to reduce grid sensitivity and prevent the model from predicting unbounded box dimensions.
+
+The revised formulas for calculating the predicted bounding box are as follows:
+
+-0.5)+c_x)
+-0.5)+c_y)
+)^2)
+)^2)
+
+Compare the center point offset before and after scaling. The center point offset range is adjusted from (0, 1) to (-0.5, 1.5). Therefore, offset can easily get 0 or 1.
+
+
+
+Compare the height and width scaling ratio(relative to anchor) before and after adjustment. The original yolo/darknet box equations have a serious flaw. Width and Height are completely unbounded as they are simply out=exp(in), which is dangerous, as it can lead to runaway gradients, instabilities, NaN losses and ultimately a complete loss of training. [refer this issue](https://github.com/ultralytics/yolov5/issues/471#issuecomment-662009779)
+
+
+
+### 4.4 Build Targets
+
+The build target process in YOLOv5 is critical for training efficiency and model accuracy. It involves assigning ground truth boxes to the appropriate grid cells in the output map and matching them with the appropriate anchor boxes.
+
+This process follows these steps:
+
+- Calculate the ratio of the ground truth box dimensions and the dimensions of each anchor template.
+
+
+
+
+
+)
+
+)
+
+)
+
+
+
+
+
+- If the calculated ratio is within the threshold, match the ground truth box with the corresponding anchor.
+
+
+
+- Assign the matched anchor to the appropriate cells, keeping in mind that due to the revised center point offset, a ground truth box can be assigned to more than one anchor. Because the center point offset range is adjusted from (0, 1) to (-0.5, 1.5). GT Box can be assigned to more anchors.
+
+
+
+This way, the build targets process ensures that each ground truth object is properly assigned and matched during the training process, allowing YOLOv5 to learn the task of object detection more effectively.
+
+## Conclusion
+
+In conclusion, YOLOv5 represents a significant step forward in the development of real-time object detection models. By incorporating various new features, enhancements, and training strategies, it surpasses previous versions of the YOLO family in performance and efficiency.
+
+The primary enhancements in YOLOv5 include the use of a dynamic architecture, an extensive range of data augmentation techniques, innovative training strategies, as well as important adjustments in computing losses and the process of building targets. All these innovations significantly improve the accuracy and efficiency of object detection while retaining a high degree of speed, which is the trademark of YOLO models.
diff --git a/ultralytics/docs/yolov5/tutorials/clearml_logging_integration.md b/ultralytics/docs/yolov5/tutorials/clearml_logging_integration.md
new file mode 100644
index 0000000000000000000000000000000000000000..43c8395c4318f31d5764396b577269fed6166971
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/clearml_logging_integration.md
@@ -0,0 +1,240 @@
+---
+comments: true
+description: Learn how ClearML can enhance your YOLOv5 pipeline – track your training runs, version your data, remotely monitor your models and optimize performance.
+keywords: ClearML, YOLOv5, Ultralytics, AI toolbox, training data, remote training, hyperparameter optimization, YOLOv5 model
+---
+
+# ClearML Integration
+
+
+
+## About ClearML
+
+[ClearML](https://cutt.ly/yolov5-tutorial-clearml) is an [open-source](https://github.com/allegroai/clearml) toolbox designed to save you time ⏱️.
+
+🔨 Track every YOLOv5 training run in the experiment manager
+
+🔧 Version and easily access your custom training data with the integrated ClearML Data Versioning Tool
+
+🔦 Remotely train and monitor your YOLOv5 training runs using ClearML Agent
+
+🔬 Get the very best mAP using ClearML Hyperparameter Optimization
+
+🔭 Turn your newly trained YOLOv5 model into an API with just a few commands using ClearML Serving
+
+
+
+# YOLOv5 with Comet
+
+This guide will cover how to use YOLOv5 with [Comet](https://bit.ly/yolov5-readme-comet2)
+
+# About Comet
+
+Comet builds tools that help data scientists, engineers, and team leaders accelerate and optimize machine learning and deep learning models.
+
+Track and visualize model metrics in real time, save your hyperparameters, datasets, and model checkpoints, and visualize your model predictions with [Comet Custom Panels](https://www.comet.com/docs/v2/guides/comet-dashboard/code-panels/about-panels/?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)!
+Comet makes sure you never lose track of your work and makes it easy to share results and collaborate across teams of all sizes!
+
+# Getting Started
+
+## Install Comet
+
+```shell
+pip install comet_ml
+```
+
+## Configure Comet Credentials
+
+There are two ways to configure Comet with YOLOv5.
+
+You can either set your credentials through environment variables
+
+**Environment Variables**
+
+```shell
+export COMET_API_KEY=
+
+# Try out an Example!
+
+Check out an example of a [completed run here](https://www.comet.com/examples/comet-example-yolov5/a0e29e0e9b984e4a822db2a62d0cb357?experiment-tab=chart&showOutliers=true&smoothing=0&transformY=smoothing&xAxis=step&utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
+
+Or better yet, try it out yourself in this Colab Notebook
+
+[](https://colab.research.google.com/drive/1RG0WOQyxlDlo5Km8GogJpIEJlg_5lyYO?usp=sharing)
+
+# Log automatically
+
+By default, Comet will log the following items
+
+## Metrics
+
+- Box Loss, Object Loss, Classification Loss for the training and validation data
+- mAP_0.5, mAP_0.5:0.95 metrics for the validation data.
+- Precision and Recall for the validation data
+
+## Parameters
+
+- Model Hyperparameters
+- All parameters passed through the command line options
+
+## Visualizations
+
+- Confusion Matrix of the model predictions on the validation data
+- Plots for the PR and F1 curves across all classes
+- Correlogram of the Class Labels
+
+# Configure Comet Logging
+
+Comet can be configured to log additional data either through command line flags passed to the training script or through environment variables.
+
+```shell
+export COMET_MODE=online # Set whether to run Comet in 'online' or 'offline' mode. Defaults to online
+export COMET_MODEL_NAME=
+
+You can preview the data directly in the Comet UI.
+
+
+Artifacts are versioned and also support adding metadata about the dataset. Comet will automatically log the metadata from your dataset `yaml` file
+
+
+### Using a saved Artifact
+
+If you would like to use a dataset from Comet Artifacts, set the `path` variable in your dataset `yaml` file to point to the following Artifact resource URL.
+
+```
+# contents of artifact.yaml file
+path: "comet://
+
+## Resuming a Training Run
+
+If your training run is interrupted for any reason, e.g. disrupted internet connection, you can resume the run using the `resume` flag and the Comet Run Path.
+
+The Run Path has the following format `comet://
diff --git a/ultralytics/docs/yolov5/tutorials/hyperparameter_evolution.md b/ultralytics/docs/yolov5/tutorials/hyperparameter_evolution.md
new file mode 100644
index 0000000000000000000000000000000000000000..6ca148a906935cd5c1762270f2ced801b32e0897
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/hyperparameter_evolution.md
@@ -0,0 +1,165 @@
+---
+comments: true
+description: Learn how to optimize YOLOv5 with hyperparameter evolution using Genetic Algorithm. This guide provides steps to initialize, define, evolve and visualize hyperparameters for top performance.
+keywords: Ultralytics, YOLOv5, Hyperparameter Optimization, Genetic Algorithm, Machine Learning, Deep Learning, AI, Object Detection, Image Classification, Python
+---
+
+📚 This guide explains **hyperparameter evolution** for YOLOv5 🚀. Hyperparameter evolution is a method of [Hyperparameter Optimization](https://en.wikipedia.org/wiki/Hyperparameter_optimization) using a [Genetic Algorithm](https://en.wikipedia.org/wiki/Genetic_algorithm) (GA) for optimization. UPDATED 25 September 2022.
+
+Hyperparameters in ML control various aspects of training, and finding optimal values for them can be a challenge. Traditional methods like grid searches can quickly become intractable due to 1) the high dimensional search space 2) unknown correlations among the dimensions, and 3) expensive nature of evaluating the fitness at each point, making GA a suitable candidate for hyperparameter searches.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## 1. Initialize Hyperparameters
+
+YOLOv5 has about 30 hyperparameters used for various training settings. These are defined in `*.yaml` files in the `/data/hyps` directory. Better initial guesses will produce better final results, so it is important to initialize these values properly before evolving. If in doubt, simply use the default values, which are optimized for YOLOv5 COCO training from scratch.
+
+```yaml
+# YOLOv5 🚀 by Ultralytics, AGPL-3.0 license
+# Hyperparameters for low-augmentation COCO training from scratch
+# python train.py --batch 64 --cfg yolov5n6.yaml --weights '' --data coco.yaml --img 640 --epochs 300 --linear
+# See tutorials for hyperparameter evolution https://github.com/ultralytics/yolov5#tutorials
+
+lr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
+lrf: 0.01 # final OneCycleLR learning rate (lr0 * lrf)
+momentum: 0.937 # SGD momentum/Adam beta1
+weight_decay: 0.0005 # optimizer weight decay 5e-4
+warmup_epochs: 3.0 # warmup epochs (fractions ok)
+warmup_momentum: 0.8 # warmup initial momentum
+warmup_bias_lr: 0.1 # warmup initial bias lr
+box: 0.05 # box loss gain
+cls: 0.5 # cls loss gain
+cls_pw: 1.0 # cls BCELoss positive_weight
+obj: 1.0 # obj loss gain (scale with pixels)
+obj_pw: 1.0 # obj BCELoss positive_weight
+iou_t: 0.20 # IoU training threshold
+anchor_t: 4.0 # anchor-multiple threshold
+# anchors: 3 # anchors per output layer (0 to ignore)
+fl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
+hsv_h: 0.015 # image HSV-Hue augmentation (fraction)
+hsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
+hsv_v: 0.4 # image HSV-Value augmentation (fraction)
+degrees: 0.0 # image rotation (+/- deg)
+translate: 0.1 # image translation (+/- fraction)
+scale: 0.5 # image scale (+/- gain)
+shear: 0.0 # image shear (+/- deg)
+perspective: 0.0 # image perspective (+/- fraction), range 0-0.001
+flipud: 0.0 # image flip up-down (probability)
+fliplr: 0.5 # image flip left-right (probability)
+mosaic: 1.0 # image mosaic (probability)
+mixup: 0.0 # image mixup (probability)
+copy_paste: 0.0 # segment copy-paste (probability)
+```
+
+## 2. Define Fitness
+
+Fitness is the value we seek to maximize. In YOLOv5 we define a default fitness function as a weighted combination of metrics: `mAP@0.5` contributes 10% of the weight and `mAP@0.5:0.95` contributes the remaining 90%, with [Precision `P` and Recall `R`](https://en.wikipedia.org/wiki/Precision_and_recall) absent. You may adjust these as you see fit or use the default fitness definition in utils/metrics.py (recommended).
+
+```python
+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)
+```
+
+## 3. Evolve
+
+Evolution is performed about a base scenario which we seek to improve upon. The base scenario in this example is finetuning COCO128 for 10 epochs using pretrained YOLOv5s. The base scenario training command is:
+
+```bash
+python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache
+```
+
+To evolve hyperparameters **specific to this scenario**, starting from our initial values defined in **Section 1.**, and maximizing the fitness defined in **Section 2.**, append `--evolve`:
+
+```bash
+# Single-GPU
+python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --evolve
+
+# Multi-GPU
+for i in 0 1 2 3 4 5 6 7; do
+ sleep $(expr 30 \* $i) && # 30-second delay (optional)
+ echo 'Starting GPU '$i'...' &&
+ nohup python train.py --epochs 10 --data coco128.yaml --weights yolov5s.pt --cache --device $i --evolve > evolve_gpu_$i.log &
+done
+
+# Multi-GPU bash-while (not recommended)
+for i in 0 1 2 3 4 5 6 7; do
+ sleep $(expr 30 \* $i) && # 30-second delay (optional)
+ echo 'Starting GPU '$i'...' &&
+ "$(while true; do nohup python train.py... --device $i --evolve 1 > evolve_gpu_$i.log; done)" &
+done
+```
+
+The default evolution settings will run the base scenario 300 times, i.e. for 300 generations. You can modify generations via the `--evolve` argument, i.e. `python train.py --evolve 1000`.
+
+The main genetic operators are **crossover** and **mutation**. In this work mutation is used, with an 80% probability and a 0.04 variance to create new offspring based on a combination of the best parents from all previous generations. Results are logged to `runs/evolve/exp/evolve.csv`, and the highest fitness offspring is saved every generation as `runs/evolve/hyp_evolved.yaml`:
+
+```yaml
+# YOLOv5 Hyperparameter Evolution Results
+# Best generation: 287
+# Last generation: 300
+# metrics/precision, metrics/recall, metrics/mAP_0.5, metrics/mAP_0.5:0.95, val/box_loss, val/obj_loss, val/cls_loss
+# 0.54634, 0.55625, 0.58201, 0.33665, 0.056451, 0.042892, 0.013441
+
+lr0: 0.01 # initial learning rate (SGD=1E-2, Adam=1E-3)
+lrf: 0.2 # final OneCycleLR learning rate (lr0 * lrf)
+momentum: 0.937 # SGD momentum/Adam beta1
+weight_decay: 0.0005 # optimizer weight decay 5e-4
+warmup_epochs: 3.0 # warmup epochs (fractions ok)
+warmup_momentum: 0.8 # warmup initial momentum
+warmup_bias_lr: 0.1 # warmup initial bias lr
+box: 0.05 # box loss gain
+cls: 0.5 # cls loss gain
+cls_pw: 1.0 # cls BCELoss positive_weight
+obj: 1.0 # obj loss gain (scale with pixels)
+obj_pw: 1.0 # obj BCELoss positive_weight
+iou_t: 0.20 # IoU training threshold
+anchor_t: 4.0 # anchor-multiple threshold
+# anchors: 3 # anchors per output layer (0 to ignore)
+fl_gamma: 0.0 # focal loss gamma (efficientDet default gamma=1.5)
+hsv_h: 0.015 # image HSV-Hue augmentation (fraction)
+hsv_s: 0.7 # image HSV-Saturation augmentation (fraction)
+hsv_v: 0.4 # image HSV-Value augmentation (fraction)
+degrees: 0.0 # image rotation (+/- deg)
+translate: 0.1 # image translation (+/- fraction)
+scale: 0.5 # image scale (+/- gain)
+shear: 0.0 # image shear (+/- deg)
+perspective: 0.0 # image perspective (+/- fraction), range 0-0.001
+flipud: 0.0 # image flip up-down (probability)
+fliplr: 0.5 # image flip left-right (probability)
+mosaic: 1.0 # image mosaic (probability)
+mixup: 0.0 # image mixup (probability)
+copy_paste: 0.0 # segment copy-paste (probability)
+```
+
+We recommend a minimum of 300 generations of evolution for best results. Note that **evolution is generally expensive and time-consuming**, as the base scenario is trained hundreds of times, possibly requiring hundreds or thousands of GPU hours.
+
+## 4. Visualize
+
+`evolve.csv` is plotted as `evolve.png` by `utils.plots.plot_evolve()` after evolution finishes with one subplot per hyperparameter showing fitness (y-axis) vs hyperparameter values (x-axis). Yellow indicates higher concentrations. Vertical distributions indicate that a parameter has been disabled and does not mutate. This is user selectable in the `meta` dictionary in train.py, and is useful for fixing parameters and preventing them from evolving.
+
+
+
+## Environments
+
+YOLOv5 is designed to be run in 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):
+
+- **Notebooks** with free GPU:
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/docs/yolov5/tutorials/model_ensembling.md b/ultralytics/docs/yolov5/tutorials/model_ensembling.md
new file mode 100644
index 0000000000000000000000000000000000000000..efb77c49d34478b5377b1d0a7828d9781a2d1898
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/model_ensembling.md
@@ -0,0 +1,146 @@
+---
+comments: true
+description: Learn how to ensemble YOLOv5 models for improved mAP and Recall! Clone the repo, install requirements, and start testing and inference.
+keywords: YOLOv5, object detection, ensemble learning, mAP, Recall
+---
+
+📚 This guide explains how to use YOLOv5 🚀 **model ensembling** during testing and inference for improved mAP and Recall. UPDATED 25 September 2022.
+
+From [https://en.wikipedia.org/wiki/Ensemble_learning](https://en.wikipedia.org/wiki/Ensemble_learning):
+> Ensemble modeling is a process where multiple diverse models are created to predict an outcome, either by using many different modeling algorithms or using different training data sets. The ensemble model then aggregates the prediction of each base model and results in once final prediction for the unseen data. The motivation for using ensemble models is to reduce the generalization error of the prediction. As long as the base models are diverse and independent, the prediction error of the model decreases when the ensemble approach is used. The approach seeks the wisdom of crowds in making a prediction. Even though the ensemble model has multiple base models within the model, it acts and performs as a single model.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Test Normally
+
+Before ensembling we want to establish the baseline performance of a single model. This command tests YOLOv5x on COCO val2017 at image size 640 pixels. `yolov5x.pt` is the largest and most accurate model available. Other options are `yolov5s.pt`, `yolov5m.pt` and `yolov5l.pt`, or you own checkpoint from training a custom dataset `./weights/best.pt`. For details on all available models please see our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
+
+```bash
+python val.py --weights yolov5x.pt --data coco.yaml --img 640 --half
+```
+
+Output:
+
+```shell
+val: data=./data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True
+YOLOv5 🚀 v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Fusing layers...
+Model Summary: 476 layers, 87730285 parameters, 0 gradients
+
+val: Scanning '../datasets/coco/val2017' images and labels...4952 found, 48 missing, 0 empty, 0 corrupted: 100% 5000/5000 [00:01<00:00, 2846.03it/s]
+val: New cache created: ../datasets/coco/val2017.cache
+ Class Images Labels P R mAP@.5 mAP@.5:.95: 100% 157/157 [02:30<00:00, 1.05it/s]
+ all 5000 36335 0.746 0.626 0.68 0.49
+Speed: 0.1ms pre-process, 22.4ms inference, 1.4ms NMS per image at shape (32, 3, 640, 640) # <--- baseline speed
+
+Evaluating pycocotools mAP... saving runs/val/exp/yolov5x_predictions.json...
+...
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.504 # <--- baseline mAP
+ Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.688
+ Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.546
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.351
+ Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.551
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.644
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.382
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.628
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.681 # <--- baseline mAR
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.524
+ Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.735
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.826
+```
+
+## Ensemble Test
+
+Multiple pretrained models may be ensembled together at test and inference time by simply appending extra models to the `--weights` argument in any existing val.py or detect.py command. This example tests an ensemble of 2 models together:
+
+- YOLOv5x
+- YOLOv5l6
+
+```bash
+python val.py --weights yolov5x.pt yolov5l6.pt --data coco.yaml --img 640 --half
+```
+
+Output:
+
+```shell
+val: data=./data/coco.yaml, weights=['yolov5x.pt', 'yolov5l6.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.6, task=val, device=, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True
+YOLOv5 🚀 v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Fusing layers...
+Model Summary: 476 layers, 87730285 parameters, 0 gradients # Model 1
+Fusing layers...
+Model Summary: 501 layers, 77218620 parameters, 0 gradients # Model 2
+Ensemble created with ['yolov5x.pt', 'yolov5l6.pt'] # Ensemble notice
+
+val: Scanning '../datasets/coco/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupted: 100% 5000/5000 [00:00<00:00, 49695545.02it/s]
+ Class Images Labels P R mAP@.5 mAP@.5:.95: 100% 157/157 [03:58<00:00, 1.52s/it]
+ all 5000 36335 0.747 0.637 0.692 0.502
+Speed: 0.1ms pre-process, 39.5ms inference, 2.0ms NMS per image at shape (32, 3, 640, 640) # <--- ensemble speed
+
+Evaluating pycocotools mAP... saving runs/val/exp3/yolov5x_predictions.json...
+...
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.515 # <--- ensemble mAP
+ Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.699
+ Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.557
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.356
+ Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.563
+ Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.668
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.387
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.638
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.689 # <--- ensemble mAR
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.526
+ Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = 0.743
+ Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = 0.844
+```
+
+## Ensemble Inference
+
+Append extra models to the `--weights` argument to run ensemble inference:
+
+```bash
+python detect.py --weights yolov5x.pt yolov5l6.pt --img 640 --source data/images
+```
+
+Output:
+
+```bash
+detect: weights=['yolov5x.pt', 'yolov5l6.pt'], source=data/images, imgsz=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, update=False, project=runs/detect, name=exp, exist_ok=False, line_width=3, hide_labels=False, hide_conf=False, half=False
+YOLOv5 🚀 v5.0-267-g6a3ee7c torch 1.9.0+cu102 CUDA:0 (Tesla P100-PCIE-16GB, 16280.875MB)
+
+Fusing layers...
+Model Summary: 476 layers, 87730285 parameters, 0 gradients
+Fusing layers...
+Model Summary: 501 layers, 77218620 parameters, 0 gradients
+Ensemble created with ['yolov5x.pt', 'yolov5l6.pt']
+
+image 1/2 /content/yolov5/data/images/bus.jpg: 640x512 4 persons, 1 bus, 1 tie, Done. (0.063s)
+image 2/2 /content/yolov5/data/images/zidane.jpg: 384x640 3 persons, 2 ties, Done. (0.056s)
+Results saved to runs/detect/exp2
+Done. (0.223s)
+```
+
+
+
+## Environments
+
+YOLOv5 is designed to be run in 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):
+
+- **Notebooks** with free GPU:
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/docs/yolov5/tutorials/model_export.md b/ultralytics/docs/yolov5/tutorials/model_export.md
new file mode 100644
index 0000000000000000000000000000000000000000..192de82769992c159088a8ea03cb74a76dc1f0ab
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/model_export.md
@@ -0,0 +1,244 @@
+---
+comments: true
+description: Learn how to export a trained YOLOv5 model from PyTorch to different formats including TorchScript, ONNX, OpenVINO, TensorRT, and CoreML, and how to use these models.
+keywords: Ultralytics, YOLOv5, model export, PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, CoreML, TensorFlow
+---
+
+# TFLite, ONNX, CoreML, TensorRT Export
+
+📚 This guide explains how to export a trained YOLOv5 🚀 model from PyTorch to ONNX and TorchScript formats. UPDATED 8 December 2022.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+For [TensorRT](https://developer.nvidia.com/tensorrt) export example (requires GPU) see our Colab [notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb#scrollTo=VTRwsvA9u7ln&line=2&uniqifier=1) appendix section.
+
+## Formats
+
+YOLOv5 inference is officially supported in 11 formats:
+
+💡 ProTip: Export to ONNX or OpenVINO for up to 3x CPU speedup. See [CPU Benchmarks](https://github.com/ultralytics/yolov5/pull/6613). 💡 ProTip: Export to TensorRT for up to 5x GPU speedup. See [GPU Benchmarks](https://github.com/ultralytics/yolov5/pull/6963).
+
+| Format | `export.py --include` | Model |
+|:---------------------------------------------------------------------------|:----------------------|:--------------------------|
+| [PyTorch](https://pytorch.org/) | - | `yolov5s.pt` |
+| [TorchScript](https://pytorch.org/docs/stable/jit.html) | `torchscript` | `yolov5s.torchscript` |
+| [ONNX](https://onnx.ai/) | `onnx` | `yolov5s.onnx` |
+| [OpenVINO](https://docs.openvino.ai/latest/index.html) | `openvino` | `yolov5s_openvino_model/` |
+| [TensorRT](https://developer.nvidia.com/tensorrt) | `engine` | `yolov5s.engine` |
+| [CoreML](https://github.com/apple/coremltools) | `coreml` | `yolov5s.mlmodel` |
+| [TensorFlow SavedModel](https://www.tensorflow.org/guide/saved_model) | `saved_model` | `yolov5s_saved_model/` |
+| [TensorFlow GraphDef](https://www.tensorflow.org/api_docs/python/tf/Graph) | `pb` | `yolov5s.pb` |
+| [TensorFlow Lite](https://www.tensorflow.org/lite) | `tflite` | `yolov5s.tflite` |
+| [TensorFlow Edge TPU](https://coral.ai/docs/edgetpu/models-intro/) | `edgetpu` | `yolov5s_edgetpu.tflite` |
+| [TensorFlow.js](https://www.tensorflow.org/js) | `tfjs` | `yolov5s_web_model/` |
+| [PaddlePaddle](https://github.com/PaddlePaddle) | `paddle` | `yolov5s_paddle_model/` |
+
+## Benchmarks
+
+Benchmarks below run on a Colab Pro with the YOLOv5 tutorial notebook . To reproduce:
+
+```bash
+python benchmarks.py --weights yolov5s.pt --imgsz 640 --device 0
+```
+
+### Colab Pro V100 GPU
+
+```
+benchmarks: weights=/content/yolov5/yolov5s.pt, imgsz=640, batch_size=1, data=/content/yolov5/data/coco128.yaml, device=0, half=False, test=False
+Checking setup...
+YOLOv5 🚀 v6.1-135-g7926afc torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
+Setup complete ✅ (8 CPUs, 51.0 GB RAM, 46.7/166.8 GB disk)
+
+Benchmarks complete (458.07s)
+ Format mAP@0.5:0.95 Inference time (ms)
+0 PyTorch 0.4623 10.19
+1 TorchScript 0.4623 6.85
+2 ONNX 0.4623 14.63
+3 OpenVINO NaN NaN
+4 TensorRT 0.4617 1.89
+5 CoreML NaN NaN
+6 TensorFlow SavedModel 0.4623 21.28
+7 TensorFlow GraphDef 0.4623 21.22
+8 TensorFlow Lite NaN NaN
+9 TensorFlow Edge TPU NaN NaN
+10 TensorFlow.js NaN NaN
+```
+
+### Colab Pro CPU
+
+```
+benchmarks: weights=/content/yolov5/yolov5s.pt, imgsz=640, batch_size=1, data=/content/yolov5/data/coco128.yaml, device=cpu, half=False, test=False
+Checking setup...
+YOLOv5 🚀 v6.1-135-g7926afc torch 1.10.0+cu111 CPU
+Setup complete ✅ (8 CPUs, 51.0 GB RAM, 41.5/166.8 GB disk)
+
+Benchmarks complete (241.20s)
+ Format mAP@0.5:0.95 Inference time (ms)
+0 PyTorch 0.4623 127.61
+1 TorchScript 0.4623 131.23
+2 ONNX 0.4623 69.34
+3 OpenVINO 0.4623 66.52
+4 TensorRT NaN NaN
+5 CoreML NaN NaN
+6 TensorFlow SavedModel 0.4623 123.79
+7 TensorFlow GraphDef 0.4623 121.57
+8 TensorFlow Lite 0.4623 316.61
+9 TensorFlow Edge TPU NaN NaN
+10 TensorFlow.js NaN NaN
+```
+
+## Export a Trained YOLOv5 Model
+
+This command exports a pretrained YOLOv5s model to TorchScript and ONNX formats. `yolov5s.pt` is the 'small' model, the second-smallest model available. Other options are `yolov5n.pt`, `yolov5m.pt`, `yolov5l.pt` and `yolov5x.pt`, along with their P6 counterparts i.e. `yolov5s6.pt` or you own custom training checkpoint i.e. `runs/exp/weights/best.pt`. For details on all available models please see our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
+
+```bash
+python export.py --weights yolov5s.pt --include torchscript onnx
+```
+
+💡 ProTip: Add `--half` to export models at FP16 half precision for smaller file sizes
+
+Output:
+
+```bash
+export: data=data/coco128.yaml, weights=['yolov5s.pt'], imgsz=[640, 640], batch_size=1, device=cpu, half=False, inplace=False, train=False, keras=False, optimize=False, int8=False, dynamic=False, simplify=False, opset=12, verbose=False, workspace=4, nms=False, agnostic_nms=False, topk_per_class=100, topk_all=100, iou_thres=0.45, conf_thres=0.25, include=['torchscript', 'onnx']
+YOLOv5 🚀 v6.2-104-ge3e5122 Python-3.8.0 torch-1.12.1+cu113 CPU
+
+Downloading https://github.com/ultralytics/yolov5/releases/download/v6.2/yolov5s.pt to yolov5s.pt...
+100% 14.1M/14.1M [00:00<00:00, 274MB/s]
+
+Fusing layers...
+YOLOv5s summary: 213 layers, 7225885 parameters, 0 gradients
+
+PyTorch: starting from yolov5s.pt with output shape (1, 25200, 85) (14.1 MB)
+
+TorchScript: starting export with torch 1.12.1+cu113...
+TorchScript: export success ✅ 1.7s, saved as yolov5s.torchscript (28.1 MB)
+
+ONNX: starting export with onnx 1.12.0...
+ONNX: export success ✅ 2.3s, saved as yolov5s.onnx (28.0 MB)
+
+Export complete (5.5s)
+Results saved to /content/yolov5
+Detect: python detect.py --weights yolov5s.onnx
+Validate: python val.py --weights yolov5s.onnx
+PyTorch Hub: model = torch.hub.load('ultralytics/yolov5', 'custom', 'yolov5s.onnx')
+Visualize: https://netron.app/
+```
+
+The 3 exported models will be saved alongside the original PyTorch model:
+
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/docs/yolov5/tutorials/model_pruning_and_sparsity.md b/ultralytics/docs/yolov5/tutorials/model_pruning_and_sparsity.md
new file mode 100644
index 0000000000000000000000000000000000000000..44ea69622372dd10b9c67667376f30a247cfb6c3
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/model_pruning_and_sparsity.md
@@ -0,0 +1,109 @@
+---
+comments: true
+description: Improve YOLOv5 model efficiency by pruning with Ultralytics. Understand the process, conduct tests and view the impact on accuracy and sparsity. Test-maintained API environments.
+keywords: YOLOv5, YOLO, Ultralytics, model pruning, PyTorch, machine learning, deep learning, computer vision, object detection
+---
+
+📚 This guide explains how to apply **pruning** to YOLOv5 🚀 models. UPDATED 25 September 2022.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Test Normally
+
+Before pruning we want to establish a baseline performance to compare to. This command tests YOLOv5x on COCO val2017 at image size 640 pixels. `yolov5x.pt` is the largest and most accurate model available. Other options are `yolov5s.pt`, `yolov5m.pt` and `yolov5l.pt`, or you own checkpoint from training a custom dataset `./weights/best.pt`. For details on all available models please see our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints).
+
+```bash
+python val.py --weights yolov5x.pt --data coco.yaml --img 640 --half
+```
+
+Output:
+
+```shell
+val: data=/content/yolov5/data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, workers=8, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True, dnn=False
+YOLOv5 🚀 v6.0-224-g4c40933 torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
+
+Fusing layers...
+Model Summary: 444 layers, 86705005 parameters, 0 gradients
+val: Scanning '/content/datasets/coco/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupt: 100% 5000/5000 [00:00
+
+30% pruned output:
+
+```bash
+val: data=/content/yolov5/data/coco.yaml, weights=['yolov5x.pt'], batch_size=32, imgsz=640, conf_thres=0.001, iou_thres=0.65, task=val, device=, workers=8, single_cls=False, augment=False, verbose=False, save_txt=False, save_hybrid=False, save_conf=False, save_json=True, project=runs/val, name=exp, exist_ok=False, half=True, dnn=False
+YOLOv5 🚀 v6.0-224-g4c40933 torch 1.10.0+cu111 CUDA:0 (Tesla V100-SXM2-16GB, 16160MiB)
+
+Fusing layers...
+Model Summary: 444 layers, 86705005 parameters, 0 gradients
+Pruning model... 0.3 global sparsity
+val: Scanning '/content/datasets/coco/val2017.cache' images and labels... 4952 found, 48 missing, 0 empty, 0 corrupt: 100% 5000/5000 [00:00
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/docs/yolov5/tutorials/multi_gpu_training.md b/ultralytics/docs/yolov5/tutorials/multi_gpu_training.md
new file mode 100644
index 0000000000000000000000000000000000000000..6740f61da2974d509638cc724e194c62a7912144
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/multi_gpu_training.md
@@ -0,0 +1,189 @@
+---
+comments: true
+description: Learn how to train datasets on single or multiple GPUs using YOLOv5. Includes setup, training modes and result profiling for efficient leveraging of multiple GPUs.
+keywords: YOLOv5, multi-GPU Training, YOLOv5 training, deep learning, machine learning, object detection, Ultralytics
+---
+
+📚 This guide explains how to properly use **multiple** GPUs to train a dataset with YOLOv5 🚀 on single or multiple machine(s). UPDATED 25 December 2022.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+💡 ProTip! **Docker Image** is recommended for all Multi-GPU trainings. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+💡 ProTip! `torch.distributed.run` replaces `torch.distributed.launch` in **PyTorch>=1.9**. See [docs](https://pytorch.org/docs/stable/distributed.html) for details.
+
+## Training
+
+Select a pretrained model to start training from. Here we select [YOLOv5s](https://github.com/ultralytics/yolov5/blob/master/models/yolov5s.yaml), the smallest and fastest model available. See our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints) for a full comparison of all models. We will train this model with Multi-GPU on the [COCO](https://github.com/ultralytics/yolov5/blob/master/data/scripts/get_coco.sh) dataset.
+
+
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
+
+## Credits
+
+I would like to thank @MagicFrogSJTU, who did all the heavy lifting, and @glenn-jocher for guiding us along the way.
diff --git a/ultralytics/docs/yolov5/tutorials/neural_magic_pruning_quantization.md b/ultralytics/docs/yolov5/tutorials/neural_magic_pruning_quantization.md
new file mode 100644
index 0000000000000000000000000000000000000000..a07547723af833ad5d32c15762f3ffe723a76201
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/neural_magic_pruning_quantization.md
@@ -0,0 +1,264 @@
+---
+comments: true
+description: Explore how to achieve exceptional AI performance with DeepSparse's incredible inference speed. Discover how to deploy YOLOv5, and learn about model sparsification and fine-tuning with SparseML.
+keywords: YOLOv5, DeepSparse, Ultralytics, Neural Magic, sparsification, inference runtime, deep learning, deployment, model fine-tuning, SparseML, AI performance, GPU-class performance
+---
+
+
+
+Welcome to software-delivered AI.
+
+This guide explains how to deploy YOLOv5 with Neural Magic's DeepSparse.
+
+DeepSparse is an inference runtime with exceptional performance on CPUs. For instance, compared to the ONNX Runtime baseline, DeepSparse offers a 5.8x speed-up for YOLOv5s, running on the same machine!
+
+
+ 
+
+ 
+
+
+
+
+For all inference options see YOLOv5 `AutoShape()` forward [method](https://github.com/ultralytics/yolov5/blob/30e4c4f09297b67afedf8b2bcd851833ddc9dead/models/common.py#L243-L252).
+
+### Inference Settings
+
+YOLOv5 models contain various inference attributes such as **confidence threshold**, **IoU threshold**, etc. which can be set by:
+
+```python
+model.conf = 0.25 # NMS confidence threshold
+ iou = 0.45 # NMS IoU threshold
+ agnostic = False # NMS class-agnostic
+ multi_label = False # NMS multiple labels per box
+ classes = None # (optional list) filter by class, i.e. = [0, 15, 16] for COCO persons, cats and dogs
+ max_det = 1000 # maximum number of detections per image
+ amp = False # Automatic Mixed Precision (AMP) inference
+
+results = model(im, size=320) # custom inference size
+```
+
+### Device
+
+Models can be transferred to any device after creation:
+
+```python
+model.cpu() # CPU
+model.cuda() # GPU
+model.to(device) # i.e. device=torch.device(0)
+```
+
+Models can also be created directly on any `device`:
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', device='cpu') # load on CPU
+```
+
+💡 ProTip: Input images are automatically transferred to the correct model device before inference.
+
+### Silence Outputs
+
+Models can be loaded silently with `_verbose=False`:
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', _verbose=False) # load silently
+```
+
+### Input Channels
+
+To load a pretrained YOLOv5s model with 4 input channels rather than the default 3:
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', channels=4)
+```
+
+In this case the model will be composed of pretrained weights **except for** the very first input layer, which is no longer the same shape as the pretrained input layer. The input layer will remain initialized by random weights.
+
+### Number of Classes
+
+To load a pretrained YOLOv5s model with 10 output classes rather than the default 80:
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', classes=10)
+```
+
+In this case the model will be composed of pretrained weights **except for** the output layers, which are no longer the same shape as the pretrained output layers. The output layers will remain initialized by random weights.
+
+### Force Reload
+
+If you run into problems with the above steps, setting `force_reload=True` may help by discarding the existing cache and force a fresh download of the latest YOLOv5 version from PyTorch Hub.
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', force_reload=True) # force reload
+```
+
+### Screenshot Inference
+
+To run inference on your desktop screen:
+
+```python
+import torch
+from PIL import ImageGrab
+
+# Model
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
+
+# Image
+im = ImageGrab.grab() # take a screenshot
+
+# Inference
+results = model(im)
+```
+
+### Multi-GPU Inference
+
+YOLOv5 models can be loaded to multiple GPUs in parallel with threaded inference:
+
+```python
+import torch
+import threading
+
+def run(model, im):
+ results = model(im)
+ results.save()
+
+# Models
+model0 = torch.hub.load('ultralytics/yolov5', 'yolov5s', device=0)
+model1 = torch.hub.load('ultralytics/yolov5', 'yolov5s', device=1)
+
+# Inference
+threading.Thread(target=run, args=[model0, 'https://ultralytics.com/images/zidane.jpg'], daemon=True).start()
+threading.Thread(target=run, args=[model1, 'https://ultralytics.com/images/bus.jpg'], daemon=True).start()
+```
+
+### Training
+
+To load a YOLOv5 model for training rather than inference, set `autoshape=False`. To load a model with randomly initialized weights (to train from scratch) use `pretrained=False`. You must provide your own training script in this case. Alternatively see our YOLOv5 [Train Custom Data Tutorial](https://docs.ultralytics.com/yolov5/tutorials/train_custom_data) for model training.
+
+```python
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', autoshape=False) # load pretrained
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s', autoshape=False, pretrained=False) # load scratch
+```
+
+### Base64 Results
+
+For use with API services. See https://github.com/ultralytics/yolov5/pull/2291 and [Flask REST API](https://github.com/ultralytics/yolov5/tree/master/utils/flask_rest_api) example for details.
+
+```python
+results = model(im) # inference
+
+results.ims # array of original images (as np array) passed to model for inference
+results.render() # updates results.ims with boxes and labels
+for im in results.ims:
+ buffered = BytesIO()
+ im_base64 = Image.fromarray(im)
+ im_base64.save(buffered, format="JPEG")
+ print(base64.b64encode(buffered.getvalue()).decode('utf-8')) # base64 encoded image with results
+```
+
+### Cropped Results
+
+Results can be returned and saved as detection crops:
+
+```python
+results = model(im) # inference
+crops = results.crop(save=True) # cropped detections dictionary
+```
+
+### Pandas Results
+
+Results can be returned as [Pandas DataFrames](https://pandas.pydata.org/):
+
+```python
+results = model(im) # inference
+results.pandas().xyxy[0] # Pandas DataFrame
+```
+
+
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/docs/yolov5/tutorials/roboflow_datasets_integration.md b/ultralytics/docs/yolov5/tutorials/roboflow_datasets_integration.md
new file mode 100644
index 0000000000000000000000000000000000000000..c2b11f36878df5149fbb28ce3476918d41d8d089
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/roboflow_datasets_integration.md
@@ -0,0 +1,52 @@
+---
+comments: true
+description: Learn how to use Roboflow for organizing, labelling, preparing, and hosting your datasets for YOLOv5 models. Enhance your model deployments with our platform.
+keywords: Ultralytics, YOLOv5, Roboflow, data organization, data labelling, data preparation, model deployment, active learning, machine learning pipeline
+---
+
+# Roboflow Datasets
+
+You can now use Roboflow to organize, label, prepare, version, and host your datasets for training YOLOv5 🚀 models. Roboflow is free to use with YOLOv5 if you make your workspace public. UPDATED 7 June 2023.
+
+!!! warning
+
+ Roboflow users can use Ultralytics under the [AGPL license](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) or procure an [Enterprise license](https://ultralytics.com/license) directly from Ultralytics. Be aware that Roboflow does **not** provide Ultralytics licenses, and it is the responsibility of the user to ensure appropriate licensing.
+
+## Upload
+
+You can upload your data to Roboflow via [web UI](https://docs.roboflow.com/adding-data), [REST API](https://docs.roboflow.com/adding-data/upload-api), or [Python](https://docs.roboflow.com/python).
+
+## Labeling
+
+After uploading data to Roboflow, you can label your data and review previous labels.
+
+[](https://roboflow.com/annotate)
+
+## Versioning
+
+You can make versions of your dataset with different preprocessing and offline augmentation options. YOLOv5 does online augmentations natively, so be intentional when layering Roboflow's offline augs on top.
+
+
+
+## Exporting Data
+
+You can download your data in YOLOv5 format to quickly begin training.
+
+```
+from roboflow import Roboflow
+rf = Roboflow(api_key="YOUR API KEY HERE")
+project = rf.workspace().project("YOUR PROJECT")
+dataset = project.version("YOUR VERSION").download("yolov5")
+```
+
+## Custom Training
+
+We have released a custom training tutorial demonstrating all of the above capabilities. You can access the code here:
+
+[](https://colab.research.google.com/github/roboflow-ai/yolov5-custom-training-tutorial/blob/main/yolov5-custom-training.ipynb)
+
+## Active Learning
+
+The real world is messy and your model will invariably encounter situations your dataset didn't anticipate. Using [active learning](https://blog.roboflow.com/what-is-active-learning/) is an important strategy to iteratively improve your dataset and model. With the Roboflow and YOLOv5 integration, you can quickly make improvements on your model deployments by using a battle tested machine learning pipeline.
+
+
+
+### PyTorch Hub TTA
+
+TTA is automatically integrated into all [YOLOv5 PyTorch Hub](https://pytorch.org/hub/ultralytics_yolov5) models, and can be accessed by passing `augment=True` at inference time.
+
+```python
+import torch
+
+# Model
+model = torch.hub.load('ultralytics/yolov5', 'yolov5s') # or yolov5m, yolov5x, custom
+
+# Images
+img = 'https://ultralytics.com/images/zidane.jpg' # or file, PIL, OpenCV, numpy, multiple
+
+# Inference
+results = model(img, augment=True) # <--- TTA inference
+
+# Results
+results.print() # or .show(), .save(), .crop(), .pandas(), etc.
+```
+
+### Customize
+
+You can customize the TTA ops applied in the YOLOv5 `forward_augment()` method [here](https://github.com/ultralytics/yolov5/blob/8c6f9e15bfc0000d18b976a95b9d7c17d407ec91/models/yolo.py#L125-L137).
+
+## Environments
+
+YOLOv5 is designed to be run in 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):
+
+- **Notebooks** with free GPU:
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/docs/yolov5/tutorials/tips_for_best_training_results.md b/ultralytics/docs/yolov5/tutorials/tips_for_best_training_results.md
new file mode 100644
index 0000000000000000000000000000000000000000..11538808fc0a4f9600ba6b4acc74e623256d8853
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/tips_for_best_training_results.md
@@ -0,0 +1,65 @@
+---
+comments: true
+description: Our comprehensive guide provides insights on how to train your YOLOv5 system to get the best mAP. Master dataset preparation, model selection, training settings, and more.
+keywords: Ultralytics, YOLOv5, Training guide, dataset preparation, model selection, training settings, mAP results, Machine Learning, Object Detection
+---
+
+📚 This guide explains how to produce the best mAP and training results with YOLOv5 🚀. UPDATED 25 May 2022.
+
+Most of the time good results can be obtained with no changes to the models or training settings, **provided your dataset is sufficiently large and well labelled**. If at first you don't get good results, there are steps you might be able to take to improve, but we always recommend users **first train with all default settings** before considering any changes. This helps establish a performance baseline and spot areas for improvement.
+
+If you have questions about your training results **we recommend you provide the maximum amount of information possible** if you expect a helpful response, including results plots (train losses, val losses, P, R, mAP), PR curve, confusion matrix, training mosaics, test results and dataset statistics images such as labels.png. All of these are located in your `project/name` directory, typically `yolov5/runs/train/exp`.
+
+We've put together a full guide for users looking to get the best results on their YOLOv5 trainings below.
+
+## Dataset
+
+- **Images per class.** ≥ 1500 images per class recommended
+- **Instances per class.** ≥ 10000 instances (labeled objects) per class recommended
+- **Image variety.** Must be representative of deployed environment. For real-world use cases we recommend images from different times of day, different seasons, different weather, different lighting, different angles, different sources (scraped online, collected locally, different cameras) etc.
+- **Label consistency.** All instances of all classes in all images must be labelled. Partial labelling will not work.
+- **Label accuracy.** Labels must closely enclose each object. No space should exist between an object and it's bounding box. No objects should be missing a label.
+- **Label verification.** View `train_batch*.jpg` on train start to verify your labels appear correct, i.e. see [example](https://docs.ultralytics.com/yolov5/tutorials/train_custom_data#local-logging) mosaic.
+- **Background images.** Background images are images with no objects that are added to a dataset to reduce False Positives (FP). We recommend about 0-10% background images to help reduce FPs (COCO has 1000 background images for reference, 1% of the total). No labels are required for background images.
+
+
+
+## Model Selection
+
+Larger models like YOLOv5x and [YOLOv5x6](https://github.com/ultralytics/yolov5/releases/tag/v5.0) will produce better results in nearly all cases, but have more parameters, require more CUDA memory to train, and are slower to run. For **mobile** deployments we recommend YOLOv5s/m, for **cloud** deployments we recommend YOLOv5l/x. See our README [table](https://github.com/ultralytics/yolov5#pretrained-checkpoints) for a full comparison of all models.
+
+
+
+
+### 4. Visualize
+
+#### Comet Logging and Visualization 🌟 NEW
+
+[Comet](https://bit.ly/yolov5-readme-comet) is now fully integrated with YOLOv5. Track and visualize model metrics in real time, save your hyperparameters, datasets, and model checkpoints, and visualize your model predictions with [Comet Custom Panels](https://bit.ly/yolov5-colab-comet-panels)! Comet makes sure you never lose track of your work and makes it easy to share results and collaborate across teams of all sizes!
+
+Getting started is easy:
+
+```shell
+pip install comet_ml # 1. install
+export COMET_API_KEY=
+
+#### ClearML Logging and Automation 🌟 NEW
+
+[ClearML](https://cutt.ly/yolov5-notebook-clearml) is completely integrated into YOLOv5 to track your experimentation, manage dataset versions and even remotely execute training runs. To enable ClearML:
+
+- `pip install clearml`
+- run `clearml-init` to connect to a ClearML server (**deploy your own open-source server [here](https://github.com/allegroai/clearml-server)**, or use our free hosted server [here](https://cutt.ly/yolov5-notebook-clearml))
+
+You'll get all the great expected features from an experiment manager: live updates, model upload, experiment comparison etc. but ClearML also tracks uncommitted changes and installed packages for example. Thanks to that ClearML Tasks (which is what we call experiments) are also reproducible on different machines! With only 1 extra line, we can schedule a YOLOv5 training task on a queue to be executed by any number of ClearML Agents (workers).
+
+You can use ClearML Data to version your dataset and then pass it to YOLOv5 simply using its unique ID. This will help you keep track of your data without adding extra hassle. Explore the [ClearML Tutorial](https://docs.ultralytics.com/yolov5/tutorials/clearml_logging_integration) for details!
+
+
+
+
+#### Local Logging
+
+Training results are automatically logged with [Tensorboard](https://www.tensorflow.org/tensorboard) and [CSV](https://github.com/ultralytics/yolov5/pull/4148) loggers to `runs/train`, with a new experiment directory created for each new training as `runs/train/exp2`, `runs/train/exp3`, etc.
+
+This directory contains train and val statistics, mosaics, labels, predictions and augmented mosaics, as well as metrics and charts including precision-recall (PR) curves and confusion matrices.
+
+
+
+Results file `results.csv` is updated after each epoch, and then plotted as `results.png` (below) after training completes. You can also plot any `results.csv` file manually:
+
+```python
+from utils.plots import plot_results
+
+plot_results('path/to/results.csv') # plot 'results.csv' as 'results.png'
+```
+
+
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/docs/yolov5/tutorials/transfer_learning_with_frozen_layers.md b/ultralytics/docs/yolov5/tutorials/transfer_learning_with_frozen_layers.md
new file mode 100644
index 0000000000000000000000000000000000000000..a40fa4ba9136909ef4034794d468b2e453f084e2
--- /dev/null
+++ b/ultralytics/docs/yolov5/tutorials/transfer_learning_with_frozen_layers.md
@@ -0,0 +1,154 @@
+---
+comments: true
+description: Learn to freeze YOLOv5 layers for efficient transfer learning. Optimize your model retraining with less resources and faster training times.
+keywords: YOLOv5, freeze layers, transfer learning, model retraining, Ultralytics
+---
+
+📚 This guide explains how to **freeze** YOLOv5 🚀 layers when **transfer learning**. Transfer learning is a useful way to quickly retrain a model on new data without having to retrain the entire network. Instead, part of the initial weights are frozen in place, and the rest of the weights are used to compute loss and are updated by the optimizer. This requires less resources than normal training and allows for faster training times, though it may also result in reductions to final trained accuracy. UPDATED 25 September 2022.
+
+## Before You Start
+
+Clone repo and install [requirements.txt](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) in a [**Python>=3.8.0**](https://www.python.org/) environment, including [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/). [Models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) download automatically from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5 # clone
+cd yolov5
+pip install -r requirements.txt # install
+```
+
+## Freeze Backbone
+
+All layers that match the train.py `freeze` list in train.py will be frozen by setting their gradients to zero before training starts.
+
+```python
+ # Freeze
+ freeze = [f'model.{x}.' for x in range(freeze)] # layers to freeze
+ for k, v in model.named_parameters():
+ v.requires_grad = True # train all layers
+ if any(x in k for x in freeze):
+ print(f'freezing {k}')
+ v.requires_grad = False
+```
+
+To see a list of module names:
+
+```python
+for k, v in model.named_parameters():
+ print(k)
+
+# Output
+model.0.conv.conv.weight
+model.0.conv.bn.weight
+model.0.conv.bn.bias
+model.1.conv.weight
+model.1.bn.weight
+model.1.bn.bias
+model.2.cv1.conv.weight
+model.2.cv1.bn.weight
+...
+model.23.m.0.cv2.bn.weight
+model.23.m.0.cv2.bn.bias
+model.24.m.0.weight
+model.24.m.0.bias
+model.24.m.1.weight
+model.24.m.1.bias
+model.24.m.2.weight
+model.24.m.2.bias
+```
+
+Looking at the model architecture we can see that the model backbone is layers 0-9:
+
+```yaml
+# YOLOv5 backbone
+ backbone:
+ # [from, number, module, args]
+ [[-1, 1, Focus, [64, 3]], # 0-P1/2
+ [-1, 1, Conv, [128, 3, 2]], # 1-P2/4
+ [-1, 3, BottleneckCSP, [128]],
+ [-1, 1, Conv, [256, 3, 2]], # 3-P3/8
+ [-1, 9, BottleneckCSP, [256]],
+ [-1, 1, Conv, [512, 3, 2]], # 5-P4/16
+ [-1, 9, BottleneckCSP, [512]],
+ [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32
+ [-1, 1, SPP, [1024, [5, 9, 13]]],
+ [-1, 3, BottleneckCSP, [1024, False]], # 9
+ ]
+
+ # YOLOv5 head
+ head:
+ [[-1, 1, Conv, [512, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 6], 1, Concat, [1]], # cat backbone P4
+ [-1, 3, BottleneckCSP, [512, False]], # 13
+
+ [-1, 1, Conv, [256, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 4], 1, Concat, [1]], # cat backbone P3
+ [-1, 3, BottleneckCSP, [256, False]], # 17 (P3/8-small)
+
+ [-1, 1, Conv, [256, 3, 2]],
+ [[-1, 14], 1, Concat, [1]], # cat head P4
+ [-1, 3, BottleneckCSP, [512, False]], # 20 (P4/16-medium)
+
+ [-1, 1, Conv, [512, 3, 2]],
+ [[-1, 10], 1, Concat, [1]], # cat head P5
+ [-1, 3, BottleneckCSP, [1024, False]], # 23 (P5/32-large)
+
+ [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)
+ ]
+```
+
+so we can define the freeze list to contain all modules with 'model.0.' - 'model.9.' in their names:
+
+```bash
+python train.py --freeze 10
+```
+
+## Freeze All Layers
+
+To freeze the full model except for the final output convolution layers in Detect(), we set freeze list to contain all modules with 'model.0.' - 'model.23.' in their names:
+
+```bash
+python train.py --freeze 24
+```
+
+## Results
+
+We train YOLOv5m on VOC on both of the above scenarios, along with a default model (no freezing), starting from the official COCO pretrained `--weights yolov5m.pt`:
+
+```python
+train.py --batch 48 --weights yolov5m.pt --data voc.yaml --epochs 50 --cache --img 512 --hyp hyp.finetune.yaml
+```
+
+### Accuracy Comparison
+
+The results show that freezing speeds up training, but reduces final accuracy slightly.
+
+
+
+
+
+
+
+### GPU Utilization Comparison
+
+Interestingly, the more modules are frozen the less GPU memory is required to train, and the lower GPU utilization. This indicates that larger models, or models trained at larger --image-size may benefit from freezing in order to train faster.
+
+
+
+
+
+## Environments
+
+YOLOv5 is designed to be run in 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):
+
+- **Notebooks** with free GPU:
+- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
+- **Amazon** Deep Learning AMI. See [AWS Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/aws_quickstart_tutorial/)
+- **Docker Image**. See [Docker Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/docker_image_quickstart_tutorial/)
+
+## 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](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py) and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/ultralytics/docs/zh/index.md b/ultralytics/docs/zh/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..82db8274245844f78064e4aacf0aa68cf51ef570
--- /dev/null
+++ b/ultralytics/docs/zh/index.md
@@ -0,0 +1,69 @@
+---
+comments: true
+description: 探索Ultralytics YOLOv8的完整指南，这是一个高速、高精度的目标检测和图像分割模型。包括安装、预测、训练教程等。
+keywords: Ultralytics, YOLOv8, 目标检测, 图像分割, 机器学习, 深度学习, 计算机视觉, YOLOv8安装, YOLOv8预测, YOLOv8训练, YOLO历史, YOLO许可
+---
+
+# Ultralytics 中文文档
+
+
+
+介绍 [Ultralytics](https://ultralytics.com) [YOLOv8](https://github.com/ultralytics/ultralytics)，这是备受好评的实时目标检测和图像分割模型的最新版本。YOLOv8基于深度学习和计算机视觉的前沿进展，提供了无与伦比的速度和准确性表现。它的精简设计使其适用于各种应用，并且可以轻松适应不同的硬件平台，从边缘设备到云API。
+
+探索YOLOv8文档，这是一个全面的资源，旨在帮助您理解并利用其功能和能力。无论您是经验丰富的机器学习从业者还是新入行者，该中心旨在最大化YOLOv8在您的项目中的潜力。
+
+## 从哪里开始
+
+- **安装** `ultralytics` 并通过 pip 在几分钟内开始运行 [:material-clock-fast: 开始使用](https://docs.ultralytics.com/quickstart/){ .md-button }
+- **预测** 使用YOLOv8预测新的图像和视频 [:octicons-image-16: 在图像上预测](https://docs.ultralytics.com/predict/){ .md-button }
+- **训练** 在您自己的自定义数据集上训练新的YOLOv8模型 [:fontawesome-solid-brain: 训练模型](https://docs.ultralytics.com/modes/train/){ .md-button }
+- **探索** YOLOv8的任务，如分割、分类、姿态和跟踪 [:material-magnify-expand: 探索任务](https://docs.ultralytics.com/tasks/){ .md-button }
+
+
+
+
+
+ 观看： 在Google Colab中如何训练您的自定义数据集上的YOLOv8模型。
+
+ 
+ 
+
+
+
+
+
+
+## Advanced Usage
+
+For more advanced usage, including real-time video processing, please refer to the `main.py` script's command-line arguments.
+
+## Contributing
+
+We welcome contributions to improve this demo! Please submit issues and pull requests for bug reports, feature requests, or submitting a new algorithm enhancement.
+
+## License
+
+This project is licensed under the AGPL-3.0 License - see the [LICENSE](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) file for details.
+
+## Acknowledgments
+
+- The YOLOv8-Segmentation-ONNXRuntime-Python demo is contributed by GitHub user [jamjamjon](https://github.com/jamjamjon).
+- Thanks to the ONNX Runtime community for providing a robust and efficient inference engine.
diff --git a/ultralytics/examples/YOLOv8-Segmentation-ONNXRuntime-Python/main.py b/ultralytics/examples/YOLOv8-Segmentation-ONNXRuntime-Python/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..b13eab35965c11a5d0fb3a8eba5cf11618f3b395
--- /dev/null
+++ b/ultralytics/examples/YOLOv8-Segmentation-ONNXRuntime-Python/main.py
@@ -0,0 +1,321 @@
+import argparse
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+
+from ultralytics.utils import ASSETS, yaml_load
+from ultralytics.utils.checks import check_yaml
+from ultralytics.utils.plotting import Colors
+
+
+class YOLOv8Seg:
+ """YOLOv8 segmentation model."""
+
+ def __init__(self, onnx_model):
+ """
+ Initialization.
+
+ Args:
+ onnx_model (str): Path to the ONNX model.
+ """
+
+ # Build Ort session
+ self.session = ort.InferenceSession(onnx_model,
+ providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
+ if ort.get_device() == 'GPU' else ['CPUExecutionProvider'])
+
+ # Numpy dtype: support both FP32 and FP16 onnx model
+ self.ndtype = np.half if self.session.get_inputs()[0].type == 'tensor(float16)' else np.single
+
+ # Get model width and height(YOLOv8-seg only has one input)
+ self.model_height, self.model_width = [x.shape for x in self.session.get_inputs()][0][-2:]
+
+ # Load COCO class names
+ self.classes = yaml_load(check_yaml('coco128.yaml'))['names']
+
+ # Create color palette
+ self.color_palette = Colors()
+
+ def __call__(self, im0, conf_threshold=0.4, iou_threshold=0.45, nm=32):
+ """
+ The whole pipeline: pre-process -> inference -> post-process.
+
+ Args:
+ im0 (Numpy.ndarray): original input image.
+ conf_threshold (float): confidence threshold for filtering predictions.
+ iou_threshold (float): iou threshold for NMS.
+ nm (int): the number of masks.
+
+ Returns:
+ boxes (List): list of bounding boxes.
+ segments (List): list of segments.
+ masks (np.ndarray): [N, H, W], output masks.
+ """
+
+ # Pre-process
+ im, ratio, (pad_w, pad_h) = self.preprocess(im0)
+
+ # Ort inference
+ preds = self.session.run(None, {self.session.get_inputs()[0].name: im})
+
+ # Post-process
+ boxes, segments, masks = self.postprocess(preds,
+ im0=im0,
+ ratio=ratio,
+ pad_w=pad_w,
+ pad_h=pad_h,
+ conf_threshold=conf_threshold,
+ iou_threshold=iou_threshold,
+ nm=nm)
+ return boxes, segments, masks
+
+ def preprocess(self, img):
+ """
+ Pre-processes the input image.
+
+ Args:
+ img (Numpy.ndarray): image about to be processed.
+
+ Returns:
+ img_process (Numpy.ndarray): image preprocessed for inference.
+ ratio (tuple): width, height ratios in letterbox.
+ pad_w (float): width padding in letterbox.
+ pad_h (float): height padding in letterbox.
+ """
+
+ # Resize and pad input image using letterbox() (Borrowed from Ultralytics)
+ shape = img.shape[:2] # original image shape
+ new_shape = (self.model_height, self.model_width)
+ r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
+ ratio = r, r
+ new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
+ pad_w, pad_h = (new_shape[1] - new_unpad[0]) / 2, (new_shape[0] - new_unpad[1]) / 2 # wh padding
+ if shape[::-1] != new_unpad: # resize
+ img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
+ top, bottom = int(round(pad_h - 0.1)), int(round(pad_h + 0.1))
+ left, right = int(round(pad_w - 0.1)), int(round(pad_w + 0.1))
+ img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114))
+
+ # Transforms: HWC to CHW -> BGR to RGB -> div(255) -> contiguous -> add axis(optional)
+ img = np.ascontiguousarray(np.einsum('HWC->CHW', img)[::-1], dtype=self.ndtype) / 255.0
+ img_process = img[None] if len(img.shape) == 3 else img
+ return img_process, ratio, (pad_w, pad_h)
+
+ def postprocess(self, preds, im0, ratio, pad_w, pad_h, conf_threshold, iou_threshold, nm=32):
+ """
+ Post-process the prediction.
+
+ Args:
+ preds (Numpy.ndarray): predictions come from ort.session.run().
+ im0 (Numpy.ndarray): [h, w, c] original input image.
+ ratio (tuple): width, height ratios in letterbox.
+ pad_w (float): width padding in letterbox.
+ pad_h (float): height padding in letterbox.
+ conf_threshold (float): conf threshold.
+ iou_threshold (float): iou threshold.
+ nm (int): the number of masks.
+
+ Returns:
+ boxes (List): list of bounding boxes.
+ segments (List): list of segments.
+ masks (np.ndarray): [N, H, W], output masks.
+ """
+ x, protos = preds[0], preds[1] # Two outputs: predictions and protos
+
+ # Transpose the first output: (Batch_size, xywh_conf_cls_nm, Num_anchors) -> (Batch_size, Num_anchors, xywh_conf_cls_nm)
+ x = np.einsum('bcn->bnc', x)
+
+ # Predictions filtering by conf-threshold
+ x = x[np.amax(x[..., 4:-nm], axis=-1) > conf_threshold]
+
+ # Create a new matrix which merge these(box, score, cls, nm) into one
+ # For more details about `numpy.c_()`: https://numpy.org/doc/1.26/reference/generated/numpy.c_.html
+ x = np.c_[x[..., :4], np.amax(x[..., 4:-nm], axis=-1), np.argmax(x[..., 4:-nm], axis=-1), x[..., -nm:]]
+
+ # NMS filtering
+ x = x[cv2.dnn.NMSBoxes(x[:, :4], x[:, 4], conf_threshold, iou_threshold)]
+
+ # Decode and return
+ if len(x) > 0:
+
+ # Bounding boxes format change: cxcywh -> xyxy
+ x[..., [0, 1]] -= x[..., [2, 3]] / 2
+ x[..., [2, 3]] += x[..., [0, 1]]
+
+ # Rescales bounding boxes from model shape(model_height, model_width) to the shape of original image
+ x[..., :4] -= [pad_w, pad_h, pad_w, pad_h]
+ x[..., :4] /= min(ratio)
+
+ # Bounding boxes boundary clamp
+ x[..., [0, 2]] = x[:, [0, 2]].clip(0, im0.shape[1])
+ x[..., [1, 3]] = x[:, [1, 3]].clip(0, im0.shape[0])
+
+ # Process masks
+ masks = self.process_mask(protos[0], x[:, 6:], x[:, :4], im0.shape)
+
+ # Masks -> Segments(contours)
+ segments = self.masks2segments(masks)
+ return x[..., :6], segments, masks # boxes, segments, masks
+ else:
+ return [], [], []
+
+ @staticmethod
+ def masks2segments(masks):
+ """
+ It takes a list of masks(n,h,w) and returns a list of segments(n,xy) (Borrowed from
+ https://github.com/ultralytics/ultralytics/blob/465df3024f44fa97d4fad9986530d5a13cdabdca/ultralytics/utils/ops.py#L750)
+
+ Args:
+ masks (numpy.ndarray): the output of the model, which is a tensor of shape (batch_size, 160, 160).
+
+ Returns:
+ segments (List): list of segment masks.
+ """
+ segments = []
+ for x in masks.astype('uint8'):
+ c = cv2.findContours(x, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[0] # CHAIN_APPROX_SIMPLE
+ if c:
+ c = np.array(c[np.array([len(x) for x in c]).argmax()]).reshape(-1, 2)
+ else:
+ c = np.zeros((0, 2)) # no segments found
+ segments.append(c.astype('float32'))
+ return segments
+
+ @staticmethod
+ def crop_mask(masks, boxes):
+ """
+ It takes a mask and a bounding box, and returns a mask that is cropped to the bounding box. (Borrowed from
+ https://github.com/ultralytics/ultralytics/blob/465df3024f44fa97d4fad9986530d5a13cdabdca/ultralytics/utils/ops.py#L599)
+
+ Args:
+ masks (Numpy.ndarray): [n, h, w] tensor of masks.
+ boxes (Numpy.ndarray): [n, 4] tensor of bbox coordinates in relative point form.
+
+ Returns:
+ (Numpy.ndarray): The masks are being cropped to the bounding box.
+ """
+ n, h, w = masks.shape
+ x1, y1, x2, y2 = np.split(boxes[:, :, None], 4, 1)
+ r = np.arange(w, dtype=x1.dtype)[None, None, :]
+ c = np.arange(h, dtype=x1.dtype)[None, :, None]
+ return masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))
+
+ def process_mask(self, protos, masks_in, bboxes, im0_shape):
+ """
+ Takes the output of the mask head, and applies the mask to the bounding boxes. This produces masks of higher quality
+ but is slower. (Borrowed from https://github.com/ultralytics/ultralytics/blob/465df3024f44fa97d4fad9986530d5a13cdabdca/ultralytics/utils/ops.py#L618)
+
+ Args:
+ protos (numpy.ndarray): [mask_dim, mask_h, mask_w].
+ masks_in (numpy.ndarray): [n, mask_dim], n is number of masks after nms.
+ bboxes (numpy.ndarray): bboxes re-scaled to original image shape.
+ im0_shape (tuple): the size of the input image (h,w,c).
+
+ Returns:
+ (numpy.ndarray): The upsampled masks.
+ """
+ c, mh, mw = protos.shape
+ masks = np.matmul(masks_in, protos.reshape((c, -1))).reshape((-1, mh, mw)).transpose(1, 2, 0) # HWN
+ masks = np.ascontiguousarray(masks)
+ masks = self.scale_mask(masks, im0_shape) # re-scale mask from P3 shape to original input image shape
+ masks = np.einsum('HWN -> NHW', masks) # HWN -> NHW
+ masks = self.crop_mask(masks, bboxes)
+ return np.greater(masks, 0.5)
+
+ @staticmethod
+ def scale_mask(masks, im0_shape, ratio_pad=None):
+ """
+ Takes a mask, and resizes it to the original image size. (Borrowed from
+ https://github.com/ultralytics/ultralytics/blob/465df3024f44fa97d4fad9986530d5a13cdabdca/ultralytics/utils/ops.py#L305)
+
+ Args:
+ masks (np.ndarray): resized and padded masks/images, [h, w, num]/[h, w, 3].
+ im0_shape (tuple): the original image shape.
+ ratio_pad (tuple): the ratio of the padding to the original image.
+
+ Returns:
+ masks (np.ndarray): The masks that are being returned.
+ """
+ im1_shape = masks.shape[:2]
+ if ratio_pad is None: # calculate from im0_shape
+ gain = min(im1_shape[0] / im0_shape[0], im1_shape[1] / im0_shape[1]) # gain = old / new
+ pad = (im1_shape[1] - im0_shape[1] * gain) / 2, (im1_shape[0] - im0_shape[0] * gain) / 2 # wh padding
+ else:
+ pad = ratio_pad[1]
+
+ # Calculate tlbr of mask
+ top, left = int(round(pad[1] - 0.1)), int(round(pad[0] - 0.1)) # y, x
+ bottom, right = int(round(im1_shape[0] - pad[1] + 0.1)), int(round(im1_shape[1] - pad[0] + 0.1))
+ if len(masks.shape) < 2:
+ raise ValueError(f'"len of masks shape" should be 2 or 3, but got {len(masks.shape)}')
+ masks = masks[top:bottom, left:right]
+ masks = cv2.resize(masks, (im0_shape[1], im0_shape[0]),
+ interpolation=cv2.INTER_LINEAR) # INTER_CUBIC would be better
+ if len(masks.shape) == 2:
+ masks = masks[:, :, None]
+ return masks
+
+ def draw_and_visualize(self, im, bboxes, segments, vis=False, save=True):
+ """
+ Draw and visualize results.
+
+ Args:
+ im (np.ndarray): original image, shape [h, w, c].
+ bboxes (numpy.ndarray): [n, 4], n is number of bboxes.
+ segments (List): list of segment masks.
+ vis (bool): imshow using OpenCV.
+ save (bool): save image annotated.
+
+ Returns:
+ None
+ """
+
+ # Draw rectangles and polygons
+ im_canvas = im.copy()
+ for (*box, conf, cls_), segment in zip(bboxes, segments):
+ # draw contour and fill mask
+ cv2.polylines(im, np.int32([segment]), True, (255, 255, 255), 2) # white borderline
+ cv2.fillPoly(im_canvas, np.int32([segment]), self.color_palette(int(cls_), bgr=True))
+
+ # draw bbox rectangle
+ cv2.rectangle(im, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])),
+ self.color_palette(int(cls_), bgr=True), 1, cv2.LINE_AA)
+ cv2.putText(im, f'{self.classes[cls_]}: {conf:.3f}', (int(box[0]), int(box[1] - 9)),
+ cv2.FONT_HERSHEY_SIMPLEX, 0.7, self.color_palette(int(cls_), bgr=True), 2, cv2.LINE_AA)
+
+ # Mix image
+ im = cv2.addWeighted(im_canvas, 0.3, im, 0.7, 0)
+
+ # Show image
+ if vis:
+ cv2.imshow('demo', im)
+ cv2.waitKey(0)
+ cv2.destroyAllWindows()
+
+ # Save image
+ if save:
+ cv2.imwrite('demo.jpg', im)
+
+
+if __name__ == '__main__':
+ # Create an argument parser to handle command-line arguments
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--model', type=str, required=True, help='Path to ONNX model')
+ parser.add_argument('--source', type=str, default=str(ASSETS / 'bus.jpg'), help='Path to input image')
+ parser.add_argument('--conf', type=float, default=0.25, help='Confidence threshold')
+ parser.add_argument('--iou', type=float, default=0.45, help='NMS IoU threshold')
+ args = parser.parse_args()
+
+ # Build model
+ model = YOLOv8Seg(args.model)
+
+ # Read image by OpenCV
+ img = cv2.imread(args.source)
+
+ # Inference
+ boxes, segments, _ = model(img, conf_threshold=args.conf, iou_threshold=args.iou)
+
+ # Draw bboxes and polygons
+ if len(boxes) > 0:
+ model.draw_and_visualize(img, boxes, segments, vis=False, save=True)
diff --git a/ultralytics/examples/hub.ipynb b/ultralytics/examples/hub.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..375dabdf6bade00fe525e06b497df082ee0a4a60
--- /dev/null
+++ b/ultralytics/examples/hub.ipynb
@@ -0,0 +1,103 @@
+{
+ "nbformat": 4,
+ "nbformat_minor": 0,
+ "metadata": {
+ "colab": {
+ "name": "Ultralytics HUB",
+ "provenance": []
+ },
+ "kernelspec": {
+ "name": "python3",
+ "display_name": "Python 3"
+ },
+ "language_info": {
+ "name": "python"
+ },
+ "accelerator": "GPU"
+ },
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FIzICjaph_Wy"
+ },
+ "source": [
+ "\n",
+ "![](\"https://github.com/ultralytics/assets/raw/main/im/ultralytics-hub.png\")
\n",
+ "\n",
+ "![\"CI](\"https://github.com/ultralytics/hub/actions/workflows/ci.yaml/badge.svg\"){kind=icon}
\n",
+ " \n",
+ " ![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
\n",
+ "\n",
+ "Welcome to the [Ultralytics](https://ultralytics.com/) HUB notebook!\n",
+ "\n",
+ "This notebook allows you to train [YOLOv5](https://github.com/ultralytics/yolov5) and [YOLOv8](https://github.com/ultralytics/ultralytics) 🚀 models using [HUB](https://hub.ultralytics.com/). Please browse the HUB Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
+ "![](\"https://raw.githubusercontent.com/ultralytics/assets/main/yolov8/banner-yolov8.png\")
\n",
+ "\n",
+ "\n",
+ "![\"Run](\"https://assets.paperspace.io/img/gradient-badge.svg\"){kind=icon}
\n",
+ " \n",
+ " ![\"Open](\"https://kaggle.com/static/images/open-in-kaggle.svg\")
\n",
+ "![](\"https://user-images.githubusercontent.com/26833433/212889447-69e5bdf1-5800-4e29-835e-2ed2336dede2.jpg\")
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "0eq1SMWl6Sfn"
+ },
+ "source": [
+ "# 2. Val\n",
+ "Validate a model's accuracy on the [COCO](https://docs.ultralytics.com/datasets/detect/coco/) dataset's `val` or `test` splits. The latest YOLOv8 [models](https://github.com/ultralytics/ultralytics#models) are downloaded automatically the first time they are used. See [YOLOv8 Val Docs](https://docs.ultralytics.com/modes/val/) for more information."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "WQPtK1QYVaD_"
+ },
+ "source": [
+ "# Download COCO val\n",
+ "import torch\n",
+ "torch.hub.download_url_to_file('https://ultralytics.com/assets/coco2017val.zip', 'tmp.zip') # download (780M - 5000 images)\n",
+ "!unzip -q tmp.zip -d datasets && rm tmp.zip # unzip"
+ ],
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "metadata": {
+ "id": "X58w8JLpMnjH",
+ "outputId": "e3aacd98-ceca-49b7-e112-a0c25979ad6c",
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ }
+ },
+ "source": [
+ "# Validate YOLOv8n on COCO8 val\n",
+ "!yolo val model=yolov8n.pt data=coco8.yaml"
+ ],
+ "execution_count": null,
+ "outputs": [
+ {
+ "output_type": "stream",
+ "name": "stdout",
+ "text": [
+ "Ultralytics YOLOv8.0.145 🚀 Python-3.10.6 torch-2.0.1+cu118 CUDA:0 (Tesla T4, 15102MiB)\n",
+ "YOLOv8n summary (fused): 168 layers, 3151904 parameters, 0 gradients\n",
+ "\n",
+ "Dataset 'coco8.yaml' images not found ⚠️, missing path '/content/datasets/coco8/images/val'\n",
+ "Downloading https://ultralytics.com/assets/coco8.zip to '/content/datasets/coco8.zip'...\n",
+ "100% 433k/433k [00:00<00:00, 12.4MB/s]\n",
+ "Unzipping /content/datasets/coco8.zip to /content/datasets...\n",
+ "Dataset download success ✅ (0.7s), saved to \u001b[1m/content/datasets\u001b[0m\n",
+ "\n",
+ "Downloading https://ultralytics.com/assets/Arial.ttf to '/root/.config/Ultralytics/Arial.ttf'...\n",
+ "100% 755k/755k [00:00<00:00, 17.5MB/s]\n",
+ "\u001b[34m\u001b[1mval: \u001b[0mScanning /content/datasets/coco8/labels/val... 4 images, 0 backgrounds, 0 corrupt: 100% 4/4 [00:00<00:00, 276.04it/s]\n",
+ "\u001b[34m\u001b[1mval: \u001b[0mNew cache created: /content/datasets/coco8/labels/val.cache\n",
+ " Class Images Instances Box(P R mAP50 mAP50-95): 100% 1/1 [00:03<00:00, 3.84s/it]\n",
+ " all 4 17 0.621 0.833 0.888 0.63\n",
+ " person 4 10 0.721 0.5 0.519 0.269\n",
+ " dog 4 1 0.37 1 0.995 0.597\n",
+ " horse 4 2 0.751 1 0.995 0.631\n",
+ " elephant 4 2 0.505 0.5 0.828 0.394\n",
+ " umbrella 4 1 0.564 1 0.995 0.995\n",
+ " potted plant 4 1 0.814 1 0.995 0.895\n",
+ "Speed: 0.3ms preprocess, 78.7ms inference, 0.0ms loss, 65.4ms postprocess per image\n",
+ "Results saved to \u001b[1mruns/detect/val\u001b[0m\n"
+ ]
+ }
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "ZY2VXXXu74w5"
+ },
+ "source": [
+ "# 3. Train\n",
+ "\n",
+ "![](\"https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png\"/)
![](\"https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png\")
\n"
+ ],
+ "metadata": {
+ "id": "Phm9ccmOKye5"
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 1. Detection\n",
+ "\n",
+ "YOLOv8 _detection_ models have no suffix and are the default YOLOv8 models, i.e. `yolov8n.pt` and are pretrained on COCO. See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for full details.\n"
+ ],
+ "metadata": {
+ "id": "yq26lwpYK1lq"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Load YOLOv8n, train it on COCO128 for 3 epochs and predict an image with it\n",
+ "from ultralytics import YOLO\n",
+ "\n",
+ "model = YOLO('yolov8n.pt') # load a pretrained YOLOv8n detection model\n",
+ "model.train(data='coco128.yaml', epochs=3) # train the model\n",
+ "model('https://ultralytics.com/images/bus.jpg') # predict on an image"
+ ],
+ "metadata": {
+ "id": "8Go5qqS9LbC5"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 2. Segmentation\n",
+ "\n",
+ "YOLOv8 _segmentation_ models use the `-seg` suffix, i.e. `yolov8n-seg.pt` and are pretrained on COCO. See [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for full details.\n"
+ ],
+ "metadata": {
+ "id": "7ZW58jUzK66B"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Load YOLOv8n-seg, train it on COCO128-seg for 3 epochs and predict an image with it\n",
+ "from ultralytics import YOLO\n",
+ "\n",
+ "model = YOLO('yolov8n-seg.pt') # load a pretrained YOLOv8n segmentation model\n",
+ "model.train(data='coco128-seg.yaml', epochs=3) # train the model\n",
+ "model('https://ultralytics.com/images/bus.jpg') # predict on an image"
+ ],
+ "metadata": {
+ "id": "WFPJIQl_L5HT"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 3. Classification\n",
+ "\n",
+ "YOLOv8 _classification_ models use the `-cls` suffix, i.e. `yolov8n-cls.pt` and are pretrained on ImageNet. See [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for full details.\n"
+ ],
+ "metadata": {
+ "id": "ax3p94VNK9zR"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Load YOLOv8n-cls, train it on mnist160 for 3 epochs and predict an image with it\n",
+ "from ultralytics import YOLO\n",
+ "\n",
+ "model = YOLO('yolov8n-cls.pt') # load a pretrained YOLOv8n classification model\n",
+ "model.train(data='mnist160', epochs=3) # train the model\n",
+ "model('https://ultralytics.com/images/bus.jpg') # predict on an image"
+ ],
+ "metadata": {
+ "id": "5q9Zu6zlL5rS"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 4. Pose\n",
+ "\n",
+ "YOLOv8 _pose_ models use the `-pose` suffix, i.e. `yolov8n-pose.pt` and are pretrained on COCO Keypoints. See [Pose Docs](https://docs.ultralytics.com/tasks/pose/) for full details."
+ ],
+ "metadata": {
+ "id": "SpIaFLiO11TG"
+ }
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Load YOLOv8n-pose, train it on COCO8-pose for 3 epochs and predict an image with it\n",
+ "from ultralytics import YOLO\n",
+ "\n",
+ "model = YOLO('yolov8n-pose.pt') # load a pretrained YOLOv8n classification model\n",
+ "model.train(data='coco8-pose.yaml', epochs=3) # train the model\n",
+ "model('https://ultralytics.com/images/bus.jpg') # predict on an image"
+ ],
+ "metadata": {
+ "id": "si4aKFNg19vX"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "IEijrePND_2I"
+ },
+ "source": [
+ "# Appendix\n",
+ "\n",
+ "Additional content below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Pip install from source\n",
+ "!pip install git+https://github.com/ultralytics/ultralytics@main"
+ ],
+ "metadata": {
+ "id": "pIdE6i8C3LYp"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Git clone and run tests on updates branch\n",
+ "!git clone https://github.com/ultralytics/ultralytics -b main\n",
+ "%pip install -qe ultralytics"
+ ],
+ "metadata": {
+ "id": "uRKlwxSJdhd1"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Run tests (Git clone only)\n",
+ "!pytest ultralytics/tests"
+ ],
+ "metadata": {
+ "id": "GtPlh7mcCGZX"
+ },
+ "execution_count": null,
+ "outputs": []
+ },
+ {
+ "cell_type": "code",
+ "source": [
+ "# Validate multiple models\n",
+ "for x in 'nsmlx':\n",
+ " !yolo val model=yolov8{x}.pt data=coco.yaml"
+ ],
+ "metadata": {
+ "id": "Wdc6t_bfzDDk"
+ },
+ "execution_count": null,
+ "outputs": []
+ }
+ ]
+}
diff --git a/ultralytics/mkdocs.yml b/ultralytics/mkdocs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..09369f388ab92f8c5178833a5c51ac5758577d1a
--- /dev/null
+++ b/ultralytics/mkdocs.yml
@@ -0,0 +1,522 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+site_name: Ultralytics YOLOv8 Docs
+site_url: https://docs.ultralytics.com
+site_description: Explore Ultralytics YOLOv8, a cutting-edge real-time object detection and image segmentation model for various applications and hardware platforms.
+site_author: Ultralytics
+repo_url: https://github.com/ultralytics/ultralytics
+edit_uri: https://github.com/ultralytics/ultralytics/tree/main/docs
+repo_name: ultralytics/ultralytics
+remote_name: https://github.com/ultralytics/docs
+
+theme:
+ name: material
+ language: en
+ custom_dir: docs/overrides
+ logo: https://github.com/ultralytics/assets/raw/main/logo/Ultralytics_Logotype_Reverse.svg
+ favicon: assets/favicon.ico
+ icon:
+ repo: fontawesome/brands/github
+ # Fonts disabled for faster page load times
+ # font:
+ # text: Helvetica
+ # code: Roboto Mono
+
+ palette:
+ # Palette toggle for light mode
+ - scheme: default
+ # primary: grey
+ toggle:
+ icon: material/toggle-switch
+ name: Switch to dark mode
+
+ # Palette toggle for dark mode
+ - scheme: slate
+ # primary: black
+ toggle:
+ icon: material/toggle-switch-off-outline
+ name: Switch to light mode
+ features:
+ - announce.dismiss
+ - content.action.edit
+ - content.code.annotate
+ - content.code.copy
+ - content.tooltips
+ - search.highlight
+ - search.share
+ - search.suggest
+ - toc.follow
+ # - toc.integrate
+ - navigation.top
+ - navigation.tabs
+ - navigation.tabs.sticky
+ - navigation.prune
+ - navigation.footer
+ - navigation.tracking
+ - navigation.instant
+ - navigation.instant.progress
+ - navigation.indexes
+ - navigation.sections
+ - content.tabs.link # all code tabs change simultaneously
+
+# Customization
+copyright: © 2023 Ultralytics Inc. All rights reserved.
+extra:
+ # version:
+ # provider: mike # version drop-down menu
+ robots: robots.txt
+ analytics:
+ provider: google
+ property: G-2M5EHKC0BH
+ alternate: # language drop-down
+ - name: English
+ link: /
+ lang: en
+ - name: 简体中文
+ link: /zh/
+ lang: zh
+ social:
+ - icon: fontawesome/brands/github
+ link: https://github.com/ultralytics
+ - icon: fontawesome/brands/linkedin
+ link: https://www.linkedin.com/company/ultralytics/
+ - icon: fontawesome/brands/twitter
+ link: https://twitter.com/ultralytics
+ - icon: fontawesome/brands/youtube
+ link: https://www.youtube.com/ultralytics
+ - icon: fontawesome/brands/docker
+ link: https://hub.docker.com/r/ultralytics/ultralytics/
+ - icon: fontawesome/brands/python
+ link: https://pypi.org/project/ultralytics/
+ - icon: fontawesome/brands/discord
+ link: https://ultralytics.com/discord
+
+extra_css:
+ - stylesheets/style.css
+ - https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css
+
+markdown_extensions:
+ # Div text decorators
+ - admonition
+ - md_in_html
+ - pymdownx.details
+ - pymdownx.superfences
+ - tables
+ - attr_list
+ - def_list
+ # Syntax highlight
+ - pymdownx.highlight:
+ anchor_linenums: true
+ - pymdownx.inlinehilite
+ - pymdownx.snippets:
+ base_path: ./
+ - pymdownx.emoji:
+ emoji_index: !!python/name:material.extensions.emoji.twemoji
+ emoji_generator: !!python/name:material.extensions.emoji.to_svg
+ - pymdownx.tabbed:
+ alternate_style: true
+
+ # Highlight
+ - pymdownx.critic
+ - pymdownx.caret
+ - pymdownx.keys
+ - pymdownx.mark
+ - pymdownx.tilde
+
+# Primary navigation ---------------------------------------------------------------------------------------------------
+nav:
+ - Home:
+ - Home: index.md
+ - Quickstart: quickstart.md
+ - Modes:
+ - modes/index.md
+ - Train: modes/train.md
+ - Val: modes/val.md
+ - Predict: modes/predict.md
+ - Export: modes/export.md
+ - Track: modes/track.md
+ - Benchmark: modes/benchmark.md
+ - Tasks:
+ - tasks/index.md
+ - Detect: tasks/detect.md
+ - Segment: tasks/segment.md
+ - Classify: tasks/classify.md
+ - Pose: tasks/pose.md
+ - Ultralytics 文档:
+ - zh/index.md
+ - Quickstart: quickstart.md
+ - Modes:
+ - modes/index.md
+ - Train: modes/train.md
+ - Val: modes/val.md
+ - Predict: modes/predict.md
+ - Export: modes/export.md
+ - Track: modes/track.md
+ - Benchmark: modes/benchmark.md
+ - Tasks:
+ - tasks/index.md
+ - Detect: tasks/detect.md
+ - Segment: tasks/segment.md
+ - Classify: tasks/classify.md
+ - Pose: tasks/pose.md
+ - Models:
+ - models/index.md
+ - YOLOv3: models/yolov3.md
+ - YOLOv4: models/yolov4.md
+ - YOLOv5: models/yolov5.md
+ - YOLOv6: models/yolov6.md
+ - YOLOv7: models/yolov7.md
+ - YOLOv8: models/yolov8.md
+ - SAM (Segment Anything Model): models/sam.md
+ - MobileSAM (Mobile Segment Anything Model): models/mobile-sam.md
+ - FastSAM (Fast Segment Anything Model): models/fast-sam.md
+ - YOLO-NAS (Neural Architecture Search): models/yolo-nas.md
+ - RT-DETR (Realtime Detection Transformer): models/rtdetr.md
+ - Datasets:
+ - datasets/index.md
+ - Detection:
+ - datasets/detect/index.md
+ - Argoverse: datasets/detect/argoverse.md
+ - COCO: datasets/detect/coco.md
+ - COCO8: datasets/detect/coco8.md
+ - GlobalWheat2020: datasets/detect/globalwheat2020.md
+ - Objects365: datasets/detect/objects365.md
+ - OpenImagesV7: datasets/detect/open-images-v7.md
+ - SKU-110K: datasets/detect/sku-110k.md
+ - VisDrone: datasets/detect/visdrone.md
+ - VOC: datasets/detect/voc.md
+ - xView: datasets/detect/xview.md
+ - Segmentation:
+ - datasets/segment/index.md
+ - COCO: datasets/segment/coco.md
+ - COCO8-seg: datasets/segment/coco8-seg.md
+ - Pose:
+ - datasets/pose/index.md
+ - COCO: datasets/pose/coco.md
+ - COCO8-pose: datasets/pose/coco8-pose.md
+ - Tiger-pose: datasets/pose/tiger-pose.md
+ - Classification:
+ - datasets/classify/index.md
+ - Caltech 101: datasets/classify/caltech101.md
+ - Caltech 256: datasets/classify/caltech256.md
+ - CIFAR-10: datasets/classify/cifar10.md
+ - CIFAR-100: datasets/classify/cifar100.md
+ - Fashion-MNIST: datasets/classify/fashion-mnist.md
+ - ImageNet: datasets/classify/imagenet.md
+ - ImageNet-10: datasets/classify/imagenet10.md
+ - Imagenette: datasets/classify/imagenette.md
+ - Imagewoof: datasets/classify/imagewoof.md
+ - MNIST: datasets/classify/mnist.md
+ - Oriented Bounding Boxes (OBB):
+ - datasets/obb/index.md
+ - DOTAv2: datasets/obb/dota-v2.md
+ - Multi-Object Tracking:
+ - datasets/track/index.md
+ - Guides:
+ - guides/index.md
+ - YOLO Common Issues: guides/yolo-common-issues.md
+ - YOLO Performance Metrics: guides/yolo-performance-metrics.md
+ - YOLO Thread-Safe Inference: guides/yolo-thread-safe-inference.md
+ - Model Deployment Options: guides/model-deployment-options.md
+ - K-Fold Cross Validation: guides/kfold-cross-validation.md
+ - Hyperparameter Tuning: guides/hyperparameter-tuning.md
+ - SAHI Tiled Inference: guides/sahi-tiled-inference.md
+ - AzureML Quickstart: guides/azureml-quickstart.md
+ - Conda Quickstart: guides/conda-quickstart.md
+ - Docker Quickstart: guides/docker-quickstart.md
+ - Raspberry Pi: guides/raspberry-pi.md
+ - Triton Inference Server: guides/triton-inference-server.md
+ - Integrations:
+ - integrations/index.md
+ - OpenVINO: integrations/openvino.md
+ - Ray Tune: integrations/ray-tune.md
+ - Roboflow: integrations/roboflow.md
+ - MLflow: integrations/mlflow.md
+ - Usage:
+ - CLI: usage/cli.md
+ - Python: usage/python.md
+ - Callbacks: usage/callbacks.md
+ - Configuration: usage/cfg.md
+ - Advanced Customization: usage/engine.md
+ - YOLOv5:
+ - yolov5/index.md
+ - Quickstart: yolov5/quickstart_tutorial.md
+ - Environments:
+ - Amazon Web Services (AWS): yolov5/environments/aws_quickstart_tutorial.md
+ - Google Cloud (GCP): yolov5/environments/google_cloud_quickstart_tutorial.md
+ - AzureML: yolov5/environments/azureml_quickstart_tutorial.md
+ - Docker Image: yolov5/environments/docker_image_quickstart_tutorial.md
+ - Tutorials:
+ - Train Custom Data: yolov5/tutorials/train_custom_data.md
+ - Tips for Best Training Results: yolov5/tutorials/tips_for_best_training_results.md
+ - Multi-GPU Training: yolov5/tutorials/multi_gpu_training.md
+ - PyTorch Hub: yolov5/tutorials/pytorch_hub_model_loading.md
+ - TFLite, ONNX, CoreML, TensorRT Export: yolov5/tutorials/model_export.md
+ - NVIDIA Jetson Nano Deployment: yolov5/tutorials/running_on_jetson_nano.md
+ - Test-Time Augmentation (TTA): yolov5/tutorials/test_time_augmentation.md
+ - Model Ensembling: yolov5/tutorials/model_ensembling.md
+ - Pruning/Sparsity Tutorial: yolov5/tutorials/model_pruning_and_sparsity.md
+ - Hyperparameter evolution: yolov5/tutorials/hyperparameter_evolution.md
+ - Transfer learning with frozen layers: yolov5/tutorials/transfer_learning_with_frozen_layers.md
+ - Architecture Summary: yolov5/tutorials/architecture_description.md
+ - Roboflow Datasets: yolov5/tutorials/roboflow_datasets_integration.md
+ - Neural Magic's DeepSparse: yolov5/tutorials/neural_magic_pruning_quantization.md
+ - Comet Logging: yolov5/tutorials/comet_logging_integration.md
+ - Clearml Logging: yolov5/tutorials/clearml_logging_integration.md
+ - HUB:
+ - hub/index.md
+ - Quickstart: hub/quickstart.md
+ - Datasets: hub/datasets.md
+ - Projects: hub/projects.md
+ - Models: hub/models.md
+ - Integrations: hub/integrations.md
+ - Ultralytics HUB App:
+ - hub/app/index.md
+ - 'iOS': hub/app/ios.md
+ - 'Android': hub/app/android.md
+ - Inference API: hub/inference_api.md
+ - Reference:
+ - cfg:
+ - __init__: reference/cfg/__init__.md
+ - data:
+ - annotator: reference/data/annotator.md
+ - augment: reference/data/augment.md
+ - base: reference/data/base.md
+ - build: reference/data/build.md
+ - converter: reference/data/converter.md
+ - dataset: reference/data/dataset.md
+ - loaders: reference/data/loaders.md
+ - utils: reference/data/utils.md
+ - engine:
+ - exporter: reference/engine/exporter.md
+ - model: reference/engine/model.md
+ - predictor: reference/engine/predictor.md
+ - results: reference/engine/results.md
+ - trainer: reference/engine/trainer.md
+ - tuner: reference/engine/tuner.md
+ - validator: reference/engine/validator.md
+ - hub:
+ - __init__: reference/hub/__init__.md
+ - auth: reference/hub/auth.md
+ - session: reference/hub/session.md
+ - utils: reference/hub/utils.md
+ - models:
+ - fastsam:
+ - model: reference/models/fastsam/model.md
+ - predict: reference/models/fastsam/predict.md
+ - prompt: reference/models/fastsam/prompt.md
+ - utils: reference/models/fastsam/utils.md
+ - val: reference/models/fastsam/val.md
+ - nas:
+ - model: reference/models/nas/model.md
+ - predict: reference/models/nas/predict.md
+ - val: reference/models/nas/val.md
+ - rtdetr:
+ - model: reference/models/rtdetr/model.md
+ - predict: reference/models/rtdetr/predict.md
+ - train: reference/models/rtdetr/train.md
+ - val: reference/models/rtdetr/val.md
+ - sam:
+ - amg: reference/models/sam/amg.md
+ - build: reference/models/sam/build.md
+ - model: reference/models/sam/model.md
+ - modules:
+ - decoders: reference/models/sam/modules/decoders.md
+ - encoders: reference/models/sam/modules/encoders.md
+ - sam: reference/models/sam/modules/sam.md
+ - tiny_encoder: reference/models/sam/modules/tiny_encoder.md
+ - transformer: reference/models/sam/modules/transformer.md
+ - predict: reference/models/sam/predict.md
+ - utils:
+ - loss: reference/models/utils/loss.md
+ - ops: reference/models/utils/ops.md
+ - yolo:
+ - classify:
+ - predict: reference/models/yolo/classify/predict.md
+ - train: reference/models/yolo/classify/train.md
+ - val: reference/models/yolo/classify/val.md
+ - detect:
+ - predict: reference/models/yolo/detect/predict.md
+ - train: reference/models/yolo/detect/train.md
+ - val: reference/models/yolo/detect/val.md
+ - model: reference/models/yolo/model.md
+ - pose:
+ - predict: reference/models/yolo/pose/predict.md
+ - train: reference/models/yolo/pose/train.md
+ - val: reference/models/yolo/pose/val.md
+ - segment:
+ - predict: reference/models/yolo/segment/predict.md
+ - train: reference/models/yolo/segment/train.md
+ - val: reference/models/yolo/segment/val.md
+ - nn:
+ - autobackend: reference/nn/autobackend.md
+ - modules:
+ - block: reference/nn/modules/block.md
+ - conv: reference/nn/modules/conv.md
+ - head: reference/nn/modules/head.md
+ - transformer: reference/nn/modules/transformer.md
+ - utils: reference/nn/modules/utils.md
+ - tasks: reference/nn/tasks.md
+ - trackers:
+ - basetrack: reference/trackers/basetrack.md
+ - bot_sort: reference/trackers/bot_sort.md
+ - byte_tracker: reference/trackers/byte_tracker.md
+ - track: reference/trackers/track.md
+ - utils:
+ - gmc: reference/trackers/utils/gmc.md
+ - kalman_filter: reference/trackers/utils/kalman_filter.md
+ - matching: reference/trackers/utils/matching.md
+ - utils:
+ - __init__: reference/utils/__init__.md
+ - autobatch: reference/utils/autobatch.md
+ - benchmarks: reference/utils/benchmarks.md
+ - callbacks:
+ - base: reference/utils/callbacks/base.md
+ - clearml: reference/utils/callbacks/clearml.md
+ - comet: reference/utils/callbacks/comet.md
+ - dvc: reference/utils/callbacks/dvc.md
+ - hub: reference/utils/callbacks/hub.md
+ - mlflow: reference/utils/callbacks/mlflow.md
+ - neptune: reference/utils/callbacks/neptune.md
+ - raytune: reference/utils/callbacks/raytune.md
+ - tensorboard: reference/utils/callbacks/tensorboard.md
+ - wb: reference/utils/callbacks/wb.md
+ - checks: reference/utils/checks.md
+ - dist: reference/utils/dist.md
+ - downloads: reference/utils/downloads.md
+ - errors: reference/utils/errors.md
+ - files: reference/utils/files.md
+ - instance: reference/utils/instance.md
+ - loss: reference/utils/loss.md
+ - metrics: reference/utils/metrics.md
+ - ops: reference/utils/ops.md
+ - patches: reference/utils/patches.md
+ - plotting: reference/utils/plotting.md
+ - tal: reference/utils/tal.md
+ - torch_utils: reference/utils/torch_utils.md
+ - triton: reference/utils/triton.md
+ - tuner: reference/utils/tuner.md
+
+ - Help:
+ - Help: help/index.md
+ - Frequently Asked Questions (FAQ): help/FAQ.md
+ - Contributing Guide: help/contributing.md
+ - Continuous Integration (CI) Guide: help/CI.md
+ - Contributor License Agreement (CLA): help/CLA.md
+ - Minimum Reproducible Example (MRE) Guide: help/minimum_reproducible_example.md
+ - Code of Conduct: help/code_of_conduct.md
+ - Environmental, Health and Safety (EHS) Policy: help/environmental-health-safety.md
+ - Security Policy: SECURITY.md
+ - Privacy Policy: help/privacy.md
+
+# Plugins including 301 redirects navigation ---------------------------------------------------------------------------
+plugins:
+ - search
+ - mkdocstrings:
+ enabled: true
+ default_handler: python
+ handlers:
+ python:
+ options:
+ docstring_style: google
+ show_root_heading: true
+ show_source: true
+ - ultralytics:
+ add_desc: False
+ add_image: True
+ add_share_buttons: True
+ default_image: https://github.com/ultralytics/ultralytics/assets/26833433/6d09221c-c52a-4234-9a5d-b862e93c6529
+ - redirects:
+ redirect_maps:
+ callbacks.md: usage/callbacks.md
+ cfg.md: usage/cfg.md
+ cli.md: usage/cli.md
+ config.md: usage/cfg.md
+ engine.md: usage/engine.md
+ environments/AWS-Quickstart.md: yolov5/environments/aws_quickstart_tutorial.md
+ environments/Docker-Quickstart.md: yolov5/environments/docker_image_quickstart_tutorial.md
+ environments/GCP-Quickstart.md: yolov5/environments/google_cloud_quickstart_tutorial.md
+ FAQ/augmentation.md: yolov5/tutorials/tips_for_best_training_results.md
+ package-framework.md: index.md
+ package-framework/mock_detector.md: index.md
+ predict.md: modes/predict.md
+ python.md: usage/python.md
+ quick-start.md: quickstart.md
+ app.md: hub/app/index.md
+ sdk.md: index.md
+ usage/hyperparameter_tuning.md: integrations/ray-tune.md
+ reference/base_pred.md: reference/engine/predictor.md
+ reference/base_trainer.md: reference/engine/trainer.md
+ reference/exporter.md: reference/engine/exporter.md
+ reference/model.md: reference/engine/model.md
+ reference/nn.md: reference/nn/modules/head.md
+ reference/ops.md: reference/utils/ops.md
+ reference/results.md: reference/engine/results.md
+ reference/base_val.md: index.md
+ tasks/classification.md: tasks/classify.md
+ tasks/detection.md: tasks/detect.md
+ tasks/segmentation.md: tasks/segment.md
+ tasks/keypoints.md: tasks/pose.md
+ tasks/tracking.md: modes/track.md
+ tutorials/architecture-summary.md: yolov5/tutorials/architecture_description.md
+ tutorials/clearml-logging.md: yolov5/tutorials/clearml_logging_integration.md
+ tutorials/comet-logging.md: yolov5/tutorials/comet_logging_integration.md
+ tutorials/hyperparameter-evolution.md: yolov5/tutorials/hyperparameter_evolution.md
+ tutorials/model-ensembling.md: yolov5/tutorials/model_ensembling.md
+ tutorials/multi-gpu-training.md: yolov5/tutorials/multi_gpu_training.md
+ tutorials/nvidia-jetson.md: yolov5/tutorials/running_on_jetson_nano.md
+ tutorials/pruning-sparsity.md: yolov5/tutorials/model_pruning_and_sparsity.md
+ tutorials/pytorch-hub.md: yolov5/tutorials/pytorch_hub_model_loading.md
+ tutorials/roboflow.md: yolov5/tutorials/roboflow_datasets_integration.md
+ tutorials/test-time-augmentation.md: yolov5/tutorials/test_time_augmentation.md
+ tutorials/torchscript-onnx-coreml-export.md: yolov5/tutorials/model_export.md
+ tutorials/train-custom-datasets.md: yolov5/tutorials/train_custom_data.md
+ tutorials/training-tips-best-results.md: yolov5/tutorials/tips_for_best_training_results.md
+ tutorials/transfer-learning-froze-layers.md: yolov5/tutorials/transfer_learning_with_frozen_layers.md
+ tutorials/weights-and-biasis-logging.md: yolov5/tutorials/comet_logging_integration.md
+ yolov5/pytorch_hub.md: yolov5/tutorials/pytorch_hub_model_loading.md
+ yolov5/hyp_evolution.md: yolov5/tutorials/hyperparameter_evolution.md
+ yolov5/pruning_sparsity.md: yolov5/tutorials/model_pruning_and_sparsity.md
+ yolov5/roboflow.md: yolov5/tutorials/roboflow_datasets_integration.md
+ yolov5/comet.md: yolov5/tutorials/comet_logging_integration.md
+ yolov5/clearml.md: yolov5/tutorials/clearml_logging_integration.md
+ yolov5/tta.md: yolov5/tutorials/test_time_augmentation.md
+ yolov5/multi_gpu_training.md: yolov5/tutorials/multi_gpu_training.md
+ yolov5/ensemble.md: yolov5/tutorials/model_ensembling.md
+ yolov5/jetson_nano.md: yolov5/tutorials/running_on_jetson_nano.md
+ yolov5/transfer_learn_frozen.md: yolov5/tutorials/transfer_learning_with_frozen_layers.md
+ yolov5/neural_magic.md: yolov5/tutorials/neural_magic_pruning_quantization.md
+ yolov5/train_custom_data.md: yolov5/tutorials/train_custom_data.md
+ yolov5/architecture.md: yolov5/tutorials/architecture_description.md
+ yolov5/export.md: yolov5/tutorials/model_export.md
+ yolov5/yolov5_quickstart_tutorial.md: yolov5/quickstart_tutorial.md
+ yolov5/tips_for_best_training_results.md: yolov5/tutorials/tips_for_best_training_results.md
+ yolov5/tutorials/yolov5_neural_magic_tutorial.md: yolov5/tutorials/neural_magic_pruning_quantization.md
+ yolov5/tutorials/model_ensembling_tutorial.md: yolov5/tutorials/model_ensembling.md
+ yolov5/tutorials/pytorch_hub_tutorial.md: yolov5/tutorials/pytorch_hub_model_loading.md
+ yolov5/tutorials/yolov5_architecture_tutorial.md: yolov5/tutorials/architecture_description.md
+ yolov5/tutorials/multi_gpu_training_tutorial.md: yolov5/tutorials/multi_gpu_training.md
+ yolov5/tutorials/yolov5_pytorch_hub_tutorial.md: yolov5/tutorials/pytorch_hub_model_loading.md
+ yolov5/tutorials/model_export_tutorial.md: yolov5/tutorials/model_export.md
+ yolov5/tutorials/jetson_nano_tutorial.md: yolov5/tutorials/running_on_jetson_nano.md
+ yolov5/tutorials/yolov5_model_ensembling_tutorial.md: yolov5/tutorials/model_ensembling.md
+ yolov5/tutorials/roboflow_integration.md: yolov5/tutorials/roboflow_datasets_integration.md
+ yolov5/tutorials/pruning_and_sparsity_tutorial.md: yolov5/tutorials/model_pruning_and_sparsity.md
+ yolov5/tutorials/yolov5_transfer_learning_with_frozen_layers_tutorial.md: yolov5/tutorials/transfer_learning_with_frozen_layers.md
+ yolov5/tutorials/transfer_learning_with_frozen_layers_tutorial.md: yolov5/tutorials/transfer_learning_with_frozen_layers.md
+ yolov5/tutorials/yolov5_model_export_tutorial.md: yolov5/tutorials/model_export.md
+ yolov5/tutorials/neural_magic_tutorial.md: yolov5/tutorials/neural_magic_pruning_quantization.md
+ yolov5/tutorials/yolov5_clearml_integration_tutorial.md: yolov5/tutorials/clearml_logging_integration.md
+ yolov5/tutorials/yolov5_train_custom_data.md: yolov5/tutorials/train_custom_data.md
+ yolov5/tutorials/comet_integration_tutorial.md: yolov5/tutorials/comet_logging_integration.md
+ yolov5/tutorials/yolov5_pruning_and_sparsity_tutorial.md: yolov5/tutorials/model_pruning_and_sparsity.md
+ yolov5/tutorials/yolov5_jetson_nano_tutorial.md: yolov5/tutorials/running_on_jetson_nano.md
+ yolov5/tutorials/yolov5_roboflow_integration.md: yolov5/tutorials/roboflow_datasets_integration.md
+ yolov5/tutorials/hyperparameter_evolution_tutorial.md: yolov5/tutorials/hyperparameter_evolution.md
+ yolov5/tutorials/yolov5_hyperparameter_evolution_tutorial.md: yolov5/tutorials/hyperparameter_evolution.md
+ yolov5/tutorials/clearml_integration_tutorial.md: yolov5/tutorials/clearml_logging_integration.md
+ yolov5/tutorials/test_time_augmentation_tutorial.md: yolov5/tutorials/test_time_augmentation.md
+ yolov5/tutorials/yolov5_test_time_augmentation_tutorial.md: yolov5/tutorials/test_time_augmentation.md
+ yolov5/environments/yolov5_amazon_web_services_quickstart_tutorial.md: yolov5/environments/aws_quickstart_tutorial.md
+ yolov5/environments/yolov5_google_cloud_platform_quickstart_tutorial.md: yolov5/environments/google_cloud_quickstart_tutorial.md
+ yolov5/environments/yolov5_docker_image_quickstart_tutorial.md: yolov5/environments/docker_image_quickstart_tutorial.md
diff --git a/ultralytics/requirements.txt b/ultralytics/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ae19defaf9029af429554c47537321517353e4d7
--- /dev/null
+++ b/ultralytics/requirements.txt
@@ -0,0 +1,45 @@
+# Ultralytics requirements
+# Example: pip install -r requirements.txt
+
+# Base ----------------------------------------
+matplotlib>=3.3.0
+numpy>=1.22.2 # pinned by Snyk to avoid a vulnerability
+opencv-python>=4.6.0
+pillow>=7.1.2
+pyyaml>=5.3.1
+requests>=2.23.0
+scipy>=1.4.1
+torch>=1.8.0
+torchvision>=0.9.0
+tqdm>=4.64.0
+
+# Logging -------------------------------------
+# tensorboard>=2.13.0
+# dvclive>=2.12.0
+# clearml
+# comet
+
+# Plotting ------------------------------------
+pandas>=1.1.4
+seaborn>=0.11.0
+
+# Export --------------------------------------
+# coremltools>=7.0 # CoreML export
+# onnx>=1.12.0 # ONNX export
+# onnxsim>=0.4.1 # ONNX simplifier
+# nvidia-pyindex # TensorRT export
+# nvidia-tensorrt # TensorRT export
+# scikit-learn==0.19.2 # CoreML quantization
+# tensorflow>=2.4.1 # TF exports (-cpu, -aarch64, -macos)
+# tflite-support
+# tensorflowjs>=3.9.0 # TF.js export
+# openvino-dev>=2023.0 # OpenVINO export
+
+# Extras --------------------------------------
+psutil # system utilization
+py-cpuinfo # display CPU info
+thop>=0.1.1 # FLOPs computation
+# ipython # interactive notebook
+# albumentations>=1.0.3 # training augmentations
+# pycocotools>=2.0.6 # COCO mAP
+# roboflow
diff --git a/ultralytics/setup.cfg b/ultralytics/setup.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..ff3644492778ca4c9e1fae071f403e1241d707d5
--- /dev/null
+++ b/ultralytics/setup.cfg
@@ -0,0 +1,71 @@
+# Project-wide configuration file, can be used for package metadata and other toll configurations
+# Example usage: global configuration for PEP8 (via flake8) setting or default pytest arguments
+# Local usage: pip install pre-commit, pre-commit run --all-files
+
+[metadata]
+license_files = LICENSE
+description_file = README.md
+
+[tool:pytest]
+norecursedirs =
+ .git
+ dist
+ build
+addopts =
+ --doctest-modules
+ --durations=30
+ --color=yes
+
+[coverage:run]
+source = ultralytics/
+data_file = tests/.coverage
+omit =
+ ultralytics/utils/callbacks/*
+
+[flake8]
+max-line-length = 120
+exclude = .tox,*.egg,build,temp
+select = E,W,F
+doctests = True
+verbose = 2
+# https://pep8.readthedocs.io/en/latest/intro.html#error-codes
+format = pylint
+# see: https://www.flake8rules.com/
+ignore = E731,F405,E402,W504,E501
+ # E731: Do not assign a lambda expression, use a def
+ # F405: name may be undefined, or defined from star imports: module
+ # E402: module level import not at top of file
+ # W504: line break after binary operator
+ # E501: line too long
+ # removed:
+ # F401: module imported but unused
+ # E231: missing whitespace after ‘,’, ‘;’, or ‘:’
+ # E127: continuation line over-indented for visual indent
+ # F403: ‘from module import *’ used; unable to detect undefined names
+
+
+[isort]
+# https://pycqa.github.io/isort/docs/configuration/options.html
+line_length = 120
+# see: https://pycqa.github.io/isort/docs/configuration/multi_line_output_modes.html
+multi_line_output = 0
+
+[yapf]
+based_on_style = pep8
+spaces_before_comment = 2
+COLUMN_LIMIT = 120
+COALESCE_BRACKETS = True
+SPACES_AROUND_POWER_OPERATOR = True
+SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET = True
+SPLIT_BEFORE_CLOSING_BRACKET = False
+SPLIT_BEFORE_FIRST_ARGUMENT = False
+# EACH_DICT_ENTRY_ON_SEPARATE_LINE = False
+
+[docformatter]
+wrap-summaries = 120
+wrap-descriptions = 120
+in-place = true
+make-summary-multi-line = false
+pre-summary-newline = true
+force-wrap = false
+close-quotes-on-newline = true
diff --git a/ultralytics/setup.py b/ultralytics/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d9917b6331471107f4398e4b52da97d0c028c41
--- /dev/null
+++ b/ultralytics/setup.py
@@ -0,0 +1,105 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import re
+from pathlib import Path
+
+from setuptools import setup
+
+# Settings
+FILE = Path(__file__).resolve()
+PARENT = FILE.parent # root directory
+README = (PARENT / 'README.md').read_text(encoding='utf-8')
+
+
+def get_version():
+ """
+ Retrieve the version number from the 'ultralytics/__init__.py' file.
+
+ Returns:
+ (str): The version number extracted from the '__version__' attribute in the 'ultralytics/__init__.py' file.
+ """
+ file = PARENT / 'ultralytics/__init__.py'
+ return re.search(r'^__version__ = [\'"]([^\'"]*)[\'"]', file.read_text(encoding='utf-8'), re.M)[1]
+
+
+def parse_requirements(file_path: Path):
+ """
+ Parse a requirements.txt file, ignoring lines that start with '#' and any text after '#'.
+
+ Args:
+ file_path (str | Path): Path to the requirements.txt file.
+
+ Returns:
+ (List[str]): List of parsed requirements.
+ """
+
+ requirements = []
+ for line in Path(file_path).read_text().splitlines():
+ line = line.strip()
+ if line and not line.startswith('#'):
+ requirements.append(line.split('#')[0].strip()) # ignore inline comments
+
+ return requirements
+
+
+setup(
+ name='ultralytics', # name of pypi package
+ version=get_version(), # version of pypi package
+ python_requires='>=3.8',
+ license='AGPL-3.0',
+ description=('Ultralytics YOLOv8 for SOTA object detection, multi-object tracking, instance segmentation, '
+ 'pose estimation and image classification.'),
+ long_description=README,
+ long_description_content_type='text/markdown',
+ url='https://github.com/ultralytics/ultralytics',
+ project_urls={
+ 'Bug Reports': 'https://github.com/ultralytics/ultralytics/issues',
+ 'Funding': 'https://ultralytics.com',
+ 'Source': 'https://github.com/ultralytics/ultralytics'},
+ author='Ultralytics',
+ author_email='hello@ultralytics.com',
+ packages=['ultralytics'] + [str(x) for x in Path('ultralytics').rglob('*/') if x.is_dir() and '__' not in str(x)],
+ package_data={
+ '': ['*.yaml'],
+ 'ultralytics.assets': ['*.jpg']},
+ include_package_data=True,
+ install_requires=parse_requirements(PARENT / 'requirements.txt'),
+ extras_require={
+ 'dev': [
+ 'ipython',
+ 'check-manifest',
+ 'pre-commit',
+ 'pytest',
+ 'pytest-cov',
+ 'coverage',
+ 'mkdocs-material',
+ 'mkdocstrings[python]',
+ 'mkdocs-redirects', # for 301 redirects
+ 'mkdocs-ultralytics-plugin>=0.0.32', # for meta descriptions and images, dates and authors
+ ],
+ 'export': [
+ 'coremltools>=7.0',
+ 'openvino-dev>=2023.0',
+ 'tensorflow<=2.13.1',
+ 'tensorflowjs', # automatically installs tensorflow
+ ], },
+ classifiers=[
+ 'Development Status :: 4 - Beta',
+ 'Intended Audience :: Developers',
+ 'Intended Audience :: Education',
+ 'Intended Audience :: Science/Research',
+ 'License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)',
+ 'Programming Language :: Python :: 3',
+ 'Programming Language :: Python :: 3.8',
+ 'Programming Language :: Python :: 3.9',
+ 'Programming Language :: Python :: 3.10',
+ 'Programming Language :: Python :: 3.11',
+ 'Topic :: Software Development',
+ 'Topic :: Scientific/Engineering',
+ 'Topic :: Scientific/Engineering :: Artificial Intelligence',
+ 'Topic :: Scientific/Engineering :: Image Recognition',
+ 'Operating System :: POSIX :: Linux',
+ 'Operating System :: MacOS',
+ 'Operating System :: Microsoft :: Windows', ],
+ keywords='machine-learning, deep-learning, vision, ML, DL, AI, YOLO, YOLOv3, YOLOv5, YOLOv8, HUB, Ultralytics',
+ entry_points={'console_scripts': ['yolo = ultralytics.cfg:entrypoint', 'ultralytics = ultralytics.cfg:entrypoint']})
diff --git a/ultralytics/tests/conftest.py b/ultralytics/tests/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..59955bd1cef80e46b36d8cbd994f12a3000ca32a
--- /dev/null
+++ b/ultralytics/tests/conftest.py
@@ -0,0 +1,94 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import shutil
+from pathlib import Path
+
+import pytest
+
+TMP = Path(__file__).resolve().parent / 'tmp' # temp directory for test files
+
+
+def pytest_addoption(parser):
+ """
+ Add custom command-line options to pytest.
+
+ Args:
+ parser (pytest.config.Parser): The pytest parser object.
+ """
+ parser.addoption('--slow', action='store_true', default=False, help='Run slow tests')
+
+
+def pytest_configure(config):
+ """
+ Register custom markers to avoid pytest warnings.
+
+ Args:
+ config (pytest.config.Config): The pytest config object.
+ """
+ config.addinivalue_line('markers', 'slow: mark test as slow to run')
+
+
+def pytest_runtest_setup(item):
+ """
+ Setup hook to skip tests marked as slow if the --slow option is not provided.
+
+ Args:
+ item (pytest.Item): The test item object.
+ """
+ if 'slow' in item.keywords and not item.config.getoption('--slow'):
+ pytest.skip('skip slow tests unless --slow is set')
+
+
+def pytest_collection_modifyitems(config, items):
+ """
+ Modify the list of test items to remove tests marked as slow if the --slow option is not provided.
+
+ Args:
+ config (pytest.config.Config): The pytest config object.
+ items (list): List of test items to be executed.
+ """
+ if not config.getoption('--slow'):
+ # Remove the item entirely from the list of test items if it's marked as 'slow'
+ items[:] = [item for item in items if 'slow' not in item.keywords]
+
+
+def pytest_sessionstart(session):
+ """
+ Initialize session configurations for pytest.
+
+ This function is automatically called by pytest after the 'Session' object has been created but before performing
+ test collection. It sets the initial seeds and prepares the temporary directory for the test session.
+
+ Args:
+ session (pytest.Session): The pytest session object.
+ """
+ from ultralytics.utils.torch_utils import init_seeds
+
+ init_seeds()
+ shutil.rmtree(TMP, ignore_errors=True) # delete any existing tests/tmp directory
+ TMP.mkdir(parents=True, exist_ok=True) # create a new empty directory
+
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+ """
+ Cleanup operations after pytest session.
+
+ This function is automatically called by pytest at the end of the entire test session. It removes certain files
+ and directories used during testing.
+
+ Args:
+ terminalreporter (pytest.terminal.TerminalReporter): The terminal reporter object.
+ exitstatus (int): The exit status of the test run.
+ config (pytest.config.Config): The pytest config object.
+ """
+ from ultralytics.utils import WEIGHTS_DIR
+
+ # Remove files
+ models = [path for x in ['*.onnx', '*.torchscript'] for path in WEIGHTS_DIR.rglob(x)]
+ for file in ['bus.jpg', 'yolov8n.onnx', 'yolov8n.torchscript'] + models:
+ Path(file).unlink(missing_ok=True)
+
+ # Remove directories
+ models = [path for x in ['*.mlpackage', '*_openvino_model'] for path in WEIGHTS_DIR.rglob(x)]
+ for directory in [TMP.parents[1] / '.pytest_cache', TMP] + models:
+ shutil.rmtree(directory, ignore_errors=True)
diff --git a/ultralytics/tests/test_cli.py b/ultralytics/tests/test_cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a3fd9929f9bbf11f05344d275e2b3aee1d049e4
--- /dev/null
+++ b/ultralytics/tests/test_cli.py
@@ -0,0 +1,134 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import subprocess
+
+import pytest
+
+from ultralytics.utils import ASSETS, WEIGHTS_DIR
+from ultralytics.utils.checks import cuda_device_count, cuda_is_available
+
+CUDA_IS_AVAILABLE = cuda_is_available()
+CUDA_DEVICE_COUNT = cuda_device_count()
+TASK_ARGS = [
+ ('detect', 'yolov8n', 'coco8.yaml'),
+ ('segment', 'yolov8n-seg', 'coco8-seg.yaml'),
+ ('classify', 'yolov8n-cls', 'imagenet10'),
+ ('pose', 'yolov8n-pose', 'coco8-pose.yaml'), ] # (task, model, data)
+EXPORT_ARGS = [
+ ('yolov8n', 'torchscript'),
+ ('yolov8n-seg', 'torchscript'),
+ ('yolov8n-cls', 'torchscript'),
+ ('yolov8n-pose', 'torchscript'), ] # (model, format)
+
+
+def run(cmd):
+ """Execute a shell command using subprocess."""
+ subprocess.run(cmd.split(), check=True)
+
+
+def test_special_modes():
+ """Test various special command modes of YOLO."""
+ run('yolo help')
+ run('yolo checks')
+ run('yolo version')
+ run('yolo settings reset')
+ run('yolo cfg')
+
+
+@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+def test_train(task, model, data):
+ """Test YOLO training for a given task, model, and data."""
+ run(f'yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 cache=disk')
+
+
+@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+def test_val(task, model, data):
+ """Test YOLO validation for a given task, model, and data."""
+ run(f'yolo val {task} model={WEIGHTS_DIR / model}.pt data={data} imgsz=32 save_txt save_json')
+
+
+@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+def test_predict(task, model, data):
+ """Test YOLO prediction on sample assets for a given task and model."""
+ run(f'yolo predict model={WEIGHTS_DIR / model}.pt source={ASSETS} imgsz=32 save save_crop save_txt')
+
+
+@pytest.mark.parametrize('model,format', EXPORT_ARGS)
+def test_export(model, format):
+ """Test exporting a YOLO model to different formats."""
+ run(f'yolo export model={WEIGHTS_DIR / model}.pt format={format} imgsz=32')
+
+
+def test_rtdetr(task='detect', model='yolov8n-rtdetr.yaml', data='coco8.yaml'):
+ """Test the RTDETR functionality with the Ultralytics framework."""
+ # Warning: MUST use imgsz=640
+ run(f'yolo train {task} model={model} data={data} --imgsz= 640 epochs =1, cache = disk') # add coma, spaces to args
+ run(f"yolo predict {task} model={model} source={ASSETS / 'bus.jpg'} imgsz=640 save save_crop save_txt")
+
+
+def test_fastsam(task='segment', model=WEIGHTS_DIR / 'FastSAM-s.pt', data='coco8-seg.yaml'):
+ """Test FastSAM segmentation functionality within Ultralytics."""
+ source = ASSETS / 'bus.jpg'
+
+ run(f'yolo segment val {task} model={model} data={data} imgsz=32')
+ run(f'yolo segment predict model={model} source={source} imgsz=32 save save_crop save_txt')
+
+ from ultralytics import FastSAM
+ from ultralytics.models.fastsam import FastSAMPrompt
+ from ultralytics.models.sam import Predictor
+
+ # Create a FastSAM model
+ sam_model = FastSAM(model) # or FastSAM-x.pt
+
+ # Run inference on an image
+ everything_results = sam_model(source, device='cpu', retina_masks=True, imgsz=1024, conf=0.4, iou=0.9)
+
+ # Remove small regions
+ new_masks, _ = Predictor.remove_small_regions(everything_results[0].masks.data, min_area=20)
+
+ # Everything prompt
+ prompt_process = FastSAMPrompt(source, everything_results, device='cpu')
+ ann = prompt_process.everything_prompt()
+
+ # Bbox default shape [0,0,0,0] -> [x1,y1,x2,y2]
+ ann = prompt_process.box_prompt(bbox=[200, 200, 300, 300])
+
+ # Text prompt
+ ann = prompt_process.text_prompt(text='a photo of a dog')
+
+ # Point prompt
+ # Points default [[0,0]] [[x1,y1],[x2,y2]]
+ # Point_label default [0] [1,0] 0:background, 1:foreground
+ ann = prompt_process.point_prompt(points=[[200, 200]], pointlabel=[1])
+ prompt_process.plot(annotations=ann, output='./')
+
+
+def test_mobilesam():
+ """Test MobileSAM segmentation functionality using Ultralytics."""
+ from ultralytics import SAM
+
+ # Load the model
+ model = SAM(WEIGHTS_DIR / 'mobile_sam.pt')
+
+ # Source
+ source = ASSETS / 'zidane.jpg'
+
+ # Predict a segment based on a point prompt
+ model.predict(source, points=[900, 370], labels=[1])
+
+ # Predict a segment based on a box prompt
+ model.predict(source, bboxes=[439, 437, 524, 709])
+
+ # Predict all
+ # model(source)
+
+
+# Slow Tests -----------------------------------------------------------------------------------------------------------
+@pytest.mark.slow
+@pytest.mark.parametrize('task,model,data', TASK_ARGS)
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+@pytest.mark.skipif(CUDA_DEVICE_COUNT < 2, reason='DDP is not available')
+def test_train_gpu(task, model, data):
+ """Test YOLO training on GPU(s) for various tasks and models."""
+ run(f'yolo train {task} model={model}.yaml data={data} imgsz=32 epochs=1 device=0') # single GPU
+ run(f'yolo train {task} model={model}.pt data={data} imgsz=32 epochs=1 device=0,1') # multi GPU
diff --git a/ultralytics/tests/test_cuda.py b/ultralytics/tests/test_cuda.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ef1104f027de7ca6703fb9d59a1cf2a288a233e
--- /dev/null
+++ b/ultralytics/tests/test_cuda.py
@@ -0,0 +1,105 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import pytest
+import torch
+
+from ultralytics import YOLO
+from ultralytics.utils import ASSETS, WEIGHTS_DIR, checks
+
+CUDA_IS_AVAILABLE = checks.cuda_is_available()
+CUDA_DEVICE_COUNT = checks.cuda_device_count()
+
+MODEL = WEIGHTS_DIR / 'path with spaces' / 'yolov8n.pt' # test spaces in path
+DATA = 'coco8.yaml'
+BUS = ASSETS / 'bus.jpg'
+
+
+def test_checks():
+ """Validate CUDA settings against torch CUDA functions."""
+ assert torch.cuda.is_available() == CUDA_IS_AVAILABLE
+ assert torch.cuda.device_count() == CUDA_DEVICE_COUNT
+
+
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+def test_train():
+ """Test model training on a minimal dataset."""
+ device = 0 if CUDA_DEVICE_COUNT == 1 else [0, 1]
+ YOLO(MODEL).train(data=DATA, imgsz=64, epochs=1, device=device) # requires imgsz>=64
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+def test_predict_multiple_devices():
+ """Validate model prediction on multiple devices."""
+ model = YOLO('yolov8n.pt')
+ model = model.cpu()
+ assert str(model.device) == 'cpu'
+ _ = model(BUS) # CPU inference
+ assert str(model.device) == 'cpu'
+
+ model = model.to('cuda:0')
+ assert str(model.device) == 'cuda:0'
+ _ = model(BUS) # CUDA inference
+ assert str(model.device) == 'cuda:0'
+
+ model = model.cpu()
+ assert str(model.device) == 'cpu'
+ _ = model(BUS) # CPU inference
+ assert str(model.device) == 'cpu'
+
+ model = model.cuda()
+ assert str(model.device) == 'cuda:0'
+ _ = model(BUS) # CUDA inference
+ assert str(model.device) == 'cuda:0'
+
+
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+def test_autobatch():
+ """Check batch size for YOLO model using autobatch."""
+ from ultralytics.utils.autobatch import check_train_batch_size
+
+ check_train_batch_size(YOLO(MODEL).model.cuda(), imgsz=128, amp=True)
+
+
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+def test_utils_benchmarks():
+ """Profile YOLO models for performance benchmarks."""
+ from ultralytics.utils.benchmarks import ProfileModels
+
+ # Pre-export a dynamic engine model to use dynamic inference
+ YOLO(MODEL).export(format='engine', imgsz=32, dynamic=True, batch=1)
+ ProfileModels([MODEL], imgsz=32, half=False, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
+
+
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason='CUDA is not available')
+def test_predict_sam():
+ """Test SAM model prediction with various prompts."""
+ from ultralytics import SAM
+ from ultralytics.models.sam import Predictor as SAMPredictor
+
+ # Load a model
+ model = SAM(WEIGHTS_DIR / 'sam_b.pt')
+
+ # Display model information (optional)
+ model.info()
+
+ # Run inference
+ model(BUS, device=0)
+
+ # Run inference with bboxes prompt
+ model(BUS, bboxes=[439, 437, 524, 709], device=0)
+
+ # Run inference with points prompt
+ model(ASSETS / 'zidane.jpg', points=[900, 370], labels=[1], device=0)
+
+ # Create SAMPredictor
+ overrides = dict(conf=0.25, task='segment', mode='predict', imgsz=1024, model=WEIGHTS_DIR / 'mobile_sam.pt')
+ predictor = SAMPredictor(overrides=overrides)
+
+ # Set image
+ predictor.set_image(ASSETS / 'zidane.jpg') # set with image file
+ # predictor(bboxes=[439, 437, 524, 709])
+ # predictor(points=[900, 370], labels=[1])
+
+ # Reset image
+ predictor.reset_image()
diff --git a/ultralytics/tests/test_engine.py b/ultralytics/tests/test_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce328efca4d9e8ebdfa81e2543e9a3a587252890
--- /dev/null
+++ b/ultralytics/tests/test_engine.py
@@ -0,0 +1,128 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from ultralytics import YOLO
+from ultralytics.cfg import get_cfg
+from ultralytics.engine.exporter import Exporter
+from ultralytics.models.yolo import classify, detect, segment
+from ultralytics.utils import ASSETS, DEFAULT_CFG, WEIGHTS_DIR
+
+CFG_DET = 'yolov8n.yaml'
+CFG_SEG = 'yolov8n-seg.yaml'
+CFG_CLS = 'yolov8n-cls.yaml' # or 'squeezenet1_0'
+CFG = get_cfg(DEFAULT_CFG)
+MODEL = WEIGHTS_DIR / 'yolov8n'
+
+
+def test_func(*args): # noqa
+ """Test function callback."""
+ print('callback test passed')
+
+
+def test_export():
+ """Test model exporting functionality."""
+ exporter = Exporter()
+ exporter.add_callback('on_export_start', test_func)
+ assert test_func in exporter.callbacks['on_export_start'], 'callback test failed'
+ f = exporter(model=YOLO(CFG_DET).model)
+ YOLO(f)(ASSETS) # exported model inference
+
+
+def test_detect():
+ """Test object detection functionality."""
+ overrides = {'data': 'coco8.yaml', 'model': CFG_DET, 'imgsz': 32, 'epochs': 1, 'save': False}
+ CFG.data = 'coco8.yaml'
+ CFG.imgsz = 32
+
+ # Trainer
+ trainer = detect.DetectionTrainer(overrides=overrides)
+ trainer.add_callback('on_train_start', test_func)
+ assert test_func in trainer.callbacks['on_train_start'], 'callback test failed'
+ trainer.train()
+
+ # Validator
+ val = detect.DetectionValidator(args=CFG)
+ val.add_callback('on_val_start', test_func)
+ assert test_func in val.callbacks['on_val_start'], 'callback test failed'
+ val(model=trainer.best) # validate best.pt
+
+ # Predictor
+ pred = detect.DetectionPredictor(overrides={'imgsz': [64, 64]})
+ pred.add_callback('on_predict_start', test_func)
+ assert test_func in pred.callbacks['on_predict_start'], 'callback test failed'
+ result = pred(source=ASSETS, model=f'{MODEL}.pt')
+ assert len(result), 'predictor test failed'
+
+ overrides['resume'] = trainer.last
+ trainer = detect.DetectionTrainer(overrides=overrides)
+ try:
+ trainer.train()
+ except Exception as e:
+ print(f'Expected exception caught: {e}')
+ return
+
+ Exception('Resume test failed!')
+
+
+def test_segment():
+ """Test image segmentation functionality."""
+ overrides = {'data': 'coco8-seg.yaml', 'model': CFG_SEG, 'imgsz': 32, 'epochs': 1, 'save': False}
+ CFG.data = 'coco8-seg.yaml'
+ CFG.imgsz = 32
+ # YOLO(CFG_SEG).train(**overrides) # works
+
+ # Trainer
+ trainer = segment.SegmentationTrainer(overrides=overrides)
+ trainer.add_callback('on_train_start', test_func)
+ assert test_func in trainer.callbacks['on_train_start'], 'callback test failed'
+ trainer.train()
+
+ # Validator
+ val = segment.SegmentationValidator(args=CFG)
+ val.add_callback('on_val_start', test_func)
+ assert test_func in val.callbacks['on_val_start'], 'callback test failed'
+ val(model=trainer.best) # validate best.pt
+
+ # Predictor
+ pred = segment.SegmentationPredictor(overrides={'imgsz': [64, 64]})
+ pred.add_callback('on_predict_start', test_func)
+ assert test_func in pred.callbacks['on_predict_start'], 'callback test failed'
+ result = pred(source=ASSETS, model=f'{MODEL}-seg.pt')
+ assert len(result), 'predictor test failed'
+
+ # Test resume
+ overrides['resume'] = trainer.last
+ trainer = segment.SegmentationTrainer(overrides=overrides)
+ try:
+ trainer.train()
+ except Exception as e:
+ print(f'Expected exception caught: {e}')
+ return
+
+ Exception('Resume test failed!')
+
+
+def test_classify():
+ """Test image classification functionality."""
+ overrides = {'data': 'imagenet10', 'model': CFG_CLS, 'imgsz': 32, 'epochs': 1, 'save': False}
+ CFG.data = 'imagenet10'
+ CFG.imgsz = 32
+ # YOLO(CFG_SEG).train(**overrides) # works
+
+ # Trainer
+ trainer = classify.ClassificationTrainer(overrides=overrides)
+ trainer.add_callback('on_train_start', test_func)
+ assert test_func in trainer.callbacks['on_train_start'], 'callback test failed'
+ trainer.train()
+
+ # Validator
+ val = classify.ClassificationValidator(args=CFG)
+ val.add_callback('on_val_start', test_func)
+ assert test_func in val.callbacks['on_val_start'], 'callback test failed'
+ val(model=trainer.best)
+
+ # Predictor
+ pred = classify.ClassificationPredictor(overrides={'imgsz': [64, 64]})
+ pred.add_callback('on_predict_start', test_func)
+ assert test_func in pred.callbacks['on_predict_start'], 'callback test failed'
+ result = pred(source=ASSETS, model=trainer.best)
+ assert len(result), 'predictor test failed'
diff --git a/ultralytics/tests/test_integrations.py b/ultralytics/tests/test_integrations.py
new file mode 100644
index 0000000000000000000000000000000000000000..896a6281ee5a99ce89fffded41d720957daef613
--- /dev/null
+++ b/ultralytics/tests/test_integrations.py
@@ -0,0 +1,117 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import contextlib
+from pathlib import Path
+
+import pytest
+
+from ultralytics import YOLO, download
+from ultralytics.utils import ASSETS, DATASETS_DIR, ROOT, SETTINGS, WEIGHTS_DIR
+from ultralytics.utils.checks import check_requirements
+
+MODEL = WEIGHTS_DIR / 'path with spaces' / 'yolov8n.pt' # test spaces in path
+CFG = 'yolov8n.yaml'
+SOURCE = ASSETS / 'bus.jpg'
+TMP = (ROOT / '../tests/tmp').resolve() # temp directory for test files
+
+
+@pytest.mark.skipif(not check_requirements('ray', install=False), reason='ray[tune] not installed')
+def test_model_ray_tune():
+ """Tune YOLO model with Ray optimization library."""
+ YOLO('yolov8n-cls.yaml').tune(use_ray=True,
+ data='imagenet10',
+ grace_period=1,
+ iterations=1,
+ imgsz=32,
+ epochs=1,
+ plots=False,
+ device='cpu')
+
+
+@pytest.mark.skipif(not check_requirements('mlflow', install=False), reason='mlflow not installed')
+def test_mlflow():
+ """Test training with MLflow tracking enabled."""
+ SETTINGS['mlflow'] = True
+ YOLO('yolov8n-cls.yaml').train(data='imagenet10', imgsz=32, epochs=3, plots=False, device='cpu')
+
+
+@pytest.mark.skipif(not check_requirements('tritonclient', install=False), reason='tritonclient[all] not installed')
+def test_triton():
+ """Test NVIDIA Triton Server functionalities."""
+ check_requirements('tritonclient[all]')
+ import subprocess
+ import time
+
+ from tritonclient.http import InferenceServerClient # noqa
+
+ # Create variables
+ model_name = 'yolo'
+ triton_repo_path = TMP / 'triton_repo'
+ triton_model_path = triton_repo_path / model_name
+
+ # Export model to ONNX
+ f = YOLO(MODEL).export(format='onnx', dynamic=True)
+
+ # Prepare Triton repo
+ (triton_model_path / '1').mkdir(parents=True, exist_ok=True)
+ Path(f).rename(triton_model_path / '1' / 'model.onnx')
+ (triton_model_path / 'config.pdtxt').touch()
+
+ # Define image https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver
+ tag = 'nvcr.io/nvidia/tritonserver:23.09-py3' # 6.4 GB
+
+ # Pull the image
+ subprocess.call(f'docker pull {tag}', shell=True)
+
+ # Run the Triton server and capture the container ID
+ container_id = subprocess.check_output(
+ f'docker run -d --rm -v {triton_repo_path}:/models -p 8000:8000 {tag} tritonserver --model-repository=/models',
+ shell=True).decode('utf-8').strip()
+
+ # Wait for the Triton server to start
+ triton_client = InferenceServerClient(url='localhost:8000', verbose=False, ssl=False)
+
+ # Wait until model is ready
+ for _ in range(10):
+ with contextlib.suppress(Exception):
+ assert triton_client.is_model_ready(model_name)
+ break
+ time.sleep(1)
+
+ # Check Triton inference
+ YOLO(f'http://localhost:8000/{model_name}', 'detect')(SOURCE) # exported model inference
+
+ # Kill and remove the container at the end of the test
+ subprocess.call(f'docker kill {container_id}', shell=True)
+
+
+@pytest.mark.skipif(not check_requirements('pycocotools', install=False), reason='pycocotools not installed')
+def test_pycocotools():
+ """Validate model predictions using pycocotools."""
+ from ultralytics.models.yolo.detect import DetectionValidator
+ from ultralytics.models.yolo.pose import PoseValidator
+ from ultralytics.models.yolo.segment import SegmentationValidator
+
+ # Download annotations after each dataset downloads first
+ url = 'https://github.com/ultralytics/assets/releases/download/v0.0.0/'
+
+ args = {'model': 'yolov8n.pt', 'data': 'coco8.yaml', 'save_json': True, 'imgsz': 64}
+ validator = DetectionValidator(args=args)
+ validator()
+ validator.is_coco = True
+ download(f'{url}instances_val2017.json', dir=DATASETS_DIR / 'coco8/annotations')
+ _ = validator.eval_json(validator.stats)
+
+ args = {'model': 'yolov8n-seg.pt', 'data': 'coco8-seg.yaml', 'save_json': True, 'imgsz': 64}
+ validator = SegmentationValidator(args=args)
+ validator()
+ validator.is_coco = True
+ download(f'{url}instances_val2017.json', dir=DATASETS_DIR / 'coco8-seg/annotations')
+ _ = validator.eval_json(validator.stats)
+
+ args = {'model': 'yolov8n-pose.pt', 'data': 'coco8-pose.yaml', 'save_json': True, 'imgsz': 64}
+ validator = PoseValidator(args=args)
+ validator()
+ validator.is_coco = True
+ download(f'{url}person_keypoints_val2017.json', dir=DATASETS_DIR / 'coco8-pose/annotations')
+ _ = validator.eval_json(validator.stats)
diff --git a/ultralytics/tests/test_python.py b/ultralytics/tests/test_python.py
new file mode 100644
index 0000000000000000000000000000000000000000..395e756d143a849abf691b01d5c5e455fc6b1314
--- /dev/null
+++ b/ultralytics/tests/test_python.py
@@ -0,0 +1,501 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import contextlib
+from copy import copy
+from pathlib import Path
+
+import cv2
+import numpy as np
+import pytest
+import torch
+from PIL import Image
+from torchvision.transforms import ToTensor
+
+from ultralytics import RTDETR, YOLO
+from ultralytics.cfg import TASK2DATA
+from ultralytics.data.build import load_inference_source
+from ultralytics.utils import (ASSETS, DEFAULT_CFG, DEFAULT_CFG_PATH, LINUX, MACOS, ONLINE, ROOT, WEIGHTS_DIR, WINDOWS,
+ checks, is_dir_writeable)
+from ultralytics.utils.downloads import download
+from ultralytics.utils.torch_utils import TORCH_1_9
+
+MODEL = WEIGHTS_DIR / 'path with spaces' / 'yolov8n.pt' # test spaces in path
+CFG = 'yolov8n.yaml'
+SOURCE = ASSETS / 'bus.jpg'
+TMP = (ROOT / '../tests/tmp').resolve() # temp directory for test files
+IS_TMP_WRITEABLE = is_dir_writeable(TMP)
+
+
+def test_model_forward():
+ """Test the forward pass of the YOLO model."""
+ model = YOLO(CFG)
+ model(source=None, imgsz=32, augment=True) # also test no source and augment
+
+
+def test_model_methods():
+ """Test various methods and properties of the YOLO model."""
+ model = YOLO(MODEL)
+
+ # Model methods
+ model.info(verbose=True, detailed=True)
+ model = model.reset_weights()
+ model = model.load(MODEL)
+ model.to('cpu')
+ model.fuse()
+ model.clear_callback('on_train_start')
+ model.reset_callbacks()
+
+ # Model properties
+ _ = model.names
+ _ = model.device
+ _ = model.transforms
+ _ = model.task_map
+
+
+def test_model_profile():
+ """Test profiling of the YOLO model with 'profile=True' argument."""
+ from ultralytics.nn.tasks import DetectionModel
+
+ model = DetectionModel() # build model
+ im = torch.randn(1, 3, 64, 64) # requires min imgsz=64
+ _ = model.predict(im, profile=True)
+
+
+@pytest.mark.skipif(not IS_TMP_WRITEABLE, reason='directory is not writeable')
+def test_predict_txt():
+ """Test YOLO predictions with sources (file, dir, glob, recursive glob) specified in a text file."""
+ txt_file = TMP / 'sources.txt'
+ with open(txt_file, 'w') as f:
+ for x in [ASSETS / 'bus.jpg', ASSETS, ASSETS / '*', ASSETS / '**/*.jpg']:
+ f.write(f'{x}\n')
+ _ = YOLO(MODEL)(source=txt_file, imgsz=32)
+
+
+def test_predict_img():
+ """Test YOLO prediction on various types of image sources."""
+ model = YOLO(MODEL)
+ seg_model = YOLO(WEIGHTS_DIR / 'yolov8n-seg.pt')
+ cls_model = YOLO(WEIGHTS_DIR / 'yolov8n-cls.pt')
+ pose_model = YOLO(WEIGHTS_DIR / 'yolov8n-pose.pt')
+ im = cv2.imread(str(SOURCE))
+ assert len(model(source=Image.open(SOURCE), save=True, verbose=True, imgsz=32)) == 1 # PIL
+ assert len(model(source=im, save=True, save_txt=True, imgsz=32)) == 1 # ndarray
+ assert len(model(source=[im, im], save=True, save_txt=True, imgsz=32)) == 2 # batch
+ assert len(list(model(source=[im, im], save=True, stream=True, imgsz=32))) == 2 # stream
+ assert len(model(torch.zeros(320, 640, 3).numpy(), imgsz=32)) == 1 # tensor to numpy
+ batch = [
+ str(SOURCE), # filename
+ Path(SOURCE), # Path
+ 'https://ultralytics.com/images/zidane.jpg' if ONLINE else SOURCE, # URI
+ cv2.imread(str(SOURCE)), # OpenCV
+ Image.open(SOURCE), # PIL
+ np.zeros((320, 640, 3))] # numpy
+ assert len(model(batch, imgsz=32)) == len(batch) # multiple sources in a batch
+
+ # Test tensor inference
+ im = cv2.imread(str(SOURCE)) # OpenCV
+ t = cv2.resize(im, (32, 32))
+ t = ToTensor()(t)
+ t = torch.stack([t, t, t, t])
+ results = model(t, imgsz=32)
+ assert len(results) == t.shape[0]
+ results = seg_model(t, imgsz=32)
+ assert len(results) == t.shape[0]
+ results = cls_model(t, imgsz=32)
+ assert len(results) == t.shape[0]
+ results = pose_model(t, imgsz=32)
+ assert len(results) == t.shape[0]
+
+
+def test_predict_grey_and_4ch():
+ """Test YOLO prediction on SOURCE converted to greyscale and 4-channel images."""
+ im = Image.open(SOURCE)
+ directory = TMP / 'im4'
+ directory.mkdir(parents=True, exist_ok=True)
+
+ source_greyscale = directory / 'greyscale.jpg'
+ source_rgba = directory / '4ch.png'
+ source_non_utf = directory / 'non_UTF_测试文件_tést_image.jpg'
+ source_spaces = directory / 'image with spaces.jpg'
+
+ im.convert('L').save(source_greyscale) # greyscale
+ im.convert('RGBA').save(source_rgba) # 4-ch PNG with alpha
+ im.save(source_non_utf) # non-UTF characters in filename
+ im.save(source_spaces) # spaces in filename
+
+ # Inference
+ model = YOLO(MODEL)
+ for f in source_rgba, source_greyscale, source_non_utf, source_spaces:
+ for source in Image.open(f), cv2.imread(str(f)), f:
+ results = model(source, save=True, verbose=True, imgsz=32)
+ assert len(results) == 1 # verify that an image was run
+ f.unlink() # cleanup
+
+
+@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+@pytest.mark.skipif(not IS_TMP_WRITEABLE, reason='directory is not writeable')
+def test_track_stream():
+ """
+ Test YouTube streaming tracking (short 10 frame video) with non-default ByteTrack tracker.
+
+ Note imgsz=160 required for tracking for higher confidence and better matches
+ """
+ import yaml
+
+ model = YOLO(MODEL)
+ model.predict('https://youtu.be/G17sBkb38XQ', imgsz=96, save=True)
+ model.track('https://ultralytics.com/assets/decelera_portrait_min.mov', imgsz=160, tracker='bytetrack.yaml')
+ model.track('https://ultralytics.com/assets/decelera_portrait_min.mov', imgsz=160, tracker='botsort.yaml')
+
+ # Test Global Motion Compensation (GMC) methods
+ for gmc in 'orb', 'sift', 'ecc':
+ with open(ROOT / 'cfg/trackers/botsort.yaml', encoding='utf-8') as f:
+ data = yaml.safe_load(f)
+ tracker = TMP / f'botsort-{gmc}.yaml'
+ data['gmc_method'] = gmc
+ with open(tracker, 'w', encoding='utf-8') as f:
+ yaml.safe_dump(data, f)
+ model.track('https://ultralytics.com/assets/decelera_portrait_min.mov', imgsz=160, tracker=tracker)
+
+
+def test_val():
+ """Test the validation mode of the YOLO model."""
+ YOLO(MODEL).val(data='coco8.yaml', imgsz=32, save_hybrid=True)
+
+
+def test_train_scratch():
+ """Test training the YOLO model from scratch."""
+ model = YOLO(CFG)
+ model.train(data='coco8.yaml', epochs=2, imgsz=32, cache='disk', batch=-1, close_mosaic=1, name='model')
+ model(SOURCE)
+
+
+def test_train_pretrained():
+ """Test training the YOLO model from a pre-trained state."""
+ model = YOLO(WEIGHTS_DIR / 'yolov8n-seg.pt')
+ model.train(data='coco8-seg.yaml', epochs=1, imgsz=32, cache='ram', copy_paste=0.5, mixup=0.5, name=0)
+ model(SOURCE)
+
+
+def test_export_torchscript():
+ """Test exporting the YOLO model to TorchScript format."""
+ f = YOLO(MODEL).export(format='torchscript', optimize=False)
+ YOLO(f)(SOURCE) # exported model inference
+
+
+def test_export_onnx():
+ """Test exporting the YOLO model to ONNX format."""
+ f = YOLO(MODEL).export(format='onnx', dynamic=True)
+ YOLO(f)(SOURCE) # exported model inference
+
+
+def test_export_openvino():
+ """Test exporting the YOLO model to OpenVINO format."""
+ f = YOLO(MODEL).export(format='openvino')
+ YOLO(f)(SOURCE) # exported model inference
+
+
+def test_export_coreml():
+ """Test exporting the YOLO model to CoreML format."""
+ if not WINDOWS: # RuntimeError: BlobWriter not loaded with coremltools 7.0 on windows
+ if MACOS:
+ f = YOLO(MODEL).export(format='coreml')
+ YOLO(f)(SOURCE) # model prediction only supported on macOS for nms=False models
+ else:
+ YOLO(MODEL).export(format='coreml', nms=True)
+
+
+def test_export_tflite(enabled=False):
+ """
+ Test exporting the YOLO model to TFLite format.
+
+ Note TF suffers from install conflicts on Windows and macOS.
+ """
+ if enabled and LINUX:
+ model = YOLO(MODEL)
+ f = model.export(format='tflite')
+ YOLO(f)(SOURCE)
+
+
+def test_export_pb(enabled=False):
+ """
+ Test exporting the YOLO model to *.pb format.
+
+ Note TF suffers from install conflicts on Windows and macOS.
+ """
+ if enabled and LINUX:
+ model = YOLO(MODEL)
+ f = model.export(format='pb')
+ YOLO(f)(SOURCE)
+
+
+def test_export_paddle(enabled=False):
+ """
+ Test exporting the YOLO model to Paddle format.
+
+ Note Paddle protobuf requirements conflicting with onnx protobuf requirements.
+ """
+ if enabled:
+ YOLO(MODEL).export(format='paddle')
+
+
+@pytest.mark.slow
+def test_export_ncnn():
+ """Test exporting the YOLO model to NCNN format."""
+ f = YOLO(MODEL).export(format='ncnn')
+ YOLO(f)(SOURCE) # exported model inference
+
+
+def test_all_model_yamls():
+ """Test YOLO model creation for all available YAML configurations."""
+ for m in (ROOT / 'cfg' / 'models').rglob('*.yaml'):
+ if 'rtdetr' in m.name:
+ if TORCH_1_9: # torch<=1.8 issue - TypeError: __init__() got an unexpected keyword argument 'batch_first'
+ _ = RTDETR(m.name)(SOURCE, imgsz=640) # must be 640
+ else:
+ YOLO(m.name)
+
+
+def test_workflow():
+ """Test the complete workflow including training, validation, prediction, and exporting."""
+ model = YOLO(MODEL)
+ model.train(data='coco8.yaml', epochs=1, imgsz=32, optimizer='SGD')
+ model.val(imgsz=32)
+ model.predict(SOURCE, imgsz=32)
+ model.export(format='onnx') # export a model to ONNX format
+
+
+def test_predict_callback_and_setup():
+ """Test callback functionality during YOLO prediction."""
+
+ def on_predict_batch_end(predictor):
+ """Callback function that handles operations at the end of a prediction batch."""
+ path, im0s, _, _ = predictor.batch
+ im0s = im0s if isinstance(im0s, list) else [im0s]
+ bs = [predictor.dataset.bs for _ in range(len(path))]
+ predictor.results = zip(predictor.results, im0s, bs) # results is List[batch_size]
+
+ model = YOLO(MODEL)
+ model.add_callback('on_predict_batch_end', on_predict_batch_end)
+
+ dataset = load_inference_source(source=SOURCE)
+ bs = dataset.bs # noqa access predictor properties
+ results = model.predict(dataset, stream=True, imgsz=160) # source already setup
+ for r, im0, bs in results:
+ print('test_callback', im0.shape)
+ print('test_callback', bs)
+ boxes = r.boxes # Boxes object for bbox outputs
+ print(boxes)
+
+
+def test_results():
+ """Test various result formats for the YOLO model."""
+ for m in 'yolov8n-pose.pt', 'yolov8n-seg.pt', 'yolov8n.pt', 'yolov8n-cls.pt':
+ results = YOLO(WEIGHTS_DIR / m)([SOURCE, SOURCE], imgsz=160)
+ for r in results:
+ r = r.cpu().numpy()
+ r = r.to(device='cpu', dtype=torch.float32)
+ r.save_txt(txt_file=TMP / 'runs/tests/label.txt', save_conf=True)
+ r.save_crop(save_dir=TMP / 'runs/tests/crops/')
+ r.tojson(normalize=True)
+ r.plot(pil=True)
+ r.plot(conf=True, boxes=True)
+ print(r, len(r), r.path)
+
+
+@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+def test_data_utils():
+ """Test utility functions in ultralytics/data/utils.py."""
+ from ultralytics.data.utils import HUBDatasetStats, autosplit
+ from ultralytics.utils.downloads import zip_directory
+
+ # from ultralytics.utils.files import WorkingDirectory
+ # with WorkingDirectory(ROOT.parent / 'tests'):
+
+ for task in 'detect', 'segment', 'pose', 'classify':
+ file = Path(TASK2DATA[task]).with_suffix('.zip') # i.e. coco8.zip
+ download(f'https://github.com/ultralytics/hub/raw/main/example_datasets/{file}', unzip=False, dir=TMP)
+ stats = HUBDatasetStats(TMP / file, task=task)
+ stats.get_json(save=True)
+ stats.process_images()
+
+ autosplit(TMP / 'coco8')
+ zip_directory(TMP / 'coco8/images/val') # zip
+
+
+@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+def test_data_converter():
+ """Test dataset converters."""
+ from ultralytics.data.converter import coco80_to_coco91_class, convert_coco
+
+ file = 'instances_val2017.json'
+ download(f'https://github.com/ultralytics/yolov5/releases/download/v1.0/{file}', dir=TMP)
+ convert_coco(labels_dir=TMP, save_dir=TMP / 'yolo_labels', use_segments=True, use_keypoints=False, cls91to80=True)
+ coco80_to_coco91_class()
+
+
+def test_data_annotator():
+ """Test automatic data annotation."""
+ from ultralytics.data.annotator import auto_annotate
+
+ auto_annotate(ASSETS,
+ det_model=WEIGHTS_DIR / 'yolov8n.pt',
+ sam_model=WEIGHTS_DIR / 'mobile_sam.pt',
+ output_dir=TMP / 'auto_annotate_labels')
+
+
+def test_events():
+ """Test event sending functionality."""
+ from ultralytics.hub.utils import Events
+
+ events = Events()
+ events.enabled = True
+ cfg = copy(DEFAULT_CFG) # does not require deepcopy
+ cfg.mode = 'test'
+ events(cfg)
+
+
+def test_cfg_init():
+ """Test configuration initialization utilities."""
+ from ultralytics.cfg import check_dict_alignment, copy_default_cfg, smart_value
+
+ with contextlib.suppress(SyntaxError):
+ check_dict_alignment({'a': 1}, {'b': 2})
+ copy_default_cfg()
+ (Path.cwd() / DEFAULT_CFG_PATH.name.replace('.yaml', '_copy.yaml')).unlink(missing_ok=False)
+ [smart_value(x) for x in ['none', 'true', 'false']]
+
+
+def test_utils_init():
+ """Test initialization utilities."""
+ from ultralytics.utils import get_git_branch, get_git_origin_url, get_ubuntu_version, is_github_actions_ci
+
+ get_ubuntu_version()
+ is_github_actions_ci()
+ get_git_origin_url()
+ get_git_branch()
+
+
+def test_utils_checks():
+ """Test various utility checks."""
+ checks.check_yolov5u_filename('yolov5n.pt')
+ checks.git_describe(ROOT)
+ checks.check_requirements() # check requirements.txt
+ checks.check_imgsz([600, 600], max_dim=1)
+ checks.check_imshow()
+ checks.check_version('ultralytics', '8.0.0')
+ checks.print_args()
+ # checks.check_imshow(warn=True)
+
+
+def test_utils_benchmarks():
+ """Test model benchmarking."""
+ from ultralytics.utils.benchmarks import ProfileModels
+
+ ProfileModels(['yolov8n.yaml'], imgsz=32, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
+
+
+def test_utils_torchutils():
+ """Test Torch utility functions."""
+ from ultralytics.nn.modules.conv import Conv
+ from ultralytics.utils.torch_utils import get_flops_with_torch_profiler, profile, time_sync
+
+ x = torch.randn(1, 64, 20, 20)
+ m = Conv(64, 64, k=1, s=2)
+
+ profile(x, [m], n=3)
+ get_flops_with_torch_profiler(m)
+ time_sync()
+
+
+@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+def test_utils_downloads():
+ """Test file download utilities."""
+ from ultralytics.utils.downloads import get_google_drive_file_info
+
+ get_google_drive_file_info('https://drive.google.com/file/d/1cqT-cJgANNrhIHCrEufUYhQ4RqiWG_lJ/view?usp=drive_link')
+
+
+def test_utils_ops():
+ """Test various operations utilities."""
+ from ultralytics.utils.ops import (ltwh2xywh, ltwh2xyxy, make_divisible, xywh2ltwh, xywh2xyxy, xywhn2xyxy,
+ xywhr2xyxyxyxy, xyxy2ltwh, xyxy2xywh, xyxy2xywhn, xyxyxyxy2xywhr)
+
+ make_divisible(17, torch.tensor([8]))
+
+ boxes = torch.rand(10, 4) # xywh
+ torch.allclose(boxes, xyxy2xywh(xywh2xyxy(boxes)))
+ torch.allclose(boxes, xyxy2xywhn(xywhn2xyxy(boxes)))
+ torch.allclose(boxes, ltwh2xywh(xywh2ltwh(boxes)))
+ torch.allclose(boxes, xyxy2ltwh(ltwh2xyxy(boxes)))
+
+ boxes = torch.rand(10, 5) # xywhr for OBB
+ boxes[:, 4] = torch.randn(10) * 30
+ torch.allclose(boxes, xyxyxyxy2xywhr(xywhr2xyxyxyxy(boxes)), rtol=1e-3)
+
+
+def test_utils_files():
+ """Test file handling utilities."""
+ from ultralytics.utils.files import file_age, file_date, get_latest_run, spaces_in_path
+
+ file_age(SOURCE)
+ file_date(SOURCE)
+ get_latest_run(ROOT / 'runs')
+
+ path = TMP / 'path/with spaces'
+ path.mkdir(parents=True, exist_ok=True)
+ with spaces_in_path(path) as new_path:
+ print(new_path)
+
+
+def test_nn_modules_conv():
+ """Test Convolutional Neural Network modules."""
+ from ultralytics.nn.modules.conv import CBAM, Conv2, ConvTranspose, DWConvTranspose2d, Focus
+
+ c1, c2 = 8, 16 # input and output channels
+ x = torch.zeros(4, c1, 10, 10) # BCHW
+
+ # Run all modules not otherwise covered in tests
+ DWConvTranspose2d(c1, c2)(x)
+ ConvTranspose(c1, c2)(x)
+ Focus(c1, c2)(x)
+ CBAM(c1)(x)
+
+ # Fuse ops
+ m = Conv2(c1, c2)
+ m.fuse_convs()
+ m(x)
+
+
+def test_nn_modules_block():
+ """Test Neural Network block modules."""
+ from ultralytics.nn.modules.block import C1, C3TR, BottleneckCSP, C3Ghost, C3x
+
+ c1, c2 = 8, 16 # input and output channels
+ x = torch.zeros(4, c1, 10, 10) # BCHW
+
+ # Run all modules not otherwise covered in tests
+ C1(c1, c2)(x)
+ C3x(c1, c2)(x)
+ C3TR(c1, c2)(x)
+ C3Ghost(c1, c2)(x)
+ BottleneckCSP(c1, c2)(x)
+
+
+@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+def test_hub():
+ """Test Ultralytics HUB functionalities."""
+ from ultralytics.hub import export_fmts_hub, logout
+ from ultralytics.hub.utils import smart_request
+
+ export_fmts_hub()
+ logout()
+ smart_request('GET', 'http://github.com', progress=True)
+
+
+@pytest.mark.slow
+@pytest.mark.skipif(not ONLINE, reason='environment is offline')
+def test_model_tune():
+ """Tune YOLO model for performance."""
+ YOLO('yolov8n-pose.pt').tune(data='coco8-pose.yaml', plots=False, imgsz=32, epochs=1, iterations=2, device='cpu')
+ YOLO('yolov8n-cls.pt').tune(data='imagenet10', plots=False, imgsz=32, epochs=1, iterations=2, device='cpu')
diff --git a/ultralytics/ultralytics/__init__.py b/ultralytics/ultralytics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..726e11044c8b71440fab707be401674c360b1ef1
--- /dev/null
+++ b/ultralytics/ultralytics/__init__.py
@@ -0,0 +1,12 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+__version__ = '8.0.208'
+
+from ultralytics.models import RTDETR, SAM, YOLO
+from ultralytics.models.fastsam import FastSAM
+from ultralytics.models.nas import NAS
+from ultralytics.utils import SETTINGS as settings
+from ultralytics.utils.checks import check_yolo as checks
+from ultralytics.utils.downloads import download
+
+__all__ = '__version__', 'YOLO', 'NAS', 'SAM', 'FastSAM', 'RTDETR', 'checks', 'download', 'settings'
diff --git a/ultralytics/ultralytics/assets/bus.jpg b/ultralytics/ultralytics/assets/bus.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..40eaaf5c330d0c498fbe1dcacf9bb8bf566797fe
Binary files /dev/null and b/ultralytics/ultralytics/assets/bus.jpg differ
diff --git a/ultralytics/ultralytics/assets/zidane.jpg b/ultralytics/ultralytics/assets/zidane.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..eeab1cdcb282b0e026a57c5bf85df36024b4e1f6
Binary files /dev/null and b/ultralytics/ultralytics/assets/zidane.jpg differ
diff --git a/ultralytics/ultralytics/cfg/__init__.py b/ultralytics/ultralytics/cfg/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..226d48946c97eaa46d691e1a094334ea66eb4557
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/__init__.py
@@ -0,0 +1,461 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import contextlib
+import shutil
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Dict, List, Union
+
+from ultralytics.utils import (ASSETS, DEFAULT_CFG, DEFAULT_CFG_DICT, DEFAULT_CFG_PATH, LOGGER, RANK, ROOT, RUNS_DIR,
+ SETTINGS, SETTINGS_YAML, TESTS_RUNNING, IterableSimpleNamespace, __version__, checks,
+ colorstr, deprecation_warn, yaml_load, yaml_print)
+
+# Define valid tasks and modes
+MODES = 'train', 'val', 'predict', 'export', 'track', 'benchmark'
+TASKS = 'detect', 'segment', 'classify', 'pose'
+TASK2DATA = {'detect': 'coco8.yaml', 'segment': 'coco8-seg.yaml', 'classify': 'imagenet10', 'pose': 'coco8-pose.yaml'}
+TASK2MODEL = {
+ 'detect': 'yolov8n.pt',
+ 'segment': 'yolov8n-seg.pt',
+ 'classify': 'yolov8n-cls.pt',
+ 'pose': 'yolov8n-pose.pt'}
+TASK2METRIC = {
+ 'detect': 'metrics/mAP50-95(B)',
+ 'segment': 'metrics/mAP50-95(M)',
+ 'classify': 'metrics/accuracy_top1',
+ 'pose': 'metrics/mAP50-95(P)'}
+
+CLI_HELP_MSG = \
+ f"""
+ Arguments received: {str(['yolo'] + sys.argv[1:])}. Ultralytics 'yolo' commands use the following syntax:
+
+ yolo TASK MODE ARGS
+
+ Where TASK (optional) is one of {TASKS}
+ MODE (required) is one of {MODES}
+ ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
+ See all ARGS at https://docs.ultralytics.com/usage/cfg or with 'yolo cfg'
+
+ 1. Train a detection model for 10 epochs with an initial learning_rate of 0.01
+ yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+
+ 2. Predict a YouTube video using a pretrained segmentation model at image size 320:
+ yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+
+ 3. Val a pretrained detection model at batch-size 1 and image size 640:
+ yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
+
+ 4. Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
+ yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+
+ 5. Run special commands:
+ yolo help
+ yolo checks
+ yolo version
+ yolo settings
+ yolo copy-cfg
+ yolo cfg
+
+ Docs: https://docs.ultralytics.com
+ Community: https://community.ultralytics.com
+ GitHub: https://github.com/ultralytics/ultralytics
+ """
+
+# Define keys for arg type checks
+CFG_FLOAT_KEYS = 'warmup_epochs', 'box', 'cls', 'dfl', 'degrees', 'shear'
+CFG_FRACTION_KEYS = ('dropout', 'iou', 'lr0', 'lrf', 'momentum', 'weight_decay', 'warmup_momentum', 'warmup_bias_lr',
+ 'label_smoothing', 'hsv_h', 'hsv_s', 'hsv_v', 'translate', 'scale', 'perspective', 'flipud',
+ 'fliplr', 'mosaic', 'mixup', 'copy_paste', 'conf', 'iou', 'fraction') # fraction floats 0.0 - 1.0
+CFG_INT_KEYS = ('epochs', 'patience', 'batch', 'workers', 'seed', 'close_mosaic', 'mask_ratio', 'max_det', 'vid_stride',
+ 'line_width', 'workspace', 'nbs', 'save_period')
+CFG_BOOL_KEYS = ('save', 'exist_ok', 'verbose', 'deterministic', 'single_cls', 'rect', 'cos_lr', 'overlap_mask', 'val',
+ 'save_json', 'save_hybrid', 'half', 'dnn', 'plots', 'show', 'save_txt', 'save_conf', 'save_crop',
+ 'show_labels', 'show_conf', 'visualize', 'augment', 'agnostic_nms', 'retina_masks', 'boxes', 'keras',
+ 'optimize', 'int8', 'dynamic', 'simplify', 'nms', 'profile')
+
+
+def cfg2dict(cfg):
+ """
+ Convert a configuration object to a dictionary, whether it is a file path, a string, or a SimpleNamespace object.
+
+ Args:
+ cfg (str | Path | dict | SimpleNamespace): Configuration object to be converted to a dictionary.
+
+ Returns:
+ cfg (dict): Configuration object in dictionary format.
+ """
+ if isinstance(cfg, (str, Path)):
+ cfg = yaml_load(cfg) # load dict
+ elif isinstance(cfg, SimpleNamespace):
+ cfg = vars(cfg) # convert to dict
+ return cfg
+
+
+def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, overrides: Dict = None):
+ """
+ Load and merge configuration data from a file or dictionary.
+
+ Args:
+ cfg (str | Path | Dict | SimpleNamespace): Configuration data.
+ overrides (str | Dict | optional): Overrides in the form of a file name or a dictionary. Default is None.
+
+ Returns:
+ (SimpleNamespace): Training arguments namespace.
+ """
+ cfg = cfg2dict(cfg)
+
+ # Merge overrides
+ if overrides:
+ overrides = cfg2dict(overrides)
+ if 'save_dir' not in cfg:
+ overrides.pop('save_dir', None) # special override keys to ignore
+ check_dict_alignment(cfg, overrides)
+ cfg = {**cfg, **overrides} # merge cfg and overrides dicts (prefer overrides)
+
+ # Special handling for numeric project/name
+ for k in 'project', 'name':
+ if k in cfg and isinstance(cfg[k], (int, float)):
+ cfg[k] = str(cfg[k])
+ if cfg.get('name') == 'model': # assign model to 'name' arg
+ cfg['name'] = cfg.get('model', '').split('.')[0]
+ LOGGER.warning(f"WARNING ⚠️ 'name=model' automatically updated to 'name={cfg['name']}'.")
+
+ # Type and Value checks
+ for k, v in cfg.items():
+ if v is not None: # None values may be from optional args
+ if k in CFG_FLOAT_KEYS and not isinstance(v, (int, float)):
+ raise TypeError(f"'{k}={v}' is of invalid type {type(v).__name__}. "
+ f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')")
+ elif k in CFG_FRACTION_KEYS:
+ if not isinstance(v, (int, float)):
+ raise TypeError(f"'{k}={v}' is of invalid type {type(v).__name__}. "
+ f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')")
+ if not (0.0 <= v <= 1.0):
+ raise ValueError(f"'{k}={v}' is an invalid value. "
+ f"Valid '{k}' values are between 0.0 and 1.0.")
+ elif k in CFG_INT_KEYS and not isinstance(v, int):
+ raise TypeError(f"'{k}={v}' is of invalid type {type(v).__name__}. "
+ f"'{k}' must be an int (i.e. '{k}=8')")
+ elif k in CFG_BOOL_KEYS and not isinstance(v, bool):
+ raise TypeError(f"'{k}={v}' is of invalid type {type(v).__name__}. "
+ f"'{k}' must be a bool (i.e. '{k}=True' or '{k}=False')")
+
+ # Return instance
+ return IterableSimpleNamespace(**cfg)
+
+
+def get_save_dir(args, name=None):
+ """Return save_dir as created from train/val/predict arguments."""
+
+ if getattr(args, 'save_dir', None):
+ save_dir = args.save_dir
+ else:
+ from ultralytics.utils.files import increment_path
+
+ project = args.project or (ROOT.parent / 'tests/tmp/runs' if TESTS_RUNNING else RUNS_DIR) / args.task
+ name = name or args.name or f'{args.mode}'
+ save_dir = increment_path(Path(project) / name, exist_ok=args.exist_ok if RANK in (-1, 0) else True)
+
+ return Path(save_dir)
+
+
+def _handle_deprecation(custom):
+ """Hardcoded function to handle deprecated config keys."""
+
+ for key in custom.copy().keys():
+ if key == 'hide_labels':
+ deprecation_warn(key, 'show_labels')
+ custom['show_labels'] = custom.pop('hide_labels') == 'False'
+ if key == 'hide_conf':
+ deprecation_warn(key, 'show_conf')
+ custom['show_conf'] = custom.pop('hide_conf') == 'False'
+ if key == 'line_thickness':
+ deprecation_warn(key, 'line_width')
+ custom['line_width'] = custom.pop('line_thickness')
+
+ return custom
+
+
+def check_dict_alignment(base: Dict, custom: Dict, e=None):
+ """
+ This function checks for any mismatched keys between a custom configuration list and a base configuration list. If
+ any mismatched keys are found, the function prints out similar keys from the base list and exits the program.
+
+ Args:
+ custom (dict): a dictionary of custom configuration options
+ base (dict): a dictionary of base configuration options
+ e (Error, optional): An optional error that is passed by the calling function.
+ """
+ custom = _handle_deprecation(custom)
+ base_keys, custom_keys = (set(x.keys()) for x in (base, custom))
+ mismatched = [k for k in custom_keys if k not in base_keys]
+ if mismatched:
+ from difflib import get_close_matches
+
+ string = ''
+ for x in mismatched:
+ matches = get_close_matches(x, base_keys) # key list
+ matches = [f'{k}={base[k]}' if base.get(k) is not None else k for k in matches]
+ match_str = f'Similar arguments are i.e. {matches}.' if matches else ''
+ string += f"'{colorstr('red', 'bold', x)}' is not a valid YOLO argument. {match_str}\n"
+ raise SyntaxError(string + CLI_HELP_MSG) from e
+
+
+def merge_equals_args(args: List[str]) -> List[str]:
+ """
+ Merges arguments around isolated '=' args in a list of strings. The function considers cases where the first
+ argument ends with '=' or the second starts with '=', as well as when the middle one is an equals sign.
+
+ Args:
+ args (List[str]): A list of strings where each element is an argument.
+
+ Returns:
+ List[str]: A list of strings where the arguments around isolated '=' are merged.
+ """
+ new_args = []
+ for i, arg in enumerate(args):
+ if arg == '=' and 0 < i < len(args) - 1: # merge ['arg', '=', 'val']
+ new_args[-1] += f'={args[i + 1]}'
+ del args[i + 1]
+ elif arg.endswith('=') and i < len(args) - 1 and '=' not in args[i + 1]: # merge ['arg=', 'val']
+ new_args.append(f'{arg}{args[i + 1]}')
+ del args[i + 1]
+ elif arg.startswith('=') and i > 0: # merge ['arg', '=val']
+ new_args[-1] += arg
+ else:
+ new_args.append(arg)
+ return new_args
+
+
+def handle_yolo_hub(args: List[str]) -> None:
+ """
+ Handle Ultralytics HUB command-line interface (CLI) commands.
+
+ This function processes Ultralytics HUB CLI commands such as login and logout.
+ It should be called when executing a script with arguments related to HUB authentication.
+
+ Args:
+ args (List[str]): A list of command line arguments
+
+ Example:
+ ```bash
+ python my_script.py hub login your_api_key
+ ```
+ """
+ from ultralytics import hub
+
+ if args[0] == 'login':
+ key = args[1] if len(args) > 1 else ''
+ # Log in to Ultralytics HUB using the provided API key
+ hub.login(key)
+ elif args[0] == 'logout':
+ # Log out from Ultralytics HUB
+ hub.logout()
+
+
+def handle_yolo_settings(args: List[str]) -> None:
+ """
+ Handle YOLO settings command-line interface (CLI) commands.
+
+ This function processes YOLO settings CLI commands such as reset.
+ It should be called when executing a script with arguments related to YOLO settings management.
+
+ Args:
+ args (List[str]): A list of command line arguments for YOLO settings management.
+
+ Example:
+ ```bash
+ python my_script.py yolo settings reset
+ ```
+ """
+ url = 'https://docs.ultralytics.com/quickstart/#ultralytics-settings' # help URL
+ try:
+ if any(args):
+ if args[0] == 'reset':
+ SETTINGS_YAML.unlink() # delete the settings file
+ SETTINGS.reset() # create new settings
+ LOGGER.info('Settings reset successfully') # inform the user that settings have been reset
+ else: # save a new setting
+ new = dict(parse_key_value_pair(a) for a in args)
+ check_dict_alignment(SETTINGS, new)
+ SETTINGS.update(new)
+
+ LOGGER.info(f'💡 Learn about settings at {url}')
+ yaml_print(SETTINGS_YAML) # print the current settings
+ except Exception as e:
+ LOGGER.warning(f"WARNING ⚠️ settings error: '{e}'. Please see {url} for help.")
+
+
+def parse_key_value_pair(pair):
+ """Parse one 'key=value' pair and return key and value."""
+ k, v = pair.split('=', 1) # split on first '=' sign
+ k, v = k.strip(), v.strip() # remove spaces
+ assert v, f"missing '{k}' value"
+ return k, smart_value(v)
+
+
+def smart_value(v):
+ """Convert a string to an underlying type such as int, float, bool, etc."""
+ v_lower = v.lower()
+ if v_lower == 'none':
+ return None
+ elif v_lower == 'true':
+ return True
+ elif v_lower == 'false':
+ return False
+ else:
+ with contextlib.suppress(Exception):
+ return eval(v)
+ return v
+
+
+def entrypoint(debug=''):
+ """
+ This function is the ultralytics package entrypoint, it's responsible for parsing the command line arguments passed
+ to the package.
+
+ This function allows for:
+ - passing mandatory YOLO args as a list of strings
+ - specifying the task to be performed, either 'detect', 'segment' or 'classify'
+ - specifying the mode, either 'train', 'val', 'test', or 'predict'
+ - running special modes like 'checks'
+ - passing overrides to the package's configuration
+
+ It uses the package's default cfg and initializes it using the passed overrides.
+ Then it calls the CLI function with the composed cfg
+ """
+ args = (debug.split(' ') if debug else sys.argv)[1:]
+ if not args: # no arguments passed
+ LOGGER.info(CLI_HELP_MSG)
+ return
+
+ special = {
+ 'help': lambda: LOGGER.info(CLI_HELP_MSG),
+ 'checks': checks.collect_system_info,
+ 'version': lambda: LOGGER.info(__version__),
+ 'settings': lambda: handle_yolo_settings(args[1:]),
+ 'cfg': lambda: yaml_print(DEFAULT_CFG_PATH),
+ 'hub': lambda: handle_yolo_hub(args[1:]),
+ 'login': lambda: handle_yolo_hub(args),
+ 'copy-cfg': copy_default_cfg}
+ full_args_dict = {**DEFAULT_CFG_DICT, **{k: None for k in TASKS}, **{k: None for k in MODES}, **special}
+
+ # Define common misuses of special commands, i.e. -h, -help, --help
+ special.update({k[0]: v for k, v in special.items()}) # singular
+ special.update({k[:-1]: v for k, v in special.items() if len(k) > 1 and k.endswith('s')}) # singular
+ special = {**special, **{f'-{k}': v for k, v in special.items()}, **{f'--{k}': v for k, v in special.items()}}
+
+ overrides = {} # basic overrides, i.e. imgsz=320
+ for a in merge_equals_args(args): # merge spaces around '=' sign
+ if a.startswith('--'):
+ LOGGER.warning(f"WARNING ⚠️ '{a}' does not require leading dashes '--', updating to '{a[2:]}'.")
+ a = a[2:]
+ if a.endswith(','):
+ LOGGER.warning(f"WARNING ⚠️ '{a}' does not require trailing comma ',', updating to '{a[:-1]}'.")
+ a = a[:-1]
+ if '=' in a:
+ try:
+ k, v = parse_key_value_pair(a)
+ if k == 'cfg' and v is not None: # custom.yaml passed
+ LOGGER.info(f'Overriding {DEFAULT_CFG_PATH} with {v}')
+ overrides = {k: val for k, val in yaml_load(checks.check_yaml(v)).items() if k != 'cfg'}
+ else:
+ overrides[k] = v
+ except (NameError, SyntaxError, ValueError, AssertionError) as e:
+ check_dict_alignment(full_args_dict, {a: ''}, e)
+
+ elif a in TASKS:
+ overrides['task'] = a
+ elif a in MODES:
+ overrides['mode'] = a
+ elif a.lower() in special:
+ special[a.lower()]()
+ return
+ elif a in DEFAULT_CFG_DICT and isinstance(DEFAULT_CFG_DICT[a], bool):
+ overrides[a] = True # auto-True for default bool args, i.e. 'yolo show' sets show=True
+ elif a in DEFAULT_CFG_DICT:
+ raise SyntaxError(f"'{colorstr('red', 'bold', a)}' is a valid YOLO argument but is missing an '=' sign "
+ f"to set its value, i.e. try '{a}={DEFAULT_CFG_DICT[a]}'\n{CLI_HELP_MSG}")
+ else:
+ check_dict_alignment(full_args_dict, {a: ''})
+
+ # Check keys
+ check_dict_alignment(full_args_dict, overrides)
+
+ # Mode
+ mode = overrides.get('mode')
+ if mode is None:
+ mode = DEFAULT_CFG.mode or 'predict'
+ LOGGER.warning(f"WARNING ⚠️ 'mode' is missing. Valid modes are {MODES}. Using default 'mode={mode}'.")
+ elif mode not in MODES:
+ raise ValueError(f"Invalid 'mode={mode}'. Valid modes are {MODES}.\n{CLI_HELP_MSG}")
+
+ # Task
+ task = overrides.pop('task', None)
+ if task:
+ if task not in TASKS:
+ raise ValueError(f"Invalid 'task={task}'. Valid tasks are {TASKS}.\n{CLI_HELP_MSG}")
+ if 'model' not in overrides:
+ overrides['model'] = TASK2MODEL[task]
+
+ # Model
+ model = overrides.pop('model', DEFAULT_CFG.model)
+ if model is None:
+ model = 'yolov8n.pt'
+ LOGGER.warning(f"WARNING ⚠️ 'model' is missing. Using default 'model={model}'.")
+ overrides['model'] = model
+ if 'rtdetr' in model.lower(): # guess architecture
+ from ultralytics import RTDETR
+ model = RTDETR(model) # no task argument
+ elif 'fastsam' in model.lower():
+ from ultralytics import FastSAM
+ model = FastSAM(model)
+ elif 'sam' in model.lower():
+ from ultralytics import SAM
+ model = SAM(model)
+ else:
+ from ultralytics import YOLO
+ model = YOLO(model, task=task)
+ if isinstance(overrides.get('pretrained'), str):
+ model.load(overrides['pretrained'])
+
+ # Task Update
+ if task != model.task:
+ if task:
+ LOGGER.warning(f"WARNING ⚠️ conflicting 'task={task}' passed with 'task={model.task}' model. "
+ f"Ignoring 'task={task}' and updating to 'task={model.task}' to match model.")
+ task = model.task
+
+ # Mode
+ if mode in ('predict', 'track') and 'source' not in overrides:
+ overrides['source'] = DEFAULT_CFG.source or ASSETS
+ LOGGER.warning(f"WARNING ⚠️ 'source' is missing. Using default 'source={overrides['source']}'.")
+ elif mode in ('train', 'val'):
+ if 'data' not in overrides and 'resume' not in overrides:
+ overrides['data'] = TASK2DATA.get(task or DEFAULT_CFG.task, DEFAULT_CFG.data)
+ LOGGER.warning(f"WARNING ⚠️ 'data' is missing. Using default 'data={overrides['data']}'.")
+ elif mode == 'export':
+ if 'format' not in overrides:
+ overrides['format'] = DEFAULT_CFG.format or 'torchscript'
+ LOGGER.warning(f"WARNING ⚠️ 'format' is missing. Using default 'format={overrides['format']}'.")
+
+ # Run command in python
+ getattr(model, mode)(**overrides) # default args from model
+
+ # Show help
+ LOGGER.info(f'💡 Learn more at https://docs.ultralytics.com/modes/{mode}')
+
+
+# Special modes --------------------------------------------------------------------------------------------------------
+def copy_default_cfg():
+ """Copy and create a new default configuration file with '_copy' appended to its name."""
+ new_file = Path.cwd() / DEFAULT_CFG_PATH.name.replace('.yaml', '_copy.yaml')
+ shutil.copy2(DEFAULT_CFG_PATH, new_file)
+ LOGGER.info(f'{DEFAULT_CFG_PATH} copied to {new_file}\n'
+ f"Example YOLO command with this new custom cfg:\n yolo cfg='{new_file}' imgsz=320 batch=8")
+
+
+if __name__ == '__main__':
+ # Example: entrypoint(debug='yolo predict model=yolov8n.pt')
+ entrypoint(debug='')
diff --git a/ultralytics/ultralytics/cfg/datasets/Argoverse.yaml b/ultralytics/ultralytics/cfg/datasets/Argoverse.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..76255e4b276f96d0ce9579fc57349b85723917d2
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/Argoverse.yaml
@@ -0,0 +1,73 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Argoverse-HD dataset (ring-front-center camera) http://www.cs.cmu.edu/~mengtial/proj/streaming/ by Argo AI
+# Example usage: yolo train data=Argoverse.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── Argoverse ← downloads here (31.5 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/Argoverse # dataset root dir
+train: Argoverse-1.1/images/train/ # train images (relative to 'path') 39384 images
+val: Argoverse-1.1/images/val/ # val images (relative to 'path') 15062 images
+test: Argoverse-1.1/images/test/ # test images (optional) https://eval.ai/web/challenges/challenge-page/800/overview
+
+# Classes
+names:
+ 0: person
+ 1: bicycle
+ 2: car
+ 3: motorcycle
+ 4: bus
+ 5: truck
+ 6: traffic_light
+ 7: stop_sign
+
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+ import json
+ from tqdm import tqdm
+ from ultralytics.utils.downloads import download
+ from pathlib import Path
+
+ def argoverse2yolo(set):
+ labels = {}
+ a = json.load(open(set, "rb"))
+ for annot in tqdm(a['annotations'], desc=f"Converting {set} to YOLOv5 format..."):
+ img_id = annot['image_id']
+ img_name = a['images'][img_id]['name']
+ img_label_name = f'{img_name[:-3]}txt'
+
+ cls = annot['category_id'] # instance class id
+ x_center, y_center, width, height = annot['bbox']
+ x_center = (x_center + width / 2) / 1920.0 # offset and scale
+ y_center = (y_center + height / 2) / 1200.0 # offset and scale
+ width /= 1920.0 # scale
+ height /= 1200.0 # scale
+
+ img_dir = set.parents[2] / 'Argoverse-1.1' / 'labels' / a['seq_dirs'][a['images'][annot['image_id']]['sid']]
+ if not img_dir.exists():
+ img_dir.mkdir(parents=True, exist_ok=True)
+
+ k = str(img_dir / img_label_name)
+ if k not in labels:
+ labels[k] = []
+ labels[k].append(f"{cls} {x_center} {y_center} {width} {height}\n")
+
+ for k in labels:
+ with open(k, "w") as f:
+ f.writelines(labels[k])
+
+
+ # Download 'https://argoverse-hd.s3.us-east-2.amazonaws.com/Argoverse-HD-Full.zip' (deprecated S3 link)
+ dir = Path(yaml['path']) # dataset root dir
+ urls = ['https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link']
+ download(urls, dir=dir)
+
+ # Convert
+ annotations_dir = 'Argoverse-HD/annotations/'
+ (dir / 'Argoverse-1.1' / 'tracking').rename(dir / 'Argoverse-1.1' / 'images') # rename 'tracking' to 'images'
+ for d in "train.json", "val.json":
+ argoverse2yolo(dir / annotations_dir / d) # convert Argoverse annotations to YOLO labels
diff --git a/ultralytics/ultralytics/cfg/datasets/DOTAv2.yaml b/ultralytics/ultralytics/cfg/datasets/DOTAv2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c663bdd5c449b87501246f35c9d73c159e447681
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/DOTAv2.yaml
@@ -0,0 +1,37 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# DOTA 2.0 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
+# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv2.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── dota2 ← downloads here (2GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/DOTAv2 # dataset root dir
+train: images/train # train images (relative to 'path') 1411 images
+val: images/val # val images (relative to 'path') 458 images
+test: images/test # test images (optional) 937 images
+
+# Classes for DOTA 2.0
+names:
+ 0: plane
+ 1: ship
+ 2: storage tank
+ 3: baseball diamond
+ 4: tennis court
+ 5: basketball court
+ 6: ground track field
+ 7: harbor
+ 8: bridge
+ 9: large vehicle
+ 10: small vehicle
+ 11: helicopter
+ 12: roundabout
+ 13: soccer ball field
+ 14: swimming pool
+ 15: container crane
+ 16: airport
+ 17: helipad
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/yolov5/releases/download/v1.0/DOTAv2.zip
diff --git a/ultralytics/ultralytics/cfg/datasets/GlobalWheat2020.yaml b/ultralytics/ultralytics/cfg/datasets/GlobalWheat2020.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..165004f6df6a14aae222063982ecf67cee543272
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/GlobalWheat2020.yaml
@@ -0,0 +1,54 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Global Wheat 2020 dataset http://www.global-wheat.com/ by University of Saskatchewan
+# Example usage: yolo train data=GlobalWheat2020.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── GlobalWheat2020 ← downloads here (7.0 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/GlobalWheat2020 # dataset root dir
+train: # train images (relative to 'path') 3422 images
+ - images/arvalis_1
+ - images/arvalis_2
+ - images/arvalis_3
+ - images/ethz_1
+ - images/rres_1
+ - images/inrae_1
+ - images/usask_1
+val: # val images (relative to 'path') 748 images (WARNING: train set contains ethz_1)
+ - images/ethz_1
+test: # test images (optional) 1276 images
+ - images/utokyo_1
+ - images/utokyo_2
+ - images/nau_1
+ - images/uq_1
+
+# Classes
+names:
+ 0: wheat_head
+
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+ from ultralytics.utils.downloads import download
+ from pathlib import Path
+
+ # Download
+ dir = Path(yaml['path']) # dataset root dir
+ urls = ['https://zenodo.org/record/4298502/files/global-wheat-codalab-official.zip',
+ 'https://github.com/ultralytics/yolov5/releases/download/v1.0/GlobalWheat2020_labels.zip']
+ download(urls, dir=dir)
+
+ # Make Directories
+ for p in 'annotations', 'images', 'labels':
+ (dir / p).mkdir(parents=True, exist_ok=True)
+
+ # Move
+ for p in 'arvalis_1', 'arvalis_2', 'arvalis_3', 'ethz_1', 'rres_1', 'inrae_1', 'usask_1', \
+ 'utokyo_1', 'utokyo_2', 'nau_1', 'uq_1':
+ (dir / 'global-wheat-codalab-official' / p).rename(dir / 'images' / p) # move to /images
+ f = (dir / 'global-wheat-codalab-official' / p).with_suffix('.json') # json file
+ if f.exists():
+ f.rename((dir / 'annotations' / p).with_suffix('.json')) # move to /annotations
diff --git a/ultralytics/ultralytics/cfg/datasets/ImageNet.yaml b/ultralytics/ultralytics/cfg/datasets/ImageNet.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c1aa155f8a814b880e4c534217f7d676bbf2e9f8
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/ImageNet.yaml
@@ -0,0 +1,2025 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# ImageNet-1k dataset https://www.image-net.org/index.php by Stanford University
+# Simplified class names from https://github.com/anishathalye/imagenet-simple-labels
+# Example usage: yolo train task=classify data=imagenet
+# parent
+# ├── ultralytics
+# └── datasets
+# └── imagenet ← downloads here (144 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/imagenet # dataset root dir
+train: train # train images (relative to 'path') 1281167 images
+val: val # val images (relative to 'path') 50000 images
+test: # test images (optional)
+
+# Classes
+names:
+ 0: tench
+ 1: goldfish
+ 2: great white shark
+ 3: tiger shark
+ 4: hammerhead shark
+ 5: electric ray
+ 6: stingray
+ 7: cock
+ 8: hen
+ 9: ostrich
+ 10: brambling
+ 11: goldfinch
+ 12: house finch
+ 13: junco
+ 14: indigo bunting
+ 15: American robin
+ 16: bulbul
+ 17: jay
+ 18: magpie
+ 19: chickadee
+ 20: American dipper
+ 21: kite
+ 22: bald eagle
+ 23: vulture
+ 24: great grey owl
+ 25: fire salamander
+ 26: smooth newt
+ 27: newt
+ 28: spotted salamander
+ 29: axolotl
+ 30: American bullfrog
+ 31: tree frog
+ 32: tailed frog
+ 33: loggerhead sea turtle
+ 34: leatherback sea turtle
+ 35: mud turtle
+ 36: terrapin
+ 37: box turtle
+ 38: banded gecko
+ 39: green iguana
+ 40: Carolina anole
+ 41: desert grassland whiptail lizard
+ 42: agama
+ 43: frilled-necked lizard
+ 44: alligator lizard
+ 45: Gila monster
+ 46: European green lizard
+ 47: chameleon
+ 48: Komodo dragon
+ 49: Nile crocodile
+ 50: American alligator
+ 51: triceratops
+ 52: worm snake
+ 53: ring-necked snake
+ 54: eastern hog-nosed snake
+ 55: smooth green snake
+ 56: kingsnake
+ 57: garter snake
+ 58: water snake
+ 59: vine snake
+ 60: night snake
+ 61: boa constrictor
+ 62: African rock python
+ 63: Indian cobra
+ 64: green mamba
+ 65: sea snake
+ 66: Saharan horned viper
+ 67: eastern diamondback rattlesnake
+ 68: sidewinder
+ 69: trilobite
+ 70: harvestman
+ 71: scorpion
+ 72: yellow garden spider
+ 73: barn spider
+ 74: European garden spider
+ 75: southern black widow
+ 76: tarantula
+ 77: wolf spider
+ 78: tick
+ 79: centipede
+ 80: black grouse
+ 81: ptarmigan
+ 82: ruffed grouse
+ 83: prairie grouse
+ 84: peacock
+ 85: quail
+ 86: partridge
+ 87: grey parrot
+ 88: macaw
+ 89: sulphur-crested cockatoo
+ 90: lorikeet
+ 91: coucal
+ 92: bee eater
+ 93: hornbill
+ 94: hummingbird
+ 95: jacamar
+ 96: toucan
+ 97: duck
+ 98: red-breasted merganser
+ 99: goose
+ 100: black swan
+ 101: tusker
+ 102: echidna
+ 103: platypus
+ 104: wallaby
+ 105: koala
+ 106: wombat
+ 107: jellyfish
+ 108: sea anemone
+ 109: brain coral
+ 110: flatworm
+ 111: nematode
+ 112: conch
+ 113: snail
+ 114: slug
+ 115: sea slug
+ 116: chiton
+ 117: chambered nautilus
+ 118: Dungeness crab
+ 119: rock crab
+ 120: fiddler crab
+ 121: red king crab
+ 122: American lobster
+ 123: spiny lobster
+ 124: crayfish
+ 125: hermit crab
+ 126: isopod
+ 127: white stork
+ 128: black stork
+ 129: spoonbill
+ 130: flamingo
+ 131: little blue heron
+ 132: great egret
+ 133: bittern
+ 134: crane (bird)
+ 135: limpkin
+ 136: common gallinule
+ 137: American coot
+ 138: bustard
+ 139: ruddy turnstone
+ 140: dunlin
+ 141: common redshank
+ 142: dowitcher
+ 143: oystercatcher
+ 144: pelican
+ 145: king penguin
+ 146: albatross
+ 147: grey whale
+ 148: killer whale
+ 149: dugong
+ 150: sea lion
+ 151: Chihuahua
+ 152: Japanese Chin
+ 153: Maltese
+ 154: Pekingese
+ 155: Shih Tzu
+ 156: King Charles Spaniel
+ 157: Papillon
+ 158: toy terrier
+ 159: Rhodesian Ridgeback
+ 160: Afghan Hound
+ 161: Basset Hound
+ 162: Beagle
+ 163: Bloodhound
+ 164: Bluetick Coonhound
+ 165: Black and Tan Coonhound
+ 166: Treeing Walker Coonhound
+ 167: English foxhound
+ 168: Redbone Coonhound
+ 169: borzoi
+ 170: Irish Wolfhound
+ 171: Italian Greyhound
+ 172: Whippet
+ 173: Ibizan Hound
+ 174: Norwegian Elkhound
+ 175: Otterhound
+ 176: Saluki
+ 177: Scottish Deerhound
+ 178: Weimaraner
+ 179: Staffordshire Bull Terrier
+ 180: American Staffordshire Terrier
+ 181: Bedlington Terrier
+ 182: Border Terrier
+ 183: Kerry Blue Terrier
+ 184: Irish Terrier
+ 185: Norfolk Terrier
+ 186: Norwich Terrier
+ 187: Yorkshire Terrier
+ 188: Wire Fox Terrier
+ 189: Lakeland Terrier
+ 190: Sealyham Terrier
+ 191: Airedale Terrier
+ 192: Cairn Terrier
+ 193: Australian Terrier
+ 194: Dandie Dinmont Terrier
+ 195: Boston Terrier
+ 196: Miniature Schnauzer
+ 197: Giant Schnauzer
+ 198: Standard Schnauzer
+ 199: Scottish Terrier
+ 200: Tibetan Terrier
+ 201: Australian Silky Terrier
+ 202: Soft-coated Wheaten Terrier
+ 203: West Highland White Terrier
+ 204: Lhasa Apso
+ 205: Flat-Coated Retriever
+ 206: Curly-coated Retriever
+ 207: Golden Retriever
+ 208: Labrador Retriever
+ 209: Chesapeake Bay Retriever
+ 210: German Shorthaired Pointer
+ 211: Vizsla
+ 212: English Setter
+ 213: Irish Setter
+ 214: Gordon Setter
+ 215: Brittany
+ 216: Clumber Spaniel
+ 217: English Springer Spaniel
+ 218: Welsh Springer Spaniel
+ 219: Cocker Spaniels
+ 220: Sussex Spaniel
+ 221: Irish Water Spaniel
+ 222: Kuvasz
+ 223: Schipperke
+ 224: Groenendael
+ 225: Malinois
+ 226: Briard
+ 227: Australian Kelpie
+ 228: Komondor
+ 229: Old English Sheepdog
+ 230: Shetland Sheepdog
+ 231: collie
+ 232: Border Collie
+ 233: Bouvier des Flandres
+ 234: Rottweiler
+ 235: German Shepherd Dog
+ 236: Dobermann
+ 237: Miniature Pinscher
+ 238: Greater Swiss Mountain Dog
+ 239: Bernese Mountain Dog
+ 240: Appenzeller Sennenhund
+ 241: Entlebucher Sennenhund
+ 242: Boxer
+ 243: Bullmastiff
+ 244: Tibetan Mastiff
+ 245: French Bulldog
+ 246: Great Dane
+ 247: St. Bernard
+ 248: husky
+ 249: Alaskan Malamute
+ 250: Siberian Husky
+ 251: Dalmatian
+ 252: Affenpinscher
+ 253: Basenji
+ 254: pug
+ 255: Leonberger
+ 256: Newfoundland
+ 257: Pyrenean Mountain Dog
+ 258: Samoyed
+ 259: Pomeranian
+ 260: Chow Chow
+ 261: Keeshond
+ 262: Griffon Bruxellois
+ 263: Pembroke Welsh Corgi
+ 264: Cardigan Welsh Corgi
+ 265: Toy Poodle
+ 266: Miniature Poodle
+ 267: Standard Poodle
+ 268: Mexican hairless dog
+ 269: grey wolf
+ 270: Alaskan tundra wolf
+ 271: red wolf
+ 272: coyote
+ 273: dingo
+ 274: dhole
+ 275: African wild dog
+ 276: hyena
+ 277: red fox
+ 278: kit fox
+ 279: Arctic fox
+ 280: grey fox
+ 281: tabby cat
+ 282: tiger cat
+ 283: Persian cat
+ 284: Siamese cat
+ 285: Egyptian Mau
+ 286: cougar
+ 287: lynx
+ 288: leopard
+ 289: snow leopard
+ 290: jaguar
+ 291: lion
+ 292: tiger
+ 293: cheetah
+ 294: brown bear
+ 295: American black bear
+ 296: polar bear
+ 297: sloth bear
+ 298: mongoose
+ 299: meerkat
+ 300: tiger beetle
+ 301: ladybug
+ 302: ground beetle
+ 303: longhorn beetle
+ 304: leaf beetle
+ 305: dung beetle
+ 306: rhinoceros beetle
+ 307: weevil
+ 308: fly
+ 309: bee
+ 310: ant
+ 311: grasshopper
+ 312: cricket
+ 313: stick insect
+ 314: cockroach
+ 315: mantis
+ 316: cicada
+ 317: leafhopper
+ 318: lacewing
+ 319: dragonfly
+ 320: damselfly
+ 321: red admiral
+ 322: ringlet
+ 323: monarch butterfly
+ 324: small white
+ 325: sulphur butterfly
+ 326: gossamer-winged butterfly
+ 327: starfish
+ 328: sea urchin
+ 329: sea cucumber
+ 330: cottontail rabbit
+ 331: hare
+ 332: Angora rabbit
+ 333: hamster
+ 334: porcupine
+ 335: fox squirrel
+ 336: marmot
+ 337: beaver
+ 338: guinea pig
+ 339: common sorrel
+ 340: zebra
+ 341: pig
+ 342: wild boar
+ 343: warthog
+ 344: hippopotamus
+ 345: ox
+ 346: water buffalo
+ 347: bison
+ 348: ram
+ 349: bighorn sheep
+ 350: Alpine ibex
+ 351: hartebeest
+ 352: impala
+ 353: gazelle
+ 354: dromedary
+ 355: llama
+ 356: weasel
+ 357: mink
+ 358: European polecat
+ 359: black-footed ferret
+ 360: otter
+ 361: skunk
+ 362: badger
+ 363: armadillo
+ 364: three-toed sloth
+ 365: orangutan
+ 366: gorilla
+ 367: chimpanzee
+ 368: gibbon
+ 369: siamang
+ 370: guenon
+ 371: patas monkey
+ 372: baboon
+ 373: macaque
+ 374: langur
+ 375: black-and-white colobus
+ 376: proboscis monkey
+ 377: marmoset
+ 378: white-headed capuchin
+ 379: howler monkey
+ 380: titi
+ 381: Geoffroy's spider monkey
+ 382: common squirrel monkey
+ 383: ring-tailed lemur
+ 384: indri
+ 385: Asian elephant
+ 386: African bush elephant
+ 387: red panda
+ 388: giant panda
+ 389: snoek
+ 390: eel
+ 391: coho salmon
+ 392: rock beauty
+ 393: clownfish
+ 394: sturgeon
+ 395: garfish
+ 396: lionfish
+ 397: pufferfish
+ 398: abacus
+ 399: abaya
+ 400: academic gown
+ 401: accordion
+ 402: acoustic guitar
+ 403: aircraft carrier
+ 404: airliner
+ 405: airship
+ 406: altar
+ 407: ambulance
+ 408: amphibious vehicle
+ 409: analog clock
+ 410: apiary
+ 411: apron
+ 412: waste container
+ 413: assault rifle
+ 414: backpack
+ 415: bakery
+ 416: balance beam
+ 417: balloon
+ 418: ballpoint pen
+ 419: Band-Aid
+ 420: banjo
+ 421: baluster
+ 422: barbell
+ 423: barber chair
+ 424: barbershop
+ 425: barn
+ 426: barometer
+ 427: barrel
+ 428: wheelbarrow
+ 429: baseball
+ 430: basketball
+ 431: bassinet
+ 432: bassoon
+ 433: swimming cap
+ 434: bath towel
+ 435: bathtub
+ 436: station wagon
+ 437: lighthouse
+ 438: beaker
+ 439: military cap
+ 440: beer bottle
+ 441: beer glass
+ 442: bell-cot
+ 443: bib
+ 444: tandem bicycle
+ 445: bikini
+ 446: ring binder
+ 447: binoculars
+ 448: birdhouse
+ 449: boathouse
+ 450: bobsleigh
+ 451: bolo tie
+ 452: poke bonnet
+ 453: bookcase
+ 454: bookstore
+ 455: bottle cap
+ 456: bow
+ 457: bow tie
+ 458: brass
+ 459: bra
+ 460: breakwater
+ 461: breastplate
+ 462: broom
+ 463: bucket
+ 464: buckle
+ 465: bulletproof vest
+ 466: high-speed train
+ 467: butcher shop
+ 468: taxicab
+ 469: cauldron
+ 470: candle
+ 471: cannon
+ 472: canoe
+ 473: can opener
+ 474: cardigan
+ 475: car mirror
+ 476: carousel
+ 477: tool kit
+ 478: carton
+ 479: car wheel
+ 480: automated teller machine
+ 481: cassette
+ 482: cassette player
+ 483: castle
+ 484: catamaran
+ 485: CD player
+ 486: cello
+ 487: mobile phone
+ 488: chain
+ 489: chain-link fence
+ 490: chain mail
+ 491: chainsaw
+ 492: chest
+ 493: chiffonier
+ 494: chime
+ 495: china cabinet
+ 496: Christmas stocking
+ 497: church
+ 498: movie theater
+ 499: cleaver
+ 500: cliff dwelling
+ 501: cloak
+ 502: clogs
+ 503: cocktail shaker
+ 504: coffee mug
+ 505: coffeemaker
+ 506: coil
+ 507: combination lock
+ 508: computer keyboard
+ 509: confectionery store
+ 510: container ship
+ 511: convertible
+ 512: corkscrew
+ 513: cornet
+ 514: cowboy boot
+ 515: cowboy hat
+ 516: cradle
+ 517: crane (machine)
+ 518: crash helmet
+ 519: crate
+ 520: infant bed
+ 521: Crock Pot
+ 522: croquet ball
+ 523: crutch
+ 524: cuirass
+ 525: dam
+ 526: desk
+ 527: desktop computer
+ 528: rotary dial telephone
+ 529: diaper
+ 530: digital clock
+ 531: digital watch
+ 532: dining table
+ 533: dishcloth
+ 534: dishwasher
+ 535: disc brake
+ 536: dock
+ 537: dog sled
+ 538: dome
+ 539: doormat
+ 540: drilling rig
+ 541: drum
+ 542: drumstick
+ 543: dumbbell
+ 544: Dutch oven
+ 545: electric fan
+ 546: electric guitar
+ 547: electric locomotive
+ 548: entertainment center
+ 549: envelope
+ 550: espresso machine
+ 551: face powder
+ 552: feather boa
+ 553: filing cabinet
+ 554: fireboat
+ 555: fire engine
+ 556: fire screen sheet
+ 557: flagpole
+ 558: flute
+ 559: folding chair
+ 560: football helmet
+ 561: forklift
+ 562: fountain
+ 563: fountain pen
+ 564: four-poster bed
+ 565: freight car
+ 566: French horn
+ 567: frying pan
+ 568: fur coat
+ 569: garbage truck
+ 570: gas mask
+ 571: gas pump
+ 572: goblet
+ 573: go-kart
+ 574: golf ball
+ 575: golf cart
+ 576: gondola
+ 577: gong
+ 578: gown
+ 579: grand piano
+ 580: greenhouse
+ 581: grille
+ 582: grocery store
+ 583: guillotine
+ 584: barrette
+ 585: hair spray
+ 586: half-track
+ 587: hammer
+ 588: hamper
+ 589: hair dryer
+ 590: hand-held computer
+ 591: handkerchief
+ 592: hard disk drive
+ 593: harmonica
+ 594: harp
+ 595: harvester
+ 596: hatchet
+ 597: holster
+ 598: home theater
+ 599: honeycomb
+ 600: hook
+ 601: hoop skirt
+ 602: horizontal bar
+ 603: horse-drawn vehicle
+ 604: hourglass
+ 605: iPod
+ 606: clothes iron
+ 607: jack-o'-lantern
+ 608: jeans
+ 609: jeep
+ 610: T-shirt
+ 611: jigsaw puzzle
+ 612: pulled rickshaw
+ 613: joystick
+ 614: kimono
+ 615: knee pad
+ 616: knot
+ 617: lab coat
+ 618: ladle
+ 619: lampshade
+ 620: laptop computer
+ 621: lawn mower
+ 622: lens cap
+ 623: paper knife
+ 624: library
+ 625: lifeboat
+ 626: lighter
+ 627: limousine
+ 628: ocean liner
+ 629: lipstick
+ 630: slip-on shoe
+ 631: lotion
+ 632: speaker
+ 633: loupe
+ 634: sawmill
+ 635: magnetic compass
+ 636: mail bag
+ 637: mailbox
+ 638: tights
+ 639: tank suit
+ 640: manhole cover
+ 641: maraca
+ 642: marimba
+ 643: mask
+ 644: match
+ 645: maypole
+ 646: maze
+ 647: measuring cup
+ 648: medicine chest
+ 649: megalith
+ 650: microphone
+ 651: microwave oven
+ 652: military uniform
+ 653: milk can
+ 654: minibus
+ 655: miniskirt
+ 656: minivan
+ 657: missile
+ 658: mitten
+ 659: mixing bowl
+ 660: mobile home
+ 661: Model T
+ 662: modem
+ 663: monastery
+ 664: monitor
+ 665: moped
+ 666: mortar
+ 667: square academic cap
+ 668: mosque
+ 669: mosquito net
+ 670: scooter
+ 671: mountain bike
+ 672: tent
+ 673: computer mouse
+ 674: mousetrap
+ 675: moving van
+ 676: muzzle
+ 677: nail
+ 678: neck brace
+ 679: necklace
+ 680: nipple
+ 681: notebook computer
+ 682: obelisk
+ 683: oboe
+ 684: ocarina
+ 685: odometer
+ 686: oil filter
+ 687: organ
+ 688: oscilloscope
+ 689: overskirt
+ 690: bullock cart
+ 691: oxygen mask
+ 692: packet
+ 693: paddle
+ 694: paddle wheel
+ 695: padlock
+ 696: paintbrush
+ 697: pajamas
+ 698: palace
+ 699: pan flute
+ 700: paper towel
+ 701: parachute
+ 702: parallel bars
+ 703: park bench
+ 704: parking meter
+ 705: passenger car
+ 706: patio
+ 707: payphone
+ 708: pedestal
+ 709: pencil case
+ 710: pencil sharpener
+ 711: perfume
+ 712: Petri dish
+ 713: photocopier
+ 714: plectrum
+ 715: Pickelhaube
+ 716: picket fence
+ 717: pickup truck
+ 718: pier
+ 719: piggy bank
+ 720: pill bottle
+ 721: pillow
+ 722: ping-pong ball
+ 723: pinwheel
+ 724: pirate ship
+ 725: pitcher
+ 726: hand plane
+ 727: planetarium
+ 728: plastic bag
+ 729: plate rack
+ 730: plow
+ 731: plunger
+ 732: Polaroid camera
+ 733: pole
+ 734: police van
+ 735: poncho
+ 736: billiard table
+ 737: soda bottle
+ 738: pot
+ 739: potter's wheel
+ 740: power drill
+ 741: prayer rug
+ 742: printer
+ 743: prison
+ 744: projectile
+ 745: projector
+ 746: hockey puck
+ 747: punching bag
+ 748: purse
+ 749: quill
+ 750: quilt
+ 751: race car
+ 752: racket
+ 753: radiator
+ 754: radio
+ 755: radio telescope
+ 756: rain barrel
+ 757: recreational vehicle
+ 758: reel
+ 759: reflex camera
+ 760: refrigerator
+ 761: remote control
+ 762: restaurant
+ 763: revolver
+ 764: rifle
+ 765: rocking chair
+ 766: rotisserie
+ 767: eraser
+ 768: rugby ball
+ 769: ruler
+ 770: running shoe
+ 771: safe
+ 772: safety pin
+ 773: salt shaker
+ 774: sandal
+ 775: sarong
+ 776: saxophone
+ 777: scabbard
+ 778: weighing scale
+ 779: school bus
+ 780: schooner
+ 781: scoreboard
+ 782: CRT screen
+ 783: screw
+ 784: screwdriver
+ 785: seat belt
+ 786: sewing machine
+ 787: shield
+ 788: shoe store
+ 789: shoji
+ 790: shopping basket
+ 791: shopping cart
+ 792: shovel
+ 793: shower cap
+ 794: shower curtain
+ 795: ski
+ 796: ski mask
+ 797: sleeping bag
+ 798: slide rule
+ 799: sliding door
+ 800: slot machine
+ 801: snorkel
+ 802: snowmobile
+ 803: snowplow
+ 804: soap dispenser
+ 805: soccer ball
+ 806: sock
+ 807: solar thermal collector
+ 808: sombrero
+ 809: soup bowl
+ 810: space bar
+ 811: space heater
+ 812: space shuttle
+ 813: spatula
+ 814: motorboat
+ 815: spider web
+ 816: spindle
+ 817: sports car
+ 818: spotlight
+ 819: stage
+ 820: steam locomotive
+ 821: through arch bridge
+ 822: steel drum
+ 823: stethoscope
+ 824: scarf
+ 825: stone wall
+ 826: stopwatch
+ 827: stove
+ 828: strainer
+ 829: tram
+ 830: stretcher
+ 831: couch
+ 832: stupa
+ 833: submarine
+ 834: suit
+ 835: sundial
+ 836: sunglass
+ 837: sunglasses
+ 838: sunscreen
+ 839: suspension bridge
+ 840: mop
+ 841: sweatshirt
+ 842: swimsuit
+ 843: swing
+ 844: switch
+ 845: syringe
+ 846: table lamp
+ 847: tank
+ 848: tape player
+ 849: teapot
+ 850: teddy bear
+ 851: television
+ 852: tennis ball
+ 853: thatched roof
+ 854: front curtain
+ 855: thimble
+ 856: threshing machine
+ 857: throne
+ 858: tile roof
+ 859: toaster
+ 860: tobacco shop
+ 861: toilet seat
+ 862: torch
+ 863: totem pole
+ 864: tow truck
+ 865: toy store
+ 866: tractor
+ 867: semi-trailer truck
+ 868: tray
+ 869: trench coat
+ 870: tricycle
+ 871: trimaran
+ 872: tripod
+ 873: triumphal arch
+ 874: trolleybus
+ 875: trombone
+ 876: tub
+ 877: turnstile
+ 878: typewriter keyboard
+ 879: umbrella
+ 880: unicycle
+ 881: upright piano
+ 882: vacuum cleaner
+ 883: vase
+ 884: vault
+ 885: velvet
+ 886: vending machine
+ 887: vestment
+ 888: viaduct
+ 889: violin
+ 890: volleyball
+ 891: waffle iron
+ 892: wall clock
+ 893: wallet
+ 894: wardrobe
+ 895: military aircraft
+ 896: sink
+ 897: washing machine
+ 898: water bottle
+ 899: water jug
+ 900: water tower
+ 901: whiskey jug
+ 902: whistle
+ 903: wig
+ 904: window screen
+ 905: window shade
+ 906: Windsor tie
+ 907: wine bottle
+ 908: wing
+ 909: wok
+ 910: wooden spoon
+ 911: wool
+ 912: split-rail fence
+ 913: shipwreck
+ 914: yawl
+ 915: yurt
+ 916: website
+ 917: comic book
+ 918: crossword
+ 919: traffic sign
+ 920: traffic light
+ 921: dust jacket
+ 922: menu
+ 923: plate
+ 924: guacamole
+ 925: consomme
+ 926: hot pot
+ 927: trifle
+ 928: ice cream
+ 929: ice pop
+ 930: baguette
+ 931: bagel
+ 932: pretzel
+ 933: cheeseburger
+ 934: hot dog
+ 935: mashed potato
+ 936: cabbage
+ 937: broccoli
+ 938: cauliflower
+ 939: zucchini
+ 940: spaghetti squash
+ 941: acorn squash
+ 942: butternut squash
+ 943: cucumber
+ 944: artichoke
+ 945: bell pepper
+ 946: cardoon
+ 947: mushroom
+ 948: Granny Smith
+ 949: strawberry
+ 950: orange
+ 951: lemon
+ 952: fig
+ 953: pineapple
+ 954: banana
+ 955: jackfruit
+ 956: custard apple
+ 957: pomegranate
+ 958: hay
+ 959: carbonara
+ 960: chocolate syrup
+ 961: dough
+ 962: meatloaf
+ 963: pizza
+ 964: pot pie
+ 965: burrito
+ 966: red wine
+ 967: espresso
+ 968: cup
+ 969: eggnog
+ 970: alp
+ 971: bubble
+ 972: cliff
+ 973: coral reef
+ 974: geyser
+ 975: lakeshore
+ 976: promontory
+ 977: shoal
+ 978: seashore
+ 979: valley
+ 980: volcano
+ 981: baseball player
+ 982: bridegroom
+ 983: scuba diver
+ 984: rapeseed
+ 985: daisy
+ 986: yellow lady's slipper
+ 987: corn
+ 988: acorn
+ 989: rose hip
+ 990: horse chestnut seed
+ 991: coral fungus
+ 992: agaric
+ 993: gyromitra
+ 994: stinkhorn mushroom
+ 995: earth star
+ 996: hen-of-the-woods
+ 997: bolete
+ 998: ear
+ 999: toilet paper
+
+# Imagenet class codes to human-readable names
+map:
+ n01440764: tench
+ n01443537: goldfish
+ n01484850: great_white_shark
+ n01491361: tiger_shark
+ n01494475: hammerhead
+ n01496331: electric_ray
+ n01498041: stingray
+ n01514668: cock
+ n01514859: hen
+ n01518878: ostrich
+ n01530575: brambling
+ n01531178: goldfinch
+ n01532829: house_finch
+ n01534433: junco
+ n01537544: indigo_bunting
+ n01558993: robin
+ n01560419: bulbul
+ n01580077: jay
+ n01582220: magpie
+ n01592084: chickadee
+ n01601694: water_ouzel
+ n01608432: kite
+ n01614925: bald_eagle
+ n01616318: vulture
+ n01622779: great_grey_owl
+ n01629819: European_fire_salamander
+ n01630670: common_newt
+ n01631663: eft
+ n01632458: spotted_salamander
+ n01632777: axolotl
+ n01641577: bullfrog
+ n01644373: tree_frog
+ n01644900: tailed_frog
+ n01664065: loggerhead
+ n01665541: leatherback_turtle
+ n01667114: mud_turtle
+ n01667778: terrapin
+ n01669191: box_turtle
+ n01675722: banded_gecko
+ n01677366: common_iguana
+ n01682714: American_chameleon
+ n01685808: whiptail
+ n01687978: agama
+ n01688243: frilled_lizard
+ n01689811: alligator_lizard
+ n01692333: Gila_monster
+ n01693334: green_lizard
+ n01694178: African_chameleon
+ n01695060: Komodo_dragon
+ n01697457: African_crocodile
+ n01698640: American_alligator
+ n01704323: triceratops
+ n01728572: thunder_snake
+ n01728920: ringneck_snake
+ n01729322: hognose_snake
+ n01729977: green_snake
+ n01734418: king_snake
+ n01735189: garter_snake
+ n01737021: water_snake
+ n01739381: vine_snake
+ n01740131: night_snake
+ n01742172: boa_constrictor
+ n01744401: rock_python
+ n01748264: Indian_cobra
+ n01749939: green_mamba
+ n01751748: sea_snake
+ n01753488: horned_viper
+ n01755581: diamondback
+ n01756291: sidewinder
+ n01768244: trilobite
+ n01770081: harvestman
+ n01770393: scorpion
+ n01773157: black_and_gold_garden_spider
+ n01773549: barn_spider
+ n01773797: garden_spider
+ n01774384: black_widow
+ n01774750: tarantula
+ n01775062: wolf_spider
+ n01776313: tick
+ n01784675: centipede
+ n01795545: black_grouse
+ n01796340: ptarmigan
+ n01797886: ruffed_grouse
+ n01798484: prairie_chicken
+ n01806143: peacock
+ n01806567: quail
+ n01807496: partridge
+ n01817953: African_grey
+ n01818515: macaw
+ n01819313: sulphur-crested_cockatoo
+ n01820546: lorikeet
+ n01824575: coucal
+ n01828970: bee_eater
+ n01829413: hornbill
+ n01833805: hummingbird
+ n01843065: jacamar
+ n01843383: toucan
+ n01847000: drake
+ n01855032: red-breasted_merganser
+ n01855672: goose
+ n01860187: black_swan
+ n01871265: tusker
+ n01872401: echidna
+ n01873310: platypus
+ n01877812: wallaby
+ n01882714: koala
+ n01883070: wombat
+ n01910747: jellyfish
+ n01914609: sea_anemone
+ n01917289: brain_coral
+ n01924916: flatworm
+ n01930112: nematode
+ n01943899: conch
+ n01944390: snail
+ n01945685: slug
+ n01950731: sea_slug
+ n01955084: chiton
+ n01968897: chambered_nautilus
+ n01978287: Dungeness_crab
+ n01978455: rock_crab
+ n01980166: fiddler_crab
+ n01981276: king_crab
+ n01983481: American_lobster
+ n01984695: spiny_lobster
+ n01985128: crayfish
+ n01986214: hermit_crab
+ n01990800: isopod
+ n02002556: white_stork
+ n02002724: black_stork
+ n02006656: spoonbill
+ n02007558: flamingo
+ n02009229: little_blue_heron
+ n02009912: American_egret
+ n02011460: bittern
+ n02012849: crane_(bird)
+ n02013706: limpkin
+ n02017213: European_gallinule
+ n02018207: American_coot
+ n02018795: bustard
+ n02025239: ruddy_turnstone
+ n02027492: red-backed_sandpiper
+ n02028035: redshank
+ n02033041: dowitcher
+ n02037110: oystercatcher
+ n02051845: pelican
+ n02056570: king_penguin
+ n02058221: albatross
+ n02066245: grey_whale
+ n02071294: killer_whale
+ n02074367: dugong
+ n02077923: sea_lion
+ n02085620: Chihuahua
+ n02085782: Japanese_spaniel
+ n02085936: Maltese_dog
+ n02086079: Pekinese
+ n02086240: Shih-Tzu
+ n02086646: Blenheim_spaniel
+ n02086910: papillon
+ n02087046: toy_terrier
+ n02087394: Rhodesian_ridgeback
+ n02088094: Afghan_hound
+ n02088238: basset
+ n02088364: beagle
+ n02088466: bloodhound
+ n02088632: bluetick
+ n02089078: black-and-tan_coonhound
+ n02089867: Walker_hound
+ n02089973: English_foxhound
+ n02090379: redbone
+ n02090622: borzoi
+ n02090721: Irish_wolfhound
+ n02091032: Italian_greyhound
+ n02091134: whippet
+ n02091244: Ibizan_hound
+ n02091467: Norwegian_elkhound
+ n02091635: otterhound
+ n02091831: Saluki
+ n02092002: Scottish_deerhound
+ n02092339: Weimaraner
+ n02093256: Staffordshire_bullterrier
+ n02093428: American_Staffordshire_terrier
+ n02093647: Bedlington_terrier
+ n02093754: Border_terrier
+ n02093859: Kerry_blue_terrier
+ n02093991: Irish_terrier
+ n02094114: Norfolk_terrier
+ n02094258: Norwich_terrier
+ n02094433: Yorkshire_terrier
+ n02095314: wire-haired_fox_terrier
+ n02095570: Lakeland_terrier
+ n02095889: Sealyham_terrier
+ n02096051: Airedale
+ n02096177: cairn
+ n02096294: Australian_terrier
+ n02096437: Dandie_Dinmont
+ n02096585: Boston_bull
+ n02097047: miniature_schnauzer
+ n02097130: giant_schnauzer
+ n02097209: standard_schnauzer
+ n02097298: Scotch_terrier
+ n02097474: Tibetan_terrier
+ n02097658: silky_terrier
+ n02098105: soft-coated_wheaten_terrier
+ n02098286: West_Highland_white_terrier
+ n02098413: Lhasa
+ n02099267: flat-coated_retriever
+ n02099429: curly-coated_retriever
+ n02099601: golden_retriever
+ n02099712: Labrador_retriever
+ n02099849: Chesapeake_Bay_retriever
+ n02100236: German_short-haired_pointer
+ n02100583: vizsla
+ n02100735: English_setter
+ n02100877: Irish_setter
+ n02101006: Gordon_setter
+ n02101388: Brittany_spaniel
+ n02101556: clumber
+ n02102040: English_springer
+ n02102177: Welsh_springer_spaniel
+ n02102318: cocker_spaniel
+ n02102480: Sussex_spaniel
+ n02102973: Irish_water_spaniel
+ n02104029: kuvasz
+ n02104365: schipperke
+ n02105056: groenendael
+ n02105162: malinois
+ n02105251: briard
+ n02105412: kelpie
+ n02105505: komondor
+ n02105641: Old_English_sheepdog
+ n02105855: Shetland_sheepdog
+ n02106030: collie
+ n02106166: Border_collie
+ n02106382: Bouvier_des_Flandres
+ n02106550: Rottweiler
+ n02106662: German_shepherd
+ n02107142: Doberman
+ n02107312: miniature_pinscher
+ n02107574: Greater_Swiss_Mountain_dog
+ n02107683: Bernese_mountain_dog
+ n02107908: Appenzeller
+ n02108000: EntleBucher
+ n02108089: boxer
+ n02108422: bull_mastiff
+ n02108551: Tibetan_mastiff
+ n02108915: French_bulldog
+ n02109047: Great_Dane
+ n02109525: Saint_Bernard
+ n02109961: Eskimo_dog
+ n02110063: malamute
+ n02110185: Siberian_husky
+ n02110341: dalmatian
+ n02110627: affenpinscher
+ n02110806: basenji
+ n02110958: pug
+ n02111129: Leonberg
+ n02111277: Newfoundland
+ n02111500: Great_Pyrenees
+ n02111889: Samoyed
+ n02112018: Pomeranian
+ n02112137: chow
+ n02112350: keeshond
+ n02112706: Brabancon_griffon
+ n02113023: Pembroke
+ n02113186: Cardigan
+ n02113624: toy_poodle
+ n02113712: miniature_poodle
+ n02113799: standard_poodle
+ n02113978: Mexican_hairless
+ n02114367: timber_wolf
+ n02114548: white_wolf
+ n02114712: red_wolf
+ n02114855: coyote
+ n02115641: dingo
+ n02115913: dhole
+ n02116738: African_hunting_dog
+ n02117135: hyena
+ n02119022: red_fox
+ n02119789: kit_fox
+ n02120079: Arctic_fox
+ n02120505: grey_fox
+ n02123045: tabby
+ n02123159: tiger_cat
+ n02123394: Persian_cat
+ n02123597: Siamese_cat
+ n02124075: Egyptian_cat
+ n02125311: cougar
+ n02127052: lynx
+ n02128385: leopard
+ n02128757: snow_leopard
+ n02128925: jaguar
+ n02129165: lion
+ n02129604: tiger
+ n02130308: cheetah
+ n02132136: brown_bear
+ n02133161: American_black_bear
+ n02134084: ice_bear
+ n02134418: sloth_bear
+ n02137549: mongoose
+ n02138441: meerkat
+ n02165105: tiger_beetle
+ n02165456: ladybug
+ n02167151: ground_beetle
+ n02168699: long-horned_beetle
+ n02169497: leaf_beetle
+ n02172182: dung_beetle
+ n02174001: rhinoceros_beetle
+ n02177972: weevil
+ n02190166: fly
+ n02206856: bee
+ n02219486: ant
+ n02226429: grasshopper
+ n02229544: cricket
+ n02231487: walking_stick
+ n02233338: cockroach
+ n02236044: mantis
+ n02256656: cicada
+ n02259212: leafhopper
+ n02264363: lacewing
+ n02268443: dragonfly
+ n02268853: damselfly
+ n02276258: admiral
+ n02277742: ringlet
+ n02279972: monarch
+ n02280649: cabbage_butterfly
+ n02281406: sulphur_butterfly
+ n02281787: lycaenid
+ n02317335: starfish
+ n02319095: sea_urchin
+ n02321529: sea_cucumber
+ n02325366: wood_rabbit
+ n02326432: hare
+ n02328150: Angora
+ n02342885: hamster
+ n02346627: porcupine
+ n02356798: fox_squirrel
+ n02361337: marmot
+ n02363005: beaver
+ n02364673: guinea_pig
+ n02389026: sorrel
+ n02391049: zebra
+ n02395406: hog
+ n02396427: wild_boar
+ n02397096: warthog
+ n02398521: hippopotamus
+ n02403003: ox
+ n02408429: water_buffalo
+ n02410509: bison
+ n02412080: ram
+ n02415577: bighorn
+ n02417914: ibex
+ n02422106: hartebeest
+ n02422699: impala
+ n02423022: gazelle
+ n02437312: Arabian_camel
+ n02437616: llama
+ n02441942: weasel
+ n02442845: mink
+ n02443114: polecat
+ n02443484: black-footed_ferret
+ n02444819: otter
+ n02445715: skunk
+ n02447366: badger
+ n02454379: armadillo
+ n02457408: three-toed_sloth
+ n02480495: orangutan
+ n02480855: gorilla
+ n02481823: chimpanzee
+ n02483362: gibbon
+ n02483708: siamang
+ n02484975: guenon
+ n02486261: patas
+ n02486410: baboon
+ n02487347: macaque
+ n02488291: langur
+ n02488702: colobus
+ n02489166: proboscis_monkey
+ n02490219: marmoset
+ n02492035: capuchin
+ n02492660: howler_monkey
+ n02493509: titi
+ n02493793: spider_monkey
+ n02494079: squirrel_monkey
+ n02497673: Madagascar_cat
+ n02500267: indri
+ n02504013: Indian_elephant
+ n02504458: African_elephant
+ n02509815: lesser_panda
+ n02510455: giant_panda
+ n02514041: barracouta
+ n02526121: eel
+ n02536864: coho
+ n02606052: rock_beauty
+ n02607072: anemone_fish
+ n02640242: sturgeon
+ n02641379: gar
+ n02643566: lionfish
+ n02655020: puffer
+ n02666196: abacus
+ n02667093: abaya
+ n02669723: academic_gown
+ n02672831: accordion
+ n02676566: acoustic_guitar
+ n02687172: aircraft_carrier
+ n02690373: airliner
+ n02692877: airship
+ n02699494: altar
+ n02701002: ambulance
+ n02704792: amphibian
+ n02708093: analog_clock
+ n02727426: apiary
+ n02730930: apron
+ n02747177: ashcan
+ n02749479: assault_rifle
+ n02769748: backpack
+ n02776631: bakery
+ n02777292: balance_beam
+ n02782093: balloon
+ n02783161: ballpoint
+ n02786058: Band_Aid
+ n02787622: banjo
+ n02788148: bannister
+ n02790996: barbell
+ n02791124: barber_chair
+ n02791270: barbershop
+ n02793495: barn
+ n02794156: barometer
+ n02795169: barrel
+ n02797295: barrow
+ n02799071: baseball
+ n02802426: basketball
+ n02804414: bassinet
+ n02804610: bassoon
+ n02807133: bathing_cap
+ n02808304: bath_towel
+ n02808440: bathtub
+ n02814533: beach_wagon
+ n02814860: beacon
+ n02815834: beaker
+ n02817516: bearskin
+ n02823428: beer_bottle
+ n02823750: beer_glass
+ n02825657: bell_cote
+ n02834397: bib
+ n02835271: bicycle-built-for-two
+ n02837789: bikini
+ n02840245: binder
+ n02841315: binoculars
+ n02843684: birdhouse
+ n02859443: boathouse
+ n02860847: bobsled
+ n02865351: bolo_tie
+ n02869837: bonnet
+ n02870880: bookcase
+ n02871525: bookshop
+ n02877765: bottlecap
+ n02879718: bow
+ n02883205: bow_tie
+ n02892201: brass
+ n02892767: brassiere
+ n02894605: breakwater
+ n02895154: breastplate
+ n02906734: broom
+ n02909870: bucket
+ n02910353: buckle
+ n02916936: bulletproof_vest
+ n02917067: bullet_train
+ n02927161: butcher_shop
+ n02930766: cab
+ n02939185: caldron
+ n02948072: candle
+ n02950826: cannon
+ n02951358: canoe
+ n02951585: can_opener
+ n02963159: cardigan
+ n02965783: car_mirror
+ n02966193: carousel
+ n02966687: carpenter's_kit
+ n02971356: carton
+ n02974003: car_wheel
+ n02977058: cash_machine
+ n02978881: cassette
+ n02979186: cassette_player
+ n02980441: castle
+ n02981792: catamaran
+ n02988304: CD_player
+ n02992211: cello
+ n02992529: cellular_telephone
+ n02999410: chain
+ n03000134: chainlink_fence
+ n03000247: chain_mail
+ n03000684: chain_saw
+ n03014705: chest
+ n03016953: chiffonier
+ n03017168: chime
+ n03018349: china_cabinet
+ n03026506: Christmas_stocking
+ n03028079: church
+ n03032252: cinema
+ n03041632: cleaver
+ n03042490: cliff_dwelling
+ n03045698: cloak
+ n03047690: clog
+ n03062245: cocktail_shaker
+ n03063599: coffee_mug
+ n03063689: coffeepot
+ n03065424: coil
+ n03075370: combination_lock
+ n03085013: computer_keyboard
+ n03089624: confectionery
+ n03095699: container_ship
+ n03100240: convertible
+ n03109150: corkscrew
+ n03110669: cornet
+ n03124043: cowboy_boot
+ n03124170: cowboy_hat
+ n03125729: cradle
+ n03126707: crane_(machine)
+ n03127747: crash_helmet
+ n03127925: crate
+ n03131574: crib
+ n03133878: Crock_Pot
+ n03134739: croquet_ball
+ n03141823: crutch
+ n03146219: cuirass
+ n03160309: dam
+ n03179701: desk
+ n03180011: desktop_computer
+ n03187595: dial_telephone
+ n03188531: diaper
+ n03196217: digital_clock
+ n03197337: digital_watch
+ n03201208: dining_table
+ n03207743: dishrag
+ n03207941: dishwasher
+ n03208938: disk_brake
+ n03216828: dock
+ n03218198: dogsled
+ n03220513: dome
+ n03223299: doormat
+ n03240683: drilling_platform
+ n03249569: drum
+ n03250847: drumstick
+ n03255030: dumbbell
+ n03259280: Dutch_oven
+ n03271574: electric_fan
+ n03272010: electric_guitar
+ n03272562: electric_locomotive
+ n03290653: entertainment_center
+ n03291819: envelope
+ n03297495: espresso_maker
+ n03314780: face_powder
+ n03325584: feather_boa
+ n03337140: file
+ n03344393: fireboat
+ n03345487: fire_engine
+ n03347037: fire_screen
+ n03355925: flagpole
+ n03372029: flute
+ n03376595: folding_chair
+ n03379051: football_helmet
+ n03384352: forklift
+ n03388043: fountain
+ n03388183: fountain_pen
+ n03388549: four-poster
+ n03393912: freight_car
+ n03394916: French_horn
+ n03400231: frying_pan
+ n03404251: fur_coat
+ n03417042: garbage_truck
+ n03424325: gasmask
+ n03425413: gas_pump
+ n03443371: goblet
+ n03444034: go-kart
+ n03445777: golf_ball
+ n03445924: golfcart
+ n03447447: gondola
+ n03447721: gong
+ n03450230: gown
+ n03452741: grand_piano
+ n03457902: greenhouse
+ n03459775: grille
+ n03461385: grocery_store
+ n03467068: guillotine
+ n03476684: hair_slide
+ n03476991: hair_spray
+ n03478589: half_track
+ n03481172: hammer
+ n03482405: hamper
+ n03483316: hand_blower
+ n03485407: hand-held_computer
+ n03485794: handkerchief
+ n03492542: hard_disc
+ n03494278: harmonica
+ n03495258: harp
+ n03496892: harvester
+ n03498962: hatchet
+ n03527444: holster
+ n03529860: home_theater
+ n03530642: honeycomb
+ n03532672: hook
+ n03534580: hoopskirt
+ n03535780: horizontal_bar
+ n03538406: horse_cart
+ n03544143: hourglass
+ n03584254: iPod
+ n03584829: iron
+ n03590841: jack-o'-lantern
+ n03594734: jean
+ n03594945: jeep
+ n03595614: jersey
+ n03598930: jigsaw_puzzle
+ n03599486: jinrikisha
+ n03602883: joystick
+ n03617480: kimono
+ n03623198: knee_pad
+ n03627232: knot
+ n03630383: lab_coat
+ n03633091: ladle
+ n03637318: lampshade
+ n03642806: laptop
+ n03649909: lawn_mower
+ n03657121: lens_cap
+ n03658185: letter_opener
+ n03661043: library
+ n03662601: lifeboat
+ n03666591: lighter
+ n03670208: limousine
+ n03673027: liner
+ n03676483: lipstick
+ n03680355: Loafer
+ n03690938: lotion
+ n03691459: loudspeaker
+ n03692522: loupe
+ n03697007: lumbermill
+ n03706229: magnetic_compass
+ n03709823: mailbag
+ n03710193: mailbox
+ n03710637: maillot_(tights)
+ n03710721: maillot_(tank_suit)
+ n03717622: manhole_cover
+ n03720891: maraca
+ n03721384: marimba
+ n03724870: mask
+ n03729826: matchstick
+ n03733131: maypole
+ n03733281: maze
+ n03733805: measuring_cup
+ n03742115: medicine_chest
+ n03743016: megalith
+ n03759954: microphone
+ n03761084: microwave
+ n03763968: military_uniform
+ n03764736: milk_can
+ n03769881: minibus
+ n03770439: miniskirt
+ n03770679: minivan
+ n03773504: missile
+ n03775071: mitten
+ n03775546: mixing_bowl
+ n03776460: mobile_home
+ n03777568: Model_T
+ n03777754: modem
+ n03781244: monastery
+ n03782006: monitor
+ n03785016: moped
+ n03786901: mortar
+ n03787032: mortarboard
+ n03788195: mosque
+ n03788365: mosquito_net
+ n03791053: motor_scooter
+ n03792782: mountain_bike
+ n03792972: mountain_tent
+ n03793489: mouse
+ n03794056: mousetrap
+ n03796401: moving_van
+ n03803284: muzzle
+ n03804744: nail
+ n03814639: neck_brace
+ n03814906: necklace
+ n03825788: nipple
+ n03832673: notebook
+ n03837869: obelisk
+ n03838899: oboe
+ n03840681: ocarina
+ n03841143: odometer
+ n03843555: oil_filter
+ n03854065: organ
+ n03857828: oscilloscope
+ n03866082: overskirt
+ n03868242: oxcart
+ n03868863: oxygen_mask
+ n03871628: packet
+ n03873416: paddle
+ n03874293: paddlewheel
+ n03874599: padlock
+ n03876231: paintbrush
+ n03877472: pajama
+ n03877845: palace
+ n03884397: panpipe
+ n03887697: paper_towel
+ n03888257: parachute
+ n03888605: parallel_bars
+ n03891251: park_bench
+ n03891332: parking_meter
+ n03895866: passenger_car
+ n03899768: patio
+ n03902125: pay-phone
+ n03903868: pedestal
+ n03908618: pencil_box
+ n03908714: pencil_sharpener
+ n03916031: perfume
+ n03920288: Petri_dish
+ n03924679: photocopier
+ n03929660: pick
+ n03929855: pickelhaube
+ n03930313: picket_fence
+ n03930630: pickup
+ n03933933: pier
+ n03935335: piggy_bank
+ n03937543: pill_bottle
+ n03938244: pillow
+ n03942813: ping-pong_ball
+ n03944341: pinwheel
+ n03947888: pirate
+ n03950228: pitcher
+ n03954731: plane
+ n03956157: planetarium
+ n03958227: plastic_bag
+ n03961711: plate_rack
+ n03967562: plow
+ n03970156: plunger
+ n03976467: Polaroid_camera
+ n03976657: pole
+ n03977966: police_van
+ n03980874: poncho
+ n03982430: pool_table
+ n03983396: pop_bottle
+ n03991062: pot
+ n03992509: potter's_wheel
+ n03995372: power_drill
+ n03998194: prayer_rug
+ n04004767: printer
+ n04005630: prison
+ n04008634: projectile
+ n04009552: projector
+ n04019541: puck
+ n04023962: punching_bag
+ n04026417: purse
+ n04033901: quill
+ n04033995: quilt
+ n04037443: racer
+ n04039381: racket
+ n04040759: radiator
+ n04041544: radio
+ n04044716: radio_telescope
+ n04049303: rain_barrel
+ n04065272: recreational_vehicle
+ n04067472: reel
+ n04069434: reflex_camera
+ n04070727: refrigerator
+ n04074963: remote_control
+ n04081281: restaurant
+ n04086273: revolver
+ n04090263: rifle
+ n04099969: rocking_chair
+ n04111531: rotisserie
+ n04116512: rubber_eraser
+ n04118538: rugby_ball
+ n04118776: rule
+ n04120489: running_shoe
+ n04125021: safe
+ n04127249: safety_pin
+ n04131690: saltshaker
+ n04133789: sandal
+ n04136333: sarong
+ n04141076: sax
+ n04141327: scabbard
+ n04141975: scale
+ n04146614: school_bus
+ n04147183: schooner
+ n04149813: scoreboard
+ n04152593: screen
+ n04153751: screw
+ n04154565: screwdriver
+ n04162706: seat_belt
+ n04179913: sewing_machine
+ n04192698: shield
+ n04200800: shoe_shop
+ n04201297: shoji
+ n04204238: shopping_basket
+ n04204347: shopping_cart
+ n04208210: shovel
+ n04209133: shower_cap
+ n04209239: shower_curtain
+ n04228054: ski
+ n04229816: ski_mask
+ n04235860: sleeping_bag
+ n04238763: slide_rule
+ n04239074: sliding_door
+ n04243546: slot
+ n04251144: snorkel
+ n04252077: snowmobile
+ n04252225: snowplow
+ n04254120: soap_dispenser
+ n04254680: soccer_ball
+ n04254777: sock
+ n04258138: solar_dish
+ n04259630: sombrero
+ n04263257: soup_bowl
+ n04264628: space_bar
+ n04265275: space_heater
+ n04266014: space_shuttle
+ n04270147: spatula
+ n04273569: speedboat
+ n04275548: spider_web
+ n04277352: spindle
+ n04285008: sports_car
+ n04286575: spotlight
+ n04296562: stage
+ n04310018: steam_locomotive
+ n04311004: steel_arch_bridge
+ n04311174: steel_drum
+ n04317175: stethoscope
+ n04325704: stole
+ n04326547: stone_wall
+ n04328186: stopwatch
+ n04330267: stove
+ n04332243: strainer
+ n04335435: streetcar
+ n04336792: stretcher
+ n04344873: studio_couch
+ n04346328: stupa
+ n04347754: submarine
+ n04350905: suit
+ n04355338: sundial
+ n04355933: sunglass
+ n04356056: sunglasses
+ n04357314: sunscreen
+ n04366367: suspension_bridge
+ n04367480: swab
+ n04370456: sweatshirt
+ n04371430: swimming_trunks
+ n04371774: swing
+ n04372370: switch
+ n04376876: syringe
+ n04380533: table_lamp
+ n04389033: tank
+ n04392985: tape_player
+ n04398044: teapot
+ n04399382: teddy
+ n04404412: television
+ n04409515: tennis_ball
+ n04417672: thatch
+ n04418357: theater_curtain
+ n04423845: thimble
+ n04428191: thresher
+ n04429376: throne
+ n04435653: tile_roof
+ n04442312: toaster
+ n04443257: tobacco_shop
+ n04447861: toilet_seat
+ n04456115: torch
+ n04458633: totem_pole
+ n04461696: tow_truck
+ n04462240: toyshop
+ n04465501: tractor
+ n04467665: trailer_truck
+ n04476259: tray
+ n04479046: trench_coat
+ n04482393: tricycle
+ n04483307: trimaran
+ n04485082: tripod
+ n04486054: triumphal_arch
+ n04487081: trolleybus
+ n04487394: trombone
+ n04493381: tub
+ n04501370: turnstile
+ n04505470: typewriter_keyboard
+ n04507155: umbrella
+ n04509417: unicycle
+ n04515003: upright
+ n04517823: vacuum
+ n04522168: vase
+ n04523525: vault
+ n04525038: velvet
+ n04525305: vending_machine
+ n04532106: vestment
+ n04532670: viaduct
+ n04536866: violin
+ n04540053: volleyball
+ n04542943: waffle_iron
+ n04548280: wall_clock
+ n04548362: wallet
+ n04550184: wardrobe
+ n04552348: warplane
+ n04553703: washbasin
+ n04554684: washer
+ n04557648: water_bottle
+ n04560804: water_jug
+ n04562935: water_tower
+ n04579145: whiskey_jug
+ n04579432: whistle
+ n04584207: wig
+ n04589890: window_screen
+ n04590129: window_shade
+ n04591157: Windsor_tie
+ n04591713: wine_bottle
+ n04592741: wing
+ n04596742: wok
+ n04597913: wooden_spoon
+ n04599235: wool
+ n04604644: worm_fence
+ n04606251: wreck
+ n04612504: yawl
+ n04613696: yurt
+ n06359193: web_site
+ n06596364: comic_book
+ n06785654: crossword_puzzle
+ n06794110: street_sign
+ n06874185: traffic_light
+ n07248320: book_jacket
+ n07565083: menu
+ n07579787: plate
+ n07583066: guacamole
+ n07584110: consomme
+ n07590611: hot_pot
+ n07613480: trifle
+ n07614500: ice_cream
+ n07615774: ice_lolly
+ n07684084: French_loaf
+ n07693725: bagel
+ n07695742: pretzel
+ n07697313: cheeseburger
+ n07697537: hotdog
+ n07711569: mashed_potato
+ n07714571: head_cabbage
+ n07714990: broccoli
+ n07715103: cauliflower
+ n07716358: zucchini
+ n07716906: spaghetti_squash
+ n07717410: acorn_squash
+ n07717556: butternut_squash
+ n07718472: cucumber
+ n07718747: artichoke
+ n07720875: bell_pepper
+ n07730033: cardoon
+ n07734744: mushroom
+ n07742313: Granny_Smith
+ n07745940: strawberry
+ n07747607: orange
+ n07749582: lemon
+ n07753113: fig
+ n07753275: pineapple
+ n07753592: banana
+ n07754684: jackfruit
+ n07760859: custard_apple
+ n07768694: pomegranate
+ n07802026: hay
+ n07831146: carbonara
+ n07836838: chocolate_sauce
+ n07860988: dough
+ n07871810: meat_loaf
+ n07873807: pizza
+ n07875152: potpie
+ n07880968: burrito
+ n07892512: red_wine
+ n07920052: espresso
+ n07930864: cup
+ n07932039: eggnog
+ n09193705: alp
+ n09229709: bubble
+ n09246464: cliff
+ n09256479: coral_reef
+ n09288635: geyser
+ n09332890: lakeside
+ n09399592: promontory
+ n09421951: sandbar
+ n09428293: seashore
+ n09468604: valley
+ n09472597: volcano
+ n09835506: ballplayer
+ n10148035: groom
+ n10565667: scuba_diver
+ n11879895: rapeseed
+ n11939491: daisy
+ n12057211: yellow_lady's_slipper
+ n12144580: corn
+ n12267677: acorn
+ n12620546: hip
+ n12768682: buckeye
+ n12985857: coral_fungus
+ n12998815: agaric
+ n13037406: gyromitra
+ n13040303: stinkhorn
+ n13044778: earthstar
+ n13052670: hen-of-the-woods
+ n13054560: bolete
+ n13133613: ear
+ n15075141: toilet_tissue
+
+
+# Download script/URL (optional)
+download: yolo/data/scripts/get_imagenet.sh
diff --git a/ultralytics/ultralytics/cfg/datasets/Objects365.yaml b/ultralytics/ultralytics/cfg/datasets/Objects365.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..415eff98352da330291de496d77d1e6280c01c48
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/Objects365.yaml
@@ -0,0 +1,443 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Objects365 dataset https://www.objects365.org/ by Megvii
+# Example usage: yolo train data=Objects365.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── Objects365 ← downloads here (712 GB = 367G data + 345G zips)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/Objects365 # dataset root dir
+train: images/train # train images (relative to 'path') 1742289 images
+val: images/val # val images (relative to 'path') 80000 images
+test: # test images (optional)
+
+# Classes
+names:
+ 0: Person
+ 1: Sneakers
+ 2: Chair
+ 3: Other Shoes
+ 4: Hat
+ 5: Car
+ 6: Lamp
+ 7: Glasses
+ 8: Bottle
+ 9: Desk
+ 10: Cup
+ 11: Street Lights
+ 12: Cabinet/shelf
+ 13: Handbag/Satchel
+ 14: Bracelet
+ 15: Plate
+ 16: Picture/Frame
+ 17: Helmet
+ 18: Book
+ 19: Gloves
+ 20: Storage box
+ 21: Boat
+ 22: Leather Shoes
+ 23: Flower
+ 24: Bench
+ 25: Potted Plant
+ 26: Bowl/Basin
+ 27: Flag
+ 28: Pillow
+ 29: Boots
+ 30: Vase
+ 31: Microphone
+ 32: Necklace
+ 33: Ring
+ 34: SUV
+ 35: Wine Glass
+ 36: Belt
+ 37: Monitor/TV
+ 38: Backpack
+ 39: Umbrella
+ 40: Traffic Light
+ 41: Speaker
+ 42: Watch
+ 43: Tie
+ 44: Trash bin Can
+ 45: Slippers
+ 46: Bicycle
+ 47: Stool
+ 48: Barrel/bucket
+ 49: Van
+ 50: Couch
+ 51: Sandals
+ 52: Basket
+ 53: Drum
+ 54: Pen/Pencil
+ 55: Bus
+ 56: Wild Bird
+ 57: High Heels
+ 58: Motorcycle
+ 59: Guitar
+ 60: Carpet
+ 61: Cell Phone
+ 62: Bread
+ 63: Camera
+ 64: Canned
+ 65: Truck
+ 66: Traffic cone
+ 67: Cymbal
+ 68: Lifesaver
+ 69: Towel
+ 70: Stuffed Toy
+ 71: Candle
+ 72: Sailboat
+ 73: Laptop
+ 74: Awning
+ 75: Bed
+ 76: Faucet
+ 77: Tent
+ 78: Horse
+ 79: Mirror
+ 80: Power outlet
+ 81: Sink
+ 82: Apple
+ 83: Air Conditioner
+ 84: Knife
+ 85: Hockey Stick
+ 86: Paddle
+ 87: Pickup Truck
+ 88: Fork
+ 89: Traffic Sign
+ 90: Balloon
+ 91: Tripod
+ 92: Dog
+ 93: Spoon
+ 94: Clock
+ 95: Pot
+ 96: Cow
+ 97: Cake
+ 98: Dinning Table
+ 99: Sheep
+ 100: Hanger
+ 101: Blackboard/Whiteboard
+ 102: Napkin
+ 103: Other Fish
+ 104: Orange/Tangerine
+ 105: Toiletry
+ 106: Keyboard
+ 107: Tomato
+ 108: Lantern
+ 109: Machinery Vehicle
+ 110: Fan
+ 111: Green Vegetables
+ 112: Banana
+ 113: Baseball Glove
+ 114: Airplane
+ 115: Mouse
+ 116: Train
+ 117: Pumpkin
+ 118: Soccer
+ 119: Skiboard
+ 120: Luggage
+ 121: Nightstand
+ 122: Tea pot
+ 123: Telephone
+ 124: Trolley
+ 125: Head Phone
+ 126: Sports Car
+ 127: Stop Sign
+ 128: Dessert
+ 129: Scooter
+ 130: Stroller
+ 131: Crane
+ 132: Remote
+ 133: Refrigerator
+ 134: Oven
+ 135: Lemon
+ 136: Duck
+ 137: Baseball Bat
+ 138: Surveillance Camera
+ 139: Cat
+ 140: Jug
+ 141: Broccoli
+ 142: Piano
+ 143: Pizza
+ 144: Elephant
+ 145: Skateboard
+ 146: Surfboard
+ 147: Gun
+ 148: Skating and Skiing shoes
+ 149: Gas stove
+ 150: Donut
+ 151: Bow Tie
+ 152: Carrot
+ 153: Toilet
+ 154: Kite
+ 155: Strawberry
+ 156: Other Balls
+ 157: Shovel
+ 158: Pepper
+ 159: Computer Box
+ 160: Toilet Paper
+ 161: Cleaning Products
+ 162: Chopsticks
+ 163: Microwave
+ 164: Pigeon
+ 165: Baseball
+ 166: Cutting/chopping Board
+ 167: Coffee Table
+ 168: Side Table
+ 169: Scissors
+ 170: Marker
+ 171: Pie
+ 172: Ladder
+ 173: Snowboard
+ 174: Cookies
+ 175: Radiator
+ 176: Fire Hydrant
+ 177: Basketball
+ 178: Zebra
+ 179: Grape
+ 180: Giraffe
+ 181: Potato
+ 182: Sausage
+ 183: Tricycle
+ 184: Violin
+ 185: Egg
+ 186: Fire Extinguisher
+ 187: Candy
+ 188: Fire Truck
+ 189: Billiards
+ 190: Converter
+ 191: Bathtub
+ 192: Wheelchair
+ 193: Golf Club
+ 194: Briefcase
+ 195: Cucumber
+ 196: Cigar/Cigarette
+ 197: Paint Brush
+ 198: Pear
+ 199: Heavy Truck
+ 200: Hamburger
+ 201: Extractor
+ 202: Extension Cord
+ 203: Tong
+ 204: Tennis Racket
+ 205: Folder
+ 206: American Football
+ 207: earphone
+ 208: Mask
+ 209: Kettle
+ 210: Tennis
+ 211: Ship
+ 212: Swing
+ 213: Coffee Machine
+ 214: Slide
+ 215: Carriage
+ 216: Onion
+ 217: Green beans
+ 218: Projector
+ 219: Frisbee
+ 220: Washing Machine/Drying Machine
+ 221: Chicken
+ 222: Printer
+ 223: Watermelon
+ 224: Saxophone
+ 225: Tissue
+ 226: Toothbrush
+ 227: Ice cream
+ 228: Hot-air balloon
+ 229: Cello
+ 230: French Fries
+ 231: Scale
+ 232: Trophy
+ 233: Cabbage
+ 234: Hot dog
+ 235: Blender
+ 236: Peach
+ 237: Rice
+ 238: Wallet/Purse
+ 239: Volleyball
+ 240: Deer
+ 241: Goose
+ 242: Tape
+ 243: Tablet
+ 244: Cosmetics
+ 245: Trumpet
+ 246: Pineapple
+ 247: Golf Ball
+ 248: Ambulance
+ 249: Parking meter
+ 250: Mango
+ 251: Key
+ 252: Hurdle
+ 253: Fishing Rod
+ 254: Medal
+ 255: Flute
+ 256: Brush
+ 257: Penguin
+ 258: Megaphone
+ 259: Corn
+ 260: Lettuce
+ 261: Garlic
+ 262: Swan
+ 263: Helicopter
+ 264: Green Onion
+ 265: Sandwich
+ 266: Nuts
+ 267: Speed Limit Sign
+ 268: Induction Cooker
+ 269: Broom
+ 270: Trombone
+ 271: Plum
+ 272: Rickshaw
+ 273: Goldfish
+ 274: Kiwi fruit
+ 275: Router/modem
+ 276: Poker Card
+ 277: Toaster
+ 278: Shrimp
+ 279: Sushi
+ 280: Cheese
+ 281: Notepaper
+ 282: Cherry
+ 283: Pliers
+ 284: CD
+ 285: Pasta
+ 286: Hammer
+ 287: Cue
+ 288: Avocado
+ 289: Hamimelon
+ 290: Flask
+ 291: Mushroom
+ 292: Screwdriver
+ 293: Soap
+ 294: Recorder
+ 295: Bear
+ 296: Eggplant
+ 297: Board Eraser
+ 298: Coconut
+ 299: Tape Measure/Ruler
+ 300: Pig
+ 301: Showerhead
+ 302: Globe
+ 303: Chips
+ 304: Steak
+ 305: Crosswalk Sign
+ 306: Stapler
+ 307: Camel
+ 308: Formula 1
+ 309: Pomegranate
+ 310: Dishwasher
+ 311: Crab
+ 312: Hoverboard
+ 313: Meat ball
+ 314: Rice Cooker
+ 315: Tuba
+ 316: Calculator
+ 317: Papaya
+ 318: Antelope
+ 319: Parrot
+ 320: Seal
+ 321: Butterfly
+ 322: Dumbbell
+ 323: Donkey
+ 324: Lion
+ 325: Urinal
+ 326: Dolphin
+ 327: Electric Drill
+ 328: Hair Dryer
+ 329: Egg tart
+ 330: Jellyfish
+ 331: Treadmill
+ 332: Lighter
+ 333: Grapefruit
+ 334: Game board
+ 335: Mop
+ 336: Radish
+ 337: Baozi
+ 338: Target
+ 339: French
+ 340: Spring Rolls
+ 341: Monkey
+ 342: Rabbit
+ 343: Pencil Case
+ 344: Yak
+ 345: Red Cabbage
+ 346: Binoculars
+ 347: Asparagus
+ 348: Barbell
+ 349: Scallop
+ 350: Noddles
+ 351: Comb
+ 352: Dumpling
+ 353: Oyster
+ 354: Table Tennis paddle
+ 355: Cosmetics Brush/Eyeliner Pencil
+ 356: Chainsaw
+ 357: Eraser
+ 358: Lobster
+ 359: Durian
+ 360: Okra
+ 361: Lipstick
+ 362: Cosmetics Mirror
+ 363: Curling
+ 364: Table Tennis
+
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+ from tqdm import tqdm
+
+ from ultralytics.utils.checks import check_requirements
+ from ultralytics.utils.downloads import download
+ from ultralytics.utils.ops import xyxy2xywhn
+
+ import numpy as np
+ from pathlib import Path
+
+ check_requirements(('pycocotools>=2.0',))
+ from pycocotools.coco import COCO
+
+ # Make Directories
+ dir = Path(yaml['path']) # dataset root dir
+ for p in 'images', 'labels':
+ (dir / p).mkdir(parents=True, exist_ok=True)
+ for q in 'train', 'val':
+ (dir / p / q).mkdir(parents=True, exist_ok=True)
+
+ # Train, Val Splits
+ for split, patches in [('train', 50 + 1), ('val', 43 + 1)]:
+ print(f"Processing {split} in {patches} patches ...")
+ images, labels = dir / 'images' / split, dir / 'labels' / split
+
+ # Download
+ url = f"https://dorc.ks3-cn-beijing.ksyun.com/data-set/2020Objects365%E6%95%B0%E6%8D%AE%E9%9B%86/{split}/"
+ if split == 'train':
+ download([f'{url}zhiyuan_objv2_{split}.tar.gz'], dir=dir) # annotations json
+ download([f'{url}patch{i}.tar.gz' for i in range(patches)], dir=images, curl=True, threads=8)
+ elif split == 'val':
+ download([f'{url}zhiyuan_objv2_{split}.json'], dir=dir) # annotations json
+ download([f'{url}images/v1/patch{i}.tar.gz' for i in range(15 + 1)], dir=images, curl=True, threads=8)
+ download([f'{url}images/v2/patch{i}.tar.gz' for i in range(16, patches)], dir=images, curl=True, threads=8)
+
+ # Move
+ for f in tqdm(images.rglob('*.jpg'), desc=f'Moving {split} images'):
+ f.rename(images / f.name) # move to /images/{split}
+
+ # Labels
+ coco = COCO(dir / f'zhiyuan_objv2_{split}.json')
+ names = [x["name"] for x in coco.loadCats(coco.getCatIds())]
+ for cid, cat in enumerate(names):
+ catIds = coco.getCatIds(catNms=[cat])
+ imgIds = coco.getImgIds(catIds=catIds)
+ for im in tqdm(coco.loadImgs(imgIds), desc=f'Class {cid + 1}/{len(names)} {cat}'):
+ width, height = im["width"], im["height"]
+ path = Path(im["file_name"]) # image filename
+ try:
+ with open(labels / path.with_suffix('.txt').name, 'a') as file:
+ annIds = coco.getAnnIds(imgIds=im["id"], catIds=catIds, iscrowd=None)
+ for a in coco.loadAnns(annIds):
+ x, y, w, h = a['bbox'] # bounding box in xywh (xy top-left corner)
+ xyxy = np.array([x, y, x + w, y + h])[None] # pixels(1,4)
+ x, y, w, h = xyxy2xywhn(xyxy, w=width, h=height, clip=True)[0] # normalized and clipped
+ file.write(f"{cid} {x:.5f} {y:.5f} {w:.5f} {h:.5f}\n")
+ except Exception as e:
+ print(e)
diff --git a/ultralytics/ultralytics/cfg/datasets/SKU-110K.yaml b/ultralytics/ultralytics/cfg/datasets/SKU-110K.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e6deac21ef34c019070a27a55aad786b60901653
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/SKU-110K.yaml
@@ -0,0 +1,58 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# SKU-110K retail items dataset https://github.com/eg4000/SKU110K_CVPR19 by Trax Retail
+# Example usage: yolo train data=SKU-110K.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── SKU-110K ← downloads here (13.6 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/SKU-110K # dataset root dir
+train: train.txt # train images (relative to 'path') 8219 images
+val: val.txt # val images (relative to 'path') 588 images
+test: test.txt # test images (optional) 2936 images
+
+# Classes
+names:
+ 0: object
+
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+ import shutil
+ from pathlib import Path
+
+ import numpy as np
+ import pandas as pd
+ from tqdm import tqdm
+
+ from ultralytics.utils.downloads import download
+ from ultralytics.utils.ops import xyxy2xywh
+
+ # Download
+ dir = Path(yaml['path']) # dataset root dir
+ parent = Path(dir.parent) # download dir
+ urls = ['http://trax-geometry.s3.amazonaws.com/cvpr_challenge/SKU110K_fixed.tar.gz']
+ download(urls, dir=parent)
+
+ # Rename directories
+ if dir.exists():
+ shutil.rmtree(dir)
+ (parent / 'SKU110K_fixed').rename(dir) # rename dir
+ (dir / 'labels').mkdir(parents=True, exist_ok=True) # create labels dir
+
+ # Convert labels
+ names = 'image', 'x1', 'y1', 'x2', 'y2', 'class', 'image_width', 'image_height' # column names
+ for d in 'annotations_train.csv', 'annotations_val.csv', 'annotations_test.csv':
+ x = pd.read_csv(dir / 'annotations' / d, names=names).values # annotations
+ images, unique_images = x[:, 0], np.unique(x[:, 0])
+ with open((dir / d).with_suffix('.txt').__str__().replace('annotations_', ''), 'w') as f:
+ f.writelines(f'./images/{s}\n' for s in unique_images)
+ for im in tqdm(unique_images, desc=f'Converting {dir / d}'):
+ cls = 0 # single-class dataset
+ with open((dir / 'labels' / im).with_suffix('.txt'), 'a') as f:
+ for r in x[images == im]:
+ w, h = r[6], r[7] # image width, height
+ xywh = xyxy2xywh(np.array([[r[1] / w, r[2] / h, r[3] / w, r[4] / h]]))[0] # instance
+ f.write(f"{cls} {xywh[0]:.5f} {xywh[1]:.5f} {xywh[2]:.5f} {xywh[3]:.5f}\n") # write label
diff --git a/ultralytics/ultralytics/cfg/datasets/VOC.yaml b/ultralytics/ultralytics/cfg/datasets/VOC.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6bdcc4f13938c9185d31e34fc60aa0c57ec58978
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/VOC.yaml
@@ -0,0 +1,100 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# PASCAL VOC dataset http://host.robots.ox.ac.uk/pascal/VOC by University of Oxford
+# Example usage: yolo train data=VOC.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── VOC ← downloads here (2.8 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/VOC
+train: # train images (relative to 'path') 16551 images
+ - images/train2012
+ - images/train2007
+ - images/val2012
+ - images/val2007
+val: # val images (relative to 'path') 4952 images
+ - images/test2007
+test: # test images (optional)
+ - images/test2007
+
+# Classes
+names:
+ 0: aeroplane
+ 1: bicycle
+ 2: bird
+ 3: boat
+ 4: bottle
+ 5: bus
+ 6: car
+ 7: cat
+ 8: chair
+ 9: cow
+ 10: diningtable
+ 11: dog
+ 12: horse
+ 13: motorbike
+ 14: person
+ 15: pottedplant
+ 16: sheep
+ 17: sofa
+ 18: train
+ 19: tvmonitor
+
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+ import xml.etree.ElementTree as ET
+
+ from tqdm import tqdm
+ from ultralytics.utils.downloads import download
+ from pathlib import Path
+
+ def convert_label(path, lb_path, year, image_id):
+ def convert_box(size, box):
+ dw, dh = 1. / size[0], 1. / size[1]
+ x, y, w, h = (box[0] + box[1]) / 2.0 - 1, (box[2] + box[3]) / 2.0 - 1, box[1] - box[0], box[3] - box[2]
+ return x * dw, y * dh, w * dw, h * dh
+
+ in_file = open(path / f'VOC{year}/Annotations/{image_id}.xml')
+ out_file = open(lb_path, 'w')
+ tree = ET.parse(in_file)
+ root = tree.getroot()
+ size = root.find('size')
+ w = int(size.find('width').text)
+ h = int(size.find('height').text)
+
+ names = list(yaml['names'].values()) # names list
+ for obj in root.iter('object'):
+ cls = obj.find('name').text
+ if cls in names and int(obj.find('difficult').text) != 1:
+ xmlbox = obj.find('bndbox')
+ bb = convert_box((w, h), [float(xmlbox.find(x).text) for x in ('xmin', 'xmax', 'ymin', 'ymax')])
+ cls_id = names.index(cls) # class id
+ out_file.write(" ".join(str(a) for a in (cls_id, *bb)) + '\n')
+
+
+ # Download
+ dir = Path(yaml['path']) # dataset root dir
+ url = 'https://github.com/ultralytics/yolov5/releases/download/v1.0/'
+ urls = [f'{url}VOCtrainval_06-Nov-2007.zip', # 446MB, 5012 images
+ f'{url}VOCtest_06-Nov-2007.zip', # 438MB, 4953 images
+ f'{url}VOCtrainval_11-May-2012.zip'] # 1.95GB, 17126 images
+ download(urls, dir=dir / 'images', curl=True, threads=3)
+
+ # Convert
+ path = dir / 'images/VOCdevkit'
+ for year, image_set in ('2012', 'train'), ('2012', 'val'), ('2007', 'train'), ('2007', 'val'), ('2007', 'test'):
+ imgs_path = dir / 'images' / f'{image_set}{year}'
+ lbs_path = dir / 'labels' / f'{image_set}{year}'
+ imgs_path.mkdir(exist_ok=True, parents=True)
+ lbs_path.mkdir(exist_ok=True, parents=True)
+
+ with open(path / f'VOC{year}/ImageSets/Main/{image_set}.txt') as f:
+ image_ids = f.read().strip().split()
+ for id in tqdm(image_ids, desc=f'{image_set}{year}'):
+ f = path / f'VOC{year}/JPEGImages/{id}.jpg' # old img path
+ lb_path = (lbs_path / f.name).with_suffix('.txt') # new label path
+ f.rename(imgs_path / f.name) # move image
+ convert_label(path, lb_path, year, id) # convert labels to YOLO format
diff --git a/ultralytics/ultralytics/cfg/datasets/VisDrone.yaml b/ultralytics/ultralytics/cfg/datasets/VisDrone.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a1a4a466ceaf1f2883c3abce6cba7045b96ce432
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/VisDrone.yaml
@@ -0,0 +1,73 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# VisDrone2019-DET dataset https://github.com/VisDrone/VisDrone-Dataset by Tianjin University
+# Example usage: yolo train data=VisDrone.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── VisDrone ← downloads here (2.3 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/VisDrone # dataset root dir
+train: VisDrone2019-DET-train/images # train images (relative to 'path') 6471 images
+val: VisDrone2019-DET-val/images # val images (relative to 'path') 548 images
+test: VisDrone2019-DET-test-dev/images # test images (optional) 1610 images
+
+# Classes
+names:
+ 0: pedestrian
+ 1: people
+ 2: bicycle
+ 3: car
+ 4: van
+ 5: truck
+ 6: tricycle
+ 7: awning-tricycle
+ 8: bus
+ 9: motor
+
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+ import os
+ from pathlib import Path
+
+ from ultralytics.utils.downloads import download
+
+ def visdrone2yolo(dir):
+ from PIL import Image
+ from tqdm import tqdm
+
+ def convert_box(size, box):
+ # Convert VisDrone box to YOLO xywh box
+ dw = 1. / size[0]
+ dh = 1. / size[1]
+ return (box[0] + box[2] / 2) * dw, (box[1] + box[3] / 2) * dh, box[2] * dw, box[3] * dh
+
+ (dir / 'labels').mkdir(parents=True, exist_ok=True) # make labels directory
+ pbar = tqdm((dir / 'annotations').glob('*.txt'), desc=f'Converting {dir}')
+ for f in pbar:
+ img_size = Image.open((dir / 'images' / f.name).with_suffix('.jpg')).size
+ lines = []
+ with open(f, 'r') as file: # read annotation.txt
+ for row in [x.split(',') for x in file.read().strip().splitlines()]:
+ if row[4] == '0': # VisDrone 'ignored regions' class 0
+ continue
+ cls = int(row[5]) - 1
+ box = convert_box(img_size, tuple(map(int, row[:4])))
+ lines.append(f"{cls} {' '.join(f'{x:.6f}' for x in box)}\n")
+ with open(str(f).replace(f'{os.sep}annotations{os.sep}', f'{os.sep}labels{os.sep}'), 'w') as fl:
+ fl.writelines(lines) # write label.txt
+
+
+ # Download
+ dir = Path(yaml['path']) # dataset root dir
+ urls = ['https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-train.zip',
+ 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-val.zip',
+ 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-test-dev.zip',
+ 'https://github.com/ultralytics/yolov5/releases/download/v1.0/VisDrone2019-DET-test-challenge.zip']
+ download(urls, dir=dir, curl=True, threads=4)
+
+ # Convert
+ for d in 'VisDrone2019-DET-train', 'VisDrone2019-DET-val', 'VisDrone2019-DET-test-dev':
+ visdrone2yolo(dir / d) # convert VisDrone annotations to YOLO labels
diff --git a/ultralytics/ultralytics/cfg/datasets/coco-pose.yaml b/ultralytics/ultralytics/cfg/datasets/coco-pose.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..670d55bf691e558c048926b7e5951d6300eddd04
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/coco-pose.yaml
@@ -0,0 +1,38 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# COCO 2017 dataset http://cocodataset.org by Microsoft
+# Example usage: yolo train data=coco-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── coco-pose ← downloads here (20.1 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco-pose # dataset root dir
+train: train2017.txt # train images (relative to 'path') 118287 images
+val: val2017.txt # val images (relative to 'path') 5000 images
+test: test-dev2017.txt # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
+
+# Keypoints
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
+
+# Classes
+names:
+ 0: person
+
+# Download script/URL (optional)
+download: |
+ from ultralytics.utils.downloads import download
+ from pathlib import Path
+
+ # Download labels
+ dir = Path(yaml['path']) # dataset root dir
+ url = 'https://github.com/ultralytics/yolov5/releases/download/v1.0/'
+ urls = [url + 'coco2017labels-pose.zip'] # labels
+ download(urls, dir=dir.parent)
+ # Download data
+ urls = ['http://images.cocodataset.org/zips/train2017.zip', # 19G, 118k images
+ 'http://images.cocodataset.org/zips/val2017.zip', # 1G, 5k images
+ 'http://images.cocodataset.org/zips/test2017.zip'] # 7G, 41k images (optional)
+ download(urls, dir=dir / 'images', threads=3)
diff --git a/ultralytics/ultralytics/cfg/datasets/coco.yaml b/ultralytics/ultralytics/cfg/datasets/coco.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..8a70a5b34bf2a4de112f7ed2c88c402d08203bbf
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/coco.yaml
@@ -0,0 +1,115 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# COCO 2017 dataset http://cocodataset.org by Microsoft
+# Example usage: yolo train data=coco.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── coco ← downloads here (20.1 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco # dataset root dir
+train: train2017.txt # train images (relative to 'path') 118287 images
+val: val2017.txt # val images (relative to 'path') 5000 images
+test: test-dev2017.txt # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
+
+# Classes
+names:
+ 0: person
+ 1: bicycle
+ 2: car
+ 3: motorcycle
+ 4: airplane
+ 5: bus
+ 6: train
+ 7: truck
+ 8: boat
+ 9: traffic light
+ 10: fire hydrant
+ 11: stop sign
+ 12: parking meter
+ 13: bench
+ 14: bird
+ 15: cat
+ 16: dog
+ 17: horse
+ 18: sheep
+ 19: cow
+ 20: elephant
+ 21: bear
+ 22: zebra
+ 23: giraffe
+ 24: backpack
+ 25: umbrella
+ 26: handbag
+ 27: tie
+ 28: suitcase
+ 29: frisbee
+ 30: skis
+ 31: snowboard
+ 32: sports ball
+ 33: kite
+ 34: baseball bat
+ 35: baseball glove
+ 36: skateboard
+ 37: surfboard
+ 38: tennis racket
+ 39: bottle
+ 40: wine glass
+ 41: cup
+ 42: fork
+ 43: knife
+ 44: spoon
+ 45: bowl
+ 46: banana
+ 47: apple
+ 48: sandwich
+ 49: orange
+ 50: broccoli
+ 51: carrot
+ 52: hot dog
+ 53: pizza
+ 54: donut
+ 55: cake
+ 56: chair
+ 57: couch
+ 58: potted plant
+ 59: bed
+ 60: dining table
+ 61: toilet
+ 62: tv
+ 63: laptop
+ 64: mouse
+ 65: remote
+ 66: keyboard
+ 67: cell phone
+ 68: microwave
+ 69: oven
+ 70: toaster
+ 71: sink
+ 72: refrigerator
+ 73: book
+ 74: clock
+ 75: vase
+ 76: scissors
+ 77: teddy bear
+ 78: hair drier
+ 79: toothbrush
+
+
+# Download script/URL (optional)
+download: |
+ from ultralytics.utils.downloads import download
+ from pathlib import Path
+
+ # Download labels
+ segments = True # segment or box labels
+ dir = Path(yaml['path']) # dataset root dir
+ url = 'https://github.com/ultralytics/yolov5/releases/download/v1.0/'
+ urls = [url + ('coco2017labels-segments.zip' if segments else 'coco2017labels.zip')] # labels
+ download(urls, dir=dir.parent)
+ # Download data
+ urls = ['http://images.cocodataset.org/zips/train2017.zip', # 19G, 118k images
+ 'http://images.cocodataset.org/zips/val2017.zip', # 1G, 5k images
+ 'http://images.cocodataset.org/zips/test2017.zip'] # 7G, 41k images (optional)
+ download(urls, dir=dir / 'images', threads=3)
diff --git a/ultralytics/ultralytics/cfg/datasets/coco128-seg.yaml b/ultralytics/ultralytics/cfg/datasets/coco128-seg.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..8c2e3da33176757a977178d83318055e9ea89bb2
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/coco128-seg.yaml
@@ -0,0 +1,101 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# COCO128-seg dataset https://www.kaggle.com/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
+# Example usage: yolo train data=coco128.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── coco128-seg ← downloads here (7 MB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco128-seg # dataset root dir
+train: images/train2017 # train images (relative to 'path') 128 images
+val: images/train2017 # val images (relative to 'path') 128 images
+test: # test images (optional)
+
+# Classes
+names:
+ 0: person
+ 1: bicycle
+ 2: car
+ 3: motorcycle
+ 4: airplane
+ 5: bus
+ 6: train
+ 7: truck
+ 8: boat
+ 9: traffic light
+ 10: fire hydrant
+ 11: stop sign
+ 12: parking meter
+ 13: bench
+ 14: bird
+ 15: cat
+ 16: dog
+ 17: horse
+ 18: sheep
+ 19: cow
+ 20: elephant
+ 21: bear
+ 22: zebra
+ 23: giraffe
+ 24: backpack
+ 25: umbrella
+ 26: handbag
+ 27: tie
+ 28: suitcase
+ 29: frisbee
+ 30: skis
+ 31: snowboard
+ 32: sports ball
+ 33: kite
+ 34: baseball bat
+ 35: baseball glove
+ 36: skateboard
+ 37: surfboard
+ 38: tennis racket
+ 39: bottle
+ 40: wine glass
+ 41: cup
+ 42: fork
+ 43: knife
+ 44: spoon
+ 45: bowl
+ 46: banana
+ 47: apple
+ 48: sandwich
+ 49: orange
+ 50: broccoli
+ 51: carrot
+ 52: hot dog
+ 53: pizza
+ 54: donut
+ 55: cake
+ 56: chair
+ 57: couch
+ 58: potted plant
+ 59: bed
+ 60: dining table
+ 61: toilet
+ 62: tv
+ 63: laptop
+ 64: mouse
+ 65: remote
+ 66: keyboard
+ 67: cell phone
+ 68: microwave
+ 69: oven
+ 70: toaster
+ 71: sink
+ 72: refrigerator
+ 73: book
+ 74: clock
+ 75: vase
+ 76: scissors
+ 77: teddy bear
+ 78: hair drier
+ 79: toothbrush
+
+
+# Download script/URL (optional)
+download: https://ultralytics.com/assets/coco128-seg.zip
diff --git a/ultralytics/ultralytics/cfg/datasets/coco128.yaml b/ultralytics/ultralytics/cfg/datasets/coco128.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9749ab6c617701dd1e2dfe0682024014bfa225d2
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/coco128.yaml
@@ -0,0 +1,101 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# COCO128 dataset https://www.kaggle.com/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
+# Example usage: yolo train data=coco128.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── coco128 ← downloads here (7 MB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco128 # dataset root dir
+train: images/train2017 # train images (relative to 'path') 128 images
+val: images/train2017 # val images (relative to 'path') 128 images
+test: # test images (optional)
+
+# Classes
+names:
+ 0: person
+ 1: bicycle
+ 2: car
+ 3: motorcycle
+ 4: airplane
+ 5: bus
+ 6: train
+ 7: truck
+ 8: boat
+ 9: traffic light
+ 10: fire hydrant
+ 11: stop sign
+ 12: parking meter
+ 13: bench
+ 14: bird
+ 15: cat
+ 16: dog
+ 17: horse
+ 18: sheep
+ 19: cow
+ 20: elephant
+ 21: bear
+ 22: zebra
+ 23: giraffe
+ 24: backpack
+ 25: umbrella
+ 26: handbag
+ 27: tie
+ 28: suitcase
+ 29: frisbee
+ 30: skis
+ 31: snowboard
+ 32: sports ball
+ 33: kite
+ 34: baseball bat
+ 35: baseball glove
+ 36: skateboard
+ 37: surfboard
+ 38: tennis racket
+ 39: bottle
+ 40: wine glass
+ 41: cup
+ 42: fork
+ 43: knife
+ 44: spoon
+ 45: bowl
+ 46: banana
+ 47: apple
+ 48: sandwich
+ 49: orange
+ 50: broccoli
+ 51: carrot
+ 52: hot dog
+ 53: pizza
+ 54: donut
+ 55: cake
+ 56: chair
+ 57: couch
+ 58: potted plant
+ 59: bed
+ 60: dining table
+ 61: toilet
+ 62: tv
+ 63: laptop
+ 64: mouse
+ 65: remote
+ 66: keyboard
+ 67: cell phone
+ 68: microwave
+ 69: oven
+ 70: toaster
+ 71: sink
+ 72: refrigerator
+ 73: book
+ 74: clock
+ 75: vase
+ 76: scissors
+ 77: teddy bear
+ 78: hair drier
+ 79: toothbrush
+
+
+# Download script/URL (optional)
+download: https://ultralytics.com/assets/coco128.zip
diff --git a/ultralytics/ultralytics/cfg/datasets/coco8-pose.yaml b/ultralytics/ultralytics/cfg/datasets/coco8-pose.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e6fab8b59801488c0da236d4b048b5e19d131ccd
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/coco8-pose.yaml
@@ -0,0 +1,25 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# COCO8-pose dataset (first 8 images from COCO train2017) by Ultralytics
+# Example usage: yolo train data=coco8-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── coco8-pose ← downloads here (1 MB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco8-pose # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+test: # test images (optional)
+
+# Keypoints
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
+
+# Classes
+names:
+ 0: person
+
+# Download script/URL (optional)
+download: https://ultralytics.com/assets/coco8-pose.zip
diff --git a/ultralytics/ultralytics/cfg/datasets/coco8-seg.yaml b/ultralytics/ultralytics/cfg/datasets/coco8-seg.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e6faca1c32c29912427853071e2d7cc9632993ca
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/coco8-seg.yaml
@@ -0,0 +1,101 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# COCO8-seg dataset (first 8 images from COCO train2017) by Ultralytics
+# Example usage: yolo train data=coco8-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── coco8-seg ← downloads here (1 MB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco8-seg # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+test: # test images (optional)
+
+# Classes
+names:
+ 0: person
+ 1: bicycle
+ 2: car
+ 3: motorcycle
+ 4: airplane
+ 5: bus
+ 6: train
+ 7: truck
+ 8: boat
+ 9: traffic light
+ 10: fire hydrant
+ 11: stop sign
+ 12: parking meter
+ 13: bench
+ 14: bird
+ 15: cat
+ 16: dog
+ 17: horse
+ 18: sheep
+ 19: cow
+ 20: elephant
+ 21: bear
+ 22: zebra
+ 23: giraffe
+ 24: backpack
+ 25: umbrella
+ 26: handbag
+ 27: tie
+ 28: suitcase
+ 29: frisbee
+ 30: skis
+ 31: snowboard
+ 32: sports ball
+ 33: kite
+ 34: baseball bat
+ 35: baseball glove
+ 36: skateboard
+ 37: surfboard
+ 38: tennis racket
+ 39: bottle
+ 40: wine glass
+ 41: cup
+ 42: fork
+ 43: knife
+ 44: spoon
+ 45: bowl
+ 46: banana
+ 47: apple
+ 48: sandwich
+ 49: orange
+ 50: broccoli
+ 51: carrot
+ 52: hot dog
+ 53: pizza
+ 54: donut
+ 55: cake
+ 56: chair
+ 57: couch
+ 58: potted plant
+ 59: bed
+ 60: dining table
+ 61: toilet
+ 62: tv
+ 63: laptop
+ 64: mouse
+ 65: remote
+ 66: keyboard
+ 67: cell phone
+ 68: microwave
+ 69: oven
+ 70: toaster
+ 71: sink
+ 72: refrigerator
+ 73: book
+ 74: clock
+ 75: vase
+ 76: scissors
+ 77: teddy bear
+ 78: hair drier
+ 79: toothbrush
+
+
+# Download script/URL (optional)
+download: https://ultralytics.com/assets/coco8-seg.zip
diff --git a/ultralytics/ultralytics/cfg/datasets/coco8.yaml b/ultralytics/ultralytics/cfg/datasets/coco8.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..eeb5d9dc78284bba1df8625361711b14c5a9eec3
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/coco8.yaml
@@ -0,0 +1,101 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# COCO8 dataset (first 8 images from COCO train2017) by Ultralytics
+# Example usage: yolo train data=coco8.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── coco8 ← downloads here (1 MB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco8 # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+test: # test images (optional)
+
+# Classes
+names:
+ 0: person
+ 1: bicycle
+ 2: car
+ 3: motorcycle
+ 4: airplane
+ 5: bus
+ 6: train
+ 7: truck
+ 8: boat
+ 9: traffic light
+ 10: fire hydrant
+ 11: stop sign
+ 12: parking meter
+ 13: bench
+ 14: bird
+ 15: cat
+ 16: dog
+ 17: horse
+ 18: sheep
+ 19: cow
+ 20: elephant
+ 21: bear
+ 22: zebra
+ 23: giraffe
+ 24: backpack
+ 25: umbrella
+ 26: handbag
+ 27: tie
+ 28: suitcase
+ 29: frisbee
+ 30: skis
+ 31: snowboard
+ 32: sports ball
+ 33: kite
+ 34: baseball bat
+ 35: baseball glove
+ 36: skateboard
+ 37: surfboard
+ 38: tennis racket
+ 39: bottle
+ 40: wine glass
+ 41: cup
+ 42: fork
+ 43: knife
+ 44: spoon
+ 45: bowl
+ 46: banana
+ 47: apple
+ 48: sandwich
+ 49: orange
+ 50: broccoli
+ 51: carrot
+ 52: hot dog
+ 53: pizza
+ 54: donut
+ 55: cake
+ 56: chair
+ 57: couch
+ 58: potted plant
+ 59: bed
+ 60: dining table
+ 61: toilet
+ 62: tv
+ 63: laptop
+ 64: mouse
+ 65: remote
+ 66: keyboard
+ 67: cell phone
+ 68: microwave
+ 69: oven
+ 70: toaster
+ 71: sink
+ 72: refrigerator
+ 73: book
+ 74: clock
+ 75: vase
+ 76: scissors
+ 77: teddy bear
+ 78: hair drier
+ 79: toothbrush
+
+
+# Download script/URL (optional)
+download: https://ultralytics.com/assets/coco8.zip
diff --git a/ultralytics/ultralytics/cfg/datasets/open-images-v7.yaml b/ultralytics/ultralytics/cfg/datasets/open-images-v7.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..bb1e3ff8158bb71bb1dafa96220d3e3b591d0f2c
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/open-images-v7.yaml
@@ -0,0 +1,661 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Open Images v7 dataset https://storage.googleapis.com/openimages/web/index.html by Google
+# Example usage: yolo train data=open-images-v7.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── open-images-v7 ← downloads here (561 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/open-images-v7 # dataset root dir
+train: images/train # train images (relative to 'path') 1743042 images
+val: images/val # val images (relative to 'path') 41620 images
+test: # test images (optional)
+
+# Classes
+names:
+ 0: Accordion
+ 1: Adhesive tape
+ 2: Aircraft
+ 3: Airplane
+ 4: Alarm clock
+ 5: Alpaca
+ 6: Ambulance
+ 7: Animal
+ 8: Ant
+ 9: Antelope
+ 10: Apple
+ 11: Armadillo
+ 12: Artichoke
+ 13: Auto part
+ 14: Axe
+ 15: Backpack
+ 16: Bagel
+ 17: Baked goods
+ 18: Balance beam
+ 19: Ball
+ 20: Balloon
+ 21: Banana
+ 22: Band-aid
+ 23: Banjo
+ 24: Barge
+ 25: Barrel
+ 26: Baseball bat
+ 27: Baseball glove
+ 28: Bat (Animal)
+ 29: Bathroom accessory
+ 30: Bathroom cabinet
+ 31: Bathtub
+ 32: Beaker
+ 33: Bear
+ 34: Bed
+ 35: Bee
+ 36: Beehive
+ 37: Beer
+ 38: Beetle
+ 39: Bell pepper
+ 40: Belt
+ 41: Bench
+ 42: Bicycle
+ 43: Bicycle helmet
+ 44: Bicycle wheel
+ 45: Bidet
+ 46: Billboard
+ 47: Billiard table
+ 48: Binoculars
+ 49: Bird
+ 50: Blender
+ 51: Blue jay
+ 52: Boat
+ 53: Bomb
+ 54: Book
+ 55: Bookcase
+ 56: Boot
+ 57: Bottle
+ 58: Bottle opener
+ 59: Bow and arrow
+ 60: Bowl
+ 61: Bowling equipment
+ 62: Box
+ 63: Boy
+ 64: Brassiere
+ 65: Bread
+ 66: Briefcase
+ 67: Broccoli
+ 68: Bronze sculpture
+ 69: Brown bear
+ 70: Building
+ 71: Bull
+ 72: Burrito
+ 73: Bus
+ 74: Bust
+ 75: Butterfly
+ 76: Cabbage
+ 77: Cabinetry
+ 78: Cake
+ 79: Cake stand
+ 80: Calculator
+ 81: Camel
+ 82: Camera
+ 83: Can opener
+ 84: Canary
+ 85: Candle
+ 86: Candy
+ 87: Cannon
+ 88: Canoe
+ 89: Cantaloupe
+ 90: Car
+ 91: Carnivore
+ 92: Carrot
+ 93: Cart
+ 94: Cassette deck
+ 95: Castle
+ 96: Cat
+ 97: Cat furniture
+ 98: Caterpillar
+ 99: Cattle
+ 100: Ceiling fan
+ 101: Cello
+ 102: Centipede
+ 103: Chainsaw
+ 104: Chair
+ 105: Cheese
+ 106: Cheetah
+ 107: Chest of drawers
+ 108: Chicken
+ 109: Chime
+ 110: Chisel
+ 111: Chopsticks
+ 112: Christmas tree
+ 113: Clock
+ 114: Closet
+ 115: Clothing
+ 116: Coat
+ 117: Cocktail
+ 118: Cocktail shaker
+ 119: Coconut
+ 120: Coffee
+ 121: Coffee cup
+ 122: Coffee table
+ 123: Coffeemaker
+ 124: Coin
+ 125: Common fig
+ 126: Common sunflower
+ 127: Computer keyboard
+ 128: Computer monitor
+ 129: Computer mouse
+ 130: Container
+ 131: Convenience store
+ 132: Cookie
+ 133: Cooking spray
+ 134: Corded phone
+ 135: Cosmetics
+ 136: Couch
+ 137: Countertop
+ 138: Cowboy hat
+ 139: Crab
+ 140: Cream
+ 141: Cricket ball
+ 142: Crocodile
+ 143: Croissant
+ 144: Crown
+ 145: Crutch
+ 146: Cucumber
+ 147: Cupboard
+ 148: Curtain
+ 149: Cutting board
+ 150: Dagger
+ 151: Dairy Product
+ 152: Deer
+ 153: Desk
+ 154: Dessert
+ 155: Diaper
+ 156: Dice
+ 157: Digital clock
+ 158: Dinosaur
+ 159: Dishwasher
+ 160: Dog
+ 161: Dog bed
+ 162: Doll
+ 163: Dolphin
+ 164: Door
+ 165: Door handle
+ 166: Doughnut
+ 167: Dragonfly
+ 168: Drawer
+ 169: Dress
+ 170: Drill (Tool)
+ 171: Drink
+ 172: Drinking straw
+ 173: Drum
+ 174: Duck
+ 175: Dumbbell
+ 176: Eagle
+ 177: Earrings
+ 178: Egg (Food)
+ 179: Elephant
+ 180: Envelope
+ 181: Eraser
+ 182: Face powder
+ 183: Facial tissue holder
+ 184: Falcon
+ 185: Fashion accessory
+ 186: Fast food
+ 187: Fax
+ 188: Fedora
+ 189: Filing cabinet
+ 190: Fire hydrant
+ 191: Fireplace
+ 192: Fish
+ 193: Flag
+ 194: Flashlight
+ 195: Flower
+ 196: Flowerpot
+ 197: Flute
+ 198: Flying disc
+ 199: Food
+ 200: Food processor
+ 201: Football
+ 202: Football helmet
+ 203: Footwear
+ 204: Fork
+ 205: Fountain
+ 206: Fox
+ 207: French fries
+ 208: French horn
+ 209: Frog
+ 210: Fruit
+ 211: Frying pan
+ 212: Furniture
+ 213: Garden Asparagus
+ 214: Gas stove
+ 215: Giraffe
+ 216: Girl
+ 217: Glasses
+ 218: Glove
+ 219: Goat
+ 220: Goggles
+ 221: Goldfish
+ 222: Golf ball
+ 223: Golf cart
+ 224: Gondola
+ 225: Goose
+ 226: Grape
+ 227: Grapefruit
+ 228: Grinder
+ 229: Guacamole
+ 230: Guitar
+ 231: Hair dryer
+ 232: Hair spray
+ 233: Hamburger
+ 234: Hammer
+ 235: Hamster
+ 236: Hand dryer
+ 237: Handbag
+ 238: Handgun
+ 239: Harbor seal
+ 240: Harmonica
+ 241: Harp
+ 242: Harpsichord
+ 243: Hat
+ 244: Headphones
+ 245: Heater
+ 246: Hedgehog
+ 247: Helicopter
+ 248: Helmet
+ 249: High heels
+ 250: Hiking equipment
+ 251: Hippopotamus
+ 252: Home appliance
+ 253: Honeycomb
+ 254: Horizontal bar
+ 255: Horse
+ 256: Hot dog
+ 257: House
+ 258: Houseplant
+ 259: Human arm
+ 260: Human beard
+ 261: Human body
+ 262: Human ear
+ 263: Human eye
+ 264: Human face
+ 265: Human foot
+ 266: Human hair
+ 267: Human hand
+ 268: Human head
+ 269: Human leg
+ 270: Human mouth
+ 271: Human nose
+ 272: Humidifier
+ 273: Ice cream
+ 274: Indoor rower
+ 275: Infant bed
+ 276: Insect
+ 277: Invertebrate
+ 278: Ipod
+ 279: Isopod
+ 280: Jacket
+ 281: Jacuzzi
+ 282: Jaguar (Animal)
+ 283: Jeans
+ 284: Jellyfish
+ 285: Jet ski
+ 286: Jug
+ 287: Juice
+ 288: Kangaroo
+ 289: Kettle
+ 290: Kitchen & dining room table
+ 291: Kitchen appliance
+ 292: Kitchen knife
+ 293: Kitchen utensil
+ 294: Kitchenware
+ 295: Kite
+ 296: Knife
+ 297: Koala
+ 298: Ladder
+ 299: Ladle
+ 300: Ladybug
+ 301: Lamp
+ 302: Land vehicle
+ 303: Lantern
+ 304: Laptop
+ 305: Lavender (Plant)
+ 306: Lemon
+ 307: Leopard
+ 308: Light bulb
+ 309: Light switch
+ 310: Lighthouse
+ 311: Lily
+ 312: Limousine
+ 313: Lion
+ 314: Lipstick
+ 315: Lizard
+ 316: Lobster
+ 317: Loveseat
+ 318: Luggage and bags
+ 319: Lynx
+ 320: Magpie
+ 321: Mammal
+ 322: Man
+ 323: Mango
+ 324: Maple
+ 325: Maracas
+ 326: Marine invertebrates
+ 327: Marine mammal
+ 328: Measuring cup
+ 329: Mechanical fan
+ 330: Medical equipment
+ 331: Microphone
+ 332: Microwave oven
+ 333: Milk
+ 334: Miniskirt
+ 335: Mirror
+ 336: Missile
+ 337: Mixer
+ 338: Mixing bowl
+ 339: Mobile phone
+ 340: Monkey
+ 341: Moths and butterflies
+ 342: Motorcycle
+ 343: Mouse
+ 344: Muffin
+ 345: Mug
+ 346: Mule
+ 347: Mushroom
+ 348: Musical instrument
+ 349: Musical keyboard
+ 350: Nail (Construction)
+ 351: Necklace
+ 352: Nightstand
+ 353: Oboe
+ 354: Office building
+ 355: Office supplies
+ 356: Orange
+ 357: Organ (Musical Instrument)
+ 358: Ostrich
+ 359: Otter
+ 360: Oven
+ 361: Owl
+ 362: Oyster
+ 363: Paddle
+ 364: Palm tree
+ 365: Pancake
+ 366: Panda
+ 367: Paper cutter
+ 368: Paper towel
+ 369: Parachute
+ 370: Parking meter
+ 371: Parrot
+ 372: Pasta
+ 373: Pastry
+ 374: Peach
+ 375: Pear
+ 376: Pen
+ 377: Pencil case
+ 378: Pencil sharpener
+ 379: Penguin
+ 380: Perfume
+ 381: Person
+ 382: Personal care
+ 383: Personal flotation device
+ 384: Piano
+ 385: Picnic basket
+ 386: Picture frame
+ 387: Pig
+ 388: Pillow
+ 389: Pineapple
+ 390: Pitcher (Container)
+ 391: Pizza
+ 392: Pizza cutter
+ 393: Plant
+ 394: Plastic bag
+ 395: Plate
+ 396: Platter
+ 397: Plumbing fixture
+ 398: Polar bear
+ 399: Pomegranate
+ 400: Popcorn
+ 401: Porch
+ 402: Porcupine
+ 403: Poster
+ 404: Potato
+ 405: Power plugs and sockets
+ 406: Pressure cooker
+ 407: Pretzel
+ 408: Printer
+ 409: Pumpkin
+ 410: Punching bag
+ 411: Rabbit
+ 412: Raccoon
+ 413: Racket
+ 414: Radish
+ 415: Ratchet (Device)
+ 416: Raven
+ 417: Rays and skates
+ 418: Red panda
+ 419: Refrigerator
+ 420: Remote control
+ 421: Reptile
+ 422: Rhinoceros
+ 423: Rifle
+ 424: Ring binder
+ 425: Rocket
+ 426: Roller skates
+ 427: Rose
+ 428: Rugby ball
+ 429: Ruler
+ 430: Salad
+ 431: Salt and pepper shakers
+ 432: Sandal
+ 433: Sandwich
+ 434: Saucer
+ 435: Saxophone
+ 436: Scale
+ 437: Scarf
+ 438: Scissors
+ 439: Scoreboard
+ 440: Scorpion
+ 441: Screwdriver
+ 442: Sculpture
+ 443: Sea lion
+ 444: Sea turtle
+ 445: Seafood
+ 446: Seahorse
+ 447: Seat belt
+ 448: Segway
+ 449: Serving tray
+ 450: Sewing machine
+ 451: Shark
+ 452: Sheep
+ 453: Shelf
+ 454: Shellfish
+ 455: Shirt
+ 456: Shorts
+ 457: Shotgun
+ 458: Shower
+ 459: Shrimp
+ 460: Sink
+ 461: Skateboard
+ 462: Ski
+ 463: Skirt
+ 464: Skull
+ 465: Skunk
+ 466: Skyscraper
+ 467: Slow cooker
+ 468: Snack
+ 469: Snail
+ 470: Snake
+ 471: Snowboard
+ 472: Snowman
+ 473: Snowmobile
+ 474: Snowplow
+ 475: Soap dispenser
+ 476: Sock
+ 477: Sofa bed
+ 478: Sombrero
+ 479: Sparrow
+ 480: Spatula
+ 481: Spice rack
+ 482: Spider
+ 483: Spoon
+ 484: Sports equipment
+ 485: Sports uniform
+ 486: Squash (Plant)
+ 487: Squid
+ 488: Squirrel
+ 489: Stairs
+ 490: Stapler
+ 491: Starfish
+ 492: Stationary bicycle
+ 493: Stethoscope
+ 494: Stool
+ 495: Stop sign
+ 496: Strawberry
+ 497: Street light
+ 498: Stretcher
+ 499: Studio couch
+ 500: Submarine
+ 501: Submarine sandwich
+ 502: Suit
+ 503: Suitcase
+ 504: Sun hat
+ 505: Sunglasses
+ 506: Surfboard
+ 507: Sushi
+ 508: Swan
+ 509: Swim cap
+ 510: Swimming pool
+ 511: Swimwear
+ 512: Sword
+ 513: Syringe
+ 514: Table
+ 515: Table tennis racket
+ 516: Tablet computer
+ 517: Tableware
+ 518: Taco
+ 519: Tank
+ 520: Tap
+ 521: Tart
+ 522: Taxi
+ 523: Tea
+ 524: Teapot
+ 525: Teddy bear
+ 526: Telephone
+ 527: Television
+ 528: Tennis ball
+ 529: Tennis racket
+ 530: Tent
+ 531: Tiara
+ 532: Tick
+ 533: Tie
+ 534: Tiger
+ 535: Tin can
+ 536: Tire
+ 537: Toaster
+ 538: Toilet
+ 539: Toilet paper
+ 540: Tomato
+ 541: Tool
+ 542: Toothbrush
+ 543: Torch
+ 544: Tortoise
+ 545: Towel
+ 546: Tower
+ 547: Toy
+ 548: Traffic light
+ 549: Traffic sign
+ 550: Train
+ 551: Training bench
+ 552: Treadmill
+ 553: Tree
+ 554: Tree house
+ 555: Tripod
+ 556: Trombone
+ 557: Trousers
+ 558: Truck
+ 559: Trumpet
+ 560: Turkey
+ 561: Turtle
+ 562: Umbrella
+ 563: Unicycle
+ 564: Van
+ 565: Vase
+ 566: Vegetable
+ 567: Vehicle
+ 568: Vehicle registration plate
+ 569: Violin
+ 570: Volleyball (Ball)
+ 571: Waffle
+ 572: Waffle iron
+ 573: Wall clock
+ 574: Wardrobe
+ 575: Washing machine
+ 576: Waste container
+ 577: Watch
+ 578: Watercraft
+ 579: Watermelon
+ 580: Weapon
+ 581: Whale
+ 582: Wheel
+ 583: Wheelchair
+ 584: Whisk
+ 585: Whiteboard
+ 586: Willow
+ 587: Window
+ 588: Window blind
+ 589: Wine
+ 590: Wine glass
+ 591: Wine rack
+ 592: Winter melon
+ 593: Wok
+ 594: Woman
+ 595: Wood-burning stove
+ 596: Woodpecker
+ 597: Worm
+ 598: Wrench
+ 599: Zebra
+ 600: Zucchini
+
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+ from ultralytics.utils import LOGGER, SETTINGS, Path, is_ubuntu, get_ubuntu_version
+ from ultralytics.utils.checks import check_requirements, check_version
+
+ check_requirements('fiftyone')
+ if is_ubuntu() and check_version(get_ubuntu_version(), '>=22.04'):
+ # Ubuntu>=22.04 patch https://github.com/voxel51/fiftyone/issues/2961#issuecomment-1666519347
+ check_requirements('fiftyone-db-ubuntu2204')
+
+ import fiftyone as fo
+ import fiftyone.zoo as foz
+ import warnings
+
+ name = 'open-images-v7'
+ fraction = 1.0 # fraction of full dataset to use
+ LOGGER.warning('WARNING ⚠️ Open Images V7 dataset requires at least **561 GB of free space. Starting download...')
+ for split in 'train', 'validation': # 1743042 train, 41620 val images
+ train = split == 'train'
+
+ # Load Open Images dataset
+ dataset = foz.load_zoo_dataset(name,
+ split=split,
+ label_types=['detections'],
+ dataset_dir=Path(SETTINGS['datasets_dir']) / 'fiftyone' / name,
+ max_samples=round((1743042 if train else 41620) * fraction))
+
+ # Define classes
+ if train:
+ classes = dataset.default_classes # all classes
+ # classes = dataset.distinct('ground_truth.detections.label') # only observed classes
+
+ # Export to YOLO format
+ with warnings.catch_warnings():
+ warnings.filterwarnings("ignore", category=UserWarning, module="fiftyone.utils.yolo")
+ dataset.export(export_dir=str(Path(SETTINGS['datasets_dir']) / name),
+ dataset_type=fo.types.YOLOv5Dataset,
+ label_field='ground_truth',
+ split='val' if split == 'validation' else split,
+ classes=classes,
+ overwrite=train)
diff --git a/ultralytics/ultralytics/cfg/datasets/tiger-pose.yaml b/ultralytics/ultralytics/cfg/datasets/tiger-pose.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1accef89a95b0e24dfba6396004c280e76ce35b8
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/tiger-pose.yaml
@@ -0,0 +1,24 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Tiger Pose dataset by Ultralytics
+# Example usage: yolo train data=tiger-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── tiger-pose ← downloads here (75.3 MB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/tiger-pose # dataset root dir
+train: train # train images (relative to 'path') 210 images
+val: val # val images (relative to 'path') 53 images
+
+# Keypoints
+kpt_shape: [12, 2] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+# Classes
+names:
+ 0: tiger
+
+# Download script/URL (optional)
+download: https://ultralytics.com/assets/tiger-pose.zip
diff --git a/ultralytics/ultralytics/cfg/datasets/xView.yaml b/ultralytics/ultralytics/cfg/datasets/xView.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..bdc2d9175723235e80e20283fe23aa5177b9ba37
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/datasets/xView.yaml
@@ -0,0 +1,153 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# DIUx xView 2018 Challenge https://challenge.xviewdataset.org by U.S. National Geospatial-Intelligence Agency (NGA)
+# -------- DOWNLOAD DATA MANUALLY and jar xf val_images.zip to 'datasets/xView' before running train command! --------
+# Example usage: yolo train data=xView.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── xView ← downloads here (20.7 GB)
+
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/xView # dataset root dir
+train: images/autosplit_train.txt # train images (relative to 'path') 90% of 847 train images
+val: images/autosplit_val.txt # train images (relative to 'path') 10% of 847 train images
+
+# Classes
+names:
+ 0: Fixed-wing Aircraft
+ 1: Small Aircraft
+ 2: Cargo Plane
+ 3: Helicopter
+ 4: Passenger Vehicle
+ 5: Small Car
+ 6: Bus
+ 7: Pickup Truck
+ 8: Utility Truck
+ 9: Truck
+ 10: Cargo Truck
+ 11: Truck w/Box
+ 12: Truck Tractor
+ 13: Trailer
+ 14: Truck w/Flatbed
+ 15: Truck w/Liquid
+ 16: Crane Truck
+ 17: Railway Vehicle
+ 18: Passenger Car
+ 19: Cargo Car
+ 20: Flat Car
+ 21: Tank car
+ 22: Locomotive
+ 23: Maritime Vessel
+ 24: Motorboat
+ 25: Sailboat
+ 26: Tugboat
+ 27: Barge
+ 28: Fishing Vessel
+ 29: Ferry
+ 30: Yacht
+ 31: Container Ship
+ 32: Oil Tanker
+ 33: Engineering Vehicle
+ 34: Tower crane
+ 35: Container Crane
+ 36: Reach Stacker
+ 37: Straddle Carrier
+ 38: Mobile Crane
+ 39: Dump Truck
+ 40: Haul Truck
+ 41: Scraper/Tractor
+ 42: Front loader/Bulldozer
+ 43: Excavator
+ 44: Cement Mixer
+ 45: Ground Grader
+ 46: Hut/Tent
+ 47: Shed
+ 48: Building
+ 49: Aircraft Hangar
+ 50: Damaged Building
+ 51: Facility
+ 52: Construction Site
+ 53: Vehicle Lot
+ 54: Helipad
+ 55: Storage Tank
+ 56: Shipping container lot
+ 57: Shipping Container
+ 58: Pylon
+ 59: Tower
+
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+ import json
+ import os
+ from pathlib import Path
+
+ import numpy as np
+ from PIL import Image
+ from tqdm import tqdm
+
+ from ultralytics.data.utils import autosplit
+ from ultralytics.utils.ops import xyxy2xywhn
+
+
+ def convert_labels(fname=Path('xView/xView_train.geojson')):
+ # Convert xView geoJSON labels to YOLO format
+ path = fname.parent
+ with open(fname) as f:
+ print(f'Loading {fname}...')
+ data = json.load(f)
+
+ # Make dirs
+ labels = Path(path / 'labels' / 'train')
+ os.system(f'rm -rf {labels}')
+ labels.mkdir(parents=True, exist_ok=True)
+
+ # xView classes 11-94 to 0-59
+ xview_class2index = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, -1, 9, 10, 11,
+ 12, 13, 14, 15, -1, -1, 16, 17, 18, 19, 20, 21, 22, -1, 23, 24, 25, -1, 26, 27, -1, 28, -1,
+ 29, 30, 31, 32, 33, 34, 35, 36, 37, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, 46,
+ 47, 48, 49, -1, 50, 51, -1, 52, -1, -1, -1, 53, 54, -1, 55, -1, -1, 56, -1, 57, -1, 58, 59]
+
+ shapes = {}
+ for feature in tqdm(data['features'], desc=f'Converting {fname}'):
+ p = feature['properties']
+ if p['bounds_imcoords']:
+ id = p['image_id']
+ file = path / 'train_images' / id
+ if file.exists(): # 1395.tif missing
+ try:
+ box = np.array([int(num) for num in p['bounds_imcoords'].split(",")])
+ assert box.shape[0] == 4, f'incorrect box shape {box.shape[0]}'
+ cls = p['type_id']
+ cls = xview_class2index[int(cls)] # xView class to 0-60
+ assert 59 >= cls >= 0, f'incorrect class index {cls}'
+
+ # Write YOLO label
+ if id not in shapes:
+ shapes[id] = Image.open(file).size
+ box = xyxy2xywhn(box[None].astype(np.float), w=shapes[id][0], h=shapes[id][1], clip=True)
+ with open((labels / id).with_suffix('.txt'), 'a') as f:
+ f.write(f"{cls} {' '.join(f'{x:.6f}' for x in box[0])}\n") # write label.txt
+ except Exception as e:
+ print(f'WARNING: skipping one label for {file}: {e}')
+
+
+ # Download manually from https://challenge.xviewdataset.org
+ dir = Path(yaml['path']) # dataset root dir
+ # urls = ['https://d307kc0mrhucc3.cloudfront.net/train_labels.zip', # train labels
+ # 'https://d307kc0mrhucc3.cloudfront.net/train_images.zip', # 15G, 847 train images
+ # 'https://d307kc0mrhucc3.cloudfront.net/val_images.zip'] # 5G, 282 val images (no labels)
+ # download(urls, dir=dir)
+
+ # Convert labels
+ convert_labels(dir / 'xView_train.geojson')
+
+ # Move images
+ images = Path(dir / 'images')
+ images.mkdir(parents=True, exist_ok=True)
+ Path(dir / 'train_images').rename(dir / 'images' / 'train')
+ Path(dir / 'val_images').rename(dir / 'images' / 'val')
+
+ # Split
+ autosplit(dir / 'images' / 'train')
diff --git a/ultralytics/ultralytics/cfg/default.yaml b/ultralytics/ultralytics/cfg/default.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..12e37083ef4c49d450a95e37f7705e0a496ec940
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/default.yaml
@@ -0,0 +1,116 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Default training settings and hyperparameters for medium-augmentation COCO training
+
+task: detect # (str) YOLO task, i.e. detect, segment, classify, pose
+mode: train # (str) YOLO mode, i.e. train, val, predict, export, track, benchmark
+
+# Train settings -------------------------------------------------------------------------------------------------------
+model: # (str, optional) path to model file, i.e. yolov8n.pt, yolov8n.yaml
+data: # (str, optional) path to data file, i.e. coco128.yaml
+epochs: 100 # (int) number of epochs to train for
+patience: 50 # (int) epochs to wait for no observable improvement for early stopping of training
+batch: 16 # (int) number of images per batch (-1 for AutoBatch)
+imgsz: 640 # (int | list) input images size as int for train and val modes, or list[w,h] for predict and export modes
+save: True # (bool) save train checkpoints and predict results
+save_period: -1 # (int) Save checkpoint every x epochs (disabled if < 1)
+cache: False # (bool) True/ram, disk or False. Use cache for data loading
+device: # (int | str | list, optional) device to run on, i.e. cuda device=0 or device=0,1,2,3 or device=cpu
+workers: 8 # (int) number of worker threads for data loading (per RANK if DDP)
+project: # (str, optional) project name
+name: # (str, optional) experiment name, results saved to 'project/name' directory
+exist_ok: False # (bool) whether to overwrite existing experiment
+pretrained: True # (bool | str) whether to use a pretrained model (bool) or a model to load weights from (str)
+optimizer: auto # (str) optimizer to use, choices=[SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, auto]
+verbose: True # (bool) whether to print verbose output
+seed: 0 # (int) random seed for reproducibility
+deterministic: True # (bool) whether to enable deterministic mode
+single_cls: False # (bool) train multi-class data as single-class
+rect: False # (bool) rectangular training if mode='train' or rectangular validation if mode='val'
+cos_lr: False # (bool) use cosine learning rate scheduler
+close_mosaic: 10 # (int) disable mosaic augmentation for final epochs (0 to disable)
+resume: False # (bool) resume training from last checkpoint
+amp: True # (bool) Automatic Mixed Precision (AMP) training, choices=[True, False], True runs AMP check
+fraction: 1.0 # (float) dataset fraction to train on (default is 1.0, all images in train set)
+profile: False # (bool) profile ONNX and TensorRT speeds during training for loggers
+freeze: None # (int | list, optional) freeze first n layers, or freeze list of layer indices during training
+# Segmentation
+overlap_mask: True # (bool) masks should overlap during training (segment train only)
+mask_ratio: 4 # (int) mask downsample ratio (segment train only)
+# Classification
+dropout: 0.0 # (float) use dropout regularization (classify train only)
+
+# Val/Test settings ----------------------------------------------------------------------------------------------------
+val: True # (bool) validate/test during training
+split: val # (str) dataset split to use for validation, i.e. 'val', 'test' or 'train'
+save_json: False # (bool) save results to JSON file
+save_hybrid: False # (bool) save hybrid version of labels (labels + additional predictions)
+conf: # (float, optional) object confidence threshold for detection (default 0.25 predict, 0.001 val)
+iou: 0.7 # (float) intersection over union (IoU) threshold for NMS
+max_det: 300 # (int) maximum number of detections per image
+half: False # (bool) use half precision (FP16)
+dnn: False # (bool) use OpenCV DNN for ONNX inference
+plots: True # (bool) save plots during train/val
+
+# Prediction settings --------------------------------------------------------------------------------------------------
+source: # (str, optional) source directory for images or videos
+show: False # (bool) show results if possible
+save_txt: False # (bool) save results as .txt file
+save_conf: False # (bool) save results with confidence scores
+save_crop: False # (bool) save cropped images with results
+show_labels: True # (bool) show object labels in plots
+show_conf: True # (bool) show object confidence scores in plots
+vid_stride: 1 # (int) video frame-rate stride
+stream_buffer: False # (bool) buffer all streaming frames (True) or return the most recent frame (False)
+line_width: # (int, optional) line width of the bounding boxes, auto if missing
+visualize: False # (bool) visualize model features
+augment: False # (bool) apply image augmentation to prediction sources
+agnostic_nms: False # (bool) class-agnostic NMS
+classes: # (int | list[int], optional) filter results by class, i.e. classes=0, or classes=[0,2,3]
+retina_masks: False # (bool) use high-resolution segmentation masks
+boxes: True # (bool) Show boxes in segmentation predictions
+
+# Export settings ------------------------------------------------------------------------------------------------------
+format: torchscript # (str) format to export to, choices at https://docs.ultralytics.com/modes/export/#export-formats
+keras: False # (bool) use Kera=s
+optimize: False # (bool) TorchScript: optimize for mobile
+int8: False # (bool) CoreML/TF INT8 quantization
+dynamic: False # (bool) ONNX/TF/TensorRT: dynamic axes
+simplify: False # (bool) ONNX: simplify model
+opset: # (int, optional) ONNX: opset version
+workspace: 4 # (int) TensorRT: workspace size (GB)
+nms: False # (bool) CoreML: add NMS
+
+# Hyperparameters ------------------------------------------------------------------------------------------------------
+lr0: 0.01 # (float) initial learning rate (i.e. SGD=1E-2, Adam=1E-3)
+lrf: 0.01 # (float) final learning rate (lr0 * lrf)
+momentum: 0.937 # (float) SGD momentum/Adam beta1
+weight_decay: 0.0005 # (float) optimizer weight decay 5e-4
+warmup_epochs: 3.0 # (float) warmup epochs (fractions ok)
+warmup_momentum: 0.8 # (float) warmup initial momentum
+warmup_bias_lr: 0.1 # (float) warmup initial bias lr
+box: 7.5 # (float) box loss gain
+cls: 0.5 # (float) cls loss gain (scale with pixels)
+dfl: 1.5 # (float) dfl loss gain
+pose: 12.0 # (float) pose loss gain
+kobj: 1.0 # (float) keypoint obj loss gain
+label_smoothing: 0.0 # (float) label smoothing (fraction)
+nbs: 64 # (int) nominal batch size
+hsv_h: 0.015 # (float) image HSV-Hue augmentation (fraction)
+hsv_s: 0.7 # (float) image HSV-Saturation augmentation (fraction)
+hsv_v: 0.4 # (float) image HSV-Value augmentation (fraction)
+degrees: 0.0 # (float) image rotation (+/- deg)
+translate: 0.1 # (float) image translation (+/- fraction)
+scale: 0.5 # (float) image scale (+/- gain)
+shear: 0.0 # (float) image shear (+/- deg)
+perspective: 0.0 # (float) image perspective (+/- fraction), range 0-0.001
+flipud: 0.0 # (float) image flip up-down (probability)
+fliplr: 0.5 # (float) image flip left-right (probability)
+mosaic: 1.0 # (float) image mosaic (probability)
+mixup: 0.0 # (float) image mixup (probability)
+copy_paste: 0.0 # (float) segment copy-paste (probability)
+
+# Custom config.yaml ---------------------------------------------------------------------------------------------------
+cfg: # (str, optional) for overriding defaults.yaml
+
+# Tracker settings ------------------------------------------------------------------------------------------------------
+tracker: botsort.yaml # (str) tracker type, choices=[botsort.yaml, bytetrack.yaml]
diff --git a/ultralytics/ultralytics/cfg/models/README.md b/ultralytics/ultralytics/cfg/models/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..4749441d6391dc6f2978484e4aabf84a0727561e
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/README.md
@@ -0,0 +1,41 @@
+## Models
+
+Welcome to the Ultralytics Models directory! Here you will find a wide variety of pre-configured model configuration files (`*.yaml`s) that can be used to create custom YOLO models. The models in this directory have been expertly crafted and fine-tuned by the Ultralytics team to provide the best performance for a wide range of object detection and image segmentation tasks.
+
+These model configurations cover a wide range of scenarios, from simple object detection to more complex tasks like instance segmentation and object tracking. They are also designed to run efficiently on a variety of hardware platforms, from CPUs to GPUs. Whether you are a seasoned machine learning practitioner or just getting started with YOLO, this directory provides a great starting point for your custom model development needs.
+
+To get started, simply browse through the models in this directory and find one that best suits your needs. Once you've selected a model, you can use the provided `*.yaml` file to train and deploy your custom YOLO model with ease. See full details at the Ultralytics [Docs](https://docs.ultralytics.com/models), and if you need help or have any questions, feel free to reach out to the Ultralytics team for support. So, don't wait, start creating your custom YOLO model now!
+
+### Usage
+
+Model `*.yaml` files may be used directly in the Command Line Interface (CLI) with a `yolo` command:
+
+```bash
+yolo task=detect mode=train model=yolov8n.yaml data=coco128.yaml epochs=100
+```
+
+They may also be used directly in a Python environment, and accepts the same
+[arguments](https://docs.ultralytics.com/usage/cfg/) as in the CLI example above:
+
+```python
+from ultralytics import YOLO
+
+model = YOLO("model.yaml") # build a YOLOv8n model from scratch
+# YOLO("model.pt") use pre-trained model if available
+model.info() # display model information
+model.train(data="coco128.yaml", epochs=100) # train the model
+```
+
+## Pre-trained Model Architectures
+
+Ultralytics supports many model architectures. Visit https://docs.ultralytics.com/models to view detailed information and usage. Any of these models can be used by loading their configs or pretrained checkpoints if available.
+
+## Contribute New Models
+
+Have you trained a new YOLO variant or achieved state-of-the-art performance with specific tuning? We'd love to showcase your work in our Models section! Contributions from the community in the form of new models, architectures, or optimizations are highly valued and can significantly enrich our repository.
+
+By contributing to this section, you're helping us offer a wider array of model choices and configurations to the community. It's a fantastic way to share your knowledge and expertise while making the Ultralytics YOLO ecosystem even more versatile.
+
+To get started, please consult our [Contributing Guide](https://docs.ultralytics.com/help/contributing) for step-by-step instructions on how to submit a Pull Request (PR) 🛠️. Your contributions are eagerly awaited!
+
+Let's join hands to extend the range and capabilities of the Ultralytics YOLO models 🙏!
diff --git a/ultralytics/ultralytics/cfg/models/rt-detr/rtdetr-l.yaml b/ultralytics/ultralytics/cfg/models/rt-detr/rtdetr-l.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..bd20da16f0828a375f1f469c1e698d6351e67aa8
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/rt-detr/rtdetr-l.yaml
@@ -0,0 +1,50 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# RT-DETR-l object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/rtdetr
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
+ # [depth, width, max_channels]
+ l: [1.00, 1.00, 1024]
+
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, HGStem, [32, 48]] # 0-P2/4
+ - [-1, 6, HGBlock, [48, 128, 3]] # stage 1
+
+ - [-1, 1, DWConv, [128, 3, 2, 1, False]] # 2-P3/8
+ - [-1, 6, HGBlock, [96, 512, 3]] # stage 2
+
+ - [-1, 1, DWConv, [512, 3, 2, 1, False]] # 4-P3/16
+ - [-1, 6, HGBlock, [192, 1024, 5, True, False]] # cm, c2, k, light, shortcut
+ - [-1, 6, HGBlock, [192, 1024, 5, True, True]]
+ - [-1, 6, HGBlock, [192, 1024, 5, True, True]] # stage 3
+
+ - [-1, 1, DWConv, [1024, 3, 2, 1, False]] # 8-P4/32
+ - [-1, 6, HGBlock, [384, 2048, 5, True, False]] # stage 4
+
+head:
+ - [-1, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 10 input_proj.2
+ - [-1, 1, AIFI, [1024, 8]]
+ - [-1, 1, Conv, [256, 1, 1]] # 12, Y5, lateral_convs.0
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [7, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 14 input_proj.1
+ - [[-2, -1], 1, Concat, [1]]
+ - [-1, 3, RepC3, [256]] # 16, fpn_blocks.0
+ - [-1, 1, Conv, [256, 1, 1]] # 17, Y4, lateral_convs.1
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [3, 1, Conv, [256, 1, 1, None, 1, 1, False]] # 19 input_proj.0
+ - [[-2, -1], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, RepC3, [256]] # X3 (21), fpn_blocks.1
+
+ - [-1, 1, Conv, [256, 3, 2]] # 22, downsample_convs.0
+ - [[-1, 17], 1, Concat, [1]] # cat Y4
+ - [-1, 3, RepC3, [256]] # F4 (24), pan_blocks.0
+
+ - [-1, 1, Conv, [256, 3, 2]] # 25, downsample_convs.1
+ - [[-1, 12], 1, Concat, [1]] # cat Y5
+ - [-1, 3, RepC3, [256]] # F5 (27), pan_blocks.1
+
+ - [[21, 24, 27], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
diff --git a/ultralytics/ultralytics/cfg/models/rt-detr/rtdetr-x.yaml b/ultralytics/ultralytics/cfg/models/rt-detr/rtdetr-x.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..848cb52b1f7430331ec625f56e496feb31f3f8eb
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/rt-detr/rtdetr-x.yaml
@@ -0,0 +1,54 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# RT-DETR-x object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/rtdetr
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
+ # [depth, width, max_channels]
+ x: [1.00, 1.00, 2048]
+
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, HGStem, [32, 64]] # 0-P2/4
+ - [-1, 6, HGBlock, [64, 128, 3]] # stage 1
+
+ - [-1, 1, DWConv, [128, 3, 2, 1, False]] # 2-P3/8
+ - [-1, 6, HGBlock, [128, 512, 3]]
+ - [-1, 6, HGBlock, [128, 512, 3, False, True]] # 4-stage 2
+
+ - [-1, 1, DWConv, [512, 3, 2, 1, False]] # 5-P3/16
+ - [-1, 6, HGBlock, [256, 1024, 5, True, False]] # cm, c2, k, light, shortcut
+ - [-1, 6, HGBlock, [256, 1024, 5, True, True]]
+ - [-1, 6, HGBlock, [256, 1024, 5, True, True]]
+ - [-1, 6, HGBlock, [256, 1024, 5, True, True]]
+ - [-1, 6, HGBlock, [256, 1024, 5, True, True]] # 10-stage 3
+
+ - [-1, 1, DWConv, [1024, 3, 2, 1, False]] # 11-P4/32
+ - [-1, 6, HGBlock, [512, 2048, 5, True, False]]
+ - [-1, 6, HGBlock, [512, 2048, 5, True, True]] # 13-stage 4
+
+head:
+ - [-1, 1, Conv, [384, 1, 1, None, 1, 1, False]] # 14 input_proj.2
+ - [-1, 1, AIFI, [2048, 8]]
+ - [-1, 1, Conv, [384, 1, 1]] # 16, Y5, lateral_convs.0
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [10, 1, Conv, [384, 1, 1, None, 1, 1, False]] # 18 input_proj.1
+ - [[-2, -1], 1, Concat, [1]]
+ - [-1, 3, RepC3, [384]] # 20, fpn_blocks.0
+ - [-1, 1, Conv, [384, 1, 1]] # 21, Y4, lateral_convs.1
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [4, 1, Conv, [384, 1, 1, None, 1, 1, False]] # 23 input_proj.0
+ - [[-2, -1], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, RepC3, [384]] # X3 (25), fpn_blocks.1
+
+ - [-1, 1, Conv, [384, 3, 2]] # 26, downsample_convs.0
+ - [[-1, 21], 1, Concat, [1]] # cat Y4
+ - [-1, 3, RepC3, [384]] # F4 (28), pan_blocks.0
+
+ - [-1, 1, Conv, [384, 3, 2]] # 29, downsample_convs.1
+ - [[-1, 16], 1, Concat, [1]] # cat Y5
+ - [-1, 3, RepC3, [384]] # F5 (31), pan_blocks.1
+
+ - [[25, 28, 31], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
diff --git a/ultralytics/ultralytics/cfg/models/v3/yolov3-spp.yaml b/ultralytics/ultralytics/cfg/models/v3/yolov3-spp.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..406e019b4c84d9b8de5cfc7e9f9d9d49c5eead76
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v3/yolov3-spp.yaml
@@ -0,0 +1,48 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv3-SPP object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/yolov3
+
+# Parameters
+nc: 80 # number of classes
+depth_multiple: 1.0 # model depth multiple
+width_multiple: 1.0 # layer channel multiple
+
+# darknet53 backbone
+backbone:
+ # [from, number, module, args]
+ [[-1, 1, Conv, [32, 3, 1]], # 0
+ [-1, 1, Conv, [64, 3, 2]], # 1-P1/2
+ [-1, 1, Bottleneck, [64]],
+ [-1, 1, Conv, [128, 3, 2]], # 3-P2/4
+ [-1, 2, Bottleneck, [128]],
+ [-1, 1, Conv, [256, 3, 2]], # 5-P3/8
+ [-1, 8, Bottleneck, [256]],
+ [-1, 1, Conv, [512, 3, 2]], # 7-P4/16
+ [-1, 8, Bottleneck, [512]],
+ [-1, 1, Conv, [1024, 3, 2]], # 9-P5/32
+ [-1, 4, Bottleneck, [1024]], # 10
+ ]
+
+# YOLOv3-SPP head
+head:
+ [[-1, 1, Bottleneck, [1024, False]],
+ [-1, 1, SPP, [512, [5, 9, 13]]],
+ [-1, 1, Conv, [1024, 3, 1]],
+ [-1, 1, Conv, [512, 1, 1]],
+ [-1, 1, Conv, [1024, 3, 1]], # 15 (P5/32-large)
+
+ [-2, 1, Conv, [256, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 8], 1, Concat, [1]], # cat backbone P4
+ [-1, 1, Bottleneck, [512, False]],
+ [-1, 1, Bottleneck, [512, False]],
+ [-1, 1, Conv, [256, 1, 1]],
+ [-1, 1, Conv, [512, 3, 1]], # 22 (P4/16-medium)
+
+ [-2, 1, Conv, [128, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 6], 1, Concat, [1]], # cat backbone P3
+ [-1, 1, Bottleneck, [256, False]],
+ [-1, 2, Bottleneck, [256, False]], # 27 (P3/8-small)
+
+ [[27, 22, 15], 1, Detect, [nc]], # Detect(P3, P4, P5)
+ ]
diff --git a/ultralytics/ultralytics/cfg/models/v3/yolov3-tiny.yaml b/ultralytics/ultralytics/cfg/models/v3/yolov3-tiny.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..69d8e42ce68daee04bd777f22ebf8f4c6d60de9a
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v3/yolov3-tiny.yaml
@@ -0,0 +1,39 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv3-tiny object detection model with P4-P5 outputs. For details see https://docs.ultralytics.com/models/yolov3
+
+# Parameters
+nc: 80 # number of classes
+depth_multiple: 1.0 # model depth multiple
+width_multiple: 1.0 # layer channel multiple
+
+# YOLOv3-tiny backbone
+backbone:
+ # [from, number, module, args]
+ [[-1, 1, Conv, [16, 3, 1]], # 0
+ [-1, 1, nn.MaxPool2d, [2, 2, 0]], # 1-P1/2
+ [-1, 1, Conv, [32, 3, 1]],
+ [-1, 1, nn.MaxPool2d, [2, 2, 0]], # 3-P2/4
+ [-1, 1, Conv, [64, 3, 1]],
+ [-1, 1, nn.MaxPool2d, [2, 2, 0]], # 5-P3/8
+ [-1, 1, Conv, [128, 3, 1]],
+ [-1, 1, nn.MaxPool2d, [2, 2, 0]], # 7-P4/16
+ [-1, 1, Conv, [256, 3, 1]],
+ [-1, 1, nn.MaxPool2d, [2, 2, 0]], # 9-P5/32
+ [-1, 1, Conv, [512, 3, 1]],
+ [-1, 1, nn.ZeroPad2d, [[0, 1, 0, 1]]], # 11
+ [-1, 1, nn.MaxPool2d, [2, 1, 0]], # 12
+ ]
+
+# YOLOv3-tiny head
+head:
+ [[-1, 1, Conv, [1024, 3, 1]],
+ [-1, 1, Conv, [256, 1, 1]],
+ [-1, 1, Conv, [512, 3, 1]], # 15 (P5/32-large)
+
+ [-2, 1, Conv, [128, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 8], 1, Concat, [1]], # cat backbone P4
+ [-1, 1, Conv, [256, 3, 1]], # 19 (P4/16-medium)
+
+ [[19, 15], 1, Detect, [nc]], # Detect(P4, P5)
+ ]
diff --git a/ultralytics/ultralytics/cfg/models/v3/yolov3.yaml b/ultralytics/ultralytics/cfg/models/v3/yolov3.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..7cc0afa173e09af9f09f752b45ad8bd113db612f
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v3/yolov3.yaml
@@ -0,0 +1,48 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv3 object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/yolov3
+
+# Parameters
+nc: 80 # number of classes
+depth_multiple: 1.0 # model depth multiple
+width_multiple: 1.0 # layer channel multiple
+
+# darknet53 backbone
+backbone:
+ # [from, number, module, args]
+ [[-1, 1, Conv, [32, 3, 1]], # 0
+ [-1, 1, Conv, [64, 3, 2]], # 1-P1/2
+ [-1, 1, Bottleneck, [64]],
+ [-1, 1, Conv, [128, 3, 2]], # 3-P2/4
+ [-1, 2, Bottleneck, [128]],
+ [-1, 1, Conv, [256, 3, 2]], # 5-P3/8
+ [-1, 8, Bottleneck, [256]],
+ [-1, 1, Conv, [512, 3, 2]], # 7-P4/16
+ [-1, 8, Bottleneck, [512]],
+ [-1, 1, Conv, [1024, 3, 2]], # 9-P5/32
+ [-1, 4, Bottleneck, [1024]], # 10
+ ]
+
+# YOLOv3 head
+head:
+ [[-1, 1, Bottleneck, [1024, False]],
+ [-1, 1, Conv, [512, 1, 1]],
+ [-1, 1, Conv, [1024, 3, 1]],
+ [-1, 1, Conv, [512, 1, 1]],
+ [-1, 1, Conv, [1024, 3, 1]], # 15 (P5/32-large)
+
+ [-2, 1, Conv, [256, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 8], 1, Concat, [1]], # cat backbone P4
+ [-1, 1, Bottleneck, [512, False]],
+ [-1, 1, Bottleneck, [512, False]],
+ [-1, 1, Conv, [256, 1, 1]],
+ [-1, 1, Conv, [512, 3, 1]], # 22 (P4/16-medium)
+
+ [-2, 1, Conv, [128, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 6], 1, Concat, [1]], # cat backbone P3
+ [-1, 1, Bottleneck, [256, False]],
+ [-1, 2, Bottleneck, [256, False]], # 27 (P3/8-small)
+
+ [[27, 22, 15], 1, Detect, [nc]], # Detect(P3, P4, P5)
+ ]
diff --git a/ultralytics/ultralytics/cfg/models/v5/yolov5-p6.yaml b/ultralytics/ultralytics/cfg/models/v5/yolov5-p6.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d4683771b50057b216aa48c5d8e5722a671d077c
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v5/yolov5-p6.yaml
@@ -0,0 +1,61 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv5 object detection model with P3-P6 outputs. For details see https://docs.ultralytics.com/models/yolov5
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov5n-p6.yaml' will call yolov5-p6.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 1024]
+ l: [1.00, 1.00, 1024]
+ x: [1.33, 1.25, 1024]
+
+# YOLOv5 v6.0 backbone
+backbone:
+ # [from, number, module, args]
+ [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2
+ [-1, 1, Conv, [128, 3, 2]], # 1-P2/4
+ [-1, 3, C3, [128]],
+ [-1, 1, Conv, [256, 3, 2]], # 3-P3/8
+ [-1, 6, C3, [256]],
+ [-1, 1, Conv, [512, 3, 2]], # 5-P4/16
+ [-1, 9, C3, [512]],
+ [-1, 1, Conv, [768, 3, 2]], # 7-P5/32
+ [-1, 3, C3, [768]],
+ [-1, 1, Conv, [1024, 3, 2]], # 9-P6/64
+ [-1, 3, C3, [1024]],
+ [-1, 1, SPPF, [1024, 5]], # 11
+ ]
+
+# YOLOv5 v6.0 head
+head:
+ [[-1, 1, Conv, [768, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 8], 1, Concat, [1]], # cat backbone P5
+ [-1, 3, C3, [768, False]], # 15
+
+ [-1, 1, Conv, [512, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 6], 1, Concat, [1]], # cat backbone P4
+ [-1, 3, C3, [512, False]], # 19
+
+ [-1, 1, Conv, [256, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 4], 1, Concat, [1]], # cat backbone P3
+ [-1, 3, C3, [256, False]], # 23 (P3/8-small)
+
+ [-1, 1, Conv, [256, 3, 2]],
+ [[-1, 20], 1, Concat, [1]], # cat head P4
+ [-1, 3, C3, [512, False]], # 26 (P4/16-medium)
+
+ [-1, 1, Conv, [512, 3, 2]],
+ [[-1, 16], 1, Concat, [1]], # cat head P5
+ [-1, 3, C3, [768, False]], # 29 (P5/32-large)
+
+ [-1, 1, Conv, [768, 3, 2]],
+ [[-1, 12], 1, Concat, [1]], # cat head P6
+ [-1, 3, C3, [1024, False]], # 32 (P6/64-xlarge)
+
+ [[23, 26, 29, 32], 1, Detect, [nc]], # Detect(P3, P4, P5, P6)
+ ]
diff --git a/ultralytics/ultralytics/cfg/models/v5/yolov5.yaml b/ultralytics/ultralytics/cfg/models/v5/yolov5.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4a3fcedf7c8d8e935c637fe80f52f94310841f45
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v5/yolov5.yaml
@@ -0,0 +1,50 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv5 object detection model with P3-P5 outputs. For details see https://docs.ultralytics.com/models/yolov5
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov5n.yaml' will call yolov5.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 1024]
+ l: [1.00, 1.00, 1024]
+ x: [1.33, 1.25, 1024]
+
+# YOLOv5 v6.0 backbone
+backbone:
+ # [from, number, module, args]
+ [[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2
+ [-1, 1, Conv, [128, 3, 2]], # 1-P2/4
+ [-1, 3, C3, [128]],
+ [-1, 1, Conv, [256, 3, 2]], # 3-P3/8
+ [-1, 6, C3, [256]],
+ [-1, 1, Conv, [512, 3, 2]], # 5-P4/16
+ [-1, 9, C3, [512]],
+ [-1, 1, Conv, [1024, 3, 2]], # 7-P5/32
+ [-1, 3, C3, [1024]],
+ [-1, 1, SPPF, [1024, 5]], # 9
+ ]
+
+# YOLOv5 v6.0 head
+head:
+ [[-1, 1, Conv, [512, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 6], 1, Concat, [1]], # cat backbone P4
+ [-1, 3, C3, [512, False]], # 13
+
+ [-1, 1, Conv, [256, 1, 1]],
+ [-1, 1, nn.Upsample, [None, 2, 'nearest']],
+ [[-1, 4], 1, Concat, [1]], # cat backbone P3
+ [-1, 3, C3, [256, False]], # 17 (P3/8-small)
+
+ [-1, 1, Conv, [256, 3, 2]],
+ [[-1, 14], 1, Concat, [1]], # cat head P4
+ [-1, 3, C3, [512, False]], # 20 (P4/16-medium)
+
+ [-1, 1, Conv, [512, 3, 2]],
+ [[-1, 10], 1, Concat, [1]], # cat head P5
+ [-1, 3, C3, [1024, False]], # 23 (P5/32-large)
+
+ [[17, 20, 23], 1, Detect, [nc]], # Detect(P3, P4, P5)
+ ]
diff --git a/ultralytics/ultralytics/cfg/models/v6/yolov6.yaml b/ultralytics/ultralytics/cfg/models/v6/yolov6.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..cb5e32ac3a75d49ddbda9e4cecdc1265ed209401
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v6/yolov6.yaml
@@ -0,0 +1,53 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv6 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/models/yolov6
+
+# Parameters
+nc: 80 # number of classes
+activation: nn.ReLU() # (optional) model default activation function
+scales: # model compound scaling constants, i.e. 'model=yolov6n.yaml' will call yolov8.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 768]
+ l: [1.00, 1.00, 512]
+ x: [1.00, 1.25, 512]
+
+# YOLOv6-3.0s backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 6, Conv, [128, 3, 1]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 12, Conv, [256, 3, 1]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 18, Conv, [512, 3, 1]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 6, Conv, [1024, 3, 1]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+
+# YOLOv6-3.0s head
+head:
+ - [-1, 1, Conv, [256, 1, 1]]
+ - [-1, 1, nn.ConvTranspose2d, [256, 2, 2, 0]]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 1, Conv, [256, 3, 1]]
+ - [-1, 9, Conv, [256, 3, 1]] # 14
+
+ - [-1, 1, Conv, [128, 1, 1]]
+ - [-1, 1, nn.ConvTranspose2d, [128, 2, 2, 0]]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 1, Conv, [128, 3, 1]]
+ - [-1, 9, Conv, [128, 3, 1]] # 19
+
+ - [-1, 1, Conv, [128, 3, 2]]
+ - [[-1, 15], 1, Concat, [1]] # cat head P4
+ - [-1, 1, Conv, [256, 3, 1]]
+ - [-1, 9, Conv, [256, 3, 1]] # 23
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 10], 1, Concat, [1]] # cat head P5
+ - [-1, 1, Conv, [512, 3, 1]]
+ - [-1, 9, Conv, [512, 3, 1]] # 27
+
+ - [[19, 23, 27], 1, Detect, [nc]] # Detect(P3, P4, P5)
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8-cls.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8-cls.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5332f1d64ee32bdf8d5cb995e5ef3a3f6f970413
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8-cls.yaml
@@ -0,0 +1,29 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8-cls image classification model. For Usage examples see https://docs.ultralytics.com/tasks/classify
+
+# Parameters
+nc: 1000 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n-cls.yaml' will call yolov8-cls.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 1024]
+ l: [1.00, 1.00, 1024]
+ x: [1.00, 1.25, 1024]
+
+# YOLOv8.0n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [1024, True]]
+
+# YOLOv8.0n head
+head:
+ - [-1, 1, Classify, [nc]] # Classify
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8-p2.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8-p2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3e286aa96f6f9ba79970c8fead0e83782f70bfca
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8-p2.yaml
@@ -0,0 +1,54 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8 object detection model with P2-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 768]
+ l: [1.00, 1.00, 512]
+ x: [1.00, 1.25, 512]
+
+# YOLOv8.0 backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+
+# YOLOv8.0-p2 head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, C2f, [512]] # 12
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 3, C2f, [256]] # 15 (P3/8-small)
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 2], 1, Concat, [1]] # cat backbone P2
+ - [-1, 3, C2f, [128]] # 18 (P2/4-xsmall)
+
+ - [-1, 1, Conv, [128, 3, 2]]
+ - [[-1, 15], 1, Concat, [1]] # cat head P3
+ - [-1, 3, C2f, [256]] # 21 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 12], 1, Concat, [1]] # cat head P4
+ - [-1, 3, C2f, [512]] # 24 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 9], 1, Concat, [1]] # cat head P5
+ - [-1, 3, C2f, [1024]] # 27 (P5/32-large)
+
+ - [[18, 21, 24, 27], 1, Detect, [nc]] # Detect(P2, P3, P4, P5)
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8-p6.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8-p6.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3635ed97ebc4219188f174be99fa301daeaf49b8
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8-p6.yaml
@@ -0,0 +1,56 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8 object detection model with P3-P6 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n-p6.yaml' will call yolov8-p6.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 768]
+ l: [1.00, 1.00, 512]
+ x: [1.00, 1.25, 512]
+
+# YOLOv8.0x6 backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [768, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [768, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 9-P6/64
+ - [-1, 3, C2f, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 11
+
+# YOLOv8.0x6 head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 8], 1, Concat, [1]] # cat backbone P5
+ - [-1, 3, C2, [768, False]] # 14
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, C2, [512, False]] # 17
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 3, C2, [256, False]] # 20 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 17], 1, Concat, [1]] # cat head P4
+ - [-1, 3, C2, [512, False]] # 23 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 14], 1, Concat, [1]] # cat head P5
+ - [-1, 3, C2, [768, False]] # 26 (P5/32-large)
+
+ - [-1, 1, Conv, [768, 3, 2]]
+ - [[-1, 11], 1, Concat, [1]] # cat head P6
+ - [-1, 3, C2, [1024, False]] # 29 (P6/64-xlarge)
+
+ - [[20, 23, 26, 29], 1, Detect, [nc]] # Detect(P3, P4, P5, P6)
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8-pose-p6.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8-pose-p6.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..abf0cfcf96e70a810185c6c546f10905d734675e
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8-pose-p6.yaml
@@ -0,0 +1,57 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8-pose-p6 keypoints/pose estimation model. For Usage examples see https://docs.ultralytics.com/tasks/pose
+
+# Parameters
+nc: 1 # number of classes
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+scales: # model compound scaling constants, i.e. 'model=yolov8n-p6.yaml' will call yolov8-p6.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 768]
+ l: [1.00, 1.00, 512]
+ x: [1.00, 1.25, 512]
+
+# YOLOv8.0x6 backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [768, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [768, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 9-P6/64
+ - [-1, 3, C2f, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 11
+
+# YOLOv8.0x6 head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 8], 1, Concat, [1]] # cat backbone P5
+ - [-1, 3, C2, [768, False]] # 14
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, C2, [512, False]] # 17
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 3, C2, [256, False]] # 20 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 17], 1, Concat, [1]] # cat head P4
+ - [-1, 3, C2, [512, False]] # 23 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 14], 1, Concat, [1]] # cat head P5
+ - [-1, 3, C2, [768, False]] # 26 (P5/32-large)
+
+ - [-1, 1, Conv, [768, 3, 2]]
+ - [[-1, 11], 1, Concat, [1]] # cat head P6
+ - [-1, 3, C2, [1024, False]] # 29 (P6/64-xlarge)
+
+ - [[20, 23, 26, 29], 1, Pose, [nc, kpt_shape]] # Pose(P3, P4, P5, P6)
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8-pose.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8-pose.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9f48e1ead9b223c9a4fcc6836501c6794d431957
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8-pose.yaml
@@ -0,0 +1,47 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8-pose keypoints/pose estimation model. For Usage examples see https://docs.ultralytics.com/tasks/pose
+
+# Parameters
+nc: 1 # number of classes
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+scales: # model compound scaling constants, i.e. 'model=yolov8n-pose.yaml' will call yolov8-pose.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 768]
+ l: [1.00, 1.00, 512]
+ x: [1.00, 1.25, 512]
+
+# YOLOv8.0n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+
+# YOLOv8.0n head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, C2f, [512]] # 12
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 3, C2f, [256]] # 15 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 12], 1, Concat, [1]] # cat head P4
+ - [-1, 3, C2f, [512]] # 18 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 9], 1, Concat, [1]] # cat head P5
+ - [-1, 3, C2f, [1024]] # 21 (P5/32-large)
+
+ - [[15, 18, 21], 1, Pose, [nc, kpt_shape]] # Pose(P3, P4, P5)
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8-rtdetr.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8-rtdetr.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a0581068f441617d3d215fb4c380f374e4da94d0
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8-rtdetr.yaml
@@ -0,0 +1,46 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
+ s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
+ m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
+ l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
+ x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
+
+# YOLOv8.0n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+
+# YOLOv8.0n head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, C2f, [512]] # 12
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 3, C2f, [256]] # 15 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 12], 1, Concat, [1]] # cat head P4
+ - [-1, 3, C2f, [512]] # 18 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 9], 1, Concat, [1]] # cat head P5
+ - [-1, 3, C2f, [1024]] # 21 (P5/32-large)
+
+ - [[15, 18, 21], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8-seg-p6.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8-seg-p6.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5ac093620f1f0bf9facdd8e6e34bc59e495f8bbc
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8-seg-p6.yaml
@@ -0,0 +1,56 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8-seg-p6 instance segmentation model. For Usage examples see https://docs.ultralytics.com/tasks/segment
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n-seg-p6.yaml' will call yolov8-seg-p6.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 768]
+ l: [1.00, 1.00, 512]
+ x: [1.00, 1.25, 512]
+
+# YOLOv8.0x6 backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [768, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [768, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 9-P6/64
+ - [-1, 3, C2f, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 11
+
+# YOLOv8.0x6 head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 8], 1, Concat, [1]] # cat backbone P5
+ - [-1, 3, C2, [768, False]] # 14
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, C2, [512, False]] # 17
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 3, C2, [256, False]] # 20 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 17], 1, Concat, [1]] # cat head P4
+ - [-1, 3, C2, [512, False]] # 23 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 14], 1, Concat, [1]] # cat head P5
+ - [-1, 3, C2, [768, False]] # 26 (P5/32-large)
+
+ - [-1, 1, Conv, [768, 3, 2]]
+ - [[-1, 11], 1, Concat, [1]] # cat head P6
+ - [-1, 3, C2, [1024, False]] # 29 (P6/64-xlarge)
+
+ - [[20, 23, 26, 29], 1, Segment, [nc, 32, 256]] # Pose(P3, P4, P5, P6)
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8-seg.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8-seg.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..fbb08fc451307ea99dc7fe99f6edfe2eb40c4daf
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8-seg.yaml
@@ -0,0 +1,46 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8-seg instance segmentation model. For Usage examples see https://docs.ultralytics.com/tasks/segment
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n-seg.yaml' will call yolov8-seg.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024]
+ s: [0.33, 0.50, 1024]
+ m: [0.67, 0.75, 768]
+ l: [1.00, 1.00, 512]
+ x: [1.00, 1.25, 512]
+
+# YOLOv8.0n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+
+# YOLOv8.0n head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, C2f, [512]] # 12
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 3, C2f, [256]] # 15 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 12], 1, Concat, [1]] # cat head P4
+ - [-1, 3, C2f, [512]] # 18 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 9], 1, Concat, [1]] # cat head P5
+ - [-1, 3, C2f, [1024]] # 21 (P5/32-large)
+
+ - [[15, 18, 21], 1, Segment, [nc, 32, 256]] # Segment(P3, P4, P5)
diff --git a/ultralytics/ultralytics/cfg/models/v8/yolov8.yaml b/ultralytics/ultralytics/cfg/models/v8/yolov8.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2255450f1715a3c244aed909a350f76f38c04170
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/models/v8/yolov8.yaml
@@ -0,0 +1,46 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.33, 0.25, 1024] # YOLOv8n summary: 225 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPs
+ s: [0.33, 0.50, 1024] # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPs
+ m: [0.67, 0.75, 768] # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPs
+ l: [1.00, 1.00, 512] # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
+ x: [1.00, 1.25, 512] # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs
+
+# YOLOv8.0n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 3, C2f, [128, True]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 6, C2f, [256, True]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 6, C2f, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 3, C2f, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+
+# YOLOv8.0n head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 3, C2f, [512]] # 12
+
+ - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 3, C2f, [256]] # 15 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 12], 1, Concat, [1]] # cat head P4
+ - [-1, 3, C2f, [512]] # 18 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 9], 1, Concat, [1]] # cat head P5
+ - [-1, 3, C2f, [1024]] # 21 (P5/32-large)
+
+ - [[15, 18, 21], 1, Detect, [nc]] # Detect(P3, P4, P5)
diff --git a/ultralytics/ultralytics/cfg/trackers/botsort.yaml b/ultralytics/ultralytics/cfg/trackers/botsort.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..cbbf348c25237c3a1fe044f369e7819c87f0dcc6
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/trackers/botsort.yaml
@@ -0,0 +1,18 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Default YOLO tracker settings for BoT-SORT tracker https://github.com/NirAharon/BoT-SORT
+
+tracker_type: botsort # tracker type, ['botsort', 'bytetrack']
+track_high_thresh: 0.5 # threshold for the first association
+track_low_thresh: 0.1 # threshold for the second association
+new_track_thresh: 0.6 # threshold for init new track if the detection does not match any tracks
+track_buffer: 30 # buffer to calculate the time when to remove tracks
+match_thresh: 0.8 # threshold for matching tracks
+# min_box_area: 10 # threshold for min box areas(for tracker evaluation, not used for now)
+# mot20: False # for tracker evaluation(not used for now)
+
+# BoT-SORT settings
+gmc_method: sparseOptFlow # method of global motion compensation
+# ReID model related thresh (not supported yet)
+proximity_thresh: 0.5
+appearance_thresh: 0.25
+with_reid: False
diff --git a/ultralytics/ultralytics/cfg/trackers/bytetrack.yaml b/ultralytics/ultralytics/cfg/trackers/bytetrack.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5060f92622a9873dbdd0596e29172277c1cdbb99
--- /dev/null
+++ b/ultralytics/ultralytics/cfg/trackers/bytetrack.yaml
@@ -0,0 +1,11 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Default YOLO tracker settings for ByteTrack tracker https://github.com/ifzhang/ByteTrack
+
+tracker_type: bytetrack # tracker type, ['botsort', 'bytetrack']
+track_high_thresh: 0.5 # threshold for the first association
+track_low_thresh: 0.1 # threshold for the second association
+new_track_thresh: 0.6 # threshold for init new track if the detection does not match any tracks
+track_buffer: 30 # buffer to calculate the time when to remove tracks
+match_thresh: 0.8 # threshold for matching tracks
+# min_box_area: 10 # threshold for min box areas(for tracker evaluation, not used for now)
+# mot20: False # for tracker evaluation(not used for now)
diff --git a/ultralytics/ultralytics/data/__init__.py b/ultralytics/ultralytics/data/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fa7e8458d432b8942b428c0d8598455d6904edc
--- /dev/null
+++ b/ultralytics/ultralytics/data/__init__.py
@@ -0,0 +1,8 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from .base import BaseDataset
+from .build import build_dataloader, build_yolo_dataset, load_inference_source
+from .dataset import ClassificationDataset, SemanticDataset, YOLODataset
+
+__all__ = ('BaseDataset', 'ClassificationDataset', 'SemanticDataset', 'YOLODataset', 'build_yolo_dataset',
+ 'build_dataloader', 'load_inference_source')
diff --git a/ultralytics/ultralytics/data/annotator.py b/ultralytics/ultralytics/data/annotator.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4e08c768ff0cc47b9290c4b4d64576dc2bed562
--- /dev/null
+++ b/ultralytics/ultralytics/data/annotator.py
@@ -0,0 +1,50 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from pathlib import Path
+
+from ultralytics import SAM, YOLO
+
+
+def auto_annotate(data, det_model='yolov8x.pt', sam_model='sam_b.pt', device='', output_dir=None):
+ """
+ Automatically annotates images using a YOLO object detection model and a SAM segmentation model.
+
+ Args:
+ data (str): Path to a folder containing images to be annotated.
+ det_model (str, optional): Pre-trained YOLO detection model. Defaults to 'yolov8x.pt'.
+ sam_model (str, optional): Pre-trained SAM segmentation model. Defaults to 'sam_b.pt'.
+ device (str, optional): Device to run the models on. Defaults to an empty string (CPU or GPU, if available).
+ output_dir (str | None | optional): Directory to save the annotated results.
+ Defaults to a 'labels' folder in the same directory as 'data'.
+
+ Example:
+ ```python
+ from ultralytics.data.annotator import auto_annotate
+
+ auto_annotate(data='ultralytics/assets', det_model='yolov8n.pt', sam_model='mobile_sam.pt')
+ ```
+ """
+ det_model = YOLO(det_model)
+ sam_model = SAM(sam_model)
+
+ data = Path(data)
+ if not output_dir:
+ output_dir = data.parent / f'{data.stem}_auto_annotate_labels'
+ Path(output_dir).mkdir(exist_ok=True, parents=True)
+
+ det_results = det_model(data, stream=True, device=device)
+
+ for result in det_results:
+ class_ids = result.boxes.cls.int().tolist() # noqa
+ if len(class_ids):
+ boxes = result.boxes.xyxy # Boxes object for bbox outputs
+ sam_results = sam_model(result.orig_img, bboxes=boxes, verbose=False, save=False, device=device)
+ segments = sam_results[0].masks.xyn # noqa
+
+ with open(f'{str(Path(output_dir) / Path(result.path).stem)}.txt', 'w') as f:
+ for i in range(len(segments)):
+ s = segments[i]
+ if len(s) == 0:
+ continue
+ segment = map(str, segments[i].reshape(-1).tolist())
+ f.write(f'{class_ids[i]} ' + ' '.join(segment) + '\n')
diff --git a/ultralytics/ultralytics/data/augment.py b/ultralytics/ultralytics/data/augment.py
new file mode 100644
index 0000000000000000000000000000000000000000..f500aa03c6bcae663f0edcf89d5d3acfa683a42e
--- /dev/null
+++ b/ultralytics/ultralytics/data/augment.py
@@ -0,0 +1,1107 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import math
+import random
+from copy import deepcopy
+
+import cv2
+import numpy as np
+import torch
+import torchvision.transforms as T
+
+from ultralytics.utils import LOGGER, colorstr
+from ultralytics.utils.checks import check_version
+from ultralytics.utils.instance import Instances
+from ultralytics.utils.metrics import bbox_ioa
+from ultralytics.utils.ops import segment2box
+
+from .utils import polygons2masks, polygons2masks_overlap
+
+
+# TODO: we might need a BaseTransform to make all these augments be compatible with both classification and semantic
+class BaseTransform:
+ """
+ Base class for image transformations.
+
+ This is a generic transformation class that can be extended for specific image processing needs.
+ The class is designed to be compatible with both classification and semantic segmentation tasks.
+
+ Methods:
+ __init__: Initializes the BaseTransform object.
+ apply_image: Applies image transformation to labels.
+ apply_instances: Applies transformations to object instances in labels.
+ apply_semantic: Applies semantic segmentation to an image.
+ __call__: Applies all label transformations to an image, instances, and semantic masks.
+ """
+
+ def __init__(self) -> None:
+ """Initializes the BaseTransform object."""
+ pass
+
+ def apply_image(self, labels):
+ """Applies image transformations to labels."""
+ pass
+
+ def apply_instances(self, labels):
+ """Applies transformations to object instances in labels."""
+ pass
+
+ def apply_semantic(self, labels):
+ """Applies semantic segmentation to an image."""
+ pass
+
+ def __call__(self, labels):
+ """Applies all label transformations to an image, instances, and semantic masks."""
+ self.apply_image(labels)
+ self.apply_instances(labels)
+ self.apply_semantic(labels)
+
+
+class Compose:
+ """Class for composing multiple image transformations."""
+
+ def __init__(self, transforms):
+ """Initializes the Compose object with a list of transforms."""
+ self.transforms = transforms
+
+ def __call__(self, data):
+ """Applies a series of transformations to input data."""
+ for t in self.transforms:
+ data = t(data)
+ return data
+
+ def append(self, transform):
+ """Appends a new transform to the existing list of transforms."""
+ self.transforms.append(transform)
+
+ def tolist(self):
+ """Converts the list of transforms to a standard Python list."""
+ return self.transforms
+
+ def __repr__(self):
+ """Returns a string representation of the object."""
+ return f"{self.__class__.__name__}({', '.join([f'{t}' for t in self.transforms])})"
+
+
+class BaseMixTransform:
+ """
+ Class for base mix (MixUp/Mosaic) transformations.
+
+ This implementation is from mmyolo.
+ """
+
+ def __init__(self, dataset, pre_transform=None, p=0.0) -> None:
+ """Initializes the BaseMixTransform object with dataset, pre_transform, and probability."""
+ self.dataset = dataset
+ self.pre_transform = pre_transform
+ self.p = p
+
+ def __call__(self, labels):
+ """Applies pre-processing transforms and mixup/mosaic transforms to labels data."""
+ if random.uniform(0, 1) > self.p:
+ return labels
+
+ # Get index of one or three other images
+ indexes = self.get_indexes()
+ if isinstance(indexes, int):
+ indexes = [indexes]
+
+ # Get images information will be used for Mosaic or MixUp
+ mix_labels = [self.dataset.get_image_and_label(i) for i in indexes]
+
+ if self.pre_transform is not None:
+ for i, data in enumerate(mix_labels):
+ mix_labels[i] = self.pre_transform(data)
+ labels['mix_labels'] = mix_labels
+
+ # Mosaic or MixUp
+ labels = self._mix_transform(labels)
+ labels.pop('mix_labels', None)
+ return labels
+
+ def _mix_transform(self, labels):
+ """Applies MixUp or Mosaic augmentation to the label dictionary."""
+ raise NotImplementedError
+
+ def get_indexes(self):
+ """Gets a list of shuffled indexes for mosaic augmentation."""
+ raise NotImplementedError
+
+
+class Mosaic(BaseMixTransform):
+ """
+ Mosaic augmentation.
+
+ This class performs mosaic augmentation by combining multiple (4 or 9) images into a single mosaic image.
+ The augmentation is applied to a dataset with a given probability.
+
+ Attributes:
+ dataset: The dataset on which the mosaic augmentation is applied.
+ imgsz (int, optional): Image size (height and width) after mosaic pipeline of a single image. Default to 640.
+ p (float, optional): Probability of applying the mosaic augmentation. Must be in the range 0-1. Default to 1.0.
+ n (int, optional): The grid size, either 4 (for 2x2) or 9 (for 3x3).
+ """
+
+ def __init__(self, dataset, imgsz=640, p=1.0, n=4):
+ """Initializes the object with a dataset, image size, probability, and border."""
+ assert 0 <= p <= 1.0, f'The probability should be in range [0, 1], but got {p}.'
+ assert n in (4, 9), 'grid must be equal to 4 or 9.'
+ super().__init__(dataset=dataset, p=p)
+ self.dataset = dataset
+ self.imgsz = imgsz
+ self.border = (-imgsz // 2, -imgsz // 2) # width, height
+ self.n = n
+
+ def get_indexes(self, buffer=True):
+ """Return a list of random indexes from the dataset."""
+ if buffer: # select images from buffer
+ return random.choices(list(self.dataset.buffer), k=self.n - 1)
+ else: # select any images
+ return [random.randint(0, len(self.dataset) - 1) for _ in range(self.n - 1)]
+
+ def _mix_transform(self, labels):
+ """Apply mixup transformation to the input image and labels."""
+ assert labels.get('rect_shape', None) is None, 'rect and mosaic are mutually exclusive.'
+ assert len(labels.get('mix_labels', [])), 'There are no other images for mosaic augment.'
+ return self._mosaic4(labels) if self.n == 4 else self._mosaic9(labels)
+
+ def _mosaic4(self, labels):
+ """Create a 2x2 image mosaic."""
+ mosaic_labels = []
+ s = self.imgsz
+ yc, xc = (int(random.uniform(-x, 2 * s + x)) for x in self.border) # mosaic center x, y
+ for i in range(4):
+ labels_patch = labels if i == 0 else labels['mix_labels'][i - 1]
+ # Load image
+ img = labels_patch['img']
+ h, w = labels_patch.pop('resized_shape')
+
+ # Place img in img4
+ if i == 0: # top left
+ img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles
+ x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc # xmin, ymin, xmax, ymax (large image)
+ x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h # xmin, ymin, xmax, ymax (small image)
+ elif i == 1: # top right
+ x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc
+ x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h
+ elif i == 2: # bottom left
+ x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h)
+ x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h)
+ elif i == 3: # bottom right
+ x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h)
+ x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h)
+
+ img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax]
+ padw = x1a - x1b
+ padh = y1a - y1b
+
+ labels_patch = self._update_labels(labels_patch, padw, padh)
+ mosaic_labels.append(labels_patch)
+ final_labels = self._cat_labels(mosaic_labels)
+ final_labels['img'] = img4
+ return final_labels
+
+ def _mosaic9(self, labels):
+ """Create a 3x3 image mosaic."""
+ mosaic_labels = []
+ s = self.imgsz
+ hp, wp = -1, -1 # height, width previous
+ for i in range(9):
+ labels_patch = labels if i == 0 else labels['mix_labels'][i - 1]
+ # Load image
+ img = labels_patch['img']
+ h, w = labels_patch.pop('resized_shape')
+
+ # Place img in img9
+ if i == 0: # center
+ img9 = np.full((s * 3, s * 3, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles
+ h0, w0 = h, w
+ c = s, s, s + w, s + h # xmin, ymin, xmax, ymax (base) coordinates
+ elif i == 1: # top
+ c = s, s - h, s + w, s
+ elif i == 2: # top right
+ c = s + wp, s - h, s + wp + w, s
+ elif i == 3: # right
+ c = s + w0, s, s + w0 + w, s + h
+ elif i == 4: # bottom right
+ c = s + w0, s + hp, s + w0 + w, s + hp + h
+ elif i == 5: # bottom
+ c = s + w0 - w, s + h0, s + w0, s + h0 + h
+ elif i == 6: # bottom left
+ c = s + w0 - wp - w, s + h0, s + w0 - wp, s + h0 + h
+ elif i == 7: # left
+ c = s - w, s + h0 - h, s, s + h0
+ elif i == 8: # top left
+ c = s - w, s + h0 - hp - h, s, s + h0 - hp
+
+ padw, padh = c[:2]
+ x1, y1, x2, y2 = (max(x, 0) for x in c) # allocate coords
+
+ # Image
+ img9[y1:y2, x1:x2] = img[y1 - padh:, x1 - padw:] # img9[ymin:ymax, xmin:xmax]
+ hp, wp = h, w # height, width previous for next iteration
+
+ # Labels assuming imgsz*2 mosaic size
+ labels_patch = self._update_labels(labels_patch, padw + self.border[0], padh + self.border[1])
+ mosaic_labels.append(labels_patch)
+ final_labels = self._cat_labels(mosaic_labels)
+
+ final_labels['img'] = img9[-self.border[0]:self.border[0], -self.border[1]:self.border[1]]
+ return final_labels
+
+ @staticmethod
+ def _update_labels(labels, padw, padh):
+ """Update labels."""
+ nh, nw = labels['img'].shape[:2]
+ labels['instances'].convert_bbox(format='xyxy')
+ labels['instances'].denormalize(nw, nh)
+ labels['instances'].add_padding(padw, padh)
+ return labels
+
+ def _cat_labels(self, mosaic_labels):
+ """Return labels with mosaic border instances clipped."""
+ if len(mosaic_labels) == 0:
+ return {}
+ cls = []
+ instances = []
+ imgsz = self.imgsz * 2 # mosaic imgsz
+ for labels in mosaic_labels:
+ cls.append(labels['cls'])
+ instances.append(labels['instances'])
+ final_labels = {
+ 'im_file': mosaic_labels[0]['im_file'],
+ 'ori_shape': mosaic_labels[0]['ori_shape'],
+ 'resized_shape': (imgsz, imgsz),
+ 'cls': np.concatenate(cls, 0),
+ 'instances': Instances.concatenate(instances, axis=0),
+ 'mosaic_border': self.border} # final_labels
+ final_labels['instances'].clip(imgsz, imgsz)
+ good = final_labels['instances'].remove_zero_area_boxes()
+ final_labels['cls'] = final_labels['cls'][good]
+ return final_labels
+
+
+class MixUp(BaseMixTransform):
+ """Class for applying MixUp augmentation to the dataset."""
+
+ def __init__(self, dataset, pre_transform=None, p=0.0) -> None:
+ """Initializes MixUp object with dataset, pre_transform, and probability of applying MixUp."""
+ super().__init__(dataset=dataset, pre_transform=pre_transform, p=p)
+
+ def get_indexes(self):
+ """Get a random index from the dataset."""
+ return random.randint(0, len(self.dataset) - 1)
+
+ def _mix_transform(self, labels):
+ """Applies MixUp augmentation as per https://arxiv.org/pdf/1710.09412.pdf."""
+ r = np.random.beta(32.0, 32.0) # mixup ratio, alpha=beta=32.0
+ labels2 = labels['mix_labels'][0]
+ labels['img'] = (labels['img'] * r + labels2['img'] * (1 - r)).astype(np.uint8)
+ labels['instances'] = Instances.concatenate([labels['instances'], labels2['instances']], axis=0)
+ labels['cls'] = np.concatenate([labels['cls'], labels2['cls']], 0)
+ return labels
+
+
+class RandomPerspective:
+ """
+ Implements random perspective and affine transformations on images and corresponding bounding boxes, segments, and
+ keypoints. These transformations include rotation, translation, scaling, and shearing. The class also offers the
+ option to apply these transformations conditionally with a specified probability.
+
+ Attributes:
+ degrees (float): Degree range for random rotations.
+ translate (float): Fraction of total width and height for random translation.
+ scale (float): Scaling factor interval, e.g., a scale factor of 0.1 allows a resize between 90%-110%.
+ shear (float): Shear intensity (angle in degrees).
+ perspective (float): Perspective distortion factor.
+ border (tuple): Tuple specifying mosaic border.
+ pre_transform (callable): A function/transform to apply to the image before starting the random transformation.
+
+ Methods:
+ affine_transform(img, border): Applies a series of affine transformations to the image.
+ apply_bboxes(bboxes, M): Transforms bounding boxes using the calculated affine matrix.
+ apply_segments(segments, M): Transforms segments and generates new bounding boxes.
+ apply_keypoints(keypoints, M): Transforms keypoints.
+ __call__(labels): Main method to apply transformations to both images and their corresponding annotations.
+ box_candidates(box1, box2): Filters out bounding boxes that don't meet certain criteria post-transformation.
+ """
+
+ def __init__(self,
+ degrees=0.0,
+ translate=0.1,
+ scale=0.5,
+ shear=0.0,
+ perspective=0.0,
+ border=(0, 0),
+ pre_transform=None):
+ """Initializes RandomPerspective object with transformation parameters."""
+
+ self.degrees = degrees
+ self.translate = translate
+ self.scale = scale
+ self.shear = shear
+ self.perspective = perspective
+ self.border = border # mosaic border
+ self.pre_transform = pre_transform
+
+ def affine_transform(self, img, border):
+ """
+ Applies a sequence of affine transformations centered around the image center.
+
+ Args:
+ img (ndarray): Input image.
+ border (tuple): Border dimensions.
+
+ Returns:
+ img (ndarray): Transformed image.
+ M (ndarray): Transformation matrix.
+ s (float): Scale factor.
+ """
+
+ # Center
+ C = np.eye(3, dtype=np.float32)
+
+ C[0, 2] = -img.shape[1] / 2 # x translation (pixels)
+ C[1, 2] = -img.shape[0] / 2 # y translation (pixels)
+
+ # Perspective
+ P = np.eye(3, dtype=np.float32)
+ P[2, 0] = random.uniform(-self.perspective, self.perspective) # x perspective (about y)
+ P[2, 1] = random.uniform(-self.perspective, self.perspective) # y perspective (about x)
+
+ # Rotation and Scale
+ R = np.eye(3, dtype=np.float32)
+ a = random.uniform(-self.degrees, self.degrees)
+ # a += random.choice([-180, -90, 0, 90]) # add 90deg rotations to small rotations
+ s = random.uniform(1 - self.scale, 1 + self.scale)
+ # s = 2 ** random.uniform(-scale, scale)
+ R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s)
+
+ # Shear
+ S = np.eye(3, dtype=np.float32)
+ S[0, 1] = math.tan(random.uniform(-self.shear, self.shear) * math.pi / 180) # x shear (deg)
+ S[1, 0] = math.tan(random.uniform(-self.shear, self.shear) * math.pi / 180) # y shear (deg)
+
+ # Translation
+ T = np.eye(3, dtype=np.float32)
+ T[0, 2] = random.uniform(0.5 - self.translate, 0.5 + self.translate) * self.size[0] # x translation (pixels)
+ T[1, 2] = random.uniform(0.5 - self.translate, 0.5 + self.translate) * self.size[1] # y translation (pixels)
+
+ # Combined rotation matrix
+ M = T @ S @ R @ P @ C # order of operations (right to left) is IMPORTANT
+ # Affine image
+ if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any(): # image changed
+ if self.perspective:
+ img = cv2.warpPerspective(img, M, dsize=self.size, borderValue=(114, 114, 114))
+ else: # affine
+ img = cv2.warpAffine(img, M[:2], dsize=self.size, borderValue=(114, 114, 114))
+ return img, M, s
+
+ def apply_bboxes(self, bboxes, M):
+ """
+ Apply affine to bboxes only.
+
+ Args:
+ bboxes (ndarray): list of bboxes, xyxy format, with shape (num_bboxes, 4).
+ M (ndarray): affine matrix.
+
+ Returns:
+ new_bboxes (ndarray): bboxes after affine, [num_bboxes, 4].
+ """
+ n = len(bboxes)
+ if n == 0:
+ return bboxes
+
+ xy = np.ones((n * 4, 3), dtype=bboxes.dtype)
+ xy[:, :2] = bboxes[:, [0, 1, 2, 3, 0, 3, 2, 1]].reshape(n * 4, 2) # x1y1, x2y2, x1y2, x2y1
+ xy = xy @ M.T # transform
+ xy = (xy[:, :2] / xy[:, 2:3] if self.perspective else xy[:, :2]).reshape(n, 8) # perspective rescale or affine
+
+ # Create new boxes
+ x = xy[:, [0, 2, 4, 6]]
+ y = xy[:, [1, 3, 5, 7]]
+ return np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1)), dtype=bboxes.dtype).reshape(4, n).T
+
+ def apply_segments(self, segments, M):
+ """
+ Apply affine to segments and generate new bboxes from segments.
+
+ Args:
+ segments (ndarray): list of segments, [num_samples, 500, 2].
+ M (ndarray): affine matrix.
+
+ Returns:
+ new_segments (ndarray): list of segments after affine, [num_samples, 500, 2].
+ new_bboxes (ndarray): bboxes after affine, [N, 4].
+ """
+ n, num = segments.shape[:2]
+ if n == 0:
+ return [], segments
+
+ xy = np.ones((n * num, 3), dtype=segments.dtype)
+ segments = segments.reshape(-1, 2)
+ xy[:, :2] = segments
+ xy = xy @ M.T # transform
+ xy = xy[:, :2] / xy[:, 2:3]
+ segments = xy.reshape(n, -1, 2)
+ bboxes = np.stack([segment2box(xy, self.size[0], self.size[1]) for xy in segments], 0)
+ return bboxes, segments
+
+ def apply_keypoints(self, keypoints, M):
+ """
+ Apply affine to keypoints.
+
+ Args:
+ keypoints (ndarray): keypoints, [N, 17, 3].
+ M (ndarray): affine matrix.
+
+ Returns:
+ new_keypoints (ndarray): keypoints after affine, [N, 17, 3].
+ """
+ n, nkpt = keypoints.shape[:2]
+ if n == 0:
+ return keypoints
+ xy = np.ones((n * nkpt, 3), dtype=keypoints.dtype)
+ visible = keypoints[..., 2].reshape(n * nkpt, 1)
+ xy[:, :2] = keypoints[..., :2].reshape(n * nkpt, 2)
+ xy = xy @ M.T # transform
+ xy = xy[:, :2] / xy[:, 2:3] # perspective rescale or affine
+ out_mask = (xy[:, 0] < 0) | (xy[:, 1] < 0) | (xy[:, 0] > self.size[0]) | (xy[:, 1] > self.size[1])
+ visible[out_mask] = 0
+ return np.concatenate([xy, visible], axis=-1).reshape(n, nkpt, 3)
+
+ def __call__(self, labels):
+ """
+ Affine images and targets.
+
+ Args:
+ labels (dict): a dict of `bboxes`, `segments`, `keypoints`.
+ """
+ if self.pre_transform and 'mosaic_border' not in labels:
+ labels = self.pre_transform(labels)
+ labels.pop('ratio_pad', None) # do not need ratio pad
+
+ img = labels['img']
+ cls = labels['cls']
+ instances = labels.pop('instances')
+ # Make sure the coord formats are right
+ instances.convert_bbox(format='xyxy')
+ instances.denormalize(*img.shape[:2][::-1])
+
+ border = labels.pop('mosaic_border', self.border)
+ self.size = img.shape[1] + border[1] * 2, img.shape[0] + border[0] * 2 # w, h
+ # M is affine matrix
+ # Scale for func:`box_candidates`
+ img, M, scale = self.affine_transform(img, border)
+
+ bboxes = self.apply_bboxes(instances.bboxes, M)
+
+ segments = instances.segments
+ keypoints = instances.keypoints
+ # Update bboxes if there are segments.
+ if len(segments):
+ bboxes, segments = self.apply_segments(segments, M)
+
+ if keypoints is not None:
+ keypoints = self.apply_keypoints(keypoints, M)
+ new_instances = Instances(bboxes, segments, keypoints, bbox_format='xyxy', normalized=False)
+ # Clip
+ new_instances.clip(*self.size)
+
+ # Filter instances
+ instances.scale(scale_w=scale, scale_h=scale, bbox_only=True)
+ # Make the bboxes have the same scale with new_bboxes
+ i = self.box_candidates(box1=instances.bboxes.T,
+ box2=new_instances.bboxes.T,
+ area_thr=0.01 if len(segments) else 0.10)
+ labels['instances'] = new_instances[i]
+ labels['cls'] = cls[i]
+ labels['img'] = img
+ labels['resized_shape'] = img.shape[:2]
+ return labels
+
+ def box_candidates(self, box1, box2, wh_thr=2, ar_thr=100, area_thr=0.1, eps=1e-16):
+ """
+ Compute box candidates based on a set of thresholds. This method compares the characteristics of the boxes
+ before and after augmentation to decide whether a box is a candidate for further processing.
+
+ Args:
+ box1 (numpy.ndarray): The 4,n bounding box before augmentation, represented as [x1, y1, x2, y2].
+ box2 (numpy.ndarray): The 4,n bounding box after augmentation, represented as [x1, y1, x2, y2].
+ wh_thr (float, optional): The width and height threshold in pixels. Default is 2.
+ ar_thr (float, optional): The aspect ratio threshold. Default is 100.
+ area_thr (float, optional): The area ratio threshold. Default is 0.1.
+ eps (float, optional): A small epsilon value to prevent division by zero. Default is 1e-16.
+
+ Returns:
+ (numpy.ndarray): A boolean array indicating which boxes are candidates based on the given thresholds.
+ """
+ w1, h1 = box1[2] - box1[0], box1[3] - box1[1]
+ w2, h2 = box2[2] - box2[0], box2[3] - box2[1]
+ ar = np.maximum(w2 / (h2 + eps), h2 / (w2 + eps)) # aspect ratio
+ return (w2 > wh_thr) & (h2 > wh_thr) & (w2 * h2 / (w1 * h1 + eps) > area_thr) & (ar < ar_thr) # candidates
+
+
+class RandomHSV:
+ """
+ This class is responsible for performing random adjustments to the Hue, Saturation, and Value (HSV) channels of an
+ image.
+
+ The adjustments are random but within limits set by hgain, sgain, and vgain.
+ """
+
+ def __init__(self, hgain=0.5, sgain=0.5, vgain=0.5) -> None:
+ """
+ Initialize RandomHSV class with gains for each HSV channel.
+
+ Args:
+ hgain (float, optional): Maximum variation for hue. Default is 0.5.
+ sgain (float, optional): Maximum variation for saturation. Default is 0.5.
+ vgain (float, optional): Maximum variation for value. Default is 0.5.
+ """
+ self.hgain = hgain
+ self.sgain = sgain
+ self.vgain = vgain
+
+ def __call__(self, labels):
+ """
+ Applies random HSV augmentation to an image within the predefined limits.
+
+ The modified image replaces the original image in the input 'labels' dict.
+ """
+ img = labels['img']
+ if self.hgain or self.sgain or self.vgain:
+ r = np.random.uniform(-1, 1, 3) * [self.hgain, self.sgain, self.vgain] + 1 # random gains
+ hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV))
+ dtype = img.dtype # uint8
+
+ x = np.arange(0, 256, dtype=r.dtype)
+ lut_hue = ((x * r[0]) % 180).astype(dtype)
+ lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)
+ lut_val = np.clip(x * r[2], 0, 255).astype(dtype)
+
+ im_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val)))
+ cv2.cvtColor(im_hsv, cv2.COLOR_HSV2BGR, dst=img) # no return needed
+ return labels
+
+
+class RandomFlip:
+ """
+ Applies a random horizontal or vertical flip to an image with a given probability.
+
+ Also updates any instances (bounding boxes, keypoints, etc.) accordingly.
+ """
+
+ def __init__(self, p=0.5, direction='horizontal', flip_idx=None) -> None:
+ """
+ Initializes the RandomFlip class with probability and direction.
+
+ Args:
+ p (float, optional): The probability of applying the flip. Must be between 0 and 1. Default is 0.5.
+ direction (str, optional): The direction to apply the flip. Must be 'horizontal' or 'vertical'.
+ Default is 'horizontal'.
+ flip_idx (array-like, optional): Index mapping for flipping keypoints, if any.
+ """
+ assert direction in ['horizontal', 'vertical'], f'Support direction `horizontal` or `vertical`, got {direction}'
+ assert 0 <= p <= 1.0
+
+ self.p = p
+ self.direction = direction
+ self.flip_idx = flip_idx
+
+ def __call__(self, labels):
+ """
+ Applies random flip to an image and updates any instances like bounding boxes or keypoints accordingly.
+
+ Args:
+ labels (dict): A dictionary containing the keys 'img' and 'instances'. 'img' is the image to be flipped.
+ 'instances' is an object containing bounding boxes and optionally keypoints.
+
+ Returns:
+ (dict): The same dict with the flipped image and updated instances under the 'img' and 'instances' keys.
+ """
+ img = labels['img']
+ instances = labels.pop('instances')
+ instances.convert_bbox(format='xywh')
+ h, w = img.shape[:2]
+ h = 1 if instances.normalized else h
+ w = 1 if instances.normalized else w
+
+ # Flip up-down
+ if self.direction == 'vertical' and random.random() < self.p:
+ img = np.flipud(img)
+ instances.flipud(h)
+ if self.direction == 'horizontal' and random.random() < self.p:
+ img = np.fliplr(img)
+ instances.fliplr(w)
+ # For keypoints
+ if self.flip_idx is not None and instances.keypoints is not None:
+ instances.keypoints = np.ascontiguousarray(instances.keypoints[:, self.flip_idx, :])
+ labels['img'] = np.ascontiguousarray(img)
+ labels['instances'] = instances
+ return labels
+
+
+class LetterBox:
+ """Resize image and padding for detection, instance segmentation, pose."""
+
+ def __init__(self, new_shape=(640, 640), auto=False, scaleFill=False, scaleup=True, center=True, stride=32):
+ """Initialize LetterBox object with specific parameters."""
+ self.new_shape = new_shape
+ self.auto = auto
+ self.scaleFill = scaleFill
+ self.scaleup = scaleup
+ self.stride = stride
+ self.center = center # Put the image in the middle or top-left
+
+ def __call__(self, labels=None, image=None):
+ """Return updated labels and image with added border."""
+ if labels is None:
+ labels = {}
+ img = labels.get('img') if image is None else image
+ shape = img.shape[:2] # current shape [height, width]
+ new_shape = labels.pop('rect_shape', self.new_shape)
+ if isinstance(new_shape, int):
+ new_shape = (new_shape, new_shape)
+
+ # Scale ratio (new / old)
+ r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
+ if not self.scaleup: # only scale down, do not scale up (for better val mAP)
+ r = min(r, 1.0)
+
+ # Compute padding
+ ratio = r, r # width, height ratios
+ new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
+ dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding
+ if self.auto: # minimum rectangle
+ dw, dh = np.mod(dw, self.stride), np.mod(dh, self.stride) # wh padding
+ elif self.scaleFill: # stretch
+ dw, dh = 0.0, 0.0
+ new_unpad = (new_shape[1], new_shape[0])
+ ratio = new_shape[1] / shape[1], new_shape[0] / shape[0] # width, height ratios
+
+ if self.center:
+ dw /= 2 # divide padding into 2 sides
+ dh /= 2
+
+ if shape[::-1] != new_unpad: # resize
+ img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
+ top, bottom = int(round(dh - 0.1)) if self.center else 0, int(round(dh + 0.1))
+ left, right = int(round(dw - 0.1)) if self.center else 0, int(round(dw + 0.1))
+ img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT,
+ value=(114, 114, 114)) # add border
+ if labels.get('ratio_pad'):
+ labels['ratio_pad'] = (labels['ratio_pad'], (left, top)) # for evaluation
+
+ if len(labels):
+ labels = self._update_labels(labels, ratio, dw, dh)
+ labels['img'] = img
+ labels['resized_shape'] = new_shape
+ return labels
+ else:
+ return img
+
+ def _update_labels(self, labels, ratio, padw, padh):
+ """Update labels."""
+ labels['instances'].convert_bbox(format='xyxy')
+ labels['instances'].denormalize(*labels['img'].shape[:2][::-1])
+ labels['instances'].scale(*ratio)
+ labels['instances'].add_padding(padw, padh)
+ return labels
+
+
+class CopyPaste:
+ """
+ Implements the Copy-Paste augmentation as described in the paper https://arxiv.org/abs/2012.07177. This class is
+ responsible for applying the Copy-Paste augmentation on images and their corresponding instances.
+ """
+
+ def __init__(self, p=0.5) -> None:
+ """
+ Initializes the CopyPaste class with a given probability.
+
+ Args:
+ p (float, optional): The probability of applying the Copy-Paste augmentation. Must be between 0 and 1.
+ Default is 0.5.
+ """
+ self.p = p
+
+ def __call__(self, labels):
+ """
+ Applies the Copy-Paste augmentation to the given image and instances.
+
+ Args:
+ labels (dict): A dictionary containing:
+ - 'img': The image to augment.
+ - 'cls': Class labels associated with the instances.
+ - 'instances': Object containing bounding boxes, and optionally, keypoints and segments.
+
+ Returns:
+ (dict): Dict with augmented image and updated instances under the 'img', 'cls', and 'instances' keys.
+
+ Notes:
+ 1. Instances are expected to have 'segments' as one of their attributes for this augmentation to work.
+ 2. This method modifies the input dictionary 'labels' in place.
+ """
+ im = labels['img']
+ cls = labels['cls']
+ h, w = im.shape[:2]
+ instances = labels.pop('instances')
+ instances.convert_bbox(format='xyxy')
+ instances.denormalize(w, h)
+ if self.p and len(instances.segments):
+ n = len(instances)
+ _, w, _ = im.shape # height, width, channels
+ im_new = np.zeros(im.shape, np.uint8)
+
+ # Calculate ioa first then select indexes randomly
+ ins_flip = deepcopy(instances)
+ ins_flip.fliplr(w)
+
+ ioa = bbox_ioa(ins_flip.bboxes, instances.bboxes) # intersection over area, (N, M)
+ indexes = np.nonzero((ioa < 0.30).all(1))[0] # (N, )
+ n = len(indexes)
+ for j in random.sample(list(indexes), k=round(self.p * n)):
+ cls = np.concatenate((cls, cls[[j]]), axis=0)
+ instances = Instances.concatenate((instances, ins_flip[[j]]), axis=0)
+ cv2.drawContours(im_new, instances.segments[[j]].astype(np.int32), -1, (1, 1, 1), cv2.FILLED)
+
+ result = cv2.flip(im, 1) # augment segments (flip left-right)
+ i = cv2.flip(im_new, 1).astype(bool)
+ im[i] = result[i]
+
+ labels['img'] = im
+ labels['cls'] = cls
+ labels['instances'] = instances
+ return labels
+
+
+class Albumentations:
+ """
+ Albumentations transformations.
+
+ Optional, uninstall package to disable. Applies Blur, Median Blur, convert to grayscale, Contrast Limited Adaptive
+ Histogram Equalization, random change of brightness and contrast, RandomGamma and lowering of image quality by
+ compression.
+ """
+
+ def __init__(self, p=1.0):
+ """Initialize the transform object for YOLO bbox formatted params."""
+ self.p = p
+ self.transform = None
+ prefix = colorstr('albumentations: ')
+ try:
+ import albumentations as A
+
+ check_version(A.__version__, '1.0.3', hard=True) # version requirement
+
+ T = [
+ A.Blur(p=0.01),
+ A.MedianBlur(p=0.01),
+ A.ToGray(p=0.01),
+ A.CLAHE(p=0.01),
+ A.RandomBrightnessContrast(p=0.0),
+ A.RandomGamma(p=0.0),
+ A.ImageCompression(quality_lower=75, p=0.0)] # transforms
+ self.transform = A.Compose(T, bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))
+
+ LOGGER.info(prefix + ', '.join(f'{x}'.replace('always_apply=False, ', '') for x in T if x.p))
+ except ImportError: # package not installed, skip
+ pass
+ except Exception as e:
+ LOGGER.info(f'{prefix}{e}')
+
+ def __call__(self, labels):
+ """Generates object detections and returns a dictionary with detection results."""
+ im = labels['img']
+ cls = labels['cls']
+ if len(cls):
+ labels['instances'].convert_bbox('xywh')
+ labels['instances'].normalize(*im.shape[:2][::-1])
+ bboxes = labels['instances'].bboxes
+ # TODO: add supports of segments and keypoints
+ if self.transform and random.random() < self.p:
+ new = self.transform(image=im, bboxes=bboxes, class_labels=cls) # transformed
+ if len(new['class_labels']) > 0: # skip update if no bbox in new im
+ labels['img'] = new['image']
+ labels['cls'] = np.array(new['class_labels'])
+ bboxes = np.array(new['bboxes'], dtype=np.float32)
+ labels['instances'].update(bboxes=bboxes)
+ return labels
+
+
+# TODO: technically this is not an augmentation, maybe we should put this to another files
+class Format:
+ """
+ Formats image annotations for object detection, instance segmentation, and pose estimation tasks. The class
+ standardizes the image and instance annotations to be used by the `collate_fn` in PyTorch DataLoader.
+
+ Attributes:
+ bbox_format (str): Format for bounding boxes. Default is 'xywh'.
+ normalize (bool): Whether to normalize bounding boxes. Default is True.
+ return_mask (bool): Return instance masks for segmentation. Default is False.
+ return_keypoint (bool): Return keypoints for pose estimation. Default is False.
+ mask_ratio (int): Downsample ratio for masks. Default is 4.
+ mask_overlap (bool): Whether to overlap masks. Default is True.
+ batch_idx (bool): Keep batch indexes. Default is True.
+ """
+
+ def __init__(self,
+ bbox_format='xywh',
+ normalize=True,
+ return_mask=False,
+ return_keypoint=False,
+ mask_ratio=4,
+ mask_overlap=True,
+ batch_idx=True):
+ """Initializes the Format class with given parameters."""
+ self.bbox_format = bbox_format
+ self.normalize = normalize
+ self.return_mask = return_mask # set False when training detection only
+ self.return_keypoint = return_keypoint
+ self.mask_ratio = mask_ratio
+ self.mask_overlap = mask_overlap
+ self.batch_idx = batch_idx # keep the batch indexes
+
+ def __call__(self, labels):
+ """Return formatted image, classes, bounding boxes & keypoints to be used by 'collate_fn'."""
+ img = labels.pop('img')
+ h, w = img.shape[:2]
+ cls = labels.pop('cls')
+ instances = labels.pop('instances')
+ instances.convert_bbox(format=self.bbox_format)
+ instances.denormalize(w, h)
+ nl = len(instances)
+
+ if self.return_mask:
+ if nl:
+ masks, instances, cls = self._format_segments(instances, cls, w, h)
+ masks = torch.from_numpy(masks)
+ else:
+ masks = torch.zeros(1 if self.mask_overlap else nl, img.shape[0] // self.mask_ratio,
+ img.shape[1] // self.mask_ratio)
+ labels['masks'] = masks
+ if self.normalize:
+ instances.normalize(w, h)
+ labels['img'] = self._format_img(img)
+ labels['cls'] = torch.from_numpy(cls) if nl else torch.zeros(nl)
+ labels['bboxes'] = torch.from_numpy(instances.bboxes) if nl else torch.zeros((nl, 4))
+ if self.return_keypoint:
+ labels['keypoints'] = torch.from_numpy(instances.keypoints)
+ # Then we can use collate_fn
+ if self.batch_idx:
+ labels['batch_idx'] = torch.zeros(nl)
+ return labels
+
+ def _format_img(self, img):
+ """Format the image for YOLO from Numpy array to PyTorch tensor."""
+ if len(img.shape) < 3:
+ img = np.expand_dims(img, -1)
+ img = np.ascontiguousarray(img.transpose(2, 0, 1)[::-1])
+ img = torch.from_numpy(img)
+ return img
+
+ def _format_segments(self, instances, cls, w, h):
+ """Convert polygon points to bitmap."""
+ segments = instances.segments
+ if self.mask_overlap:
+ masks, sorted_idx = polygons2masks_overlap((h, w), segments, downsample_ratio=self.mask_ratio)
+ masks = masks[None] # (640, 640) -> (1, 640, 640)
+ instances = instances[sorted_idx]
+ cls = cls[sorted_idx]
+ else:
+ masks = polygons2masks((h, w), segments, color=1, downsample_ratio=self.mask_ratio)
+
+ return masks, instances, cls
+
+
+def v8_transforms(dataset, imgsz, hyp, stretch=False):
+ """Convert images to a size suitable for YOLOv8 training."""
+ pre_transform = Compose([
+ Mosaic(dataset, imgsz=imgsz, p=hyp.mosaic),
+ CopyPaste(p=hyp.copy_paste),
+ RandomPerspective(
+ degrees=hyp.degrees,
+ translate=hyp.translate,
+ scale=hyp.scale,
+ shear=hyp.shear,
+ perspective=hyp.perspective,
+ pre_transform=None if stretch else LetterBox(new_shape=(imgsz, imgsz)),
+ )])
+ flip_idx = dataset.data.get('flip_idx', []) # for keypoints augmentation
+ if dataset.use_keypoints:
+ kpt_shape = dataset.data.get('kpt_shape', None)
+ if len(flip_idx) == 0 and hyp.fliplr > 0.0:
+ hyp.fliplr = 0.0
+ LOGGER.warning("WARNING ⚠️ No 'flip_idx' array defined in data.yaml, setting augmentation 'fliplr=0.0'")
+ elif flip_idx and (len(flip_idx) != kpt_shape[0]):
+ raise ValueError(f'data.yaml flip_idx={flip_idx} length must be equal to kpt_shape[0]={kpt_shape[0]}')
+
+ return Compose([
+ pre_transform,
+ MixUp(dataset, pre_transform=pre_transform, p=hyp.mixup),
+ Albumentations(p=1.0),
+ RandomHSV(hgain=hyp.hsv_h, sgain=hyp.hsv_s, vgain=hyp.hsv_v),
+ RandomFlip(direction='vertical', p=hyp.flipud),
+ RandomFlip(direction='horizontal', p=hyp.fliplr, flip_idx=flip_idx)]) # transforms
+
+
+# Classification augmentations -----------------------------------------------------------------------------------------
+def classify_transforms(size=224, rect=False, mean=(0.0, 0.0, 0.0), std=(1.0, 1.0, 1.0)): # IMAGENET_MEAN, IMAGENET_STD
+ """Transforms to apply if albumentations not installed."""
+ if not isinstance(size, int):
+ raise TypeError(f'classify_transforms() size {size} must be integer, not (list, tuple)')
+ transforms = [ClassifyLetterBox(size, auto=True) if rect else CenterCrop(size), ToTensor()]
+ if any(mean) or any(std):
+ transforms.append(T.Normalize(mean, std, inplace=True))
+ return T.Compose(transforms)
+
+
+def hsv2colorjitter(h, s, v):
+ """Map HSV (hue, saturation, value) jitter into ColorJitter values (brightness, contrast, saturation, hue)"""
+ return v, v, s, h
+
+
+def classify_albumentations(
+ augment=True,
+ size=224,
+ scale=(0.08, 1.0),
+ hflip=0.5,
+ vflip=0.0,
+ hsv_h=0.015, # image HSV-Hue augmentation (fraction)
+ hsv_s=0.7, # image HSV-Saturation augmentation (fraction)
+ hsv_v=0.4, # image HSV-Value augmentation (fraction)
+ mean=(0.0, 0.0, 0.0), # IMAGENET_MEAN
+ std=(1.0, 1.0, 1.0), # IMAGENET_STD
+ auto_aug=False,
+):
+ """YOLOv8 classification Albumentations (optional, only used if package is installed)."""
+ prefix = colorstr('albumentations: ')
+ try:
+ import albumentations as A
+ from albumentations.pytorch import ToTensorV2
+
+ check_version(A.__version__, '1.0.3', hard=True) # version requirement
+ if augment: # Resize and crop
+ T = [A.RandomResizedCrop(height=size, width=size, scale=scale)]
+ if auto_aug:
+ # TODO: implement AugMix, AutoAug & RandAug in albumentations
+ LOGGER.info(f'{prefix}auto augmentations are currently not supported')
+ else:
+ if hflip > 0:
+ T += [A.HorizontalFlip(p=hflip)]
+ if vflip > 0:
+ T += [A.VerticalFlip(p=vflip)]
+ if any((hsv_h, hsv_s, hsv_v)):
+ T += [A.ColorJitter(*hsv2colorjitter(hsv_h, hsv_s, hsv_v))] # brightness, contrast, saturation, hue
+ else: # Use fixed crop for eval set (reproducibility)
+ T = [A.SmallestMaxSize(max_size=size), A.CenterCrop(height=size, width=size)]
+ T += [A.Normalize(mean=mean, std=std), ToTensorV2()] # Normalize and convert to Tensor
+ LOGGER.info(prefix + ', '.join(f'{x}'.replace('always_apply=False, ', '') for x in T if x.p))
+ return A.Compose(T)
+
+ except ImportError: # package not installed, skip
+ pass
+ except Exception as e:
+ LOGGER.info(f'{prefix}{e}')
+
+
+class ClassifyLetterBox:
+ """
+ YOLOv8 LetterBox class for image preprocessing, designed to be part of a transformation pipeline, e.g.,
+ T.Compose([LetterBox(size), ToTensor()]).
+
+ Attributes:
+ h (int): Target height of the image.
+ w (int): Target width of the image.
+ auto (bool): If True, automatically solves for short side using stride.
+ stride (int): The stride value, used when 'auto' is True.
+ """
+
+ def __init__(self, size=(640, 640), auto=False, stride=32):
+ """
+ Initializes the ClassifyLetterBox class with a target size, auto-flag, and stride.
+
+ Args:
+ size (Union[int, Tuple[int, int]]): The target dimensions (height, width) for the letterbox.
+ auto (bool): If True, automatically calculates the short side based on stride.
+ stride (int): The stride value, used when 'auto' is True.
+ """
+ super().__init__()
+ self.h, self.w = (size, size) if isinstance(size, int) else size
+ self.auto = auto # pass max size integer, automatically solve for short side using stride
+ self.stride = stride # used with auto
+
+ def __call__(self, im):
+ """
+ Resizes the image and pads it with a letterbox method.
+
+ Args:
+ im (numpy.ndarray): The input image as a numpy array of shape HWC.
+
+ Returns:
+ (numpy.ndarray): The letterboxed and resized image as a numpy array.
+ """
+ imh, imw = im.shape[:2]
+ r = min(self.h / imh, self.w / imw) # ratio of new/old dimensions
+ h, w = round(imh * r), round(imw * r) # resized image dimensions
+
+ # Calculate padding dimensions
+ hs, ws = (math.ceil(x / self.stride) * self.stride for x in (h, w)) if self.auto else (self.h, self.w)
+ top, left = round((hs - h) / 2 - 0.1), round((ws - w) / 2 - 0.1)
+
+ # Create padded image
+ im_out = np.full((hs, ws, 3), 114, dtype=im.dtype)
+ im_out[top:top + h, left:left + w] = cv2.resize(im, (w, h), interpolation=cv2.INTER_LINEAR)
+ return im_out
+
+
+class CenterCrop:
+ """YOLOv8 CenterCrop class for image preprocessing, designed to be part of a transformation pipeline, e.g.,
+ T.Compose([CenterCrop(size), ToTensor()]).
+ """
+
+ def __init__(self, size=640):
+ """Converts an image from numpy array to PyTorch tensor."""
+ super().__init__()
+ self.h, self.w = (size, size) if isinstance(size, int) else size
+
+ def __call__(self, im):
+ """
+ Resizes and crops the center of the image using a letterbox method.
+
+ Args:
+ im (numpy.ndarray): The input image as a numpy array of shape HWC.
+
+ Returns:
+ (numpy.ndarray): The center-cropped and resized image as a numpy array.
+ """
+ imh, imw = im.shape[:2]
+ m = min(imh, imw) # min dimension
+ top, left = (imh - m) // 2, (imw - m) // 2
+ return cv2.resize(im[top:top + m, left:left + m], (self.w, self.h), interpolation=cv2.INTER_LINEAR)
+
+
+class ToTensor:
+ """YOLOv8 ToTensor class for image preprocessing, i.e., T.Compose([LetterBox(size), ToTensor()])."""
+
+ def __init__(self, half=False):
+ """Initialize YOLOv8 ToTensor object with optional half-precision support."""
+ super().__init__()
+ self.half = half
+
+ def __call__(self, im):
+ """
+ Transforms an image from a numpy array to a PyTorch tensor, applying optional half-precision and normalization.
+
+ Args:
+ im (numpy.ndarray): Input image as a numpy array with shape (H, W, C) in BGR order.
+
+ Returns:
+ (torch.Tensor): The transformed image as a PyTorch tensor in float32 or float16, normalized to [0, 1].
+ """
+ im = np.ascontiguousarray(im.transpose((2, 0, 1))[::-1]) # HWC to CHW -> BGR to RGB -> contiguous
+ im = torch.from_numpy(im) # to torch
+ im = im.half() if self.half else im.float() # uint8 to fp16/32
+ im /= 255.0 # 0-255 to 0.0-1.0
+ return im
diff --git a/ultralytics/ultralytics/data/base.py b/ultralytics/ultralytics/data/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..1df546b3913cb56ae2224b1c65159bd818f5bd09
--- /dev/null
+++ b/ultralytics/ultralytics/data/base.py
@@ -0,0 +1,304 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import glob
+import math
+import os
+import random
+from copy import deepcopy
+from multiprocessing.pool import ThreadPool
+from pathlib import Path
+from typing import Optional
+
+import cv2
+import numpy as np
+import psutil
+from torch.utils.data import Dataset
+
+from ultralytics.utils import DEFAULT_CFG, LOCAL_RANK, LOGGER, NUM_THREADS, TQDM
+
+from .utils import HELP_URL, IMG_FORMATS
+
+
+class BaseDataset(Dataset):
+ """
+ Base dataset class for loading and processing image data.
+
+ Args:
+ img_path (str): Path to the folder containing images.
+ imgsz (int, optional): Image size. Defaults to 640.
+ cache (bool, optional): Cache images to RAM or disk during training. Defaults to False.
+ augment (bool, optional): If True, data augmentation is applied. Defaults to True.
+ hyp (dict, optional): Hyperparameters to apply data augmentation. Defaults to None.
+ prefix (str, optional): Prefix to print in log messages. Defaults to ''.
+ rect (bool, optional): If True, rectangular training is used. Defaults to False.
+ batch_size (int, optional): Size of batches. Defaults to None.
+ stride (int, optional): Stride. Defaults to 32.
+ pad (float, optional): Padding. Defaults to 0.0.
+ single_cls (bool, optional): If True, single class training is used. Defaults to False.
+ classes (list): List of included classes. Default is None.
+ fraction (float): Fraction of dataset to utilize. Default is 1.0 (use all data).
+
+ Attributes:
+ im_files (list): List of image file paths.
+ labels (list): List of label data dictionaries.
+ ni (int): Number of images in the dataset.
+ ims (list): List of loaded images.
+ npy_files (list): List of numpy file paths.
+ transforms (callable): Image transformation function.
+ """
+
+ def __init__(self,
+ img_path,
+ imgsz=640,
+ cache=False,
+ augment=True,
+ hyp=DEFAULT_CFG,
+ prefix='',
+ rect=False,
+ batch_size=16,
+ stride=32,
+ pad=0.5,
+ single_cls=False,
+ classes=None,
+ fraction=1.0):
+ """Initialize BaseDataset with given configuration and options."""
+ super().__init__()
+ self.img_path = img_path
+ self.imgsz = imgsz
+ self.augment = augment
+ self.single_cls = single_cls
+ self.prefix = prefix
+ self.fraction = fraction
+ self.im_files = self.get_img_files(self.img_path)
+ self.labels = self.get_labels()
+ self.update_labels(include_class=classes) # single_cls and include_class
+ self.ni = len(self.labels) # number of images
+ self.rect = rect
+ self.batch_size = batch_size
+ self.stride = stride
+ self.pad = pad
+ if self.rect:
+ assert self.batch_size is not None
+ self.set_rectangle()
+
+ # Buffer thread for mosaic images
+ self.buffer = [] # buffer size = batch size
+ self.max_buffer_length = min((self.ni, self.batch_size * 8, 1000)) if self.augment else 0
+
+ # Cache images
+ if cache == 'ram' and not self.check_cache_ram():
+ cache = False
+ self.ims, self.im_hw0, self.im_hw = [None] * self.ni, [None] * self.ni, [None] * self.ni
+ self.npy_files = [Path(f).with_suffix('.npy') for f in self.im_files]
+ if cache:
+ self.cache_images(cache)
+
+ # Transforms
+ self.transforms = self.build_transforms(hyp=hyp)
+
+ def get_img_files(self, img_path):
+ """Read image files."""
+ try:
+ f = [] # image files
+ for p in img_path if isinstance(img_path, list) else [img_path]:
+ p = Path(p) # os-agnostic
+ if p.is_dir(): # dir
+ f += glob.glob(str(p / '**' / '*.*'), recursive=True)
+ # F = list(p.rglob('*.*')) # pathlib
+ elif p.is_file(): # file
+ with open(p) as t:
+ t = t.read().strip().splitlines()
+ parent = str(p.parent) + os.sep
+ f += [x.replace('./', parent) if x.startswith('./') else x for x in t] # local to global path
+ # F += [p.parent / x.lstrip(os.sep) for x in t] # local to global path (pathlib)
+ else:
+ raise FileNotFoundError(f'{self.prefix}{p} does not exist')
+ im_files = sorted(x.replace('/', os.sep) for x in f if x.split('.')[-1].lower() in IMG_FORMATS)
+ # self.img_files = sorted([x for x in f if x.suffix[1:].lower() in IMG_FORMATS]) # pathlib
+ assert im_files, f'{self.prefix}No images found in {img_path}'
+ except Exception as e:
+ raise FileNotFoundError(f'{self.prefix}Error loading data from {img_path}\n{HELP_URL}') from e
+ if self.fraction < 1:
+ im_files = im_files[:round(len(im_files) * self.fraction)]
+ return im_files
+
+ def update_labels(self, include_class: Optional[list]):
+ """Update labels to include only these classes (optional)."""
+ include_class_array = np.array(include_class).reshape(1, -1)
+ for i in range(len(self.labels)):
+ if include_class is not None:
+ cls = self.labels[i]['cls']
+ bboxes = self.labels[i]['bboxes']
+ segments = self.labels[i]['segments']
+ keypoints = self.labels[i]['keypoints']
+ j = (cls == include_class_array).any(1)
+ self.labels[i]['cls'] = cls[j]
+ self.labels[i]['bboxes'] = bboxes[j]
+ if segments:
+ self.labels[i]['segments'] = [segments[si] for si, idx in enumerate(j) if idx]
+ if keypoints is not None:
+ self.labels[i]['keypoints'] = keypoints[j]
+ if self.single_cls:
+ self.labels[i]['cls'][:, 0] = 0
+
+ def load_image(self, i, rect_mode=True):
+ """Loads 1 image from dataset index 'i', returns (im, resized hw)."""
+ im, f, fn = self.ims[i], self.im_files[i], self.npy_files[i]
+ if im is None: # not cached in RAM
+ if fn.exists(): # load npy
+ try:
+ im = np.load(fn)
+ except Exception as e:
+ LOGGER.warning(f'{self.prefix}WARNING ⚠️ Removing corrupt *.npy image file {fn} due to: {e}')
+ Path(fn).unlink(missing_ok=True)
+ im = cv2.imread(f) # BGR
+ else: # read image
+ im = cv2.imread(f) # BGR
+ if im is None:
+ raise FileNotFoundError(f'Image Not Found {f}')
+
+ h0, w0 = im.shape[:2] # orig hw
+ if rect_mode: # resize long side to imgsz while maintaining aspect ratio
+ r = self.imgsz / max(h0, w0) # ratio
+ if r != 1: # if sizes are not equal
+ w, h = (min(math.ceil(w0 * r), self.imgsz), min(math.ceil(h0 * r), self.imgsz))
+ im = cv2.resize(im, (w, h), interpolation=cv2.INTER_LINEAR)
+ elif not (h0 == w0 == self.imgsz): # resize by stretching image to square imgsz
+ im = cv2.resize(im, (self.imgsz, self.imgsz), interpolation=cv2.INTER_LINEAR)
+
+ # Add to buffer if training with augmentations
+ if self.augment:
+ self.ims[i], self.im_hw0[i], self.im_hw[i] = im, (h0, w0), im.shape[:2] # im, hw_original, hw_resized
+ self.buffer.append(i)
+ if len(self.buffer) >= self.max_buffer_length:
+ j = self.buffer.pop(0)
+ self.ims[j], self.im_hw0[j], self.im_hw[j] = None, None, None
+
+ return im, (h0, w0), im.shape[:2]
+
+ return self.ims[i], self.im_hw0[i], self.im_hw[i]
+
+ def cache_images(self, cache):
+ """Cache images to memory or disk."""
+ b, gb = 0, 1 << 30 # bytes of cached images, bytes per gigabytes
+ fcn = self.cache_images_to_disk if cache == 'disk' else self.load_image
+ with ThreadPool(NUM_THREADS) as pool:
+ results = pool.imap(fcn, range(self.ni))
+ pbar = TQDM(enumerate(results), total=self.ni, disable=LOCAL_RANK > 0)
+ for i, x in pbar:
+ if cache == 'disk':
+ b += self.npy_files[i].stat().st_size
+ else: # 'ram'
+ self.ims[i], self.im_hw0[i], self.im_hw[i] = x # im, hw_orig, hw_resized = load_image(self, i)
+ b += self.ims[i].nbytes
+ pbar.desc = f'{self.prefix}Caching images ({b / gb:.1f}GB {cache})'
+ pbar.close()
+
+ def cache_images_to_disk(self, i):
+ """Saves an image as an *.npy file for faster loading."""
+ f = self.npy_files[i]
+ if not f.exists():
+ np.save(f.as_posix(), cv2.imread(self.im_files[i]), allow_pickle=False)
+
+ def check_cache_ram(self, safety_margin=0.5):
+ """Check image caching requirements vs available memory."""
+ b, gb = 0, 1 << 30 # bytes of cached images, bytes per gigabytes
+ n = min(self.ni, 30) # extrapolate from 30 random images
+ for _ in range(n):
+ im = cv2.imread(random.choice(self.im_files)) # sample image
+ ratio = self.imgsz / max(im.shape[0], im.shape[1]) # max(h, w) # ratio
+ b += im.nbytes * ratio ** 2
+ mem_required = b * self.ni / n * (1 + safety_margin) # GB required to cache dataset into RAM
+ mem = psutil.virtual_memory()
+ cache = mem_required < mem.available # to cache or not to cache, that is the question
+ if not cache:
+ LOGGER.info(f'{self.prefix}{mem_required / gb:.1f}GB RAM required to cache images '
+ f'with {int(safety_margin * 100)}% safety margin but only '
+ f'{mem.available / gb:.1f}/{mem.total / gb:.1f}GB available, '
+ f"{'caching images ✅' if cache else 'not caching images ⚠️'}")
+ return cache
+
+ def set_rectangle(self):
+ """Sets the shape of bounding boxes for YOLO detections as rectangles."""
+ bi = np.floor(np.arange(self.ni) / self.batch_size).astype(int) # batch index
+ nb = bi[-1] + 1 # number of batches
+
+ s = np.array([x.pop('shape') for x in self.labels]) # hw
+ ar = s[:, 0] / s[:, 1] # aspect ratio
+ irect = ar.argsort()
+ self.im_files = [self.im_files[i] for i in irect]
+ self.labels = [self.labels[i] for i in irect]
+ ar = ar[irect]
+
+ # Set training image shapes
+ shapes = [[1, 1]] * nb
+ for i in range(nb):
+ ari = ar[bi == i]
+ mini, maxi = ari.min(), ari.max()
+ if maxi < 1:
+ shapes[i] = [maxi, 1]
+ elif mini > 1:
+ shapes[i] = [1, 1 / mini]
+
+ self.batch_shapes = np.ceil(np.array(shapes) * self.imgsz / self.stride + self.pad).astype(int) * self.stride
+ self.batch = bi # batch index of image
+
+ def __getitem__(self, index):
+ """Returns transformed label information for given index."""
+ return self.transforms(self.get_image_and_label(index))
+
+ def get_image_and_label(self, index):
+ """Get and return label information from the dataset."""
+ label = deepcopy(self.labels[index]) # requires deepcopy() https://github.com/ultralytics/ultralytics/pull/1948
+ label.pop('shape', None) # shape is for rect, remove it
+ label['img'], label['ori_shape'], label['resized_shape'] = self.load_image(index)
+ label['ratio_pad'] = (label['resized_shape'][0] / label['ori_shape'][0],
+ label['resized_shape'][1] / label['ori_shape'][1]) # for evaluation
+ if self.rect:
+ label['rect_shape'] = self.batch_shapes[self.batch[index]]
+ return self.update_labels_info(label)
+
+ def __len__(self):
+ """Returns the length of the labels list for the dataset."""
+ return len(self.labels)
+
+ def update_labels_info(self, label):
+ """Custom your label format here."""
+ return label
+
+ def build_transforms(self, hyp=None):
+ """
+ Users can customize augmentations here.
+
+ Example:
+ ```python
+ if self.augment:
+ # Training transforms
+ return Compose([])
+ else:
+ # Val transforms
+ return Compose([])
+ ```
+ """
+ raise NotImplementedError
+
+ def get_labels(self):
+ """
+ Users can customize their own format here.
+
+ Note:
+ Ensure output is a dictionary with the following keys:
+ ```python
+ dict(
+ im_file=im_file,
+ shape=shape, # format: (height, width)
+ cls=cls,
+ bboxes=bboxes, # xywh
+ segments=segments, # xy
+ keypoints=keypoints, # xy
+ normalized=True, # or False
+ bbox_format="xyxy", # or xywh, ltwh
+ )
+ ```
+ """
+ raise NotImplementedError
diff --git a/ultralytics/ultralytics/data/build.py b/ultralytics/ultralytics/data/build.py
new file mode 100644
index 0000000000000000000000000000000000000000..07de91c831bd49f419202085f435098a8dc2a3e0
--- /dev/null
+++ b/ultralytics/ultralytics/data/build.py
@@ -0,0 +1,177 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import os
+import random
+from pathlib import Path
+
+import numpy as np
+import torch
+from PIL import Image
+from torch.utils.data import dataloader, distributed
+
+from ultralytics.data.loaders import (LOADERS, LoadImages, LoadPilAndNumpy, LoadScreenshots, LoadStreams, LoadTensor,
+ SourceTypes, autocast_list)
+from ultralytics.data.utils import IMG_FORMATS, VID_FORMATS
+from ultralytics.utils import RANK, colorstr
+from ultralytics.utils.checks import check_file
+
+from .dataset import YOLODataset
+from .utils import PIN_MEMORY
+
+
+class InfiniteDataLoader(dataloader.DataLoader):
+ """
+ Dataloader that reuses workers.
+
+ Uses same syntax as vanilla DataLoader.
+ """
+
+ def __init__(self, *args, **kwargs):
+ """Dataloader that infinitely recycles workers, inherits from DataLoader."""
+ super().__init__(*args, **kwargs)
+ object.__setattr__(self, 'batch_sampler', _RepeatSampler(self.batch_sampler))
+ self.iterator = super().__iter__()
+
+ def __len__(self):
+ """Returns the length of the batch sampler's sampler."""
+ return len(self.batch_sampler.sampler)
+
+ def __iter__(self):
+ """Creates a sampler that repeats indefinitely."""
+ for _ in range(len(self)):
+ yield next(self.iterator)
+
+ def reset(self):
+ """
+ Reset iterator.
+
+ This is useful when we want to modify settings of dataset while training.
+ """
+ self.iterator = self._get_iterator()
+
+
+class _RepeatSampler:
+ """
+ Sampler that repeats forever.
+
+ Args:
+ sampler (Dataset.sampler): The sampler to repeat.
+ """
+
+ def __init__(self, sampler):
+ """Initializes an object that repeats a given sampler indefinitely."""
+ self.sampler = sampler
+
+ def __iter__(self):
+ """Iterates over the 'sampler' and yields its contents."""
+ while True:
+ yield from iter(self.sampler)
+
+
+def seed_worker(worker_id): # noqa
+ """Set dataloader worker seed https://pytorch.org/docs/stable/notes/randomness.html#dataloader."""
+ worker_seed = torch.initial_seed() % 2 ** 32
+ np.random.seed(worker_seed)
+ random.seed(worker_seed)
+
+
+def build_yolo_dataset(cfg, img_path, batch, data, mode='train', rect=False, stride=32):
+ """Build YOLO Dataset."""
+ return YOLODataset(
+ img_path=img_path,
+ imgsz=cfg.imgsz,
+ batch_size=batch,
+ augment=mode == 'train', # augmentation
+ hyp=cfg, # TODO: probably add a get_hyps_from_cfg function
+ rect=cfg.rect or rect, # rectangular batches
+ cache=cfg.cache or None,
+ single_cls=cfg.single_cls or False,
+ stride=int(stride),
+ pad=0.0 if mode == 'train' else 0.5,
+ prefix=colorstr(f'{mode}: '),
+ use_segments=cfg.task == 'segment',
+ use_keypoints=cfg.task == 'pose',
+ classes=cfg.classes,
+ data=data,
+ fraction=cfg.fraction if mode == 'train' else 1.0)
+
+
+def build_dataloader(dataset, batch, workers, shuffle=True, rank=-1):
+ """Return an InfiniteDataLoader or DataLoader for training or validation set."""
+ batch = min(batch, len(dataset))
+ nd = torch.cuda.device_count() # number of CUDA devices
+ nw = min([os.cpu_count() // max(nd, 1), batch if batch > 1 else 0, workers]) # number of workers
+ sampler = None if rank == -1 else distributed.DistributedSampler(dataset, shuffle=shuffle)
+ generator = torch.Generator()
+ generator.manual_seed(6148914691236517205 + RANK)
+ return InfiniteDataLoader(dataset=dataset,
+ batch_size=batch,
+ shuffle=shuffle and sampler is None,
+ num_workers=nw,
+ sampler=sampler,
+ pin_memory=PIN_MEMORY,
+ collate_fn=getattr(dataset, 'collate_fn', None),
+ worker_init_fn=seed_worker,
+ generator=generator)
+
+
+def check_source(source):
+ """Check source type and return corresponding flag values."""
+ webcam, screenshot, from_img, in_memory, tensor = False, False, False, False, False
+ if isinstance(source, (str, int, Path)): # int for local usb camera
+ source = str(source)
+ is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
+ is_url = source.lower().startswith(('https://', 'http://', 'rtsp://', 'rtmp://', 'tcp://'))
+ webcam = source.isnumeric() or source.endswith('.streams') or (is_url and not is_file)
+ screenshot = source.lower() == 'screen'
+ if is_url and is_file:
+ source = check_file(source) # download
+ elif isinstance(source, LOADERS):
+ in_memory = True
+ elif isinstance(source, (list, tuple)):
+ source = autocast_list(source) # convert all list elements to PIL or np arrays
+ from_img = True
+ elif isinstance(source, (Image.Image, np.ndarray)):
+ from_img = True
+ elif isinstance(source, torch.Tensor):
+ tensor = True
+ else:
+ raise TypeError('Unsupported image type. For supported types see https://docs.ultralytics.com/modes/predict')
+
+ return source, webcam, screenshot, from_img, in_memory, tensor
+
+
+def load_inference_source(source=None, imgsz=640, vid_stride=1, buffer=False):
+ """
+ Loads an inference source for object detection and applies necessary transformations.
+
+ Args:
+ source (str, Path, Tensor, PIL.Image, np.ndarray): The input source for inference.
+ imgsz (int, optional): The size of the image for inference. Default is 640.
+ vid_stride (int, optional): The frame interval for video sources. Default is 1.
+ buffer (bool, optional): Determined whether stream frames will be buffered. Default is False.
+
+ Returns:
+ dataset (Dataset): A dataset object for the specified input source.
+ """
+ source, webcam, screenshot, from_img, in_memory, tensor = check_source(source)
+ source_type = source.source_type if in_memory else SourceTypes(webcam, screenshot, from_img, tensor)
+
+ # Dataloader
+ if tensor:
+ dataset = LoadTensor(source)
+ elif in_memory:
+ dataset = source
+ elif webcam:
+ dataset = LoadStreams(source, imgsz=imgsz, vid_stride=vid_stride, buffer=buffer)
+ elif screenshot:
+ dataset = LoadScreenshots(source, imgsz=imgsz)
+ elif from_img:
+ dataset = LoadPilAndNumpy(source, imgsz=imgsz)
+ else:
+ dataset = LoadImages(source, imgsz=imgsz, vid_stride=vid_stride)
+
+ # Attach source types to the dataset
+ setattr(dataset, 'source_type', source_type)
+
+ return dataset
diff --git a/ultralytics/ultralytics/data/converter.py b/ultralytics/ultralytics/data/converter.py
new file mode 100644
index 0000000000000000000000000000000000000000..4fc50489a1f096b3f45c5e683debf238519bae64
--- /dev/null
+++ b/ultralytics/ultralytics/data/converter.py
@@ -0,0 +1,305 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import json
+from collections import defaultdict
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+from ultralytics.utils import LOGGER, TQDM
+from ultralytics.utils.files import increment_path
+
+
+def coco91_to_coco80_class():
+ """
+ Converts 91-index COCO class IDs to 80-index COCO class IDs.
+
+ Returns:
+ (list): A list of 91 class IDs where the index represents the 80-index class ID and the value is the
+ corresponding 91-index class ID.
+ """
+ return [
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, None, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, None, 24, 25, None,
+ None, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, None, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+ 51, 52, 53, 54, 55, 56, 57, 58, 59, None, 60, None, None, 61, None, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
+ None, 73, 74, 75, 76, 77, 78, 79, None]
+
+
+def coco80_to_coco91_class(): #
+ """
+ Converts 80-index (val2014) to 91-index (paper).
+ For details see https://tech.amikelive.com/node-718/what-object-categories-labels-are-in-coco-dataset/.
+
+ Example:
+ ```python
+ import numpy as np
+
+ a = np.loadtxt('data/coco.names', dtype='str', delimiter='\n')
+ b = np.loadtxt('data/coco_paper.names', dtype='str', delimiter='\n')
+ x1 = [list(a[i] == b).index(True) + 1 for i in range(80)] # darknet to coco
+ x2 = [list(b[i] == a).index(True) if any(b[i] == a) else None for i in range(91)] # coco to darknet
+ ```
+ """
+ return [
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 31, 32, 33, 34,
+ 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+ 64, 65, 67, 70, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 89, 90]
+
+
+def convert_coco(labels_dir='../coco/annotations/',
+ save_dir='coco_converted/',
+ use_segments=False,
+ use_keypoints=False,
+ cls91to80=True):
+ """
+ Converts COCO dataset annotations to a YOLO annotation format suitable for training YOLO models.
+
+ Args:
+ labels_dir (str, optional): Path to directory containing COCO dataset annotation files.
+ save_dir (str, optional): Path to directory to save results to.
+ use_segments (bool, optional): Whether to include segmentation masks in the output.
+ use_keypoints (bool, optional): Whether to include keypoint annotations in the output.
+ cls91to80 (bool, optional): Whether to map 91 COCO class IDs to the corresponding 80 COCO class IDs.
+
+ Example:
+ ```python
+ from ultralytics.data.converter import convert_coco
+
+ convert_coco('../datasets/coco/annotations/', use_segments=True, use_keypoints=False, cls91to80=True)
+ ```
+
+ Output:
+ Generates output files in the specified output directory.
+ """
+
+ # Create dataset directory
+ save_dir = increment_path(save_dir) # increment if save directory already exists
+ for p in save_dir / 'labels', save_dir / 'images':
+ p.mkdir(parents=True, exist_ok=True) # make dir
+
+ # Convert classes
+ coco80 = coco91_to_coco80_class()
+
+ # Import json
+ for json_file in sorted(Path(labels_dir).resolve().glob('*.json')):
+ fn = Path(save_dir) / 'labels' / json_file.stem.replace('instances_', '') # folder name
+ fn.mkdir(parents=True, exist_ok=True)
+ with open(json_file) as f:
+ data = json.load(f)
+
+ # Create image dict
+ images = {f'{x["id"]:d}': x for x in data['images']}
+ # Create image-annotations dict
+ imgToAnns = defaultdict(list)
+ for ann in data['annotations']:
+ imgToAnns[ann['image_id']].append(ann)
+
+ # Write labels file
+ for img_id, anns in TQDM(imgToAnns.items(), desc=f'Annotations {json_file}'):
+ img = images[f'{img_id:d}']
+ h, w, f = img['height'], img['width'], img['file_name']
+
+ bboxes = []
+ segments = []
+ keypoints = []
+ for ann in anns:
+ if ann['iscrowd']:
+ continue
+ # The COCO box format is [top left x, top left y, width, height]
+ box = np.array(ann['bbox'], dtype=np.float64)
+ box[:2] += box[2:] / 2 # xy top-left corner to center
+ box[[0, 2]] /= w # normalize x
+ box[[1, 3]] /= h # normalize y
+ if box[2] <= 0 or box[3] <= 0: # if w <= 0 and h <= 0
+ continue
+
+ cls = coco80[ann['category_id'] - 1] if cls91to80 else ann['category_id'] - 1 # class
+ box = [cls] + box.tolist()
+ if box not in bboxes:
+ bboxes.append(box)
+ if use_segments and ann.get('segmentation') is not None:
+ if len(ann['segmentation']) == 0:
+ segments.append([])
+ continue
+ elif len(ann['segmentation']) > 1:
+ s = merge_multi_segment(ann['segmentation'])
+ s = (np.concatenate(s, axis=0) / np.array([w, h])).reshape(-1).tolist()
+ else:
+ s = [j for i in ann['segmentation'] for j in i] # all segments concatenated
+ s = (np.array(s).reshape(-1, 2) / np.array([w, h])).reshape(-1).tolist()
+ s = [cls] + s
+ if s not in segments:
+ segments.append(s)
+ if use_keypoints and ann.get('keypoints') is not None:
+ keypoints.append(box + (np.array(ann['keypoints']).reshape(-1, 3) /
+ np.array([w, h, 1])).reshape(-1).tolist())
+
+ # Write
+ with open((fn / f).with_suffix('.txt'), 'a') as file:
+ for i in range(len(bboxes)):
+ if use_keypoints:
+ line = *(keypoints[i]), # cls, box, keypoints
+ else:
+ line = *(segments[i]
+ if use_segments and len(segments[i]) > 0 else bboxes[i]), # cls, box or segments
+ file.write(('%g ' * len(line)).rstrip() % line + '\n')
+
+ LOGGER.info(f'COCO data converted successfully.\nResults saved to {save_dir.resolve()}')
+
+
+def convert_dota_to_yolo_obb(dota_root_path: str):
+ """
+ Converts DOTA dataset annotations to YOLO OBB (Oriented Bounding Box) format.
+
+ The function processes images in the 'train' and 'val' folders of the DOTA dataset. For each image, it reads the
+ associated label from the original labels directory and writes new labels in YOLO OBB format to a new directory.
+
+ Args:
+ dota_root_path (str): The root directory path of the DOTA dataset.
+
+ Example:
+ ```python
+ from ultralytics.data.converter import convert_dota_to_yolo_obb
+
+ convert_dota_to_yolo_obb('path/to/DOTA')
+ ```
+
+ Notes:
+ The directory structure assumed for the DOTA dataset:
+ - DOTA
+ - images
+ - train
+ - val
+ - labels
+ - train_original
+ - val_original
+
+ After the function execution, the new labels will be saved in:
+ - DOTA
+ - labels
+ - train
+ - val
+ """
+ dota_root_path = Path(dota_root_path)
+
+ # Class names to indices mapping
+ class_mapping = {
+ 'plane': 0,
+ 'ship': 1,
+ 'storage-tank': 2,
+ 'baseball-diamond': 3,
+ 'tennis-court': 4,
+ 'basketball-court': 5,
+ 'ground-track-field': 6,
+ 'harbor': 7,
+ 'bridge': 8,
+ 'large-vehicle': 9,
+ 'small-vehicle': 10,
+ 'helicopter': 11,
+ 'roundabout': 12,
+ 'soccer-ball-field': 13,
+ 'swimming-pool': 14,
+ 'container-crane': 15,
+ 'airport': 16,
+ 'helipad': 17}
+
+ def convert_label(image_name, image_width, image_height, orig_label_dir, save_dir):
+ """Converts a single image's DOTA annotation to YOLO OBB format and saves it to a specified directory."""
+ orig_label_path = orig_label_dir / f'{image_name}.txt'
+ save_path = save_dir / f'{image_name}.txt'
+
+ with orig_label_path.open('r') as f, save_path.open('w') as g:
+ lines = f.readlines()
+ for line in lines:
+ parts = line.strip().split()
+ if len(parts) < 9:
+ continue
+ class_name = parts[8]
+ class_idx = class_mapping[class_name]
+ coords = [float(p) for p in parts[:8]]
+ normalized_coords = [
+ coords[i] / image_width if i % 2 == 0 else coords[i] / image_height for i in range(8)]
+ formatted_coords = ['{:.6g}'.format(coord) for coord in normalized_coords]
+ g.write(f"{class_idx} {' '.join(formatted_coords)}\n")
+
+ for phase in ['train', 'val']:
+ image_dir = dota_root_path / 'images' / phase
+ orig_label_dir = dota_root_path / 'labels' / f'{phase}_original'
+ save_dir = dota_root_path / 'labels' / phase
+
+ save_dir.mkdir(parents=True, exist_ok=True)
+
+ image_paths = list(image_dir.iterdir())
+ for image_path in TQDM(image_paths, desc=f'Processing {phase} images'):
+ if image_path.suffix != '.png':
+ continue
+ image_name_without_ext = image_path.stem
+ img = cv2.imread(str(image_path))
+ h, w = img.shape[:2]
+ convert_label(image_name_without_ext, w, h, orig_label_dir, save_dir)
+
+
+def min_index(arr1, arr2):
+ """
+ Find a pair of indexes with the shortest distance between two arrays of 2D points.
+
+ Args:
+ arr1 (np.array): A NumPy array of shape (N, 2) representing N 2D points.
+ arr2 (np.array): A NumPy array of shape (M, 2) representing M 2D points.
+
+ Returns:
+ (tuple): A tuple containing the indexes of the points with the shortest distance in arr1 and arr2 respectively.
+ """
+ dis = ((arr1[:, None, :] - arr2[None, :, :]) ** 2).sum(-1)
+ return np.unravel_index(np.argmin(dis, axis=None), dis.shape)
+
+
+def merge_multi_segment(segments):
+ """
+ Merge multiple segments into one list by connecting the coordinates with the minimum distance between each segment.
+ This function connects these coordinates with a thin line to merge all segments into one.
+
+ Args:
+ segments (List[List]): Original segmentations in COCO's JSON file.
+ Each element is a list of coordinates, like [segmentation1, segmentation2,...].
+
+ Returns:
+ s (List[np.ndarray]): A list of connected segments represented as NumPy arrays.
+ """
+ s = []
+ segments = [np.array(i).reshape(-1, 2) for i in segments]
+ idx_list = [[] for _ in range(len(segments))]
+
+ # Record the indexes with min distance between each segment
+ for i in range(1, len(segments)):
+ idx1, idx2 = min_index(segments[i - 1], segments[i])
+ idx_list[i - 1].append(idx1)
+ idx_list[i].append(idx2)
+
+ # Use two round to connect all the segments
+ for k in range(2):
+ # Forward connection
+ if k == 0:
+ for i, idx in enumerate(idx_list):
+ # Middle segments have two indexes, reverse the index of middle segments
+ if len(idx) == 2 and idx[0] > idx[1]:
+ idx = idx[::-1]
+ segments[i] = segments[i][::-1, :]
+
+ segments[i] = np.roll(segments[i], -idx[0], axis=0)
+ segments[i] = np.concatenate([segments[i], segments[i][:1]])
+ # Deal with the first segment and the last one
+ if i in [0, len(idx_list) - 1]:
+ s.append(segments[i])
+ else:
+ idx = [0, idx[1] - idx[0]]
+ s.append(segments[i][idx[0]:idx[1] + 1])
+
+ else:
+ for i in range(len(idx_list) - 1, -1, -1):
+ if i not in [0, len(idx_list) - 1]:
+ idx = idx_list[i]
+ nidx = abs(idx[1] - idx[0])
+ s.append(segments[i][nidx:])
+ return s
diff --git a/ultralytics/ultralytics/data/dataset.py b/ultralytics/ultralytics/data/dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..068311efc865fa6553558c8572330b32abed949a
--- /dev/null
+++ b/ultralytics/ultralytics/data/dataset.py
@@ -0,0 +1,340 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+import contextlib
+from itertools import repeat
+from multiprocessing.pool import ThreadPool
+from pathlib import Path
+
+import cv2
+import numpy as np
+import torch
+import torchvision
+
+from ultralytics.utils import LOCAL_RANK, NUM_THREADS, TQDM, colorstr, is_dir_writeable
+
+from .augment import Compose, Format, Instances, LetterBox, classify_albumentations, classify_transforms, v8_transforms
+from .base import BaseDataset
+from .utils import HELP_URL, LOGGER, get_hash, img2label_paths, verify_image, verify_image_label
+
+# Ultralytics dataset *.cache version, >= 1.0.0 for YOLOv8
+DATASET_CACHE_VERSION = '1.0.3'
+
+
+class YOLODataset(BaseDataset):
+ """
+ Dataset class for loading object detection and/or segmentation labels in YOLO format.
+
+ Args:
+ data (dict, optional): A dataset YAML dictionary. Defaults to None.
+ use_segments (bool, optional): If True, segmentation masks are used as labels. Defaults to False.
+ use_keypoints (bool, optional): If True, keypoints are used as labels. Defaults to False.
+
+ Returns:
+ (torch.utils.data.Dataset): A PyTorch dataset object that can be used for training an object detection model.
+ """
+
+ def __init__(self, *args, data=None, use_segments=False, use_keypoints=False, **kwargs):
+ """Initializes the YOLODataset with optional configurations for segments and keypoints."""
+ self.use_segments = use_segments
+ self.use_keypoints = use_keypoints
+ self.data = data
+ assert not (self.use_segments and self.use_keypoints), 'Can not use both segments and keypoints.'
+ super().__init__(*args, **kwargs)
+
+ def cache_labels(self, path=Path('./labels.cache')):
+ """
+ Cache dataset labels, check images and read shapes.
+
+ Args:
+ path (Path): path where to save the cache file (default: Path('./labels.cache')).
+ Returns:
+ (dict): labels.
+ """
+ x = {'labels': []}
+ nm, nf, ne, nc, msgs = 0, 0, 0, 0, [] # number missing, found, empty, corrupt, messages
+ desc = f'{self.prefix}Scanning {path.parent / path.stem}...'
+ total = len(self.im_files)
+ nkpt, ndim = self.data.get('kpt_shape', (0, 0))
+ if self.use_keypoints and (nkpt <= 0 or ndim not in (2, 3)):
+ raise ValueError("'kpt_shape' in data.yaml missing or incorrect. Should be a list with [number of "
+ "keypoints, number of dims (2 for x,y or 3 for x,y,visible)], i.e. 'kpt_shape: [17, 3]'")
+ with ThreadPool(NUM_THREADS) as pool:
+ results = pool.imap(func=verify_image_label,
+ iterable=zip(self.im_files, self.label_files, repeat(self.prefix),
+ repeat(self.use_keypoints), repeat(len(self.data['names'])), repeat(nkpt),
+ repeat(ndim)))
+ pbar = TQDM(results, desc=desc, total=total)
+ for im_file, lb, shape, segments, keypoint, nm_f, nf_f, ne_f, nc_f, msg in pbar:
+ nm += nm_f
+ nf += nf_f
+ ne += ne_f
+ nc += nc_f
+ if im_file:
+ x['labels'].append(
+ dict(
+ im_file=im_file,
+ shape=shape,
+ cls=lb[:, 0:1], # n, 1
+ bboxes=lb[:, 1:], # n, 4
+ segments=segments,
+ keypoints=keypoint,
+ normalized=True,
+ bbox_format='xywh'))
+ if msg:
+ msgs.append(msg)
+ pbar.desc = f'{desc} {nf} images, {nm + ne} backgrounds, {nc} corrupt'
+ pbar.close()
+
+ if msgs:
+ LOGGER.info('\n'.join(msgs))
+ if nf == 0:
+ LOGGER.warning(f'{self.prefix}WARNING ⚠️ No labels found in {path}. {HELP_URL}')
+ x['hash'] = get_hash(self.label_files + self.im_files)
+ x['results'] = nf, nm, ne, nc, len(self.im_files)
+ x['msgs'] = msgs # warnings
+ save_dataset_cache_file(self.prefix, path, x)
+ return x
+
+ def get_labels(self):
+ """Returns dictionary of labels for YOLO training."""
+ self.label_files = img2label_paths(self.im_files)
+ cache_path = Path(self.label_files[0]).parent.with_suffix('.cache')
+ try:
+ cache, exists = load_dataset_cache_file(cache_path), True # attempt to load a *.cache file
+ assert cache['version'] == DATASET_CACHE_VERSION # matches current version
+ assert cache['hash'] == get_hash(self.label_files + self.im_files) # identical hash
+ except (FileNotFoundError, AssertionError, AttributeError):
+ cache, exists = self.cache_labels(cache_path), False # run cache ops
+
+ # Display cache
+ nf, nm, ne, nc, n = cache.pop('results') # found, missing, empty, corrupt, total
+ if exists and LOCAL_RANK in (-1, 0):
+ d = f'Scanning {cache_path}... {nf} images, {nm + ne} backgrounds, {nc} corrupt'
+ TQDM(None, desc=self.prefix + d, total=n, initial=n) # display results
+ if cache['msgs']:
+ LOGGER.info('\n'.join(cache['msgs'])) # display warnings
+
+ # Read cache
+ [cache.pop(k) for k in ('hash', 'version', 'msgs')] # remove items
+ labels = cache['labels']
+ if not labels:
+ LOGGER.warning(f'WARNING ⚠️ No images found in {cache_path}, training may not work correctly. {HELP_URL}')
+ self.im_files = [lb['im_file'] for lb in labels] # update im_files
+
+ # Check if the dataset is all boxes or all segments
+ lengths = ((len(lb['cls']), len(lb['bboxes']), len(lb['segments'])) for lb in labels)
+ len_cls, len_boxes, len_segments = (sum(x) for x in zip(*lengths))
+ if len_segments and len_boxes != len_segments:
+ LOGGER.warning(
+ f'WARNING ⚠️ Box and segment counts should be equal, but got len(segments) = {len_segments}, '
+ f'len(boxes) = {len_boxes}. To resolve this only boxes will be used and all segments will be removed. '
+ 'To avoid this please supply either a detect or segment dataset, not a detect-segment mixed dataset.')
+ for lb in labels:
+ lb['segments'] = []
+ if len_cls == 0:
+ LOGGER.warning(f'WARNING ⚠️ No labels found in {cache_path}, training may not work correctly. {HELP_URL}')
+ return labels
+
+ def build_transforms(self, hyp=None):
+ """Builds and appends transforms to the list."""
+ if self.augment:
+ hyp.mosaic = hyp.mosaic if self.augment and not self.rect else 0.0
+ hyp.mixup = hyp.mixup if self.augment and not self.rect else 0.0
+ transforms = v8_transforms(self, self.imgsz, hyp)
+ else:
+ transforms = Compose([LetterBox(new_shape=(self.imgsz, self.imgsz), scaleup=False)])
+ transforms.append(
+ Format(bbox_format='xywh',
+ normalize=True,
+ return_mask=self.use_segments,
+ return_keypoint=self.use_keypoints,
+ batch_idx=True,
+ mask_ratio=hyp.mask_ratio,
+ mask_overlap=hyp.overlap_mask))
+ return transforms
+
+ def close_mosaic(self, hyp):
+ """Sets mosaic, copy_paste and mixup options to 0.0 and builds transformations."""
+ hyp.mosaic = 0.0 # set mosaic ratio=0.0
+ hyp.copy_paste = 0.0 # keep the same behavior as previous v8 close-mosaic
+ hyp.mixup = 0.0 # keep the same behavior as previous v8 close-mosaic
+ self.transforms = self.build_transforms(hyp)
+
+ def update_labels_info(self, label):
+ """Custom your label format here."""
+ # NOTE: cls is not with bboxes now, classification and semantic segmentation need an independent cls label
+ # We can make it also support classification and semantic segmentation by add or remove some dict keys there.
+ bboxes = label.pop('bboxes')
+ segments = label.pop('segments')
+ keypoints = label.pop('keypoints', None)
+ bbox_format = label.pop('bbox_format')
+ normalized = label.pop('normalized')
+ label['instances'] = Instances(bboxes, segments, keypoints, bbox_format=bbox_format, normalized=normalized)
+ return label
+
+ @staticmethod
+ def collate_fn(batch):
+ """Collates data samples into batches."""
+ new_batch = {}
+ keys = batch[0].keys()
+ values = list(zip(*[list(b.values()) for b in batch]))
+ for i, k in enumerate(keys):
+ value = values[i]
+ if k == 'img':
+ value = torch.stack(value, 0)
+ if k in ['masks', 'keypoints', 'bboxes', 'cls']:
+ value = torch.cat(value, 0)
+ new_batch[k] = value
+ new_batch['batch_idx'] = list(new_batch['batch_idx'])
+ for i in range(len(new_batch['batch_idx'])):
+ new_batch['batch_idx'][i] += i # add target image index for build_targets()
+ new_batch['batch_idx'] = torch.cat(new_batch['batch_idx'], 0)
+ return new_batch
+
+
+# Classification dataloaders -------------------------------------------------------------------------------------------
+class ClassificationDataset(torchvision.datasets.ImageFolder):
+ """
+ YOLO Classification Dataset.
+
+ Args:
+ root (str): Dataset path.
+
+ Attributes:
+ cache_ram (bool): True if images should be cached in RAM, False otherwise.
+ cache_disk (bool): True if images should be cached on disk, False otherwise.
+ samples (list): List of samples containing file, index, npy, and im.
+ torch_transforms (callable): torchvision transforms applied to the dataset.
+ album_transforms (callable, optional): Albumentations transforms applied to the dataset if augment is True.
+ """
+
+ def __init__(self, root, args, augment=False, cache=False, prefix=''):
+ """
+ Initialize YOLO object with root, image size, augmentations, and cache settings.
+
+ Args:
+ root (str): Dataset path.
+ args (Namespace): Argument parser containing dataset related settings.
+ augment (bool, optional): True if dataset should be augmented, False otherwise. Defaults to False.
+ cache (bool | str | optional): Cache setting, can be True, False, 'ram' or 'disk'. Defaults to False.
+ """
+ super().__init__(root=root)
+ if augment and args.fraction < 1.0: # reduce training fraction
+ self.samples = self.samples[:round(len(self.samples) * args.fraction)]
+ self.prefix = colorstr(f'{prefix}: ') if prefix else ''
+ self.cache_ram = cache is True or cache == 'ram'
+ self.cache_disk = cache == 'disk'
+ self.samples = self.verify_images() # filter out bad images
+ self.samples = [list(x) + [Path(x[0]).with_suffix('.npy'), None] for x in self.samples] # file, index, npy, im
+ self.torch_transforms = classify_transforms(args.imgsz, rect=args.rect)
+ self.album_transforms = classify_albumentations(
+ augment=augment,
+ size=args.imgsz,
+ scale=(1.0 - args.scale, 1.0), # (0.08, 1.0)
+ hflip=args.fliplr,
+ vflip=args.flipud,
+ hsv_h=args.hsv_h, # HSV-Hue augmentation (fraction)
+ hsv_s=args.hsv_s, # HSV-Saturation augmentation (fraction)
+ hsv_v=args.hsv_v, # HSV-Value augmentation (fraction)
+ mean=(0.0, 0.0, 0.0), # IMAGENET_MEAN
+ std=(1.0, 1.0, 1.0), # IMAGENET_STD
+ auto_aug=False) if augment else None
+
+ def __getitem__(self, i):
+ """Returns subset of data and targets corresponding to given indices."""
+ f, j, fn, im = self.samples[i] # filename, index, filename.with_suffix('.npy'), image
+ if self.cache_ram and im is None:
+ im = self.samples[i][3] = cv2.imread(f)
+ elif self.cache_disk:
+ if not fn.exists(): # load npy
+ np.save(fn.as_posix(), cv2.imread(f), allow_pickle=False)
+ im = np.load(fn)
+ else: # read image
+ im = cv2.imread(f) # BGR
+ if self.album_transforms:
+ sample = self.album_transforms(image=cv2.cvtColor(im, cv2.COLOR_BGR2RGB))['image']
+ else:
+ sample = self.torch_transforms(im)
+ return {'img': sample, 'cls': j}
+
+ def __len__(self) -> int:
+ """Return the total number of samples in the dataset."""
+ return len(self.samples)
+
+ def verify_images(self):
+ """Verify all images in dataset."""
+ desc = f'{self.prefix}Scanning {self.root}...'
+ path = Path(self.root).with_suffix('.cache') # *.cache file path
+
+ with contextlib.suppress(FileNotFoundError, AssertionError, AttributeError):
+ cache = load_dataset_cache_file(path) # attempt to load a *.cache file
+ assert cache['version'] == DATASET_CACHE_VERSION # matches current version
+ assert cache['hash'] == get_hash([x[0] for x in self.samples]) # identical hash
+ nf, nc, n, samples = cache.pop('results') # found, missing, empty, corrupt, total
+ if LOCAL_RANK in (-1, 0):
+ d = f'{desc} {nf} images, {nc} corrupt'
+ TQDM(None, desc=d, total=n, initial=n)
+ if cache['msgs']:
+ LOGGER.info('\n'.join(cache['msgs'])) # display warnings
+ return samples
+
+ # Run scan if *.cache retrieval failed
+ nf, nc, msgs, samples, x = 0, 0, [], [], {}
+ with ThreadPool(NUM_THREADS) as pool:
+ results = pool.imap(func=verify_image, iterable=zip(self.samples, repeat(self.prefix)))
+ pbar = TQDM(results, desc=desc, total=len(self.samples))
+ for sample, nf_f, nc_f, msg in pbar:
+ if nf_f:
+ samples.append(sample)
+ if msg:
+ msgs.append(msg)
+ nf += nf_f
+ nc += nc_f
+ pbar.desc = f'{desc} {nf} images, {nc} corrupt'
+ pbar.close()
+ if msgs:
+ LOGGER.info('\n'.join(msgs))
+ x['hash'] = get_hash([x[0] for x in self.samples])
+ x['results'] = nf, nc, len(samples), samples
+ x['msgs'] = msgs # warnings
+ save_dataset_cache_file(self.prefix, path, x)
+ return samples
+
+
+def load_dataset_cache_file(path):
+ """Load an Ultralytics *.cache dictionary from path."""
+ import gc
+ gc.disable() # reduce pickle load time https://github.com/ultralytics/ultralytics/pull/1585
+ cache = np.load(str(path), allow_pickle=True).item() # load dict
+ gc.enable()
+ return cache
+
+
+def save_dataset_cache_file(prefix, path, x):
+ """Save an Ultralytics dataset *.cache dictionary x to path."""
+ x['version'] = DATASET_CACHE_VERSION # add cache version
+ if is_dir_writeable(path.parent):
+ if path.exists():
+ path.unlink() # remove *.cache file if exists
+ np.save(str(path), x) # save cache for next time
+ path.with_suffix('.cache.npy').rename(path) # remove .npy suffix
+ LOGGER.info(f'{prefix}New cache created: {path}')
+ else:
+ LOGGER.warning(f'{prefix}WARNING ⚠️ Cache directory {path.parent} is not writeable, cache not saved.')
+
+
+# TODO: support semantic segmentation
+class SemanticDataset(BaseDataset):
+ """
+ Semantic Segmentation Dataset.
+
+ This class is responsible for handling datasets used for semantic segmentation tasks. It inherits functionalities
+ from the BaseDataset class.
+
+ Note:
+ This class is currently a placeholder and needs to be populated with methods and attributes for supporting
+ semantic segmentation tasks.
+ """
+
+ def __init__(self):
+ """Initialize a SemanticDataset object."""
+ super().__init__()
diff --git a/ultralytics/ultralytics/data/loaders.py b/ultralytics/ultralytics/data/loaders.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcf4fbefb4e224aa9f2b3cf66479878f0b249377
--- /dev/null
+++ b/ultralytics/ultralytics/data/loaders.py
@@ -0,0 +1,523 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import glob
+import math
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from threading import Thread
+from urllib.parse import urlparse
+
+import cv2
+import numpy as np
+import requests
+import torch
+from PIL import Image
+
+from ultralytics.data.utils import IMG_FORMATS, VID_FORMATS
+from ultralytics.utils import LOGGER, is_colab, is_kaggle, ops
+from ultralytics.utils.checks import check_requirements
+
+
+@dataclass
+class SourceTypes:
+ """Class to represent various types of input sources for predictions."""
+ webcam: bool = False
+ screenshot: bool = False
+ from_img: bool = False
+ tensor: bool = False
+
+
+class LoadStreams:
+ """
+ Stream Loader for various types of video streams.
+
+ Suitable for use with `yolo predict source='rtsp://example.com/media.mp4'`, supports RTSP, RTMP, HTTP, and TCP streams.
+
+ Attributes:
+ sources (str): The source input paths or URLs for the video streams.
+ imgsz (int): The image size for processing, defaults to 640.
+ vid_stride (int): Video frame-rate stride, defaults to 1.
+ buffer (bool): Whether to buffer input streams, defaults to False.
+ running (bool): Flag to indicate if the streaming thread is running.
+ mode (str): Set to 'stream' indicating real-time capture.
+ imgs (list): List of image frames for each stream.
+ fps (list): List of FPS for each stream.
+ frames (list): List of total frames for each stream.
+ threads (list): List of threads for each stream.
+ shape (list): List of shapes for each stream.
+ caps (list): List of cv2.VideoCapture objects for each stream.
+ bs (int): Batch size for processing.
+
+ Methods:
+ __init__: Initialize the stream loader.
+ update: Read stream frames in daemon thread.
+ close: Close stream loader and release resources.
+ __iter__: Returns an iterator object for the class.
+ __next__: Returns source paths, transformed, and original images for processing.
+ __len__: Return the length of the sources object.
+ """
+
+ def __init__(self, sources='file.streams', imgsz=640, vid_stride=1, buffer=False):
+ """Initialize instance variables and check for consistent input stream shapes."""
+ torch.backends.cudnn.benchmark = True # faster for fixed-size inference
+ self.buffer = buffer # buffer input streams
+ self.running = True # running flag for Thread
+ self.mode = 'stream'
+ self.imgsz = imgsz
+ self.vid_stride = vid_stride # video frame-rate stride
+ sources = Path(sources).read_text().rsplit() if os.path.isfile(sources) else [sources]
+ n = len(sources)
+ self.sources = [ops.clean_str(x) for x in sources] # clean source names for later
+ self.imgs, self.fps, self.frames, self.threads, self.shape = [[]] * n, [0] * n, [0] * n, [None] * n, [[]] * n
+ self.caps = [None] * n # video capture objects
+ for i, s in enumerate(sources): # index, source
+ # Start thread to read frames from video stream
+ st = f'{i + 1}/{n}: {s}... '
+ if urlparse(s).hostname in ('www.youtube.com', 'youtube.com', 'youtu.be'): # if source is YouTube video
+ # YouTube format i.e. 'https://www.youtube.com/watch?v=Zgi9g1ksQHc' or 'https://youtu.be/LNwODJXcvt4'
+ s = get_best_youtube_url(s)
+ s = eval(s) if s.isnumeric() else s # i.e. s = '0' local webcam
+ if s == 0 and (is_colab() or is_kaggle()):
+ raise NotImplementedError("'source=0' webcam not supported in Colab and Kaggle notebooks. "
+ "Try running 'source=0' in a local environment.")
+ self.caps[i] = cv2.VideoCapture(s) # store video capture object
+ if not self.caps[i].isOpened():
+ raise ConnectionError(f'{st}Failed to open {s}')
+ w = int(self.caps[i].get(cv2.CAP_PROP_FRAME_WIDTH))
+ h = int(self.caps[i].get(cv2.CAP_PROP_FRAME_HEIGHT))
+ fps = self.caps[i].get(cv2.CAP_PROP_FPS) # warning: may return 0 or nan
+ self.frames[i] = max(int(self.caps[i].get(cv2.CAP_PROP_FRAME_COUNT)), 0) or float(
+ 'inf') # infinite stream fallback
+ self.fps[i] = max((fps if math.isfinite(fps) else 0) % 100, 0) or 30 # 30 FPS fallback
+
+ success, im = self.caps[i].read() # guarantee first frame
+ if not success or im is None:
+ raise ConnectionError(f'{st}Failed to read images from {s}')
+ self.imgs[i].append(im)
+ self.shape[i] = im.shape
+ self.threads[i] = Thread(target=self.update, args=([i, self.caps[i], s]), daemon=True)
+ LOGGER.info(f'{st}Success ✅ ({self.frames[i]} frames of shape {w}x{h} at {self.fps[i]:.2f} FPS)')
+ self.threads[i].start()
+ LOGGER.info('') # newline
+
+ # Check for common shapes
+ self.bs = self.__len__()
+
+ def update(self, i, cap, stream):
+ """Read stream `i` frames in daemon thread."""
+ n, f = 0, self.frames[i] # frame number, frame array
+ while self.running and cap.isOpened() and n < (f - 1):
+ if len(self.imgs[i]) < 30: # keep a <=30-image buffer
+ n += 1
+ cap.grab() # .read() = .grab() followed by .retrieve()
+ if n % self.vid_stride == 0:
+ success, im = cap.retrieve()
+ if not success:
+ im = np.zeros(self.shape[i], dtype=np.uint8)
+ LOGGER.warning('WARNING ⚠️ Video stream unresponsive, please check your IP camera connection.')
+ cap.open(stream) # re-open stream if signal was lost
+ if self.buffer:
+ self.imgs[i].append(im)
+ else:
+ self.imgs[i] = [im]
+ else:
+ time.sleep(0.01) # wait until the buffer is empty
+
+ def close(self):
+ """Close stream loader and release resources."""
+ self.running = False # stop flag for Thread
+ for thread in self.threads:
+ if thread.is_alive():
+ thread.join(timeout=5) # Add timeout
+ for cap in self.caps: # Iterate through the stored VideoCapture objects
+ try:
+ cap.release() # release video capture
+ except Exception as e:
+ LOGGER.warning(f'WARNING ⚠️ Could not release VideoCapture object: {e}')
+ cv2.destroyAllWindows()
+
+ def __iter__(self):
+ """Iterates through YOLO image feed and re-opens unresponsive streams."""
+ self.count = -1
+ return self
+
+ def __next__(self):
+ """Returns source paths, transformed and original images for processing."""
+ self.count += 1
+
+ images = []
+ for i, x in enumerate(self.imgs):
+
+ # Wait until a frame is available in each buffer
+ while not x:
+ if not self.threads[i].is_alive() or cv2.waitKey(1) == ord('q'): # q to quit
+ self.close()
+ raise StopIteration
+ time.sleep(1 / min(self.fps))
+ x = self.imgs[i]
+ if not x:
+ LOGGER.warning(f'WARNING ⚠️ Waiting for stream {i}')
+
+ # Get and remove the first frame from imgs buffer
+ if self.buffer:
+ images.append(x.pop(0))
+
+ # Get the last frame, and clear the rest from the imgs buffer
+ else:
+ images.append(x.pop(-1) if x else np.zeros(self.shape[i], dtype=np.uint8))
+ x.clear()
+
+ return self.sources, images, None, ''
+
+ def __len__(self):
+ """Return the length of the sources object."""
+ return len(self.sources) # 1E12 frames = 32 streams at 30 FPS for 30 years
+
+
+class LoadScreenshots:
+ """
+ YOLOv8 screenshot dataloader.
+
+ This class manages the loading of screenshot images for processing with YOLOv8.
+ Suitable for use with `yolo predict source=screen`.
+
+ Attributes:
+ source (str): The source input indicating which screen to capture.
+ imgsz (int): The image size for processing, defaults to 640.
+ screen (int): The screen number to capture.
+ left (int): The left coordinate for screen capture area.
+ top (int): The top coordinate for screen capture area.
+ width (int): The width of the screen capture area.
+ height (int): The height of the screen capture area.
+ mode (str): Set to 'stream' indicating real-time capture.
+ frame (int): Counter for captured frames.
+ sct (mss.mss): Screen capture object from `mss` library.
+ bs (int): Batch size, set to 1.
+ monitor (dict): Monitor configuration details.
+
+ Methods:
+ __iter__: Returns an iterator object.
+ __next__: Captures the next screenshot and returns it.
+ """
+
+ def __init__(self, source, imgsz=640):
+ """Source = [screen_number left top width height] (pixels)."""
+ check_requirements('mss')
+ import mss # noqa
+
+ source, *params = source.split()
+ self.screen, left, top, width, height = 0, None, None, None, None # default to full screen 0
+ if len(params) == 1:
+ self.screen = int(params[0])
+ elif len(params) == 4:
+ left, top, width, height = (int(x) for x in params)
+ elif len(params) == 5:
+ self.screen, left, top, width, height = (int(x) for x in params)
+ self.imgsz = imgsz
+ self.mode = 'stream'
+ self.frame = 0
+ self.sct = mss.mss()
+ self.bs = 1
+
+ # Parse monitor shape
+ monitor = self.sct.monitors[self.screen]
+ self.top = monitor['top'] if top is None else (monitor['top'] + top)
+ self.left = monitor['left'] if left is None else (monitor['left'] + left)
+ self.width = width or monitor['width']
+ self.height = height or monitor['height']
+ self.monitor = {'left': self.left, 'top': self.top, 'width': self.width, 'height': self.height}
+
+ def __iter__(self):
+ """Returns an iterator of the object."""
+ return self
+
+ def __next__(self):
+ """mss screen capture: get raw pixels from the screen as np array."""
+ im0 = np.asarray(self.sct.grab(self.monitor))[:, :, :3] # BGRA to BGR
+ s = f'screen {self.screen} (LTWH): {self.left},{self.top},{self.width},{self.height}: '
+
+ self.frame += 1
+ return [str(self.screen)], [im0], None, s # screen, img, vid_cap, string
+
+
+class LoadImages:
+ """
+ YOLOv8 image/video dataloader.
+
+ This class manages the loading and pre-processing of image and video data for YOLOv8. It supports loading from
+ various formats, including single image files, video files, and lists of image and video paths.
+
+ Attributes:
+ imgsz (int): Image size, defaults to 640.
+ files (list): List of image and video file paths.
+ nf (int): Total number of files (images and videos).
+ video_flag (list): Flags indicating whether a file is a video (True) or an image (False).
+ mode (str): Current mode, 'image' or 'video'.
+ vid_stride (int): Stride for video frame-rate, defaults to 1.
+ bs (int): Batch size, set to 1 for this class.
+ cap (cv2.VideoCapture): Video capture object for OpenCV.
+ frame (int): Frame counter for video.
+ frames (int): Total number of frames in the video.
+ count (int): Counter for iteration, initialized at 0 during `__iter__()`.
+
+ Methods:
+ _new_video(path): Create a new cv2.VideoCapture object for a given video path.
+ """
+
+ def __init__(self, path, imgsz=640, vid_stride=1):
+ """Initialize the Dataloader and raise FileNotFoundError if file not found."""
+ parent = None
+ if isinstance(path, str) and Path(path).suffix == '.txt': # *.txt file with img/vid/dir on each line
+ parent = Path(path).parent
+ path = Path(path).read_text().splitlines() # list of sources
+ files = []
+ for p in sorted(path) if isinstance(path, (list, tuple)) else [path]:
+ a = str(Path(p).absolute()) # do not use .resolve() https://github.com/ultralytics/ultralytics/issues/2912
+ if '*' in a:
+ files.extend(sorted(glob.glob(a, recursive=True))) # glob
+ elif os.path.isdir(a):
+ files.extend(sorted(glob.glob(os.path.join(a, '*.*')))) # dir
+ elif os.path.isfile(a):
+ files.append(a) # files (absolute or relative to CWD)
+ elif parent and (parent / p).is_file():
+ files.append(str((parent / p).absolute())) # files (relative to *.txt file parent)
+ else:
+ raise FileNotFoundError(f'{p} does not exist')
+
+ images = [x for x in files if x.split('.')[-1].lower() in IMG_FORMATS]
+ videos = [x for x in files if x.split('.')[-1].lower() in VID_FORMATS]
+ ni, nv = len(images), len(videos)
+
+ self.imgsz = imgsz
+ self.files = images + videos
+ self.nf = ni + nv # number of files
+ self.video_flag = [False] * ni + [True] * nv
+ self.mode = 'image'
+ self.vid_stride = vid_stride # video frame-rate stride
+ self.bs = 1
+ if any(videos):
+ self._new_video(videos[0]) # new video
+ else:
+ self.cap = None
+ if self.nf == 0:
+ raise FileNotFoundError(f'No images or videos found in {p}. '
+ f'Supported formats are:\nimages: {IMG_FORMATS}\nvideos: {VID_FORMATS}')
+
+ def __iter__(self):
+ """Returns an iterator object for VideoStream or ImageFolder."""
+ self.count = 0
+ return self
+
+ def __next__(self):
+ """Return next image, path and metadata from dataset."""
+ if self.count == self.nf:
+ raise StopIteration
+ path = self.files[self.count]
+
+ if self.video_flag[self.count]:
+ # Read video
+ self.mode = 'video'
+ for _ in range(self.vid_stride):
+ self.cap.grab()
+ success, im0 = self.cap.retrieve()
+ while not success:
+ self.count += 1
+ self.cap.release()
+ if self.count == self.nf: # last video
+ raise StopIteration
+ path = self.files[self.count]
+ self._new_video(path)
+ success, im0 = self.cap.read()
+
+ self.frame += 1
+ # im0 = self._cv2_rotate(im0) # for use if cv2 autorotation is False
+ s = f'video {self.count + 1}/{self.nf} ({self.frame}/{self.frames}) {path}: '
+
+ else:
+ # Read image
+ self.count += 1
+ im0 = cv2.imread(path) # BGR
+ if im0 is None:
+ raise FileNotFoundError(f'Image Not Found {path}')
+ s = f'image {self.count}/{self.nf} {path}: '
+
+ return [path], [im0], self.cap, s
+
+ def _new_video(self, path):
+ """Create a new video capture object."""
+ self.frame = 0
+ self.cap = cv2.VideoCapture(path)
+ self.frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT) / self.vid_stride)
+
+ def __len__(self):
+ """Returns the number of files in the object."""
+ return self.nf # number of files
+
+
+class LoadPilAndNumpy:
+ """
+ Load images from PIL and Numpy arrays for batch processing.
+
+ This class is designed to manage loading and pre-processing of image data from both PIL and Numpy formats.
+ It performs basic validation and format conversion to ensure that the images are in the required format for
+ downstream processing.
+
+ Attributes:
+ paths (list): List of image paths or autogenerated filenames.
+ im0 (list): List of images stored as Numpy arrays.
+ imgsz (int): Image size, defaults to 640.
+ mode (str): Type of data being processed, defaults to 'image'.
+ bs (int): Batch size, equivalent to the length of `im0`.
+ count (int): Counter for iteration, initialized at 0 during `__iter__()`.
+
+ Methods:
+ _single_check(im): Validate and format a single image to a Numpy array.
+ """
+
+ def __init__(self, im0, imgsz=640):
+ """Initialize PIL and Numpy Dataloader."""
+ if not isinstance(im0, list):
+ im0 = [im0]
+ self.paths = [getattr(im, 'filename', f'image{i}.jpg') for i, im in enumerate(im0)]
+ self.im0 = [self._single_check(im) for im in im0]
+ self.imgsz = imgsz
+ self.mode = 'image'
+ # Generate fake paths
+ self.bs = len(self.im0)
+
+ @staticmethod
+ def _single_check(im):
+ """Validate and format an image to numpy array."""
+ assert isinstance(im, (Image.Image, np.ndarray)), f'Expected PIL/np.ndarray image type, but got {type(im)}'
+ if isinstance(im, Image.Image):
+ if im.mode != 'RGB':
+ im = im.convert('RGB')
+ im = np.asarray(im)[:, :, ::-1]
+ im = np.ascontiguousarray(im) # contiguous
+ return im
+
+ def __len__(self):
+ """Returns the length of the 'im0' attribute."""
+ return len(self.im0)
+
+ def __next__(self):
+ """Returns batch paths, images, processed images, None, ''."""
+ if self.count == 1: # loop only once as it's batch inference
+ raise StopIteration
+ self.count += 1
+ return self.paths, self.im0, None, ''
+
+ def __iter__(self):
+ """Enables iteration for class LoadPilAndNumpy."""
+ self.count = 0
+ return self
+
+
+class LoadTensor:
+ """
+ Load images from torch.Tensor data.
+
+ This class manages the loading and pre-processing of image data from PyTorch tensors for further processing.
+
+ Attributes:
+ im0 (torch.Tensor): The input tensor containing the image(s).
+ bs (int): Batch size, inferred from the shape of `im0`.
+ mode (str): Current mode, set to 'image'.
+ paths (list): List of image paths or filenames.
+ count (int): Counter for iteration, initialized at 0 during `__iter__()`.
+
+ Methods:
+ _single_check(im, stride): Validate and possibly modify the input tensor.
+ """
+
+ def __init__(self, im0) -> None:
+ """Initialize Tensor Dataloader."""
+ self.im0 = self._single_check(im0)
+ self.bs = self.im0.shape[0]
+ self.mode = 'image'
+ self.paths = [getattr(im, 'filename', f'image{i}.jpg') for i, im in enumerate(im0)]
+
+ @staticmethod
+ def _single_check(im, stride=32):
+ """Validate and format an image to torch.Tensor."""
+ s = f'WARNING ⚠️ torch.Tensor inputs should be BCHW i.e. shape(1, 3, 640, 640) ' \
+ f'divisible by stride {stride}. Input shape{tuple(im.shape)} is incompatible.'
+ if len(im.shape) != 4:
+ if len(im.shape) != 3:
+ raise ValueError(s)
+ LOGGER.warning(s)
+ im = im.unsqueeze(0)
+ if im.shape[2] % stride or im.shape[3] % stride:
+ raise ValueError(s)
+ if im.max() > 1.0 + torch.finfo(im.dtype).eps: # torch.float32 eps is 1.2e-07
+ LOGGER.warning(f'WARNING ⚠️ torch.Tensor inputs should be normalized 0.0-1.0 but max value is {im.max()}. '
+ f'Dividing input by 255.')
+ im = im.float() / 255.0
+
+ return im
+
+ def __iter__(self):
+ """Returns an iterator object."""
+ self.count = 0
+ return self
+
+ def __next__(self):
+ """Return next item in the iterator."""
+ if self.count == 1:
+ raise StopIteration
+ self.count += 1
+ return self.paths, self.im0, None, ''
+
+ def __len__(self):
+ """Returns the batch size."""
+ return self.bs
+
+
+def autocast_list(source):
+ """Merges a list of source of different types into a list of numpy arrays or PIL images."""
+ files = []
+ for im in source:
+ if isinstance(im, (str, Path)): # filename or uri
+ files.append(Image.open(requests.get(im, stream=True).raw if str(im).startswith('http') else im))
+ elif isinstance(im, (Image.Image, np.ndarray)): # PIL or np Image
+ files.append(im)
+ else:
+ raise TypeError(f'type {type(im).__name__} is not a supported Ultralytics prediction source type. \n'
+ f'See https://docs.ultralytics.com/modes/predict for supported source types.')
+
+ return files
+
+
+LOADERS = LoadStreams, LoadPilAndNumpy, LoadImages, LoadScreenshots # tuple
+
+
+def get_best_youtube_url(url, use_pafy=False):
+ """
+ Retrieves the URL of the best quality MP4 video stream from a given YouTube video.
+
+ This function uses the pafy or yt_dlp library to extract the video info from YouTube. It then finds the highest
+ quality MP4 format that has video codec but no audio codec, and returns the URL of this video stream.
+
+ Args:
+ url (str): The URL of the YouTube video.
+ use_pafy (bool): Use the pafy package, default=True, otherwise use yt_dlp package.
+
+ Returns:
+ (str): The URL of the best quality MP4 video stream, or None if no suitable stream is found.
+ """
+ if use_pafy:
+ check_requirements(('pafy', 'youtube_dl==2020.12.2'))
+ import pafy # noqa
+ return pafy.new(url).getbestvideo(preftype='mp4').url
+ else:
+ check_requirements('yt-dlp')
+ import yt_dlp
+ with yt_dlp.YoutubeDL({'quiet': True}) as ydl:
+ info_dict = ydl.extract_info(url, download=False) # extract info
+ for f in reversed(info_dict.get('formats', [])): # reversed because best is usually last
+ # Find a format with video codec, no audio, *.mp4 extension at least 1920x1080 size
+ good_size = (f.get('width') or 0) >= 1920 or (f.get('height') or 0) >= 1080
+ if good_size and f['vcodec'] != 'none' and f['acodec'] == 'none' and f['ext'] == 'mp4':
+ return f.get('url')
diff --git a/ultralytics/ultralytics/data/scripts/download_weights.sh b/ultralytics/ultralytics/data/scripts/download_weights.sh
new file mode 100644
index 0000000000000000000000000000000000000000..87db31fe1e673146b0dbe2c3a318a01b709b7c14
--- /dev/null
+++ b/ultralytics/ultralytics/data/scripts/download_weights.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Download latest models from https://github.com/ultralytics/assets/releases
+# Example usage: bash ultralytics/data/scripts/download_weights.sh
+# parent
+# └── weights
+# ├── yolov8n.pt ← downloads here
+# ├── yolov8s.pt
+# └── ...
+
+python - <
+
+Object tracking in the realm of video analytics is a critical task that not only identifies the location and class of objects within the frame but also maintains a unique ID for each detected object as the video progresses. The applications are limitless—ranging from surveillance and security to real-time sports analytics.
+
+## Why Choose Ultralytics YOLO for Object Tracking?
+
+The output from Ultralytics trackers is consistent with standard object detection but has the added value of object IDs. This makes it easy to track objects in video streams and perform subsequent analytics. Here's why you should consider using Ultralytics YOLO for your object tracking needs:
+
+- **Efficiency:** Process video streams in real-time without compromising accuracy.
+- **Flexibility:** Supports multiple tracking algorithms and configurations.
+- **Ease of Use:** Simple Python API and CLI options for quick integration and deployment.
+- **Customizability:** Easy to use with custom trained YOLO models, allowing integration into domain-specific applications.
+
+**Video Tutorial:** [Object Detection and Tracking with Ultralytics YOLOv8](https://www.youtube.com/embed/hHyHmOtmEgs?si=VNZtXmm45Nb9s-N-).
+
+## Features at a Glance
+
+Ultralytics YOLO extends its object detection features to provide robust and versatile object tracking:
+
+- **Real-Time Tracking:** Seamlessly track objects in high-frame-rate videos.
+- **Multiple Tracker Support:** Choose from a variety of established tracking algorithms.
+- **Customizable Tracker Configurations:** Tailor the tracking algorithm to meet specific requirements by adjusting various parameters.
+
+## Available Trackers
+
+Ultralytics YOLO supports the following tracking algorithms. They can be enabled by passing the relevant YAML configuration file such as `tracker=tracker_type.yaml`:
+
+- [BoT-SORT](https://github.com/NirAharon/BoT-SORT) - Use `botsort.yaml` to enable this tracker.
+- [ByteTrack](https://github.com/ifzhang/ByteTrack) - Use `bytetrack.yaml` to enable this tracker.
+
+The default tracker is BoT-SORT.
+
+## Tracking
+
+To run the tracker on video streams, use a trained Detect, Segment or Pose model such as YOLOv8n, YOLOv8n-seg and YOLOv8n-pose.
+
+#### Python
+
+```python
+from ultralytics import YOLO
+
+# Load an official or custom model
+model = YOLO("yolov8n.pt") # Load an official Detect model
+model = YOLO("yolov8n-seg.pt") # Load an official Segment model
+model = YOLO("yolov8n-pose.pt") # Load an official Pose model
+model = YOLO("path/to/best.pt") # Load a custom trained model
+
+# Perform tracking with the model
+results = model.track(
+ source="https://youtu.be/LNwODJXcvt4", show=True
+) # Tracking with default tracker
+results = model.track(
+ source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml"
+) # Tracking with ByteTrack tracker
+```
+
+#### CLI
+
+```bash
+# Perform tracking with various models using the command line interface
+yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" # Official Detect model
+yolo track model=yolov8n-seg.pt source="https://youtu.be/LNwODJXcvt4" # Official Segment model
+yolo track model=yolov8n-pose.pt source="https://youtu.be/LNwODJXcvt4" # Official Pose model
+yolo track model=path/to/best.pt source="https://youtu.be/LNwODJXcvt4" # Custom trained model
+
+# Track using ByteTrack tracker
+yolo track model=path/to/best.pt tracker="bytetrack.yaml"
+```
+
+As can be seen in the above usage, tracking is available for all Detect, Segment and Pose models run on videos or streaming sources.
+
+## Configuration
+
+### Tracking Arguments
+
+Tracking configuration shares properties with Predict mode, such as `conf`, `iou`, and `show`. For further configurations, refer to the [Predict](https://docs.ultralytics.com/modes/predict/) model page.
+
+#### Python
+
+```python
+from ultralytics import YOLO
+
+# Configure the tracking parameters and run the tracker
+model = YOLO("yolov8n.pt")
+results = model.track(
+ source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True
+)
+```
+
+#### CLI
+
+```bash
+# Configure tracking parameters and run the tracker using the command line interface
+yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
+```
+
+### Tracker Selection
+
+Ultralytics also allows you to use a modified tracker configuration file. To do this, simply make a copy of a tracker config file (for example, `custom_tracker.yaml`) from [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) and modify any configurations (except the `tracker_type`) as per your needs.
+
+#### Python
+
+```python
+from ultralytics import YOLO
+
+# Load the model and run the tracker with a custom configuration file
+model = YOLO("yolov8n.pt")
+results = model.track(
+ source="https://youtu.be/LNwODJXcvt4", tracker="custom_tracker.yaml"
+)
+```
+
+#### CLI
+
+```bash
+# Load the model and run the tracker with a custom configuration file using the command line interface
+yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" tracker='custom_tracker.yaml'
+```
+
+For a comprehensive list of tracking arguments, refer to the [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers) page.
+
+## Python Examples
+
+### Persisting Tracks Loop
+
+Here is a Python script using OpenCV (`cv2`) and YOLOv8 to run object tracking on video frames. This script still assumes you have already installed the necessary packages (`opencv-python` and `ultralytics`). The `persist=True` argument tells the tracker than the current image or frame is the next in a sequence and to expect tracks from the previous image in the current image.
+
+#### Python
+
+```python
+import cv2
+from ultralytics import YOLO
+
+# Load the YOLOv8 model
+model = YOLO("yolov8n.pt")
+
+# Open the video file
+video_path = "path/to/video.mp4"
+cap = cv2.VideoCapture(video_path)
+
+# Loop through the video frames
+while cap.isOpened():
+ # Read a frame from the video
+ success, frame = cap.read()
+
+ if success:
+ # Run YOLOv8 tracking on the frame, persisting tracks between frames
+ results = model.track(frame, persist=True)
+
+ # Visualize the results on the frame
+ annotated_frame = results[0].plot()
+
+ # Display the annotated frame
+ cv2.imshow("YOLOv8 Tracking", annotated_frame)
+
+ # Break the loop if 'q' is pressed
+ if cv2.waitKey(1) & 0xFF == ord("q"):
+ break
+ else:
+ # Break the loop if the end of the video is reached
+ break
+
+# Release the video capture object and close the display window
+cap.release()
+cv2.destroyAllWindows()
+```
+
+Please note the change from `model(frame)` to `model.track(frame)`, which enables object tracking instead of simple detection. This modified script will run the tracker on each frame of the video, visualize the results, and display them in a window. The loop can be exited by pressing 'q'.
+
+### Plotting Tracks Over Time
+
+Visualizing object tracks over consecutive frames can provide valuable insights into the movement patterns and behavior of detected objects within a video. With Ultralytics YOLOv8, plotting these tracks is a seamless and efficient process.
+
+In the following example, we demonstrate how to utilize YOLOv8's tracking capabilities to plot the movement of detected objects across multiple video frames. This script involves opening a video file, reading it frame by frame, and utilizing the YOLO model to identify and track various objects. By retaining the center points of the detected bounding boxes and connecting them, we can draw lines that represent the paths followed by the tracked objects.
+
+#### Python
+
+```python
+from collections import defaultdict
+
+import cv2
+import numpy as np
+
+from ultralytics import YOLO
+
+# Load the YOLOv8 model
+model = YOLO("yolov8n.pt")
+
+# Open the video file
+video_path = "path/to/video.mp4"
+cap = cv2.VideoCapture(video_path)
+
+# Store the track history
+track_history = defaultdict(lambda: [])
+
+# Loop through the video frames
+while cap.isOpened():
+ # Read a frame from the video
+ success, frame = cap.read()
+
+ if success:
+ # Run YOLOv8 tracking on the frame, persisting tracks between frames
+ results = model.track(frame, persist=True)
+
+ # Get the boxes and track IDs
+ boxes = results[0].boxes.xywh.cpu()
+ track_ids = results[0].boxes.id.int().cpu().tolist()
+
+ # Visualize the results on the frame
+ annotated_frame = results[0].plot()
+
+ # Plot the tracks
+ for box, track_id in zip(boxes, track_ids):
+ x, y, w, h = box
+ track = track_history[track_id]
+ track.append((float(x), float(y))) # x, y center point
+ if len(track) > 30: # retain 90 tracks for 90 frames
+ track.pop(0)
+
+ # Draw the tracking lines
+ points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
+ cv2.polylines(
+ annotated_frame,
+ [points],
+ isClosed=False,
+ color=(230, 230, 230),
+ thickness=10,
+ )
+
+ # Display the annotated frame
+ cv2.imshow("YOLOv8 Tracking", annotated_frame)
+
+ # Break the loop if 'q' is pressed
+ if cv2.waitKey(1) & 0xFF == ord("q"):
+ break
+ else:
+ # Break the loop if the end of the video is reached
+ break
+
+# Release the video capture object and close the display window
+cap.release()
+cv2.destroyAllWindows()
+```
+
+### Multithreaded Tracking
+
+Multithreaded tracking provides the capability to run object tracking on multiple video streams simultaneously. This is particularly useful when handling multiple video inputs, such as from multiple surveillance cameras, where concurrent processing can greatly enhance efficiency and performance.
+
+In the provided Python script, we make use of Python's `threading` module to run multiple instances of the tracker concurrently. Each thread is responsible for running the tracker on one video file, and all the threads run simultaneously in the background.
+
+To ensure that each thread receives the correct parameters (the video file and the model to use), we define a function `run_tracker_in_thread` that accepts these parameters and contains the main tracking loop. This function reads the video frame by frame, runs the tracker, and displays the results.
+
+Two different models are used in this example: `yolov8n.pt` and `yolov8n-seg.pt`, each tracking objects in a different video file. The video files are specified in `video_file1` and `video_file2`.
+
+The `daemon=True` parameter in `threading.Thread` means that these threads will be closed as soon as the main program finishes. We then start the threads with `start()` and use `join()` to make the main thread wait until both tracker threads have finished.
+
+Finally, after all threads have completed their task, the windows displaying the results are closed using `cv2.destroyAllWindows()`.
+
+#### Python
+
+```python
+import threading
+
+import cv2
+from ultralytics import YOLO
+
+
+def run_tracker_in_thread(filename, model):
+ video = cv2.VideoCapture(filename)
+ frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+ for _ in range(frames):
+ ret, frame = video.read()
+ if ret:
+ results = model.track(source=frame, persist=True)
+ res_plotted = results[0].plot()
+ cv2.imshow("p", res_plotted)
+ if cv2.waitKey(1) == ord("q"):
+ break
+
+
+# Load the models
+model1 = YOLO("yolov8n.pt")
+model2 = YOLO("yolov8n-seg.pt")
+
+# Define the video files for the trackers
+video_file1 = "path/to/video1.mp4"
+video_file2 = "path/to/video2.mp4"
+
+# Create the tracker threads
+tracker_thread1 = threading.Thread(
+ target=run_tracker_in_thread, args=(video_file1, model1), daemon=True
+)
+tracker_thread2 = threading.Thread(
+ target=run_tracker_in_thread, args=(video_file2, model2), daemon=True
+)
+
+# Start the tracker threads
+tracker_thread1.start()
+tracker_thread2.start()
+
+# Wait for the tracker threads to finish
+tracker_thread1.join()
+tracker_thread2.join()
+
+# Clean up and close windows
+cv2.destroyAllWindows()
+```
+
+This example can easily be extended to handle more video files and models by creating more threads and applying the same methodology.
+
+## Contribute New Trackers
+
+Are you proficient in multi-object tracking and have successfully implemented or adapted a tracking algorithm with Ultralytics YOLO? We invite you to contribute to our Trackers section in [ultralytics/cfg/trackers](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/trackers)! Your real-world applications and solutions could be invaluable for users working on tracking tasks.
+
+By contributing to this section, you help expand the scope of tracking solutions available within the Ultralytics YOLO framework, adding another layer of functionality and utility for the community.
+
+To initiate your contribution, please refer to our [Contributing Guide](https://docs.ultralytics.com/help/contributing) for comprehensive instructions on submitting a Pull Request (PR) 🛠️. We are excited to see what you bring to the table!
+
+Together, let's enhance the tracking capabilities of the Ultralytics YOLO ecosystem 🙏!
diff --git a/ultralytics/ultralytics/trackers/__init__.py b/ultralytics/ultralytics/trackers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..46e178e422724b27d6db6ba89265b7e160ca261b
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/__init__.py
@@ -0,0 +1,7 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from .bot_sort import BOTSORT
+from .byte_tracker import BYTETracker
+from .track import register_tracker
+
+__all__ = 'register_tracker', 'BOTSORT', 'BYTETracker' # allow simpler import
diff --git a/ultralytics/ultralytics/trackers/basetrack.py b/ultralytics/ultralytics/trackers/basetrack.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c7b0f707508d92699b9a2f5c3d4500006e9faa5
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/basetrack.py
@@ -0,0 +1,71 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from collections import OrderedDict
+
+import numpy as np
+
+
+class TrackState:
+ """Enumeration of possible object tracking states."""
+
+ New = 0
+ Tracked = 1
+ Lost = 2
+ Removed = 3
+
+
+class BaseTrack:
+ """Base class for object tracking, handling basic track attributes and operations."""
+
+ _count = 0
+
+ track_id = 0
+ is_activated = False
+ state = TrackState.New
+
+ history = OrderedDict()
+ features = []
+ curr_feature = None
+ score = 0
+ start_frame = 0
+ frame_id = 0
+ time_since_update = 0
+
+ # Multi-camera
+ location = (np.inf, np.inf)
+
+ @property
+ def end_frame(self):
+ """Return the last frame ID of the track."""
+ return self.frame_id
+
+ @staticmethod
+ def next_id():
+ """Increment and return the global track ID counter."""
+ BaseTrack._count += 1
+ return BaseTrack._count
+
+ def activate(self, *args):
+ """Activate the track with the provided arguments."""
+ raise NotImplementedError
+
+ def predict(self):
+ """Predict the next state of the track."""
+ raise NotImplementedError
+
+ def update(self, *args, **kwargs):
+ """Update the track with new observations."""
+ raise NotImplementedError
+
+ def mark_lost(self):
+ """Mark the track as lost."""
+ self.state = TrackState.Lost
+
+ def mark_removed(self):
+ """Mark the track as removed."""
+ self.state = TrackState.Removed
+
+ @staticmethod
+ def reset_id():
+ """Reset the global track ID counter."""
+ BaseTrack._count = 0
diff --git a/ultralytics/ultralytics/trackers/bot_sort.py b/ultralytics/ultralytics/trackers/bot_sort.py
new file mode 100644
index 0000000000000000000000000000000000000000..778786b83e02f1dcaf332e7616f1e613fef7dd25
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/bot_sort.py
@@ -0,0 +1,199 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from collections import deque
+
+import numpy as np
+
+from .basetrack import TrackState
+from .byte_tracker import BYTETracker, STrack
+from .utils import matching
+from .utils.gmc import GMC
+from .utils.kalman_filter import KalmanFilterXYWH
+
+
+class BOTrack(STrack):
+ """
+ An extended version of the STrack class for YOLOv8, adding object tracking features.
+
+ Attributes:
+ shared_kalman (KalmanFilterXYWH): A shared Kalman filter for all instances of BOTrack.
+ smooth_feat (np.ndarray): Smoothed feature vector.
+ curr_feat (np.ndarray): Current feature vector.
+ features (deque): A deque to store feature vectors with a maximum length defined by `feat_history`.
+ alpha (float): Smoothing factor for the exponential moving average of features.
+ mean (np.ndarray): The mean state of the Kalman filter.
+ covariance (np.ndarray): The covariance matrix of the Kalman filter.
+
+ Methods:
+ update_features(feat): Update features vector and smooth it using exponential moving average.
+ predict(): Predicts the mean and covariance using Kalman filter.
+ re_activate(new_track, frame_id, new_id): Reactivates a track with updated features and optionally new ID.
+ update(new_track, frame_id): Update the YOLOv8 instance with new track and frame ID.
+ tlwh: Property that gets the current position in tlwh format `(top left x, top left y, width, height)`.
+ multi_predict(stracks): Predicts the mean and covariance of multiple object tracks using shared Kalman filter.
+ convert_coords(tlwh): Converts tlwh bounding box coordinates to xywh format.
+ tlwh_to_xywh(tlwh): Convert bounding box to xywh format `(center x, center y, width, height)`.
+
+ Usage:
+ bo_track = BOTrack(tlwh, score, cls, feat)
+ bo_track.predict()
+ bo_track.update(new_track, frame_id)
+ """
+ shared_kalman = KalmanFilterXYWH()
+
+ def __init__(self, tlwh, score, cls, feat=None, feat_history=50):
+ """Initialize YOLOv8 object with temporal parameters, such as feature history, alpha and current features."""
+ super().__init__(tlwh, score, cls)
+
+ self.smooth_feat = None
+ self.curr_feat = None
+ if feat is not None:
+ self.update_features(feat)
+ self.features = deque([], maxlen=feat_history)
+ self.alpha = 0.9
+
+ def update_features(self, feat):
+ """Update features vector and smooth it using exponential moving average."""
+ feat /= np.linalg.norm(feat)
+ self.curr_feat = feat
+ if self.smooth_feat is None:
+ self.smooth_feat = feat
+ else:
+ self.smooth_feat = self.alpha * self.smooth_feat + (1 - self.alpha) * feat
+ self.features.append(feat)
+ self.smooth_feat /= np.linalg.norm(self.smooth_feat)
+
+ def predict(self):
+ """Predicts the mean and covariance using Kalman filter."""
+ mean_state = self.mean.copy()
+ if self.state != TrackState.Tracked:
+ mean_state[6] = 0
+ mean_state[7] = 0
+
+ self.mean, self.covariance = self.kalman_filter.predict(mean_state, self.covariance)
+
+ def re_activate(self, new_track, frame_id, new_id=False):
+ """Reactivates a track with updated features and optionally assigns a new ID."""
+ if new_track.curr_feat is not None:
+ self.update_features(new_track.curr_feat)
+ super().re_activate(new_track, frame_id, new_id)
+
+ def update(self, new_track, frame_id):
+ """Update the YOLOv8 instance with new track and frame ID."""
+ if new_track.curr_feat is not None:
+ self.update_features(new_track.curr_feat)
+ super().update(new_track, frame_id)
+
+ @property
+ def tlwh(self):
+ """Get current position in bounding box format `(top left x, top left y, width, height)`."""
+ if self.mean is None:
+ return self._tlwh.copy()
+ ret = self.mean[:4].copy()
+ ret[:2] -= ret[2:] / 2
+ return ret
+
+ @staticmethod
+ def multi_predict(stracks):
+ """Predicts the mean and covariance of multiple object tracks using shared Kalman filter."""
+ if len(stracks) <= 0:
+ return
+ multi_mean = np.asarray([st.mean.copy() for st in stracks])
+ multi_covariance = np.asarray([st.covariance for st in stracks])
+ for i, st in enumerate(stracks):
+ if st.state != TrackState.Tracked:
+ multi_mean[i][6] = 0
+ multi_mean[i][7] = 0
+ multi_mean, multi_covariance = BOTrack.shared_kalman.multi_predict(multi_mean, multi_covariance)
+ for i, (mean, cov) in enumerate(zip(multi_mean, multi_covariance)):
+ stracks[i].mean = mean
+ stracks[i].covariance = cov
+
+ def convert_coords(self, tlwh):
+ """Converts Top-Left-Width-Height bounding box coordinates to X-Y-Width-Height format."""
+ return self.tlwh_to_xywh(tlwh)
+
+ @staticmethod
+ def tlwh_to_xywh(tlwh):
+ """Convert bounding box to format `(center x, center y, width, height)`."""
+ ret = np.asarray(tlwh).copy()
+ ret[:2] += ret[2:] / 2
+ return ret
+
+
+class BOTSORT(BYTETracker):
+ """
+ An extended version of the BYTETracker class for YOLOv8, designed for object tracking with ReID and GMC algorithm.
+
+ Attributes:
+ proximity_thresh (float): Threshold for spatial proximity (IoU) between tracks and detections.
+ appearance_thresh (float): Threshold for appearance similarity (ReID embeddings) between tracks and detections.
+ encoder (object): Object to handle ReID embeddings, set to None if ReID is not enabled.
+ gmc (GMC): An instance of the GMC algorithm for data association.
+ args (object): Parsed command-line arguments containing tracking parameters.
+
+ Methods:
+ get_kalmanfilter(): Returns an instance of KalmanFilterXYWH for object tracking.
+ init_track(dets, scores, cls, img): Initialize track with detections, scores, and classes.
+ get_dists(tracks, detections): Get distances between tracks and detections using IoU and (optionally) ReID.
+ multi_predict(tracks): Predict and track multiple objects with YOLOv8 model.
+
+ Usage:
+ bot_sort = BOTSORT(args, frame_rate)
+ bot_sort.init_track(dets, scores, cls, img)
+ bot_sort.multi_predict(tracks)
+
+ Note:
+ The class is designed to work with the YOLOv8 object detection model and supports ReID only if enabled via args.
+ """
+
+ def __init__(self, args, frame_rate=30):
+ """Initialize YOLOv8 object with ReID module and GMC algorithm."""
+ super().__init__(args, frame_rate)
+ # ReID module
+ self.proximity_thresh = args.proximity_thresh
+ self.appearance_thresh = args.appearance_thresh
+
+ if args.with_reid:
+ # Haven't supported BoT-SORT(reid) yet
+ self.encoder = None
+ self.gmc = GMC(method=args.gmc_method)
+
+ def get_kalmanfilter(self):
+ """Returns an instance of KalmanFilterXYWH for object tracking."""
+ return KalmanFilterXYWH()
+
+ def init_track(self, dets, scores, cls, img=None):
+ """Initialize track with detections, scores, and classes."""
+ if len(dets) == 0:
+ return []
+ if self.args.with_reid and self.encoder is not None:
+ features_keep = self.encoder.inference(img, dets)
+ return [BOTrack(xyxy, s, c, f) for (xyxy, s, c, f) in zip(dets, scores, cls, features_keep)] # detections
+ else:
+ return [BOTrack(xyxy, s, c) for (xyxy, s, c) in zip(dets, scores, cls)] # detections
+
+ def get_dists(self, tracks, detections):
+ """Get distances between tracks and detections using IoU and (optionally) ReID embeddings."""
+ dists = matching.iou_distance(tracks, detections)
+ dists_mask = (dists > self.proximity_thresh)
+
+ # TODO: mot20
+ # if not self.args.mot20:
+ dists = matching.fuse_score(dists, detections)
+
+ if self.args.with_reid and self.encoder is not None:
+ emb_dists = matching.embedding_distance(tracks, detections) / 2.0
+ emb_dists[emb_dists > self.appearance_thresh] = 1.0
+ emb_dists[dists_mask] = 1.0
+ dists = np.minimum(dists, emb_dists)
+ return dists
+
+ def multi_predict(self, tracks):
+ """Predict and track multiple objects with YOLOv8 model."""
+ BOTrack.multi_predict(tracks)
+
+ def reset(self):
+ """Reset tracker."""
+ super().reset()
+ self.gmc.reset_params()
diff --git a/ultralytics/ultralytics/trackers/byte_tracker.py b/ultralytics/ultralytics/trackers/byte_tracker.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a612f89524d54f0a6e88e1f565d5fa8a4ebe230
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/byte_tracker.py
@@ -0,0 +1,429 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import numpy as np
+
+from .basetrack import BaseTrack, TrackState
+from .utils import matching
+from .utils.kalman_filter import KalmanFilterXYAH
+
+
+class STrack(BaseTrack):
+ """
+ Single object tracking representation that uses Kalman filtering for state estimation.
+
+ This class is responsible for storing all the information regarding individual tracklets and performs state updates
+ and predictions based on Kalman filter.
+
+ Attributes:
+ shared_kalman (KalmanFilterXYAH): Shared Kalman filter that is used across all STrack instances for prediction.
+ _tlwh (np.ndarray): Private attribute to store top-left corner coordinates and width and height of bounding box.
+ kalman_filter (KalmanFilterXYAH): Instance of Kalman filter used for this particular object track.
+ mean (np.ndarray): Mean state estimate vector.
+ covariance (np.ndarray): Covariance of state estimate.
+ is_activated (bool): Boolean flag indicating if the track has been activated.
+ score (float): Confidence score of the track.
+ tracklet_len (int): Length of the tracklet.
+ cls (any): Class label for the object.
+ idx (int): Index or identifier for the object.
+ frame_id (int): Current frame ID.
+ start_frame (int): Frame where the object was first detected.
+
+ Methods:
+ predict(): Predict the next state of the object using Kalman filter.
+ multi_predict(stracks): Predict the next states for multiple tracks.
+ multi_gmc(stracks, H): Update multiple track states using a homography matrix.
+ activate(kalman_filter, frame_id): Activate a new tracklet.
+ re_activate(new_track, frame_id, new_id): Reactivate a previously lost tracklet.
+ update(new_track, frame_id): Update the state of a matched track.
+ convert_coords(tlwh): Convert bounding box to x-y-angle-height format.
+ tlwh_to_xyah(tlwh): Convert tlwh bounding box to xyah format.
+ tlbr_to_tlwh(tlbr): Convert tlbr bounding box to tlwh format.
+ tlwh_to_tlbr(tlwh): Convert tlwh bounding box to tlbr format.
+ """
+
+ shared_kalman = KalmanFilterXYAH()
+
+ def __init__(self, tlwh, score, cls):
+ """Initialize new STrack instance."""
+ self._tlwh = np.asarray(self.tlbr_to_tlwh(tlwh[:-1]), dtype=np.float32)
+ self.kalman_filter = None
+ self.mean, self.covariance = None, None
+ self.is_activated = False
+
+ self.score = score
+ self.tracklet_len = 0
+ self.cls = cls
+ self.idx = tlwh[-1]
+
+ def predict(self):
+ """Predicts mean and covariance using Kalman filter."""
+ mean_state = self.mean.copy()
+ if self.state != TrackState.Tracked:
+ mean_state[7] = 0
+ self.mean, self.covariance = self.kalman_filter.predict(mean_state, self.covariance)
+
+ @staticmethod
+ def multi_predict(stracks):
+ """Perform multi-object predictive tracking using Kalman filter for given stracks."""
+ if len(stracks) <= 0:
+ return
+ multi_mean = np.asarray([st.mean.copy() for st in stracks])
+ multi_covariance = np.asarray([st.covariance for st in stracks])
+ for i, st in enumerate(stracks):
+ if st.state != TrackState.Tracked:
+ multi_mean[i][7] = 0
+ multi_mean, multi_covariance = STrack.shared_kalman.multi_predict(multi_mean, multi_covariance)
+ for i, (mean, cov) in enumerate(zip(multi_mean, multi_covariance)):
+ stracks[i].mean = mean
+ stracks[i].covariance = cov
+
+ @staticmethod
+ def multi_gmc(stracks, H=np.eye(2, 3)):
+ """Update state tracks positions and covariances using a homography matrix."""
+ if len(stracks) > 0:
+ multi_mean = np.asarray([st.mean.copy() for st in stracks])
+ multi_covariance = np.asarray([st.covariance for st in stracks])
+
+ R = H[:2, :2]
+ R8x8 = np.kron(np.eye(4, dtype=float), R)
+ t = H[:2, 2]
+
+ for i, (mean, cov) in enumerate(zip(multi_mean, multi_covariance)):
+ mean = R8x8.dot(mean)
+ mean[:2] += t
+ cov = R8x8.dot(cov).dot(R8x8.transpose())
+
+ stracks[i].mean = mean
+ stracks[i].covariance = cov
+
+ def activate(self, kalman_filter, frame_id):
+ """Start a new tracklet."""
+ self.kalman_filter = kalman_filter
+ self.track_id = self.next_id()
+ self.mean, self.covariance = self.kalman_filter.initiate(self.convert_coords(self._tlwh))
+
+ self.tracklet_len = 0
+ self.state = TrackState.Tracked
+ if frame_id == 1:
+ self.is_activated = True
+ self.frame_id = frame_id
+ self.start_frame = frame_id
+
+ def re_activate(self, new_track, frame_id, new_id=False):
+ """Reactivates a previously lost track with a new detection."""
+ self.mean, self.covariance = self.kalman_filter.update(self.mean, self.covariance,
+ self.convert_coords(new_track.tlwh))
+ self.tracklet_len = 0
+ self.state = TrackState.Tracked
+ self.is_activated = True
+ self.frame_id = frame_id
+ if new_id:
+ self.track_id = self.next_id()
+ self.score = new_track.score
+ self.cls = new_track.cls
+ self.idx = new_track.idx
+
+ def update(self, new_track, frame_id):
+ """
+ Update the state of a matched track.
+
+ Args:
+ new_track (STrack): The new track containing updated information.
+ frame_id (int): The ID of the current frame.
+ """
+ self.frame_id = frame_id
+ self.tracklet_len += 1
+
+ new_tlwh = new_track.tlwh
+ self.mean, self.covariance = self.kalman_filter.update(self.mean, self.covariance,
+ self.convert_coords(new_tlwh))
+ self.state = TrackState.Tracked
+ self.is_activated = True
+
+ self.score = new_track.score
+ self.cls = new_track.cls
+ self.idx = new_track.idx
+
+ def convert_coords(self, tlwh):
+ """Convert a bounding box's top-left-width-height format to its x-y-angle-height equivalent."""
+ return self.tlwh_to_xyah(tlwh)
+
+ @property
+ def tlwh(self):
+ """Get current position in bounding box format (top left x, top left y, width, height)."""
+ if self.mean is None:
+ return self._tlwh.copy()
+ ret = self.mean[:4].copy()
+ ret[2] *= ret[3]
+ ret[:2] -= ret[2:] / 2
+ return ret
+
+ @property
+ def tlbr(self):
+ """Convert bounding box to format (min x, min y, max x, max y), i.e., (top left, bottom right)."""
+ ret = self.tlwh.copy()
+ ret[2:] += ret[:2]
+ return ret
+
+ @staticmethod
+ def tlwh_to_xyah(tlwh):
+ """Convert bounding box to format (center x, center y, aspect ratio, height), where the aspect ratio is width /
+ height.
+ """
+ ret = np.asarray(tlwh).copy()
+ ret[:2] += ret[2:] / 2
+ ret[2] /= ret[3]
+ return ret
+
+ @staticmethod
+ def tlbr_to_tlwh(tlbr):
+ """Converts top-left bottom-right format to top-left width height format."""
+ ret = np.asarray(tlbr).copy()
+ ret[2:] -= ret[:2]
+ return ret
+
+ @staticmethod
+ def tlwh_to_tlbr(tlwh):
+ """Converts tlwh bounding box format to tlbr format."""
+ ret = np.asarray(tlwh).copy()
+ ret[2:] += ret[:2]
+ return ret
+
+ def __repr__(self):
+ """Return a string representation of the BYTETracker object with start and end frames and track ID."""
+ return f'OT_{self.track_id}_({self.start_frame}-{self.end_frame})'
+
+
+class BYTETracker:
+ """
+ BYTETracker: A tracking algorithm built on top of YOLOv8 for object detection and tracking.
+
+ The class is responsible for initializing, updating, and managing the tracks for detected objects in a video
+ sequence. It maintains the state of tracked, lost, and removed tracks over frames, utilizes Kalman filtering for
+ predicting the new object locations, and performs data association.
+
+ Attributes:
+ tracked_stracks (list[STrack]): List of successfully activated tracks.
+ lost_stracks (list[STrack]): List of lost tracks.
+ removed_stracks (list[STrack]): List of removed tracks.
+ frame_id (int): The current frame ID.
+ args (namespace): Command-line arguments.
+ max_time_lost (int): The maximum frames for a track to be considered as 'lost'.
+ kalman_filter (object): Kalman Filter object.
+
+ Methods:
+ update(results, img=None): Updates object tracker with new detections.
+ get_kalmanfilter(): Returns a Kalman filter object for tracking bounding boxes.
+ init_track(dets, scores, cls, img=None): Initialize object tracking with detections.
+ get_dists(tracks, detections): Calculates the distance between tracks and detections.
+ multi_predict(tracks): Predicts the location of tracks.
+ reset_id(): Resets the ID counter of STrack.
+ joint_stracks(tlista, tlistb): Combines two lists of stracks.
+ sub_stracks(tlista, tlistb): Filters out the stracks present in the second list from the first list.
+ remove_duplicate_stracks(stracksa, stracksb): Removes duplicate stracks based on IOU.
+ """
+
+ def __init__(self, args, frame_rate=30):
+ """Initialize a YOLOv8 object to track objects with given arguments and frame rate."""
+ self.tracked_stracks = [] # type: list[STrack]
+ self.lost_stracks = [] # type: list[STrack]
+ self.removed_stracks = [] # type: list[STrack]
+
+ self.frame_id = 0
+ self.args = args
+ self.max_time_lost = int(frame_rate / 30.0 * args.track_buffer)
+ self.kalman_filter = self.get_kalmanfilter()
+ self.reset_id()
+
+ def update(self, results, img=None):
+ """Updates object tracker with new detections and returns tracked object bounding boxes."""
+ self.frame_id += 1
+ activated_stracks = []
+ refind_stracks = []
+ lost_stracks = []
+ removed_stracks = []
+
+ scores = results.conf
+ bboxes = results.xyxy
+ # Add index
+ bboxes = np.concatenate([bboxes, np.arange(len(bboxes)).reshape(-1, 1)], axis=-1)
+ cls = results.cls
+
+ remain_inds = scores > self.args.track_high_thresh
+ inds_low = scores > self.args.track_low_thresh
+ inds_high = scores < self.args.track_high_thresh
+
+ inds_second = np.logical_and(inds_low, inds_high)
+ dets_second = bboxes[inds_second]
+ dets = bboxes[remain_inds]
+ scores_keep = scores[remain_inds]
+ scores_second = scores[inds_second]
+ cls_keep = cls[remain_inds]
+ cls_second = cls[inds_second]
+
+ detections = self.init_track(dets, scores_keep, cls_keep, img)
+ # Add newly detected tracklets to tracked_stracks
+ unconfirmed = []
+ tracked_stracks = [] # type: list[STrack]
+ for track in self.tracked_stracks:
+ if not track.is_activated:
+ unconfirmed.append(track)
+ else:
+ tracked_stracks.append(track)
+ # Step 2: First association, with high score detection boxes
+ strack_pool = self.joint_stracks(tracked_stracks, self.lost_stracks)
+ # Predict the current location with KF
+ self.multi_predict(strack_pool)
+ if hasattr(self, 'gmc') and img is not None:
+ warp = self.gmc.apply(img, dets)
+ STrack.multi_gmc(strack_pool, warp)
+ STrack.multi_gmc(unconfirmed, warp)
+
+ dists = self.get_dists(strack_pool, detections)
+ matches, u_track, u_detection = matching.linear_assignment(dists, thresh=self.args.match_thresh)
+
+ for itracked, idet in matches:
+ track = strack_pool[itracked]
+ det = detections[idet]
+ if track.state == TrackState.Tracked:
+ track.update(det, self.frame_id)
+ activated_stracks.append(track)
+ else:
+ track.re_activate(det, self.frame_id, new_id=False)
+ refind_stracks.append(track)
+ # Step 3: Second association, with low score detection boxes association the untrack to the low score detections
+ detections_second = self.init_track(dets_second, scores_second, cls_second, img)
+ r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
+ # TODO
+ dists = matching.iou_distance(r_tracked_stracks, detections_second)
+ matches, u_track, u_detection_second = matching.linear_assignment(dists, thresh=0.5)
+ for itracked, idet in matches:
+ track = r_tracked_stracks[itracked]
+ det = detections_second[idet]
+ if track.state == TrackState.Tracked:
+ track.update(det, self.frame_id)
+ activated_stracks.append(track)
+ else:
+ track.re_activate(det, self.frame_id, new_id=False)
+ refind_stracks.append(track)
+
+ for it in u_track:
+ track = r_tracked_stracks[it]
+ if track.state != TrackState.Lost:
+ track.mark_lost()
+ lost_stracks.append(track)
+ # Deal with unconfirmed tracks, usually tracks with only one beginning frame
+ detections = [detections[i] for i in u_detection]
+ dists = self.get_dists(unconfirmed, detections)
+ matches, u_unconfirmed, u_detection = matching.linear_assignment(dists, thresh=0.7)
+ for itracked, idet in matches:
+ unconfirmed[itracked].update(detections[idet], self.frame_id)
+ activated_stracks.append(unconfirmed[itracked])
+ for it in u_unconfirmed:
+ track = unconfirmed[it]
+ track.mark_removed()
+ removed_stracks.append(track)
+ # Step 4: Init new stracks
+ for inew in u_detection:
+ track = detections[inew]
+ if track.score < self.args.new_track_thresh:
+ continue
+ track.activate(self.kalman_filter, self.frame_id)
+ activated_stracks.append(track)
+ # Step 5: Update state
+ for track in self.lost_stracks:
+ if self.frame_id - track.end_frame > self.max_time_lost:
+ track.mark_removed()
+ removed_stracks.append(track)
+
+ self.tracked_stracks = [t for t in self.tracked_stracks if t.state == TrackState.Tracked]
+ self.tracked_stracks = self.joint_stracks(self.tracked_stracks, activated_stracks)
+ self.tracked_stracks = self.joint_stracks(self.tracked_stracks, refind_stracks)
+ self.lost_stracks = self.sub_stracks(self.lost_stracks, self.tracked_stracks)
+ self.lost_stracks.extend(lost_stracks)
+ self.lost_stracks = self.sub_stracks(self.lost_stracks, self.removed_stracks)
+ self.tracked_stracks, self.lost_stracks = self.remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
+ self.removed_stracks.extend(removed_stracks)
+ if len(self.removed_stracks) > 1000:
+ self.removed_stracks = self.removed_stracks[-999:] # clip remove stracks to 1000 maximum
+ return np.asarray(
+ [x.tlbr.tolist() + [x.track_id, x.score, x.cls, x.idx] for x in self.tracked_stracks if x.is_activated],
+ dtype=np.float32)
+
+ def get_kalmanfilter(self):
+ """Returns a Kalman filter object for tracking bounding boxes."""
+ return KalmanFilterXYAH()
+
+ def init_track(self, dets, scores, cls, img=None):
+ """Initialize object tracking with detections and scores using STrack algorithm."""
+ return [STrack(xyxy, s, c) for (xyxy, s, c) in zip(dets, scores, cls)] if len(dets) else [] # detections
+
+ def get_dists(self, tracks, detections):
+ """Calculates the distance between tracks and detections using IOU and fuses scores."""
+ dists = matching.iou_distance(tracks, detections)
+ # TODO: mot20
+ # if not self.args.mot20:
+ dists = matching.fuse_score(dists, detections)
+ return dists
+
+ def multi_predict(self, tracks):
+ """Returns the predicted tracks using the YOLOv8 network."""
+ STrack.multi_predict(tracks)
+
+ def reset_id(self):
+ """Resets the ID counter of STrack."""
+ STrack.reset_id()
+
+ def reset(self):
+ """Reset tracker."""
+ self.tracked_stracks = [] # type: list[STrack]
+ self.lost_stracks = [] # type: list[STrack]
+ self.removed_stracks = [] # type: list[STrack]
+ self.frame_id = 0
+ self.kalman_filter = self.get_kalmanfilter()
+ self.reset_id()
+
+ @staticmethod
+ def joint_stracks(tlista, tlistb):
+ """Combine two lists of stracks into a single one."""
+ exists = {}
+ res = []
+ for t in tlista:
+ exists[t.track_id] = 1
+ res.append(t)
+ for t in tlistb:
+ tid = t.track_id
+ if not exists.get(tid, 0):
+ exists[tid] = 1
+ res.append(t)
+ return res
+
+ @staticmethod
+ def sub_stracks(tlista, tlistb):
+ """DEPRECATED CODE in https://github.com/ultralytics/ultralytics/pull/1890/
+ stracks = {t.track_id: t for t in tlista}
+ for t in tlistb:
+ tid = t.track_id
+ if stracks.get(tid, 0):
+ del stracks[tid]
+ return list(stracks.values())
+ """
+ track_ids_b = {t.track_id for t in tlistb}
+ return [t for t in tlista if t.track_id not in track_ids_b]
+
+ @staticmethod
+ def remove_duplicate_stracks(stracksa, stracksb):
+ """Remove duplicate stracks with non-maximum IOU distance."""
+ pdist = matching.iou_distance(stracksa, stracksb)
+ pairs = np.where(pdist < 0.15)
+ dupa, dupb = [], []
+ for p, q in zip(*pairs):
+ timep = stracksa[p].frame_id - stracksa[p].start_frame
+ timeq = stracksb[q].frame_id - stracksb[q].start_frame
+ if timep > timeq:
+ dupb.append(q)
+ else:
+ dupa.append(p)
+ resa = [t for i, t in enumerate(stracksa) if i not in dupa]
+ resb = [t for i, t in enumerate(stracksb) if i not in dupb]
+ return resa, resb
diff --git a/ultralytics/ultralytics/trackers/track.py b/ultralytics/ultralytics/trackers/track.py
new file mode 100644
index 0000000000000000000000000000000000000000..39e2275f0bc992f751cb55271015c48bb6312551
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/track.py
@@ -0,0 +1,70 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+from functools import partial
+from pathlib import Path
+
+import torch
+
+from ultralytics.utils import IterableSimpleNamespace, yaml_load
+from ultralytics.utils.checks import check_yaml
+
+from .bot_sort import BOTSORT
+from .byte_tracker import BYTETracker
+
+TRACKER_MAP = {'bytetrack': BYTETracker, 'botsort': BOTSORT}
+
+
+def on_predict_start(predictor, persist=False):
+ """
+ Initialize trackers for object tracking during prediction.
+
+ Args:
+ predictor (object): The predictor object to initialize trackers for.
+ persist (bool, optional): Whether to persist the trackers if they already exist. Defaults to False.
+
+ Raises:
+ AssertionError: If the tracker_type is not 'bytetrack' or 'botsort'.
+ """
+ if hasattr(predictor, 'trackers') and persist:
+ return
+ tracker = check_yaml(predictor.args.tracker)
+ cfg = IterableSimpleNamespace(**yaml_load(tracker))
+ assert cfg.tracker_type in ['bytetrack', 'botsort'], \
+ f"Only support 'bytetrack' and 'botsort' for now, but got '{cfg.tracker_type}'"
+ trackers = []
+ for _ in range(predictor.dataset.bs):
+ tracker = TRACKER_MAP[cfg.tracker_type](args=cfg, frame_rate=30)
+ trackers.append(tracker)
+ predictor.trackers = trackers
+
+
+def on_predict_postprocess_end(predictor, persist=False):
+ """Postprocess detected boxes and update with object tracking."""
+ bs = predictor.dataset.bs
+ path, im0s = predictor.batch[:2]
+
+ for i in range(bs):
+ if not persist and predictor.vid_path[i] != str(predictor.save_dir / Path(path[i]).name): # new video
+ predictor.trackers[i].reset()
+
+ det = predictor.results[i].boxes.cpu().numpy()
+ if len(det) == 0:
+ continue
+ tracks = predictor.trackers[i].update(det, im0s[i])
+ if len(tracks) == 0:
+ continue
+ idx = tracks[:, -1].astype(int)
+ predictor.results[i] = predictor.results[i][idx]
+ predictor.results[i].update(boxes=torch.as_tensor(tracks[:, :-1]))
+
+
+def register_tracker(model, persist):
+ """
+ Register tracking callbacks to the model for object tracking during prediction.
+
+ Args:
+ model (object): The model object to register tracking callbacks for.
+ persist (bool): Whether to persist the trackers if they already exist.
+ """
+ model.add_callback('on_predict_start', partial(on_predict_start, persist=persist))
+ model.add_callback('on_predict_postprocess_end', partial(on_predict_postprocess_end, persist=persist))
diff --git a/ultralytics/ultralytics/trackers/utils/__init__.py b/ultralytics/ultralytics/trackers/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e68dc12245afb4f72ba5f7c1227df74613a427d
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/utils/__init__.py
@@ -0,0 +1 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
diff --git a/ultralytics/ultralytics/trackers/utils/gmc.py b/ultralytics/ultralytics/trackers/utils/gmc.py
new file mode 100644
index 0000000000000000000000000000000000000000..60c46a191a15683fafe7bed326c73200ea93cafa
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/utils/gmc.py
@@ -0,0 +1,309 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import copy
+
+import cv2
+import numpy as np
+
+from ultralytics.utils import LOGGER
+
+
+class GMC:
+ """
+ Generalized Motion Compensation (GMC) class for tracking and object detection in video frames.
+
+ This class provides methods for tracking and detecting objects based on several tracking algorithms including ORB,
+ SIFT, ECC, and Sparse Optical Flow. It also supports downscaling of frames for computational efficiency.
+
+ Attributes:
+ method (str): The method used for tracking. Options include 'orb', 'sift', 'ecc', 'sparseOptFlow', 'none'.
+ downscale (int): Factor by which to downscale the frames for processing.
+ prevFrame (np.array): Stores the previous frame for tracking.
+ prevKeyPoints (list): Stores the keypoints from the previous frame.
+ prevDescriptors (np.array): Stores the descriptors from the previous frame.
+ initializedFirstFrame (bool): Flag to indicate if the first frame has been processed.
+
+ Methods:
+ __init__(self, method='sparseOptFlow', downscale=2): Initializes a GMC object with the specified method
+ and downscale factor.
+ apply(self, raw_frame, detections=None): Applies the chosen method to a raw frame and optionally uses
+ provided detections.
+ applyEcc(self, raw_frame, detections=None): Applies the ECC algorithm to a raw frame.
+ applyFeatures(self, raw_frame, detections=None): Applies feature-based methods like ORB or SIFT to a raw frame.
+ applySparseOptFlow(self, raw_frame, detections=None): Applies the Sparse Optical Flow method to a raw frame.
+ """
+
+ def __init__(self, method='sparseOptFlow', downscale=2):
+ """Initialize a video tracker with specified parameters."""
+ super().__init__()
+
+ self.method = method
+ self.downscale = max(1, int(downscale))
+
+ if self.method == 'orb':
+ self.detector = cv2.FastFeatureDetector_create(20)
+ self.extractor = cv2.ORB_create()
+ self.matcher = cv2.BFMatcher(cv2.NORM_HAMMING)
+
+ elif self.method == 'sift':
+ self.detector = cv2.SIFT_create(nOctaveLayers=3, contrastThreshold=0.02, edgeThreshold=20)
+ self.extractor = cv2.SIFT_create(nOctaveLayers=3, contrastThreshold=0.02, edgeThreshold=20)
+ self.matcher = cv2.BFMatcher(cv2.NORM_L2)
+
+ elif self.method == 'ecc':
+ number_of_iterations = 5000
+ termination_eps = 1e-6
+ self.warp_mode = cv2.MOTION_EUCLIDEAN
+ self.criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, number_of_iterations, termination_eps)
+
+ elif self.method == 'sparseOptFlow':
+ self.feature_params = dict(maxCorners=1000,
+ qualityLevel=0.01,
+ minDistance=1,
+ blockSize=3,
+ useHarrisDetector=False,
+ k=0.04)
+
+ elif self.method in ['none', 'None', None]:
+ self.method = None
+ else:
+ raise ValueError(f'Error: Unknown GMC method:{method}')
+
+ self.prevFrame = None
+ self.prevKeyPoints = None
+ self.prevDescriptors = None
+
+ self.initializedFirstFrame = False
+
+ def apply(self, raw_frame, detections=None):
+ """Apply object detection on a raw frame using specified method."""
+ if self.method in ['orb', 'sift']:
+ return self.applyFeatures(raw_frame, detections)
+ elif self.method == 'ecc':
+ return self.applyEcc(raw_frame, detections)
+ elif self.method == 'sparseOptFlow':
+ return self.applySparseOptFlow(raw_frame, detections)
+ else:
+ return np.eye(2, 3)
+
+ def applyEcc(self, raw_frame, detections=None):
+ """Initialize."""
+ height, width, _ = raw_frame.shape
+ frame = cv2.cvtColor(raw_frame, cv2.COLOR_BGR2GRAY)
+ H = np.eye(2, 3, dtype=np.float32)
+
+ # Downscale image (TODO: consider using pyramids)
+ if self.downscale > 1.0:
+ frame = cv2.GaussianBlur(frame, (3, 3), 1.5)
+ frame = cv2.resize(frame, (width // self.downscale, height // self.downscale))
+ width = width // self.downscale
+ height = height // self.downscale
+
+ # Handle first frame
+ if not self.initializedFirstFrame:
+ # Initialize data
+ self.prevFrame = frame.copy()
+
+ # Initialization done
+ self.initializedFirstFrame = True
+
+ return H
+
+ # Run the ECC algorithm. The results are stored in warp_matrix.
+ # (cc, H) = cv2.findTransformECC(self.prevFrame, frame, H, self.warp_mode, self.criteria)
+ try:
+ (cc, H) = cv2.findTransformECC(self.prevFrame, frame, H, self.warp_mode, self.criteria, None, 1)
+ except Exception as e:
+ LOGGER.warning(f'WARNING: find transform failed. Set warp as identity {e}')
+
+ return H
+
+ def applyFeatures(self, raw_frame, detections=None):
+ """Initialize."""
+ height, width, _ = raw_frame.shape
+ frame = cv2.cvtColor(raw_frame, cv2.COLOR_BGR2GRAY)
+ H = np.eye(2, 3)
+
+ # Downscale image (TODO: consider using pyramids)
+ if self.downscale > 1.0:
+ # frame = cv2.GaussianBlur(frame, (3, 3), 1.5)
+ frame = cv2.resize(frame, (width // self.downscale, height // self.downscale))
+ width = width // self.downscale
+ height = height // self.downscale
+
+ # Find the keypoints
+ mask = np.zeros_like(frame)
+ # mask[int(0.05 * height): int(0.95 * height), int(0.05 * width): int(0.95 * width)] = 255
+ mask[int(0.02 * height):int(0.98 * height), int(0.02 * width):int(0.98 * width)] = 255
+ if detections is not None:
+ for det in detections:
+ tlbr = (det[:4] / self.downscale).astype(np.int_)
+ mask[tlbr[1]:tlbr[3], tlbr[0]:tlbr[2]] = 0
+
+ keypoints = self.detector.detect(frame, mask)
+
+ # Compute the descriptors
+ keypoints, descriptors = self.extractor.compute(frame, keypoints)
+
+ # Handle first frame
+ if not self.initializedFirstFrame:
+ # Initialize data
+ self.prevFrame = frame.copy()
+ self.prevKeyPoints = copy.copy(keypoints)
+ self.prevDescriptors = copy.copy(descriptors)
+
+ # Initialization done
+ self.initializedFirstFrame = True
+
+ return H
+
+ # Match descriptors.
+ knnMatches = self.matcher.knnMatch(self.prevDescriptors, descriptors, 2)
+
+ # Filtered matches based on smallest spatial distance
+ matches = []
+ spatialDistances = []
+
+ maxSpatialDistance = 0.25 * np.array([width, height])
+
+ # Handle empty matches case
+ if len(knnMatches) == 0:
+ # Store to next iteration
+ self.prevFrame = frame.copy()
+ self.prevKeyPoints = copy.copy(keypoints)
+ self.prevDescriptors = copy.copy(descriptors)
+
+ return H
+
+ for m, n in knnMatches:
+ if m.distance < 0.9 * n.distance:
+ prevKeyPointLocation = self.prevKeyPoints[m.queryIdx].pt
+ currKeyPointLocation = keypoints[m.trainIdx].pt
+
+ spatialDistance = (prevKeyPointLocation[0] - currKeyPointLocation[0],
+ prevKeyPointLocation[1] - currKeyPointLocation[1])
+
+ if (np.abs(spatialDistance[0]) < maxSpatialDistance[0]) and \
+ (np.abs(spatialDistance[1]) < maxSpatialDistance[1]):
+ spatialDistances.append(spatialDistance)
+ matches.append(m)
+
+ meanSpatialDistances = np.mean(spatialDistances, 0)
+ stdSpatialDistances = np.std(spatialDistances, 0)
+
+ inliers = (spatialDistances - meanSpatialDistances) < 2.5 * stdSpatialDistances
+
+ goodMatches = []
+ prevPoints = []
+ currPoints = []
+ for i in range(len(matches)):
+ if inliers[i, 0] and inliers[i, 1]:
+ goodMatches.append(matches[i])
+ prevPoints.append(self.prevKeyPoints[matches[i].queryIdx].pt)
+ currPoints.append(keypoints[matches[i].trainIdx].pt)
+
+ prevPoints = np.array(prevPoints)
+ currPoints = np.array(currPoints)
+
+ # Draw the keypoint matches on the output image
+ # if False:
+ # import matplotlib.pyplot as plt
+ # matches_img = np.hstack((self.prevFrame, frame))
+ # matches_img = cv2.cvtColor(matches_img, cv2.COLOR_GRAY2BGR)
+ # W = np.size(self.prevFrame, 1)
+ # for m in goodMatches:
+ # prev_pt = np.array(self.prevKeyPoints[m.queryIdx].pt, dtype=np.int_)
+ # curr_pt = np.array(keypoints[m.trainIdx].pt, dtype=np.int_)
+ # curr_pt[0] += W
+ # color = np.random.randint(0, 255, 3)
+ # color = (int(color[0]), int(color[1]), int(color[2]))
+ #
+ # matches_img = cv2.line(matches_img, prev_pt, curr_pt, tuple(color), 1, cv2.LINE_AA)
+ # matches_img = cv2.circle(matches_img, prev_pt, 2, tuple(color), -1)
+ # matches_img = cv2.circle(matches_img, curr_pt, 2, tuple(color), -1)
+ #
+ # plt.figure()
+ # plt.imshow(matches_img)
+ # plt.show()
+
+ # Find rigid matrix
+ if (np.size(prevPoints, 0) > 4) and (np.size(prevPoints, 0) == np.size(prevPoints, 0)):
+ H, inliers = cv2.estimateAffinePartial2D(prevPoints, currPoints, cv2.RANSAC)
+
+ # Handle downscale
+ if self.downscale > 1.0:
+ H[0, 2] *= self.downscale
+ H[1, 2] *= self.downscale
+ else:
+ LOGGER.warning('WARNING: not enough matching points')
+
+ # Store to next iteration
+ self.prevFrame = frame.copy()
+ self.prevKeyPoints = copy.copy(keypoints)
+ self.prevDescriptors = copy.copy(descriptors)
+
+ return H
+
+ def applySparseOptFlow(self, raw_frame, detections=None):
+ """Initialize."""
+ height, width, _ = raw_frame.shape
+ frame = cv2.cvtColor(raw_frame, cv2.COLOR_BGR2GRAY)
+ H = np.eye(2, 3)
+
+ # Downscale image
+ if self.downscale > 1.0:
+ # frame = cv2.GaussianBlur(frame, (3, 3), 1.5)
+ frame = cv2.resize(frame, (width // self.downscale, height // self.downscale))
+
+ # Find the keypoints
+ keypoints = cv2.goodFeaturesToTrack(frame, mask=None, **self.feature_params)
+
+ # Handle first frame
+ if not self.initializedFirstFrame:
+ # Initialize data
+ self.prevFrame = frame.copy()
+ self.prevKeyPoints = copy.copy(keypoints)
+
+ # Initialization done
+ self.initializedFirstFrame = True
+
+ return H
+
+ # Find correspondences
+ matchedKeypoints, status, err = cv2.calcOpticalFlowPyrLK(self.prevFrame, frame, self.prevKeyPoints, None)
+
+ # Leave good correspondences only
+ prevPoints = []
+ currPoints = []
+
+ for i in range(len(status)):
+ if status[i]:
+ prevPoints.append(self.prevKeyPoints[i])
+ currPoints.append(matchedKeypoints[i])
+
+ prevPoints = np.array(prevPoints)
+ currPoints = np.array(currPoints)
+
+ # Find rigid matrix
+ if (np.size(prevPoints, 0) > 4) and (np.size(prevPoints, 0) == np.size(prevPoints, 0)):
+ H, inliers = cv2.estimateAffinePartial2D(prevPoints, currPoints, cv2.RANSAC)
+
+ # Handle downscale
+ if self.downscale > 1.0:
+ H[0, 2] *= self.downscale
+ H[1, 2] *= self.downscale
+ else:
+ LOGGER.warning('WARNING: not enough matching points')
+
+ # Store to next iteration
+ self.prevFrame = frame.copy()
+ self.prevKeyPoints = copy.copy(keypoints)
+
+ return H
+
+ def reset_params(self):
+ """Reset parameters."""
+ self.prevFrame = None
+ self.prevKeyPoints = None
+ self.prevDescriptors = None
+ self.initializedFirstFrame = False
diff --git a/ultralytics/ultralytics/trackers/utils/kalman_filter.py b/ultralytics/ultralytics/trackers/utils/kalman_filter.py
new file mode 100644
index 0000000000000000000000000000000000000000..d74082745a5b0823bf059e54962c2cd8756b9a88
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/utils/kalman_filter.py
@@ -0,0 +1,368 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import numpy as np
+import scipy.linalg
+
+
+class KalmanFilterXYAH:
+ """
+ For bytetrack. A simple Kalman filter for tracking bounding boxes in image space.
+
+ The 8-dimensional state space (x, y, a, h, vx, vy, va, vh) contains the bounding box center position (x, y), aspect
+ ratio a, height h, and their respective velocities.
+
+ Object motion follows a constant velocity model. The bounding box location (x, y, a, h) is taken as direct
+ observation of the state space (linear observation model).
+ """
+
+ def __init__(self):
+ """Initialize Kalman filter model matrices with motion and observation uncertainty weights."""
+ ndim, dt = 4, 1.
+
+ # Create Kalman filter model matrices.
+ self._motion_mat = np.eye(2 * ndim, 2 * ndim)
+ for i in range(ndim):
+ self._motion_mat[i, ndim + i] = dt
+ self._update_mat = np.eye(ndim, 2 * ndim)
+
+ # Motion and observation uncertainty are chosen relative to the current state estimate. These weights control
+ # the amount of uncertainty in the model. This is a bit hacky.
+ self._std_weight_position = 1. / 20
+ self._std_weight_velocity = 1. / 160
+
+ def initiate(self, measurement):
+ """
+ Create track from unassociated measurement.
+
+ Parameters
+ ----------
+ measurement : ndarray
+ Bounding box coordinates (x, y, a, h) with center position (x, y),
+ aspect ratio a, and height h.
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the mean vector (8 dimensional) and covariance matrix (8x8
+ dimensional) of the new track. Unobserved velocities are initialized
+ to 0 mean.
+ """
+ mean_pos = measurement
+ mean_vel = np.zeros_like(mean_pos)
+ mean = np.r_[mean_pos, mean_vel]
+
+ std = [
+ 2 * self._std_weight_position * measurement[3], 2 * self._std_weight_position * measurement[3], 1e-2,
+ 2 * self._std_weight_position * measurement[3], 10 * self._std_weight_velocity * measurement[3],
+ 10 * self._std_weight_velocity * measurement[3], 1e-5, 10 * self._std_weight_velocity * measurement[3]]
+ covariance = np.diag(np.square(std))
+ return mean, covariance
+
+ def predict(self, mean, covariance):
+ """
+ Run Kalman filter prediction step.
+
+ Parameters
+ ----------
+ mean : ndarray
+ The 8 dimensional mean vector of the object state at the previous time step.
+ covariance : ndarray
+ The 8x8 dimensional covariance matrix of the object state at the previous time step.
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the mean vector and covariance matrix of the predicted state. Unobserved velocities are
+ initialized to 0 mean.
+ """
+ std_pos = [
+ self._std_weight_position * mean[3], self._std_weight_position * mean[3], 1e-2,
+ self._std_weight_position * mean[3]]
+ std_vel = [
+ self._std_weight_velocity * mean[3], self._std_weight_velocity * mean[3], 1e-5,
+ self._std_weight_velocity * mean[3]]
+ motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
+
+ # mean = np.dot(self._motion_mat, mean)
+ mean = np.dot(mean, self._motion_mat.T)
+ covariance = np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
+
+ return mean, covariance
+
+ def project(self, mean, covariance):
+ """
+ Project state distribution to measurement space.
+
+ Parameters
+ ----------
+ mean : ndarray
+ The state's mean vector (8 dimensional array).
+ covariance : ndarray
+ The state's covariance matrix (8x8 dimensional).
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the projected mean and covariance matrix of the given state estimate.
+ """
+ std = [
+ self._std_weight_position * mean[3], self._std_weight_position * mean[3], 1e-1,
+ self._std_weight_position * mean[3]]
+ innovation_cov = np.diag(np.square(std))
+
+ mean = np.dot(self._update_mat, mean)
+ covariance = np.linalg.multi_dot((self._update_mat, covariance, self._update_mat.T))
+ return mean, covariance + innovation_cov
+
+ def multi_predict(self, mean, covariance):
+ """
+ Run Kalman filter prediction step (Vectorized version).
+
+ Parameters
+ ----------
+ mean : ndarray
+ The Nx8 dimensional mean matrix of the object states at the previous time step.
+ covariance : ndarray
+ The Nx8x8 dimensional covariance matrix of the object states at the previous time step.
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the mean vector and covariance matrix of the predicted state. Unobserved velocities are
+ initialized to 0 mean.
+ """
+ std_pos = [
+ self._std_weight_position * mean[:, 3], self._std_weight_position * mean[:, 3],
+ 1e-2 * np.ones_like(mean[:, 3]), self._std_weight_position * mean[:, 3]]
+ std_vel = [
+ self._std_weight_velocity * mean[:, 3], self._std_weight_velocity * mean[:, 3],
+ 1e-5 * np.ones_like(mean[:, 3]), self._std_weight_velocity * mean[:, 3]]
+ sqr = np.square(np.r_[std_pos, std_vel]).T
+
+ motion_cov = [np.diag(sqr[i]) for i in range(len(mean))]
+ motion_cov = np.asarray(motion_cov)
+
+ mean = np.dot(mean, self._motion_mat.T)
+ left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
+ covariance = np.dot(left, self._motion_mat.T) + motion_cov
+
+ return mean, covariance
+
+ def update(self, mean, covariance, measurement):
+ """
+ Run Kalman filter correction step.
+
+ Parameters
+ ----------
+ mean : ndarray
+ The predicted state's mean vector (8 dimensional).
+ covariance : ndarray
+ The state's covariance matrix (8x8 dimensional).
+ measurement : ndarray
+ The 4 dimensional measurement vector (x, y, a, h), where (x, y) is the center position, a the aspect
+ ratio, and h the height of the bounding box.
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the measurement-corrected state distribution.
+ """
+ projected_mean, projected_cov = self.project(mean, covariance)
+
+ chol_factor, lower = scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
+ kalman_gain = scipy.linalg.cho_solve((chol_factor, lower),
+ np.dot(covariance, self._update_mat.T).T,
+ check_finite=False).T
+ innovation = measurement - projected_mean
+
+ new_mean = mean + np.dot(innovation, kalman_gain.T)
+ new_covariance = covariance - np.linalg.multi_dot((kalman_gain, projected_cov, kalman_gain.T))
+ return new_mean, new_covariance
+
+ def gating_distance(self, mean, covariance, measurements, only_position=False, metric='maha'):
+ """
+ Compute gating distance between state distribution and measurements. A suitable distance threshold can be
+ obtained from `chi2inv95`. If `only_position` is False, the chi-square distribution has 4 degrees of freedom,
+ otherwise 2.
+
+ Parameters
+ ----------
+ mean : ndarray
+ Mean vector over the state distribution (8 dimensional).
+ covariance : ndarray
+ Covariance of the state distribution (8x8 dimensional).
+ measurements : ndarray
+ An Nx4 dimensional matrix of N measurements, each in format (x, y, a, h) where (x, y) is the bounding box
+ center position, a the aspect ratio, and h the height.
+ only_position : Optional[bool]
+ If True, distance computation is done with respect to the bounding box center position only.
+
+ Returns
+ -------
+ ndarray
+ Returns an array of length N, where the i-th element contains the squared Mahalanobis distance between
+ (mean, covariance) and `measurements[i]`.
+ """
+ mean, covariance = self.project(mean, covariance)
+ if only_position:
+ mean, covariance = mean[:2], covariance[:2, :2]
+ measurements = measurements[:, :2]
+
+ d = measurements - mean
+ if metric == 'gaussian':
+ return np.sum(d * d, axis=1)
+ elif metric == 'maha':
+ cholesky_factor = np.linalg.cholesky(covariance)
+ z = scipy.linalg.solve_triangular(cholesky_factor, d.T, lower=True, check_finite=False, overwrite_b=True)
+ return np.sum(z * z, axis=0) # square maha
+ else:
+ raise ValueError('invalid distance metric')
+
+
+class KalmanFilterXYWH(KalmanFilterXYAH):
+ """
+ For BoT-SORT. A simple Kalman filter for tracking bounding boxes in image space.
+
+ The 8-dimensional state space (x, y, w, h, vx, vy, vw, vh) contains the bounding box center position (x, y), width
+ w, height h, and their respective velocities.
+
+ Object motion follows a constant velocity model. The bounding box location (x, y, w, h) is taken as direct
+ observation of the state space (linear observation model).
+ """
+
+ def initiate(self, measurement):
+ """
+ Create track from unassociated measurement.
+
+ Parameters
+ ----------
+ measurement : ndarray
+ Bounding box coordinates (x, y, w, h) with center position (x, y), width w, and height h.
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the mean vector (8 dimensional) and covariance matrix (8x8 dimensional) of the new track.
+ Unobserved velocities are initialized to 0 mean.
+ """
+ mean_pos = measurement
+ mean_vel = np.zeros_like(mean_pos)
+ mean = np.r_[mean_pos, mean_vel]
+
+ std = [
+ 2 * self._std_weight_position * measurement[2], 2 * self._std_weight_position * measurement[3],
+ 2 * self._std_weight_position * measurement[2], 2 * self._std_weight_position * measurement[3],
+ 10 * self._std_weight_velocity * measurement[2], 10 * self._std_weight_velocity * measurement[3],
+ 10 * self._std_weight_velocity * measurement[2], 10 * self._std_weight_velocity * measurement[3]]
+ covariance = np.diag(np.square(std))
+ return mean, covariance
+
+ def predict(self, mean, covariance):
+ """
+ Run Kalman filter prediction step.
+
+ Parameters
+ ----------
+ mean : ndarray
+ The 8 dimensional mean vector of the object state at the previous time step.
+ covariance : ndarray
+ The 8x8 dimensional covariance matrix of the object state at the previous time step.
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the mean vector and covariance matrix of the predicted state. Unobserved velocities are
+ initialized to 0 mean.
+ """
+ std_pos = [
+ self._std_weight_position * mean[2], self._std_weight_position * mean[3],
+ self._std_weight_position * mean[2], self._std_weight_position * mean[3]]
+ std_vel = [
+ self._std_weight_velocity * mean[2], self._std_weight_velocity * mean[3],
+ self._std_weight_velocity * mean[2], self._std_weight_velocity * mean[3]]
+ motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
+
+ mean = np.dot(mean, self._motion_mat.T)
+ covariance = np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
+
+ return mean, covariance
+
+ def project(self, mean, covariance):
+ """
+ Project state distribution to measurement space.
+
+ Parameters
+ ----------
+ mean : ndarray
+ The state's mean vector (8 dimensional array).
+ covariance : ndarray
+ The state's covariance matrix (8x8 dimensional).
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the projected mean and covariance matrix of the given state estimate.
+ """
+ std = [
+ self._std_weight_position * mean[2], self._std_weight_position * mean[3],
+ self._std_weight_position * mean[2], self._std_weight_position * mean[3]]
+ innovation_cov = np.diag(np.square(std))
+
+ mean = np.dot(self._update_mat, mean)
+ covariance = np.linalg.multi_dot((self._update_mat, covariance, self._update_mat.T))
+ return mean, covariance + innovation_cov
+
+ def multi_predict(self, mean, covariance):
+ """
+ Run Kalman filter prediction step (Vectorized version).
+
+ Parameters
+ ----------
+ mean : ndarray
+ The Nx8 dimensional mean matrix of the object states at the previous time step.
+ covariance : ndarray
+ The Nx8x8 dimensional covariance matrix of the object states at the previous time step.
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the mean vector and covariance matrix of the predicted state. Unobserved velocities are
+ initialized to 0 mean.
+ """
+ std_pos = [
+ self._std_weight_position * mean[:, 2], self._std_weight_position * mean[:, 3],
+ self._std_weight_position * mean[:, 2], self._std_weight_position * mean[:, 3]]
+ std_vel = [
+ self._std_weight_velocity * mean[:, 2], self._std_weight_velocity * mean[:, 3],
+ self._std_weight_velocity * mean[:, 2], self._std_weight_velocity * mean[:, 3]]
+ sqr = np.square(np.r_[std_pos, std_vel]).T
+
+ motion_cov = [np.diag(sqr[i]) for i in range(len(mean))]
+ motion_cov = np.asarray(motion_cov)
+
+ mean = np.dot(mean, self._motion_mat.T)
+ left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
+ covariance = np.dot(left, self._motion_mat.T) + motion_cov
+
+ return mean, covariance
+
+ def update(self, mean, covariance, measurement):
+ """
+ Run Kalman filter correction step.
+
+ Parameters
+ ----------
+ mean : ndarray
+ The predicted state's mean vector (8 dimensional).
+ covariance : ndarray
+ The state's covariance matrix (8x8 dimensional).
+ measurement : ndarray
+ The 4 dimensional measurement vector (x, y, w, h), where (x, y) is the center position, w the width,
+ and h the height of the bounding box.
+
+ Returns
+ -------
+ (ndarray, ndarray)
+ Returns the measurement-corrected state distribution.
+ """
+ return super().update(mean, covariance, measurement)
diff --git a/ultralytics/ultralytics/trackers/utils/matching.py b/ultralytics/ultralytics/trackers/utils/matching.py
new file mode 100644
index 0000000000000000000000000000000000000000..f2ee75e549a98e28203f5886b1e725651251f12b
--- /dev/null
+++ b/ultralytics/ultralytics/trackers/utils/matching.py
@@ -0,0 +1,126 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import numpy as np
+import scipy
+from scipy.spatial.distance import cdist
+
+from ultralytics.utils.metrics import bbox_ioa
+
+try:
+ import lap # for linear_assignment
+
+ assert lap.__version__ # verify package is not directory
+except (ImportError, AssertionError, AttributeError):
+ from ultralytics.utils.checks import check_requirements
+
+ check_requirements('lapx>=0.5.2') # update to lap package from https://github.com/rathaROG/lapx
+ import lap
+
+
+def linear_assignment(cost_matrix, thresh, use_lap=True):
+ """
+ Perform linear assignment using scipy or lap.lapjv.
+
+ Args:
+ cost_matrix (np.ndarray): The matrix containing cost values for assignments.
+ thresh (float): Threshold for considering an assignment valid.
+ use_lap (bool, optional): Whether to use lap.lapjv. Defaults to True.
+
+ Returns:
+ (tuple): Tuple containing matched indices, unmatched indices from 'a', and unmatched indices from 'b'.
+ """
+
+ if cost_matrix.size == 0:
+ return np.empty((0, 2), dtype=int), tuple(range(cost_matrix.shape[0])), tuple(range(cost_matrix.shape[1]))
+
+ if use_lap:
+ # https://github.com/gatagat/lap
+ _, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh)
+ matches = [[ix, mx] for ix, mx in enumerate(x) if mx >= 0]
+ unmatched_a = np.where(x < 0)[0]
+ unmatched_b = np.where(y < 0)[0]
+ else:
+ # https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linear_sum_assignment.html
+ x, y = scipy.optimize.linear_sum_assignment(cost_matrix) # row x, col y
+ matches = np.asarray([[x[i], y[i]] for i in range(len(x)) if cost_matrix[x[i], y[i]] <= thresh])
+ if len(matches) == 0:
+ unmatched_a = list(np.arange(cost_matrix.shape[0]))
+ unmatched_b = list(np.arange(cost_matrix.shape[1]))
+ else:
+ unmatched_a = list(set(np.arange(cost_matrix.shape[0])) - set(matches[:, 0]))
+ unmatched_b = list(set(np.arange(cost_matrix.shape[1])) - set(matches[:, 1]))
+
+ return matches, unmatched_a, unmatched_b
+
+
+def iou_distance(atracks, btracks):
+ """
+ Compute cost based on Intersection over Union (IoU) between tracks.
+
+ Args:
+ atracks (list[STrack] | list[np.ndarray]): List of tracks 'a' or bounding boxes.
+ btracks (list[STrack] | list[np.ndarray]): List of tracks 'b' or bounding boxes.
+
+ Returns:
+ (np.ndarray): Cost matrix computed based on IoU.
+ """
+
+ if (len(atracks) > 0 and isinstance(atracks[0], np.ndarray)) \
+ or (len(btracks) > 0 and isinstance(btracks[0], np.ndarray)):
+ atlbrs = atracks
+ btlbrs = btracks
+ else:
+ atlbrs = [track.tlbr for track in atracks]
+ btlbrs = [track.tlbr for track in btracks]
+
+ ious = np.zeros((len(atlbrs), len(btlbrs)), dtype=np.float32)
+ if len(atlbrs) and len(btlbrs):
+ ious = bbox_ioa(np.ascontiguousarray(atlbrs, dtype=np.float32),
+ np.ascontiguousarray(btlbrs, dtype=np.float32),
+ iou=True)
+ return 1 - ious # cost matrix
+
+
+def embedding_distance(tracks, detections, metric='cosine'):
+ """
+ Compute distance between tracks and detections based on embeddings.
+
+ Args:
+ tracks (list[STrack]): List of tracks.
+ detections (list[BaseTrack]): List of detections.
+ metric (str, optional): Metric for distance computation. Defaults to 'cosine'.
+
+ Returns:
+ (np.ndarray): Cost matrix computed based on embeddings.
+ """
+
+ cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float32)
+ if cost_matrix.size == 0:
+ return cost_matrix
+ det_features = np.asarray([track.curr_feat for track in detections], dtype=np.float32)
+ # for i, track in enumerate(tracks):
+ # cost_matrix[i, :] = np.maximum(0.0, cdist(track.smooth_feat.reshape(1,-1), det_features, metric))
+ track_features = np.asarray([track.smooth_feat for track in tracks], dtype=np.float32)
+ cost_matrix = np.maximum(0.0, cdist(track_features, det_features, metric)) # Normalized features
+ return cost_matrix
+
+
+def fuse_score(cost_matrix, detections):
+ """
+ Fuses cost matrix with detection scores to produce a single similarity matrix.
+
+ Args:
+ cost_matrix (np.ndarray): The matrix containing cost values for assignments.
+ detections (list[BaseTrack]): List of detections with scores.
+
+ Returns:
+ (np.ndarray): Fused similarity matrix.
+ """
+
+ if cost_matrix.size == 0:
+ return cost_matrix
+ iou_sim = 1 - cost_matrix
+ det_scores = np.array([det.score for det in detections])
+ det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0)
+ fuse_sim = iou_sim * det_scores
+ return 1 - fuse_sim # fuse_cost
diff --git a/ultralytics/ultralytics/utils/__init__.py b/ultralytics/ultralytics/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1050da9440b08b926b5f2ac13d30713ae9b97714
--- /dev/null
+++ b/ultralytics/ultralytics/utils/__init__.py
@@ -0,0 +1,944 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+
+import contextlib
+import inspect
+import logging.config
+import os
+import platform
+import re
+import subprocess
+import sys
+import threading
+import urllib
+import uuid
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Union
+
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+import yaml
+from tqdm import tqdm as tqdm_original
+
+from ultralytics import __version__
+
+# PyTorch Multi-GPU DDP Constants
+RANK = int(os.getenv('RANK', -1))
+LOCAL_RANK = int(os.getenv('LOCAL_RANK', -1)) # https://pytorch.org/docs/stable/elastic/run.html
+
+# Other Constants
+FILE = Path(__file__).resolve()
+ROOT = FILE.parents[1] # YOLO
+ASSETS = ROOT / 'assets' # default images
+DEFAULT_CFG_PATH = ROOT / 'cfg/default.yaml'
+NUM_THREADS = min(8, max(1, os.cpu_count() - 1)) # number of YOLOv5 multiprocessing threads
+AUTOINSTALL = str(os.getenv('YOLO_AUTOINSTALL', True)).lower() == 'true' # global auto-install mode
+VERBOSE = str(os.getenv('YOLO_VERBOSE', True)).lower() == 'true' # global verbose mode
+TQDM_BAR_FORMAT = '{l_bar}{bar:10}{r_bar}' if VERBOSE else None # tqdm bar format
+LOGGING_NAME = 'ultralytics'
+MACOS, LINUX, WINDOWS = (platform.system() == x for x in ['Darwin', 'Linux', 'Windows']) # environment booleans
+ARM64 = platform.machine() in ('arm64', 'aarch64') # ARM64 booleans
+HELP_MSG = \
+ """
+ Usage examples for running YOLOv8:
+
+ 1. Install the ultralytics package:
+
+ pip install ultralytics
+
+ 2. Use the Python SDK:
+
+ from ultralytics import YOLO
+
+ # Load a model
+ model = YOLO('yolov8n.yaml') # build a new model from scratch
+ model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
+
+ # Use the model
+ results = model.train(data="coco128.yaml", epochs=3) # train the model
+ results = model.val() # evaluate model performance on the validation set
+ results = model('https://ultralytics.com/images/bus.jpg') # predict on an image
+ success = model.export(format='onnx') # export the model to ONNX format
+
+ 3. Use the command line interface (CLI):
+
+ YOLOv8 'yolo' CLI commands use the following syntax:
+
+ yolo TASK MODE ARGS
+
+ Where TASK (optional) is one of [detect, segment, classify]
+ MODE (required) is one of [train, val, predict, export]
+ ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
+ See all ARGS at https://docs.ultralytics.com/usage/cfg or with 'yolo cfg'
+
+ - Train a detection model for 10 epochs with an initial learning_rate of 0.01
+ yolo detect train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+
+ - Predict a YouTube video using a pretrained segmentation model at image size 320:
+ yolo segment predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+
+ - Val a pretrained detection model at batch-size 1 and image size 640:
+ yolo detect val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
+
+ - Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
+ yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+
+ - Run special commands:
+ yolo help
+ yolo checks
+ yolo version
+ yolo settings
+ yolo copy-cfg
+ yolo cfg
+
+ Docs: https://docs.ultralytics.com
+ Community: https://community.ultralytics.com
+ GitHub: https://github.com/ultralytics/ultralytics
+ """
+
+# Settings
+torch.set_printoptions(linewidth=320, precision=4, profile='default')
+np.set_printoptions(linewidth=320, formatter={'float_kind': '{:11.5g}'.format}) # format short g, %precision=5
+cv2.setNumThreads(0) # prevent OpenCV from multithreading (incompatible with PyTorch DataLoader)
+os.environ['NUMEXPR_MAX_THREADS'] = str(NUM_THREADS) # NumExpr max threads
+os.environ['CUBLAS_WORKSPACE_CONFIG'] = ':4096:8' # for deterministic training
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # suppress verbose TF compiler warnings in Colab
+
+
+class TQDM(tqdm_original):
+ """
+ Custom Ultralytics tqdm class with different default arguments.
+
+ Args:
+ *args (list): Positional arguments passed to original tqdm.
+ **kwargs (dict): Keyword arguments, with custom defaults applied.
+ """
+
+ def __init__(self, *args, **kwargs):
+ """Initialize custom Ultralytics tqdm class with different default arguments."""
+ # Set new default values (these can still be overridden when calling TQDM)
+ kwargs['disable'] = not VERBOSE or kwargs.get('disable', False) # logical 'and' with default value if passed
+ kwargs.setdefault('bar_format', TQDM_BAR_FORMAT) # override default value if passed
+ super().__init__(*args, **kwargs)
+
+
+class SimpleClass:
+ """Ultralytics SimpleClass is a base class providing helpful string representation, error reporting, and attribute
+ access methods for easier debugging and usage.
+ """
+
+ def __str__(self):
+ """Return a human-readable string representation of the object."""
+ attr = []
+ for a in dir(self):
+ v = getattr(self, a)
+ if not callable(v) and not a.startswith('_'):
+ if isinstance(v, SimpleClass):
+ # Display only the module and class name for subclasses
+ s = f'{a}: {v.__module__}.{v.__class__.__name__} object'
+ else:
+ s = f'{a}: {repr(v)}'
+ attr.append(s)
+ return f'{self.__module__}.{self.__class__.__name__} object with attributes:\n\n' + '\n'.join(attr)
+
+ def __repr__(self):
+ """Return a machine-readable string representation of the object."""
+ return self.__str__()
+
+ def __getattr__(self, attr):
+ """Custom attribute access error message with helpful information."""
+ name = self.__class__.__name__
+ raise AttributeError(f"'{name}' object has no attribute '{attr}'. See valid attributes below.\n{self.__doc__}")
+
+
+class IterableSimpleNamespace(SimpleNamespace):
+ """Ultralytics IterableSimpleNamespace is an extension class of SimpleNamespace that adds iterable functionality and
+ enables usage with dict() and for loops.
+ """
+
+ def __iter__(self):
+ """Return an iterator of key-value pairs from the namespace's attributes."""
+ return iter(vars(self).items())
+
+ def __str__(self):
+ """Return a human-readable string representation of the object."""
+ return '\n'.join(f'{k}={v}' for k, v in vars(self).items())
+
+ def __getattr__(self, attr):
+ """Custom attribute access error message with helpful information."""
+ name = self.__class__.__name__
+ raise AttributeError(f"""
+ '{name}' object has no attribute '{attr}'. This may be caused by a modified or out of date ultralytics
+ 'default.yaml' file.\nPlease update your code with 'pip install -U ultralytics' and if necessary replace
+ {DEFAULT_CFG_PATH} with the latest version from
+ https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/default.yaml
+ """)
+
+ def get(self, key, default=None):
+ """Return the value of the specified key if it exists; otherwise, return the default value."""
+ return getattr(self, key, default)
+
+
+def plt_settings(rcparams=None, backend='Agg'):
+ """
+ Decorator to temporarily set rc parameters and the backend for a plotting function.
+
+ Example:
+ decorator: @plt_settings({"font.size": 12})
+ context manager: with plt_settings({"font.size": 12}):
+
+ Args:
+ rcparams (dict): Dictionary of rc parameters to set.
+ backend (str, optional): Name of the backend to use. Defaults to 'Agg'.
+
+ Returns:
+ (Callable): Decorated function with temporarily set rc parameters and backend. This decorator can be
+ applied to any function that needs to have specific matplotlib rc parameters and backend for its execution.
+ """
+
+ if rcparams is None:
+ rcparams = {'font.size': 11}
+
+ def decorator(func):
+ """Decorator to apply temporary rc parameters and backend to a function."""
+
+ def wrapper(*args, **kwargs):
+ """Sets rc parameters and backend, calls the original function, and restores the settings."""
+ original_backend = plt.get_backend()
+ if backend != original_backend:
+ plt.close('all') # auto-close()ing of figures upon backend switching is deprecated since 3.8
+ plt.switch_backend(backend)
+
+ with plt.rc_context(rcparams):
+ result = func(*args, **kwargs)
+
+ if backend != original_backend:
+ plt.close('all')
+ plt.switch_backend(original_backend)
+ return result
+
+ return wrapper
+
+ return decorator
+
+
+def set_logging(name=LOGGING_NAME, verbose=True):
+ """Sets up logging for the given name."""
+ rank = int(os.getenv('RANK', -1)) # rank in world for Multi-GPU trainings
+ level = logging.INFO if verbose and rank in {-1, 0} else logging.ERROR
+ logging.config.dictConfig({
+ 'version': 1,
+ 'disable_existing_loggers': False,
+ 'formatters': {
+ name: {
+ 'format': '%(message)s'}},
+ 'handlers': {
+ name: {
+ 'class': 'logging.StreamHandler',
+ 'formatter': name,
+ 'level': level}},
+ 'loggers': {
+ name: {
+ 'level': level,
+ 'handlers': [name],
+ 'propagate': False}}})
+
+
+def emojis(string=''):
+ """Return platform-dependent emoji-safe version of string."""
+ return string.encode().decode('ascii', 'ignore') if WINDOWS else string
+
+
+class EmojiFilter(logging.Filter):
+ """
+ A custom logging filter class for removing emojis in log messages.
+
+ This filter is particularly useful for ensuring compatibility with Windows terminals that may not support the
+ display of emojis in log messages.
+ """
+
+ def filter(self, record):
+ """Filter logs by emoji unicode characters on windows."""
+ record.msg = emojis(record.msg)
+ return super().filter(record)
+
+
+# Set logger
+set_logging(LOGGING_NAME, verbose=VERBOSE) # run before defining LOGGER
+LOGGER = logging.getLogger(LOGGING_NAME) # define globally (used in train.py, val.py, detect.py, etc.)
+if WINDOWS: # emoji-safe logging
+ LOGGER.addFilter(EmojiFilter())
+for logger in 'sentry_sdk', 'urllib3.connectionpool':
+ logging.getLogger(logger).setLevel(logging.CRITICAL)
+
+
+class ThreadingLocked:
+ """
+ A decorator class for ensuring thread-safe execution of a function or method. This class can be used as a decorator
+ to make sure that if the decorated function is called from multiple threads, only one thread at a time will be able
+ to execute the function.
+
+ Attributes:
+ lock (threading.Lock): A lock object used to manage access to the decorated function.
+
+ Example:
+ ```python
+ from ultralytics.utils import ThreadingLocked
+
+ @ThreadingLocked()
+ def my_function():
+ # Your code here
+ pass
+ ```
+ """
+
+ def __init__(self):
+ """Initializes the decorator class for thread-safe execution of a function or method."""
+ self.lock = threading.Lock()
+
+ def __call__(self, f):
+ """Run thread-safe execution of function or method."""
+ from functools import wraps
+
+ @wraps(f)
+ def decorated(*args, **kwargs):
+ """Applies thread-safety to the decorated function or method."""
+ with self.lock:
+ return f(*args, **kwargs)
+
+ return decorated
+
+
+def yaml_save(file='data.yaml', data=None, header=''):
+ """
+ Save YAML data to a file.
+
+ Args:
+ file (str, optional): File name. Default is 'data.yaml'.
+ data (dict): Data to save in YAML format.
+ header (str, optional): YAML header to add.
+
+ Returns:
+ (None): Data is saved to the specified file.
+ """
+ if data is None:
+ data = {}
+ file = Path(file)
+ if not file.parent.exists():
+ # Create parent directories if they don't exist
+ file.parent.mkdir(parents=True, exist_ok=True)
+
+ # Convert Path objects to strings
+ valid_types = int, float, str, bool, list, tuple, dict, type(None)
+ for k, v in data.items():
+ if not isinstance(v, valid_types):
+ data[k] = str(v)
+
+ # Dump data to file in YAML format
+ with open(file, 'w', errors='ignore', encoding='utf-8') as f:
+ if header:
+ f.write(header)
+ yaml.safe_dump(data, f, sort_keys=False, allow_unicode=True)
+
+
+def yaml_load(file='data.yaml', append_filename=False):
+ """
+ Load YAML data from a file.
+
+ Args:
+ file (str, optional): File name. Default is 'data.yaml'.
+ append_filename (bool): Add the YAML filename to the YAML dictionary. Default is False.
+
+ Returns:
+ (dict): YAML data and file name.
+ """
+ assert Path(file).suffix in ('.yaml', '.yml'), f'Attempting to load non-YAML file {file} with yaml_load()'
+ with open(file, errors='ignore', encoding='utf-8') as f:
+ s = f.read() # string
+
+ # Remove special characters
+ if not s.isprintable():
+ s = re.sub(r'[^\x09\x0A\x0D\x20-\x7E\x85\xA0-\uD7FF\uE000-\uFFFD\U00010000-\U0010ffff]+', '', s)
+
+ # Add YAML filename to dict and return
+ data = yaml.safe_load(s) or {} # always return a dict (yaml.safe_load() may return None for empty files)
+ if append_filename:
+ data['yaml_file'] = str(file)
+ return data
+
+
+def yaml_print(yaml_file: Union[str, Path, dict]) -> None:
+ """
+ Pretty prints a YAML file or a YAML-formatted dictionary.
+
+ Args:
+ yaml_file: The file path of the YAML file or a YAML-formatted dictionary.
+
+ Returns:
+ None
+ """
+ yaml_dict = yaml_load(yaml_file) if isinstance(yaml_file, (str, Path)) else yaml_file
+ dump = yaml.dump(yaml_dict, sort_keys=False, allow_unicode=True)
+ LOGGER.info(f"Printing '{colorstr('bold', 'black', yaml_file)}'\n\n{dump}")
+
+
+# Default configuration
+DEFAULT_CFG_DICT = yaml_load(DEFAULT_CFG_PATH)
+for k, v in DEFAULT_CFG_DICT.items():
+ if isinstance(v, str) and v.lower() == 'none':
+ DEFAULT_CFG_DICT[k] = None
+DEFAULT_CFG_KEYS = DEFAULT_CFG_DICT.keys()
+DEFAULT_CFG = IterableSimpleNamespace(**DEFAULT_CFG_DICT)
+
+
+def is_ubuntu() -> bool:
+ """
+ Check if the OS is Ubuntu.
+
+ Returns:
+ (bool): True if OS is Ubuntu, False otherwise.
+ """
+ with contextlib.suppress(FileNotFoundError):
+ with open('/etc/os-release') as f:
+ return 'ID=ubuntu' in f.read()
+ return False
+
+
+def is_colab():
+ """
+ Check if the current script is running inside a Google Colab notebook.
+
+ Returns:
+ (bool): True if running inside a Colab notebook, False otherwise.
+ """
+ return 'COLAB_RELEASE_TAG' in os.environ or 'COLAB_BACKEND_VERSION' in os.environ
+
+
+def is_kaggle():
+ """
+ Check if the current script is running inside a Kaggle kernel.
+
+ Returns:
+ (bool): True if running inside a Kaggle kernel, False otherwise.
+ """
+ return os.environ.get('PWD') == '/kaggle/working' and os.environ.get('KAGGLE_URL_BASE') == 'https://www.kaggle.com'
+
+
+def is_jupyter():
+ """
+ Check if the current script is running inside a Jupyter Notebook. Verified on Colab, Jupyterlab, Kaggle, Paperspace.
+
+ Returns:
+ (bool): True if running inside a Jupyter Notebook, False otherwise.
+ """
+ with contextlib.suppress(Exception):
+ from IPython import get_ipython
+ return get_ipython() is not None
+ return False
+
+
+def is_docker() -> bool:
+ """
+ Determine if the script is running inside a Docker container.
+
+ Returns:
+ (bool): True if the script is running inside a Docker container, False otherwise.
+ """
+ file = Path('/proc/self/cgroup')
+ if file.exists():
+ with open(file) as f:
+ return 'docker' in f.read()
+ else:
+ return False
+
+
+def is_online() -> bool:
+ """
+ Check internet connectivity by attempting to connect to a known online host.
+
+ Returns:
+ (bool): True if connection is successful, False otherwise.
+ """
+ import socket
+
+ for host in '1.1.1.1', '8.8.8.8', '223.5.5.5': # Cloudflare, Google, AliDNS:
+ try:
+ test_connection = socket.create_connection(address=(host, 53), timeout=2)
+ except (socket.timeout, socket.gaierror, OSError):
+ continue
+ else:
+ # If the connection was successful, close it to avoid a ResourceWarning
+ test_connection.close()
+ return True
+ return False
+
+
+ONLINE = is_online()
+
+
+def is_pip_package(filepath: str = __name__) -> bool:
+ """
+ Determines if the file at the given filepath is part of a pip package.
+
+ Args:
+ filepath (str): The filepath to check.
+
+ Returns:
+ (bool): True if the file is part of a pip package, False otherwise.
+ """
+ import importlib.util
+
+ # Get the spec for the module
+ spec = importlib.util.find_spec(filepath)
+
+ # Return whether the spec is not None and the origin is not None (indicating it is a package)
+ return spec is not None and spec.origin is not None
+
+
+def is_dir_writeable(dir_path: Union[str, Path]) -> bool:
+ """
+ Check if a directory is writeable.
+
+ Args:
+ dir_path (str | Path): The path to the directory.
+
+ Returns:
+ (bool): True if the directory is writeable, False otherwise.
+ """
+ return os.access(str(dir_path), os.W_OK)
+
+
+def is_pytest_running():
+ """
+ Determines whether pytest is currently running or not.
+
+ Returns:
+ (bool): True if pytest is running, False otherwise.
+ """
+ return ('PYTEST_CURRENT_TEST' in os.environ) or ('pytest' in sys.modules) or ('pytest' in Path(sys.argv[0]).stem)
+
+
+def is_github_actions_ci() -> bool:
+ """
+ Determine if the current environment is a GitHub Actions CI Python runner.
+
+ Returns:
+ (bool): True if the current environment is a GitHub Actions CI Python runner, False otherwise.
+ """
+ return 'GITHUB_ACTIONS' in os.environ and 'RUNNER_OS' in os.environ and 'RUNNER_TOOL_CACHE' in os.environ
+
+
+def is_git_dir():
+ """
+ Determines whether the current file is part of a git repository. If the current file is not part of a git
+ repository, returns None.
+
+ Returns:
+ (bool): True if current file is part of a git repository.
+ """
+ return get_git_dir() is not None
+
+
+def get_git_dir():
+ """
+ Determines whether the current file is part of a git repository and if so, returns the repository root directory. If
+ the current file is not part of a git repository, returns None.
+
+ Returns:
+ (Path | None): Git root directory if found or None if not found.
+ """
+ for d in Path(__file__).parents:
+ if (d / '.git').is_dir():
+ return d
+
+
+def get_git_origin_url():
+ """
+ Retrieves the origin URL of a git repository.
+
+ Returns:
+ (str | None): The origin URL of the git repository or None if not git directory.
+ """
+ if is_git_dir():
+ with contextlib.suppress(subprocess.CalledProcessError):
+ origin = subprocess.check_output(['git', 'config', '--get', 'remote.origin.url'])
+ return origin.decode().strip()
+
+
+def get_git_branch():
+ """
+ Returns the current git branch name. If not in a git repository, returns None.
+
+ Returns:
+ (str | None): The current git branch name or None if not a git directory.
+ """
+ if is_git_dir():
+ with contextlib.suppress(subprocess.CalledProcessError):
+ origin = subprocess.check_output(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])
+ return origin.decode().strip()
+
+
+def get_default_args(func):
+ """
+ Returns a dictionary of default arguments for a function.
+
+ Args:
+ func (callable): The function to inspect.
+
+ Returns:
+ (dict): A dictionary where each key is a parameter name, and each value is the default value of that parameter.
+ """
+ signature = inspect.signature(func)
+ return {k: v.default for k, v in signature.parameters.items() if v.default is not inspect.Parameter.empty}
+
+
+def get_ubuntu_version():
+ """
+ Retrieve the Ubuntu version if the OS is Ubuntu.
+
+ Returns:
+ (str): Ubuntu version or None if not an Ubuntu OS.
+ """
+ if is_ubuntu():
+ with contextlib.suppress(FileNotFoundError, AttributeError):
+ with open('/etc/os-release') as f:
+ return re.search(r'VERSION_ID="(\d+\.\d+)"', f.read())[1]
+
+
+def get_user_config_dir(sub_dir='Ultralytics'):
+ """
+ Get the user config directory.
+
+ Args:
+ sub_dir (str): The name of the subdirectory to create.
+
+ Returns:
+ (Path): The path to the user config directory.
+ """
+ # Return the appropriate config directory for each operating system
+ if WINDOWS:
+ path = Path.home() / 'AppData' / 'Roaming' / sub_dir
+ elif MACOS: # macOS
+ path = Path.home() / 'Library' / 'Application Support' / sub_dir
+ elif LINUX:
+ path = Path.home() / '.config' / sub_dir
+ else:
+ raise ValueError(f'Unsupported operating system: {platform.system()}')
+
+ # GCP and AWS lambda fix, only /tmp is writeable
+ if not is_dir_writeable(path.parent):
+ LOGGER.warning(f"WARNING ⚠️ user config directory '{path}' is not writeable, defaulting to '/tmp' or CWD."
+ 'Alternatively you can define a YOLO_CONFIG_DIR environment variable for this path.')
+ path = Path('/tmp') / sub_dir if is_dir_writeable('/tmp') else Path().cwd() / sub_dir
+
+ # Create the subdirectory if it does not exist
+ path.mkdir(parents=True, exist_ok=True)
+
+ return path
+
+
+USER_CONFIG_DIR = Path(os.getenv('YOLO_CONFIG_DIR') or get_user_config_dir()) # Ultralytics settings dir
+SETTINGS_YAML = USER_CONFIG_DIR / 'settings.yaml'
+
+
+def colorstr(*input):
+ """
+ Colors a string based on the provided color and style arguments. Utilizes ANSI escape codes.
+ See https://en.wikipedia.org/wiki/ANSI_escape_code for more details.
+
+ This function can be called in two ways:
+ - colorstr('color', 'style', 'your string')
+ - colorstr('your string')
+
+ In the second form, 'blue' and 'bold' will be applied by default.
+
+ Args:
+ *input (str): A sequence of strings where the first n-1 strings are color and style arguments,
+ and the last string is the one to be colored.
+
+ Supported Colors and Styles:
+ Basic Colors: 'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'
+ Bright Colors: 'bright_black', 'bright_red', 'bright_green', 'bright_yellow',
+ 'bright_blue', 'bright_magenta', 'bright_cyan', 'bright_white'
+ Misc: 'end', 'bold', 'underline'
+
+ Returns:
+ (str): The input string wrapped with ANSI escape codes for the specified color and style.
+
+ Examples:
+ >>> colorstr('blue', 'bold', 'hello world')
+ >>> '\033[34m\033[1mhello world\033[0m'
+ """
+ *args, string = input if len(input) > 1 else ('blue', 'bold', input[0]) # color arguments, string
+ colors = {
+ 'black': '\033[30m', # basic colors
+ 'red': '\033[31m',
+ 'green': '\033[32m',
+ 'yellow': '\033[33m',
+ 'blue': '\033[34m',
+ 'magenta': '\033[35m',
+ 'cyan': '\033[36m',
+ 'white': '\033[37m',
+ 'bright_black': '\033[90m', # bright colors
+ 'bright_red': '\033[91m',
+ 'bright_green': '\033[92m',
+ 'bright_yellow': '\033[93m',
+ 'bright_blue': '\033[94m',
+ 'bright_magenta': '\033[95m',
+ 'bright_cyan': '\033[96m',
+ 'bright_white': '\033[97m',
+ 'end': '\033[0m', # misc
+ 'bold': '\033[1m',
+ 'underline': '\033[4m'}
+ return ''.join(colors[x] for x in args) + f'{string}' + colors['end']
+
+
+def remove_colorstr(input_string):
+ """
+ Removes ANSI escape codes from a string, effectively un-coloring it.
+
+ Args:
+ input_string (str): The string to remove color and style from.
+
+ Returns:
+ (str): A new string with all ANSI escape codes removed.
+
+ Examples:
+ >>> remove_colorstr(colorstr('blue', 'bold', 'hello world'))
+ >>> 'hello world'
+ """
+ ansi_escape = re.compile(r'\x1B\[[0-9;]*[A-Za-z]')
+ return ansi_escape.sub('', input_string)
+
+
+class TryExcept(contextlib.ContextDecorator):
+ """
+ YOLOv8 TryExcept class.
+
+ Use as @TryExcept() decorator or 'with TryExcept():' context manager.
+ """
+
+ def __init__(self, msg='', verbose=True):
+ """Initialize TryExcept class with optional message and verbosity settings."""
+ self.msg = msg
+ self.verbose = verbose
+
+ def __enter__(self):
+ """Executes when entering TryExcept context, initializes instance."""
+ pass
+
+ def __exit__(self, exc_type, value, traceback):
+ """Defines behavior when exiting a 'with' block, prints error message if necessary."""
+ if self.verbose and value:
+ print(emojis(f"{self.msg}{': ' if self.msg else ''}{value}"))
+ return True
+
+
+def threaded(func):
+ """
+ Multi-threads a target function and returns thread.
+
+ Use as @threaded decorator.
+ """
+
+ def wrapper(*args, **kwargs):
+ """Multi-threads a given function and returns the thread."""
+ thread = threading.Thread(target=func, args=args, kwargs=kwargs, daemon=True)
+ thread.start()
+ return thread
+
+ return wrapper
+
+
+def set_sentry():
+ """
+ Initialize the Sentry SDK for error tracking and reporting. Only used if sentry_sdk package is installed and
+ sync=True in settings. Run 'yolo settings' to see and update settings YAML file.
+
+ Conditions required to send errors (ALL conditions must be met or no errors will be reported):
+ - sentry_sdk package is installed
+ - sync=True in YOLO settings
+ - pytest is not running
+ - running in a pip package installation
+ - running in a non-git directory
+ - running with rank -1 or 0
+ - online environment
+ - CLI used to run package (checked with 'yolo' as the name of the main CLI command)
+
+ The function also configures Sentry SDK to ignore KeyboardInterrupt and FileNotFoundError
+ exceptions and to exclude events with 'out of memory' in their exception message.
+
+ Additionally, the function sets custom tags and user information for Sentry events.
+ """
+
+ def before_send(event, hint):
+ """
+ Modify the event before sending it to Sentry based on specific exception types and messages.
+
+ Args:
+ event (dict): The event dictionary containing information about the error.
+ hint (dict): A dictionary containing additional information about the error.
+
+ Returns:
+ dict: The modified event or None if the event should not be sent to Sentry.
+ """
+ if 'exc_info' in hint:
+ exc_type, exc_value, tb = hint['exc_info']
+ if exc_type in (KeyboardInterrupt, FileNotFoundError) \
+ or 'out of memory' in str(exc_value):
+ return None # do not send event
+
+ event['tags'] = {
+ 'sys_argv': sys.argv[0],
+ 'sys_argv_name': Path(sys.argv[0]).name,
+ 'install': 'git' if is_git_dir() else 'pip' if is_pip_package() else 'other',
+ 'os': ENVIRONMENT}
+ return event
+
+ if SETTINGS['sync'] and \
+ RANK in (-1, 0) and \
+ Path(sys.argv[0]).name == 'yolo' and \
+ not TESTS_RUNNING and \
+ ONLINE and \
+ is_pip_package() and \
+ not is_git_dir():
+
+ # If sentry_sdk package is not installed then return and do not use Sentry
+ try:
+ import sentry_sdk # noqa
+ except ImportError:
+ return
+
+ sentry_sdk.init(
+ dsn='https://5ff1556b71594bfea135ff0203a0d290@o4504521589325824.ingest.sentry.io/4504521592406016',
+ debug=False,
+ traces_sample_rate=1.0,
+ release=__version__,
+ environment='production', # 'dev' or 'production'
+ before_send=before_send,
+ ignore_errors=[KeyboardInterrupt, FileNotFoundError])
+ sentry_sdk.set_user({'id': SETTINGS['uuid']}) # SHA-256 anonymized UUID hash
+
+
+class SettingsManager(dict):
+ """
+ Manages Ultralytics settings stored in a YAML file.
+
+ Args:
+ file (str | Path): Path to the Ultralytics settings YAML file. Default is USER_CONFIG_DIR / 'settings.yaml'.
+ version (str): Settings version. In case of local version mismatch, new default settings will be saved.
+ """
+
+ def __init__(self, file=SETTINGS_YAML, version='0.0.4'):
+ """Initialize the SettingsManager with default settings, load and validate current settings from the YAML
+ file.
+ """
+ import copy
+ import hashlib
+
+ from ultralytics.utils.checks import check_version
+ from ultralytics.utils.torch_utils import torch_distributed_zero_first
+
+ git_dir = get_git_dir()
+ root = git_dir or Path()
+ datasets_root = (root.parent if git_dir and is_dir_writeable(root.parent) else root).resolve()
+
+ self.file = Path(file)
+ self.version = version
+ self.defaults = {
+ 'settings_version': version,
+ 'datasets_dir': str(datasets_root / 'datasets'),
+ 'weights_dir': str(root / 'weights'),
+ 'runs_dir': str(root / 'runs'),
+ 'uuid': hashlib.sha256(str(uuid.getnode()).encode()).hexdigest(),
+ 'sync': True,
+ 'api_key': '',
+ 'clearml': True, # integrations
+ 'comet': True,
+ 'dvc': True,
+ 'hub': True,
+ 'mlflow': True,
+ 'neptune': True,
+ 'raytune': True,
+ 'tensorboard': True,
+ 'wandb': True}
+
+ super().__init__(copy.deepcopy(self.defaults))
+
+ with torch_distributed_zero_first(RANK):
+ if not self.file.exists():
+ self.save()
+
+ self.load()
+ correct_keys = self.keys() == self.defaults.keys()
+ correct_types = all(type(a) is type(b) for a, b in zip(self.values(), self.defaults.values()))
+ correct_version = check_version(self['settings_version'], self.version)
+ if not (correct_keys and correct_types and correct_version):
+ LOGGER.warning(
+ 'WARNING ⚠️ Ultralytics settings reset to default values. This may be due to a possible problem '
+ 'with your settings or a recent ultralytics package update. '
+ f"\nView settings with 'yolo settings' or at '{self.file}'"
+ "\nUpdate settings with 'yolo settings key=value', i.e. 'yolo settings runs_dir=path/to/dir'.")
+ self.reset()
+
+ def load(self):
+ """Loads settings from the YAML file."""
+ super().update(yaml_load(self.file))
+
+ def save(self):
+ """Saves the current settings to the YAML file."""
+ yaml_save(self.file, dict(self))
+
+ def update(self, *args, **kwargs):
+ """Updates a setting value in the current settings."""
+ super().update(*args, **kwargs)
+ self.save()
+
+ def reset(self):
+ """Resets the settings to default and saves them."""
+ self.clear()
+ self.update(self.defaults)
+ self.save()
+
+
+def deprecation_warn(arg, new_arg, version=None):
+ """Issue a deprecation warning when a deprecated argument is used, suggesting an updated argument."""
+ if not version:
+ version = float(__version__[:3]) + 0.2 # deprecate after 2nd major release
+ LOGGER.warning(f"WARNING ⚠️ '{arg}' is deprecated and will be removed in 'ultralytics {version}' in the future. "
+ f"Please use '{new_arg}' instead.")
+
+
+def clean_url(url):
+ """Strip auth from URL, i.e. https://url.com/file.txt?auth -> https://url.com/file.txt."""
+ url = Path(url).as_posix().replace(':/', '://') # Pathlib turns :// -> :/, as_posix() for Windows
+ return urllib.parse.unquote(url).split('?')[0] # '%2F' to '/', split https://url.com/file.txt?auth
+
+
+def url2file(url):
+ """Convert URL to filename, i.e. https://url.com/file.txt?auth -> file.txt."""
+ return Path(clean_url(url)).name
+
+
+# Run below code on utils init ------------------------------------------------------------------------------------
+
+# Check first-install steps
+PREFIX = colorstr('Ultralytics: ')
+SETTINGS = SettingsManager() # initialize settings
+DATASETS_DIR = Path(SETTINGS['datasets_dir']) # global datasets directory
+WEIGHTS_DIR = Path(SETTINGS['weights_dir']) # global weights directory
+RUNS_DIR = Path(SETTINGS['runs_dir']) # global runs directory
+ENVIRONMENT = 'Colab' if is_colab() else 'Kaggle' if is_kaggle() else 'Jupyter' if is_jupyter() else \
+ 'Docker' if is_docker() else platform.system()
+TESTS_RUNNING = is_pytest_running() or is_github_actions_ci()
+set_sentry()
+
+# Apply monkey patches
+from .patches import imread, imshow, imwrite, torch_save
+
+torch.save = torch_save
+if WINDOWS:
+ # Apply cv2 patches for non-ASCII and non-UTF characters in image paths
+ cv2.imread, cv2.imwrite, cv2.imshow = imread, imwrite, imshow
diff --git a/ultralytics/ultralytics/utils/autobatch.py b/ultralytics/ultralytics/utils/autobatch.py
new file mode 100644
index 0000000000000000000000000000000000000000..172a4c12d804f392f0946ae818f664a9f91cda4b
--- /dev/null
+++ b/ultralytics/ultralytics/utils/autobatch.py
@@ -0,0 +1,88 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+"""Functions for estimating the best YOLO batch size to use a fraction of the available CUDA memory in PyTorch."""
+
+from copy import deepcopy
+
+import numpy as np
+import torch
+
+from ultralytics.utils import DEFAULT_CFG, LOGGER, colorstr
+from ultralytics.utils.torch_utils import profile
+
+
+def check_train_batch_size(model, imgsz=640, amp=True):
+ """
+ Check YOLO training batch size using the autobatch() function.
+
+ Args:
+ model (torch.nn.Module): YOLO model to check batch size for.
+ imgsz (int): Image size used for training.
+ amp (bool): If True, use automatic mixed precision (AMP) for training.
+
+ Returns:
+ (int): Optimal batch size computed using the autobatch() function.
+ """
+
+ with torch.cuda.amp.autocast(amp):
+ return autobatch(deepcopy(model).train(), imgsz) # compute optimal batch size
+
+
+def autobatch(model, imgsz=640, fraction=0.60, batch_size=DEFAULT_CFG.batch):
+ """
+ Automatically estimate the best YOLO batch size to use a fraction of the available CUDA memory.
+
+ Args:
+ model (torch.nn.module): YOLO model to compute batch size for.
+ imgsz (int, optional): The image size used as input for the YOLO model. Defaults to 640.
+ fraction (float, optional): The fraction of available CUDA memory to use. Defaults to 0.60.
+ batch_size (int, optional): The default batch size to use if an error is detected. Defaults to 16.
+
+ Returns:
+ (int): The optimal batch size.
+ """
+
+ # Check device
+ prefix = colorstr('AutoBatch: ')
+ LOGGER.info(f'{prefix}Computing optimal batch size for imgsz={imgsz}')
+ device = next(model.parameters()).device # get model device
+ if device.type == 'cpu':
+ LOGGER.info(f'{prefix}CUDA not detected, using default CPU batch-size {batch_size}')
+ return batch_size
+ if torch.backends.cudnn.benchmark:
+ LOGGER.info(f'{prefix} ⚠️ Requires torch.backends.cudnn.benchmark=False, using default batch-size {batch_size}')
+ return batch_size
+
+ # Inspect CUDA memory
+ gb = 1 << 30 # bytes to GiB (1024 ** 3)
+ d = str(device).upper() # 'CUDA:0'
+ properties = torch.cuda.get_device_properties(device) # device properties
+ t = properties.total_memory / gb # GiB total
+ r = torch.cuda.memory_reserved(device) / gb # GiB reserved
+ a = torch.cuda.memory_allocated(device) / gb # GiB allocated
+ f = t - (r + a) # GiB free
+ LOGGER.info(f'{prefix}{d} ({properties.name}) {t:.2f}G total, {r:.2f}G reserved, {a:.2f}G allocated, {f:.2f}G free')
+
+ # Profile batch sizes
+ batch_sizes = [1, 2, 4, 8, 16]
+ try:
+ img = [torch.empty(b, 3, imgsz, imgsz) for b in batch_sizes]
+ results = profile(img, model, n=3, device=device)
+
+ # Fit a solution
+ y = [x[2] for x in results if x] # memory [2]
+ p = np.polyfit(batch_sizes[:len(y)], y, deg=1) # first degree polynomial fit
+ b = int((f * fraction - p[1]) / p[0]) # y intercept (optimal batch size)
+ if None in results: # some sizes failed
+ i = results.index(None) # first fail index
+ if b >= batch_sizes[i]: # y intercept above failure point
+ b = batch_sizes[max(i - 1, 0)] # select prior safe point
+ if b < 1 or b > 1024: # b outside of safe range
+ b = batch_size
+ LOGGER.info(f'{prefix}WARNING ⚠️ CUDA anomaly detected, using default batch-size {batch_size}.')
+
+ fraction = (np.polyval(p, b) + r + a) / t # actual fraction predicted
+ LOGGER.info(f'{prefix}Using batch-size {b} for {d} {t * fraction:.2f}G/{t:.2f}G ({fraction * 100:.0f}%) ✅')
+ return b
+ except Exception as e:
+ LOGGER.warning(f'{prefix}WARNING ⚠️ error detected: {e}, using default batch-size {batch_size}.')
+ return batch_size
diff --git a/ultralytics/ultralytics/utils/benchmarks.py b/ultralytics/ultralytics/utils/benchmarks.py
new file mode 100644
index 0000000000000000000000000000000000000000..4842ff5bb2e9d0918364fb46fa0d6e74327ddc37
--- /dev/null
+++ b/ultralytics/ultralytics/utils/benchmarks.py
@@ -0,0 +1,393 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+"""
+Benchmark a YOLO model formats for speed and accuracy.
+
+Usage:
+ from ultralytics.utils.benchmarks import ProfileModels, benchmark
+ ProfileModels(['yolov8n.yaml', 'yolov8s.yaml']).profile()
+ benchmark(model='yolov8n.pt', imgsz=160)
+
+Format | `format=argument` | Model
+--- | --- | ---
+PyTorch | - | yolov8n.pt
+TorchScript | `torchscript` | yolov8n.torchscript
+ONNX | `onnx` | yolov8n.onnx
+OpenVINO | `openvino` | yolov8n_openvino_model/
+TensorRT | `engine` | yolov8n.engine
+CoreML | `coreml` | yolov8n.mlpackage
+TensorFlow SavedModel | `saved_model` | yolov8n_saved_model/
+TensorFlow GraphDef | `pb` | yolov8n.pb
+TensorFlow Lite | `tflite` | yolov8n.tflite
+TensorFlow Edge TPU | `edgetpu` | yolov8n_edgetpu.tflite
+TensorFlow.js | `tfjs` | yolov8n_web_model/
+PaddlePaddle | `paddle` | yolov8n_paddle_model/
+ncnn | `ncnn` | yolov8n_ncnn_model/
+"""
+
+import glob
+import platform
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import torch.cuda
+
+from ultralytics import YOLO
+from ultralytics.cfg import TASK2DATA, TASK2METRIC
+from ultralytics.engine.exporter import export_formats
+from ultralytics.utils import ASSETS, LINUX, LOGGER, MACOS, TQDM, WEIGHTS_DIR
+from ultralytics.utils.checks import check_requirements, check_yolo
+from ultralytics.utils.files import file_size
+from ultralytics.utils.torch_utils import select_device
+
+
+def benchmark(model=WEIGHTS_DIR / 'yolov8n.pt',
+ data=None,
+ imgsz=160,
+ half=False,
+ int8=False,
+ device='cpu',
+ verbose=False):
+ """
+ Benchmark a YOLO model across different formats for speed and accuracy.
+
+ Args:
+ model (str | Path | optional): Path to the model file or directory. Default is
+ Path(SETTINGS['weights_dir']) / 'yolov8n.pt'.
+ data (str, optional): Dataset to evaluate on, inherited from TASK2DATA if not passed. Default is None.
+ imgsz (int, optional): Image size for the benchmark. Default is 160.
+ half (bool, optional): Use half-precision for the model if True. Default is False.
+ int8 (bool, optional): Use int8-precision for the model if True. Default is False.
+ device (str, optional): Device to run the benchmark on, either 'cpu' or 'cuda'. Default is 'cpu'.
+ verbose (bool | float | optional): If True or a float, assert benchmarks pass with given metric.
+ Default is False.
+
+ Returns:
+ df (pandas.DataFrame): A pandas DataFrame with benchmark results for each format, including file size,
+ metric, and inference time.
+
+ Example:
+ ```python
+ from ultralytics.utils.benchmarks import benchmark
+
+ benchmark(model='yolov8n.pt', imgsz=640)
+ ```
+ """
+
+ import pandas as pd
+ pd.options.display.max_columns = 10
+ pd.options.display.width = 120
+ device = select_device(device, verbose=False)
+ if isinstance(model, (str, Path)):
+ model = YOLO(model)
+
+ y = []
+ t0 = time.time()
+ for i, (name, format, suffix, cpu, gpu) in export_formats().iterrows(): # index, (name, format, suffix, CPU, GPU)
+ emoji, filename = '❌', None # export defaults
+ try:
+ assert i != 9 or LINUX, 'Edge TPU export only supported on Linux'
+ if i == 10:
+ assert MACOS or LINUX, 'TF.js export only supported on macOS and Linux'
+ elif i == 11:
+ assert sys.version_info < (3, 11), 'PaddlePaddle export only supported on Python<=3.10'
+ if 'cpu' in device.type:
+ assert cpu, 'inference not supported on CPU'
+ if 'cuda' in device.type:
+ assert gpu, 'inference not supported on GPU'
+
+ # Export
+ if format == '-':
+ filename = model.ckpt_path or model.cfg
+ exported_model = model # PyTorch format
+ else:
+ filename = model.export(imgsz=imgsz, format=format, half=half, int8=int8, device=device, verbose=False)
+ exported_model = YOLO(filename, task=model.task)
+ assert suffix in str(filename), 'export failed'
+ emoji = '❎' # indicates export succeeded
+
+ # Predict
+ assert model.task != 'pose' or i != 7, 'GraphDef Pose inference is not supported'
+ assert i not in (9, 10), 'inference not supported' # Edge TPU and TF.js are unsupported
+ assert i != 5 or platform.system() == 'Darwin', 'inference only supported on macOS>=10.13' # CoreML
+ exported_model.predict(ASSETS / 'bus.jpg', imgsz=imgsz, device=device, half=half)
+
+ # Validate
+ data = data or TASK2DATA[model.task] # task to dataset, i.e. coco8.yaml for task=detect
+ key = TASK2METRIC[model.task] # task to metric, i.e. metrics/mAP50-95(B) for task=detect
+ results = exported_model.val(data=data,
+ batch=1,
+ imgsz=imgsz,
+ plots=False,
+ device=device,
+ half=half,
+ int8=int8,
+ verbose=False)
+ metric, speed = results.results_dict[key], results.speed['inference']
+ y.append([name, '✅', round(file_size(filename), 1), round(metric, 4), round(speed, 2)])
+ except Exception as e:
+ if verbose:
+ assert type(e) is AssertionError, f'Benchmark failure for {name}: {e}'
+ LOGGER.warning(f'ERROR ❌️ Benchmark failure for {name}: {e}')
+ y.append([name, emoji, round(file_size(filename), 1), None, None]) # mAP, t_inference
+
+ # Print results
+ check_yolo(device=device) # print system info
+ df = pd.DataFrame(y, columns=['Format', 'Status❔', 'Size (MB)', key, 'Inference time (ms/im)'])
+
+ name = Path(model.ckpt_path).name
+ s = f'\nBenchmarks complete for {name} on {data} at imgsz={imgsz} ({time.time() - t0:.2f}s)\n{df}\n'
+ LOGGER.info(s)
+ with open('benchmarks.log', 'a', errors='ignore', encoding='utf-8') as f:
+ f.write(s)
+
+ if verbose and isinstance(verbose, float):
+ metrics = df[key].array # values to compare to floor
+ floor = verbose # minimum metric floor to pass, i.e. = 0.29 mAP for YOLOv5n
+ assert all(x > floor for x in metrics if pd.notna(x)), f'Benchmark failure: metric(s) < floor {floor}'
+
+ return df
+
+
+class ProfileModels:
+ """
+ ProfileModels class for profiling different models on ONNX and TensorRT.
+
+ This class profiles the performance of different models, provided their paths. The profiling includes parameters such as
+ model speed and FLOPs.
+
+ Attributes:
+ paths (list): Paths of the models to profile.
+ num_timed_runs (int): Number of timed runs for the profiling. Default is 100.
+ num_warmup_runs (int): Number of warmup runs before profiling. Default is 10.
+ min_time (float): Minimum number of seconds to profile for. Default is 60.
+ imgsz (int): Image size used in the models. Default is 640.
+
+ Methods:
+ profile(): Profiles the models and prints the result.
+
+ Example:
+ ```python
+ from ultralytics.utils.benchmarks import ProfileModels
+
+ ProfileModels(['yolov8n.yaml', 'yolov8s.yaml'], imgsz=640).profile()
+ ```
+ """
+
+ def __init__(self,
+ paths: list,
+ num_timed_runs=100,
+ num_warmup_runs=10,
+ min_time=60,
+ imgsz=640,
+ half=True,
+ trt=True,
+ device=None):
+ """
+ Initialize the ProfileModels class for profiling models.
+
+ Args:
+ paths (list): List of paths of the models to be profiled.
+ num_timed_runs (int, optional): Number of timed runs for the profiling. Default is 100.
+ num_warmup_runs (int, optional): Number of warmup runs before the actual profiling starts. Default is 10.
+ min_time (float, optional): Minimum time in seconds for profiling a model. Default is 60.
+ imgsz (int, optional): Size of the image used during profiling. Default is 640.
+ half (bool, optional): Flag to indicate whether to use half-precision floating point for profiling. Default is True.
+ trt (bool, optional): Flag to indicate whether to profile using TensorRT. Default is True.
+ device (torch.device, optional): Device used for profiling. If None, it is determined automatically. Default is None.
+ """
+ self.paths = paths
+ self.num_timed_runs = num_timed_runs
+ self.num_warmup_runs = num_warmup_runs
+ self.min_time = min_time
+ self.imgsz = imgsz
+ self.half = half
+ self.trt = trt # run TensorRT profiling
+ self.device = device or torch.device(0 if torch.cuda.is_available() else 'cpu')
+
+ def profile(self):
+ """Logs the benchmarking results of a model, checks metrics against floor and returns the results."""
+ files = self.get_files()
+
+ if not files:
+ print('No matching *.pt or *.onnx files found.')
+ return
+
+ table_rows = []
+ output = []
+ for file in files:
+ engine_file = file.with_suffix('.engine')
+ if file.suffix in ('.pt', '.yaml', '.yml'):
+ model = YOLO(str(file))
+ model.fuse() # to report correct params and GFLOPs in model.info()
+ model_info = model.info()
+ if self.trt and self.device.type != 'cpu' and not engine_file.is_file():
+ engine_file = model.export(format='engine',
+ half=self.half,
+ imgsz=self.imgsz,
+ device=self.device,
+ verbose=False)
+ onnx_file = model.export(format='onnx',
+ half=self.half,
+ imgsz=self.imgsz,
+ simplify=True,
+ device=self.device,
+ verbose=False)
+ elif file.suffix == '.onnx':
+ model_info = self.get_onnx_model_info(file)
+ onnx_file = file
+ else:
+ continue
+
+ t_engine = self.profile_tensorrt_model(str(engine_file))
+ t_onnx = self.profile_onnx_model(str(onnx_file))
+ table_rows.append(self.generate_table_row(file.stem, t_onnx, t_engine, model_info))
+ output.append(self.generate_results_dict(file.stem, t_onnx, t_engine, model_info))
+
+ self.print_table(table_rows)
+ return output
+
+ def get_files(self):
+ """Returns a list of paths for all relevant model files given by the user."""
+ files = []
+ for path in self.paths:
+ path = Path(path)
+ if path.is_dir():
+ extensions = ['*.pt', '*.onnx', '*.yaml']
+ files.extend([file for ext in extensions for file in glob.glob(str(path / ext))])
+ elif path.suffix in {'.pt', '.yaml', '.yml'}: # add non-existing
+ files.append(str(path))
+ else:
+ files.extend(glob.glob(str(path)))
+
+ print(f'Profiling: {sorted(files)}')
+ return [Path(file) for file in sorted(files)]
+
+ def get_onnx_model_info(self, onnx_file: str):
+ """Retrieves the information including number of layers, parameters, gradients and FLOPs for an ONNX model
+ file.
+ """
+ # return (num_layers, num_params, num_gradients, num_flops)
+ return 0.0, 0.0, 0.0, 0.0
+
+ def iterative_sigma_clipping(self, data, sigma=2, max_iters=3):
+ """Applies an iterative sigma clipping algorithm to the given data times number of iterations."""
+ data = np.array(data)
+ for _ in range(max_iters):
+ mean, std = np.mean(data), np.std(data)
+ clipped_data = data[(data > mean - sigma * std) & (data < mean + sigma * std)]
+ if len(clipped_data) == len(data):
+ break
+ data = clipped_data
+ return data
+
+ def profile_tensorrt_model(self, engine_file: str, eps: float = 1e-3):
+ """Profiles the TensorRT model, measuring average run time and standard deviation among runs."""
+ if not self.trt or not Path(engine_file).is_file():
+ return 0.0, 0.0
+
+ # Model and input
+ model = YOLO(engine_file)
+ input_data = np.random.rand(self.imgsz, self.imgsz, 3).astype(np.float32) # must be FP32
+
+ # Warmup runs
+ elapsed = 0.0
+ for _ in range(3):
+ start_time = time.time()
+ for _ in range(self.num_warmup_runs):
+ model(input_data, imgsz=self.imgsz, verbose=False)
+ elapsed = time.time() - start_time
+
+ # Compute number of runs as higher of min_time or num_timed_runs
+ num_runs = max(round(self.min_time / (elapsed + eps) * self.num_warmup_runs), self.num_timed_runs * 50)
+
+ # Timed runs
+ run_times = []
+ for _ in TQDM(range(num_runs), desc=engine_file):
+ results = model(input_data, imgsz=self.imgsz, verbose=False)
+ run_times.append(results[0].speed['inference']) # Convert to milliseconds
+
+ run_times = self.iterative_sigma_clipping(np.array(run_times), sigma=2, max_iters=3) # sigma clipping
+ return np.mean(run_times), np.std(run_times)
+
+ def profile_onnx_model(self, onnx_file: str, eps: float = 1e-3):
+ """Profiles an ONNX model by executing it multiple times and returns the mean and standard deviation of run
+ times.
+ """
+ check_requirements('onnxruntime')
+ import onnxruntime as ort
+
+ # Session with either 'TensorrtExecutionProvider', 'CUDAExecutionProvider', 'CPUExecutionProvider'
+ sess_options = ort.SessionOptions()
+ sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+ sess_options.intra_op_num_threads = 8 # Limit the number of threads
+ sess = ort.InferenceSession(onnx_file, sess_options, providers=['CPUExecutionProvider'])
+
+ input_tensor = sess.get_inputs()[0]
+ input_type = input_tensor.type
+
+ # Mapping ONNX datatype to numpy datatype
+ if 'float16' in input_type:
+ input_dtype = np.float16
+ elif 'float' in input_type:
+ input_dtype = np.float32
+ elif 'double' in input_type:
+ input_dtype = np.float64
+ elif 'int64' in input_type:
+ input_dtype = np.int64
+ elif 'int32' in input_type:
+ input_dtype = np.int32
+ else:
+ raise ValueError(f'Unsupported ONNX datatype {input_type}')
+
+ input_data = np.random.rand(*input_tensor.shape).astype(input_dtype)
+ input_name = input_tensor.name
+ output_name = sess.get_outputs()[0].name
+
+ # Warmup runs
+ elapsed = 0.0
+ for _ in range(3):
+ start_time = time.time()
+ for _ in range(self.num_warmup_runs):
+ sess.run([output_name], {input_name: input_data})
+ elapsed = time.time() - start_time
+
+ # Compute number of runs as higher of min_time or num_timed_runs
+ num_runs = max(round(self.min_time / (elapsed + eps) * self.num_warmup_runs), self.num_timed_runs)
+
+ # Timed runs
+ run_times = []
+ for _ in TQDM(range(num_runs), desc=onnx_file):
+ start_time = time.time()
+ sess.run([output_name], {input_name: input_data})
+ run_times.append((time.time() - start_time) * 1000) # Convert to milliseconds
+
+ run_times = self.iterative_sigma_clipping(np.array(run_times), sigma=2, max_iters=5) # sigma clipping
+ return np.mean(run_times), np.std(run_times)
+
+ def generate_table_row(self, model_name, t_onnx, t_engine, model_info):
+ """Generates a formatted string for a table row that includes model performance and metric details."""
+ layers, params, gradients, flops = model_info
+ return f'| {model_name:18s} | {self.imgsz} | - | {t_onnx[0]:.2f} ± {t_onnx[1]:.2f} ms | {t_engine[0]:.2f} ± {t_engine[1]:.2f} ms | {params / 1e6:.1f} | {flops:.1f} |'
+
+ def generate_results_dict(self, model_name, t_onnx, t_engine, model_info):
+ """Generates a dictionary of model details including name, parameters, GFLOPS and speed metrics."""
+ layers, params, gradients, flops = model_info
+ return {
+ 'model/name': model_name,
+ 'model/parameters': params,
+ 'model/GFLOPs': round(flops, 3),
+ 'model/speed_ONNX(ms)': round(t_onnx[0], 3),
+ 'model/speed_TensorRT(ms)': round(t_engine[0], 3)}
+
+ def print_table(self, table_rows):
+ """Formats and prints a comparison table for different models with given statistics and performance data."""
+ gpu = torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'GPU'
+ header = f'| Model | size
