+
+
+
+ Watch: Ultralytics COCO Dataset Overview
+
(pixels) | mAPval
50-95 | Speed
CPU ONNX
(ms) | Speed
A100 TensorRT
(ms) | params
(M) | FLOPs
(B) | +| ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- | +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 | + +## Key Features + +- COCO contains 330K images, with 200K images having annotations for object detection, segmentation, and captioning tasks. +- The dataset comprises 80 object categories, including common objects like cars, bicycles, and animals, as well as more specific categories such as umbrellas, handbags, and sports equipment. +- Annotations include object bounding boxes, segmentation masks, and captions for each image. +- COCO provides standardized evaluation metrics like mean Average Precision (mAP) for object detection, and mean Average Recall (mAR) for segmentation tasks, making it suitable for comparing model performance. + +## Dataset Structure + +The COCO dataset is split into three subsets: + +1. **Train2017**: This subset contains 118K images for training object detection, segmentation, and captioning models. +2. **Val2017**: This subset has 5K images used for validation purposes during model training. +3. **Test2017**: This subset consists of 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/7384) for performance evaluation. + +## Applications + +The COCO dataset is widely used for training and evaluating deep learning models in object detection (such as YOLO, Faster R-CNN, and SSD), instance segmentation (such as Mask R-CNN), and keypoint detection (such as OpenPose). The dataset's diverse set of object categories, large number of annotated images, and standardized evaluation metrics make it an essential 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 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 model on the COCO 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="coco.yaml", epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # Start training from a pretrained *.pt model + yolo detect train data=coco.yaml model=yolov8n.pt epochs=100 imgsz=640 + ``` + +## Sample Images and Annotations + +The COCO dataset contains a diverse set of images with various object categories and complex scenes. Here are some examples of images from the 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 COCO 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: + +!!! quote "" + + === "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). + +## FAQ + +### What is the COCO dataset and why is it important for computer vision? + +The [COCO dataset](https://cocodataset.org/#home) (Common Objects in Context) is a large-scale dataset used for object detection, segmentation, and captioning. It contains 330K images with detailed annotations for 80 object categories, making it essential for benchmarking and training computer vision models. Researchers use COCO due to its diverse categories and standardized evaluation metrics like mean Average Precision (mAP). + +### How can I train a YOLO model using the COCO dataset? + +To train a YOLOv8 model using the COCO dataset, you can use the following code snippets: + +!!! 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="coco.yaml", epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # Start training from a pretrained *.pt model + yolo detect train data=coco.yaml model=yolov8n.pt epochs=100 imgsz=640 + ``` + +Refer to the [Training page](../../modes/train.md) for more details on available arguments. + +### What are the key features of the COCO dataset? + +The COCO dataset includes: + +- 330K images, with 200K annotated for object detection, segmentation, and captioning. +- 80 object categories ranging from common items like cars and animals to specific ones like handbags and sports equipment. +- Standardized evaluation metrics for object detection (mAP) and segmentation (mean Average Recall, mAR). +- **Mosaicing** technique in training batches to enhance model generalization across various object sizes and contexts. + +### Where can I find pretrained YOLOv8 models trained on the COCO dataset? + +Pretrained YOLOv8 models on the COCO dataset can be downloaded from the links provided in the documentation. Examples include: + +- [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n.pt) +- [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt) +- [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m.pt) + +These models vary in size, mAP, and inference speed, providing options for different performance and resource requirements. + +### How is the COCO dataset structured and how do I use it? + +The COCO dataset is split into three subsets: + +1. **Train2017**: 118K images for training. +2. **Val2017**: 5K images for validation during training. +3. **Test2017**: 20K images for benchmarking trained models. Results need to be submitted to the [COCO evaluation server](https://codalab.lisn.upsaclay.fr/competitions/7384) for performance evaluation. + +The dataset's YAML configuration file is available at [coco.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), which defines paths, classes, and dataset details. diff --git a/ultralytics/docs/en/datasets/detect/coco8.md b/ultralytics/docs/en/datasets/detect/coco8.md new file mode 100644 index 0000000000000000000000000000000000000000..a0972693ea43fce618a31cef2892aef63feeb3d3 --- /dev/null +++ b/ultralytics/docs/en/datasets/detect/coco8.md @@ -0,0 +1,135 @@ +--- +comments: true +description: Explore the Ultralytics COCO8 dataset, a versatile and manageable set of 8 images perfect for testing object detection models and training pipelines. +keywords: COCO8, Ultralytics, dataset, object detection, YOLOv8, training, validation, machine learning, computer vision +--- + +# COCO8 Dataset + +## Introduction + +[Ultralytics](https://www.ultralytics.com/) COCO8 is a small, but versatile object detection 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 object detection 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. + +
+
+
+
+ Watch: Ultralytics COCO Dataset Overview
+
+
+- **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:
+
+!!! quote ""
+
+ === "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).
+
+## FAQ
+
+### What is the Ultralytics COCO8 dataset used for?
+
+The Ultralytics COCO8 dataset is a compact yet versatile object detection dataset consisting of the first 8 images from the COCO train 2017 set, with 4 images for training and 4 for validation. It is designed for testing and debugging object detection models and experimentation with new detection approaches. Despite its small size, COCO8 offers enough diversity to act as a sanity check for your training pipelines before deploying larger datasets. For more details, view the [COCO8 dataset](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8.yaml).
+
+### How do I train a YOLOv8 model using the COCO8 dataset?
+
+To train a YOLOv8 model using the COCO8 dataset, you can employ either Python or CLI commands. Here's how you can start:
+
+!!! 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="coco8.yaml", epochs=100, imgsz=640)
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Start training from a pretrained *.pt model
+ yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640
+ ```
+
+For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
+
+### Why should I use Ultralytics HUB for managing my COCO8 training?
+
+Ultralytics HUB is an all-in-one web tool designed to simplify the training and deployment of YOLO models, including the Ultralytics YOLOv8 models on the COCO8 dataset. It offers cloud training, real-time tracking, and seamless dataset management. HUB allows you to start training with a single click and avoids the complexities of manual setups. Discover more about [Ultralytics HUB](https://hub.ultralytics.com/) and its benefits.
+
+### What are the benefits of using mosaic augmentation in training with the COCO8 dataset?
+
+Mosaic augmentation, demonstrated in the COCO8 dataset, combines multiple images into a single image during training. This technique increases the variety of objects and scenes in each training batch, improving the model's ability to generalize across different object sizes, aspect ratios, and contexts. This results in a more robust object detection model. For more details, refer to the [training guide](#usage).
+
+### How can I validate my YOLOv8 model trained on the COCO8 dataset?
+
+Validation of your YOLOv8 model trained on the COCO8 dataset can be performed using the model's validation commands. You can invoke the validation mode via CLI or Python script to evaluate the model's performance using precise metrics. For detailed instructions, visit the [Validation](../../modes/val.md) page.
diff --git a/ultralytics/docs/en/datasets/detect/globalwheat2020.md b/ultralytics/docs/en/datasets/detect/globalwheat2020.md
new file mode 100644
index 0000000000000000000000000000000000000000..37b9759f36a059da25ab28ae487187ea7ec2e38e
--- /dev/null
+++ b/ultralytics/docs/en/datasets/detect/globalwheat2020.md
@@ -0,0 +1,145 @@
+---
+comments: true
+description: Explore the Global Wheat Head Dataset to develop accurate wheat head detection models. Includes training images, annotations, and usage for crop management.
+keywords: Global Wheat Head Dataset, wheat head detection, wheat phenotyping, crop management, deep learning, object detection, training datasets
+---
+
+# Global Wheat Head Dataset
+
+The [Global Wheat Head Dataset](https://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:
+
+!!! quote ""
+
+ === "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](https://www.global-wheat.com/).
+
+## FAQ
+
+### What is the Global Wheat Head Dataset used for?
+
+The Global Wheat Head Dataset is primarily used for developing and training deep learning models aimed at wheat head detection. This is crucial for applications in wheat phenotyping and crop management, allowing for more accurate estimations of wheat head density, size, and overall crop yield potential. Accurate detection methods help in assessing crop health and maturity, essential for efficient crop management.
+
+### How do I train a YOLOv8n model on the Global Wheat Head Dataset?
+
+To train a YOLOv8n model on the Global Wheat Head Dataset, you can use the following code snippets. Make sure you have the `GlobalWheat2020.yaml` configuration file specifying dataset paths and classes:
+
+!!! example "Train Example"
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a pre-trained model (recommended for training)
+ model = YOLO("yolov8n.pt")
+
+ # 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
+ ```
+
+For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
+
+### What are the key features of the Global Wheat Head Dataset?
+
+Key features of the Global Wheat Head Dataset include:
+
+- Over 3,000 training images from Europe (France, UK, Switzerland) and North America (Canada).
+- Approximately 1,000 test images from Australia, Japan, and China.
+- High variability in wheat head appearances due to different growing environments.
+- Detailed annotations with wheat head bounding boxes to aid object detection models.
+
+These features facilitate the development of robust models capable of generalization across multiple regions.
+
+### Where can I find the configuration YAML file for the Global Wheat Head Dataset?
+
+The configuration YAML file for the Global Wheat Head Dataset, named `GlobalWheat2020.yaml`, is available on GitHub. You can access it at this [link](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/GlobalWheat2020.yaml). This file contains necessary information about dataset paths, classes, and other configuration details needed for model training in Ultralytics YOLO.
+
+### Why is wheat head detection important in crop management?
+
+Wheat head detection is critical in crop management because it enables accurate estimation of wheat head density and size, which are essential for evaluating crop health, maturity, and yield potential. By leveraging deep learning models trained on datasets like the Global Wheat Head Dataset, farmers and researchers can better monitor and manage crops, leading to improved productivity and optimized resource use in agricultural practices. This technological advancement supports sustainable agriculture and food security initiatives.
+
+For more information on applications of AI in agriculture, visit [AI in Agriculture](https://www.ultralytics.com/solutions/ai-in-agriculture).
diff --git a/ultralytics/docs/en/datasets/detect/index.md b/ultralytics/docs/en/datasets/detect/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..f76ba40bc2516cfb8ebe155ad5d7742110ca0893
--- /dev/null
+++ b/ultralytics/docs/en/datasets/detect/index.md
@@ -0,0 +1,188 @@
+---
+comments: true
+description: Learn about dataset formats compatible with Ultralytics YOLO for robust object detection. Explore supported datasets and learn how to convert formats.
+keywords: Ultralytics, YOLO, object detection datasets, dataset formats, COCO, dataset conversion, training datasets
+---
+
+# 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).
+
+
+
+
+
+ Watch: YOLO World training workflow with LVIS dataset
+
+ 
+
+
+
+
+ Watch: Object Detection using OpenImagesV7 Pretrained Model
+
(pixels) | mAPval
50-95 | Speed
CPU ONNX
(ms) | Speed
A100 TensorRT
(ms) | params
(M) | FLOPs
(B) | +| ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- | +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 | + + + +## Key Features + +- Encompasses ~9M images annotated in various ways to suit multiple computer vision tasks. +- Houses a staggering 16M bounding boxes across 600 object classes in 1.9M images. These boxes are primarily hand-drawn by experts ensuring high precision. +- Visual relationship annotations totaling 3.3M are available, detailing 1,466 unique relationship triplets, object properties, and human activities. +- V5 introduced segmentation masks for 2.8M objects across 350 classes. +- V6 introduced 675k localized narratives that amalgamate voice, text, and mouse traces highlighting described objects. +- V7 introduced 66.4M point-level labels on 1.4M images, spanning 5,827 classes. +- Encompasses 61.4M image-level labels across a diverse set of 20,638 classes. +- Provides a unified platform for image classification, object detection, relationship detection, instance segmentation, and multimodal image descriptions. + +## Dataset Structure + +Open Images V7 is structured in multiple components catering to varied computer vision challenges: + +- **Images**: About 9 million images, often showcasing intricate scenes with an average of 8.3 objects per image. +- **Bounding Boxes**: Over 16 million boxes that demarcate objects across 600 categories. +- **Segmentation Masks**: These detail the exact boundary of 2.8M objects across 350 classes. +- **Visual Relationships**: 3.3M annotations indicating object relationships, properties, and actions. +- **Localized Narratives**: 675k descriptions combining voice, text, and mouse traces. +- **Point-Level Labels**: 66.4M labels across 1.4M images, suitable for zero/few-shot semantic segmentation. + +## Applications + +Open Images V7 is a cornerstone for training and evaluating state-of-the-art models in various computer vision tasks. The dataset's broad scope and high-quality annotations make it indispensable for researchers and developers specializing in computer vision. + +## Dataset YAML + +Typically, datasets come with a YAML (Yet Another Markup Language) file that delineates the dataset's configuration. For the case of Open Images V7, a hypothetical `OpenImagesV7.yaml` might exist. For accurate paths and configurations, one should refer to the dataset's official repository or documentation. + +!!! example "OpenImagesV7.yaml" + + ```yaml + --8<-- "ultralytics/cfg/datasets/open-images-v7.yaml" + ``` + +## Usage + +To train a YOLOv8n model on the Open Images V7 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. + +!!! warning + + The complete Open Images V7 dataset comprises 1,743,042 training images and 41,620 validation images, requiring approximately **561 GB of storage space** upon download. + + Executing the commands provided below will trigger an automatic download of the full dataset if it's not already present locally. Before running the below example it's crucial to: + + - Verify that your device has enough storage capacity. + - Ensure a robust and speedy internet connection. + +!!! example "Train Example" + + === "Python" + + ```python + from ultralytics import YOLO + + # Load a COCO-pretrained YOLOv8n model + model = YOLO("yolov8n.pt") + + # Train the model on the Open Images V7 dataset + results = model.train(data="open-images-v7.yaml", epochs=100, imgsz=640) + ``` + + === "CLI" + + ```bash + # Train a COCO-pretrained YOLOv8n model on the Open Images V7 dataset + yolo detect train data=open-images-v7.yaml model=yolov8n.pt epochs=100 imgsz=640 + ``` + +## Sample Data and Annotations + +Illustrations of the dataset help provide insights into its richness: + + + +- **Open Images V7**: This image exemplifies the depth and detail of annotations available, including bounding boxes, relationships, and segmentation masks. + +Researchers can gain invaluable insights into the array of computer vision challenges that the dataset addresses, from basic object detection to intricate relationship identification. + +## Citations and Acknowledgments + +For those employing Open Images V7 in their work, it's prudent to cite the relevant papers and acknowledge the creators: + +!!! quote "" + + === "BibTeX" + + ```bibtex + @article{OpenImages, + author = {Alina Kuznetsova and Hassan Rom and Neil Alldrin and Jasper Uijlings and Ivan Krasin and Jordi Pont-Tuset and Shahab Kamali and Stefan Popov and Matteo Malloci and Alexander Kolesnikov and Tom Duerig and Vittorio Ferrari}, + title = {The Open Images Dataset V4: Unified image classification, object detection, and visual relationship detection at scale}, + year = {2020}, + journal = {IJCV} + } + ``` + +A heartfelt acknowledgment goes out to the Google AI team for creating and maintaining the Open Images V7 dataset. For a deep dive into the dataset and its offerings, navigate to the [official Open Images V7 website](https://storage.googleapis.com/openimages/web/index.html). + +## FAQ + +### What is the Open Images V7 dataset? + +Open Images V7 is an extensive and versatile dataset created by Google, designed to advance research in computer vision. It includes image-level labels, object bounding boxes, object segmentation masks, visual relationships, and localized narratives, making it ideal for various computer vision tasks such as object detection, segmentation, and relationship detection. + +### How do I train a YOLOv8 model on the Open Images V7 dataset? + +To train a YOLOv8 model on the Open Images V7 dataset, you can use both Python and CLI commands. Here's an example of training the YOLOv8n model for 100 epochs with an image size of 640: + +!!! example "Train Example" + + === "Python" + + ```python + from ultralytics import YOLO + + # Load a COCO-pretrained YOLOv8n model + model = YOLO("yolov8n.pt") + + # Train the model on the Open Images V7 dataset + results = model.train(data="open-images-v7.yaml", epochs=100, imgsz=640) + ``` + + + === "CLI" + + ```bash + # Train a COCO-pretrained YOLOv8n model on the Open Images V7 dataset + yolo detect train data=open-images-v7.yaml model=yolov8n.pt epochs=100 imgsz=640 + ``` + +For more details on arguments and settings, refer to the [Training](../../modes/train.md) page. + +### What are some key features of the Open Images V7 dataset? + +The Open Images V7 dataset includes approximately 9 million images with various annotations: + +- **Bounding Boxes**: 16 million bounding boxes across 600 object classes. +- **Segmentation Masks**: Masks for 2.8 million objects across 350 classes. +- **Visual Relationships**: 3.3 million annotations indicating relationships, properties, and actions. +- **Localized Narratives**: 675,000 descriptions combining voice, text, and mouse traces. +- **Point-Level Labels**: 66.4 million labels across 1.4 million images. +- **Image-Level Labels**: 61.4 million labels across 20,638 classes. + +### What pretrained models are available for the Open Images V7 dataset? + +Ultralytics provides several YOLOv8 pretrained models for the Open Images V7 dataset, each with different sizes and performance metrics: + +| Model | size
(pixels) | mAPval
50-95 | Speed
CPU ONNX
(ms) | Speed
A100 TensorRT
(ms) | params
(M) | FLOPs
(B) | +| ----------------------------------------------------------------------------------------- | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- | +| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n-oiv7.pt) | 640 | 18.4 | 142.4 | 1.21 | 3.5 | 10.5 | +| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s-oiv7.pt) | 640 | 27.7 | 183.1 | 1.40 | 11.4 | 29.7 | +| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m-oiv7.pt) | 640 | 33.6 | 408.5 | 2.26 | 26.2 | 80.6 | +| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l-oiv7.pt) | 640 | 34.9 | 596.9 | 2.43 | 44.1 | 167.4 | +| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x-oiv7.pt) | 640 | 36.3 | 860.6 | 3.56 | 68.7 | 260.6 | + +### What applications can the Open Images V7 dataset be used for? + +The Open Images V7 dataset supports a variety of computer vision tasks including: + +- **Image Classification** +- **Object Detection** +- **Instance Segmentation** +- **Visual Relationship Detection** +- **Multimodal Image Descriptions** + +Its comprehensive annotations and broad scope make it suitable for training and evaluating advanced machine learning models, as highlighted in practical use cases detailed in our [applications](#applications) section. diff --git a/ultralytics/docs/en/datasets/detect/roboflow-100.md b/ultralytics/docs/en/datasets/detect/roboflow-100.md new file mode 100644 index 0000000000000000000000000000000000000000..844326c38127dcddf95fc1a2cc8519caf88a4ec2 --- /dev/null +++ b/ultralytics/docs/en/datasets/detect/roboflow-100.md @@ -0,0 +1,218 @@ +--- +comments: true +description: Explore the Roboflow 100 dataset featuring 100 diverse datasets designed to test object detection models across various domains, from healthcare to video games. +keywords: Roboflow 100, Ultralytics, object detection, dataset, benchmarking, machine learning, computer vision, diverse datasets, model evaluation +--- + +# Roboflow 100 Dataset + +Roboflow 100, developed by [Roboflow](https://roboflow.com/?ref=ultralytics) and sponsored by Intel, is a groundbreaking [object detection](../../tasks/detect.md) benchmark. It includes 100 diverse datasets sampled from over 90,000 public datasets. This benchmark is designed to test the adaptability of models to various domains, including healthcare, aerial imagery, and video games. + +
+ 
+
+ 
+
+
+
+
+ Watch: How to Train YOLOv10 on SKU-110k Dataset using Ultralytics | Retail Dataset
+
+
+
+
+ Watch: How to Train Ultralytics YOLO Models on the VisDrone Dataset for Drone Image Analysis
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+
+ Watch: YOLOv8 MLOps Integration using ClearML
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+
+ Watch: How to Train Ultralytics YOLOv8 models on Your Custom Dataset in Google Colab | Episode 3
+
+
+
+
+ Watch: Gradio Integration with Ultralytics YOLOv8
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+
+
+
+
+ Watch: Ultralytics YOLOv8 Deployment and Integrations
+
+
+## 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://www.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](../quickstart.md#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).
+
+## FAQ
+
+### How do I set up MLflow logging with Ultralytics YOLO?
+
+To set up MLflow logging with Ultralytics YOLO, you first need to ensure MLflow is installed. You can install it using pip:
+
+```bash
+pip install mlflow
+```
+
+Next, enable MLflow logging in Ultralytics settings. This can be controlled using the `mlflow` key. For more information, see the [settings guide](../quickstart.md#ultralytics-settings).
+
+!!! example "Update Ultralytics MLflow Settings"
+
+ === "Python"
+
+ ```python
+ from ultralytics import settings
+
+ # Update a setting
+ settings.update({"mlflow": True})
+
+ # Reset settings to default values
+ settings.reset()
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Update a setting
+ yolo settings runs_dir='/path/to/runs'
+
+ # Reset settings to default values
+ yolo settings reset
+ ```
+
+Finally, start a local MLflow server for tracking:
+
+```bash
+mlflow server --backend-store-uri runs/mlflow
+```
+
+### What metrics and parameters can I log using MLflow with Ultralytics YOLO?
+
+Ultralytics YOLO with MLflow supports logging various metrics, parameters, and artifacts throughout the training process:
+
+- **Metrics Logging**: Tracks metrics at the end of each epoch and upon training completion.
+- **Parameter Logging**: Logs all parameters used in the training process.
+- **Artifacts Logging**: Saves model artifacts like weights and configuration files after training.
+
+For more detailed information, visit the [Ultralytics YOLO tracking documentation](#features).
+
+### Can I disable MLflow logging once it is enabled?
+
+Yes, you can disable MLflow logging for Ultralytics YOLO by updating the settings. Here's how you can do it using the CLI:
+
+```bash
+yolo settings mlflow=False
+```
+
+For further customization and resetting settings, refer to the [settings guide](../quickstart.md#ultralytics-settings).
+
+### How can I start and stop an MLflow server for Ultralytics YOLO tracking?
+
+To start an MLflow server for tracking your experiments in Ultralytics YOLO, use the following command:
+
+```bash
+mlflow server --backend-store-uri runs/mlflow
+```
+
+This command starts a local server at http://127.0.0.1:5000 by default. If you need to stop running MLflow server instances, use the following bash command:
+
+```bash
+ps aux | grep 'mlflow' | grep -v 'grep' | awk '{print $2}' | xargs kill -9
+```
+
+Refer to the [commands section](#commands) for more command options.
+
+### What are the benefits of integrating MLflow with Ultralytics YOLO for experiment tracking?
+
+Integrating MLflow with Ultralytics YOLO offers several benefits for managing your machine learning experiments:
+
+- **Enhanced Experiment Tracking**: Easily track and compare different runs and their outcomes.
+- **Improved Model Reproducibility**: Ensure that your experiments are reproducible by logging all parameters and artifacts.
+- **Performance Monitoring**: Visualize performance metrics over time to make data-driven decisions for model improvements.
+
+For an in-depth look at setting up and leveraging MLflow with Ultralytics YOLO, explore the [MLflow Integration for Ultralytics YOLO](#introduction) documentation.
diff --git a/ultralytics/docs/en/integrations/ncnn.md b/ultralytics/docs/en/integrations/ncnn.md
new file mode 100644
index 0000000000000000000000000000000000000000..cc64a0f84c8b5d3632505238dc2607512910b4a4
--- /dev/null
+++ b/ultralytics/docs/en/integrations/ncnn.md
@@ -0,0 +1,186 @@
+---
+comments: true
+description: Optimize YOLOv8 models for mobile and embedded devices by exporting to NCNN format. Enhance performance in resource-constrained environments.
+keywords: Ultralytics, YOLOv8, NCNN, model export, machine learning, deployment, mobile, embedded systems, deep learning, AI models
+---
+
+# How to Export to NCNN from YOLOv8 for Smooth Deployment
+
+Deploying computer vision models on devices with limited computational power, such as mobile or embedded systems, can be tricky. You need to make sure you use a format optimized for optimal performance. This makes sure that even devices with limited processing power can handle advanced computer vision tasks well.
+
+The export to NCNN format feature allows you to optimize your [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) models for lightweight device-based applications. In this guide, we'll walk you through how to convert your models to the NCNN format, making it easier for your models to perform well on various mobile and embedded devices.
+
+## Why should you export to NCNN?
+
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+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/2024/openvino-workflow/running-inference/inference-devices-and-modes/cpu-device.html) speedup, as well as accelerating YOLO inference on Intel [GPU](https://docs.openvino.ai/2024/openvino-workflow/running-inference/inference-devices-and-modes/gpu-device.html) and [NPU](https://docs.openvino.ai/2024/openvino-workflow/running-inference/inference-devices-and-modes/npu-device.html) hardware.
+
+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.
+
+
+
+
+| Model | Format | Status | Size (MB) | mAP50-95(B) | Inference time (ms/im) |
+| ------- | ----------- | ------ | --------- | ----------- | ---------------------- |
+| YOLOv8n | PyTorch | ✅ | 6.2 | 0.3709 | 21.79 |
+| YOLOv8n | TorchScript | ✅ | 12.4 | 0.3704 | 23.24 |
+| YOLOv8n | ONNX | ✅ | 12.2 | 0.3704 | 37.22 |
+| YOLOv8n | OpenVINO | ✅ | 12.3 | 0.3703 | 3.29 |
+| YOLOv8s | PyTorch | ✅ | 21.5 | 0.4471 | 31.89 |
+| YOLOv8s | TorchScript | ✅ | 42.9 | 0.4472 | 32.71 |
+| YOLOv8s | ONNX | ✅ | 42.8 | 0.4472 | 43.42 |
+| YOLOv8s | OpenVINO | ✅ | 42.9 | 0.4470 | 3.92 |
+| YOLOv8m | PyTorch | ✅ | 49.7 | 0.5013 | 50.75 |
+| YOLOv8m | TorchScript | ✅ | 99.2 | 0.4999 | 47.90 |
+| YOLOv8m | ONNX | ✅ | 99.0 | 0.4999 | 63.16 |
+| YOLOv8m | OpenVINO | ✅ | 49.8 | 0.4997 | 7.11 |
+| YOLOv8l | PyTorch | ✅ | 83.7 | 0.5293 | 77.45 |
+| YOLOv8l | TorchScript | ✅ | 167.2 | 0.5268 | 85.71 |
+| YOLOv8l | ONNX | ✅ | 166.8 | 0.5268 | 88.94 |
+| YOLOv8l | OpenVINO | ✅ | 167.0 | 0.5264 | 9.37 |
+| YOLOv8x | PyTorch | ✅ | 130.5 | 0.5404 | 100.09 |
+| YOLOv8x | TorchScript | ✅ | 260.7 | 0.5371 | 114.64 |
+| YOLOv8x | ONNX | ✅ | 260.4 | 0.5371 | 110.32 |
+| YOLOv8x | OpenVINO | ✅ | 260.6 | 0.5367 | 15.02 |
+
+This table represents the benchmark results for five different models (YOLOv8n, YOLOv8s, YOLOv8m, YOLOv8l, YOLOv8x) across four different formats (PyTorch, TorchScript, ONNX, OpenVINO), giving us the status, size, mAP50-95(B) metric, and inference time for each combination.
+
+### Intel Arc GPU
+
+Intel® Arc™ represents Intel's foray into the dedicated GPU market. The Arc™ series, designed to compete with leading GPU manufacturers like AMD and Nvidia, caters to both the laptop and desktop markets. The series includes mobile versions for compact devices like laptops, and larger, more powerful versions for desktop computers.
+
+The Arc™ series is divided into three categories: Arc™ 3, Arc™ 5, and Arc™ 7, with each number indicating the performance level. Each category includes several models, and the 'M' in the GPU model name signifies a mobile, integrated variant.
+
+Early reviews have praised the Arc™ series, particularly the integrated A770M GPU, for its impressive graphics performance. The availability of the Arc™ series varies by region, and additional models are expected to be released soon. Intel® Arc™ GPUs offer high-performance solutions for a range of computing needs, from gaming to content creation.
+
+Benchmarks below run on Intel® Arc 770 GPU at FP32 precision.
+
+
+
+
+
+
+| Model | Format | Status | Size (MB) | metrics/mAP50-95(B) | Inference time (ms/im) |
+| ------- | ----------- | ------ | --------- | ------------------- | ---------------------- |
+| YOLOv8n | PyTorch | ✅ | 6.2 | 0.3709 | 88.79 |
+| YOLOv8n | TorchScript | ✅ | 12.4 | 0.3704 | 102.66 |
+| YOLOv8n | ONNX | ✅ | 12.2 | 0.3704 | 57.98 |
+| YOLOv8n | OpenVINO | ✅ | 12.3 | 0.3703 | 8.52 |
+| YOLOv8s | PyTorch | ✅ | 21.5 | 0.4471 | 189.83 |
+| YOLOv8s | TorchScript | ✅ | 42.9 | 0.4472 | 227.58 |
+| YOLOv8s | ONNX | ✅ | 42.7 | 0.4472 | 142.03 |
+| YOLOv8s | OpenVINO | ✅ | 42.9 | 0.4469 | 9.19 |
+| YOLOv8m | PyTorch | ✅ | 49.7 | 0.5013 | 411.64 |
+| YOLOv8m | TorchScript | ✅ | 99.2 | 0.4999 | 517.12 |
+| YOLOv8m | ONNX | ✅ | 98.9 | 0.4999 | 298.68 |
+| YOLOv8m | OpenVINO | ✅ | 99.1 | 0.4996 | 12.55 |
+| YOLOv8l | PyTorch | ✅ | 83.7 | 0.5293 | 725.73 |
+| YOLOv8l | TorchScript | ✅ | 167.1 | 0.5268 | 892.83 |
+| YOLOv8l | ONNX | ✅ | 166.8 | 0.5268 | 576.11 |
+| YOLOv8l | OpenVINO | ✅ | 167.0 | 0.5262 | 17.62 |
+| YOLOv8x | PyTorch | ✅ | 130.5 | 0.5404 | 988.92 |
+| YOLOv8x | TorchScript | ✅ | 260.7 | 0.5371 | 1186.42 |
+| YOLOv8x | ONNX | ✅ | 260.4 | 0.5371 | 768.90 |
+| YOLOv8x | OpenVINO | ✅ | 260.6 | 0.5367 | 19 |
+
+### Intel Xeon CPU
+
+The Intel® Xeon® CPU is a high-performance, server-grade processor designed for complex and demanding workloads. From high-end cloud computing and virtualization to artificial intelligence and machine learning applications, Xeon® CPUs provide the power, reliability, and flexibility required for today's data centers.
+
+Notably, Xeon® CPUs deliver high compute density and scalability, making them ideal for both small businesses and large enterprises. By choosing Intel® Xeon® CPUs, organizations can confidently handle their most demanding computing tasks and foster innovation while maintaining cost-effectiveness and operational efficiency.
+
+Benchmarks below run on 4th Gen Intel® Xeon® Scalable CPU at FP32 precision.
+
+
+
+
+
+
+| Model | Format | Status | Size (MB) | metrics/mAP50-95(B) | Inference time (ms/im) |
+| ------- | ----------- | ------ | --------- | ------------------- | ---------------------- |
+| YOLOv8n | PyTorch | ✅ | 6.2 | 0.3709 | 24.36 |
+| YOLOv8n | TorchScript | ✅ | 12.4 | 0.3704 | 23.93 |
+| YOLOv8n | ONNX | ✅ | 12.2 | 0.3704 | 39.86 |
+| YOLOv8n | OpenVINO | ✅ | 12.3 | 0.3704 | 11.34 |
+| YOLOv8s | PyTorch | ✅ | 21.5 | 0.4471 | 33.77 |
+| YOLOv8s | TorchScript | ✅ | 42.9 | 0.4472 | 34.84 |
+| YOLOv8s | ONNX | ✅ | 42.8 | 0.4472 | 43.23 |
+| YOLOv8s | OpenVINO | ✅ | 42.9 | 0.4471 | 13.86 |
+| YOLOv8m | PyTorch | ✅ | 49.7 | 0.5013 | 53.91 |
+| YOLOv8m | TorchScript | ✅ | 99.2 | 0.4999 | 53.51 |
+| YOLOv8m | ONNX | ✅ | 99.0 | 0.4999 | 64.16 |
+| YOLOv8m | OpenVINO | ✅ | 99.1 | 0.4996 | 28.79 |
+| YOLOv8l | PyTorch | ✅ | 83.7 | 0.5293 | 75.78 |
+| YOLOv8l | TorchScript | ✅ | 167.2 | 0.5268 | 79.13 |
+| YOLOv8l | ONNX | ✅ | 166.8 | 0.5268 | 88.45 |
+| YOLOv8l | OpenVINO | ✅ | 167.0 | 0.5263 | 56.23 |
+| YOLOv8x | PyTorch | ✅ | 130.5 | 0.5404 | 96.60 |
+| YOLOv8x | TorchScript | ✅ | 260.7 | 0.5371 | 114.28 |
+| YOLOv8x | ONNX | ✅ | 260.4 | 0.5371 | 111.02 |
+| YOLOv8x | OpenVINO | ✅ | 260.6 | 0.5371 | 83.28 |
+
+### Intel Core CPU
+
+The Intel® Core® series is a range of high-performance processors by Intel. The lineup includes Core i3 (entry-level), Core i5 (mid-range), Core i7 (high-end), and Core i9 (extreme performance). Each series caters to different computing needs and budgets, from everyday tasks to demanding professional workloads. With each new generation, improvements are made to performance, energy efficiency, and features.
+
+Benchmarks below run on 13th Gen Intel® Core® i7-13700H CPU at FP32 precision.
+
+
+
+
+
+
+| Model | Format | Status | Size (MB) | metrics/mAP50-95(B) | Inference time (ms/im) |
+| ------- | ----------- | ------ | --------- | ------------------- | ---------------------- |
+| YOLOv8n | PyTorch | ✅ | 6.2 | 0.4478 | 104.61 |
+| YOLOv8n | TorchScript | ✅ | 12.4 | 0.4525 | 112.39 |
+| YOLOv8n | ONNX | ✅ | 12.2 | 0.4525 | 28.02 |
+| YOLOv8n | OpenVINO | ✅ | 12.3 | 0.4504 | 23.53 |
+| YOLOv8s | PyTorch | ✅ | 21.5 | 0.5885 | 194.83 |
+| YOLOv8s | TorchScript | ✅ | 43.0 | 0.5962 | 202.01 |
+| YOLOv8s | ONNX | ✅ | 42.8 | 0.5962 | 65.74 |
+| YOLOv8s | OpenVINO | ✅ | 42.9 | 0.5966 | 38.66 |
+| YOLOv8m | PyTorch | ✅ | 49.7 | 0.6101 | 355.23 |
+| YOLOv8m | TorchScript | ✅ | 99.2 | 0.6120 | 424.78 |
+| YOLOv8m | ONNX | ✅ | 99.0 | 0.6120 | 173.39 |
+| YOLOv8m | OpenVINO | ✅ | 99.1 | 0.6091 | 69.80 |
+| YOLOv8l | PyTorch | ✅ | 83.7 | 0.6591 | 593.00 |
+| YOLOv8l | TorchScript | ✅ | 167.2 | 0.6580 | 697.54 |
+| YOLOv8l | ONNX | ✅ | 166.8 | 0.6580 | 342.15 |
+| YOLOv8l | OpenVINO | ✅ | 167.0 | 0.0708 | 117.69 |
+| YOLOv8x | PyTorch | ✅ | 130.5 | 0.6651 | 804.65 |
+| YOLOv8x | TorchScript | ✅ | 260.8 | 0.6650 | 921.46 |
+| YOLOv8x | ONNX | ✅ | 260.4 | 0.6650 | 526.66 |
+| YOLOv8x | OpenVINO | ✅ | 260.6 | 0.6619 | 158.73 |
+
+## Reproduce Our Results
+
+To reproduce the Ultralytics benchmarks above on all export [formats](../modes/export.md) run this code:
+
+!!! example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a YOLOv8n PyTorch model
+ model = YOLO("yolov8n.pt")
+
+ # Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all export formats
+ results = model.benchmarks(data="coco8.yaml")
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all export formats
+ yolo benchmark model=yolov8n.pt data=coco8.yaml
+ ```
+
+ Note that benchmarking results might vary based on the exact hardware and software configuration of a system, as well as the current workload of the system at the time the benchmarks are run. For the most reliable results use a dataset with a large number of images, i.e. `data='coco128.yaml' (128 val images), or `data='coco.yaml'` (5000 val images).
+
+## Conclusion
+
+The benchmarking results clearly demonstrate the benefits of exporting the YOLOv8 model to the OpenVINO format. Across different models and hardware platforms, the OpenVINO format consistently outperforms other formats in terms of inference speed while maintaining comparable accuracy.
+
+For the Intel® Data Center GPU Flex Series, the OpenVINO format was able to deliver inference speeds almost 10 times faster than the original PyTorch format. On the Xeon CPU, the OpenVINO format was twice as fast as the PyTorch format. The accuracy of the models remained nearly identical across the different formats.
+
+The benchmarks underline the effectiveness of OpenVINO as a tool for deploying deep learning models. By converting models to the OpenVINO format, developers can achieve significant performance improvements, making it easier to deploy these models in real-world applications.
+
+For more detailed information and instructions on using OpenVINO, refer to the [official OpenVINO documentation](https://docs.openvino.ai/).
+
+## FAQ
+
+### How do I export YOLOv8 models to OpenVINO format?
+
+Exporting YOLOv8 models to the OpenVINO format can significantly enhance CPU speed and enable GPU and NPU accelerations on Intel hardware. To export, you can use either Python or CLI as shown below:
+
+!!! example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a YOLOv8n PyTorch model
+ model = YOLO("yolov8n.pt")
+
+ # Export the model
+ model.export(format="openvino") # creates 'yolov8n_openvino_model/'
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Export a YOLOv8n PyTorch model to OpenVINO format
+ yolo export model=yolov8n.pt format=openvino # creates 'yolov8n_openvino_model/'
+ ```
+
+For more information, refer to the [export formats documentation](../modes/export.md).
+
+### What are the benefits of using OpenVINO with YOLOv8 models?
+
+Using Intel's OpenVINO toolkit with YOLOv8 models offers several benefits:
+
+1. **Performance**: Achieve up to 3x speedup on CPU inference and leverage Intel GPUs and NPUs for acceleration.
+2. **Model Optimizer**: Convert, optimize, and execute models from popular frameworks like PyTorch, TensorFlow, and ONNX.
+3. **Ease of Use**: Over 80 tutorial notebooks are available to help users get started, including ones for YOLOv8.
+4. **Heterogeneous Execution**: Deploy models on various Intel hardware with a unified API.
+
+For detailed performance comparisons, visit our [benchmarks section](#openvino-yolov8-benchmarks).
+
+### How can I run inference using a YOLOv8 model exported to OpenVINO?
+
+After exporting a YOLOv8 model to OpenVINO format, you can run inference using Python or CLI:
+
+!!! example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load the exported OpenVINO model
+ ov_model = YOLO("yolov8n_openvino_model/")
+
+ # Run inference
+ results = ov_model("https://ultralytics.com/images/bus.jpg")
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Run inference with the exported model
+ yolo predict model=yolov8n_openvino_model source='https://ultralytics.com/images/bus.jpg'
+ ```
+
+Refer to our [predict mode documentation](../modes/predict.md) for more details.
+
+### Why should I choose Ultralytics YOLOv8 over other models for OpenVINO export?
+
+Ultralytics YOLOv8 is optimized for real-time object detection with high accuracy and speed. Specifically, when combined with OpenVINO, YOLOv8 provides:
+
+- Up to 3x speedup on Intel CPUs
+- Seamless deployment on Intel GPUs and NPUs
+- Consistent and comparable accuracy across various export formats
+
+For in-depth performance analysis, check our detailed [YOLOv8 benchmarks](#openvino-yolov8-benchmarks) on different hardware.
+
+### Can I benchmark YOLOv8 models on different formats such as PyTorch, ONNX, and OpenVINO?
+
+Yes, you can benchmark YOLOv8 models in various formats including PyTorch, TorchScript, ONNX, and OpenVINO. Use the following code snippet to run benchmarks on your chosen dataset:
+
+!!! example
+
+ === "Python"
+
+ ```python
+ from ultralytics import YOLO
+
+ # Load a YOLOv8n PyTorch model
+ model = YOLO("yolov8n.pt")
+
+ # Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all export formats
+ results = model.benchmarks(data="coco8.yaml")
+ ```
+
+ === "CLI"
+
+ ```bash
+ # Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all export formats
+ yolo benchmark model=yolov8n.pt data=coco8.yaml
+ ```
+
+For detailed benchmark results, refer to our [benchmarks section](#openvino-yolov8-benchmarks) and [export formats](../modes/export.md) documentation.
diff --git a/ultralytics/docs/en/integrations/paddlepaddle.md b/ultralytics/docs/en/integrations/paddlepaddle.md
new file mode 100644
index 0000000000000000000000000000000000000000..700c24f62e2efa14734c7c1d78f0dfde60cef801
--- /dev/null
+++ b/ultralytics/docs/en/integrations/paddlepaddle.md
@@ -0,0 +1,202 @@
+---
+comments: true
+description: Learn how to export YOLOv8 models to PaddlePaddle format for enhanced performance, flexibility, and deployment across various platforms and devices.
+keywords: YOLOv8, PaddlePaddle, export models, computer vision, deep learning, model deployment, performance optimization
+---
+
+# How to Export to PaddlePaddle Format from YOLOv8 Models
+
+Bridging the gap between developing and deploying computer vision models in real-world scenarios with varying conditions can be difficult. PaddlePaddle makes this process easier with its focus on flexibility, performance, and its capability for parallel processing in distributed environments. This means you can use your YOLOv8 computer vision models on a wide variety of devices and platforms, from smartphones to cloud-based servers.
+
+The ability to export to PaddlePaddle model format allows you to optimize your [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) models for use within the PaddlePaddle framework. PaddlePaddle is known for facilitating industrial deployments and is a good choice for deploying computer vision applications in real-world settings across various domains.
+
+## Why should you export to PaddlePaddle?
+
+
+
+ 
+
+ 
+
+ 
+
+
+
+
+ Watch: Ultralytics Live Session 7: It's All About the Environment: Optimizing YOLOv8 Training With Gradient
+
+ 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 
+
+ 
+
+ 
+
+ 
+
(ms) | min \| max
(ms) | mAPval
50(B) | mAPval
50-95(B) | `batch` | size
(pixels) | + |-----------|--------------|--------------|--------------------|----------------------|-------------------------|---------|-----------------------| + | FP32 | Predict | 0.52 | 0.51 \| 0.56 | | | 8 | 640 | + | FP32 | COCOval | 0.52 | | 0.52 | 0.37 | 1 | 640 | + | FP16 | Predict | 0.34 | 0.34 \| 0.41 | | | 8 | 640 | + | FP16 | COCOval | 0.33 | | 0.52 | 0.37 | 1 | 640 | + | INT8 | Predict | 0.28 | 0.27 \| 0.31 | | | 8 | 640 | + | INT8 | COCOval | 0.29 | | 0.47 | 0.33 | 1 | 640 | + + === "Segmentation (COCO)" + + See [Segmentation Docs](../tasks/segment.md) for usage examples with these models trained on [COCO](../datasets/segment/coco.md), which include 80 pre-trained classes. + + !!! note + Inference times shown for `mean`, `min` (fastest), and `max` (slowest) for each test using pre-trained weights `yolov8n-seg.engine` + + | Precision | Eval test | mean
(ms) | min \| max
(ms) | mAPval
50(B) | mAPval
50-95(B) | mAPval
50(M) | mAPval
50-95(M) | `batch` | size
(pixels) | + |-----------|--------------|--------------|--------------------|----------------------|-------------------------|----------------------|-------------------------|---------|-----------------------| + | FP32 | Predict | 0.62 | 0.61 \| 0.68 | | | | | 8 | 640 | + | FP32 | COCOval | 0.63 | | 0.52 | 0.36 | 0.49 | 0.31 | 1 | 640 | + | FP16 | Predict | 0.40 | 0.39 \| 0.44 | | | | | 8 | 640 | + | FP16 | COCOval | 0.43 | | 0.52 | 0.36 | 0.49 | 0.30 | 1 | 640 | + | INT8 | Predict | 0.34 | 0.33 \| 0.37 | | | | | 8 | 640 | + | INT8 | COCOval | 0.36 | | 0.46 | 0.32 | 0.43 | 0.27 | 1 | 640 | + + === "Classification (ImageNet)" + + See [Classification Docs](../tasks/classify.md) for usage examples with these models trained on [ImageNet](../datasets/classify/imagenet.md), which include 1000 pre-trained classes. + + !!! note + Inference times shown for `mean`, `min` (fastest), and `max` (slowest) for each test using pre-trained weights `yolov8n-cls.engine` + + | Precision | Eval test | mean
(ms) | min \| max
(ms) | top-1 | top-5 | `batch` | size
(pixels) | + |-----------|------------------|--------------|--------------------|-------|-------|---------|-----------------------| + | FP32 | Predict | 0.26 | 0.25 \| 0.28 | | | 8 | 640 | + | FP32 | ImageNetval | 0.26 | | 0.35 | 0.61 | 1 | 640 | + | FP16 | Predict | 0.18 | 0.17 \| 0.19 | | | 8 | 640 | + | FP16 | ImageNetval | 0.18 | | 0.35 | 0.61 | 1 | 640 | + | INT8 | Predict | 0.16 | 0.15 \| 0.57 | | | 8 | 640 | + | INT8 | ImageNetval | 0.15 | | 0.32 | 0.59 | 1 | 640 | + + === "Pose (COCO)" + + See [Pose Estimation Docs](../tasks/pose.md) for usage examples with these models trained on [COCO](../datasets/pose/coco.md), which include 1 pre-trained class, "person". + + !!! note + Inference times shown for `mean`, `min` (fastest), and `max` (slowest) for each test using pre-trained weights `yolov8n-pose.engine` + + | Precision | Eval test | mean
(ms) | min \| max
(ms) | mAPval
50(B) | mAPval
50-95(B) | mAPval
50(P) | mAPval
50-95(P) | `batch` | size
(pixels) | + |-----------|--------------|--------------|--------------------|----------------------|-------------------------|----------------------|-------------------------|---------|-----------------------| + | FP32 | Predict | 0.54 | 0.53 \| 0.58 | | | | | 8 | 640 | + | FP32 | COCOval | 0.55 | | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | + | FP16 | Predict | 0.37 | 0.35 \| 0.41 | | | | | 8 | 640 | + | FP16 | COCOval | 0.36 | | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | + | INT8 | Predict | 0.29 | 0.28 \| 0.33 | | | | | 8 | 640 | + | INT8 | COCOval | 0.30 | | 0.90 | 0.68 | 0.78 | 0.47 | 1 | 640 | + + === "OBB (DOTAv1)" + + See [Oriented Detection Docs](../tasks/obb.md) for usage examples with these models trained on [DOTAv1](../datasets/obb/dota-v2.md#dota-v10), which include 15 pre-trained classes. + + !!! note + Inference times shown for `mean`, `min` (fastest), and `max` (slowest) for each test using pre-trained weights `yolov8n-obb.engine` + + | Precision | Eval test | mean
(ms) | min \| max
(ms) | mAPval
50(B) | mAPval
50-95(B) | `batch` | size
(pixels) | + |-----------|----------------|--------------|--------------------|----------------------|-------------------------|---------|-----------------------| + | FP32 | Predict | 0.52 | 0.51 \| 0.59 | | | 8 | 640 | + | FP32 | DOTAv1val | 0.76 | | 0.50 | 0.36 | 1 | 640 | + | FP16 | Predict | 0.34 | 0.33 \| 0.42 | | | 8 | 640 | + | FP16 | DOTAv1val | 0.59 | | 0.50 | 0.36 | 1 | 640 | + | INT8 | Predict | 0.29 | 0.28 \| 0.33 | | | 8 | 640 | + | INT8 | DOTAv1val | 0.32 | | 0.45 | 0.32 | 1 | 640 | + +### Consumer GPUs + +!!! tip "Detection Performance (COCO)" + + === "RTX 3080 12 GB" + + Tested with Windows 10.0.19045, `python 3.10.9`, `ultralytics==8.2.4`, `tensorrt==10.0.0b6` + + !!! note + Inference times shown for `mean`, `min` (fastest), and `max` (slowest) for each test using pre-trained weights `yolov8n.engine` + + | Precision | Eval test | mean
(ms) | min \| max
(ms) | mAPval
50(B) | mAPval
50-95(B) | `batch` | size
(pixels) | + |-----------|--------------|--------------|--------------------|----------------------|-------------------------|---------|-----------------------| + | FP32 | Predict | 1.06 | 0.75 \| 1.88 | | | 8 | 640 | + | FP32 | COCOval | 1.37 | | 0.52 | 0.37 | 1 | 640 | + | FP16 | Predict | 0.62 | 0.75 \| 1.13 | | | 8 | 640 | + | FP16 | COCOval | 0.85 | | 0.52 | 0.37 | 1 | 640 | + | INT8 | Predict | 0.52 | 0.38 \| 1.00 | | | 8 | 640 | + | INT8 | COCOval | 0.74 | | 0.47 | 0.33 | 1 | 640 | + + === "RTX 3060 12 GB" + + Tested with Windows 10.0.22631, `python 3.11.9`, `ultralytics==8.2.4`, `tensorrt==10.0.1` + + !!! note + Inference times shown for `mean`, `min` (fastest), and `max` (slowest) for each test using pre-trained weights `yolov8n.engine` + + + | Precision | Eval test | mean
(ms) | min \| max
(ms) | mAPval
50(B) | mAPval
50-95(B) | `batch` | size
(pixels) | + |-----------|--------------|--------------|--------------------|----------------------|-------------------------|---------|-----------------------| + | FP32 | Predict | 1.76 | 1.69 \| 1.87 | | | 8 | 640 | + | FP32 | COCOval | 1.94 | | 0.52 | 0.37 | 1 | 640 | + | FP16 | Predict | 0.86 | 0.75 \| 1.00 | | | 8 | 640 | + | FP16 | COCOval | 1.43 | | 0.52 | 0.37 | 1 | 640 | + | INT8 | Predict | 0.80 | 0.75 \| 1.00 | | | 8 | 640 | + | INT8 | COCOval | 1.35 | | 0.47 | 0.33 | 1 | 640 | + + === "RTX 2060 6 GB" + + Tested with Pop!_OS 22.04 LTS, `python 3.10.12`, `ultralytics==8.2.4`, `tensorrt==8.6.1.post1` + + !!! note + Inference times shown for `mean`, `min` (fastest), and `max` (slowest) for each test using pre-trained weights `yolov8n.engine` + + | Precision | Eval test | mean
(ms) | min \| max
(ms) | mAPval
50(B) | mAPval
50-95(B) | `batch` | size
(pixels) | + |-----------|--------------|--------------|--------------------|----------------------|-------------------------|---------|-----------------------| + | FP32 | Predict | 2.84 | 2.84 \| 2.85 | | | 8 | 640 | + | FP32 | COCOval | 2.94 | | 0.52 | 0.37 | 1 | 640 | + | FP16 | Predict | 1.09 | 1.09 \| 1.10 | | | 8 | 640 | + | FP16 | COCOval | 1.20 | | 0.52 | 0.37 | 1 | 640 | + | INT8 | Predict | 0.75 | 0.74 \| 0.75 | | | 8 | 640 | + | INT8 | COCOval | 0.76 | | 0.47 | 0.33 | 1 | 640 | + +### Embedded Devices + +!!! tip "Detection Performance (COCO)" + + === "Jetson Orin NX 16GB" + + Tested with JetPack 6.0 (L4T 36.3) Ubuntu 22.04.4 LTS, `python 3.10.12`, `ultralytics==8.2.16`, `tensorrt==10.0.1` + + !!! note + Inference times shown for `mean`, `min` (fastest), and `max` (slowest) for each test using pre-trained weights `yolov8n.engine` + + | Precision | Eval test | mean
(ms) | min \| max
(ms) | mAPval
50(B) | mAPval
50-95(B) | `batch` | size
(pixels) | + |-----------|--------------|--------------|--------------------|----------------------|-------------------------|---------|-----------------------| + | FP32 | Predict | 6.11 | 6.10 \| 6.29 | | | 8 | 640 | + | FP32 | COCOval | 6.17 | | 0.52 | 0.37 | 1 | 640 | + | FP16 | Predict | 3.18 | 3.18 \| 3.20 | | | 8 | 640 | + | FP16 | COCOval | 3.19 | | 0.52 | 0.37 | 1 | 640 | + | INT8 | Predict | 2.30 | 2.29 \| 2.35 | | | 8 | 640 | + | INT8 | COCOval | 2.32 | | 0.46 | 0.32 | 1 | 640 | + +!!! info + + See our [quickstart guide on NVIDIA Jetson with Ultralytics YOLO](../guides/nvidia-jetson.md) to learn more about setup and configuration. + +#### Evaluation methods + +Expand sections below for information on how these models were exported and tested. + +??? example "Export configurations" + + See [export mode](../modes/export.md) for details regarding export configuration arguments. + + ```py + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + + # TensorRT FP32 + out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2) + + # TensorRT FP16 + out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, half=True) + + # TensorRT INT8 with calibration `data` (i.e. COCO, ImageNet, or DOTAv1 for appropriate model task) + out = model.export( + format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, int8=True, data="coco8.yaml" + ) + ``` + +??? example "Predict loop" + + See [predict mode](../modes/predict.md) for additional information. + + ```py + import cv2 + + from ultralytics import YOLO + + model = YOLO("yolov8n.engine") + img = cv2.imread("path/to/image.jpg") + + for _ in range(100): + result = model.predict( + [img] * 8, # batch=8 of the same image + verbose=False, + device="cuda", + ) + ``` + +??? example "Validation configuration" + + See [`val` mode](../modes/val.md) to learn more about validation configuration arguments. + + ```py + from ultralytics import YOLO + + model = YOLO("yolov8n.engine") + results = model.val( + data="data.yaml", # COCO, ImageNet, or DOTAv1 for appropriate model task + batch=1, + imgsz=640, + verbose=False, + device="cuda", + ) + ``` + +## Deploying Exported YOLOv8 TensorRT Models + +Having successfully exported your Ultralytics YOLOv8 models to TensorRT format, you're now ready to deploy them. For in-depth instructions on deploying your TensorRT models in various settings, take a look at the following resources: + +- **[Deploy Ultralytics with a Triton Server](../guides/triton-inference-server.md)**: Our guide on how to use NVIDIA's Triton Inference (formerly TensorRT Inference) Server specifically for use with Ultralytics YOLO models. + +- **[Deploying Deep Neural Networks with NVIDIA TensorRT](https://developer.nvidia.com/blog/deploying-deep-learning-nvidia-tensorrt/)**: This article explains how to use NVIDIA TensorRT to deploy deep neural networks on GPU-based deployment platforms efficiently. + +- **[End-to-End AI for NVIDIA-Based PCs: NVIDIA TensorRT Deployment](https://developer.nvidia.com/blog/end-to-end-ai-for-nvidia-based-pcs-nvidia-tensorrt-deployment/)**: This blog post explains the use of NVIDIA TensorRT for optimizing and deploying AI models on NVIDIA-based PCs. + +- **[GitHub Repository for NVIDIA TensorRT:](https://github.com/NVIDIA/TensorRT)**: This is the official GitHub repository that contains the source code and documentation for NVIDIA TensorRT. + +## Summary + +In this guide, we focused on converting Ultralytics YOLOv8 models to NVIDIA's TensorRT model format. This conversion step is crucial for improving the efficiency and speed of YOLOv8 models, making them more effective and suitable for diverse deployment environments. + +For more information on usage details, take a look at the [TensorRT official documentation](https://docs.nvidia.com/deeplearning/tensorrt/). + +If you're curious about additional Ultralytics YOLOv8 integrations, our [integration guide page](../integrations/index.md) provides an extensive selection of informative resources and insights. + +## FAQ + +### How do I convert YOLOv8 models to TensorRT format? + +To convert your Ultralytics YOLOv8 models to TensorRT format for optimized NVIDIA GPU inference, follow these steps: + +1. **Install the required package**: + + ```bash + pip install ultralytics + ``` + +2. **Export your YOLOv8 model**: + + ```python + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + model.export(format="engine") # creates 'yolov8n.engine' + + # Run inference + model = YOLO("yolov8n.engine") + results = model("https://ultralytics.com/images/bus.jpg") + ``` + +For more details, visit the [YOLOv8 Installation guide](../quickstart.md) and the [export documentation](../modes/export.md). + +### What are the benefits of using TensorRT for YOLOv8 models? + +Using TensorRT to optimize YOLOv8 models offers several benefits: + +- **Faster Inference Speed**: TensorRT optimizes the model layers and uses precision calibration (INT8 and FP16) to speed up inference without significantly sacrificing accuracy. +- **Memory Efficiency**: TensorRT manages tensor memory dynamically, reducing overhead and improving GPU memory utilization. +- **Layer Fusion**: Combines multiple layers into single operations, reducing computational complexity. +- **Kernel Auto-Tuning**: Automatically selects optimized GPU kernels for each model layer, ensuring maximum performance. + +For more information, explore the detailed features of TensorRT [here](https://developer.nvidia.com/tensorrt) and read our [TensorRT overview section](#tensorrt). + +### Can I use INT8 quantization with TensorRT for YOLOv8 models? + +Yes, you can export YOLOv8 models using TensorRT with INT8 quantization. This process involves post-training quantization (PTQ) and calibration: + +1. **Export with INT8**: + + ```python + from ultralytics import YOLO + + model = YOLO("yolov8n.pt") + model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml") + ``` + +2. **Run inference**: + + ```python + from ultralytics import YOLO + + model = YOLO("yolov8n.engine", task="detect") + result = model.predict("https://ultralytics.com/images/bus.jpg") + ``` + +For more details, refer to the [exporting TensorRT with INT8 quantization section](#exporting-tensorrt-with-int8-quantization). + +### How do I deploy YOLOv8 TensorRT models on an NVIDIA Triton Inference Server? + +Deploying YOLOv8 TensorRT models on an NVIDIA Triton Inference Server can be done using the following resources: + +- **[Deploy Ultralytics YOLOv8 with Triton Server](../guides/triton-inference-server.md)**: Step-by-step guidance on setting up and using Triton Inference Server. +- **[NVIDIA Triton Inference Server Documentation](https://developer.nvidia.com/blog/deploying-deep-learning-nvidia-tensorrt/)**: Official NVIDIA documentation for detailed deployment options and configurations. + +These guides will help you integrate YOLOv8 models efficiently in various deployment environments. + +### What are the performance improvements observed with YOLOv8 models exported to TensorRT? + +Performance improvements with TensorRT can vary based on the hardware used. Here are some typical benchmarks: + +- **NVIDIA A100**: + + - **FP32** Inference: ~0.52 ms / image + - **FP16** Inference: ~0.34 ms / image + - **INT8** Inference: ~0.28 ms / image + - Slight reduction in mAP with INT8 precision, but significant improvement in speed. + +- **Consumer GPUs (e.g., RTX 3080)**: + - **FP32** Inference: ~1.06 ms / image + - **FP16** Inference: ~0.62 ms / image + - **INT8** Inference: ~0.52 ms / image + +Detailed performance benchmarks for different hardware configurations can be found in the [performance section](#ultralytics-yolo-tensorrt-export-performance). + +For more comprehensive insights into TensorRT performance, refer to the [Ultralytics documentation](../modes/export.md) and our performance analysis reports. diff --git a/ultralytics/docs/en/integrations/tf-graphdef.md b/ultralytics/docs/en/integrations/tf-graphdef.md new file mode 100644 index 0000000000000000000000000000000000000000..24ae0dd980c9e98234ab53a69f0139f0948406db --- /dev/null +++ b/ultralytics/docs/en/integrations/tf-graphdef.md @@ -0,0 +1,204 @@ +--- +comments: true +description: Learn how to export YOLOv8 models to the TF GraphDef format for seamless deployment on various platforms, including mobile and web. +keywords: YOLOv8, export, TensorFlow, GraphDef, model deployment, TensorFlow Serving, TensorFlow Lite, TensorFlow.js, machine learning, AI, computer vision +--- + +# How to Export to TF GraphDef from YOLOv8 for Deployment + +When you are deploying cutting-edge computer vision models, like YOLOv8, in different environments, you might run into compatibility issues. Google's TensorFlow GraphDef, or TF GraphDef, offers a solution by providing a serialized, platform-independent representation of your model. Using the TF GraphDef model format, you can deploy your YOLOv8 model in environments where the complete TensorFlow ecosystem may not be available, such as mobile devices or specialized hardware. + +In this guide, we'll walk you step by step through how to export your [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) models to the TF GraphDef model format. By converting your model, you can streamline deployment and use YOLOv8's computer vision capabilities in a broader range of applications and platforms. + +
+ 
+
+ 
+
+ 
+
+ 
+
+ 
+
+
+ 
+
+ Run example code using Ultralytics YOLO in under 20 seconds! 🚀
+
+
+ 
+
+
+
+ 
+
+ Visual Studio Code Extension Marketplace page for Ultralytics-Snippets
+
+
+ 
+
+ After inserting snippet, renaming model as world_model updates all instances. Pressing Tab ⇥ moves to the next field, which opens a dropdown menu and allows for selection of a model scale, and moving to the next field provides another dropdown to choose either world or worldv2 model variant.
+
+
+ 
+
+ Typing ex-yolo-p will still arrive at the correct snippet.
+
+
+ 
+
+ Once tabbed to the boxes field, a dropdown menu appears to allow selection of another attribute as required.
+
+
+ 
+
+
+
+
+
+ Watch: How to use Ultralytics YOLOv8 with Weights and Biases
+
+ 
+