diff --git a/docs/en/models/fast-sam.md b/docs/en/models/fast-sam.md index e4b4ab35..b40e668a 100644 --- a/docs/en/models/fast-sam.md +++ b/docs/en/models/fast-sam.md @@ -238,3 +238,60 @@ We would like to acknowledge the FastSAM authors for their significant contribut ``` The original FastSAM paper can be found on [arXiv](https://arxiv.org/abs/2306.12156). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/CASIA-IVA-Lab/FastSAM). We appreciate their efforts in advancing the field and making their work accessible to the broader community. + +## FAQ + +### What is FastSAM and how does it work? + +FastSAM, or Fast Segment Anything Model, is a real-time CNN-based solution designed to segment any object within an image. It decouples the segmentation task into two stages: all-instance segmentation and prompt-guided selection. The first stage uses [YOLOv8-seg](../tasks/segment.md) to produce segmentation masks for all instances in the image. The second stage outputs the region-of-interest based on user prompts. This approach significantly reduces computational demands while maintaining competitive performance, making it ideal for various vision tasks. + +### How does FastSAM compare to the Segment Anything Model (SAM)? + +FastSAM addresses the limitations of SAM, which is a heavy Transformer model requiring substantial computational resources. FastSAM offers similar performance with significantly reduced computational demands by leveraging CNNs for real-time segmentation. It achieves competitive results on benchmarks like MS COCO with faster inference speeds using a single NVIDIA RTX 3090. This makes FastSAM a more efficient and practical solution for real-time industrial applications. + +### Can I use FastSAM for real-time segmentation and what are its practical applications? + +Yes, FastSAM is designed for real-time segmentation tasks. Its efficiency and reduced computational demands make it suitable for various practical applications, including: + +- Industrial automation where quick segmentation results are necessary. +- Real-time tracking in video streams ([tracking mode](../modes/track.md)). +- Real-time object detection and segmentation in autonomous systems. +- Security and surveillance systems requiring prompt object segmentation. + +### How do I use FastSAM for inference in Python? + +You can easily integrate FastSAM into your Python applications for inference. Here's an example: + +```python +from ultralytics import FastSAM +from ultralytics.models.fastsam import FastSAMPrompt + +# Define an inference source +source = "path/to/image.jpg" + +# Create a FastSAM model +model = FastSAM("FastSAM-s.pt") # or FastSAM-x.pt + +# Run inference on an image +results = model(source, device="cpu", retina_masks=True, imgsz=1024, conf=0.4, iou=0.9) + +# Process the prompts +prompt_process = FastSAMPrompt(source, results, device="cpu") +annotations = prompt_process.everything_prompt() +prompt_process.plot(annotations=annotations, output="./") +``` + +This snippet demonstrates the simplicity of loading a pre-trained model and running predictions. For more details, refer to the [predict mode](../modes/predict.md). + +### What are the key features of FastSAM? + +FastSAM offers several key features: + +1. **Real-time solution**: Leveraging CNNs for immediate results. +2. **Efficiency and performance**: Comparable to SAM but with reduced computational resources. +3. **Prompt-guided segmentation**: Flexibility to segment objects based on various user interactions. +4. **Based on YOLOv8-seg**: Utilizes YOLOv8's capabilities for instance segmentation. +5. **Benchmark performance**: High scores on MS COCO with faster inference speeds. +6. **Model compression feasibility**: Demonstrates significant reduction in computational effort while maintaining performance. + +These features make FastSAM a powerful tool for a wide array of vision tasks. For a comprehensive list of features, visit the [FastSAM overview](#overview). diff --git a/docs/en/models/index.md b/docs/en/models/index.md index a1f46bcc..35ffdc44 100644 --- a/docs/en/models/index.md +++ b/docs/en/models/index.md @@ -95,3 +95,55 @@ Interested in contributing your model to Ultralytics? Great! We're always open t 6. **Code Review & Merging**: After review, if your model meets our criteria, it will be merged into the main repository. For detailed steps, consult our [Contributing Guide](../help/contributing.md). + +## FAQ + +### What types of tasks can Ultralytics YOLO models handle? + +Ultralytics YOLO models support a range of tasks including [object detection](../tasks/detect.md), [instance segmentation](../tasks/segment.md), [image classification](../tasks/classify.md), [pose estimation](../tasks/pose.md), and [multi-object tracking](../modes/track.md). These models are designed to achieve high performance in different computer vision applications, making them versatile tools for various project needs. + +### How do I train a YOLOv8 model for object detection? + +To train a YOLOv8 model for object detection, you can either use the Python API or the Command Line Interface (CLI). Below is an example using Python: + +```python +from ultralytics import YOLO + +# Load a COCO-pretrained YOLOv8n model +model = YOLO("yolov8n.pt") + +# Display model information (optional) +model.info() + +# Train the model on the COCO8 example dataset for 100 epochs +results = model.train(data="coco8.yaml", epochs=100, imgsz=640) +``` + +For more detailed instructions, visit the [Train](../modes/train.md) documentation page. + +### Can I contribute my own model to Ultralytics? + +Yes, you can contribute your own model to Ultralytics. To do so, follow these steps: + +1. **Fork the Repository**: Fork the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics). +2. **Clone Your Fork**: Clone your fork to your local machine and create a new branch. +3. **Implement Your Model**: Add your model while following the coding standards in the [Contributing Guide](../help/contributing.md). +4. **Test Thoroughly**: Ensure your model passes all tests. +5. **Create a Pull Request**: Submit your work for review. + +Visit the [Contributing Guide](../help/contributing.md) for detailed steps. + +### Which YOLO versions are supported by Ultralytics? + +Ultralytics supports a wide range of YOLO versions from [YOLOv3](yolov3.md) to the latest [YOLOv10](yolov10.md). Each version has unique features and improvements. For instance, YOLOv8 supports tasks such as instance segmentation and pose estimation, while YOLOv10 offers NMS-free training and efficiency-accuracy driven architecture. + +### How can I run inference with a YOLOv8 model using the Command Line Interface (CLI)? + +To run inference with a YOLOv8 model using the CLI, use the following command: + +```bash +# Load a COCO-pretrained YOLOv8n model and run inference on the 'bus.jpg' image +yolo predict model=yolov8n.pt source=path/to/bus.jpg +``` + +For more information on using CLI commands, visit the [Predict](../modes/predict.md) documentation page. diff --git a/docs/en/models/mobile-sam.md b/docs/en/models/mobile-sam.md index 00fd5331..541e09b6 100644 --- a/docs/en/models/mobile-sam.md +++ b/docs/en/models/mobile-sam.md @@ -117,3 +117,52 @@ If you find MobileSAM useful in your research or development work, please consid year={2023} } ``` + +## FAQ + +### How do I use MobileSAM for image segmentation on a mobile application? + +MobileSAM is specifically designed for lightweight and fast image segmentation on mobile applications. To get started, you can download the model weights [here](https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt) and use the following Python code snippet for inference: + +```python +from ultralytics import SAM + +# Load the model +model = SAM("mobile_sam.pt") + +# Predict a segment based on a point prompt +model.predict("ultralytics/assets/zidane.jpg", points=[900, 370], labels=[1]) +``` + +For more detailed usage and various prompts, refer to the [SAM page](sam.md). + +### What are the performance benefits of using MobileSAM over the original SAM? + +MobileSAM offers significant improvements in both size and speed over the original SAM. Here is a detailed comparison: + +- **Image Encoder**: MobileSAM uses a smaller Tiny-ViT (5M parameters) instead of the original heavyweight ViT-H (611M parameters), resulting in an 8ms encoding time versus 452ms with SAM. +- **Overall Pipeline**: MobileSAM's entire pipeline, including image encoding and mask decoding, operates at 12ms per image compared to SAM's 456ms, making it approximately 7 times faster. + In summary, MobileSAM is about 5 times smaller and 7 times faster than the original SAM, making it ideal for mobile applications. + +### Why should developers adopt MobileSAM for mobile applications? + +Developers should consider using MobileSAM for mobile applications due to its lightweight and fast performance, making it highly efficient for real-time image segmentation tasks. + +- **Efficiency**: MobileSAM's Tiny-ViT encoder allows for rapid processing, achieving segmentation results in just 12ms. +- **Size**: The model size is significantly reduced, making it easier to deploy and run on mobile devices. + These advancements facilitate real-time applications, such as augmented reality, mobile games, and other interactive experiences. + +Learn more about the MobileSAM's performance on its [project page](https://github.com/ChaoningZhang/MobileSAM). + +### How easy is it to transition from the original SAM to MobileSAM? + +Transitioning from the original SAM to MobileSAM is straightforward as MobileSAM retains the same pipeline, including pre-processing, post-processing, and interfaces. Only the image encoder has been changed to the more efficient Tiny-ViT. Users currently using SAM can switch to MobileSAM with minimal code modifications, benefiting from improved performance without the need for significant reconfiguration. + +### What tasks are supported by the MobileSAM model? + +The MobileSAM model supports instance segmentation tasks. Currently, it is optimized for [Inference](../modes/predict.md) mode. Additional tasks like validation, training, and export are not supported at this time, as indicated in the mode compatibility table: +| Model Type | Tasks Supported | Inference | Validation | Training | Export | +| ---------- | -------------------------------------------- | --------- | ---------- | -------- | ------ | +| MobileSAM | [Instance Segmentation](../tasks/segment.md) | ✅ | ❌ | ❌ | ❌ | + +For more information about supported tasks and operational modes, check the [tasks page](../tasks/segment.md) and the mode details like [Inference](../modes/predict.md), [Validation](../modes/val.md), and [Export](../modes/export.md). diff --git a/docs/en/models/rtdetr.md b/docs/en/models/rtdetr.md index fcabf844..80fdbb8c 100644 --- a/docs/en/models/rtdetr.md +++ b/docs/en/models/rtdetr.md @@ -100,4 +100,64 @@ If you use Baidu's RT-DETR in your research or development work, please cite the We would like to acknowledge Baidu and the [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) team for creating and maintaining this valuable resource for the computer vision community. Their contribution to the field with the development of the Vision Transformers-based real-time object detector, RT-DETR, is greatly appreciated. -_Keywords: RT-DETR, Transformer, ViT, Vision Transformers, Baidu RT-DETR, PaddlePaddle, Paddle Paddle RT-DETR, real-time object detection, Vision Transformers-based object detection, pre-trained PaddlePaddle RT-DETR models, Baidu's RT-DETR usage, Ultralytics Python API_ +## FAQ + +### What is Baidu's RT-DETR and how does it work? + +Baidu's RT-DETR (Real-Time Detection Transformer) is an end-to-end vision transformer-based object detector designed for real-time performance without compromising accuracy. Unlike traditional object detectors, it employs a convolutional backbone with an efficient hybrid encoder that handles multiscale feature processing by decoupling intra-scale interaction and cross-scale fusion. The model also utilizes IoU-aware query selection for initializing object queries, which improves detection accuracy. For flexible applications, the inference speed can be adjusted using different decoder layers without retraining. For more details, you can check out the [original paper](https://arxiv.org/abs/2304.08069). + +### How can I use a pre-trained RT-DETR model with Ultralytics? + +Using a pre-trained RT-DETR model with the Ultralytics Python API is straightforward. Here's an example: + +```python +from ultralytics import RTDETR + +# Load a COCO-pretrained RT-DETR-l model +model = RTDETR("rtdetr-l.pt") + +# Display model information (optional) +model.info() + +# Train the model on the COCO8 example dataset for 100 epochs +results = model.train(data="coco8.yaml", epochs=100, imgsz=640) + +# Run inference with the RT-DETR-l model on the 'bus.jpg' image +results = model("path/to/bus.jpg") +``` + +You can find more details on specific modes like [Predict](../modes/predict.md), [Train](../modes/train.md), and [Export](../modes/export.md). + +### What are the key features of RT-DETR that make it unique? + +The RT-DETR model has several key features that set it apart: + +1. **Efficient Hybrid Encoder**: This design processes multiscale features by decoupling intra-scale interaction and cross-scale fusion, reducing computational costs. +2. **IoU-aware Query Selection**: Enhances object query initialization, focusing on the most relevant objects for higher detection accuracy. +3. **Adaptable Inference Speed**: The model supports flexible adjustments of inference speed by using different decoder layers without retraining, making it highly adaptable for various real-time object detection scenarios. + +### What performance can I expect from RT-DETR on different scales? + +The Ultralytics Python API provides pre-trained PaddlePaddle RT-DETR models in different scales, offering notable performance metrics: + +- **RT-DETR-L**: Achieves 53.0% AP on COCO val2017 and runs at 114 FPS on a T4 GPU. +- **RT-DETR-X**: Achieves 54.8% AP on COCO val2017 and runs at 74 FPS on a T4 GPU. + +This makes the RT-DETR models highly efficient for real-time applications requiring both speed and accuracy. + +### How can I acknowledge Baidu's contribution if I use RT-DETR in my research? + +If you use Baidu's RT-DETR in your research or development work, you should cite the original paper. Here is the BibTeX entry for your reference: + +```bibtex +@misc{lv2023detrs, + title={DETRs Beat YOLOs on Real-time Object Detection}, + author={Wenyu Lv and Shangliang Xu and Yian Zhao and Guanzhong Wang and Jinman Wei and Cheng Cui and Yuning Du and Qingqing Dang and Yi Liu}, + year={2023}, + eprint={2304.08069}, + archivePrefix={arXiv}, + primaryClass={cs.CV} +} +``` + +Additionally, acknowledge Baidu and the [PaddlePaddle](https://github.com/PaddlePaddle/PaddleDetection) team for creating and maintaining this valuable resource for the computer vision community. diff --git a/docs/en/models/sam.md b/docs/en/models/sam.md index 5dc97a85..aad0792b 100644 --- a/docs/en/models/sam.md +++ b/docs/en/models/sam.md @@ -224,4 +224,32 @@ If you find SAM useful in your research or development work, please consider cit We would like to express our gratitude to Meta AI for creating and maintaining this valuable resource for the computer vision community. -_keywords: Segment Anything, Segment Anything Model, SAM, Meta SAM, image segmentation, promptable segmentation, zero-shot performance, SA-1B dataset, advanced architecture, auto-annotation, Ultralytics, pre-trained models, SAM base, SAM large, instance segmentation, computer vision, AI, artificial intelligence, machine learning, data annotation, segmentation masks, detection model, YOLO detection model, bibtex, Meta AI._ +## FAQ + +### What is the Segment Anything Model (SAM)? + +The Segment Anything Model (SAM) is a cutting-edge image segmentation model designed for promptable segmentation, allowing it to generate segmentation masks based on spatial or text-based prompts. SAM is capable of zero-shot transfer, meaning it can adapt to new image distributions and tasks without prior knowledge. It's trained on the extensive [SA-1B dataset](https://ai.facebook.com/datasets/segment-anything/), which comprises over 1 billion masks on 11 million images. For more details, check the [Introduction to SAM](#introduction-to-sam-the-segment-anything-model). + +### How does SAM achieve zero-shot performance in image segmentation? + +SAM achieves zero-shot performance by leveraging its advanced architecture, which includes a robust image encoder, a prompt encoder, and a lightweight mask decoder. This configuration enables SAM to respond effectively to any given prompt and adapt to new tasks without additional training. Its training on the highly diverse SA-1B dataset further enhances its adaptability. Learn more about its architecture in the [Key Features of the Segment Anything Model](#key-features-of-the-segment-anything-model-sam). + +### Can I use SAM for tasks other than segmentation? + +Yes, SAM can be employed for various downstream tasks beyond its primary segmentation role. These tasks include edge detection, object proposal generation, instance segmentation, and preliminary text-to-mask prediction. Through prompt engineering, SAM can adapt swiftly to new tasks and data distributions, offering flexible applications. For practical use cases and examples, refer to the [How to Use SAM](#how-to-use-sam-versatility-and-power-in-image-segmentation) section. + +### How does SAM compare to Ultralytics YOLOv8 models? + +While SAM excels in automatic, real-time segmentation with promptable capabilities, Ultralytics YOLOv8 models are smaller, faster, and more efficient for object detection and instance segmentation tasks. For instance, the YOLOv8n-seg model is significantly smaller and faster than the SAM-b model, making it ideal for applications requiring high-speed processing with lower computational resources. See a detailed comparison in the [SAM comparison vs YOLOv8](#sam-comparison-vs-yolov8) section. + +### How can I auto-annotate a segmentation dataset using SAM? + +To auto-annotate a segmentation dataset, you can use the `auto_annotate` function provided by the Ultralytics framework. This function allows you to automatically generate high-quality segmentation masks using a pre-trained detection model paired with the SAM segmentation model: + +```python +from ultralytics.data.annotator import auto_annotate + +auto_annotate(data="path/to/images", det_model="yolov8x.pt", sam_model="sam_b.pt") +``` + +This approach accelerates the annotation process by bypassing manual labeling, making it especially useful for large datasets. For step-by-step instructions, visit [Generate Your Segmentation Dataset Using a Detection Model](#generate-your-segmentation-dataset-using-a-detection-model). diff --git a/docs/en/models/yolo-nas.md b/docs/en/models/yolo-nas.md index fbcd7e44..b3307838 100644 --- a/docs/en/models/yolo-nas.md +++ b/docs/en/models/yolo-nas.md @@ -117,4 +117,62 @@ If you employ YOLO-NAS in your research or development work, please cite SuperGr We express our gratitude to Deci AI's [SuperGradients](https://github.com/Deci-AI/super-gradients/) team for their efforts in creating and maintaining this valuable resource for the computer vision community. We believe YOLO-NAS, with its innovative architecture and superior object detection capabilities, will become a critical tool for developers and researchers alike. -_Keywords: YOLO-NAS, Deci AI, object detection, deep learning, neural architecture search, Ultralytics Python API, YOLO model, SuperGradients, pre-trained models, quantization-friendly basic block, advanced training schemes, post-training quantization, AutoNAC optimization, COCO, Objects365, Roboflow 100_ +## FAQ + +### What is YOLO-NAS and how does it differ from previous YOLO models? + +YOLO-NAS, developed by Deci AI, is an advanced object detection model built using Neural Architecture Search (NAS). It offers significant improvements over previous YOLO models, including: + +- **Quantization-Friendly Basic Block:** This helps reduce the precision drop when the model is converted to INT8 quantization. +- **Enhanced Training and Quantization:** YOLO-NAS utilizes sophisticated training schemes and post-training quantization techniques. +- **Pre-trained on Large Datasets:** Utilizes the COCO, Objects365, and Roboflow 100 datasets, making it highly robust for downstream tasks. + +For more details, refer to the [Overview of YOLO-NAS](#overview). + +### How can I use YOLO-NAS models in my Python application? + +Ultralytics makes it easy to integrate YOLO-NAS models into your Python applications via the `ultralytics` package. Here's a basic example: + +```python +from ultralytics import NAS + +# Load a pre-trained YOLO-NAS-s model +model = NAS("yolo_nas_s.pt") + +# Display model information +model.info() + +# Validate the model on the COCO8 dataset +results = model.val(data="coco8.yaml") + +# Run inference with the YOLO-NAS-s model on an image +results = model("path/to/image.jpg") +``` + +For additional examples, see the [Usage Examples](#usage-examples) section of the documentation. + +### Why should I use YOLO-NAS for object detection tasks? + +YOLO-NAS offers several advantages that make it a compelling choice for object detection: + +- **High Performance:** Achieves a balance between accuracy and latency, crucial for real-time applications. +- **Pre-Trained on Diverse Datasets:** Provides robust models for various use cases with extensive pre-training on datasets like COCO and Objects365. +- **Quantization Efficiency:** For applications requiring low latency, the INT8 quantized versions show minimal precision drop, making them suitable for resource-constrained environments. + +For a detailed comparison of model variants, see [Pre-trained Models](#pre-trained-models). + +### What are the supported tasks and modes for YOLO-NAS models? + +YOLO-NAS models support several tasks and modes, including: + +- **Object Detection:** Suitable for identifying and localizing objects in images. +- **Inference and Validation:** Models can be used for both inference and validation to assess performance. +- **Export:** YOLO-NAS models can be exported to various formats for deployment. + +However, the YOLO-NAS implementation using the `ultralytics` package does not currently support training. For more information, visit the [Supported Tasks and Modes](#supported-tasks-and-modes) section. + +### How does quantization impact the performance of YOLO-NAS models? + +Quantization can significantly reduce the model size and improve inference speed with minimal impact on accuracy. YOLO-NAS introduces a quantization-friendly basic block, resulting in minimal precision loss when converted to INT8. This makes YOLO-NAS highly efficient for deployment in scenarios with resource constraints. + +To understand the performance metrics of INT8 quantized models, refer to the [Pre-trained Models](#pre-trained-models) section. diff --git a/docs/en/models/yolo-world.md b/docs/en/models/yolo-world.md index 2d94ee1a..c0dcbf82 100644 --- a/docs/en/models/yolo-world.md +++ b/docs/en/models/yolo-world.md @@ -335,3 +335,61 @@ We extend our gratitude to the [Tencent AILab Computer Vision Center](https://ai ``` For further reading, the original YOLO-World paper is available on [arXiv](https://arxiv.org/pdf/2401.17270v2.pdf). The project's source code and additional resources can be accessed via their [GitHub repository](https://github.com/AILab-CVC/YOLO-World). We appreciate their commitment to advancing the field and sharing their valuable insights with the community. + +## FAQ + +### What is the YOLO-World Model and how does it improve open-vocabulary object detection? + +The YOLO-World Model is an advanced, real-time object detection model based on Ultralytics YOLOv8, designed specifically for open-vocabulary detection tasks. It leverages vision-language modeling and pre-training on large datasets to detect a broad range of objects based on descriptive texts, significantly reducing computational demands while maintaining high performance. This makes it suitable for real-time applications across various industries needing immediate results. + +### How do I train a custom YOLO-World Model using the Ultralytics API? + +Training a custom YOLO-World Model is straightforward with Ultralytics' API. You can use pretrained weights and configuration files to start training on your dataset. Here is an example of training with Python: + +```python +from ultralytics import YOLOWorld + +# Load a pretrained YOLOv8s-worldv2 model +model = YOLOWorld("yolov8s-worldv2.pt") + +# Train the model on the COCO8 example dataset for 100 epochs +results = model.train(data="coco8.yaml", epochs=100, imgsz=640) + +# Run inference with the YOLOv8s-worldv2 model on an image +results = model("path/to/image.jpg") +``` + +Refer to the [Training](../modes/train.md) page for more details. + +### What are the main advantages of using YOLO-World for object detection? + +YOLO-World offers several advantages: + +- **Real-time detection**: Utilizes CNNs for high-speed inference. +- **Lower computational demand**: Efficiently processes images with minimal resources. +- **Open-vocabulary detection**: Detects objects without predefined categories, based on descriptive texts. +- **High performance**: Outperforms other models on standard benchmarks while running on a single NVIDIA V100 GPU. + +### Can I customize the classes YOLO-World detects without retraining the model? + +Yes, YOLO-World allows you to dynamically specify detection classes through custom prompts without retraining the model. Here's an example of how to set custom classes: + +```python +from ultralytics import YOLOWorld + +# Initialize a YOLO-World model +model = YOLOWorld("yolov8s-world.pt") + +# Define custom classes +model.set_classes(["person", "bus"]) + +# Execute prediction on an image +results = model.predict("path/to/image.jpg") +results[0].show() +``` + +You can learn more about this feature on the [Predict Usage](#predict-usage) section. + +### What datasets are supported for training YOLO-World from scratch? + +YOLO-World supports various datasets for training, including Objects365, GQA, and Flickr30k for detection and grounding tasks. For validation, it supports datasets like LVIS minival. Detailed information about preparing and using these datasets can be found in the [Zero-shot Transfer on COCO Dataset](#zero-shot-transfer-on-coco-dataset) section. diff --git a/docs/en/models/yolov10.md b/docs/en/models/yolov10.md index 24b13eaa..6c579858 100644 --- a/docs/en/models/yolov10.md +++ b/docs/en/models/yolov10.md @@ -44,14 +44,14 @@ YOLOv10 comes in various model scales to cater to different application needs: YOLOv10 outperforms previous YOLO versions and other state-of-the-art models in terms of accuracy and efficiency. For example, YOLOv10-S is 1.8x faster than RT-DETR-R18 with similar AP on the COCO dataset, and YOLOv10-B has 46% less latency and 25% fewer parameters than YOLOv9-C with the same performance. -| Model | Input Size | APval | FLOPs (G) | Latency (ms) | -| --------- | ---------- | ---------------- | --------- | ------------ | -| YOLOv10-N | 640 | 38.5 | **6.7** | **1.84** | -| YOLOv10-S | 640 | 46.3 | 21.6 | 2.49 | -| YOLOv10-M | 640 | 51.1 | 59.1 | 4.74 | -| YOLOv10-B | 640 | 52.5 | 92.0 | 5.74 | -| YOLOv10-L | 640 | 53.2 | 120.3 | 7.28 | -| YOLOv10-X | 640 | **54.4** | 160.4 | 10.70 | +| Model | Input Size | APval | FLOPs (G) | Latency (ms) | +| -------------- | ---------- | ---------------- | --------- | ------------ | +| [YOLOv10-N][1] | 640 | 38.5 | **6.7** | **1.84** | +| [YOLOv10-S][2] | 640 | 46.3 | 21.6 | 2.49 | +| [YOLOv10-M][3] | 640 | 51.1 | 59.1 | 4.74 | +| [YOLOv10-B][4] | 640 | 52.5 | 92.0 | 5.74 | +| [YOLOv10-L][5] | 640 | 53.2 | 120.3 | 7.28 | +| [YOLOv10-X][6] | 640 | **54.4** | 160.4 | 10.70 | Latency measured with TensorRT FP16 on T4 GPU. @@ -90,33 +90,40 @@ Compared to other state-of-the-art detectors: Here is a detailed comparison of YOLOv10 variants with other state-of-the-art models: -| Model | Params (M) | FLOPs (G) | APval (%) | Latency (ms) | Latency (Forward) (ms) | -| ------------- | ---------- | --------- | --------- | ------------ | ---------------------- | -| YOLOv6-3.0-N | 4.7 | 11.4 | 37.0 | 2.69 | **1.76** | -| Gold-YOLO-N | 5.6 | 12.1 | **39.6** | 2.92 | 1.82 | -| YOLOv8-N | 3.2 | 8.7 | 37.3 | 6.16 | 1.77 | -| **YOLOv10-N** | **2.3** | **6.7** | 39.5 | **1.84** | 1.79 | -| | | | | | | -| YOLOv6-3.0-S | 18.5 | 45.3 | 44.3 | 3.42 | 2.35 | -| Gold-YOLO-S | 21.5 | 46.0 | 45.4 | 3.82 | 2.73 | -| YOLOv8-S | 11.2 | 28.6 | 44.9 | 7.07 | **2.33** | -| **YOLOv10-S** | **7.2** | **21.6** | **46.8** | **2.49** | 2.39 | -| | | | | | | -| RT-DETR-R18 | 20.0 | 60.0 | 46.5 | **4.58** | **4.49** | -| YOLOv6-3.0-M | 34.9 | 85.8 | 49.1 | 5.63 | 4.56 | -| Gold-YOLO-M | 41.3 | 87.5 | 49.8 | 6.38 | 5.45 | -| YOLOv8-M | 25.9 | 78.9 | 50.6 | 9.50 | 5.09 | -| **YOLOv10-M** | **15.4** | **59.1** | **51.3** | 4.74 | 4.63 | -| | | | | | | -| YOLOv6-3.0-L | 59.6 | 150.7 | 51.8 | 9.02 | 7.90 | -| Gold-YOLO-L | 75.1 | 151.7 | 51.8 | 10.65 | 9.78 | -| YOLOv8-L | 43.7 | 165.2 | 52.9 | 12.39 | 8.06 | -| RT-DETR-R50 | 42.0 | 136.0 | 53.1 | 9.20 | 9.07 | -| **YOLOv10-L** | **24.4** | **120.3** | **53.4** | **7.28** | **7.21** | -| | | | | | | -| YOLOv8-X | 68.2 | 257.8 | 53.9 | 16.86 | 12.83 | -| RT-DETR-R101 | 76.0 | 259.0 | 54.3 | 13.71 | 13.58 | -| **YOLOv10-X** | **29.5** | **160.4** | **54.4** | **10.70** | **10.60** | +| Model | Params (M) | FLOPs (G) | APval (%) | Latency (ms) | Latency (Forward) (ms) | +| ------------------ | ---------- | --------- | --------- | ------------ | ---------------------- | +| YOLOv6-3.0-N | 4.7 | 11.4 | 37.0 | 2.69 | **1.76** | +| Gold-YOLO-N | 5.6 | 12.1 | **39.6** | 2.92 | 1.82 | +| YOLOv8-N | 3.2 | 8.7 | 37.3 | 6.16 | 1.77 | +| **[YOLOv10-N][1]** | **2.3** | **6.7** | 39.5 | **1.84** | 1.79 | +| | | | | | | +| YOLOv6-3.0-S | 18.5 | 45.3 | 44.3 | 3.42 | 2.35 | +| Gold-YOLO-S | 21.5 | 46.0 | 45.4 | 3.82 | 2.73 | +| YOLOv8-S | 11.2 | 28.6 | 44.9 | 7.07 | **2.33** | +| **[YOLOv10-S][2]** | **7.2** | **21.6** | **46.8** | **2.49** | 2.39 | +| | | | | | | +| RT-DETR-R18 | 20.0 | 60.0 | 46.5 | **4.58** | **4.49** | +| YOLOv6-3.0-M | 34.9 | 85.8 | 49.1 | 5.63 | 4.56 | +| Gold-YOLO-M | 41.3 | 87.5 | 49.8 | 6.38 | 5.45 | +| YOLOv8-M | 25.9 | 78.9 | 50.6 | 9.50 | 5.09 | +| **[YOLOv10-M][3]** | **15.4** | **59.1** | **51.3** | 4.74 | 4.63 | +| | | | | | | +| YOLOv6-3.0-L | 59.6 | 150.7 | 51.8 | 9.02 | 7.90 | +| Gold-YOLO-L | 75.1 | 151.7 | 51.8 | 10.65 | 9.78 | +| YOLOv8-L | 43.7 | 165.2 | 52.9 | 12.39 | 8.06 | +| RT-DETR-R50 | 42.0 | 136.0 | 53.1 | 9.20 | 9.07 | +| **[YOLOv10-L][5]** | **24.4** | **120.3** | **53.4** | **7.28** | **7.21** | +| | | | | | | +| YOLOv8-X | 68.2 | 257.8 | 53.9 | 16.86 | 12.83 | +| RT-DETR-R101 | 76.0 | 259.0 | 54.3 | 13.71 | 13.58 | +| **[YOLOv10-X][6]** | **29.5** | **160.4** | **54.4** | **10.70** | **10.60** | + +[1]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10n.pt +[2]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10s.pt +[3]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10m.pt +[4]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10b.pt +[5]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10l.pt +[6]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10x.pt ## Usage Examples @@ -224,9 +231,65 @@ We would like to acknowledge the YOLOv10 authors from [Tsinghua University](http For detailed implementation, architectural innovations, and experimental results, please refer to the YOLOv10 [research paper](https://arxiv.org/pdf/2405.14458) and [GitHub repository](https://github.com/THU-MIG/yolov10) by the Tsinghua University team. -[1]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10n.pt -[2]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10s.pt -[3]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10m.pt -[4]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10b.pt -[5]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10l.pt -[6]: https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov10x.pt +## FAQ + +### What is YOLOv10 and how does it differ from previous versions? + +YOLOv10 is the latest version of the YOLO (You Only Look Once) series for real-time object detection, optimized for both accuracy and efficiency. Unlike previous versions, YOLOv10 eliminates the need for non-maximum suppression (NMS) by utilizing consistent dual assignments, significantly reducing inference latency. It also introduces a holistic model design approach and various architectural enhancements, making it superior in performance and computational efficiency. + +Learn more about YOLOv10's architecture in the [Architecture section](#architecture). + +### How can I use YOLOv10 for real-time object detection in Python? + +To use YOLOv10 for real-time object detection in Python, you can follow this example script: + +```python +from ultralytics import YOLO + +# Load a pre-trained YOLOv10n model +model = YOLO("yolov10n.pt") + +# Perform object detection on an image +results = model("image.jpg") + +# Display the results +results[0].show() +``` + +This example demonstrates loading a pre-trained YOLOv10 model and performing object detection on an image. You can also run detection via CLI with: + +```bash +# Load a COCO-pretrained YOLOv10n model and run inference on the 'bus.jpg' image +yolo detect predict model=yolov10n.pt source=path/to/bus.jpg +``` + +Explore more usage examples in the [Usage Examples](#usage-examples) section. + +### What are the key features that make YOLOv10 stand out? + +YOLOv10 offers several innovative features: + +- **NMS-Free Training**: Utilizes consistent dual assignments to eliminate NMS, reducing inference latency. +- **Holistic Model Design**: Comprehensive optimization of model components for both efficiency and accuracy, including lightweight classification heads and large-kernel convolutions. +- **Enhanced Model Capabilities**: Incorporates partial self-attention modules and other advanced techniques to boost performance without significant computational cost. + +Dive into more details on these features in the [Key Features](#key-features) section. + +### Which model variants are available in YOLOv10 and how do they differ? + +YOLOv10 offers several variants tailored for different application needs: + +- **YOLOv10-N**: Nano version for extremely resource-constrained environments. +- **YOLOv10-S**: Small version balancing speed and accuracy. +- **YOLOv10-M**: Medium version for general-purpose use. +- **YOLOv10-B**: Balanced version with increased width for higher accuracy. +- **YOLOv10-L**: Large version for higher accuracy at the cost of increased computational resources. +- **YOLOv10-X**: Extra-large version for maximum accuracy and performance. + +Each variant offers a trade-off between computational efficiency and detection accuracy, suitable for various real-time applications. See the complete [Model Variants](#model-variants) for more information. + +### How does YOLOv10's performance compare to other object detection models? + +YOLOv10 outperforms previous YOLO versions and other state-of-the-art models in both accuracy and efficiency metrics. For example, YOLOv10-S is 1.8x faster than RT-DETR-R18 with a similar Average Precision (AP) on the COCO dataset. Additionally, YOLOv10-B has 46% less latency and 25% fewer parameters than YOLOv9-C while maintaining equivalent performance. + +For detailed benchmark results, check out the [Performance](#performance) section. diff --git a/docs/en/models/yolov3.md b/docs/en/models/yolov3.md index 8ea1ee01..273b4479 100644 --- a/docs/en/models/yolov3.md +++ b/docs/en/models/yolov3.md @@ -96,3 +96,55 @@ If you use YOLOv3 in your research, please cite the original YOLO papers and the ``` Thank you to Joseph Redmon and Ali Farhadi for developing the original YOLOv3. + +## FAQ + +### What is YOLOv3, and how does it improve object detection? + +YOLOv3 is the third iteration of the _You Only Look Once (YOLO)_ object detection algorithm. It enhances object detection accuracy by utilizing three different sizes of detection kernels: 13x13, 26x26, and 52x52. This allows the model to detect objects at multiple scales, improving accuracy for objects of varying sizes. YOLOv3 also supports multi-label predictions for bounding boxes and includes a superior feature extractor network. + +### Why should I use Ultralytics' implementation of YOLOv3? + +Ultralytics' implementation of YOLOv3, known as YOLOv3-Ultralytics, retains the original model's architecture but adds significant enhancements. It offers more pre-trained models, additional training methods, and customization options, making it user-friendly and versatile for practical applications. This implementation enhances the usability and flexibility of YOLOv3 in real-world object detection tasks. + +### How does YOLOv3u differ from YOLOv3 and YOLOv3-Ultralytics? + +YOLOv3u is an updated version of YOLOv3-Ultralytics that incorporates the anchor-free, objectness-free split head used in YOLOv8 models. This update eliminates the need for pre-defined anchor boxes and objectness scores, making YOLOv3u more robust and accurate in detecting objects of varying sizes and shapes, without altering the backbone and neck architecture of YOLOv3. + +### Can I use YOLOv3 models for multiple prediction tasks? + +Yes, the YOLOv3 series, including YOLOv3, YOLOv3-Ultralytics, and YOLOv3u, are designed for object detection tasks. They support several modes such as [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md). This versatility ensures they can be used effectively across different stages of model deployment and development in various applications. + +### How can I train a YOLOv3 model using Ultralytics? + +You can train a YOLOv3 model using Ultralytics by leveraging the Python code or CLI commands: + +**Using Python:** + +```python +from ultralytics import YOLO + +# Load a COCO-pretrained YOLOv3n model +model = YOLO("yolov3n.pt") + +# Display model information (optional) +model.info() + +# Train the model on the COCO8 example dataset for 100 epochs +results = model.train(data="coco8.yaml", epochs=100, imgsz=640) + +# Run inference with the YOLOv3n model on the 'bus.jpg' image +results = model("path/to/bus.jpg") +``` + +**Using CLI:** + +```bash +# Load a COCO-pretrained YOLOv3n model and train it on the COCO8 example dataset for 100 epochs +yolo train model=yolov3n.pt data=coco8.yaml epochs=100 imgsz=640 + +# Load a COCO-pretrained YOLOv3n model and run inference on the 'bus.jpg' image +yolo predict model=yolov3n.pt source=path/to/bus.jpg +``` + +For more details, visit the [Train](../modes/train.md) and [Predict](../modes/predict.md) documentation pages. diff --git a/docs/en/models/yolov4.md b/docs/en/models/yolov4.md index d49014bd..9e04f730 100644 --- a/docs/en/models/yolov4.md +++ b/docs/en/models/yolov4.md @@ -68,3 +68,44 @@ We would like to acknowledge the YOLOv4 authors for their significant contributi ``` The original YOLOv4 paper can be found on [arXiv](https://arxiv.org/abs/2004.10934). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/AlexeyAB/darknet). We appreciate their efforts in advancing the field and making their work accessible to the broader community. + +## FAQ + +### What are the key features of the YOLOv4 model? + +YOLOv4, which stands for "You Only Look Once version 4," is designed with several innovative features that optimize its performance. Key features include: + +- **Weighted-Residual-Connections (WRC)** +- **Cross-Stage-Partial-connections (CSP)** +- **Cross mini-Batch Normalization (CmBN)** +- **Self-adversarial training (SAT)** +- **Mish-activation** +- **Mosaic data augmentation** +- **DropBlock regularization** +- **CIoU loss** + These features collectively enhance YOLOv4's speed and accuracy, making it ideal for real-time object detection tasks. For more details on its architecture, you can visit the [YOLOv4 section](https://docs.ultralytics.com/models/yolov4). + +### How does YOLOv4 compare to its predecessor, YOLOv3? + +YOLOv4 introduces several improvements over YOLOv3, including advanced features such as Weighted-Residual-Connections (WRC), Cross-Stage-Partial-connections (CSP), and Cross mini-Batch Normalization (CmBN). These enhancements contribute to better speed and accuracy in object detection: + +- **Higher Accuracy:** YOLOv4 achieves state-of-the-art results in object detection benchmarks. +- **Improved Speed:** Despite its complex architecture, YOLOv4 maintains real-time performance. +- **Better Backbone and Neck:** YOLOv4 utilizes CSPDarknet53 as the backbone and PANet as the neck, which are more advanced than YOLOv3's components. + For more information, compare the features in the [YOLOv3](yolov3.md) and YOLOv4 documentation. + +### Can YOLOv4 be used for training on a conventional GPU? + +Yes, YOLOv4 is designed to be efficient on conventional GPU hardware, making it accessible for various users. The model can be trained using a single GPU, which broadens its usability for researchers and developers without access to high-end hardware. The architecture balances efficiency and computational requirements, allowing real-time object detection even on affordable hardware. For specific training guidelines, refer to the instructions provided in the [YOLOv4 GitHub repository](https://github.com/AlexeyAB/darknet). + +### What is the "bag of freebies" in YOLOv4? + +The "bag of freebies" in YOLOv4 refers to techniques that enhance model accuracy during training without increasing inference costs. These include: + +- **Photometric Distortions:** Adjusting brightness, contrast, hue, saturation, and noise. +- **Geometric Distortions:** Applying random scaling, cropping, flipping, and rotating. + These techniques improve the model's robustness and ability to generalize across different image types. Learn more about these methods in the [YOLOv4 features and performance](#features-and-performance) section. + +### Is YOLOv4 supported by Ultralytics? + +As of the latest update, Ultralytics does not currently support YOLOv4 models. Users interested in utilizing YOLOv4 should refer to the original [YOLOv4 GitHub repository](https://github.com/AlexeyAB/darknet) for installation and usage instructions. Ultralytics intends to update their documentation and support once integration with YOLOv4 is implemented. For alternative models supported by Ultralytics, you can explore [Ultralytics YOLO models](https://docs.ultralytics.com/models/). diff --git a/docs/en/models/yolov5.md b/docs/en/models/yolov5.md index e3128f70..57d24ad0 100644 --- a/docs/en/models/yolov5.md +++ b/docs/en/models/yolov5.md @@ -112,3 +112,72 @@ If you use YOLOv5 or YOLOv5u in your research, please cite the Ultralytics YOLOv ``` Please note that YOLOv5 models are provided under [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) and [Enterprise](https://ultralytics.com/license) licenses. + +## FAQ + +### What is YOLOv5u and how does it differ from YOLOv5? + +YOLOv5u is an advanced version of the YOLOv5 object detection model developed by Ultralytics. It introduces an anchor-free, objectness-free split head, a feature adopted from the YOLOv8 models. This architectural change enhances the model's accuracy-speed tradeoff, making it more efficient and flexible for various object detection tasks. Learn more about these features in the [YOLOv5 Overview](#overview). + +### Why should I use the anchor-free split head in YOLOv5u? + +The anchor-free split head in YOLOv5u offers several advantages: + +- **Flexibility:** It alleviates the need for predefined anchor boxes, making the model more adaptable to diverse object scales and shapes. +- **Simplicity:** Reducing dependencies on anchor boxes simplifies the model architecture, potentially decreasing the computational load. +- **Performance:** Empirical results show enhanced performance in terms of accuracy and speed, making it suitable for real-time applications. + +For detailed information, see the [Anchor-free Split Ultralytics Head section](#key-features). + +### How can I deploy the YOLOv5u model for real-time object detection? + +Deploying YOLOv5u for real-time object detection involves several steps: + +1. **Load the Model:** + + ```python + from ultralytics import YOLO + + model = YOLO("yolov5u.pt") + ``` + +2. **Run Inference:** + ```python + results = model("path/to/image.jpg") + ``` + +For a comprehensive guide, refer to the [Usage Examples](#usage-examples) section. + +### What are the pre-trained model variants available for YOLOv5u? + +YOLOv5u offers a variety of pre-trained models to cater to different needs: + +- **YOLOv5nu** +- **YOLOv5su** +- **YOLOv5mu** +- **YOLOv5lu** +- **YOLOv5xu** +- **YOLOv5n6u** +- **YOLOv5s6u** +- **YOLOv5m6u** +- **YOLOv5l6u** +- **YOLOv5x6u** + +These models support tasks like detection and offer various modes such as [Inference](../modes/predict.md), [Validation](../modes/val.md), [Training](../modes/train.md), and [Export](../modes/export.md). For detailed metrics, see the [Performance Metrics](#performance-metrics) section. + +### How do YOLOv5u models perform on different hardware setups? + +YOLOv5u models have been evaluated on both CPU and GPU hardware, demonstrating competitive performance metrics across various setups. For example: + +- **YOLOv5nu.pt:** + + - **Speed (CPU ONNX):** 73.6 ms + - **Speed (A100 TensorRT):** 1.06 ms + - **mAP (50-95):** 34.3 + +- **YOLOv5lu.pt:** + - **Speed (CPU ONNX):** 408.4 ms + - **Speed (A100 TensorRT):** 2.50 ms + - **mAP (50-95):** 52.2 + +For more detailed performance metrics, visit the [Performance Metrics](#performance-metrics) section. diff --git a/docs/en/models/yolov6.md b/docs/en/models/yolov6.md index fa4b483d..585c78cc 100644 --- a/docs/en/models/yolov6.md +++ b/docs/en/models/yolov6.md @@ -104,3 +104,56 @@ We would like to acknowledge the authors for their significant contributions in ``` The original YOLOv6 paper can be found on [arXiv](https://arxiv.org/abs/2301.05586). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/meituan/YOLOv6). We appreciate their efforts in advancing the field and making their work accessible to the broader community. + +## FAQ + +### What is Meituan YOLOv6 and how does it differ from other YOLO models? + +Meituan YOLOv6 is a highly advanced object detection model that balances speed and accuracy, making it ideal for real-time applications. This model features unique enhancements such as the Bidirectional Concatenation (BiC) module, Anchor-Aided Training (AAT) strategy, and an improved backbone and neck design, providing state-of-the-art performance on the COCO dataset. Unlike prior YOLO models, YOLOv6 incorporates these innovative strategies to enhance both inference speed and detection accuracy. + +### How do I use the YOLOv6 model in a Python script? + +Using the YOLOv6 model in a Python script is straightforward. Here is a sample code snippet to get you started: + +```python +from ultralytics import YOLO + +# Build a YOLOv6n model from scratch +model = YOLO("yolov6n.yaml") + +# Display model information (optional) +model.info() + +# Train the model on the COCO8 example dataset for 100 epochs +results = model.train(data="coco8.yaml", epochs=100, imgsz=640) + +# Run inference with the YOLOv6n model on the 'bus.jpg' image +results = model("path/to/bus.jpg") +``` + +For more detailed examples and documentation, visit the [Train](../modes/train.md) and [Predict](../modes/predict.md) pages. + +### What are the performance metrics for different scales of YOLOv6 models? + +YOLOv6 offers pretrained models in various scales with the following performance metrics on the COCO val2017 dataset: + +- **YOLOv6-N**: 37.5% AP at 1187 FPS using an NVIDIA Tesla T4 GPU +- **YOLOv6-S**: 45.0% AP at 484 FPS +- **YOLOv6-M**: 50.0% AP at 226 FPS +- **YOLOv6-L**: 52.8% AP at 116 FPS +- **YOLOv6-L6**: State-of-the-art accuracy for real-time + +These metrics make YOLOv6 a versatile choice for both high-accuracy and high-speed applications. + +### What are the unique features of YOLOv6 that improve its performance? + +YOLOv6 introduces several key features that enhance its performance: + +- **Bidirectional Concatenation (BiC) Module**: Improves localization signals and offers performance gains with minimal speed degradation. +- **Anchor-Aided Training (AAT) Strategy**: Combines the benefits of anchor-based and anchor-free methods for better efficiency without sacrificing inference speed. +- **Enhanced Backbone and Neck Design**: Adds additional stages to the backbone and neck, achieving state-of-the-art results on high-resolution inputs. +- **Self-Distillation Strategy**: Boosts smaller model performance by refining the auxiliary regression branch during training and removing it during inference to maintain speed. + +### How can YOLOv6 be used for mobile and embedded applications? + +YOLOv6 supports quantized models for different precisions and models optimized for mobile platforms, making it suitable for applications requiring low-latency and energy-efficient computations. For deployment on mobile and edge devices, you can explore conversion to formats like TFLite and ONNX, as detailed in the [Export](../modes/export.md) documentation. Quantized models ensure high performance even on resource-constrained devices, enabling real-time object detection in mobile and IoT applications. diff --git a/docs/en/models/yolov7.md b/docs/en/models/yolov7.md index ba5c111d..023c2ee2 100644 --- a/docs/en/models/yolov7.md +++ b/docs/en/models/yolov7.md @@ -8,8 +8,57 @@ keywords: YOLOv7, real-time object detection, Ultralytics, AI, computer vision, YOLOv7 is a state-of-the-art real-time object detector that surpasses all known object detectors in both speed and accuracy in the range from 5 FPS to 160 FPS. It has the highest accuracy (56.8% AP) among all known real-time object detectors with 30 FPS or higher on GPU V100. Moreover, YOLOv7 outperforms other object detectors such as YOLOR, YOLOX, Scaled-YOLOv4, YOLOv5, and many others in speed and accuracy. The model is trained on the MS COCO dataset from scratch without using any other datasets or pre-trained weights. Source code for YOLOv7 is available on GitHub. -![YOLOv7 comparison with SOTA object detectors](https://github.com/ultralytics/ultralytics/assets/26833433/5e1e0420-8122-4c79-b8d0-2860aa79af92) -**Comparison of state-of-the-art object detectors.** From the results in Table 2 we know that the proposed method has the best speed-accuracy trade-off comprehensively. If we compare YOLOv7-tiny-SiLU with YOLOv5-N (r6.1), our method is 127 fps faster and 10.7% more accurate on AP. In addition, YOLOv7 has 51.4% AP at frame rate of 161 fps, while PPYOLOE-L with the same AP has only 78 fps frame rate. In terms of parameter usage, YOLOv7 is 41% less than PPYOLOE-L. If we compare YOLOv7-X with 114 fps inference speed to YOLOv5-L (r6.1) with 99 fps inference speed, YOLOv7-X can improve AP by 3.9%. If YOLOv7-X is compared with YOLOv5-X (r6.1) of similar scale, the inference speed of YOLOv7-X is 31 fps faster. In addition, in terms the amount of parameters and computation, YOLOv7-X reduces 22% of parameters and 8% of computation compared to YOLOv5-X (r6.1), but improves AP by 2.2% ([Source](https://arxiv.org/pdf/2207.02696.pdf)). +![YOLOv7 comparison with SOTA object detectors](https://github.com/ultralytics/ultralytics/assets/26833433/f7605c4e-8607-428b-aca4-0c2adfceb1a2) + +## Comparison of SOTA object detectors + +From the results in the YOLO comparison table we know that the proposed method has the best speed-accuracy trade-off comprehensively. If we compare YOLOv7-tiny-SiLU with YOLOv5-N (r6.1), our method is 127 fps faster and 10.7% more accurate on AP. In addition, YOLOv7 has 51.4% AP at frame rate of 161 fps, while PPYOLOE-L with the same AP has only 78 fps frame rate. In terms of parameter usage, YOLOv7 is 41% less than PPYOLOE-L. If we compare YOLOv7-X with 114 fps inference speed to YOLOv5-L (r6.1) with 99 fps inference speed, YOLOv7-X can improve AP by 3.9%. If YOLOv7-X is compared with YOLOv5-X (r6.1) of similar scale, the inference speed of YOLOv7-X is 31 fps faster. In addition, in terms the amount of parameters and computation, YOLOv7-X reduces 22% of parameters and 8% of computation compared to YOLOv5-X (r6.1), but improves AP by 2.2% ([Source](https://arxiv.org/pdf/2207.02696.pdf)). + +| Model | Params
(M) | FLOPs
(G) | Size
(pixels) | FPS | APtest / val
50-95 | APtest
50 | APtest
75 | APtest
S | APtest
M | APtest
L | +| --------------------- | ------------------ | ----------------- | --------------------- | ------- | -------------------------- | ----------------- | ----------------- | ---------------- | ---------------- | ---------------- | +| [YOLOX-S][1] | **9.0M** | **26.8G** | 640 | **102** | 40.5% / 40.5% | - | - | - | - | - | +| [YOLOX-M][1] | 25.3M | 73.8G | 640 | 81 | 47.2% / 46.9% | - | - | - | - | - | +| [YOLOX-L][1] | 54.2M | 155.6G | 640 | 69 | 50.1% / 49.7% | - | - | - | - | - | +| [YOLOX-X][1] | 99.1M | 281.9G | 640 | 58 | **51.5% / 51.1%** | - | - | - | - | - | +| | | | | | | | | | | | +| [PPYOLOE-S][2] | **7.9M** | **17.4G** | 640 | **208** | 43.1% / 42.7% | 60.5% | 46.6% | 23.2% | 46.4% | 56.9% | +| [PPYOLOE-M][2] | 23.4M | 49.9G | 640 | 123 | 48.9% / 48.6% | 66.5% | 53.0% | 28.6% | 52.9% | 63.8% | +| [PPYOLOE-L][2] | 52.2M | 110.1G | 640 | 78 | 51.4% / 50.9% | 68.9% | 55.6% | 31.4% | 55.3% | 66.1% | +| [PPYOLOE-X][2] | 98.4M | 206.6G | 640 | 45 | **52.2% / 51.9%** | **69.9%** | **56.5%** | **33.3%** | **56.3%** | **66.4%** | +| | | | | | | | | | | | +| [YOLOv5-N (r6.1)][3] | **1.9M** | **4.5G** | 640 | **159** | - / 28.0% | - | - | - | - | - | +| [YOLOv5-S (r6.1)][3] | 7.2M | 16.5G | 640 | 156 | - / 37.4% | - | - | - | - | - | +| [YOLOv5-M (r6.1)][3] | 21.2M | 49.0G | 640 | 122 | - / 45.4% | - | - | - | - | - | +| [YOLOv5-L (r6.1)][3] | 46.5M | 109.1G | 640 | 99 | - / 49.0% | - | - | - | - | - | +| [YOLOv5-X (r6.1)][3] | 86.7M | 205.7G | 640 | 83 | - / **50.7%** | - | - | - | - | - | +| | | | | | | | | | | | +| [YOLOR-CSP][4] | 52.9M | 120.4G | 640 | 106 | 51.1% / 50.8% | 69.6% | 55.7% | 31.7% | 55.3% | 64.7% | +| [YOLOR-CSP-X][4] | 96.9M | 226.8G | 640 | 87 | 53.0% / 52.7% | 71.4% | 57.9% | 33.7% | 57.1% | 66.8% | +| [YOLOv7-tiny-SiLU][5] | **6.2M** | **13.8G** | 640 | **286** | 38.7% / 38.7% | 56.7% | 41.7% | 18.8% | 42.4% | 51.9% | +| [YOLOv7][5] | 36.9M | 104.7G | 640 | 161 | 51.4% / 51.2% | 69.7% | 55.9% | 31.8% | 55.5% | 65.0% | +| [YOLOv7-X][5] | 71.3M | 189.9G | 640 | 114 | **53.1% / 52.9%** | **71.2%** | **57.8%** | **33.8%** | **57.1%** | **67.4%** | +| | | | | | | | | | | | +| [YOLOv5-N6 (r6.1)][3] | **3.2M** | **18.4G** | 1280 | **123** | - / 36.0% | - | - | - | - | - | +| [YOLOv5-S6 (r6.1)][3] | 12.6M | 67.2G | 1280 | 122 | - / 44.8% | - | - | - | - | - | +| [YOLOv5-M6 (r6.1)][3] | 35.7M | 200.0G | 1280 | 90 | - / 51.3% | - | - | - | - | - | +| [YOLOv5-L6 (r6.1)][3] | 76.8M | 445.6G | 1280 | 63 | - / 53.7% | - | - | - | - | - | +| [YOLOv5-X6 (r6.1)][3] | 140.7M | 839.2G | 1280 | 38 | - / **55.0%** | - | - | - | - | - | +| | | | | | | | | | | | +| [YOLOR-P6][4] | **37.2M** | **325.6G** | 1280 | **76** | 53.9% / 53.5% | 71.4% | 58.9% | 36.1% | 57.7% | 65.6% | +| [YOLOR-W6][4] | 79.8G | 453.2G | 1280 | 66 | 55.2% / 54.8% | 72.7% | 60.5% | 37.7% | 59.1% | 67.1% | +| [YOLOR-E6][4] | 115.8M | 683.2G | 1280 | 45 | 55.8% / 55.7% | 73.4% | 61.1% | 38.4% | 59.7% | 67.7% | +| [YOLOR-D6][4] | 151.7M | 935.6G | 1280 | 34 | **56.5% / 56.1%** | **74.1%** | **61.9%** | **38.9%** | **60.4%** | **68.7%** | +| | | | | | | | | | | | +| [YOLOv7-W6][5] | **70.4M** | **360.0G** | 1280 | **84** | 54.9% / 54.6% | 72.6% | 60.1% | 37.3% | 58.7% | 67.1% | +| [YOLOv7-E6][5] | 97.2M | 515.2G | 1280 | 56 | 56.0% / 55.9% | 73.5% | 61.2% | 38.0% | 59.9% | 68.4% | +| [YOLOv7-D6][5] | 154.7M | 806.8G | 1280 | 44 | 56.6% / 56.3% | 74.0% | 61.8% | 38.8% | 60.1% | 69.5% | +| [YOLOv7-E6E][5] | 151.7M | 843.2G | 1280 | 36 | **56.8% / 56.8%** | **74.4%** | **62.1%** | **39.3%** | **60.5%** | **69.0%** | + +[1]: https://github.com/Megvii-BaseDetection/YOLOX +[2]: https://github.com/PaddlePaddle/PaddleDetection +[3]: https://github.com/ultralytics/yolov5 +[4]: https://github.com/WongKinYiu/yolor +[5]: https://github.com/WongKinYiu/yolov7 ## Overview @@ -63,3 +112,25 @@ We would like to acknowledge the YOLOv7 authors for their significant contributi ``` The original YOLOv7 paper can be found on [arXiv](https://arxiv.org/pdf/2207.02696.pdf). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/WongKinYiu/yolov7). We appreciate their efforts in advancing the field and making their work accessible to the broader community. + +## FAQ + +### What makes YOLOv7 the most accurate real-time object detector? + +YOLOv7 stands out due to its superior accuracy and speed. With an accuracy of 56.8% AP and the ability to process up to 161 FPS on a GPU V100, it surpasses all known real-time object detectors. Additionally, YOLOv7 introduces features like model re-parameterization, dynamic label assignment, and efficient parameter usage, enhancing both speed and accuracy. Check out the detailed comparison in the [source paper](https://arxiv.org/pdf/2207.02696.pdf). + +### How does model re-parameterization work in YOLOv7? + +Model re-parameterization in YOLOv7 involves optimizing the gradient propagation path across various network layers. This strategy effectively recalibrates the training process, improving detection accuracy without increasing the inference cost. For more details, refer to the [Model Re-parameterization section](#key-features) in the documentation. + +### Why should I choose YOLOv7 over YOLOv5 or other object detectors? + +YOLOv7 outperforms YOLOv5 and other detectors like YOLOR, YOLOX, and PPYOLOE in both speed and accuracy. For instance, YOLOv7 achieves 127 FPS faster and 10.7% higher accuracy compared to YOLOv5-N. Furthermore, YOLOv7 effectively reduces parameters and computation while delivering higher AP scores, making it an optimal choice for real-time applications. Learn more in our [comparison table](#comparison-of-sota-object-detectors). + +### What datasets is YOLOv7 trained on, and how do they impact its performance? + +YOLOv7 is trained exclusively on the MS COCO dataset without using additional datasets or pre-trained weights. This robust dataset provides a wide variety of images and annotations that contribute to YOLOv7's high accuracy and generalization capabilities. Explore more about dataset formats and usage in our [datasets section](https://docs.ultralytics.com/datasets/detect/coco/). + +### Are there any practical YOLOv7 usage examples available? + +Currently, Ultralytics does not directly support YOLOv7 models. However, you can find detailed installation and usage instructions on the YOLOv7 GitHub repository. These steps involve cloning the repository, installing dependencies, and setting up your environment to train and use the model. Follow the [YOLOv7 GitHub repository](https://github.com/WongKinYiu/yolov7) for the latest updates. For other examples, see our [usage examples](#usage-examples) section. diff --git a/docs/en/models/yolov8.md b/docs/en/models/yolov8.md index d932a154..2ce0eb4a 100644 --- a/docs/en/models/yolov8.md +++ b/docs/en/models/yolov8.md @@ -184,3 +184,34 @@ If you use the YOLOv8 model or any other software from this repository in your w ``` Please note that the DOI is pending and will be added to the citation once it is available. YOLOv8 models are provided under [AGPL-3.0](https://github.com/ultralytics/ultralytics/blob/main/LICENSE) and [Enterprise](https://ultralytics.com/license) licenses. + +## FAQ + +### What differentiates YOLOv8 from previous YOLO versions? + +YOLOv8 builds upon the advancements of its predecessors by incorporating state-of-the-art backbone and neck architectures for improved feature extraction and object detection performance. It utilizes an anchor-free split head for better accuracy and efficiency. With a focus on maintaining the optimal accuracy-speed tradeoff, YOLOv8 is suitable for real-time object detection across diverse applications. Explore more in [YOLOv8 Key Features](#key-features). + +### How can I use YOLOv8 for different tasks like segmentation and pose estimation? + +YOLOv8 is versatile, offering specialized variants for various tasks such as object detection, instance segmentation, pose/keypoints detection, oriented object detection, and classification. These models come pre-trained and are optimized for high performance and accuracy. For more details, refer to the [Supported Tasks and Modes](#supported-tasks-and-modes). + +### How do I run inference using a YOLOv8 model in Python? + +To run inference with a YOLOv8 model in Python, you can use the `YOLO` class from the Ultralytics package. Here's a basic example: + +```python +from ultralytics import YOLO + +model = YOLO("yolov8n.pt") +results = model("path/to/image.jpg") +``` + +For detailed examples, see the [Usage Examples](#usage-examples) section. + +### What are the performance benchmarks for YOLOv8 models? + +YOLOv8 models are benchmarked on datasets such as COCO and Open Images V7, showing significant improvements in mAP and speed across various hardware setups. Detailed performance metrics include parameters, FLOPs, and inference speeds on different devices. For comprehensive benchmark details, visit [Performance Metrics](#performance-metrics). + +### How do I export a YOLOv8 model for deployment? + +You can export YOLOv8 models to various formats like ONNX, TensorRT, and CoreML for seamless deployment across different platforms. The export process ensures maximum compatibility and performance optimization. Learn more about exporting models in the [Export](../modes/export.md) section. diff --git a/docs/en/models/yolov9.md b/docs/en/models/yolov9.md index 249b2634..5852203b 100644 --- a/docs/en/models/yolov9.md +++ b/docs/en/models/yolov9.md @@ -177,3 +177,35 @@ We would like to acknowledge the YOLOv9 authors for their significant contributi ``` The original YOLOv9 paper can be found on [arXiv](https://arxiv.org/pdf/2402.13616.pdf). The authors have made their work publicly available, and the codebase can be accessed on [GitHub](https://github.com/WongKinYiu/yolov9). We appreciate their efforts in advancing the field and making their work accessible to the broader community. + +## FAQ + +### What is YOLOv9 and why should I use it for real-time object detection? + +YOLOv9 is the latest iteration of the YOLO (You Only Look Once) object detection family, featuring groundbreaking techniques like Programmable Gradient Information (PGI) and Generalized Efficient Layer Aggregation Network (GELAN). This model demonstrates significant improvements in efficiency, accuracy, and adaptability, setting new benchmarks on the [MS COCO](../datasets/detect/coco.md) dataset. The integration of PGI and GELAN ensures retention of crucial data throughout the detection process, making YOLOv9 an exceptional choice for real-time object detection. + +### How do Programmable Gradient Information (PGI) and GELAN improve YOLOv9's performance? + +Programmable Gradient Information (PGI) helps counteract information loss in deep neural networks by ensuring the preservation of essential data across network layers. This leads to more reliable gradient generation and better model convergence. The Generalized Efficient Layer Aggregation Network (GELAN) enhances parameter utilization and computational efficiency by allowing flexible integration of various computational blocks. These innovations collectively improve the accuracy and efficiency of YOLOv9. For more details, see the [Innovations section](#programmable-gradient-information-pgi). + +### What makes YOLOv9 more efficient than previous YOLO versions? + +YOLOv9 incorporates several innovations like PGI and GELAN that effectively address the information bottleneck and improve layer aggregation, respectively. This results in high parameter efficiency and reduced computational load. Models such as YOLOv9s and YOLOv9e demonstrate significant gains in performance compared to previous versions. For a detailed performance comparison, refer to the [Performance section on MS COCO](#performance-on-ms-coco-dataset). + +### Can I train YOLOv9 on my custom dataset using Ultralytics? + +Yes, you can easily train YOLOv9 on your custom dataset using Ultralytics. The Ultralytics YOLO framework supports various modes including [Train](../modes/train.md), [Predict](../modes/predict.md), and [Val](../modes/val.md). For example, you can start training a YOLOv9c model with the following Python code snippet: + +```python +from ultralytics import YOLO + +# Load the YOLOv9c model configuration +model = YOLO("yolov9c.yaml") + +# Train the model on your custom dataset +results = model.train(data="custom_dataset.yaml", epochs=100, imgsz=640) +``` + +### How does YOLOv9 compare to other state-of-the-art real-time object detectors? + +YOLOv9 shows superior performance across different model sizes on the [COCO dataset](../datasets/detect/coco.md). It achieves higher mean Average Precision (mAP) with fewer parameters and computational resources compared to competitors. For instance, the YOLOv9c model operates with 42% fewer parameters and 21% less computational demand than YOLOv7 AF, while matching its accuracy. Detailed performance metrics can be found in the [Performance Comparison table](#performance-on-ms-coco-dataset). diff --git a/mkdocs.yml b/mkdocs.yml index 76cd8e78..fc81555e 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -84,7 +84,7 @@ extra: # version: - icon: fontawesome/brands/x-twitter link: https://twitter.com/ultralytics - icon: fontawesome/brands/youtube - link: https://www.youtube.com/ultralytics + link: https://youtube.com/ultralytics?sub_confirmation=1 - icon: fontawesome/brands/docker link: https://hub.docker.com/r/ultralytics/ultralytics/ - icon: fontawesome/brands/python