- **Google Cloud** Deep Learning VM. See [GCP Quickstart Guide](https://docs.ultralytics.com/yolov5/environments/google_cloud_quickstart_tutorial/)
@@ -59,4 +59,4 @@ jobs:
- If this badge is green, all [Ultralytics CI](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml?query=event%3Aschedule) tests are currently passing. CI tests verify correct operation of all YOLOv8 [Modes](https://docs.ultralytics.com/modes/) and [Tasks](https://docs.ultralytics.com/tasks/) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
+ If this badge is green, all [Ultralytics CI](https://github.com/ultralytics/ultralytics/actions/workflows/ci.yaml?query=event%3Aschedule) tests are currently passing. CI tests verify correct operation of all YOLO [Modes](https://docs.ultralytics.com/modes/) and [Tasks](https://docs.ultralytics.com/tasks/) on macOS, Windows, and Ubuntu every 24 hours and on every commit.
diff --git a/.github/workflows/merge-main-into-prs.yml b/.github/workflows/merge-main-into-prs.yml
index cb4cfbb64b..347ec1b99c 100644
--- a/.github/workflows/merge-main-into-prs.yml
+++ b/.github/workflows/merge-main-into-prs.yml
@@ -85,4 +85,3 @@ jobs:
print(f"Branches updated: {updated_branches}")
print(f"Branches already up-to-date: {up_to_date_branches}")
print(f"Total errors: {errors}")
-
diff --git a/CITATION.cff b/CITATION.cff
index bee0abe21a..6c294c0d9b 100644
--- a/CITATION.cff
+++ b/CITATION.cff
@@ -11,14 +11,14 @@ authors:
family-names: Jocher
affiliation: Ultralytics
orcid: 'https://orcid.org/0000-0001-5950-6979'
- - given-names: Ayush
- family-names: Chaurasia
- affiliation: Ultralytics
- orcid: 'https://orcid.org/0000-0002-7603-6750'
- family-names: Qiu
given-names: Jing
affiliation: Ultralytics
orcid: 'https://orcid.org/0000-0003-3783-7069'
+ - given-names: Ayush
+ family-names: Chaurasia
+ affiliation: Ultralytics
+ orcid: 'https://orcid.org/0000-0002-7603-6750'
repository-code: 'https://github.com/ultralytics/ultralytics'
url: 'https://ultralytics.com'
license: AGPL-3.0
diff --git a/README.md b/README.md
index 704c04b794..b39b089a2e 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@
- 
+
@@ -20,13 +20,13 @@
+
@@ -47,7 +47,7 @@ To request an Enterprise License please complete the form at [Ultralytics Licens
## | 
| | | | | 
@@ -137,13 +124,13 @@ All [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cf
See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for usage examples with these models trained on [COCO](https://docs.ultralytics.com/datasets/detect/coco/), which include 80 pre-trained classes.
-| Model | size
##
-
-
-
+
+
+
-
-
+
+
+
+
@@ -45,16 +45,14 @@
| | | | | |
-所有[模型](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)在首次使用时会自动从最新的Ultralytics [发布版本](https://github.com/ultralytics/assets/releases)下载。
+所有[模型](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models)在首次使用时自动从最新的 Ultralytics [发布](https://github.com/ultralytics/assets/releases)下载。
-| Roboflow | ClearML ⭐ NEW | Comet ⭐ NEW | Neural Magic ⭐ NEW |
-| :-------------------------------------------------------------------------------------------------------: | :------------------------------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------: |
-| 使用 [Roboflow](https://roboflow.com/?ref=ultralytics) 将您的自定义数据集直接标记并导出至 YOLOv8 进行训练 | 使用 [ClearML](https://clear.ml/)（开源！）自动跟踪、可视化，甚至远程训练 YOLOv8 | 免费且永久，[Comet](https://bit.ly/yolov8-readme-comet) 让您保存 YOLOv8 模型、恢复训练，并以交互式方式查看和调试预测 | 使用 [Neural Magic DeepSparse](https://bit.ly/yolov5-neuralmagic) 使 YOLOv8 推理速度提高多达 6 倍 |
+| Roboflow | ClearML ⭐ NEW | Comet ⭐ NEW | Neural Magic ⭐ NEW |
+| :--------------------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------: |
+| Label and export your custom datasets directly to YOLO11 for training with [Roboflow](https://roboflow.com/?ref=ultralytics) | Automatically track, visualize and even remotely train YOLO11 using [ClearML](https://clear.ml/) (open-source!) | Free forever, [Comet](https://bit.ly/yolov5-readme-comet) lets you save YOLO11 models, resume training, and interactively visualize and debug predictions | Run YOLO11 inference up to 6x faster with [Neural Magic DeepSparse](https://bit.ly/yolov5-neuralmagic) |
##
## 
-##
@@ -22,7 +22,7 @@ This dataset is intended for use with [Ultralytics HUB](https://hub.ultralytics.
allowfullscreen>
- Watch: Train YOLOv8 Pose Model on Tiger-Pose Dataset Using Ultralytics HUB
+ Watch: Train YOLO11 Pose Model on Tiger-Pose Dataset Using Ultralytics HUB
+
+
+
+ Watch: How to generate Analytical Graphs using Ultralytics | Line Graphs, Bar Plots, Area and Pie Charts
+
@@ -152,9 +152,9 @@ Find comprehensive information on the [Predict](../modes/predict.md) page for fu
## FAQ
-### What is a Coral Edge TPU and how does it enhance Raspberry Pi's performance with Ultralytics YOLOv8?
+### What is a Coral Edge TPU and how does it enhance Raspberry Pi's performance with Ultralytics YOLO11?
-The Coral Edge TPU is a compact device designed to add an Edge TPU coprocessor to your system. This coprocessor enables low-power, high-performance [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) inference, particularly optimized for TensorFlow Lite models. When using a Raspberry Pi, the Edge TPU accelerates ML model inference, significantly boosting performance, especially for Ultralytics YOLOv8 models. You can read more about the Coral Edge TPU on their [home page](https://coral.ai/products/accelerator).
+The Coral Edge TPU is a compact device designed to add an Edge TPU coprocessor to your system. This coprocessor enables low-power, high-performance [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) inference, particularly optimized for TensorFlow Lite models. When using a Raspberry Pi, the Edge TPU accelerates ML model inference, significantly boosting performance, especially for Ultralytics YOLO11 models. You can read more about the Coral Edge TPU on their [home page](https://coral.ai/products/accelerator).
### How do I install the Coral Edge TPU runtime on a Raspberry Pi?
@@ -166,9 +166,9 @@ sudo dpkg -i path/to/package.deb
Make sure to uninstall any previous Coral Edge TPU runtime versions by following the steps outlined in the [Installation Walkthrough](#installation-walkthrough) section.
-### Can I export my Ultralytics YOLOv8 model to be compatible with Coral Edge TPU?
+### Can I export my Ultralytics YOLO11 model to be compatible with Coral Edge TPU?
-Yes, you can export your Ultralytics YOLOv8 model to be compatible with the Coral Edge TPU. It is recommended to perform the export on Google Colab, an x86_64 Linux machine, or using the [Ultralytics Docker container](docker-quickstart.md). You can also use Ultralytics HUB for exporting. Here is how you can export your model using Python and CLI:
+Yes, you can export your Ultralytics YOLO11 model to be compatible with the Coral Edge TPU. It is recommended to perform the export on Google Colab, an x86_64 Linux machine, or using the [Ultralytics Docker container](docker-quickstart.md). You can also use Ultralytics HUB for exporting. Here is how you can export your model using Python and CLI:
!!! note "Exporting the model"
@@ -208,9 +208,9 @@ pip install -U tflite-runtime
For a specific wheel, such as TensorFlow 2.15.0 `tflite-runtime`, you can download it from [this link](https://github.com/feranick/TFlite-builds/releases) and install it using `pip`. Detailed instructions are available in the section on running the model [Running the Model](#running-the-model).
-### How do I run inference with an exported YOLOv8 model on a Raspberry Pi using the Coral Edge TPU?
+### How do I run inference with an exported YOLO11 model on a Raspberry Pi using the Coral Edge TPU?
-After exporting your YOLOv8 model to an Edge TPU-compatible format, you can run inference using the following code snippets:
+After exporting your YOLO11 model to an Edge TPU-compatible format, you can run inference using the following code snippets:
!!! note "Running the model"
diff --git a/docs/en/guides/data-collection-and-annotation.md b/docs/en/guides/data-collection-and-annotation.md
index 6ca205260e..058323ee29 100644
--- a/docs/en/guides/data-collection-and-annotation.md
+++ b/docs/en/guides/data-collection-and-annotation.md
@@ -88,7 +88,7 @@ Let's say you are ready to annotate now. There are several open-source tools ava
- **[Label Studio](https://github.com/HumanSignal/label-studio)**: A flexible tool that supports a wide range of annotation tasks and includes features for managing projects and quality control.
- **[CVAT](https://github.com/cvat-ai/cvat)**: A powerful tool that supports various annotation formats and customizable workflows, making it suitable for complex projects.
-- **[Labelme](https://github.com/labelmeai/labelme)**: A simple and easy-to-use tool that allows for quick annotation of images with polygons, making it ideal for straightforward tasks.
+- **[Labelme](https://github.com/wkentaro/labelme)**: A simple and easy-to-use tool that allows for quick annotation of images with polygons, making it ideal for straightforward tasks.
@@ -136,12 +136,12 @@ Bouncing your ideas and queries off other [computer vision](https://www.ultralyt
### Where to Find Help and Support
-- **GitHub Issues:** Visit the YOLOv8 GitHub repository and use the [Issues tab](https://github.com/ultralytics/ultralytics/issues) to raise questions, report bugs, and suggest features. The community and maintainers are there to help with any issues you face.
+- **GitHub Issues:** Visit the YOLO11 GitHub repository and use the [Issues tab](https://github.com/ultralytics/ultralytics/issues) to raise questions, report bugs, and suggest features. The community and maintainers are there to help with any issues you face.
- **Ultralytics Discord Server:** Join the [Ultralytics Discord server](https://discord.com/invite/ultralytics) to connect with other users and developers, get support, share knowledge, and brainstorm ideas.
### Official Documentation
-- **Ultralytics YOLOv8 Documentation:** Refer to the [official YOLOv8 documentation](./index.md) for thorough guides and valuable insights on numerous computer vision tasks and projects.
+- **Ultralytics YOLO11 Documentation:** Refer to the [official YOLO11 documentation](./index.md) for thorough guides and valuable insights on numerous computer vision tasks and projects.
## Conclusion
@@ -159,7 +159,7 @@ Ensuring high consistency and accuracy in data annotation involves establishing
### How many images do I need for training Ultralytics YOLO models?
-For effective [transfer learning](https://www.ultralytics.com/glossary/transfer-learning) and object detection with Ultralytics YOLO models, start with a minimum of a few hundred annotated objects per class. If training for just one class, begin with at least 100 annotated images and train for approximately 100 [epochs](https://www.ultralytics.com/glossary/epoch). More complex tasks might require thousands of images per class to achieve high reliability and performance. Quality annotations are crucial, so ensure your data collection and annotation processes are rigorous and aligned with your project's specific goals. Explore detailed training strategies in the [YOLOv8 training guide](../modes/train.md).
+For effective [transfer learning](https://www.ultralytics.com/glossary/transfer-learning) and object detection with Ultralytics YOLO models, start with a minimum of a few hundred annotated objects per class. If training for just one class, begin with at least 100 annotated images and train for approximately 100 [epochs](https://www.ultralytics.com/glossary/epoch). More complex tasks might require thousands of images per class to achieve high reliability and performance. Quality annotations are crucial, so ensure your data collection and annotation processes are rigorous and aligned with your project's specific goals. Explore detailed training strategies in the [YOLO11 training guide](../modes/train.md).
### What are some popular tools for data annotation?
@@ -167,7 +167,7 @@ Several popular open-source tools can streamline the data annotation process:
- **[Label Studio](https://github.com/HumanSignal/label-studio)**: A flexible tool supporting various annotation tasks, project management, and quality control features.
- **[CVAT](https://www.cvat.ai/)**: Offers multiple annotation formats and customizable workflows, making it suitable for complex projects.
-- **[Labelme](https://github.com/labelmeai/labelme)**: Ideal for quick and straightforward image annotation with polygons.
+- **[Labelme](https://github.com/wkentaro/labelme)**: Ideal for quick and straightforward image annotation with polygons.
These tools can help enhance the efficiency and accuracy of your annotation workflows. For extensive feature lists and guides, refer to our [data annotation tools documentation](../datasets/index.md).
diff --git a/docs/en/guides/deepstream-nvidia-jetson.md b/docs/en/guides/deepstream-nvidia-jetson.md
index ab15009b99..90c361cb92 100644
--- a/docs/en/guides/deepstream-nvidia-jetson.md
+++ b/docs/en/guides/deepstream-nvidia-jetson.md
@@ -1,10 +1,10 @@
---
comments: true
-description: Learn how to deploy Ultralytics YOLOv8 on NVIDIA Jetson devices using TensorRT and DeepStream SDK. Explore performance benchmarks and maximize AI capabilities.
-keywords: Ultralytics, YOLOv8, NVIDIA Jetson, JetPack, AI deployment, embedded systems, deep learning, TensorRT, DeepStream SDK, computer vision
+description: Learn how to deploy Ultralytics YOLO11 on NVIDIA Jetson devices using TensorRT and DeepStream SDK. Explore performance benchmarks and maximize AI capabilities.
+keywords: Ultralytics, YOLO11, NVIDIA Jetson, JetPack, AI deployment, embedded systems, deep learning, TensorRT, DeepStream SDK, computer vision
---
-# Ultralytics YOLOv8 on NVIDIA Jetson using DeepStream SDK and TensorRT
+# Ultralytics YOLO11 on NVIDIA Jetson using DeepStream SDK and TensorRT
@@ -14,10 +14,10 @@ keywords: Ultralytics, YOLOv8, NVIDIA Jetson, JetPack, AI deployment, embedded s
allowfullscreen>
- Watch: How to Run Multiple Streams with DeepStream SDK on Jetson Nano using Ultralytics YOLOv8
+ Watch: How to Run Multiple Streams with DeepStream SDK on Jetson Nano using Ultralytics YOLO11
@@ -33,7 +33,7 @@ This comprehensive guide provides a detailed walkthrough for deploying Ultralyti
Before you start to follow this guide:
-- Visit our documentation, [Quick Start Guide: NVIDIA Jetson with Ultralytics YOLOv8](nvidia-jetson.md) to set up your NVIDIA Jetson device with Ultralytics YOLOv8
+- Visit our documentation, [Quick Start Guide: NVIDIA Jetson with Ultralytics YOLO11](nvidia-jetson.md) to set up your NVIDIA Jetson device with Ultralytics YOLO11
- Install [DeepStream SDK](https://developer.nvidia.com/deepstream-getting-started) according to the JetPack version
- For JetPack 4.6.4, install [DeepStream 6.0.1](https://docs.nvidia.com/metropolis/deepstream/6.0.1/dev-guide/text/DS_Quickstart.html)
@@ -43,7 +43,7 @@ Before you start to follow this guide:
In this guide we have used the Debian package method of installing DeepStream SDK to the Jetson device. You can also visit the [DeepStream SDK on Jetson (Archived)](https://developer.nvidia.com/embedded/deepstream-on-jetson-downloads-archived) to access legacy versions of DeepStream.
-## DeepStream Configuration for YOLOv8
+## DeepStream Configuration for YOLO11
Here we are using [marcoslucianops/DeepStream-Yolo](https://github.com/marcoslucianops/DeepStream-Yolo) GitHub repository which includes NVIDIA DeepStream SDK support for YOLO models. We appreciate the efforts of marcoslucianops for his contributions!
@@ -61,7 +61,7 @@ Here we are using [marcoslucianops/DeepStream-Yolo](https://github.com/marcosluc
cd DeepStream-Yolo
```
-3. Download Ultralytics YOLOv8 detection model (.pt) of your choice from [YOLOv8 releases](https://github.com/ultralytics/assets/releases). Here we use [yolov8s.pt](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt).
+3. Download Ultralytics YOLO11 detection model (.pt) of your choice from [YOLO11 releases](https://github.com/ultralytics/assets/releases). Here we use [yolov8s.pt](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt).
```bash
wget https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt
@@ -69,7 +69,7 @@ Here we are using [marcoslucianops/DeepStream-Yolo](https://github.com/marcosluc
!!! note
- You can also use a [custom trained YOLOv8 model](https://docs.ultralytics.com/modes/train/).
+ You can also use a [custom trained YOLO11 model](https://docs.ultralytics.com/modes/train/).
4. Convert model to ONNX
@@ -179,7 +179,7 @@ deepstream-app -c deepstream_app_config.txt
It will take a long time to generate the TensorRT engine file before starting the inference. So please be patient.
-
- 
+
-For a detailed explanation of various tasks, please take a look at the Ultralytics Docs page on [YOLOv8 Tasks](../tasks/index.md).
+For a detailed explanation of various tasks, please take a look at the Ultralytics Docs page on [YOLO11 Tasks](../tasks/index.md).
### Can a Pre-trained Model Remember Classes It Knew Before Custom Training?
@@ -114,12 +114,12 @@ Connecting with other computer vision enthusiasts can be incredibly helpful for
### Community Support Channels
-- **GitHub Issues:** Head over to the YOLOv8 GitHub repository. You can use the [Issues tab](https://github.com/ultralytics/ultralytics/issues) to raise questions, report bugs, and suggest features. The community and maintainers can assist with specific problems you encounter.
+- **GitHub Issues:** Head over to the YOLO11 GitHub repository. You can use the [Issues tab](https://github.com/ultralytics/ultralytics/issues) to raise questions, report bugs, and suggest features. The community and maintainers can assist with specific problems you encounter.
- **Ultralytics Discord Server:** Become part of the [Ultralytics Discord server](https://discord.com/invite/ultralytics). Connect with fellow users and developers, seek support, exchange knowledge, and discuss ideas.
### Comprehensive Guides and Documentation
-- **Ultralytics YOLOv8 Documentation:** Explore the [official YOLOv8 documentation](./index.md) for in-depth guides and valuable tips on various computer vision tasks and projects.
+- **Ultralytics YOLO11 Documentation:** Explore the [official YOLO11 documentation](./index.md) for in-depth guides and valuable tips on various computer vision tasks and projects.
## Conclusion
@@ -138,11 +138,11 @@ To define a clear problem statement for your Ultralytics computer vision project
Providing a well-defined problem statement ensures that the project remains focused and aligned with your objectives. For a detailed guide, refer to our [practical guide](#defining-a-clear-problem-statement).
-### Why should I use Ultralytics YOLOv8 for speed estimation in my computer vision project?
+### Why should I use Ultralytics YOLO11 for speed estimation in my computer vision project?
-Ultralytics YOLOv8 is ideal for speed estimation because of its real-time object tracking capabilities, high accuracy, and robust performance in detecting and monitoring vehicle speeds. It overcomes inefficiencies and inaccuracies of traditional radar systems by leveraging cutting-edge computer vision technology. Check out our blog on [speed estimation using YOLOv8](https://www.ultralytics.com/blog/ultralytics-yolov8-for-speed-estimation-in-computer-vision-projects) for more insights and practical examples.
+Ultralytics YOLO11 is ideal for speed estimation because of its real-time object tracking capabilities, high accuracy, and robust performance in detecting and monitoring vehicle speeds. It overcomes inefficiencies and inaccuracies of traditional radar systems by leveraging cutting-edge computer vision technology. Check out our blog on [speed estimation using YOLO11](https://www.ultralytics.com/blog/ultralytics-yolov8-for-speed-estimation-in-computer-vision-projects) for more insights and practical examples.
-### How do I set effective measurable objectives for my computer vision project with Ultralytics YOLOv8?
+### How do I set effective measurable objectives for my computer vision project with Ultralytics YOLO11?
Set effective and measurable objectives using the SMART criteria:
diff --git a/docs/en/guides/distance-calculation.md b/docs/en/guides/distance-calculation.md
index 443b208b70..b0b12f919b 100644
--- a/docs/en/guides/distance-calculation.md
+++ b/docs/en/guides/distance-calculation.md
@@ -1,14 +1,14 @@
---
comments: true
-description: Learn how to calculate distances between objects using Ultralytics YOLOv8 for accurate spatial positioning and scene understanding.
-keywords: Ultralytics, YOLOv8, distance calculation, computer vision, object tracking, spatial positioning
+description: Learn how to calculate distances between objects using Ultralytics YOLO11 for accurate spatial positioning and scene understanding.
+keywords: Ultralytics, YOLO11, distance calculation, computer vision, object tracking, spatial positioning
---
-# Distance Calculation using Ultralytics YOLOv8
+# Distance Calculation using Ultralytics YOLO11
## What is Distance Calculation?
-Measuring the gap between two objects is known as distance calculation within a specified space. In the case of [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics), the [bounding box](https://www.ultralytics.com/glossary/bounding-box) centroid is employed to calculate the distance for bounding boxes highlighted by the user.
+Measuring the gap between two objects is known as distance calculation within a specified space. In the case of [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics), the [bounding box](https://www.ultralytics.com/glossary/bounding-box) centroid is employed to calculate the distance for bounding boxes highlighted by the user.
@@ -18,14 +18,14 @@ Measuring the gap between two objects is known as distance calculation within a
allowfullscreen>
- Watch: Distance Calculation using Ultralytics YOLOv8
+ Watch: Distance Calculation using Ultralytics YOLO11
@@ -18,7 +18,7 @@ A heatmap generated with [Ultralytics YOLOv8](https://github.com/ultralytics/ult
allowfullscreen>
- Watch: Heatmaps using Ultralytics YOLOv8
+ Watch: Heatmaps using Ultralytics YOLO11
-For a full list of augmentation hyperparameters used in YOLOv8 please refer to the [configurations page](../usage/cfg.md#augmentation-settings).
+For a full list of augmentation hyperparameters used in YOLO11 please refer to the [configurations page](../usage/cfg.md#augmentation-settings).
### Genetic Evolution and Mutation
@@ -67,7 +67,7 @@ The process is repeated until either the set number of iterations is reached or
## Usage Example
-Here's how to use the `model.tune()` method to utilize the `Tuner` class for hyperparameter tuning of YOLOv8n on COCO8 for 30 epochs with an AdamW optimizer and skipping plotting, checkpointing and validation other than on final epoch for faster Tuning.
+Here's how to use the `model.tune()` method to utilize the `Tuner` class for hyperparameter tuning of YOLO11n on COCO8 for 30 epochs with an AdamW optimizer and skipping plotting, checkpointing and validation other than on final epoch for faster Tuning.
!!! example
@@ -77,7 +77,7 @@ Here's how to use the `model.tune()` method to utilize the `Tuner` class for hyp
from ultralytics import YOLO
# Initialize the YOLO model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)
@@ -202,7 +202,7 @@ The hyperparameter tuning process in Ultralytics YOLO is simplified yet powerful
1. [Hyperparameter Optimization in Wikipedia](https://en.wikipedia.org/wiki/Hyperparameter_optimization)
2. [YOLOv5 Hyperparameter Evolution Guide](../yolov5/tutorials/hyperparameter_evolution.md)
-3. [Efficient Hyperparameter Tuning with Ray Tune and YOLOv8](../integrations/ray-tune.md)
+3. [Efficient Hyperparameter Tuning with Ray Tune and YOLO11](../integrations/ray-tune.md)
For deeper insights, you can explore the `Tuner` class source code and accompanying documentation. Should you have any questions, feature requests, or need further assistance, feel free to reach out to us on [GitHub](https://github.com/ultralytics/ultralytics/issues/new/choose) or [Discord](https://discord.com/invite/ultralytics).
@@ -220,7 +220,7 @@ To optimize the learning rate for Ultralytics YOLO, start by setting an initial
from ultralytics import YOLO
# Initialize the YOLO model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Tune hyperparameters on COCO8 for 30 epochs
model.tune(data="coco8.yaml", epochs=30, iterations=300, optimizer="AdamW", plots=False, save=False, val=False)
@@ -228,9 +228,9 @@ To optimize the learning rate for Ultralytics YOLO, start by setting an initial
For more details, check the [Ultralytics YOLO configuration page](../usage/cfg.md#augmentation-settings).
-### What are the benefits of using genetic algorithms for hyperparameter tuning in YOLOv8?
+### What are the benefits of using genetic algorithms for hyperparameter tuning in YOLO11?
-Genetic algorithms in Ultralytics YOLOv8 provide a robust method for exploring the hyperparameter space, leading to highly optimized model performance. Key benefits include:
+Genetic algorithms in Ultralytics YOLO11 provide a robust method for exploring the hyperparameter space, leading to highly optimized model performance. Key benefits include:
- **Efficient Search**: Genetic algorithms like mutation can quickly explore a large set of hyperparameters.
- **Avoiding Local Minima**: By introducing randomness, they help in avoiding local minima, ensuring better global optimization.
@@ -240,7 +240,7 @@ To see how genetic algorithms can optimize hyperparameters, check out the [hyper
### How long does the hyperparameter tuning process take for Ultralytics YOLO?
-The time required for hyperparameter tuning with Ultralytics YOLO largely depends on several factors such as the size of the dataset, the complexity of the model architecture, the number of iterations, and the computational resources available. For instance, tuning YOLOv8n on a dataset like COCO8 for 30 epochs might take several hours to days, depending on the hardware.
+The time required for hyperparameter tuning with Ultralytics YOLO largely depends on several factors such as the size of the dataset, the complexity of the model architecture, the number of iterations, and the computational resources available. For instance, tuning YOLO11n on a dataset like COCO8 for 30 epochs might take several hours to days, depending on the hardware.
To effectively manage tuning time, define a clear tuning budget beforehand ([internal section link](#preparing-for-hyperparameter-tuning)). This helps in balancing resource allocation and optimization goals.
diff --git a/docs/en/guides/index.md b/docs/en/guides/index.md
index 1ad70434ab..4255d346b3 100644
--- a/docs/en/guides/index.md
+++ b/docs/en/guides/index.md
@@ -18,7 +18,7 @@ Whether you're a beginner or an expert in [deep learning](https://www.ultralytic
allowfullscreen>
-## Evaluating YOLOv8 Model Performance
+## Evaluating YOLO11 Model Performance
-With respect to YOLOv8, you can use the [validation mode](../modes/val.md) to evaluate the model. Also, be sure to take a look at our guide that goes in-depth into [YOLOv8 performance metrics](./yolo-performance-metrics.md) and how they can be interpreted.
+With respect to YOLO11, you can use the [validation mode](../modes/val.md) to evaluate the model. Also, be sure to take a look at our guide that goes in-depth into [YOLO11 performance metrics](./yolo-performance-metrics.md) and how they can be interpreted.
### Common Community Questions
-When evaluating your YOLOv8 model, you might run into a few hiccups. Based on common community questions, here are some tips to help you get the most out of your YOLOv8 model:
+When evaluating your YOLO11 model, you might run into a few hiccups. Based on common community questions, here are some tips to help you get the most out of your YOLO11 model:
#### Handling Variable Image Sizes
-Evaluating your YOLOv8 model with images of different sizes can help you understand its performance on diverse datasets. Using the `rect=true` validation parameter, YOLOv8 adjusts the network's stride for each batch based on the image sizes, allowing the model to handle rectangular images without forcing them to a single size.
+Evaluating your YOLO11 model with images of different sizes can help you understand its performance on diverse datasets. Using the `rect=true` validation parameter, YOLO11 adjusts the network's stride for each batch based on the image sizes, allowing the model to handle rectangular images without forcing them to a single size.
The `imgsz` validation parameter sets the maximum dimension for image resizing, which is 640 by default. You can adjust this based on your dataset's maximum dimensions and the GPU memory available. Even with `imgsz` set, `rect=true` lets the model manage varying image sizes effectively by dynamically adjusting the stride.
-#### Accessing YOLOv8 Metrics
+#### Accessing YOLO11 Metrics
-If you want to get a deeper understanding of your YOLOv8 model's performance, you can easily access specific evaluation metrics with a few lines of Python code. The code snippet below will let you load your model, run an evaluation, and print out various metrics that show how well your model is doing.
+If you want to get a deeper understanding of your YOLO11 model's performance, you can easily access specific evaluation metrics with a few lines of Python code. The code snippet below will let you load your model, run an evaluation, and print out various metrics that show how well your model is doing.
!!! example "Usage"
@@ -71,7 +71,7 @@ If you want to get a deeper understanding of your YOLOv8 model's performance, yo
from ultralytics import YOLO
# Load the model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Run the evaluation
results = model.val(data="coco8.yaml")
@@ -101,7 +101,7 @@ If you want to get a deeper understanding of your YOLOv8 model's performance, yo
print("Recall curve:", results.box.r_curve)
```
-The results object also includes speed metrics like preprocess time, inference time, loss, and postprocess time. By analyzing these metrics, you can fine-tune and optimize your YOLOv8 model for better performance, making it more effective for your specific use case.
+The results object also includes speed metrics like preprocess time, inference time, loss, and postprocess time. By analyzing these metrics, you can fine-tune and optimize your YOLO11 model for better performance, making it more effective for your specific use case.
## How Does Fine-Tuning Work?
@@ -115,11 +115,11 @@ Fine-tuning a model means paying close attention to several vital parameters and
Usually, during the initial training [epochs](https://www.ultralytics.com/glossary/epoch), the learning rate starts low and gradually increases to stabilize the training process. However, since your model has already learned some features from the previous dataset, starting with a higher learning rate right away can be more beneficial.
-When evaluating your YOLOv8 model, you can set the `warmup_epochs` validation parameter to `warmup_epochs=0` to prevent the learning rate from starting too high. By following this process, the training will continue from the provided weights, adjusting to the nuances of your new data.
+When evaluating your YOLO11 model, you can set the `warmup_epochs` validation parameter to `warmup_epochs=0` to prevent the learning rate from starting too high. By following this process, the training will continue from the provided weights, adjusting to the nuances of your new data.
### Image Tiling for Small Objects
-Image tiling can improve detection accuracy for small objects. By dividing larger images into smaller segments, such as splitting 1280x1280 images into multiple 640x640 segments, you maintain the original resolution, and the model can learn from high-resolution fragments. When using YOLOv8, make sure to adjust your labels for these new segments correctly.
+Image tiling can improve detection accuracy for small objects. By dividing larger images into smaller segments, such as splitting 1280x1280 images into multiple 640x640 segments, you maintain the original resolution, and the model can learn from high-resolution fragments. When using YOLO11, make sure to adjust your labels for these new segments correctly.
## Engage with the Community
@@ -127,12 +127,12 @@ Sharing your ideas and questions with other [computer vision](https://www.ultral
### Finding Help and Support
-- **GitHub Issues:** Explore the YOLOv8 GitHub repository and use the [Issues tab](https://github.com/ultralytics/ultralytics/issues) to ask questions, report bugs, and suggest features. The community and maintainers are available to assist with any issues you encounter.
+- **GitHub Issues:** Explore the YOLO11 GitHub repository and use the [Issues tab](https://github.com/ultralytics/ultralytics/issues) to ask questions, report bugs, and suggest features. The community and maintainers are available to assist with any issues you encounter.
- **Ultralytics Discord Server:** Join the [Ultralytics Discord server](https://discord.com/invite/ultralytics) to connect with other users and developers, get support, share knowledge, and brainstorm ideas.
### Official Documentation
-- **Ultralytics YOLOv8 Documentation:** Check out the [official YOLOv8 documentation](./index.md) for comprehensive guides and valuable insights on various computer vision tasks and projects.
+- **Ultralytics YOLO11 Documentation:** Check out the [official YOLO11 documentation](./index.md) for comprehensive guides and valuable insights on various computer vision tasks and projects.
## Final Thoughts
@@ -140,30 +140,30 @@ Evaluating and fine-tuning your computer vision model are important steps for su
## FAQ
-### What are the key metrics for evaluating YOLOv8 model performance?
+### What are the key metrics for evaluating YOLO11 model performance?
-To evaluate YOLOv8 model performance, important metrics include Confidence Score, Intersection over Union (IoU), and Mean Average Precision (mAP). Confidence Score measures the model's certainty for each detected object class. IoU evaluates how well the predicted bounding box overlaps with the ground truth. Mean Average Precision (mAP) aggregates precision scores across classes, with mAP@.5 and mAP@.5:.95 being two common types for varying IoU thresholds. Learn more about these metrics in our [YOLOv8 performance metrics guide](./yolo-performance-metrics.md).
+To evaluate YOLO11 model performance, important metrics include Confidence Score, Intersection over Union (IoU), and Mean Average Precision (mAP). Confidence Score measures the model's certainty for each detected object class. IoU evaluates how well the predicted bounding box overlaps with the ground truth. Mean Average Precision (mAP) aggregates precision scores across classes, with mAP@.5 and mAP@.5:.95 being two common types for varying IoU thresholds. Learn more about these metrics in our [YOLO11 performance metrics guide](./yolo-performance-metrics.md).
-### How can I fine-tune a pre-trained YOLOv8 model for my specific dataset?
+### How can I fine-tune a pre-trained YOLO11 model for my specific dataset?
-Fine-tuning a pre-trained YOLOv8 model involves adjusting its parameters to improve performance on a specific task or dataset. Start by evaluating your model using metrics, then set a higher initial learning rate by adjusting the `warmup_epochs` parameter to 0 for immediate stability. Use parameters like `rect=true` for handling varied image sizes effectively. For more detailed guidance, refer to our section on [fine-tuning YOLOv8 models](#how-does-fine-tuning-work).
+Fine-tuning a pre-trained YOLO11 model involves adjusting its parameters to improve performance on a specific task or dataset. Start by evaluating your model using metrics, then set a higher initial learning rate by adjusting the `warmup_epochs` parameter to 0 for immediate stability. Use parameters like `rect=true` for handling varied image sizes effectively. For more detailed guidance, refer to our section on [fine-tuning YOLO11 models](#how-does-fine-tuning-work).
-### How can I handle variable image sizes when evaluating my YOLOv8 model?
+### How can I handle variable image sizes when evaluating my YOLO11 model?
-To handle variable image sizes during evaluation, use the `rect=true` parameter in YOLOv8, which adjusts the network's stride for each batch based on image sizes. The `imgsz` parameter sets the maximum dimension for image resizing, defaulting to 640. Adjust `imgsz` to suit your dataset and GPU memory. For more details, visit our [section on handling variable image sizes](#handling-variable-image-sizes).
+To handle variable image sizes during evaluation, use the `rect=true` parameter in YOLO11, which adjusts the network's stride for each batch based on image sizes. The `imgsz` parameter sets the maximum dimension for image resizing, defaulting to 640. Adjust `imgsz` to suit your dataset and GPU memory. For more details, visit our [section on handling variable image sizes](#handling-variable-image-sizes).
-### What practical steps can I take to improve mean average precision for my YOLOv8 model?
+### What practical steps can I take to improve mean average precision for my YOLO11 model?
-Improving mean average precision (mAP) for a YOLOv8 model involves several steps:
+Improving mean average precision (mAP) for a YOLO11 model involves several steps:
1. **Tuning Hyperparameters**: Experiment with different learning rates, [batch sizes](https://www.ultralytics.com/glossary/batch-size), and image augmentations.
2. **[Data Augmentation](https://www.ultralytics.com/glossary/data-augmentation)**: Use techniques like Mosaic and MixUp to create diverse training samples.
3. **Image Tiling**: Split larger images into smaller tiles to improve detection accuracy for small objects.
Refer to our detailed guide on [model fine-tuning](#tips-for-fine-tuning-your-model) for specific strategies.
-### How do I access YOLOv8 model evaluation metrics in Python?
+### How do I access YOLO11 model evaluation metrics in Python?
-You can access YOLOv8 model evaluation metrics using Python with the following steps:
+You can access YOLO11 model evaluation metrics using Python with the following steps:
!!! example "Usage"
@@ -173,7 +173,7 @@ You can access YOLOv8 model evaluation metrics using Python with the following s
from ultralytics import YOLO
# Load the model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Run the evaluation
results = model.val(data="coco8.yaml")
@@ -185,4 +185,4 @@ You can access YOLOv8 model evaluation metrics using Python with the following s
print("Mean recall:", results.box.mr)
```
-Analyzing these metrics helps fine-tune and optimize your YOLOv8 model. For a deeper dive, check out our guide on [YOLOv8 metrics](../modes/val.md).
+Analyzing these metrics helps fine-tune and optimize your YOLO11 model. For a deeper dive, check out our guide on [YOLO11 metrics](../modes/val.md).
diff --git a/docs/en/guides/model-monitoring-and-maintenance.md b/docs/en/guides/model-monitoring-and-maintenance.md
index 2aedc8e3a3..1f4f8ed855 100644
--- a/docs/en/guides/model-monitoring-and-maintenance.md
+++ b/docs/en/guides/model-monitoring-and-maintenance.md
@@ -123,12 +123,12 @@ Joining a community of computer vision enthusiasts can help you solve problems a
### Community Resources
-- **GitHub Issues:** Check out the [YOLOv8 GitHub repository](https://github.com/ultralytics/ultralytics/issues) and use the Issues tab to ask questions, report bugs, and suggest new features. The community and maintainers are highly active and supportive.
+- **GitHub Issues:** Check out the [YOLO11 GitHub repository](https://github.com/ultralytics/ultralytics/issues) and use the Issues tab to ask questions, report bugs, and suggest new features. The community and maintainers are highly active and supportive.
- **Ultralytics Discord Server:** Join the [Ultralytics Discord server](https://discord.com/invite/ultralytics) to chat with other users and developers, get support, and share your experiences.
### Official Documentation
-- **Ultralytics YOLOv8 Documentation:** Visit the [official YOLOv8 documentation](./index.md) for detailed guides and helpful tips on various computer vision projects.
+- **Ultralytics YOLO11 Documentation:** Visit the [official YOLO11 documentation](./index.md) for detailed guides and helpful tips on various computer vision projects.
Using these resources will help you solve challenges and stay up-to-date with the latest trends and practices in the computer vision community.
diff --git a/docs/en/guides/model-testing.md b/docs/en/guides/model-testing.md
index 8d32467955..b8bcb91353 100644
--- a/docs/en/guides/model-testing.md
+++ b/docs/en/guides/model-testing.md
@@ -44,22 +44,22 @@ Next, the testing results can be analyzed:
- **Error Analysis:** Perform a thorough error analysis to understand the types of errors (e.g., false positives vs. false negatives) and their potential causes.
- **Bias and Fairness:** Check for any biases in the model's predictions. Ensure that the model performs equally well across different subsets of the data, especially if it includes sensitive attributes like race, gender, or age.
-## Testing Your YOLOv8 Model
+## Testing Your YOLO11 Model
-To test your YOLOv8 model, you can use the validation mode. It's a straightforward way to understand the model's strengths and areas that need improvement. Also, you'll need to format your test dataset correctly for YOLOv8. For more details on how to use the validation mode, check out the [Model Validation](../modes/val.md) docs page.
+To test your YOLO11 model, you can use the validation mode. It's a straightforward way to understand the model's strengths and areas that need improvement. Also, you'll need to format your test dataset correctly for YOLO11. For more details on how to use the validation mode, check out the [Model Validation](../modes/val.md) docs page.
-## Using YOLOv8 to Predict on Multiple Test Images
+## Using YOLO11 to Predict on Multiple Test Images
-If you want to test your trained YOLOv8 model on multiple images stored in a folder, you can easily do so in one go. Instead of using the validation mode, which is typically used to evaluate model performance on a validation set and provide detailed metrics, you might just want to see predictions on all images in your test set. For this, you can use the [prediction mode](../modes/predict.md).
+If you want to test your trained YOLO11 model on multiple images stored in a folder, you can easily do so in one go. Instead of using the validation mode, which is typically used to evaluate model performance on a validation set and provide detailed metrics, you might just want to see predictions on all images in your test set. For this, you can use the [prediction mode](../modes/predict.md).
### Difference Between Validation and Prediction Modes
- **[Validation Mode](../modes/val.md):** Used to evaluate the model's performance by comparing predictions against known labels (ground truth). It provides detailed metrics such as accuracy, precision, recall, and F1 score.
- **[Prediction Mode](../modes/predict.md):** Used to run the model on new, unseen data to generate predictions. It does not provide detailed performance metrics but allows you to see how the model performs on real-world images.
-## Running YOLOv8 Predictions Without Custom Training
+## Running YOLO11 Predictions Without Custom Training
-If you are interested in testing the basic YOLOv8 model to understand whether it can be used for your application without custom training, you can use the prediction mode. While the model is pre-trained on datasets like COCO, running predictions on your own dataset can give you a quick sense of how well it might perform in your specific context.
+If you are interested in testing the basic YOLO11 model to understand whether it can be used for your application without custom training, you can use the prediction mode. While the model is pre-trained on datasets like COCO, running predictions on your own dataset can give you a quick sense of how well it might perform in your specific context.
## Overfitting and [Underfitting](https://www.ultralytics.com/glossary/underfitting) in [Machine Learning](https://www.ultralytics.com/glossary/machine-learning-ml)
@@ -128,12 +128,12 @@ Becoming part of a community of computer vision enthusiasts can aid in solving p
### Community Resources
-- **GitHub Issues:** Explore the [YOLOv8 GitHub repository](https://github.com/ultralytics/ultralytics/issues) and use the Issues tab to ask questions, report bugs, and suggest new features. The community and maintainers are very active and ready to help.
+- **GitHub Issues:** Explore the [YOLO11 GitHub repository](https://github.com/ultralytics/ultralytics/issues) and use the Issues tab to ask questions, report bugs, and suggest new features. The community and maintainers are very active and ready to help.
- **Ultralytics Discord Server:** Join the [Ultralytics Discord server](https://discord.com/invite/ultralytics) to chat with other users and developers, get support, and share your experiences.
### Official Documentation
-- **Ultralytics YOLOv8 Documentation:** Check out the [official YOLOv8 documentation](./index.md) for detailed guides and helpful tips on various computer vision projects.
+- **Ultralytics YOLO11 Documentation:** Check out the [official YOLO11 documentation](./index.md) for detailed guides and helpful tips on various computer vision projects.
These resources will help you navigate challenges and remain updated on the latest trends and practices within the computer vision community.
@@ -147,9 +147,9 @@ Building trustworthy computer vision models relies on rigorous model testing. By
Model evaluation and model testing are distinct steps in a computer vision project. Model evaluation involves using a labeled dataset to compute metrics such as [accuracy](https://www.ultralytics.com/glossary/accuracy), precision, recall, and [F1 score](https://www.ultralytics.com/glossary/f1-score), providing insights into the model's performance with a controlled dataset. Model testing, on the other hand, assesses the model's performance in real-world scenarios by applying it to new, unseen data, ensuring the model's learned behavior aligns with expectations outside the evaluation environment. For a detailed guide, refer to the [steps in a computer vision project](./steps-of-a-cv-project.md).
-### How can I test my Ultralytics YOLOv8 model on multiple images?
+### How can I test my Ultralytics YOLO11 model on multiple images?
-To test your Ultralytics YOLOv8 model on multiple images, you can use the [prediction mode](../modes/predict.md). This mode allows you to run the model on new, unseen data to generate predictions without providing detailed metrics. This is ideal for real-world performance testing on larger image sets stored in a folder. For evaluating performance metrics, use the [validation mode](../modes/val.md) instead.
+To test your Ultralytics YOLO11 model on multiple images, you can use the [prediction mode](../modes/predict.md). This mode allows you to run the model on new, unseen data to generate predictions without providing detailed metrics. This is ideal for real-world performance testing on larger image sets stored in a folder. For evaluating performance metrics, use the [validation mode](../modes/val.md) instead.
### What should I do if my computer vision model shows signs of overfitting or underfitting?
@@ -195,6 +195,6 @@ Post-testing, if the model performance meets the project goals, proceed with dep
Gain insights from the [Model Testing Vs. Model Evaluation](#model-testing-vs-model-evaluation) section to refine and enhance model effectiveness in real-world applications.
-### How do I run YOLOv8 predictions without custom training?
+### How do I run YOLO11 predictions without custom training?
-You can run predictions using the pre-trained YOLOv8 model on your dataset to see if it suits your application needs. Utilize the [prediction mode](../modes/predict.md) to get a quick sense of performance results without diving into custom training.
+You can run predictions using the pre-trained YOLO11 model on your dataset to see if it suits your application needs. Utilize the [prediction mode](../modes/predict.md) to get a quick sense of performance results without diving into custom training.
diff --git a/docs/en/guides/model-training-tips.md b/docs/en/guides/model-training-tips.md
index 725081a244..e7e3904811 100644
--- a/docs/en/guides/model-training-tips.md
+++ b/docs/en/guides/model-training-tips.md
@@ -46,25 +46,25 @@ There are a few different aspects to think about when you are planning on using
When training models on large datasets, efficiently utilizing your GPU is key. Batch size is an important factor. It is the number of data samples that a machine learning model processes in a single training iteration.
Using the maximum batch size supported by your GPU, you can fully take advantage of its capabilities and reduce the time model training takes. However, you want to avoid running out of GPU memory. If you encounter memory errors, reduce the batch size incrementally until the model trains smoothly.
-With respect to YOLOv8, you can set the `batch_size` parameter in the [training configuration](../modes/train.md) to match your GPU capacity. Also, setting `batch=-1` in your training script will automatically determine the [batch size](https://www.ultralytics.com/glossary/batch-size) that can be efficiently processed based on your device's capabilities. By fine-tuning the batch size, you can make the most of your GPU resources and improve the overall training process.
+With respect to YOLO11, you can set the `batch_size` parameter in the [training configuration](../modes/train.md) to match your GPU capacity. Also, setting `batch=-1` in your training script will automatically determine the [batch size](https://www.ultralytics.com/glossary/batch-size) that can be efficiently processed based on your device's capabilities. By fine-tuning the batch size, you can make the most of your GPU resources and improve the overall training process.
### Subset Training
Subset training is a smart strategy that involves training your model on a smaller set of data that represents the larger dataset. It can save time and resources, especially during initial model development and testing. If you are running short on time or experimenting with different model configurations, subset training is a good option.
-When it comes to YOLOv8, you can easily implement subset training by using the `fraction` parameter. This parameter lets you specify what fraction of your dataset to use for training. For example, setting `fraction=0.1` will train your model on 10% of the data. You can use this technique for quick iterations and tuning your model before committing to training a model using a full dataset. Subset training helps you make rapid progress and identify potential issues early on.
+When it comes to YOLO11, you can easily implement subset training by using the `fraction` parameter. This parameter lets you specify what fraction of your dataset to use for training. For example, setting `fraction=0.1` will train your model on 10% of the data. You can use this technique for quick iterations and tuning your model before committing to training a model using a full dataset. Subset training helps you make rapid progress and identify potential issues early on.
### Multi-scale Training
Multiscale training is a technique that improves your model's ability to generalize by training it on images of varying sizes. Your model can learn to detect objects at different scales and distances and become more robust.
-For example, when you train YOLOv8, you can enable multiscale training by setting the `scale` parameter. This parameter adjusts the size of training images by a specified factor, simulating objects at different distances. For example, setting `scale=0.5` will reduce the image size by half, while `scale=2.0` will double it. Configuring this parameter allows your model to experience a variety of image scales and improve its detection capabilities across different object sizes and scenarios.
+For example, when you train YOLO11, you can enable multiscale training by setting the `scale` parameter. This parameter adjusts the size of training images by a specified factor, simulating objects at different distances. For example, setting `scale=0.5` will reduce the image size by half, while `scale=2.0` will double it. Configuring this parameter allows your model to experience a variety of image scales and improve its detection capabilities across different object sizes and scenarios.
### Caching
Caching is an important technique to improve the efficiency of training machine learning models. By storing preprocessed images in memory, caching reduces the time the GPU spends waiting for data to be loaded from the disk. The model can continuously receive data without delays caused by disk I/O operations.
-Caching can be controlled when training YOLOv8 using the `cache` parameter:
+Caching can be controlled when training YOLO11 using the `cache` parameter:
- _`cache=True`_: Stores dataset images in RAM, providing the fastest access speed but at the cost of increased memory usage.
- _`cache='disk'`_: Stores the images on disk, slower than RAM but faster than loading fresh data each time.
@@ -80,19 +80,19 @@ Mixed precision training uses both 16-bit (FP16) and 32-bit (FP32) floating-poin
To implement mixed precision training, you'll need to modify your training scripts and ensure your hardware (like GPUs) supports it. Many modern [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) frameworks, such as [Tensorflow](https://www.ultralytics.com/glossary/tensorflow), offer built-in support for mixed precision.
-Mixed precision training is straightforward when working with YOLOv8. You can use the `amp` flag in your training configuration. Setting `amp=True` enables Automatic Mixed Precision (AMP) training. Mixed precision training is a simple yet effective way to optimize your model training process.
+Mixed precision training is straightforward when working with YOLO11. You can use the `amp` flag in your training configuration. Setting `amp=True` enables Automatic Mixed Precision (AMP) training. Mixed precision training is a simple yet effective way to optimize your model training process.
### Pre-trained Weights
Using pretrained weights is a smart way to speed up your model's training process. Pretrained weights come from models already trained on large datasets, giving your model a head start. [Transfer learning](https://www.ultralytics.com/glossary/transfer-learning) adapts pretrained models to new, related tasks. Fine-tuning a pre-trained model involves starting with these weights and then continuing training on your specific dataset. This method of training results in faster training times and often better performance because the model starts with a solid understanding of basic features.
-The `pretrained` parameter makes transfer learning easy with YOLOv8. Setting `pretrained=True` will use default pre-trained weights, or you can specify a path to a custom pre-trained model. Using pre-trained weights and transfer learning effectively boosts your model's capabilities and reduces training costs.
+The `pretrained` parameter makes transfer learning easy with YOLO11. Setting `pretrained=True` will use default pre-trained weights, or you can specify a path to a custom pre-trained model. Using pre-trained weights and transfer learning effectively boosts your model's capabilities and reduces training costs.
### Other Techniques to Consider When Handling a Large Dataset
There are a couple of other techniques to consider when handling a large dataset:
-- **[Learning Rate](https://www.ultralytics.com/glossary/learning-rate) Schedulers**: Implementing learning rate schedulers dynamically adjusts the learning rate during training. A well-tuned learning rate can prevent the model from overshooting minima and improve stability. When training YOLOv8, the `lrf` parameter helps manage learning rate scheduling by setting the final learning rate as a fraction of the initial rate.
+- **[Learning Rate](https://www.ultralytics.com/glossary/learning-rate) Schedulers**: Implementing learning rate schedulers dynamically adjusts the learning rate during training. A well-tuned learning rate can prevent the model from overshooting minima and improve stability. When training YOLO11, the `lrf` parameter helps manage learning rate scheduling by setting the final learning rate as a fraction of the initial rate.
- **Distributed Training**: For handling large datasets, distributed training can be a game-changer. You can reduce the training time by spreading the training workload across multiple GPUs or machines.
## The Number of Epochs To Train For
@@ -101,7 +101,7 @@ When training a model, an epoch refers to one complete pass through the entire t
A common question that comes up is how to determine the number of epochs to train the model for. A good starting point is 300 epochs. If the model overfits early, you can reduce the number of epochs. If [overfitting](https://www.ultralytics.com/glossary/overfitting) does not occur after 300 epochs, you can extend the training to 600, 1200, or more epochs.
-However, the ideal number of epochs can vary based on your dataset's size and project goals. Larger datasets might require more epochs for the model to learn effectively, while smaller datasets might need fewer epochs to avoid overfitting. With respect to YOLOv8, you can set the `epochs` parameter in your training script.
+However, the ideal number of epochs can vary based on your dataset's size and project goals. Larger datasets might require more epochs for the model to learn effectively, while smaller datasets might need fewer epochs to avoid overfitting. With respect to YOLO11, you can set the `epochs` parameter in your training script.
## Early Stopping
@@ -113,7 +113,7 @@ The process involves setting a patience parameter that determines how many [epoc
-For YOLOv8, you can enable early stopping by setting the patience parameter in your training configuration. For example, `patience=5` means training will stop if there's no improvement in validation metrics for 5 consecutive epochs. Using this method ensures the training process remains efficient and achieves optimal performance without excessive computation.
+For YOLO11, you can enable early stopping by setting the patience parameter in your training configuration. For example, `patience=5` means training will stop if there's no improvement in validation metrics for 5 consecutive epochs. Using this method ensures the training process remains efficient and achieves optimal performance without excessive computation.
## Choosing Between Cloud and Local Training
@@ -143,13 +143,13 @@ Different optimizers have various strengths and weaknesses. Let's take a glimpse
- Combines the benefits of both SGD with momentum and RMSProp.
- Adjusts the learning rate for each parameter based on estimates of the first and second moments of the gradients.
- Well-suited for noisy data and sparse gradients.
- - Efficient and generally requires less tuning, making it a recommended optimizer for YOLOv8.
+ - Efficient and generally requires less tuning, making it a recommended optimizer for YOLO11.
- **RMSProp (Root Mean Square Propagation)**:
- Adjusts the learning rate for each parameter by dividing the gradient by a running average of the magnitudes of recent gradients.
- Helps in handling the vanishing gradient problem and is effective for [recurrent neural networks](https://www.ultralytics.com/glossary/recurrent-neural-network-rnn).
-For YOLOv8, the `optimizer` parameter lets you choose from various optimizers, including SGD, Adam, AdamW, NAdam, RAdam, and RMSProp, or you can set it to `auto` for automatic selection based on model configuration.
+For YOLO11, the `optimizer` parameter lets you choose from various optimizers, including SGD, Adam, AdamW, NAdam, RAdam, and RMSProp, or you can set it to `auto` for automatic selection based on model configuration.
## Connecting with the Community
@@ -157,12 +157,12 @@ Being part of a community of computer vision enthusiasts can help you solve prob
### Community Resources
-- **GitHub Issues:** Visit the [YOLOv8 GitHub repository](https://github.com/ultralytics/ultralytics/issues) and use the Issues tab to ask questions, report bugs, and suggest new features. The community and maintainers are very active and ready to help.
+- **GitHub Issues:** Visit the [YOLO11 GitHub repository](https://github.com/ultralytics/ultralytics/issues) and use the Issues tab to ask questions, report bugs, and suggest new features. The community and maintainers are very active and ready to help.
- **Ultralytics Discord Server:** Join the [Ultralytics Discord server](https://discord.com/invite/ultralytics) to chat with other users and developers, get support, and share your experiences.
### Official Documentation
-- **Ultralytics YOLOv8 Documentation:** Check out the [official YOLOv8 documentation](./index.md) for detailed guides and helpful tips on various computer vision projects.
+- **Ultralytics YOLO11 Documentation:** Check out the [official YOLO11 documentation](./index.md) for detailed guides and helpful tips on various computer vision projects.
Using these resources will help you solve challenges and stay up-to-date with the latest trends and practices in the computer vision community.
@@ -174,20 +174,20 @@ Training computer vision models involves following good practices, optimizing yo
### How can I improve GPU utilization when training a large dataset with Ultralytics YOLO?
-To improve GPU utilization, set the `batch_size` parameter in your training configuration to the maximum size supported by your GPU. This ensures that you make full use of the GPU's capabilities, reducing training time. If you encounter memory errors, incrementally reduce the batch size until training runs smoothly. For YOLOv8, setting `batch=-1` in your training script will automatically determine the optimal batch size for efficient processing. For further information, refer to the [training configuration](../modes/train.md).
+To improve GPU utilization, set the `batch_size` parameter in your training configuration to the maximum size supported by your GPU. This ensures that you make full use of the GPU's capabilities, reducing training time. If you encounter memory errors, incrementally reduce the batch size until training runs smoothly. For YOLO11, setting `batch=-1` in your training script will automatically determine the optimal batch size for efficient processing. For further information, refer to the [training configuration](../modes/train.md).
-### What is mixed precision training, and how do I enable it in YOLOv8?
+### What is mixed precision training, and how do I enable it in YOLO11?
-Mixed precision training utilizes both 16-bit (FP16) and 32-bit (FP32) floating-point types to balance computational speed and precision. This approach speeds up training and reduces memory usage without sacrificing model [accuracy](https://www.ultralytics.com/glossary/accuracy). To enable mixed precision training in YOLOv8, set the `amp` parameter to `True` in your training configuration. This activates Automatic Mixed Precision (AMP) training. For more details on this optimization technique, see the [training configuration](../modes/train.md).
+Mixed precision training utilizes both 16-bit (FP16) and 32-bit (FP32) floating-point types to balance computational speed and precision. This approach speeds up training and reduces memory usage without sacrificing model [accuracy](https://www.ultralytics.com/glossary/accuracy). To enable mixed precision training in YOLO11, set the `amp` parameter to `True` in your training configuration. This activates Automatic Mixed Precision (AMP) training. For more details on this optimization technique, see the [training configuration](../modes/train.md).
-### How does multiscale training enhance YOLOv8 model performance?
+### How does multiscale training enhance YOLO11 model performance?
-Multiscale training enhances model performance by training on images of varying sizes, allowing the model to better generalize across different scales and distances. In YOLOv8, you can enable multiscale training by setting the `scale` parameter in the training configuration. For example, `scale=0.5` reduces the image size by half, while `scale=2.0` doubles it. This technique simulates objects at different distances, making the model more robust across various scenarios. For settings and more details, check out the [training configuration](../modes/train.md).
+Multiscale training enhances model performance by training on images of varying sizes, allowing the model to better generalize across different scales and distances. In YOLO11, you can enable multiscale training by setting the `scale` parameter in the training configuration. For example, `scale=0.5` reduces the image size by half, while `scale=2.0` doubles it. This technique simulates objects at different distances, making the model more robust across various scenarios. For settings and more details, check out the [training configuration](../modes/train.md).
-### How can I use pre-trained weights to speed up training in YOLOv8?
+### How can I use pre-trained weights to speed up training in YOLO11?
-Using pre-trained weights can significantly reduce training times and improve model performance by starting from a model that already understands basic features. In YOLOv8, you can set the `pretrained` parameter to `True` or specify a path to custom pre-trained weights in your training configuration. This approach, known as transfer learning, leverages knowledge from large datasets to adapt to your specific task. Learn more about pre-trained weights and their advantages [here](../modes/train.md).
+Using pre-trained weights can significantly reduce training times and improve model performance by starting from a model that already understands basic features. In YOLO11, you can set the `pretrained` parameter to `True` or specify a path to custom pre-trained weights in your training configuration. This approach, known as transfer learning, leverages knowledge from large datasets to adapt to your specific task. Learn more about pre-trained weights and their advantages [here](../modes/train.md).
-### What is the recommended number of epochs for training a model, and how do I set this in YOLOv8?
+### What is the recommended number of epochs for training a model, and how do I set this in YOLO11?
-The number of epochs refers to the complete passes through the training dataset during model training. A typical starting point is 300 epochs. If your model overfits early, you can reduce the number. Alternatively, if overfitting isn't observed, you might extend training to 600, 1200, or more epochs. To set this in YOLOv8, use the `epochs` parameter in your training script. For additional advice on determining the ideal number of epochs, refer to this section on [number of epochs](#the-number-of-epochs-to-train-for).
+The number of epochs refers to the complete passes through the training dataset during model training. A typical starting point is 300 epochs. If your model overfits early, you can reduce the number. Alternatively, if overfitting isn't observed, you might extend training to 600, 1200, or more epochs. To set this in YOLO11, use the `epochs` parameter in your training script. For additional advice on determining the ideal number of epochs, refer to this section on [number of epochs](#the-number-of-epochs-to-train-for).
diff --git a/docs/en/guides/object-blurring.md b/docs/en/guides/object-blurring.md
index 315bcd76ea..2c6a3bdfc9 100644
--- a/docs/en/guides/object-blurring.md
+++ b/docs/en/guides/object-blurring.md
@@ -1,14 +1,14 @@
---
comments: true
-description: Learn how to use Ultralytics YOLOv8 for real-time object blurring to enhance privacy and focus in your images and videos.
-keywords: YOLOv8, object blurring, real-time processing, privacy protection, image manipulation, video editing, Ultralytics
+description: Learn how to use Ultralytics YOLO11 for real-time object blurring to enhance privacy and focus in your images and videos.
+keywords: YOLO11, object blurring, real-time processing, privacy protection, image manipulation, video editing, Ultralytics
---
-# Object Blurring using Ultralytics YOLOv8 🚀
+# Object Blurring using Ultralytics YOLO11 🚀
## What is Object Blurring?
-Object blurring with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves applying a blurring effect to specific detected objects in an image or video. This can be achieved using the YOLOv8 model capabilities to identify and manipulate objects within a given scene.
+Object blurring with [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics/) involves applying a blurring effect to specific detected objects in an image or video. This can be achieved using the YOLO11 model capabilities to identify and manipulate objects within a given scene.
@@ -18,16 +18,16 @@ Object blurring with [Ultralytics YOLOv8](https://github.com/ultralytics/ultraly
allowfullscreen>
- Watch: Object Blurring using Ultralytics YOLOv8
+ Watch: Object Blurring using Ultralytics YOLO11
|
- Watch: Class-wise Object Counting using Ultralytics YOLOv8 + Watch: Class-wise Object Counting using Ultralytics YOLO11 |
@@ -18,23 +18,23 @@ Object cropping with [Ultralytics YOLOv8](https://github.com/ultralytics/ultraly
allowfullscreen>
- Watch: Object Cropping using Ultralytics YOLOv8
+ Watch: Object Cropping using Ultralytics YOLO
@@ -18,21 +18,21 @@ Parking management with [Ultralytics YOLOv8](https://github.com/ultralytics/ultr
allowfullscreen>
- Watch: How to Implement Parking Management Using Ultralytics YOLOv8 🚀
+ Watch: How to Implement Parking Management Using Ultralytics YOLO 🚀
-With respect to YOLOv8, you can [augment your custom dataset](../modes/train.md) by modifying the dataset configuration file, a .yaml file. In this file, you can add an augmentation section with parameters that specify how you want to augment your data.
+With respect to YOLO11, you can [augment your custom dataset](../modes/train.md) by modifying the dataset configuration file, a .yaml file. In this file, you can add an augmentation section with parameters that specify how you want to augment your data.
-The [Ultralytics YOLOv8 repository](https://github.com/ultralytics/ultralytics/tree/main) supports a wide range of data augmentations. You can apply various transformations such as:
+The [Ultralytics YOLO11 repository](https://github.com/ultralytics/ultralytics/tree/main) supports a wide range of data augmentations. You can apply various transformations such as:
- Random Crops
- Flipping: Images can be flipped horizontally or vertically.
@@ -89,12 +89,12 @@ Also, you can adjust the intensity of these augmentation techniques through spec
## A Case Study of Preprocessing
-Consider a project aimed at developing a model to detect and classify different types of vehicles in traffic images using YOLOv8. We've collected traffic images and annotated them with bounding boxes and labels.
+Consider a project aimed at developing a model to detect and classify different types of vehicles in traffic images using YOLO11. We've collected traffic images and annotated them with bounding boxes and labels.
Here's what each step of preprocessing would look like for this project:
-- Resizing Images: Since YOLOv8 handles flexible input sizes and performs resizing automatically, manual resizing is not required. The model will adjust the image size according to the specified 'imgsz' parameter during training.
-- Normalizing Pixel Values: YOLOv8 automatically normalizes pixel values to a range of 0 to 1 during preprocessing, so it's not required.
+- Resizing Images: Since YOLO11 handles flexible input sizes and performs resizing automatically, manual resizing is not required. The model will adjust the image size according to the specified 'imgsz' parameter during training.
+- Normalizing Pixel Values: YOLO11 automatically normalizes pixel values to a range of 0 to 1 during preprocessing, so it's not required.
- Splitting the Dataset: Divide the dataset into training (70%), validation (20%), and test (10%) sets using tools like scikit-learn.
- [Data Augmentation](https://www.ultralytics.com/glossary/data-augmentation): Modify the dataset configuration file (.yaml) to include data augmentation techniques such as random crops, horizontal flips, and brightness adjustments.
@@ -132,12 +132,12 @@ Having discussions about your project with other computer vision enthusiasts can
### Channels to Connect with the Community
-- **GitHub Issues:** Visit the YOLOv8 GitHub repository and use the [Issues tab](https://github.com/ultralytics/ultralytics/issues) to raise questions, report bugs, and suggest features. The community and maintainers are there to help with any issues you face.
+- **GitHub Issues:** Visit the YOLO11 GitHub repository and use the [Issues tab](https://github.com/ultralytics/ultralytics/issues) to raise questions, report bugs, and suggest features. The community and maintainers are there to help with any issues you face.
- **Ultralytics Discord Server:** Join the [Ultralytics Discord server](https://discord.com/invite/ultralytics) to connect with other users and developers, get support, share knowledge, and brainstorm ideas.
### Official Documentation
-- **Ultralytics YOLOv8 Documentation:** Refer to the [official YOLOv8 documentation](./index.md) for thorough guides and valuable insights on numerous computer vision tasks and projects.
+- **Ultralytics YOLO11 Documentation:** Refer to the [official YOLO11 documentation](./index.md) for thorough guides and valuable insights on numerous computer vision tasks and projects.
## Your Dataset Is Ready!
@@ -151,7 +151,7 @@ Data preprocessing is essential in computer vision projects because it ensures t
### How can I use Ultralytics YOLO for data augmentation?
-For data augmentation with Ultralytics YOLOv8, you need to modify the dataset configuration file (.yaml). In this file, you can specify various augmentation techniques such as random crops, horizontal flips, and brightness adjustments. This can be effectively done using the training configurations [explained here](../modes/train.md). Data augmentation helps create a more robust dataset, reduce [overfitting](https://www.ultralytics.com/glossary/overfitting), and improve model generalization.
+For data augmentation with Ultralytics YOLO11, you need to modify the dataset configuration file (.yaml). In this file, you can specify various augmentation techniques such as random crops, horizontal flips, and brightness adjustments. This can be effectively done using the training configurations [explained here](../modes/train.md). Data augmentation helps create a more robust dataset, reduce [overfitting](https://www.ultralytics.com/glossary/overfitting), and improve model generalization.
### What are the best data normalization techniques for computer vision data?
@@ -160,12 +160,12 @@ Normalization scales pixel values to a standard range for faster convergence and
- **Min-Max Scaling**: Scales pixel values to a range of 0 to 1.
- **Z-Score Normalization**: Scales pixel values based on their mean and standard deviation.
-For YOLOv8, normalization is handled automatically, including conversion to RGB and pixel value scaling. Learn more about it in the [model training section](../modes/train.md).
+For YOLO11, normalization is handled automatically, including conversion to RGB and pixel value scaling. Learn more about it in the [model training section](../modes/train.md).
### How should I split my annotated dataset for training?
To split your dataset, a common practice is to divide it into 70% for training, 20% for validation, and 10% for testing. It is important to maintain the data distribution of classes across these splits and avoid data leakage by performing augmentation only on the training set. Use tools like scikit-learn or [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) for efficient dataset splitting. See the detailed guide on [dataset preparation](../guides/data-collection-and-annotation.md).
-### Can I handle varying image sizes in YOLOv8 without manual resizing?
+### Can I handle varying image sizes in YOLO11 without manual resizing?
-Yes, Ultralytics YOLOv8 can handle varying image sizes through the 'imgsz' parameter during model training. This parameter ensures that images are resized so their largest dimension matches the specified size (e.g., 640 pixels), while maintaining the aspect ratio. For more flexible input handling and automatic adjustments, check the [model training section](../modes/train.md).
+Yes, Ultralytics YOLO11 can handle varying image sizes through the 'imgsz' parameter during model training. This parameter ensures that images are resized so their largest dimension matches the specified size (e.g., 640 pixels), while maintaining the aspect ratio. For more flexible input handling and automatic adjustments, check the [model training section](../modes/train.md).
diff --git a/docs/en/guides/queue-management.md b/docs/en/guides/queue-management.md
index 9fb4897edf..8f6610bc9e 100644
--- a/docs/en/guides/queue-management.md
+++ b/docs/en/guides/queue-management.md
@@ -1,14 +1,14 @@
---
comments: true
-description: Learn how to manage and optimize queues using Ultralytics YOLOv8 to reduce wait times and increase efficiency in various real-world applications.
-keywords: queue management, YOLOv8, Ultralytics, reduce wait times, efficiency, customer satisfaction, retail, airports, healthcare, banks
+description: Learn how to manage and optimize queues using Ultralytics YOLO11 to reduce wait times and increase efficiency in various real-world applications.
+keywords: queue management, YOLO11, Ultralytics, reduce wait times, efficiency, customer satisfaction, retail, airports, healthcare, banks
---
-# Queue Management using Ultralytics YOLOv8 🚀
+# Queue Management using Ultralytics YOLO11 🚀
## What is Queue Management?
-Queue management using [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves organizing and controlling lines of people or vehicles to reduce wait times and enhance efficiency. It's about optimizing queues to improve customer satisfaction and system performance in various settings like retail, banks, airports, and healthcare facilities.
+Queue management using [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics/) involves organizing and controlling lines of people or vehicles to reduce wait times and enhance efficiency. It's about optimizing queues to improve customer satisfaction and system performance in various settings like retail, banks, airports, and healthcare facilities.
@@ -18,7 +18,7 @@ Queue management using [Ultralytics YOLOv8](https://github.com/ultralytics/ultra
allowfullscreen>
- Watch: How to Implement Queue Management with Ultralytics YOLOv8 | Airport and Metro Station
+ Watch: How to Implement Queue Management with Ultralytics YOLO11 | Airport and Metro Station
@@ -24,7 +24,7 @@ SAHI (Slicing Aided Hyper Inference) is an innovative library designed to optimi
allowfullscreen>
- Watch: Inference with SAHI (Slicing Aided Hyper Inference) using Ultralytics YOLOv8
+ Watch: Inference with SAHI (Slicing Aided Hyper Inference) using Ultralytics YOLO11
| YOLOv8 without SAHI | -YOLOv8 with SAHI | +YOLO11 without SAHI | +YOLO11 with SAHI |
|---|---|---|---|
 |
-  |
+ |
+ |
-The Security Alarm System Project utilizing Ultralytics YOLOv8 integrates advanced [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) capabilities to enhance security measures. YOLOv8, developed by Ultralytics, provides real-time object detection, allowing the system to identify and respond to potential security threats promptly. This project offers several advantages:
+The Security Alarm System Project utilizing Ultralytics YOLO11 integrates advanced [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) capabilities to enhance security measures. YOLO11, developed by Ultralytics, provides real-time object detection, allowing the system to identify and respond to potential security threats promptly. This project offers several advantages:
-- **Real-time Detection:** YOLOv8's efficiency enables the Security Alarm System to detect and respond to security incidents in real-time, minimizing response time.
-- **[Accuracy](https://www.ultralytics.com/glossary/accuracy):** YOLOv8 is known for its accuracy in object detection, reducing false positives and enhancing the reliability of the security alarm system.
+- **Real-time Detection:** YOLO11's efficiency enables the Security Alarm System to detect and respond to security incidents in real-time, minimizing response time.
+- **[Accuracy](https://www.ultralytics.com/glossary/accuracy):** YOLO11 is known for its accuracy in object detection, reducing false positives and enhancing the reliability of the security alarm system.
- **Integration Capabilities:** The project can be seamlessly integrated with existing security infrastructure, providing an upgraded layer of intelligent surveillance.
@@ -22,7 +22,7 @@ The Security Alarm System Project utilizing Ultralytics YOLOv8 integrates advanc
allowfullscreen>
- Watch: Security Alarm System Project with Ultralytics YOLOv8 [Object Detection](https://www.ultralytics.com/glossary/object-detection)
+ Watch: Security Alarm System Project with Ultralytics YOLO11 Object Detection
@@ -18,12 +18,12 @@ keywords: Ultralytics YOLOv8, speed estimation, object tracking, computer vision
allowfullscreen>
- Watch: Speed Estimation using Ultralytics YOLOv8
+ Watch: Speed Estimation using Ultralytics YOLO11
-[Data collection and annotation](./data-collection-and-annotation.md) can be a time-consuming manual effort. Annotation tools can help make this process easier. Here are some useful open annotation tools: [LabeI Studio](https://github.com/HumanSignal/label-studio), [CVAT](https://github.com/cvat-ai/cvat), and [Labelme](https://github.com/labelmeai/labelme).
+[Data collection and annotation](./data-collection-and-annotation.md) can be a time-consuming manual effort. Annotation tools can help make this process easier. Here are some useful open annotation tools: [LabeI Studio](https://github.com/HumanSignal/label-studio), [CVAT](https://github.com/cvat-ai/cvat), and [Labelme](https://github.com/wkentaro/labelme).
## Step 3: [Data Augmentation](https://www.ultralytics.com/glossary/data-augmentation) and Splitting Your Dataset
@@ -166,7 +166,7 @@ Once your model has been thoroughly tested, it's time to deploy it. Deployment i
- Setting Up the Environment: Configure the necessary infrastructure for your chosen deployment option, whether it's cloud-based (AWS, Google Cloud, Azure) or edge-based (local devices, IoT).
-- **[Exporting the Model](../modes/export.md):** Export your model to the appropriate format (e.g., ONNX, TensorRT, CoreML for YOLOv8) to ensure compatibility with your deployment platform.
+- **[Exporting the Model](../modes/export.md):** Export your model to the appropriate format (e.g., ONNX, TensorRT, CoreML for YOLO11) to ensure compatibility with your deployment platform.
- **Deploying the Model:** Deploy the model by setting up APIs or endpoints and integrating it with your application.
- **Ensuring Scalability**: Implement load balancers, auto-scaling groups, and monitoring tools to manage resources and handle increasing data and user requests.
@@ -188,12 +188,12 @@ Connecting with a community of computer vision enthusiasts can help you tackle a
### Community Resources
-- **GitHub Issues:** Check out the [YOLOv8 GitHub repository](https://github.com/ultralytics/ultralytics/issues) and use the Issues tab to ask questions, report bugs, and suggest new features. The active community and maintainers are there to help with specific issues.
+- **GitHub Issues:** Check out the [YOLO11 GitHub repository](https://github.com/ultralytics/ultralytics/issues) and use the Issues tab to ask questions, report bugs, and suggest new features. The active community and maintainers are there to help with specific issues.
- **Ultralytics Discord Server:** Join the [Ultralytics Discord server](https://discord.com/invite/ultralytics) to interact with other users and developers, get support, and share insights.
### Official Documentation
-- **Ultralytics YOLOv8 Documentation:** Explore the [official YOLOv8 documentation](./index.md) for detailed guides with helpful tips on different computer vision tasks and projects.
+- **Ultralytics YOLO11 Documentation:** Explore the [official YOLO11 documentation](./index.md) for detailed guides with helpful tips on different computer vision tasks and projects.
Using these resources will help you overcome challenges and stay updated with the latest trends and best practices in the computer vision community.
@@ -215,7 +215,7 @@ Data annotation is vital for teaching your model to recognize patterns. The type
- **Object Detection**: Bounding boxes drawn around objects.
- **Image Segmentation**: Each pixel labeled according to the object it belongs to.
-Tools like [Label Studio](https://github.com/HumanSignal/label-studio), [CVAT](https://github.com/cvat-ai/cvat), and [Labelme](https://github.com/labelmeai/labelme) can assist in this process. For more details, refer to our [data collection and annotation guide](./data-collection-and-annotation.md).
+Tools like [Label Studio](https://github.com/HumanSignal/label-studio), [CVAT](https://github.com/cvat-ai/cvat), and [Labelme](https://github.com/wkentaro/labelme) can assist in this process. For more details, refer to our [data collection and annotation guide](./data-collection-and-annotation.md).
### What steps should I follow to augment and split my dataset effectively?
@@ -229,7 +229,7 @@ After splitting, apply data augmentation techniques like rotation, scaling, and
### How can I export my trained computer vision model for deployment?
-Exporting your model ensures compatibility with different deployment platforms. Ultralytics provides multiple formats, including ONNX, TensorRT, and CoreML. To export your YOLOv8 model, follow this guide:
+Exporting your model ensures compatibility with different deployment platforms. Ultralytics provides multiple formats, including ONNX, TensorRT, and CoreML. To export your YOLO11 model, follow this guide:
- Use the `export` function with the desired format parameter.
- Ensure the exported model fits the specifications of your deployment environment (e.g., edge devices, cloud).
diff --git a/docs/en/guides/streamlit-live-inference.md b/docs/en/guides/streamlit-live-inference.md
index e8fb5c9165..b5831fd4f5 100644
--- a/docs/en/guides/streamlit-live-inference.md
+++ b/docs/en/guides/streamlit-live-inference.md
@@ -1,14 +1,14 @@
---
comments: true
-description: Learn how to set up a real-time object detection application using Streamlit and Ultralytics YOLOv8. Follow this step-by-step guide to implement webcam-based object detection.
-keywords: Streamlit, YOLOv8, Real-time Object Detection, Streamlit Application, YOLOv8 Streamlit Tutorial, Webcam Object Detection
+description: Learn how to set up a real-time object detection application using Streamlit and Ultralytics YOLO11. Follow this step-by-step guide to implement webcam-based object detection.
+keywords: Streamlit, YOLO11, Real-time Object Detection, Streamlit Application, YOLO11 Streamlit Tutorial, Webcam Object Detection
---
-# Live Inference with Streamlit Application using Ultralytics YOLOv8
+# Live Inference with Streamlit Application using Ultralytics YOLO11
## Introduction
-Streamlit makes it simple to build and deploy interactive web applications. Combining this with Ultralytics YOLOv8 allows for real-time [object detection](https://www.ultralytics.com/glossary/object-detection) and analysis directly in your browser. YOLOv8 high accuracy and speed ensure seamless performance for live video streams, making it ideal for applications in security, retail, and beyond.
+Streamlit makes it simple to build and deploy interactive web applications. Combining this with Ultralytics YOLO11 allows for real-time [object detection](https://www.ultralytics.com/glossary/object-detection) and analysis directly in your browser. YOLO11 high accuracy and speed ensure seamless performance for live video streams, making it ideal for applications in security, retail, and beyond.
@@ -18,19 +18,19 @@ Streamlit makes it simple to build and deploy interactive web applications. Comb
allowfullscreen>
- Watch: How to Use Streamlit with Ultralytics for Real-Time [Computer Vision](https://www.ultralytics.com/glossary/computer-vision-cv) in Your Browser
+ Watch: How to Use Streamlit with Ultralytics for Real-Time Computer Vision in Your Browser
@@ -38,7 +38,7 @@ Ensure you have the following prerequisites before proceeding:
pip install tritonclient[all]
```
-## Exporting YOLOv8 to ONNX Format
+## Exporting YOLO11 to ONNX Format
Before deploying the model on Triton, it must be exported to the ONNX format. ONNX (Open Neural Network Exchange) is a format that allows models to be transferred between different deep learning frameworks. Use the `export` function from the `YOLO` class:
@@ -46,7 +46,7 @@ Before deploying the model on Triton, it must be exported to the ONNX format. ON
from ultralytics import YOLO
# Load a model
-model = YOLO("yolov8n.pt") # load an official model
+model = YOLO("yolo11n.pt") # load an official model
# Export the model
onnx_file = model.export(format="onnx", dynamic=True)
@@ -141,21 +141,21 @@ subprocess.call(f"docker kill {container_id}", shell=True)
---
-By following the above steps, you can deploy and run Ultralytics YOLOv8 models efficiently on Triton Inference Server, providing a scalable and high-performance solution for deep learning inference tasks. If you face any issues or have further queries, refer to the [official Triton documentation](https://docs.nvidia.com/deeplearning/triton-inference-server/user-guide/docs/index.html) or reach out to the Ultralytics community for support.
+By following the above steps, you can deploy and run Ultralytics YOLO11 models efficiently on Triton Inference Server, providing a scalable and high-performance solution for deep learning inference tasks. If you face any issues or have further queries, refer to the [official Triton documentation](https://docs.nvidia.com/deeplearning/triton-inference-server/user-guide/docs/index.html) or reach out to the Ultralytics community for support.
## FAQ
-### How do I set up Ultralytics YOLOv8 with NVIDIA Triton Inference Server?
+### How do I set up Ultralytics YOLO11 with NVIDIA Triton Inference Server?
-Setting up [Ultralytics YOLOv8](https://docs.ultralytics.com/models/yolov8/) with [NVIDIA Triton Inference Server](https://developer.nvidia.com/triton-inference-server) involves a few key steps:
+Setting up [Ultralytics YOLO11](https://docs.ultralytics.com/models/yolov8/) with [NVIDIA Triton Inference Server](https://developer.nvidia.com/triton-inference-server) involves a few key steps:
-1. **Export YOLOv8 to ONNX format**:
+1. **Export YOLO11 to ONNX format**:
```python
from ultralytics import YOLO
# Load a model
- model = YOLO("yolov8n.pt") # load an official model
+ model = YOLO("yolo11n.pt") # load an official model
# Export the model to ONNX format
onnx_file = model.export(format="onnx", dynamic=True)
@@ -209,21 +209,21 @@ Setting up [Ultralytics YOLOv8](https://docs.ultralytics.com/models/yolov8/) wit
time.sleep(1)
```
-This setup can help you efficiently deploy YOLOv8 models at scale on Triton Inference Server for high-performance AI model inference.
+This setup can help you efficiently deploy YOLO11 models at scale on Triton Inference Server for high-performance AI model inference.
-### What benefits does using Ultralytics YOLOv8 with NVIDIA Triton Inference Server offer?
+### What benefits does using Ultralytics YOLO11 with NVIDIA Triton Inference Server offer?
-Integrating [Ultralytics YOLOv8](../models/yolov8.md) with [NVIDIA Triton Inference Server](https://developer.nvidia.com/triton-inference-server) provides several advantages:
+Integrating [Ultralytics YOLO11](../models/yolov8.md) with [NVIDIA Triton Inference Server](https://developer.nvidia.com/triton-inference-server) provides several advantages:
- **Scalable AI Inference**: Triton allows serving multiple models from a single server instance, supporting dynamic model loading and unloading, making it highly scalable for diverse AI workloads.
- **High Performance**: Optimized for NVIDIA GPUs, Triton Inference Server ensures high-speed inference operations, perfect for real-time applications such as [object detection](https://www.ultralytics.com/glossary/object-detection).
- **Ensemble and Model Versioning**: Triton's ensemble mode enables combining multiple models to improve results, and its model versioning supports A/B testing and rolling updates.
-For detailed instructions on setting up and running YOLOv8 with Triton, you can refer to the [setup guide](#setting-up-triton-model-repository).
+For detailed instructions on setting up and running YOLO11 with Triton, you can refer to the [setup guide](#setting-up-triton-model-repository).
-### Why should I export my YOLOv8 model to ONNX format before using Triton Inference Server?
+### Why should I export my YOLO11 model to ONNX format before using Triton Inference Server?
-Using ONNX (Open Neural Network Exchange) format for your [Ultralytics YOLOv8](../models/yolov8.md) model before deploying it on [NVIDIA Triton Inference Server](https://developer.nvidia.com/triton-inference-server) offers several key benefits:
+Using ONNX (Open Neural Network Exchange) format for your [Ultralytics YOLO11](../models/yolov8.md) model before deploying it on [NVIDIA Triton Inference Server](https://developer.nvidia.com/triton-inference-server) offers several key benefits:
- **Interoperability**: ONNX format supports transfer between different deep learning frameworks (such as PyTorch, TensorFlow), ensuring broader compatibility.
- **Optimization**: Many deployment environments, including Triton, optimize for ONNX, enabling faster inference and better performance.
@@ -234,15 +234,15 @@ To export your model, use:
```python
from ultralytics import YOLO
-model = YOLO("yolov8n.pt")
+model = YOLO("yolo11n.pt")
onnx_file = model.export(format="onnx", dynamic=True)
```
You can follow the steps in the [exporting guide](../modes/export.md) to complete the process.
-### Can I run inference using the Ultralytics YOLOv8 model on Triton Inference Server?
+### Can I run inference using the Ultralytics YOLO11 model on Triton Inference Server?
-Yes, you can run inference using the [Ultralytics YOLOv8](../models/yolov8.md) model on [NVIDIA Triton Inference Server](https://developer.nvidia.com/triton-inference-server). Once your model is set up in the Triton Model Repository and the server is running, you can load and run inference on your model as follows:
+Yes, you can run inference using the [Ultralytics YOLO11](../models/yolov8.md) model on [NVIDIA Triton Inference Server](https://developer.nvidia.com/triton-inference-server). Once your model is set up in the Triton Model Repository and the server is running, you can load and run inference on your model as follows:
```python
from ultralytics import YOLO
@@ -254,14 +254,14 @@ model = YOLO("http://localhost:8000/yolo", task="detect")
results = model("path/to/image.jpg")
```
-For an in-depth guide on setting up and running Triton Server with YOLOv8, refer to the [running triton inference server](#running-triton-inference-server) section.
+For an in-depth guide on setting up and running Triton Server with YOLO11, refer to the [running triton inference server](#running-triton-inference-server) section.
-### How does Ultralytics YOLOv8 compare to [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) and PyTorch models for deployment?
+### How does Ultralytics YOLO11 compare to [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) and PyTorch models for deployment?
-[Ultralytics YOLOv8](https://docs.ultralytics.com/models/yolov8/) offers several unique advantages compared to TensorFlow and PyTorch models for deployment:
+[Ultralytics YOLO11](https://docs.ultralytics.com/models/yolov8/) offers several unique advantages compared to TensorFlow and PyTorch models for deployment:
-- **Real-time Performance**: Optimized for real-time object detection tasks, YOLOv8 provides state-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed, making it ideal for applications requiring live video analytics.
-- **Ease of Use**: YOLOv8 integrates seamlessly with Triton Inference Server and supports diverse export formats (ONNX, TensorRT, CoreML), making it flexible for various deployment scenarios.
-- **Advanced Features**: YOLOv8 includes features like dynamic model loading, model versioning, and ensemble inference, which are crucial for scalable and reliable AI deployments.
+- **Real-time Performance**: Optimized for real-time object detection tasks, YOLO11 provides state-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed, making it ideal for applications requiring live video analytics.
+- **Ease of Use**: YOLO11 integrates seamlessly with Triton Inference Server and supports diverse export formats (ONNX, TensorRT, CoreML), making it flexible for various deployment scenarios.
+- **Advanced Features**: YOLO11 includes features like dynamic model loading, model versioning, and ensemble inference, which are crucial for scalable and reliable AI deployments.
For more details, compare the deployment options in the [model deployment guide](../modes/export.md).
diff --git a/docs/en/guides/view-results-in-terminal.md b/docs/en/guides/view-results-in-terminal.md
index cb6ce1c087..2d8ff4b647 100644
--- a/docs/en/guides/view-results-in-terminal.md
+++ b/docs/en/guides/view-results-in-terminal.md
@@ -47,7 +47,7 @@ The VSCode compatible protocols for viewing images using the integrated terminal
from ultralytics import YOLO
# Load a model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Run inference on an image
results = model.predict(source="ultralytics/assets/bus.jpg")
@@ -111,7 +111,7 @@ from sixel import SixelWriter
from ultralytics import YOLO
# Load a model
-model = YOLO("yolov8n.pt")
+model = YOLO("yolo11n.pt")
# Run inference on an image
results = model.predict(source="ultralytics/assets/bus.jpg")
@@ -164,7 +164,7 @@ To view YOLO inference results in a VSCode terminal on macOS or Linux, follow th
```python
from ultralytics import YOLO
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
results = model.predict(source="path_to_image")
plot = results[0].plot()
```
diff --git a/docs/en/guides/vision-eye.md b/docs/en/guides/vision-eye.md
index 48cff2746d..f374388c9c 100644
--- a/docs/en/guides/vision-eye.md
+++ b/docs/en/guides/vision-eye.md
@@ -1,23 +1,23 @@
---
comments: true
-description: Discover VisionEye's object mapping and tracking powered by Ultralytics YOLOv8. Simulate human eye precision, track objects, and calculate distances effortlessly.
-keywords: VisionEye, YOLOv8, Ultralytics, object mapping, object tracking, distance calculation, computer vision, AI, machine learning, Python, tutorial
+description: Discover VisionEye's object mapping and tracking powered by Ultralytics YOLO11. Simulate human eye precision, track objects, and calculate distances effortlessly.
+keywords: VisionEye, YOLO11, Ultralytics, object mapping, object tracking, distance calculation, computer vision, AI, machine learning, Python, tutorial
---
-# VisionEye View Object Mapping using Ultralytics YOLOv8 🚀
+# VisionEye View Object Mapping using Ultralytics YOLO11 🚀
## What is VisionEye Object Mapping?
-[Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) VisionEye offers the capability for computers to identify and pinpoint objects, simulating the observational [precision](https://www.ultralytics.com/glossary/precision) of the human eye. This functionality enables computers to discern and focus on specific objects, much like the way the human eye observes details from a particular viewpoint.
+[Ultralytics YOLO11](https://github.com/ultralytics/ultralytics/) VisionEye offers the capability for computers to identify and pinpoint objects, simulating the observational [precision](https://www.ultralytics.com/glossary/precision) of the human eye. This functionality enables computers to discern and focus on specific objects, much like the way the human eye observes details from a particular viewpoint.
## Samples
| VisionEye View | VisionEye View With Object Tracking | VisionEye View With Distance Calculation |
| :----------------------------------------------------------------------------------------------------------------------------------------------------------: | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-|  |  |  |
-| VisionEye View Object Mapping using Ultralytics YOLOv8 | VisionEye View Object Mapping with Object Tracking using Ultralytics YOLOv8 | VisionEye View with Distance Calculation using Ultralytics YOLOv8 |
+|  |  |  |
+| VisionEye View Object Mapping using Ultralytics YOLO11 | VisionEye View Object Mapping with Object Tracking using Ultralytics YOLO11 | VisionEye View with Distance Calculation using Ultralytics YOLO11 |
-!!! example "VisionEye Object Mapping using YOLOv8"
+!!! example "VisionEye Object Mapping using YOLO11"
=== "VisionEye Object Mapping"
@@ -27,7 +27,7 @@ keywords: VisionEye, YOLOv8, Ultralytics, object mapping, object tracking, dista
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
names = model.model.names
cap = cv2.VideoCapture("path/to/video/file.mp4")
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
@@ -71,7 +71,7 @@ keywords: VisionEye, YOLOv8, Ultralytics, object mapping, object tracking, dista
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
@@ -118,7 +118,7 @@ keywords: VisionEye, YOLOv8, Ultralytics, object mapping, object tracking, dista
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator
- model = YOLO("yolov8s.pt")
+ model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
@@ -180,16 +180,16 @@ For any inquiries, feel free to post your questions in the [Ultralytics Issue Se
## FAQ
-### How do I start using VisionEye Object Mapping with Ultralytics YOLOv8?
+### How do I start using VisionEye Object Mapping with Ultralytics YOLO11?
-To start using VisionEye Object Mapping with Ultralytics YOLOv8, first, you'll need to install the Ultralytics YOLO package via pip. Then, you can use the sample code provided in the documentation to set up [object detection](https://www.ultralytics.com/glossary/object-detection) with VisionEye. Here's a simple example to get you started:
+To start using VisionEye Object Mapping with Ultralytics YOLO11, first, you'll need to install the Ultralytics YOLO package via pip. Then, you can use the sample code provided in the documentation to set up [object detection](https://www.ultralytics.com/glossary/object-detection) with VisionEye. Here's a simple example to get you started:
```python
import cv2
from ultralytics import YOLO
-model = YOLO("yolov8n.pt")
+model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
while True:
@@ -210,12 +210,12 @@ cap.release()
cv2.destroyAllWindows()
```
-### What are the key features of VisionEye's object tracking capability using Ultralytics YOLOv8?
+### What are the key features of VisionEye's object tracking capability using Ultralytics YOLO11?
-VisionEye's object tracking with Ultralytics YOLOv8 allows users to follow the movement of objects within a video frame. Key features include:
+VisionEye's object tracking with Ultralytics YOLO11 allows users to follow the movement of objects within a video frame. Key features include:
1. **Real-Time Object Tracking**: Keeps up with objects as they move.
-2. **Object Identification**: Utilizes YOLOv8's powerful detection algorithms.
+2. **Object Identification**: Utilizes YOLO11's powerful detection algorithms.
3. **Distance Calculation**: Calculates distances between objects and specified points.
4. **Annotation and Visualization**: Provides visual markers for tracked objects.
@@ -226,7 +226,7 @@ import cv2
from ultralytics import YOLO
-model = YOLO("yolov8n.pt")
+model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
while True:
@@ -249,9 +249,9 @@ cv2.destroyAllWindows()
For a comprehensive guide, visit the [VisionEye Object Mapping with Object Tracking](#samples).
-### How can I calculate distances with VisionEye's YOLOv8 model?
+### How can I calculate distances with VisionEye's YOLO11 model?
-Distance calculation with VisionEye and Ultralytics YOLOv8 involves determining the distance of detected objects from a specified point in the frame. It enhances spatial analysis capabilities, useful in applications such as autonomous driving and surveillance.
+Distance calculation with VisionEye and Ultralytics YOLO11 involves determining the distance of detected objects from a specified point in the frame. It enhances spatial analysis capabilities, useful in applications such as autonomous driving and surveillance.
Here's a simplified example:
@@ -262,7 +262,7 @@ import cv2
from ultralytics import YOLO
-model = YOLO("yolov8s.pt")
+model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
center_point = (0, 480) # Example center point
pixel_per_meter = 10
@@ -290,19 +290,19 @@ cv2.destroyAllWindows()
For detailed instructions, refer to the [VisionEye with Distance Calculation](#samples).
-### Why should I use Ultralytics YOLOv8 for object mapping and tracking?
+### Why should I use Ultralytics YOLO11 for object mapping and tracking?
-Ultralytics YOLOv8 is renowned for its speed, [accuracy](https://www.ultralytics.com/glossary/accuracy), and ease of integration, making it a top choice for object mapping and tracking. Key advantages include:
+Ultralytics YOLO11 is renowned for its speed, [accuracy](https://www.ultralytics.com/glossary/accuracy), and ease of integration, making it a top choice for object mapping and tracking. Key advantages include:
1. **State-of-the-art Performance**: Delivers high accuracy in real-time object detection.
2. **Flexibility**: Supports various tasks such as detection, tracking, and distance calculation.
3. **Community and Support**: Extensive documentation and active GitHub community for troubleshooting and enhancements.
4. **Ease of Use**: Intuitive API simplifies complex tasks, allowing for rapid deployment and iteration.
-For more information on applications and benefits, check out the [Ultralytics YOLOv8 documentation](https://docs.ultralytics.com/models/yolov8/).
+For more information on applications and benefits, check out the [Ultralytics YOLO11 documentation](https://docs.ultralytics.com/models/yolov8/).
### How can I integrate VisionEye with other [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) tools like Comet or ClearML?
-Ultralytics YOLOv8 can integrate seamlessly with various machine learning tools like Comet and ClearML, enhancing experiment tracking, collaboration, and reproducibility. Follow the detailed guides on [how to use YOLOv5 with Comet](https://www.ultralytics.com/blog/how-to-use-yolov5-with-comet) and [integrate YOLOv8 with ClearML](https://docs.ultralytics.com/integrations/clearml/) to get started.
+Ultralytics YOLO11 can integrate seamlessly with various machine learning tools like Comet and ClearML, enhancing experiment tracking, collaboration, and reproducibility. Follow the detailed guides on [how to use YOLOv5 with Comet](https://www.ultralytics.com/blog/how-to-use-yolov5-with-comet) and [integrate YOLO11 with ClearML](https://docs.ultralytics.com/integrations/clearml/) to get started.
For further exploration and integration examples, check our [Ultralytics Integrations Guide](https://docs.ultralytics.com/integrations/).
diff --git a/docs/en/guides/workouts-monitoring.md b/docs/en/guides/workouts-monitoring.md
index 4585631683..af996894b3 100644
--- a/docs/en/guides/workouts-monitoring.md
+++ b/docs/en/guides/workouts-monitoring.md
@@ -1,12 +1,12 @@
---
comments: true
-description: Optimize your fitness routine with real-time workouts monitoring using Ultralytics YOLOv8. Track and improve your exercise form and performance.
-keywords: workouts monitoring, Ultralytics YOLOv8, pose estimation, fitness tracking, exercise assessment, real-time feedback, exercise form, performance metrics
+description: Optimize your fitness routine with real-time workouts monitoring using Ultralytics YOLO11. Track and improve your exercise form and performance.
+keywords: workouts monitoring, Ultralytics YOLO11, pose estimation, fitness tracking, exercise assessment, real-time feedback, exercise form, performance metrics
---
-# Workouts Monitoring using Ultralytics YOLOv8
+# Workouts Monitoring using Ultralytics YOLO11
-Monitoring workouts through pose estimation with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) enhances exercise assessment by accurately tracking key body landmarks and joints in real-time. This technology provides instant feedback on exercise form, tracks workout routines, and measures performance metrics, optimizing training sessions for users and trainers alike.
+Monitoring workouts through pose estimation with [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics/) enhances exercise assessment by accurately tracking key body landmarks and joints in real-time. This technology provides instant feedback on exercise form, tracks workout routines, and measures performance metrics, optimizing training sessions for users and trainers alike.
@@ -16,7 +16,7 @@ Monitoring workouts through pose estimation with [Ultralytics YOLOv8](https://gi
allowfullscreen>
- Watch: Workouts Monitoring using Ultralytics YOLOv8 | Pushups, Pullups, Ab Workouts
+ Watch: Workouts Monitoring using Ultralytics YOLO11 | Pushups, Pullups, Ab Workouts
@@ -22,7 +22,7 @@ This guide serves as a comprehensive aid for troubleshooting common issues encou
allowfullscreen>
- Watch: Ultralytics YOLOv8 Common Issues | Installation Errors, Model Training Issues
+ Watch: Ultralytics YOLO11 Common Issues | Installation Errors, Model Training Issues
@@ -18,12 +18,12 @@ Performance metrics are key tools to evaluate the [accuracy](https://www.ultraly
allowfullscreen>
- Watch: Ultralytics YOLOv8 Performance Metrics | MAP, F1 Score, [Precision](https://www.ultralytics.com/glossary/precision), IoU & Accuracy
+ Watch: Ultralytics YOLO11 Performance Metrics | MAP, F1 Score, Precision, IoU & Accuracy
-
+
@@ -31,9 +31,9 @@ keywords: Ultralytics, YOLOv8, object detection, image segmentation, deep learni
@@ -68,7 +68,7 @@ Explore the YOLOv8 Docs, a comprehensive resource designed to help you understan
allowfullscreen>
- Watch: How to Train a YOLOv8 model on Your Custom Dataset in Google Colab.
+ Watch: How to Train a YOLO model on Your Custom Dataset in Google Colab.
@@ -40,9 +40,9 @@ First, ensure you have the following prerequisites in place:
- Adequate Service Quota: Confirm that you have sufficient quotas for two separate resources in Amazon SageMaker: one for `ml.m5.4xlarge` for endpoint usage and another for `ml.m5.4xlarge` for notebook instance usage. Each of these requires a minimum of one quota value. If your current quotas are below this requirement, it's important to request an increase for each. You can request a quota increase by following the detailed instructions in the [AWS Service Quotas documentation](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html#quota-console-increase).
-### Step 2: Clone the YOLOv8 SageMaker Repository
+### Step 2: Clone the YOLO11 SageMaker Repository
-The next step is to clone the specific AWS repository that contains the resources for deploying YOLOv8 on SageMaker. This repository, hosted on GitHub, includes the necessary CDK scripts and configuration files.
+The next step is to clone the specific AWS repository that contains the resources for deploying YOLO11 on SageMaker. This repository, hosted on GitHub, includes the necessary CDK scripts and configuration files.
- Clone the GitHub Repository: Execute the following command in your terminal to clone the host-yolov8-on-sagemaker-endpoint repository:
@@ -104,11 +104,11 @@ cdk bootstrap
cdk deploy
```
-### Step 5: Deploy the YOLOv8 Model
+### Step 5: Deploy the YOLO Model
-Before diving into the deployment instructions, be sure to check out the range of [YOLOv8 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements.
+Before diving into the deployment instructions, be sure to check out the range of [YOLO11 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements.
-After creating the AWS CloudFormation Stack, the next step is to deploy YOLOv8.
+After creating the AWS CloudFormation Stack, the next step is to deploy YOLO11.
- Open the Notebook Instance: Go to the AWS Console and navigate to the Amazon SageMaker service. Select "Notebook Instances" from the dashboard, then locate the notebook instance that was created by your CDK deployment script. Open the notebook instance to access the Jupyter environment.
@@ -136,18 +136,18 @@ def output_fn(prediction_output):
return json.dumps(infer)
```
-- Deploy the Endpoint Using 1_DeployEndpoint.ipynb: In the Jupyter environment, open the 1_DeployEndpoint.ipynb notebook located in the sm-notebook directory. Follow the instructions in the notebook and run the cells to download the YOLOv8 model, package it with the updated inference code, and upload it to an Amazon S3 bucket. The notebook will guide you through creating and deploying a SageMaker endpoint for the YOLOv8 model.
+- Deploy the Endpoint Using 1_DeployEndpoint.ipynb: In the Jupyter environment, open the 1_DeployEndpoint.ipynb notebook located in the sm-notebook directory. Follow the instructions in the notebook and run the cells to download the YOLO11 model, package it with the updated inference code, and upload it to an Amazon S3 bucket. The notebook will guide you through creating and deploying a SageMaker endpoint for the YOLO11 model.
### Step 6: Testing Your Deployment
-Now that your YOLOv8 model is deployed, it's important to test its performance and functionality.
+Now that your YOLO11 model is deployed, it's important to test its performance and functionality.
- Open the Test Notebook: In the same Jupyter environment, locate and open the 2_TestEndpoint.ipynb notebook, also in the sm-notebook directory.
- Run the Test Notebook: Follow the instructions within the notebook to test the deployed SageMaker endpoint. This includes sending an image to the endpoint and running inferences. Then, you'll plot the output to visualize the model's performance and [accuracy](https://www.ultralytics.com/glossary/accuracy), as shown below.
- 
+
@@ -34,7 +34,7 @@ Learn how to train a YOLOv8 model with custom data on YouTube with Nicolai. Chec
allowfullscreen>
- Watch: How to Train Ultralytics YOLOv8 models on Your Custom Dataset in Google Colab | Episode 3
+ Watch: How to Train Ultralytics YOLO11 models on Your Custom Dataset in Google Colab | Episode 3
@@ -18,7 +18,7 @@ This Gradio interface provides an easy and interactive way to perform object det
allowfullscreen>
- Watch: Gradio Integration with Ultralytics YOLOv8
+ Watch: Gradio Integration with Ultralytics YOLO11
@@ -36,9 +36,9 @@ Before diving into how to deploy YOLOV8 using DeepSparse, let's understand the b
- **High Performance on Standard CPUs**: Delivers GPU-like performance on CPUs, providing a more accessible and cost-effective option for various applications.
-- **Streamlined Integration and Deployment**: Offers user-friendly tools for easy integration of YOLOv8 into applications, including image and video annotation features.
+- **Streamlined Integration and Deployment**: Offers user-friendly tools for easy integration of YOLO11 into applications, including image and video annotation features.
-- **Support for Various Model Types**: Compatible with both standard and sparsity-optimized YOLOv8 models, adding deployment flexibility.
+- **Support for Various Model Types**: Compatible with both standard and sparsity-optimized YOLO11 models, adding deployment flexibility.
- **Cost-Effective and Scalable Solution**: Reduces operational expenses and offers scalable deployment of advanced object detection models.
@@ -56,15 +56,15 @@ Neural Magic's Deep Sparse technology is inspired by the human brain's efficienc
For more details on how Neural Magic's DeepSparse technology work, check out [their blog post](https://neuralmagic.com/blog/how-neural-magics-deep-sparse-technology-works/).
-## Creating A Sparse Version of YOLOv8 Trained on a Custom Dataset
+## Creating A Sparse Version of YOLO11 Trained on a Custom Dataset
-SparseZoo, an open-source model repository by Neural Magic, offers [a collection of pre-sparsified YOLOv8 model checkpoints](https://sparsezoo.neuralmagic.com/?modelSet=computer_vision&searchModels=yolo). With SparseML, seamlessly integrated with Ultralytics, users can effortlessly fine-tune these sparse checkpoints on their specific datasets using a straightforward command-line interface.
+SparseZoo, an open-source model repository by Neural Magic, offers [a collection of pre-sparsified YOLO11 model checkpoints](https://sparsezoo.neuralmagic.com/?modelSet=computer_vision&searchModels=yolo). With SparseML, seamlessly integrated with Ultralytics, users can effortlessly fine-tune these sparse checkpoints on their specific datasets using a straightforward command-line interface.
-Checkout [Neural Magic's SparseML YOLOv8 documentation](https://github.com/neuralmagic/sparseml/tree/main/integrations/ultralytics-yolov8) for more details.
+Checkout [Neural Magic's SparseML YOLO11 documentation](https://github.com/neuralmagic/sparseml/tree/main/integrations/ultralytics-yolov8) for more details.
## Usage: Deploying YOLOV8 using DeepSparse
-Deploying YOLOv8 with Neural Magic's DeepSparse involves a few straightforward steps. Before diving into the usage instructions, be sure to check out the range of [YOLOv8 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements. Here's how you can get started.
+Deploying YOLO11 with Neural Magic's DeepSparse involves a few straightforward steps. Before diving into the usage instructions, be sure to check out the range of [YOLO11 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements. Here's how you can get started.
### Step 1: Installation
@@ -79,24 +79,24 @@ To install the required packages, run:
pip install deepsparse[yolov8]
```
-### Step 2: Exporting YOLOv8 to ONNX Format
+### Step 2: Exporting YOLO11 to ONNX Format
-DeepSparse Engine requires YOLOv8 models in ONNX format. Exporting your model to this format is essential for compatibility with DeepSparse. Use the following command to export YOLOv8 models:
+DeepSparse Engine requires YOLO11 models in ONNX format. Exporting your model to this format is essential for compatibility with DeepSparse. Use the following command to export YOLO11 models:
!!! tip "Model Export"
=== "CLI"
```bash
- # Export YOLOv8 model to ONNX format
- yolo task=detect mode=export model=yolov8n.pt format=onnx opset=13
+ # Export YOLO11 model to ONNX format
+ yolo task=detect mode=export model=yolo11n.pt format=onnx opset=13
```
-This command will save the `yolov8n.onnx` model to your disk.
+This command will save the `yolo11n.onnx` model to your disk.
### Step 3: Deploying and Running Inferences
-With your YOLOv8 model in ONNX format, you can deploy and run inferences using DeepSparse. This can be done easily with their intuitive Python API:
+With your YOLO11 model in ONNX format, you can deploy and run inferences using DeepSparse. This can be done easily with their intuitive Python API:
!!! tip "Deploying and Running Inferences"
@@ -105,8 +105,8 @@ With your YOLOv8 model in ONNX format, you can deploy and run inferences using D
```python
from deepsparse import Pipeline
- # Specify the path to your YOLOv8 ONNX model
- model_path = "path/to/yolov8n.onnx"
+ # Specify the path to your YOLO11 ONNX model
+ model_path = "path/to/yolo11n.onnx"
# Set up the DeepSparse Pipeline
yolo_pipeline = Pipeline.create(task="yolov8", model_path=model_path)
@@ -118,7 +118,7 @@ With your YOLOv8 model in ONNX format, you can deploy and run inferences using D
### Step 4: Benchmarking Performance
-It's important to check that your YOLOv8 model is performing optimally on DeepSparse. You can benchmark your model's performance to analyze throughput and latency:
+It's important to check that your YOLO11 model is performing optimally on DeepSparse. You can benchmark your model's performance to analyze throughput and latency:
!!! tip "Benchmarking"
@@ -126,12 +126,12 @@ It's important to check that your YOLOv8 model is performing optimally on DeepSp
```bash
# Benchmark performance
- deepsparse.benchmark model_path="path/to/yolov8n.onnx" --scenario=sync --input_shapes="[1,3,640,640]"
+ deepsparse.benchmark model_path="path/to/yolo11n.onnx" --scenario=sync --input_shapes="[1,3,640,640]"
```
### Step 5: Additional Features
-DeepSparse provides additional features for practical integration of YOLOv8 in applications, such as image annotation and dataset evaluation.
+DeepSparse provides additional features for practical integration of YOLO11 in applications, such as image annotation and dataset evaluation.
!!! tip "Additional Features"
@@ -139,10 +139,10 @@ DeepSparse provides additional features for practical integration of YOLOv8 in a
```bash
# For image annotation
- deepsparse.yolov8.annotate --source "path/to/image.jpg" --model_filepath "path/to/yolov8n.onnx"
+ deepsparse.yolov8.annotate --source "path/to/image.jpg" --model_filepath "path/to/yolo11n.onnx"
# For evaluating model performance on a dataset
- deepsparse.yolov8.eval --model_path "path/to/yolov8n.onnx"
+ deepsparse.yolov8.eval --model_path "path/to/yolo11n.onnx"
```
Running the annotate command processes your specified image, detecting objects, and saving the annotated image with bounding boxes and classifications. The annotated image will be stored in an annotation-results folder. This helps provide a visual representation of the model's detection capabilities.
@@ -151,61 +151,61 @@ Running the annotate command processes your specified image, detecting objects,
@@ -16,10 +16,10 @@ Bridging the gap between developing and deploying [computer vision](https://www.
allowfullscreen>
- Watch: How to Export Ultralytics YOLOv8 Models to PaddlePaddle Format | Key Features of PaddlePaddle Format
+ Watch: How to Export Ultralytics YOLO11 Models to PaddlePaddle Format | Key Features of PaddlePaddle Format
@@ -46,14 +46,14 @@ Explore more capabilities of YOLOv8 and Paperspace Gradient in a discussion with
allowfullscreen>
- Watch: Ultralytics Live Session 7: It's All About the Environment: Optimizing YOLOv8 Training With Gradient
+ Watch: Ultralytics Live Session 7: It's All About the Environment: Optimizing YOLO11 Training With Gradient
-[Ray Tune](https://docs.ray.io/en/latest/tune/index.html) is a hyperparameter tuning library designed for efficiency and flexibility. It supports various search strategies, parallelism, and early stopping strategies, and seamlessly integrates with popular [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) frameworks, including Ultralytics YOLOv8.
+[Ray Tune](https://docs.ray.io/en/latest/tune/index.html) is a hyperparameter tuning library designed for efficiency and flexibility. It supports various search strategies, parallelism, and early stopping strategies, and seamlessly integrates with popular [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) frameworks, including Ultralytics YOLO11.
### Integration with Weights & Biases
-YOLOv8 also allows optional integration with [Weights & Biases](https://wandb.ai/site) for monitoring the tuning process.
+YOLO11 also allows optional integration with [Weights & Biases](https://wandb.ai/site) for monitoring the tuning process.
## Installation
@@ -49,21 +49,21 @@ To install the required packages, run:
```python
from ultralytics import YOLO
- # Load a YOLOv8n model
- model = YOLO("yolov8n.pt")
+ # Load a YOLO11n model
+ model = YOLO("yolo11n.pt")
- # Start tuning hyperparameters for YOLOv8n training on the COCO8 dataset
+ # Start tuning hyperparameters for YOLO11n training on the COCO8 dataset
result_grid = model.tune(data="coco8.yaml", use_ray=True)
```
## `tune()` Method Parameters
-The `tune()` method in YOLOv8 provides an easy-to-use interface for hyperparameter tuning with Ray Tune. It accepts several arguments that allow you to customize the tuning process. Below is a detailed explanation of each parameter:
+The `tune()` method in YOLO11 provides an easy-to-use interface for hyperparameter tuning with Ray Tune. It accepts several arguments that allow you to customize the tuning process. Below is a detailed explanation of each parameter:
| Parameter | Type | Description | Default Value |
| --------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- |
| `data` | `str` | The dataset configuration file (in YAML format) to run the tuner on. This file should specify the training and [validation data](https://www.ultralytics.com/glossary/validation-data) paths, as well as other dataset-specific settings. | |
-| `space` | `dict, optional` | A dictionary defining the hyperparameter search space for Ray Tune. Each key corresponds to a hyperparameter name, and the value specifies the range of values to explore during tuning. If not provided, YOLOv8 uses a default search space with various hyperparameters. | |
+| `space` | `dict, optional` | A dictionary defining the hyperparameter search space for Ray Tune. Each key corresponds to a hyperparameter name, and the value specifies the range of values to explore during tuning. If not provided, YOLO11 uses a default search space with various hyperparameters. | |
| `grace_period` | `int, optional` | The grace period in [epochs](https://www.ultralytics.com/glossary/epoch) for the [ASHA scheduler](https://docs.ray.io/en/latest/tune/api/schedulers.html) in Ray Tune. The scheduler will not terminate any trial before this number of epochs, allowing the model to have some minimum training before making a decision on early stopping. | 10 |
| `gpu_per_trial` | `int, optional` | The number of GPUs to allocate per trial during tuning. This helps manage GPU usage, particularly in multi-GPU environments. If not provided, the tuner will use all available GPUs. | None |
| `iterations` | `int, optional` | The maximum number of trials to run during tuning. This parameter helps control the total number of hyperparameter combinations tested, ensuring the tuning process does not run indefinitely. | 10 |
@@ -73,7 +73,7 @@ By customizing these parameters, you can fine-tune the hyperparameter optimizati
## Default Search Space Description
-The following table lists the default search space parameters for hyperparameter tuning in YOLOv8 with Ray Tune. Each parameter has a specific value range defined by `tune.uniform()`.
+The following table lists the default search space parameters for hyperparameter tuning in YOLO11 with Ray Tune. Each parameter has a specific value range defined by `tune.uniform()`.
| Parameter | Value Range | Description |
| ----------------- | -------------------------- | --------------------------------------------------------------------------- |
@@ -101,7 +101,7 @@ The following table lists the default search space parameters for hyperparameter
## Custom Search Space Example
-In this example, we demonstrate how to use a custom search space for hyperparameter tuning with Ray Tune and YOLOv8. By providing a custom search space, you can focus the tuning process on specific hyperparameters of interest.
+In this example, we demonstrate how to use a custom search space for hyperparameter tuning with Ray Tune and YOLO11. By providing a custom search space, you can focus the tuning process on specific hyperparameters of interest.
!!! example "Usage"
@@ -109,7 +109,7 @@ In this example, we demonstrate how to use a custom search space for hyperparame
from ultralytics import YOLO
# Define a YOLO model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Run Ray Tune on the model
result_grid = model.tune(
@@ -120,7 +120,7 @@ In this example, we demonstrate how to use a custom search space for hyperparame
)
```
-In the code snippet above, we create a YOLO model with the "yolov8n.pt" pretrained weights. Then, we call the `tune()` method, specifying the dataset configuration with "coco8.yaml". We provide a custom search space for the initial learning rate `lr0` using a dictionary with the key "lr0" and the value `tune.uniform(1e-5, 1e-1)`. Finally, we pass additional training arguments, such as the number of epochs directly to the tune method as `epochs=50`.
+In the code snippet above, we create a YOLO model with the "yolo11n.pt" pretrained weights. Then, we call the `tune()` method, specifying the dataset configuration with "coco8.yaml". We provide a custom search space for the initial learning rate `lr0` using a dictionary with the key "lr0" and the value `tune.uniform(1e-5, 1e-1)`. Finally, we pass additional training arguments, such as the number of epochs directly to the tune method as `epochs=50`.
## Processing Ray Tune Results
@@ -186,9 +186,9 @@ Explore further by looking into Ray Tune's [Analyze Results](https://docs.ray.io
## FAQ
-### How do I tune the hyperparameters of my YOLOv8 model using Ray Tune?
+### How do I tune the hyperparameters of my YOLO11 model using Ray Tune?
-To tune the hyperparameters of your Ultralytics YOLOv8 model using Ray Tune, follow these steps:
+To tune the hyperparameters of your Ultralytics YOLO11 model using Ray Tune, follow these steps:
1. **Install the required packages:**
@@ -197,13 +197,13 @@ To tune the hyperparameters of your Ultralytics YOLOv8 model using Ray Tune, fol
pip install wandb # optional for logging
```
-2. **Load your YOLOv8 model and start tuning:**
+2. **Load your YOLO11 model and start tuning:**
```python
from ultralytics import YOLO
- # Load a YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load a YOLO11 model
+ model = YOLO("yolo11n.pt")
# Start tuning with the COCO8 dataset
result_grid = model.tune(data="coco8.yaml", use_ray=True)
@@ -211,9 +211,9 @@ To tune the hyperparameters of your Ultralytics YOLOv8 model using Ray Tune, fol
This utilizes Ray Tune's advanced search strategies and parallelism to efficiently optimize your model's hyperparameters. For more information, check out the [Ray Tune documentation](https://docs.ray.io/en/latest/tune/index.html).
-### What are the default hyperparameters for YOLOv8 tuning with Ray Tune?
+### What are the default hyperparameters for YOLO11 tuning with Ray Tune?
-Ultralytics YOLOv8 uses the following default hyperparameters for tuning with Ray Tune:
+Ultralytics YOLO11 uses the following default hyperparameters for tuning with Ray Tune:
| Parameter | Value Range | Description |
| --------------- | -------------------------- | ------------------------------ |
@@ -229,9 +229,9 @@ Ultralytics YOLOv8 uses the following default hyperparameters for tuning with Ra
These hyperparameters can be customized to suit your specific needs. For a complete list and more details, refer to the [Hyperparameter Tuning](../guides/hyperparameter-tuning.md) guide.
-### How can I integrate Weights & Biases with my YOLOv8 model tuning?
+### How can I integrate Weights & Biases with my YOLO11 model tuning?
-To integrate Weights & Biases (W&B) with your Ultralytics YOLOv8 tuning process:
+To integrate Weights & Biases (W&B) with your Ultralytics YOLO11 tuning process:
1. **Install W&B:**
@@ -249,7 +249,7 @@ To integrate Weights & Biases (W&B) with your Ultralytics YOLOv8 tuning process:
wandb.init(project="YOLO-Tuning", entity="your-entity")
# Load YOLO model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Tune hyperparameters
result_grid = model.tune(data="coco8.yaml", use_ray=True)
@@ -257,7 +257,7 @@ To integrate Weights & Biases (W&B) with your Ultralytics YOLOv8 tuning process:
This setup will allow you to monitor the tuning process, track hyperparameter configurations, and visualize results in W&B.
-### Why should I use Ray Tune for hyperparameter optimization with YOLOv8?
+### Why should I use Ray Tune for hyperparameter optimization with YOLO11?
Ray Tune offers numerous advantages for hyperparameter optimization:
@@ -265,18 +265,18 @@ Ray Tune offers numerous advantages for hyperparameter optimization:
- **Parallelism:** Supports parallel execution of multiple trials, significantly speeding up the tuning process.
- **Early Stopping:** Employs strategies like ASHA to terminate under-performing trials early, saving computational resources.
-Ray Tune seamlessly integrates with Ultralytics YOLOv8, providing an easy-to-use interface for tuning hyperparameters effectively. To get started, check out the [Efficient Hyperparameter Tuning with Ray Tune and YOLOv8](../guides/hyperparameter-tuning.md) guide.
+Ray Tune seamlessly integrates with Ultralytics YOLO11, providing an easy-to-use interface for tuning hyperparameters effectively. To get started, check out the [Efficient Hyperparameter Tuning with Ray Tune and YOLO11](../guides/hyperparameter-tuning.md) guide.
-### How can I define a custom search space for YOLOv8 hyperparameter tuning?
+### How can I define a custom search space for YOLO11 hyperparameter tuning?
-To define a custom search space for your YOLOv8 hyperparameter tuning with Ray Tune:
+To define a custom search space for your YOLO11 hyperparameter tuning with Ray Tune:
```python
from ray import tune
from ultralytics import YOLO
-model = YOLO("yolov8n.pt")
+model = YOLO("yolo11n.pt")
search_space = {"lr0": tune.uniform(1e-5, 1e-1), "momentum": tune.uniform(0.6, 0.98)}
result_grid = model.tune(data="coco8.yaml", space=search_space, use_ray=True)
```
diff --git a/docs/en/integrations/roboflow.md b/docs/en/integrations/roboflow.md
index 321e560164..921538859a 100644
--- a/docs/en/integrations/roboflow.md
+++ b/docs/en/integrations/roboflow.md
@@ -1,7 +1,7 @@
---
comments: true
-description: Learn how to gather, label, and deploy data for custom YOLOv8 models using Roboflow's powerful tools. Optimize your computer vision pipeline effortlessly.
-keywords: Roboflow, YOLOv8, data labeling, computer vision, model training, model deployment, dataset management, automated image annotation, AI tools
+description: Learn how to gather, label, and deploy data for custom YOLO11 models using Roboflow's powerful tools. Optimize your computer vision pipeline effortlessly.
+keywords: Roboflow, YOLO11, data labeling, computer vision, model training, model deployment, dataset management, automated image annotation, AI tools
---
# Roboflow
@@ -17,17 +17,17 @@ keywords: Roboflow, YOLOv8, data labeling, computer vision, model training, mode
For more details see [Ultralytics Licensing](https://www.ultralytics.com/license).
-In this guide, we are going to showcase how to find, label, and organize data for use in training a custom Ultralytics YOLOv8 model. Use the table of contents below to jump directly to a specific section:
+In this guide, we are going to showcase how to find, label, and organize data for use in training a custom Ultralytics YOLO11 model. Use the table of contents below to jump directly to a specific section:
-- Gather data for training a custom YOLOv8 model
-- Upload, convert and label data for YOLOv8 format
+- Gather data for training a custom YOLO11 model
+- Upload, convert and label data for YOLO11 format
- Pre-process and augment data for model robustness
-- Dataset management for [YOLOv8](../models/yolov8.md)
+- Dataset management for [YOLO11](../models/yolov8.md)
- Export data in 40+ formats for model training
-- Upload custom YOLOv8 model weights for testing and deployment
-- Gather Data for Training a Custom YOLOv8 Model
+- Upload custom YOLO11 model weights for testing and deployment
+- Gather Data for Training a Custom YOLO11 Model
-Roboflow provides two services that can help you collect data for YOLOv8 models: [Universe](https://universe.roboflow.com/?ref=ultralytics) and [Collect](https://github.com/roboflow/roboflow-collect?ref=ultralytics).
+Roboflow provides two services that can help you collect data for YOLO11 models: [Universe](https://universe.roboflow.com/?ref=ultralytics) and [Collect](https://github.com/roboflow/roboflow-collect?ref=ultralytics).
Universe is an online repository with over 250,000 vision datasets totalling over 100 million images.
@@ -41,21 +41,21 @@ With a [free Roboflow account](https://app.roboflow.com/?ref=ultralytics), you c
-For YOLOv8, select "YOLOv8" as the export format:
+For YOLO11, select "YOLO11" as the export format:
@@ -95,7 +95,7 @@ You can also add tags to images from the Tags panel in the sidebar. You can appl
-## Dataset Management for YOLOv8
+## Dataset Management for YOLO11
Roboflow provides a suite of tools for understanding computer vision datasets.
@@ -157,13 +157,13 @@ When your dataset version has been generated, you can export your data into a ra
-You are now ready to train YOLOv8 on a custom dataset. Follow this [written guide](https://blog.roboflow.com/how-to-train-yolov8-on-a-custom-dataset/?ref=ultralytics) and [YouTube video](https://www.youtube.com/watch?v=wuZtUMEiKWY) for step-by-step instructions or refer to the [Ultralytics documentation](../modes/train.md).
+You are now ready to train YOLO11 on a custom dataset. Follow this [written guide](https://blog.roboflow.com/how-to-train-yolov8-on-a-custom-dataset/?ref=ultralytics) and [YouTube video](https://www.youtube.com/watch?v=wuZtUMEiKWY) for step-by-step instructions or refer to the [Ultralytics documentation](../modes/train.md).
-## Upload Custom YOLOv8 Model Weights for Testing and Deployment
+## Upload Custom YOLO11 Model Weights for Testing and Deployment
Roboflow offers an infinitely scalable API for deployed models and SDKs for use with NVIDIA Jetsons, Luxonis OAKs, Raspberry Pis, GPU-based devices, and more.
-You can deploy YOLOv8 models by uploading YOLOv8 weights to Roboflow. You can do this in a few lines of Python code. Create a new Python file and add the following code:
+You can deploy YOLO11 models by uploading YOLO11 weights to Roboflow. You can do this in a few lines of Python code. Create a new Python file and add the following code:
```python
import roboflow # install with 'pip install roboflow'
@@ -190,7 +190,7 @@ To test your model and find deployment instructions for supported SDKs, go to th
You can also use your uploaded model as a [labeling assistant](https://docs.roboflow.com/annotate/use-roboflow-annotate/model-assisted-labeling?ref=ultralytics). This feature uses your trained model to recommend annotations on images uploaded to Roboflow.
-## How to Evaluate YOLOv8 Models
+## How to Evaluate YOLO11 Models
Roboflow provides a range of features for use in evaluating models.
@@ -224,17 +224,17 @@ You can use Vector Analysis to:
## Learning Resources
-Want to learn more about using Roboflow for creating YOLOv8 models? The following resources may be helpful in your work.
+Want to learn more about using Roboflow for creating YOLO11 models? The following resources may be helpful in your work.
-- [Train YOLOv8 on a Custom Dataset](https://github.com/roboflow/notebooks/blob/main/notebooks/train-yolov8-object-detection-on-custom-dataset.ipynb): Follow our interactive notebook that shows you how to train a YOLOv8 model on a custom dataset.
-- [Autodistill](https://docs.autodistill.com/): Use large foundation vision models to label data for specific models. You can label images for use in training YOLOv8 classification, detection, and segmentation models with Autodistill.
+- [Train YOLO11 on a Custom Dataset](https://github.com/roboflow/notebooks/blob/main/notebooks/train-yolov8-object-detection-on-custom-dataset.ipynb): Follow our interactive notebook that shows you how to train a YOLO11 model on a custom dataset.
+- [Autodistill](https://docs.autodistill.com/): Use large foundation vision models to label data for specific models. You can label images for use in training YOLO11 classification, detection, and segmentation models with Autodistill.
- [Supervision](https://supervision.roboflow.com/?ref=ultralytics): A Python package with helpful utilities for use in working with computer vision models. You can use supervision to filter detections, compute confusion matrices, and more, all in a few lines of Python code.
-- [Roboflow Blog](https://blog.roboflow.com/?ref=ultralytics): The Roboflow Blog features over 500 articles on computer vision, covering topics from how to train a YOLOv8 model to annotation best practices.
-- [Roboflow YouTube channel](https://www.youtube.com/@Roboflow): Browse dozens of in-depth computer vision guides on our YouTube channel, covering topics from training YOLOv8 models to automated image labeling.
+- [Roboflow Blog](https://blog.roboflow.com/?ref=ultralytics): The Roboflow Blog features over 500 articles on computer vision, covering topics from how to train a YOLO11 model to annotation best practices.
+- [Roboflow YouTube channel](https://www.youtube.com/@Roboflow): Browse dozens of in-depth computer vision guides on our YouTube channel, covering topics from training YOLO11 models to automated image labeling.
## Project Showcase
-Below are a few of the many pieces of feedback we have received for using YOLOv8 and Roboflow together to create computer vision models.
+Below are a few of the many pieces of feedback we have received for using YOLO11 and Roboflow together to create computer vision models.
@@ -244,26 +244,26 @@ Below are a few of the many pieces of feedback we have received for using YOLOv8
## FAQ
-### How do I label data for YOLOv8 models using Roboflow?
+### How do I label data for YOLO11 models using Roboflow?
-Labeling data for YOLOv8 models using Roboflow is straightforward with Roboflow Annotate. First, create a project on Roboflow and upload your images. After uploading, select the batch of images and click "Start Annotating." You can use the `B` key for bounding boxes or the `P` key for polygons. For faster annotation, use the SAM-based label assistant by clicking the cursor icon in the sidebar. Detailed steps can be found [here](#upload-convert-and-label-data-for-yolov8-format).
+Labeling data for YOLO11 models using Roboflow is straightforward with Roboflow Annotate. First, create a project on Roboflow and upload your images. After uploading, select the batch of images and click "Start Annotating." You can use the `B` key for bounding boxes or the `P` key for polygons. For faster annotation, use the SAM-based label assistant by clicking the cursor icon in the sidebar. Detailed steps can be found [here](#upload-convert-and-label-data-for-yolo11-format).
-### What services does Roboflow offer for collecting YOLOv8 [training data](https://www.ultralytics.com/glossary/training-data)?
+### What services does Roboflow offer for collecting YOLO11 [training data](https://www.ultralytics.com/glossary/training-data)?
-Roboflow provides two key services for collecting YOLOv8 training data: [Universe](https://universe.roboflow.com/?ref=ultralytics) and [Collect](https://github.com/roboflow/roboflow-collect?ref=ultralytics). Universe offers access to over 250,000 vision datasets, while Collect helps you gather images using a webcam and automated prompts.
+Roboflow provides two key services for collecting YOLO11 training data: [Universe](https://universe.roboflow.com/?ref=ultralytics) and [Collect](https://github.com/roboflow/roboflow-collect?ref=ultralytics). Universe offers access to over 250,000 vision datasets, while Collect helps you gather images using a webcam and automated prompts.
-### How can I manage and analyze my YOLOv8 dataset using Roboflow?
+### How can I manage and analyze my YOLO11 dataset using Roboflow?
-Roboflow offers robust dataset management tools, including dataset search, tagging, and Health Check. Use the search feature to find images based on text descriptions or tags. Health Check provides insights into dataset quality, showing class balance, image sizes, and annotation heatmaps. This helps optimize dataset performance before training YOLOv8 models. Detailed information can be found [here](#dataset-management-for-yolov8).
+Roboflow offers robust dataset management tools, including dataset search, tagging, and Health Check. Use the search feature to find images based on text descriptions or tags. Health Check provides insights into dataset quality, showing class balance, image sizes, and annotation heatmaps. This helps optimize dataset performance before training YOLO11 models. Detailed information can be found [here](#dataset-management-for-yolo11).
-### How do I export my YOLOv8 dataset from Roboflow?
+### How do I export my YOLO11 dataset from Roboflow?
-To export your YOLOv8 dataset from Roboflow, you need to create a dataset version. Click "Versions" in the sidebar, then "Create New Version" and apply any desired augmentations. Once the version is generated, click "Export Dataset" and choose the YOLOv8 format. Follow this process [here](#export-data-in-40-formats-for-model-training).
+To export your YOLO11 dataset from Roboflow, you need to create a dataset version. Click "Versions" in the sidebar, then "Create New Version" and apply any desired augmentations. Once the version is generated, click "Export Dataset" and choose the YOLO11 format. Follow this process [here](#export-data-in-40-formats-for-model-training).
-### How can I integrate and deploy YOLOv8 models with Roboflow?
+### How can I integrate and deploy YOLO11 models with Roboflow?
-Integrate and deploy YOLOv8 models on Roboflow by uploading your YOLOv8 weights through a few lines of Python code. Use the provided script to authenticate and upload your model, which will create an API for deployment. For details on the script and further instructions, see [this section](#upload-custom-yolov8-model-weights-for-testing-and-deployment).
+Integrate and deploy YOLO11 models on Roboflow by uploading your YOLO11 weights through a few lines of Python code. Use the provided script to authenticate and upload your model, which will create an API for deployment. For details on the script and further instructions, see [this section](#upload-custom-yolo11-model-weights-for-testing-and-deployment).
-### What tools does Roboflow provide for evaluating YOLOv8 models?
+### What tools does Roboflow provide for evaluating YOLO11 models?
-Roboflow offers model evaluation tools, including a confusion matrix and vector analysis plots. Access these tools from the "View Detailed Evaluation" button on your model page. These features help identify model performance issues and find areas for improvement. For more information, refer to [this section](#how-to-evaluate-yolov8-models).
+Roboflow offers model evaluation tools, including a confusion matrix and vector analysis plots. Access these tools from the "View Detailed Evaluation" button on your model page. These features help identify model performance issues and find areas for improvement. For more information, refer to [this section](#how-to-evaluate-yolo11-models).
diff --git a/docs/en/integrations/tensorboard.md b/docs/en/integrations/tensorboard.md
index d563aca12b..c6cad0d50b 100644
--- a/docs/en/integrations/tensorboard.md
+++ b/docs/en/integrations/tensorboard.md
@@ -1,14 +1,14 @@
---
comments: true
-description: Learn how to integrate YOLOv8 with TensorBoard for real-time visual insights into your model's training metrics, performance graphs, and debugging workflows.
-keywords: YOLOv8, TensorBoard, model training, visualization, machine learning, deep learning, Ultralytics, training metrics, performance analysis
+description: Learn how to integrate YOLO11 with TensorBoard for real-time visual insights into your model's training metrics, performance graphs, and debugging workflows.
+keywords: YOLO11, TensorBoard, model training, visualization, machine learning, deep learning, Ultralytics, training metrics, performance analysis
---
-# Gain Visual Insights with YOLOv8's Integration with TensorBoard
+# Gain Visual Insights with YOLO11's Integration with TensorBoard
-Understanding and fine-tuning [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models like [Ultralytics' YOLOv8](https://www.ultralytics.com/) becomes more straightforward when you take a closer look at their training processes. Model training visualization helps with getting insights into the model's learning patterns, performance metrics, and overall behavior. YOLOv8's integration with TensorBoard makes this process of visualization and analysis easier and enables more efficient and informed adjustments to the model.
+Understanding and fine-tuning [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models like [Ultralytics' YOLO11](https://www.ultralytics.com/) becomes more straightforward when you take a closer look at their training processes. Model training visualization helps with getting insights into the model's learning patterns, performance metrics, and overall behavior. YOLO11's integration with TensorBoard makes this process of visualization and analysis easier and enables more efficient and informed adjustments to the model.
-This guide covers how to use TensorBoard with YOLOv8. You'll learn about various visualizations, from tracking metrics to analyzing model graphs. These tools will help you understand your YOLOv8 model's performance better.
+This guide covers how to use TensorBoard with YOLO11. You'll learn about various visualizations, from tracking metrics to analyzing model graphs. These tools will help you understand your YOLO11 model's performance better.
## TensorBoard
@@ -18,9 +18,9 @@ This guide covers how to use TensorBoard with YOLOv8. You'll learn about various
[TensorBoard](https://www.tensorflow.org/tensorboard), [TensorFlow](https://www.ultralytics.com/glossary/tensorflow)'s visualization toolkit, is essential for [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) experimentation. TensorBoard features a range of visualization tools, crucial for monitoring machine learning models. These tools include tracking key metrics like loss and accuracy, visualizing model graphs, and viewing histograms of weights and biases over time. It also provides capabilities for projecting [embeddings](https://www.ultralytics.com/glossary/embeddings) to lower-dimensional spaces and displaying multimedia data.
-## YOLOv8 Training with TensorBoard
+## YOLO11 Training with TensorBoard
-Using TensorBoard while training YOLOv8 models is straightforward and offers significant benefits.
+Using TensorBoard while training YOLO11 models is straightforward and offers significant benefits.
## Installation
@@ -31,13 +31,13 @@ To install the required package, run:
=== "CLI"
```bash
- # Install the required package for YOLOv8 and Tensorboard
+ # Install the required package for YOLO11 and Tensorboard
pip install ultralytics
```
-TensorBoard is conveniently pre-installed with YOLOv8, eliminating the need for additional setup for visualization purposes.
+TensorBoard is conveniently pre-installed with YOLO11, eliminating the need for additional setup for visualization purposes.
-For detailed instructions and best practices related to the installation process, be sure to check our [YOLOv8 Installation guide](../quickstart.md). While installing the required packages for YOLOv8, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
+For detailed instructions and best practices related to the installation process, be sure to check our [YOLO11 Installation guide](../quickstart.md). While installing the required packages for YOLO11, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
## Configuring TensorBoard for Google Colab
@@ -54,7 +54,7 @@ When using Google Colab, it's important to set up TensorBoard before starting yo
## Usage
-Before diving into the usage instructions, be sure to check out the range of [YOLOv8 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements.
+Before diving into the usage instructions, be sure to check out the range of [YOLO11 models offered by Ultralytics](../models/index.md). This will help you choose the most appropriate model for your project requirements.
!!! example "Usage"
@@ -64,7 +64,7 @@ Before diving into the usage instructions, be sure to check out the range of [YO
from ultralytics import YOLO
# Load a pre-trained model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
@@ -76,17 +76,17 @@ Upon running the usage code snippet above, you can expect the following output:
TensorBoard: Start with 'tensorboard --logdir path_to_your_tensorboard_logs', view at http://localhost:6006/
```
-This output indicates that TensorBoard is now actively monitoring your YOLOv8 training session. You can access the TensorBoard dashboard by visiting the provided URL (http://localhost:6006/) to view real-time training metrics and model performance. For users working in Google Colab, the TensorBoard will be displayed in the same cell where you executed the TensorBoard configuration commands.
+This output indicates that TensorBoard is now actively monitoring your YOLO11 training session. You can access the TensorBoard dashboard by visiting the provided URL (http://localhost:6006/) to view real-time training metrics and model performance. For users working in Google Colab, the TensorBoard will be displayed in the same cell where you executed the TensorBoard configuration commands.
-For more information related to the model training process, be sure to check our [YOLOv8 Model Training guide](../modes/train.md). If you are interested in learning more about logging, checkpoints, plotting, and file management, read our [usage guide on configuration](../usage/cfg.md).
+For more information related to the model training process, be sure to check our [YOLO11 Model Training guide](../modes/train.md). If you are interested in learning more about logging, checkpoints, plotting, and file management, read our [usage guide on configuration](../usage/cfg.md).
-## Understanding Your TensorBoard for YOLOv8 Training
+## Understanding Your TensorBoard for YOLO11 Training
-Now, let's focus on understanding the various features and components of TensorBoard in the context of YOLOv8 training. The three key sections of the TensorBoard are Time Series, Scalars, and Graphs.
+Now, let's focus on understanding the various features and components of TensorBoard in the context of YOLO11 training. The three key sections of the TensorBoard are Time Series, Scalars, and Graphs.
### Time Series
-The Time Series feature in the TensorBoard offers a dynamic and detailed perspective of various training metrics over time for YOLOv8 models. It focuses on the progression and trends of metrics across training epochs. Here's an example of what you can expect to see.
+The Time Series feature in the TensorBoard offers a dynamic and detailed perspective of various training metrics over time for YOLO11 models. It focuses on the progression and trends of metrics across training epochs. Here's an example of what you can expect to see.
@@ -100,13 +100,13 @@ The Time Series feature in the TensorBoard offers a dynamic and detailed perspec
- **In-Depth Analysis**: Time Series provides an in-depth analysis of each metric. For instance, different learning rate segments are shown, offering insights into how adjustments in learning rate impact the model's learning curve.
-#### Importance of Time Series in YOLOv8 Training
+#### Importance of Time Series in YOLO11 Training
-The Time Series section is essential for a thorough analysis of the YOLOv8 model's training progress. It lets you track the metrics in real time to promptly identify and solve issues. It also offers a detailed view of each metrics progression, which is crucial for fine-tuning the model and enhancing its performance.
+The Time Series section is essential for a thorough analysis of the YOLO11 model's training progress. It lets you track the metrics in real time to promptly identify and solve issues. It also offers a detailed view of each metrics progression, which is crucial for fine-tuning the model and enhancing its performance.
### Scalars
-Scalars in the TensorBoard are crucial for plotting and analyzing simple metrics like loss and accuracy during the training of YOLOv8 models. They offer a clear and concise view of how these metrics evolve with each training [epoch](https://www.ultralytics.com/glossary/epoch), providing insights into the model's learning effectiveness and stability. Here's an example of what you can expect to see.
+Scalars in the TensorBoard are crucial for plotting and analyzing simple metrics like loss and accuracy during the training of YOLO11 models. They offer a clear and concise view of how these metrics evolve with each training [epoch](https://www.ultralytics.com/glossary/epoch), providing insights into the model's learning effectiveness and stability. Here's an example of what you can expect to see.
@@ -130,7 +130,7 @@ Scalars in the TensorBoard are crucial for plotting and analyzing simple metrics
#### Importance of Monitoring Scalars
-Observing scalar metrics is crucial for fine-tuning the YOLOv8 model. Variations in these metrics, such as spikes or irregular patterns in loss graphs, can highlight potential issues such as [overfitting](https://www.ultralytics.com/glossary/overfitting), [underfitting](https://www.ultralytics.com/glossary/underfitting), or inappropriate learning rate settings. By closely monitoring these scalars, you can make informed decisions to optimize the training process, ensuring that the model learns effectively and achieves the desired performance.
+Observing scalar metrics is crucial for fine-tuning the YOLO11 model. Variations in these metrics, such as spikes or irregular patterns in loss graphs, can highlight potential issues such as [overfitting](https://www.ultralytics.com/glossary/overfitting), [underfitting](https://www.ultralytics.com/glossary/underfitting), or inappropriate learning rate settings. By closely monitoring these scalars, you can make informed decisions to optimize the training process, ensuring that the model learns effectively and achieves the desired performance.
### Difference Between Scalars and Time Series
@@ -138,15 +138,15 @@ While both Scalars and Time Series in TensorBoard are used for tracking metrics,
### Graphs
-The Graphs section of the TensorBoard visualizes the computational graph of the YOLOv8 model, showing how operations and data flow within the model. It's a powerful tool for understanding the model's structure, ensuring that all layers are connected correctly, and for identifying any potential bottlenecks in data flow. Here's an example of what you can expect to see.
+The Graphs section of the TensorBoard visualizes the computational graph of the YOLO11 model, showing how operations and data flow within the model. It's a powerful tool for understanding the model's structure, ensuring that all layers are connected correctly, and for identifying any potential bottlenecks in data flow. Here's an example of what you can expect to see.
-Graphs are particularly useful for debugging the model, especially in complex architectures typical in [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models like YOLOv8. They help in verifying layer connections and the overall design of the model.
+Graphs are particularly useful for debugging the model, especially in complex architectures typical in [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models like YOLO11. They help in verifying layer connections and the overall design of the model.
## Summary
-This guide aims to help you use TensorBoard with YOLOv8 for visualization and analysis of machine learning model training. It focuses on explaining how key TensorBoard features can provide insights into training metrics and model performance during YOLOv8 training sessions.
+This guide aims to help you use TensorBoard with YOLO11 for visualization and analysis of machine learning model training. It focuses on explaining how key TensorBoard features can provide insights into training metrics and model performance during YOLO11 training sessions.
For a more detailed exploration of these features and effective utilization strategies, you can refer to TensorFlow's official [TensorBoard documentation](https://www.tensorflow.org/tensorboard/get_started) and their [GitHub repository](https://github.com/tensorflow/tensorboard).
@@ -154,29 +154,29 @@ Want to learn more about the various integrations of Ultralytics? Check out the
## FAQ
-### What benefits does using TensorBoard with YOLOv8 offer?
+### What benefits does using TensorBoard with YOLO11 offer?
-Using TensorBoard with YOLOv8 provides several visualization tools essential for efficient model training:
+Using TensorBoard with YOLO11 provides several visualization tools essential for efficient model training:
- **Real-Time Metrics Tracking:** Track key metrics such as loss, accuracy, precision, and recall live.
- **Model Graph Visualization:** Understand and debug the model architecture by visualizing computational graphs.
- **Embedding Visualization:** Project embeddings to lower-dimensional spaces for better insight.
-These tools enable you to make informed adjustments to enhance your YOLOv8 model's performance. For more details on TensorBoard features, check out the TensorFlow [TensorBoard guide](https://www.tensorflow.org/tensorboard/get_started).
+These tools enable you to make informed adjustments to enhance your YOLO11 model's performance. For more details on TensorBoard features, check out the TensorFlow [TensorBoard guide](https://www.tensorflow.org/tensorboard/get_started).
-### How can I monitor training metrics using TensorBoard when training a YOLOv8 model?
+### How can I monitor training metrics using TensorBoard when training a YOLO11 model?
-To monitor training metrics while training a YOLOv8 model with TensorBoard, follow these steps:
+To monitor training metrics while training a YOLO11 model with TensorBoard, follow these steps:
-1. **Install TensorBoard and YOLOv8:** Run `pip install ultralytics` which includes TensorBoard.
-2. **Configure TensorBoard Logging:** During the training process, YOLOv8 logs metrics to a specified log directory.
+1. **Install TensorBoard and YOLO11:** Run `pip install ultralytics` which includes TensorBoard.
+2. **Configure TensorBoard Logging:** During the training process, YOLO11 logs metrics to a specified log directory.
3. **Start TensorBoard:** Launch TensorBoard using the command `tensorboard --logdir path/to/your/tensorboard/logs`.
-The TensorBoard dashboard, accessible via [http://localhost:6006/](http://localhost:6006/), provides real-time insights into various training metrics. For a deeper dive into training configurations, visit our [YOLOv8 Configuration guide](../usage/cfg.md).
+The TensorBoard dashboard, accessible via [http://localhost:6006/](http://localhost:6006/), provides real-time insights into various training metrics. For a deeper dive into training configurations, visit our [YOLO11 Configuration guide](../usage/cfg.md).
-### What kind of metrics can I visualize with TensorBoard when training YOLOv8 models?
+### What kind of metrics can I visualize with TensorBoard when training YOLO11 models?
-When training YOLOv8 models, TensorBoard allows you to visualize an array of important metrics including:
+When training YOLO11 models, TensorBoard allows you to visualize an array of important metrics including:
- **Loss (Training and Validation):** Indicates how well the model is performing during training and validation.
- **Accuracy/Precision/[Recall](https://www.ultralytics.com/glossary/recall):** Key performance metrics to evaluate detection accuracy.
@@ -185,9 +185,9 @@ When training YOLOv8 models, TensorBoard allows you to visualize an array of imp
These visualizations are essential for tracking model performance and making necessary optimizations. For more information on these metrics, refer to our [Performance Metrics guide](../guides/yolo-performance-metrics.md).
-### Can I use TensorBoard in a Google Colab environment for training YOLOv8?
+### Can I use TensorBoard in a Google Colab environment for training YOLO11?
-Yes, you can use TensorBoard in a Google Colab environment to train YOLOv8 models. Here's a quick setup:
+Yes, you can use TensorBoard in a Google Colab environment to train YOLO11 models. Here's a quick setup:
!!! example "Configure TensorBoard for Google Colab"
@@ -198,16 +198,16 @@ Yes, you can use TensorBoard in a Google Colab environment to train YOLOv8 model
%tensorboard --logdir path/to/runs
```
- Then, run the YOLOv8 training script:
+ Then, run the YOLO11 training script:
```python
from ultralytics import YOLO
# Load a pre-trained model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
```
-TensorBoard will visualize the training progress within Colab, providing real-time insights into metrics like loss and accuracy. For additional details on configuring YOLOv8 training, see our detailed [YOLOv8 Installation guide](../quickstart.md).
+TensorBoard will visualize the training progress within Colab, providing real-time insights into metrics like loss and accuracy. For additional details on configuring YOLO11 training, see our detailed [YOLO11 Installation guide](../quickstart.md).
diff --git a/docs/en/integrations/tensorrt.md b/docs/en/integrations/tensorrt.md
index 0e40198113..1a8e5a9161 100644
--- a/docs/en/integrations/tensorrt.md
+++ b/docs/en/integrations/tensorrt.md
@@ -380,7 +380,7 @@ Expand sections below for information on how these models were exported and test
See [export mode](../modes/export.md) for details regarding export configuration arguments.
- ```py
+ ```python
from ultralytics import YOLO
model = YOLO("yolov8n.pt")
@@ -401,7 +401,7 @@ Expand sections below for information on how these models were exported and test
See [predict mode](../modes/predict.md) for additional information.
- ```py
+ ```python
import cv2
from ultralytics import YOLO
@@ -421,7 +421,7 @@ Expand sections below for information on how these models were exported and test
See [`val` mode](../modes/val.md) to learn more about validation configuration arguments.
- ```py
+ ```python
from ultralytics import YOLO
model = YOLO("yolov8n.engine")
diff --git a/docs/en/integrations/tf-graphdef.md b/docs/en/integrations/tf-graphdef.md
index 15cbd48426..fd6d86a32a 100644
--- a/docs/en/integrations/tf-graphdef.md
+++ b/docs/en/integrations/tf-graphdef.md
@@ -1,14 +1,14 @@
---
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
+description: Learn how to export YOLO11 models to the TF GraphDef format for seamless deployment on various platforms, including mobile and web.
+keywords: YOLO11, 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
+# How to Export to TF GraphDef from YOLO11 for Deployment
-When you are deploying cutting-edge [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models, like YOLOv8, in different environments, you might run into compatibility issues. Google's [TensorFlow](https://www.ultralytics.com/glossary/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.
+When you are deploying cutting-edge [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models, like YOLO11, in different environments, you might run into compatibility issues. Google's [TensorFlow](https://www.ultralytics.com/glossary/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 YOLO11 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.
+In this guide, we'll walk you step by step through how to export your [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics) models to the TF GraphDef model format. By converting your model, you can streamline deployment and use YOLO11's computer vision capabilities in a broader range of applications and platforms.
@@ -16,11 +16,11 @@ In this guide, we'll walk you step by step through how to export your [Ultralyti
## Why Should You Export to TF GraphDef?
-TF GraphDef is a powerful component of the TensorFlow ecosystem that was developed by Google. It can be used to optimize and deploy models like YOLOv8. Exporting to TF GraphDef lets us move models from research to real-world applications. It allows models to run in environments without the full TensorFlow framework.
+TF GraphDef is a powerful component of the TensorFlow ecosystem that was developed by Google. It can be used to optimize and deploy models like YOLO11. Exporting to TF GraphDef lets us move models from research to real-world applications. It allows models to run in environments without the full TensorFlow framework.
The GraphDef format represents the model as a serialized computation graph. This enables various optimization techniques like constant folding, quantization, and graph transformations. These optimizations ensure efficient execution, reduced memory usage, and faster inference speeds.
-GraphDef models can use hardware accelerators such as GPUs, TPUs, and AI chips, unlocking significant performance gains for the YOLOv8 inference pipeline. The TF GraphDef format creates a self-contained package with the model and its dependencies, simplifying deployment and integration into diverse systems.
+GraphDef models can use hardware accelerators such as GPUs, TPUs, and AI chips, unlocking significant performance gains for the YOLO11 inference pipeline. The TF GraphDef format creates a self-contained package with the model and its dependencies, simplifying deployment and integration into diverse systems.
## Key Features of TF GraphDef Models
@@ -38,7 +38,7 @@ Here's a look at its key characteristics:
## Deployment Options with TF GraphDef
-Before we dive into the process of exporting YOLOv8 models to TF GraphDef, let's take a look at some typical deployment situations where this format is used.
+Before we dive into the process of exporting YOLO11 models to TF GraphDef, let's take a look at some typical deployment situations where this format is used.
Here's how you can deploy with TF GraphDef efficiently across various platforms.
@@ -46,13 +46,13 @@ Here's how you can deploy with TF GraphDef efficiently across various platforms.
- **Mobile and Embedded Devices:** With tools like TensorFlow Lite, you can convert TF GraphDef models into formats optimized for smartphones, tablets, and various embedded devices. Your models can then be used for on-device inference, where execution is done locally, often providing performance gains and offline capabilities.
-- **Web Browsers:** TensorFlow.js enables the deployment of TF GraphDef models directly within web browsers. It paves the way for real-time object detection applications running on the client side, using the capabilities of YOLOv8 through JavaScript.
+- **Web Browsers:** TensorFlow.js enables the deployment of TF GraphDef models directly within web browsers. It paves the way for real-time object detection applications running on the client side, using the capabilities of YOLO11 through JavaScript.
- **Specialized Hardware:** TF GraphDef's platform-agnostic nature allows it to target custom hardware, such as accelerators and TPUs (Tensor Processing Units). These devices can provide performance advantages for computationally intensive models.
-## Exporting YOLOv8 Models to TF GraphDef
+## Exporting YOLO11 Models to TF GraphDef
-You can convert your YOLOv8 object detection model to the TF GraphDef format, which is compatible with various systems, to improve its performance across platforms.
+You can convert your YOLO11 object detection model to the TF GraphDef format, which is compatible with various systems, to improve its performance across platforms.
### Installation
@@ -63,15 +63,15 @@ To install the required package, run:
=== "CLI"
```bash
- # Install the required package for YOLOv8
+ # Install the required package for YOLO11
pip install ultralytics
```
-For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLOv8, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
+For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLO11, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
### Usage
-Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLOv8 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
+Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLO11 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
!!! example "Usage"
@@ -80,14 +80,14 @@ Before diving into the usage instructions, it's important to note that while all
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TF GraphDef format
- model.export(format="pb") # creates 'yolov8n.pb'
+ model.export(format="pb") # creates 'yolo11n.pb'
# Load the exported TF GraphDef model
- tf_graphdef_model = YOLO("yolov8n.pb")
+ tf_graphdef_model = YOLO("yolo11n.pb")
# Run inference
results = tf_graphdef_model("https://ultralytics.com/images/bus.jpg")
@@ -96,18 +96,18 @@ Before diving into the usage instructions, it's important to note that while all
=== "CLI"
```bash
- # Export a YOLOv8n PyTorch model to TF GraphDef format
- yolo export model=yolov8n.pt format=pb # creates 'yolov8n.pb'
+ # Export a YOLO11n PyTorch model to TF GraphDef format
+ yolo export model=yolo11n.pt format=pb # creates 'yolo11n.pb'
# Run inference with the exported model
- yolo predict model='yolov8n.pb' source='https://ultralytics.com/images/bus.jpg'
+ yolo predict model='yolo11n.pb' source='https://ultralytics.com/images/bus.jpg'
```
For more details about supported export options, visit the [Ultralytics documentation page on deployment options](../guides/model-deployment-options.md).
-## Deploying Exported YOLOv8 TF GraphDef Models
+## Deploying Exported YOLO11 TF GraphDef Models
-Once you've exported your YOLOv8 model to the TF GraphDef format, the next step is deployment. The primary and recommended first step for running a TF GraphDef model is to use the YOLO("model.pb") method, as previously shown in the usage code snippet.
+Once you've exported your YOLO11 model to the TF GraphDef format, the next step is deployment. The primary and recommended first step for running a TF GraphDef model is to use the YOLO("model.pb") method, as previously shown in the usage code snippet.
However, for more information on deploying your TF GraphDef models, take a look at the following resources:
@@ -119,17 +119,17 @@ However, for more information on deploying your TF GraphDef models, take a look
## Summary
-In this guide, we explored how to export Ultralytics YOLOv8 models to the TF GraphDef format. By doing this, you can flexibly deploy your optimized YOLOv8 models in different environments.
+In this guide, we explored how to export Ultralytics YOLO11 models to the TF GraphDef format. By doing this, you can flexibly deploy your optimized YOLO11 models in different environments.
For further details on usage, visit the [TF GraphDef official documentation](https://www.tensorflow.org/api_docs/python/tf/Graph).
-For more information on integrating Ultralytics YOLOv8 with other platforms and frameworks, don't forget to check out our [integration guide page](index.md). It has great resources and insights to help you make the most of YOLOv8 in your projects.
+For more information on integrating Ultralytics YOLO11 with other platforms and frameworks, don't forget to check out our [integration guide page](index.md). It has great resources and insights to help you make the most of YOLO11 in your projects.
## FAQ
-### How do I export a YOLOv8 model to TF GraphDef format?
+### How do I export a YOLO11 model to TF GraphDef format?
-Ultralytics YOLOv8 models can be exported to TensorFlow GraphDef (TF GraphDef) format seamlessly. This format provides a serialized, platform-independent representation of the model, ideal for deploying in varied environments like mobile and web. To export a YOLOv8 model to TF GraphDef, follow these steps:
+Ultralytics YOLO11 models can be exported to TensorFlow GraphDef (TF GraphDef) format seamlessly. This format provides a serialized, platform-independent representation of the model, ideal for deploying in varied environments like mobile and web. To export a YOLO11 model to TF GraphDef, follow these steps:
!!! example "Usage"
@@ -138,14 +138,14 @@ Ultralytics YOLOv8 models can be exported to TensorFlow GraphDef (TF GraphDef) f
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TF GraphDef format
- model.export(format="pb") # creates 'yolov8n.pb'
+ model.export(format="pb") # creates 'yolo11n.pb'
# Load the exported TF GraphDef model
- tf_graphdef_model = YOLO("yolov8n.pb")
+ tf_graphdef_model = YOLO("yolo11n.pb")
# Run inference
results = tf_graphdef_model("https://ultralytics.com/images/bus.jpg")
@@ -154,18 +154,18 @@ Ultralytics YOLOv8 models can be exported to TensorFlow GraphDef (TF GraphDef) f
=== "CLI"
```bash
- # Export a YOLOv8n PyTorch model to TF GraphDef format
- yolo export model="yolov8n.pt" format="pb" # creates 'yolov8n.pb'
+ # Export a YOLO11n PyTorch model to TF GraphDef format
+ yolo export model="yolo11n.pt" format="pb" # creates 'yolo11n.pb'
# Run inference with the exported model
- yolo predict model="yolov8n.pb" source="https://ultralytics.com/images/bus.jpg"
+ yolo predict model="yolo11n.pb" source="https://ultralytics.com/images/bus.jpg"
```
For more information on different export options, visit the [Ultralytics documentation on model export](../modes/export.md).
-### What are the benefits of using TF GraphDef for YOLOv8 model deployment?
+### What are the benefits of using TF GraphDef for YOLO11 model deployment?
-Exporting YOLOv8 models to the TF GraphDef format offers multiple advantages, including:
+Exporting YOLO11 models to the TF GraphDef format offers multiple advantages, including:
1. **Platform Independence**: TF GraphDef provides a platform-independent format, allowing models to be deployed across various environments including mobile and web browsers.
2. **Optimizations**: The format enables several optimizations, such as constant folding, quantization, and graph transformations, which enhance execution efficiency and reduce memory usage.
@@ -173,19 +173,19 @@ Exporting YOLOv8 models to the TF GraphDef format offers multiple advantages, in
Read more about the benefits in the [TF GraphDef section](#why-should-you-export-to-tf-graphdef) of our documentation.
-### Why should I use Ultralytics YOLOv8 over other [object detection](https://www.ultralytics.com/glossary/object-detection) models?
+### Why should I use Ultralytics YOLO11 over other [object detection](https://www.ultralytics.com/glossary/object-detection) models?
-Ultralytics YOLOv8 offers numerous advantages compared to other models like YOLOv5 and YOLOv7. Some key benefits include:
+Ultralytics YOLO11 offers numerous advantages compared to other models like YOLOv5 and YOLOv7. Some key benefits include:
-1. **State-of-the-Art Performance**: YOLOv8 provides exceptional speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) for real-time object detection, segmentation, and classification.
+1. **State-of-the-Art Performance**: YOLO11 provides exceptional speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) for real-time object detection, segmentation, and classification.
2. **Ease of Use**: Features a user-friendly API for model training, validation, prediction, and export, making it accessible for both beginners and experts.
3. **Broad Compatibility**: Supports multiple export formats including ONNX, TensorRT, CoreML, and TensorFlow, for versatile deployment options.
-Explore further details in our [introduction to YOLOv8](https://docs.ultralytics.com/models/yolov8/).
+Explore further details in our [introduction to YOLO11](https://docs.ultralytics.com/models/yolov8/).
-### How can I deploy a YOLOv8 model on specialized hardware using TF GraphDef?
+### How can I deploy a YOLO11 model on specialized hardware using TF GraphDef?
-Once a YOLOv8 model is exported to TF GraphDef format, you can deploy it across various specialized hardware platforms. Typical deployment scenarios include:
+Once a YOLO11 model is exported to TF GraphDef format, you can deploy it across various specialized hardware platforms. Typical deployment scenarios include:
- **TensorFlow Serving**: Use TensorFlow Serving for scalable model deployment in production environments. It supports model management and efficient serving.
- **Mobile Devices**: Convert TF GraphDef models to TensorFlow Lite, optimized for mobile and embedded devices, enabling on-device inference.
@@ -194,11 +194,11 @@ Once a YOLOv8 model is exported to TF GraphDef format, you can deploy it across
Check the [deployment options](#deployment-options-with-tf-graphdef) section for detailed information.
-### Where can I find solutions for common issues while exporting YOLOv8 models?
+### Where can I find solutions for common issues while exporting YOLO11 models?
-For troubleshooting common issues with exporting YOLOv8 models, Ultralytics provides comprehensive guides and resources. If you encounter problems during installation or model export, refer to:
+For troubleshooting common issues with exporting YOLO11 models, Ultralytics provides comprehensive guides and resources. If you encounter problems during installation or model export, refer to:
- **[Common Issues Guide](../guides/yolo-common-issues.md)**: Offers solutions to frequently faced problems.
- **[Installation Guide](../quickstart.md)**: Step-by-step instructions for setting up the required packages.
-These resources should help you resolve most issues related to YOLOv8 model export and deployment.
+These resources should help you resolve most issues related to YOLO11 model export and deployment.
diff --git a/docs/en/integrations/tf-savedmodel.md b/docs/en/integrations/tf-savedmodel.md
index 9f04dc7893..288802b641 100644
--- a/docs/en/integrations/tf-savedmodel.md
+++ b/docs/en/integrations/tf-savedmodel.md
@@ -1,14 +1,14 @@
---
comments: true
-description: Learn how to export Ultralytics YOLOv8 models to TensorFlow SavedModel format for easy deployment across various platforms and environments.
-keywords: YOLOv8, TF SavedModel, Ultralytics, TensorFlow, model export, model deployment, machine learning, AI
+description: Learn how to export Ultralytics YOLO11 models to TensorFlow SavedModel format for easy deployment across various platforms and environments.
+keywords: YOLO11, TF SavedModel, Ultralytics, TensorFlow, model export, model deployment, machine learning, AI
---
-# Understand How to Export to TF SavedModel Format From YOLOv8
+# Understand How to Export to TF SavedModel Format From YOLO11
Deploying [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models can be challenging. However, using an efficient and flexible model format can make your job easier. TF SavedModel is an open-source machine-learning framework used by TensorFlow to load machine-learning models in a consistent way. It is like a suitcase for TensorFlow models, making them easy to carry and use on different devices and systems.
-Learning how to export to TF SavedModel from [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) models can help you deploy models easily across different platforms and environments. In this guide, we'll walk through how to convert your models to the TF SavedModel format, simplifying the process of running inferences with your models on different devices.
+Learning how to export to TF SavedModel from [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics) models can help you deploy models easily across different platforms and environments. In this guide, we'll walk through how to convert your models to the TF SavedModel format, simplifying the process of running inferences with your models on different devices.
## Why Should You Export to TF SavedModel?
@@ -32,7 +32,7 @@ Here are the key features that make TF SavedModel a great option for AI develope
## Deployment Options with TF SavedModel
-Before we dive into the process of exporting YOLOv8 models to the TF SavedModel format, let's explore some typical deployment scenarios where this format is used.
+Before we dive into the process of exporting YOLO11 models to the TF SavedModel format, let's explore some typical deployment scenarios where this format is used.
TF SavedModel provides a range of options to deploy your machine learning models:
@@ -44,9 +44,9 @@ TF SavedModel provides a range of options to deploy your machine learning models
- **TensorFlow Runtime:** TensorFlow Runtime (`tfrt`) is a high-performance runtime for executing [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) graphs. It provides lower-level APIs for loading and running TF SavedModels in C++ environments. TensorFlow Runtime offers better performance compared to the standard TensorFlow runtime. It is suitable for deployment scenarios that require low-latency inference and tight integration with existing C++ codebases.
-## Exporting YOLOv8 Models to TF SavedModel
+## Exporting YOLO11 Models to TF SavedModel
-By exporting YOLOv8 models to the TF SavedModel format, you enhance their adaptability and ease of deployment across various platforms.
+By exporting YOLO11 models to the TF SavedModel format, you enhance their adaptability and ease of deployment across various platforms.
### Installation
@@ -57,15 +57,15 @@ To install the required package, run:
=== "CLI"
```bash
- # Install the required package for YOLOv8
+ # Install the required package for YOLO11
pip install ultralytics
```
-For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLOv8, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
+For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLO11, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
### Usage
-Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLOv8 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
+Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLO11 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
!!! example "Usage"
@@ -74,14 +74,14 @@ Before diving into the usage instructions, it's important to note that while all
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TF SavedModel format
- model.export(format="saved_model") # creates '/yolov8n_saved_model'
+ model.export(format="saved_model") # creates '/yolo11n_saved_model'
# Load the exported TF SavedModel model
- tf_savedmodel_model = YOLO("./yolov8n_saved_model")
+ tf_savedmodel_model = YOLO("./yolo11n_saved_model")
# Run inference
results = tf_savedmodel_model("https://ultralytics.com/images/bus.jpg")
@@ -90,18 +90,18 @@ Before diving into the usage instructions, it's important to note that while all
=== "CLI"
```bash
- # Export a YOLOv8n PyTorch model to TF SavedModel format
- yolo export model=yolov8n.pt format=saved_model # creates '/yolov8n_saved_model'
+ # Export a YOLO11n PyTorch model to TF SavedModel format
+ yolo export model=yolo11n.pt format=saved_model # creates '/yolo11n_saved_model'
# Run inference with the exported model
- yolo predict model='./yolov8n_saved_model' source='https://ultralytics.com/images/bus.jpg'
+ yolo predict model='./yolo11n_saved_model' source='https://ultralytics.com/images/bus.jpg'
```
For more details about supported export options, visit the [Ultralytics documentation page on deployment options](../guides/model-deployment-options.md).
-## Deploying Exported YOLOv8 TF SavedModel Models
+## Deploying Exported YOLO11 TF SavedModel Models
-Now that you have exported your YOLOv8 model to the TF SavedModel format, the next step is to deploy it. The primary and recommended first step for running a TF GraphDef model is to use the YOLO("./yolov8n_saved_model") method, as previously shown in the usage code snippet.
+Now that you have exported your YOLO11 model to the TF SavedModel format, the next step is to deploy it. The primary and recommended first step for running a TF GraphDef model is to use the YOLO("./yolo11n_saved_model") method, as previously shown in the usage code snippet.
However, for in-depth instructions on deploying your TF SavedModel models, take a look at the following resources:
@@ -113,11 +113,11 @@ However, for in-depth instructions on deploying your TF SavedModel models, take
## Summary
-In this guide, we explored how to export Ultralytics YOLOv8 models to the TF SavedModel format. By exporting to TF SavedModel, you gain the flexibility to optimize, deploy, and scale your YOLOv8 models on a wide range of platforms.
+In this guide, we explored how to export Ultralytics YOLO11 models to the TF SavedModel format. By exporting to TF SavedModel, you gain the flexibility to optimize, deploy, and scale your YOLO11 models on a wide range of platforms.
For further details on usage, visit the [TF SavedModel official documentation](https://www.tensorflow.org/guide/saved_model).
-For more information on integrating Ultralytics YOLOv8 with other platforms and frameworks, don't forget to check out our [integration guide page](index.md). It's packed with great resources to help you make the most of YOLOv8 in your projects.
+For more information on integrating Ultralytics YOLO11 with other platforms and frameworks, don't forget to check out our [integration guide page](index.md). It's packed with great resources to help you make the most of YOLO11 in your projects.
## FAQ
@@ -125,32 +125,32 @@ For more information on integrating Ultralytics YOLOv8 with other platforms and
Exporting an Ultralytics YOLO model to the TensorFlow SavedModel format is straightforward. You can use either Python or CLI to achieve this:
-!!! example "Exporting YOLOv8 to TF SavedModel"
+!!! example "Exporting YOLO11 to TF SavedModel"
=== "Python"
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TF SavedModel format
- model.export(format="saved_model") # creates '/yolov8n_saved_model'
+ model.export(format="saved_model") # creates '/yolo11n_saved_model'
# Load the exported TF SavedModel for inference
- tf_savedmodel_model = YOLO("./yolov8n_saved_model")
+ tf_savedmodel_model = YOLO("./yolo11n_saved_model")
results = tf_savedmodel_model("https://ultralytics.com/images/bus.jpg")
```
=== "CLI"
```bash
- # Export the YOLOv8 model to TF SavedModel format
- yolo export model=yolov8n.pt format=saved_model # creates '/yolov8n_saved_model'
+ # Export the YOLO11 model to TF SavedModel format
+ yolo export model=yolo11n.pt format=saved_model # creates '/yolo11n_saved_model'
# Run inference with the exported model
- yolo predict model='./yolov8n_saved_model' source='https://ultralytics.com/images/bus.jpg'
+ yolo predict model='./yolo11n_saved_model' source='https://ultralytics.com/images/bus.jpg'
```
Refer to the [Ultralytics Export documentation](../modes/export.md) for more details.
@@ -176,9 +176,9 @@ TF SavedModel can be deployed in various environments, including:
For detailed deployment options, visit the official guides on [deploying TensorFlow models](https://www.tensorflow.org/tfx/guide/serving).
-### How can I install the necessary packages to export YOLOv8 models?
+### How can I install the necessary packages to export YOLO11 models?
-To export YOLOv8 models, you need to install the `ultralytics` package. Run the following command in your terminal:
+To export YOLO11 models, you need to install the `ultralytics` package. Run the following command in your terminal:
```bash
pip install ultralytics
diff --git a/docs/en/integrations/tfjs.md b/docs/en/integrations/tfjs.md
index ea2d613c62..a8168215b6 100644
--- a/docs/en/integrations/tfjs.md
+++ b/docs/en/integrations/tfjs.md
@@ -1,14 +1,14 @@
---
comments: true
-description: Convert your Ultralytics YOLOv8 models to TensorFlow.js for high-speed, local object detection. Learn how to optimize ML models for browser and Node.js apps.
-keywords: YOLOv8, TensorFlow.js, TF.js, model export, machine learning, object detection, browser ML, Node.js, Ultralytics, YOLO, export models
+description: Convert your Ultralytics YOLO11 models to TensorFlow.js for high-speed, local object detection. Learn how to optimize ML models for browser and Node.js apps.
+keywords: YOLO11, TensorFlow.js, TF.js, model export, machine learning, object detection, browser ML, Node.js, Ultralytics, YOLO, export models
---
-# Export to TF.js Model Format From a YOLOv8 Model Format
+# Export to TF.js Model Format From a YOLO11 Model Format
Deploying [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models directly in the browser or on Node.js can be tricky. You'll need to make sure your model format is optimized for faster performance so that the model can be used to run interactive applications locally on the user's device. The TensorFlow.js, or TF.js, model format is designed to use minimal power while delivering fast performance.
-The 'export to TF.js model format' feature allows you to optimize your [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) models for high-speed and locally-run [object detection](https://www.ultralytics.com/glossary/object-detection) inference. In this guide, we'll walk you through converting your models to the TF.js format, making it easier for your models to perform well on various local browsers and Node.js applications.
+The 'export to TF.js model format' feature allows you to optimize your [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics) models for high-speed and locally-run [object detection](https://www.ultralytics.com/glossary/object-detection) inference. In this guide, we'll walk you through converting your models to the TF.js format, making it easier for your models to perform well on various local browsers and Node.js applications.
## Why Should You Export to TF.js?
@@ -32,7 +32,7 @@ Here are the key features that make TF.js a powerful tool for developers:
## Deployment Options with TensorFlow.js
-Before we dive into the process of exporting YOLOv8 models to the TF.js format, let's explore some typical deployment scenarios where this format is used.
+Before we dive into the process of exporting YOLO11 models to the TF.js format, let's explore some typical deployment scenarios where this format is used.
TF.js provides a range of options to deploy your machine learning models:
@@ -42,9 +42,9 @@ TF.js provides a range of options to deploy your machine learning models:
- **Chrome Extensions:** An interesting deployment scenario is the creation of Chrome extensions with TensorFlow.js. For instance, you can develop an extension that allows users to right-click on an image within any webpage to classify it using a pre-trained ML model. TensorFlow.js can be integrated into everyday web browsing experiences to provide immediate insights or augmentations based on machine learning.
-## Exporting YOLOv8 Models to TensorFlow.js
+## Exporting YOLO11 Models to TensorFlow.js
-You can expand model compatibility and deployment flexibility by converting YOLOv8 models to TF.js.
+You can expand model compatibility and deployment flexibility by converting YOLO11 models to TF.js.
### Installation
@@ -55,15 +55,15 @@ To install the required package, run:
=== "CLI"
```bash
- # Install the required package for YOLOv8
+ # Install the required package for YOLO11
pip install ultralytics
```
-For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLOv8, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
+For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLO11, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
### Usage
-Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLOv8 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
+Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLO11 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
!!! example "Usage"
@@ -72,14 +72,14 @@ Before diving into the usage instructions, it's important to note that while all
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TF.js format
- model.export(format="tfjs") # creates '/yolov8n_web_model'
+ model.export(format="tfjs") # creates '/yolo11n_web_model'
# Load the exported TF.js model
- tfjs_model = YOLO("./yolov8n_web_model")
+ tfjs_model = YOLO("./yolo11n_web_model")
# Run inference
results = tfjs_model("https://ultralytics.com/images/bus.jpg")
@@ -88,18 +88,18 @@ Before diving into the usage instructions, it's important to note that while all
=== "CLI"
```bash
- # Export a YOLOv8n PyTorch model to TF.js format
- yolo export model=yolov8n.pt format=tfjs # creates '/yolov8n_web_model'
+ # Export a YOLO11n PyTorch model to TF.js format
+ yolo export model=yolo11n.pt format=tfjs # creates '/yolo11n_web_model'
# Run inference with the exported model
- yolo predict model='./yolov8n_web_model' source='https://ultralytics.com/images/bus.jpg'
+ yolo predict model='./yolo11n_web_model' source='https://ultralytics.com/images/bus.jpg'
```
For more details about supported export options, visit the [Ultralytics documentation page on deployment options](../guides/model-deployment-options.md).
-## Deploying Exported YOLOv8 TensorFlow.js Models
+## Deploying Exported YOLO11 TensorFlow.js Models
-Now that you have exported your YOLOv8 model to the TF.js format, the next step is to deploy it. The primary and recommended first step for running a TF.js is to use the YOLO("./yolov8n_web_model") method, as previously shown in the usage code snippet.
+Now that you have exported your YOLO11 model to the TF.js format, the next step is to deploy it. The primary and recommended first step for running a TF.js is to use the `YOLO("./yolo11n_web_model")` method, as previously shown in the usage code snippet.
However, for in-depth instructions on deploying your TF.js models, take a look at the following resources:
@@ -111,17 +111,17 @@ However, for in-depth instructions on deploying your TF.js models, take a look a
## Summary
-In this guide, we learned how to export Ultralytics YOLOv8 models to the TensorFlow.js format. By exporting to TF.js, you gain the flexibility to optimize, deploy, and scale your YOLOv8 models on a wide range of platforms.
+In this guide, we learned how to export Ultralytics YOLO11 models to the TensorFlow.js format. By exporting to TF.js, you gain the flexibility to optimize, deploy, and scale your YOLO11 models on a wide range of platforms.
For further details on usage, visit the [TensorFlow.js official documentation](https://www.tensorflow.org/js/guide).
-For more information on integrating Ultralytics YOLOv8 with other platforms and frameworks, don't forget to check out our [integration guide page](index.md). It's packed with great resources to help you make the most of YOLOv8 in your projects.
+For more information on integrating Ultralytics YOLO11 with other platforms and frameworks, don't forget to check out our [integration guide page](index.md). It's packed with great resources to help you make the most of YOLO11 in your projects.
## FAQ
-### How do I export Ultralytics YOLOv8 models to TensorFlow.js format?
+### How do I export Ultralytics YOLO11 models to TensorFlow.js format?
-Exporting Ultralytics YOLOv8 models to TensorFlow.js (TF.js) format is straightforward. You can follow these steps:
+Exporting Ultralytics YOLO11 models to TensorFlow.js (TF.js) format is straightforward. You can follow these steps:
!!! example "Usage"
@@ -130,14 +130,14 @@ Exporting Ultralytics YOLOv8 models to TensorFlow.js (TF.js) format is straightf
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TF.js format
- model.export(format="tfjs") # creates '/yolov8n_web_model'
+ model.export(format="tfjs") # creates '/yolo11n_web_model'
# Load the exported TF.js model
- tfjs_model = YOLO("./yolov8n_web_model")
+ tfjs_model = YOLO("./yolo11n_web_model")
# Run inference
results = tfjs_model("https://ultralytics.com/images/bus.jpg")
@@ -146,18 +146,18 @@ Exporting Ultralytics YOLOv8 models to TensorFlow.js (TF.js) format is straightf
=== "CLI"
```bash
- # Export a YOLOv8n PyTorch model to TF.js format
- yolo export model=yolov8n.pt format=tfjs # creates '/yolov8n_web_model'
+ # Export a YOLO11n PyTorch model to TF.js format
+ yolo export model=yolo11n.pt format=tfjs # creates '/yolo11n_web_model'
# Run inference with the exported model
- yolo predict model='./yolov8n_web_model' source='https://ultralytics.com/images/bus.jpg'
+ yolo predict model='./yolo11n_web_model' source='https://ultralytics.com/images/bus.jpg'
```
For more details about supported export options, visit the [Ultralytics documentation page on deployment options](../guides/model-deployment-options.md).
-### Why should I export my YOLOv8 models to TensorFlow.js?
+### Why should I export my YOLO11 models to TensorFlow.js?
-Exporting YOLOv8 models to TensorFlow.js offers several advantages, including:
+Exporting YOLO11 models to TensorFlow.js offers several advantages, including:
1. **Local Execution:** Models can run directly in the browser or Node.js, reducing latency and enhancing user experience.
2. **Cross-Platform Support:** TF.js supports multiple environments, allowing flexibility in deployment.
@@ -177,7 +177,7 @@ TensorFlow.js is specifically designed for efficient execution of ML models in b
Interested in learning more about TF.js? Check out the [official TensorFlow.js guide](https://www.tensorflow.org/js/guide).
-### What are the key features of TensorFlow.js for deploying YOLOv8 models?
+### What are the key features of TensorFlow.js for deploying YOLO11 models?
Key features of TensorFlow.js include:
@@ -185,10 +185,10 @@ Key features of TensorFlow.js include:
- **Multiple Backends:** Supports CPU, WebGL for GPU acceleration, WebAssembly (WASM), and WebGPU for advanced operations.
- **Offline Capabilities:** Models can run directly in the browser without internet connectivity, making it ideal for developing responsive web applications.
-For deployment scenarios and more in-depth information, see our section on [Deployment Options with TensorFlow.js](#deploying-exported-yolov8-tensorflowjs-models).
+For deployment scenarios and more in-depth information, see our section on [Deployment Options with TensorFlow.js](#deploying-exported-yolo11-tensorflowjs-models).
-### Can I deploy a YOLOv8 model on server-side Node.js applications using TensorFlow.js?
+### Can I deploy a YOLO11 model on server-side Node.js applications using TensorFlow.js?
-Yes, TensorFlow.js allows the deployment of YOLOv8 models on Node.js environments. This enables server-side machine learning applications that benefit from the processing power of a server and access to server-side data. Typical use cases include real-time data processing and machine learning pipelines on backend servers.
+Yes, TensorFlow.js allows the deployment of YOLO11 models on Node.js environments. This enables server-side machine learning applications that benefit from the processing power of a server and access to server-side data. Typical use cases include real-time data processing and machine learning pipelines on backend servers.
To get started with Node.js deployment, refer to the [Run TensorFlow.js in Node.js](https://www.tensorflow.org/js/guide/nodejs) guide from TensorFlow.
diff --git a/docs/en/integrations/tflite.md b/docs/en/integrations/tflite.md
index 028675eabb..9f0ebad156 100644
--- a/docs/en/integrations/tflite.md
+++ b/docs/en/integrations/tflite.md
@@ -1,10 +1,10 @@
---
comments: true
-description: Learn how to convert YOLOv8 models to TFLite for edge device deployment. Optimize performance and ensure seamless execution on various platforms.
-keywords: YOLOv8, TFLite, model export, TensorFlow Lite, edge devices, deployment, Ultralytics, machine learning, on-device inference, model optimization
+description: Learn how to convert YOLO11 models to TFLite for edge device deployment. Optimize performance and ensure seamless execution on various platforms.
+keywords: YOLO11, TFLite, model export, TensorFlow Lite, edge devices, deployment, Ultralytics, machine learning, on-device inference, model optimization
---
-# A Guide on YOLOv8 Model Export to TFLite for Deployment
+# A Guide on YOLO11 Model Export to TFLite for Deployment
@@ -12,7 +12,7 @@ keywords: YOLOv8, TFLite, model export, TensorFlow Lite, edge devices, deploymen
Deploying [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models on edge devices or embedded devices requires a format that can ensure seamless performance.
-The TensorFlow Lite or TFLite export format allows you to optimize your [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) models for tasks like [object detection](https://www.ultralytics.com/glossary/object-detection) and [image classification](https://www.ultralytics.com/glossary/image-classification) in edge device-based applications. In this guide, we'll walk through the steps for converting your models to the TFLite format, making it easier for your models to perform well on various edge devices.
+The TensorFlow Lite or TFLite export format allows you to optimize your [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics) models for tasks like [object detection](https://www.ultralytics.com/glossary/object-detection) and [image classification](https://www.ultralytics.com/glossary/image-classification) in edge device-based applications. In this guide, we'll walk through the steps for converting your models to the TFLite format, making it easier for your models to perform well on various edge devices.
## Why should you export to TFLite?
@@ -34,7 +34,7 @@ TFLite models offer a wide range of key features that enable on-device machine l
## Deployment Options in TFLite
-Before we look at the code for exporting YOLOv8 models to the TFLite format, let's understand how TFLite models are normally used.
+Before we look at the code for exporting YOLO11 models to the TFLite format, let's understand how TFLite models are normally used.
TFLite offers various on-device deployment options for machine learning models, including:
@@ -48,7 +48,7 @@ TFLite offers various on-device deployment options for machine learning models,
- **Deploying with Microcontrollers**: TFLite models can also be deployed on microcontrollers and other devices with only a few kilobytes of memory. The core runtime just fits in 16 KB on an Arm Cortex M3 and can run many basic models. It doesn't require operating system support, any standard C or C++ libraries, or dynamic memory allocation.
-## Export to TFLite: Converting Your YOLOv8 Model
+## Export to TFLite: Converting Your YOLO11 Model
You can improve on-device model execution efficiency and optimize performance by converting them to TFLite format.
@@ -61,15 +61,15 @@ To install the required packages, run:
=== "CLI"
```bash
- # Install the required package for YOLOv8
+ # Install the required package for YOLO11
pip install ultralytics
```
-For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLOv8, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
+For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLO11, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
### Usage
-Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLOv8 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
+Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLO11 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
!!! example "Usage"
@@ -78,14 +78,14 @@ Before diving into the usage instructions, it's important to note that while all
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TFLite format
- model.export(format="tflite") # creates 'yolov8n_float32.tflite'
+ model.export(format="tflite") # creates 'yolo11n_float32.tflite'
# Load the exported TFLite model
- tflite_model = YOLO("yolov8n_float32.tflite")
+ tflite_model = YOLO("yolo11n_float32.tflite")
# Run inference
results = tflite_model("https://ultralytics.com/images/bus.jpg")
@@ -94,18 +94,18 @@ Before diving into the usage instructions, it's important to note that while all
=== "CLI"
```bash
- # Export a YOLOv8n PyTorch model to TFLite format
- yolo export model=yolov8n.pt format=tflite # creates 'yolov8n_float32.tflite'
+ # Export a YOLO11n PyTorch model to TFLite format
+ yolo export model=yolo11n.pt format=tflite # creates 'yolo11n_float32.tflite'
# Run inference with the exported model
- yolo predict model='yolov8n_float32.tflite' source='https://ultralytics.com/images/bus.jpg'
+ yolo predict model='yolo11n_float32.tflite' source='https://ultralytics.com/images/bus.jpg'
```
For more details about the export process, visit the [Ultralytics documentation page on exporting](../modes/export.md).
-## Deploying Exported YOLOv8 TFLite Models
+## Deploying Exported YOLO11 TFLite Models
-After successfully exporting your Ultralytics YOLOv8 models to TFLite format, you can now deploy them. The primary and recommended first step for running a TFLite model is to utilize the YOLO("model.tflite") method, as outlined in the previous usage code snippet. However, for in-depth instructions on deploying your TFLite models in various other settings, take a look at the following resources:
+After successfully exporting your Ultralytics YOLO11 models to TFLite format, you can now deploy them. The primary and recommended first step for running a TFLite model is to utilize the YOLO("model.tflite") method, as outlined in the previous usage code snippet. However, for in-depth instructions on deploying your TFLite models in various other settings, take a look at the following resources:
- **[Android](https://ai.google.dev/edge/litert/android)**: A quick start guide for integrating [TensorFlow](https://www.ultralytics.com/glossary/tensorflow) Lite into Android applications, providing easy-to-follow steps for setting up and running [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models.
@@ -115,17 +115,17 @@ After successfully exporting your Ultralytics YOLOv8 models to TFLite format, yo
## Summary
-In this guide, we focused on how to export to TFLite format. By converting your Ultralytics YOLOv8 models to TFLite model format, you can improve the efficiency and speed of YOLOv8 models, making them more effective and suitable for [edge computing](https://www.ultralytics.com/glossary/edge-computing) environments.
+In this guide, we focused on how to export to TFLite format. By converting your Ultralytics YOLO11 models to TFLite model format, you can improve the efficiency and speed of YOLO11 models, making them more effective and suitable for [edge computing](https://www.ultralytics.com/glossary/edge-computing) environments.
For further details on usage, visit the [TFLite official documentation](https://ai.google.dev/edge/litert).
-Also, if you're curious about other Ultralytics YOLOv8 integrations, make sure to check out our [integration guide page](../integrations/index.md). You'll find tons of helpful info and insights waiting for you there.
+Also, if you're curious about other Ultralytics YOLO11 integrations, make sure to check out our [integration guide page](../integrations/index.md). You'll find tons of helpful info and insights waiting for you there.
## FAQ
-### How do I export a YOLOv8 model to TFLite format?
+### How do I export a YOLO11 model to TFLite format?
-To export a YOLOv8 model to TFLite format, you can use the Ultralytics library. First, install the required package using:
+To export a YOLO11 model to TFLite format, you can use the Ultralytics library. First, install the required package using:
```bash
pip install ultralytics
@@ -136,24 +136,24 @@ Then, use the following code snippet to export your model:
```python
from ultralytics import YOLO
-# Load the YOLOv8 model
-model = YOLO("yolov8n.pt")
+# Load the YOLO11 model
+model = YOLO("yolo11n.pt")
# Export the model to TFLite format
-model.export(format="tflite") # creates 'yolov8n_float32.tflite'
+model.export(format="tflite") # creates 'yolo11n_float32.tflite'
```
For CLI users, you can achieve this with:
```bash
-yolo export model=yolov8n.pt format=tflite # creates 'yolov8n_float32.tflite'
+yolo export model=yolo11n.pt format=tflite # creates 'yolo11n_float32.tflite'
```
For more details, visit the [Ultralytics export guide](../modes/export.md).
-### What are the benefits of using TensorFlow Lite for YOLOv8 [model deployment](https://www.ultralytics.com/glossary/model-deployment)?
+### What are the benefits of using TensorFlow Lite for YOLO11 [model deployment](https://www.ultralytics.com/glossary/model-deployment)?
-TensorFlow Lite (TFLite) is an open-source [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) framework designed for on-device inference, making it ideal for deploying YOLOv8 models on mobile, embedded, and IoT devices. Key benefits include:
+TensorFlow Lite (TFLite) is an open-source [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) framework designed for on-device inference, making it ideal for deploying YOLO11 models on mobile, embedded, and IoT devices. Key benefits include:
- **On-device optimization**: Minimize latency and enhance privacy by processing data locally.
- **Platform compatibility**: Supports Android, iOS, embedded Linux, and MCU.
@@ -161,33 +161,33 @@ TensorFlow Lite (TFLite) is an open-source [deep learning](https://www.ultralyti
To learn more, check out the [TFLite guide](https://ai.google.dev/edge/litert).
-### Is it possible to run YOLOv8 TFLite models on Raspberry Pi?
+### Is it possible to run YOLO11 TFLite models on Raspberry Pi?
-Yes, you can run YOLOv8 TFLite models on Raspberry Pi to improve inference speeds. First, export your model to TFLite format as explained [here](#how-do-i-export-a-yolov8-model-to-tflite-format). Then, use a tool like TensorFlow Lite Interpreter to execute the model on your Raspberry Pi.
+Yes, you can run YOLO11 TFLite models on Raspberry Pi to improve inference speeds. First, export your model to TFLite format as explained [here](#how-do-i-export-a-yolo11-model-to-tflite-format). Then, use a tool like TensorFlow Lite Interpreter to execute the model on your Raspberry Pi.
For further optimizations, you might consider using [Coral Edge TPU](https://coral.withgoogle.com/). For detailed steps, refer to our [Raspberry Pi deployment guide](../guides/raspberry-pi.md).
-### Can I use TFLite models on microcontrollers for YOLOv8 predictions?
+### Can I use TFLite models on microcontrollers for YOLO11 predictions?
-Yes, TFLite supports deployment on microcontrollers with limited resources. TFLite's core runtime requires only 16 KB of memory on an Arm Cortex M3 and can run basic YOLOv8 models. This makes it suitable for deployment on devices with minimal computational power and memory.
+Yes, TFLite supports deployment on microcontrollers with limited resources. TFLite's core runtime requires only 16 KB of memory on an Arm Cortex M3 and can run basic YOLO11 models. This makes it suitable for deployment on devices with minimal computational power and memory.
To get started, visit the [TFLite Micro for Microcontrollers guide](https://ai.google.dev/edge/litert/microcontrollers/overview).
-### What platforms are compatible with TFLite exported YOLOv8 models?
+### What platforms are compatible with TFLite exported YOLO11 models?
-TensorFlow Lite provides extensive platform compatibility, allowing you to deploy YOLOv8 models on a wide range of devices, including:
+TensorFlow Lite provides extensive platform compatibility, allowing you to deploy YOLO11 models on a wide range of devices, including:
- **Android and iOS**: Native support through TFLite Android and iOS libraries.
- **Embedded Linux**: Ideal for single-board computers such as Raspberry Pi.
- **Microcontrollers**: Suitable for MCUs with constrained resources.
-For more information on deployment options, see our detailed [deployment guide](#deploying-exported-yolov8-tflite-models).
+For more information on deployment options, see our detailed [deployment guide](#deploying-exported-yolo11-tflite-models).
-### How do I troubleshoot common issues during YOLOv8 model export to TFLite?
+### How do I troubleshoot common issues during YOLO11 model export to TFLite?
-If you encounter errors while exporting YOLOv8 models to TFLite, common solutions include:
+If you encounter errors while exporting YOLO11 models to TFLite, common solutions include:
- **Check package compatibility**: Ensure you're using compatible versions of Ultralytics and TensorFlow. Refer to our [installation guide](../quickstart.md).
-- **Model support**: Verify that the specific YOLOv8 model supports TFLite export by checking [here](../modes/export.md).
+- **Model support**: Verify that the specific YOLO11 model supports TFLite export by checking [here](../modes/export.md).
For additional troubleshooting tips, visit our [Common Issues guide](../guides/yolo-common-issues.md).
diff --git a/docs/en/integrations/torchscript.md b/docs/en/integrations/torchscript.md
index 839caff921..1be1516c0b 100644
--- a/docs/en/integrations/torchscript.md
+++ b/docs/en/integrations/torchscript.md
@@ -1,22 +1,22 @@
---
comments: true
-description: Learn how to export Ultralytics YOLOv8 models to TorchScript for flexible, cross-platform deployment. Boost performance and utilize in various environments.
-keywords: YOLOv8, TorchScript, model export, Ultralytics, PyTorch, deep learning, AI deployment, cross-platform, performance optimization
+description: Learn how to export Ultralytics YOLO11 models to TorchScript for flexible, cross-platform deployment. Boost performance and utilize in various environments.
+keywords: YOLO11, TorchScript, model export, Ultralytics, PyTorch, deep learning, AI deployment, cross-platform, performance optimization
---
-# YOLOv8 Model Export to TorchScript for Quick Deployment
+# YOLO11 Model Export to TorchScript for Quick Deployment
Deploying [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) models across different environments, including embedded systems, web browsers, or platforms with limited Python support, requires a flexible and portable solution. TorchScript focuses on portability and the ability to run models in environments where the entire Python framework is unavailable. This makes it ideal for scenarios where you need to deploy your computer vision capabilities across various devices or platforms.
-Export to Torchscript to serialize your [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) models for cross-platform compatibility and streamlined deployment. In this guide, we'll show you how to export your YOLOv8 models to the TorchScript format, making it easier for you to use them across a wider range of applications.
+Export to Torchscript to serialize your [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics) models for cross-platform compatibility and streamlined deployment. In this guide, we'll show you how to export your YOLO11 models to the TorchScript format, making it easier for you to use them across a wider range of applications.
## Why should you export to TorchScript?
-Developed by the creators of PyTorch, TorchScript is a powerful tool for optimizing and deploying PyTorch models across a variety of platforms. Exporting YOLOv8 models to [TorchScript](https://pytorch.org/docs/stable/jit.html) is crucial for moving from research to real-world applications. TorchScript, part of the PyTorch framework, helps make this transition smoother by allowing PyTorch models to be used in environments that don't support Python.
+Developed by the creators of PyTorch, TorchScript is a powerful tool for optimizing and deploying PyTorch models across a variety of platforms. Exporting YOLO11 models to [TorchScript](https://pytorch.org/docs/stable/jit.html) is crucial for moving from research to real-world applications. TorchScript, part of the PyTorch framework, helps make this transition smoother by allowing PyTorch models to be used in environments that don't support Python.
-The process involves two techniques: tracing and scripting. Tracing records operations during model execution, while scripting allows for the definition of models using a subset of Python. These techniques ensure that models like YOLOv8 can still work their magic even outside their usual Python environment.
+The process involves two techniques: tracing and scripting. Tracing records operations during model execution, while scripting allows for the definition of models using a subset of Python. These techniques ensure that models like YOLO11 can still work their magic even outside their usual Python environment.
@@ -42,7 +42,7 @@ Here are the key features that make TorchScript a valuable tool for developers:
## Deployment Options in TorchScript
-Before we look at the code for exporting YOLOv8 models to the TorchScript format, let's understand where TorchScript models are normally used.
+Before we look at the code for exporting YOLO11 models to the TorchScript format, let's understand where TorchScript models are normally used.
TorchScript offers various deployment options for [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models, such as:
@@ -52,9 +52,9 @@ TorchScript offers various deployment options for [machine learning](https://www
- **Cloud Deployment**: TorchScript models can be deployed to cloud-based servers using solutions like TorchServe. It provides features like model versioning, batching, and metrics monitoring for scalable deployment in production environments. Cloud deployment with TorchScript can make your models accessible via APIs or other web services.
-## Export to TorchScript: Converting Your YOLOv8 Model
+## Export to TorchScript: Converting Your YOLO11 Model
-Exporting YOLOv8 models to TorchScript makes it easier to use them in different places and helps them run faster and more efficiently. This is great for anyone looking to use deep learning models more effectively in real-world applications.
+Exporting YOLO11 models to TorchScript makes it easier to use them in different places and helps them run faster and more efficiently. This is great for anyone looking to use deep learning models more effectively in real-world applications.
### Installation
@@ -65,15 +65,15 @@ To install the required package, run:
=== "CLI"
```bash
- # Install the required package for YOLOv8
+ # Install the required package for YOLO11
pip install ultralytics
```
-For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLOv8, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
+For detailed instructions and best practices related to the installation process, check our [Ultralytics Installation guide](../quickstart.md). While installing the required packages for YOLO11, if you encounter any difficulties, consult our [Common Issues guide](../guides/yolo-common-issues.md) for solutions and tips.
### Usage
-Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLOv8 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
+Before diving into the usage instructions, it's important to note that while all [Ultralytics YOLO11 models](../models/index.md) are available for exporting, you can ensure that the model you select supports export functionality [here](../modes/export.md).
!!! example "Usage"
@@ -82,14 +82,14 @@ Before diving into the usage instructions, it's important to note that while all
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TorchScript format
- model.export(format="torchscript") # creates 'yolov8n.torchscript'
+ model.export(format="torchscript") # creates 'yolo11n.torchscript'
# Load the exported TorchScript model
- torchscript_model = YOLO("yolov8n.torchscript")
+ torchscript_model = YOLO("yolo11n.torchscript")
# Run inference
results = torchscript_model("https://ultralytics.com/images/bus.jpg")
@@ -98,18 +98,18 @@ Before diving into the usage instructions, it's important to note that while all
=== "CLI"
```bash
- # Export a YOLOv8n PyTorch model to TorchScript format
- yolo export model=yolov8n.pt format=torchscript # creates 'yolov8n.torchscript'
+ # Export a YOLO11n PyTorch model to TorchScript format
+ yolo export model=yolo11n.pt format=torchscript # creates 'yolo11n.torchscript'
# Run inference with the exported model
- yolo predict model=yolov8n.torchscript source='https://ultralytics.com/images/bus.jpg'
+ yolo predict model=yolo11n.torchscript source='https://ultralytics.com/images/bus.jpg'
```
For more details about the export process, visit the [Ultralytics documentation page on exporting](../modes/export.md).
-## Deploying Exported YOLOv8 TorchScript Models
+## Deploying Exported YOLO11 TorchScript Models
-After successfully exporting your Ultralytics YOLOv8 models to TorchScript format, you can now deploy them. The primary and recommended first step for running a TorchScript model is to utilize the YOLO("model.torchscript") method, as outlined in the previous usage code snippet. However, for in-depth instructions on deploying your TorchScript models in various other settings, take a look at the following resources:
+After successfully exporting your Ultralytics YOLO11 models to TorchScript format, you can now deploy them. The primary and recommended first step for running a TorchScript model is to utilize the YOLO("model.torchscript") method, as outlined in the previous usage code snippet. However, for in-depth instructions on deploying your TorchScript models in various other settings, take a look at the following resources:
- **[Explore Mobile Deployment](https://pytorch.org/mobile/home/)**: The [PyTorch](https://www.ultralytics.com/glossary/pytorch) Mobile Documentation provides comprehensive guidelines for deploying models on mobile devices, ensuring your applications are efficient and responsive.
@@ -119,21 +119,21 @@ After successfully exporting your Ultralytics YOLOv8 models to TorchScript forma
## Summary
-In this guide, we explored the process of exporting Ultralytics YOLOv8 models to the TorchScript format. By following the provided instructions, you can optimize YOLOv8 models for performance and gain the flexibility to deploy them across various platforms and environments.
+In this guide, we explored the process of exporting Ultralytics YOLO11 models to the TorchScript format. By following the provided instructions, you can optimize YOLO11 models for performance and gain the flexibility to deploy them across various platforms and environments.
For further details on usage, visit [TorchScript's official documentation](https://pytorch.org/docs/stable/jit.html).
-Also, if you'd like to know more about other Ultralytics YOLOv8 integrations, visit our [integration guide page](../integrations/index.md). You'll find plenty of useful resources and insights there.
+Also, if you'd like to know more about other Ultralytics YOLO11 integrations, visit our [integration guide page](../integrations/index.md). You'll find plenty of useful resources and insights there.
## FAQ
-### What is Ultralytics YOLOv8 model export to TorchScript?
+### What is Ultralytics YOLO11 model export to TorchScript?
-Exporting an Ultralytics YOLOv8 model to TorchScript allows for flexible, cross-platform deployment. TorchScript, a part of the PyTorch ecosystem, facilitates the serialization of models, which can then be executed in environments that lack Python support. This makes it ideal for deploying models on embedded systems, C++ environments, mobile applications, and even web browsers. Exporting to TorchScript enables efficient performance and wider applicability of your YOLOv8 models across diverse platforms.
+Exporting an Ultralytics YOLO11 model to TorchScript allows for flexible, cross-platform deployment. TorchScript, a part of the PyTorch ecosystem, facilitates the serialization of models, which can then be executed in environments that lack Python support. This makes it ideal for deploying models on embedded systems, C++ environments, mobile applications, and even web browsers. Exporting to TorchScript enables efficient performance and wider applicability of your YOLO11 models across diverse platforms.
-### How can I export my YOLOv8 model to TorchScript using Ultralytics?
+### How can I export my YOLO11 model to TorchScript using Ultralytics?
-To export a YOLOv8 model to TorchScript, you can use the following example code:
+To export a YOLO11 model to TorchScript, you can use the following example code:
!!! example "Usage"
@@ -142,14 +142,14 @@ To export a YOLOv8 model to TorchScript, you can use the following example code:
```python
from ultralytics import YOLO
- # Load the YOLOv8 model
- model = YOLO("yolov8n.pt")
+ # Load the YOLO11 model
+ model = YOLO("yolo11n.pt")
# Export the model to TorchScript format
- model.export(format="torchscript") # creates 'yolov8n.torchscript'
+ model.export(format="torchscript") # creates 'yolo11n.torchscript'
# Load the exported TorchScript model
- torchscript_model = YOLO("yolov8n.torchscript")
+ torchscript_model = YOLO("yolo11n.torchscript")
# Run inference
results = torchscript_model("https://ultralytics.com/images/bus.jpg")
@@ -158,18 +158,18 @@ To export a YOLOv8 model to TorchScript, you can use the following example code:
=== "CLI"
```bash
- # Export a YOLOv8n PyTorch model to TorchScript format
- yolo export model=yolov8n.pt format=torchscript # creates 'yolov8n.torchscript'
+ # Export a YOLO11n PyTorch model to TorchScript format
+ yolo export model=yolo11n.pt format=torchscript # creates 'yolo11n.torchscript'
# Run inference with the exported model
- yolo predict model=yolov8n.torchscript source='https://ultralytics.com/images/bus.jpg'
+ yolo predict model=yolo11n.torchscript source='https://ultralytics.com/images/bus.jpg'
```
For more details about the export process, refer to the [Ultralytics documentation on exporting](../modes/export.md).
-### Why should I use TorchScript for deploying YOLOv8 models?
+### Why should I use TorchScript for deploying YOLO11 models?
-Using TorchScript for deploying YOLOv8 models offers several advantages:
+Using TorchScript for deploying YOLO11 models offers several advantages:
- **Portability**: Exported models can run in environments without the need for Python, such as C++ applications, embedded systems, or mobile devices.
- **Optimization**: TorchScript supports static graph execution and Just-In-Time (JIT) compilation, which can optimize model performance.
@@ -178,24 +178,24 @@ Using TorchScript for deploying YOLOv8 models offers several advantages:
For more insights into deployment, visit the [PyTorch Mobile Documentation](https://pytorch.org/mobile/home/), [TorchServe Documentation](https://pytorch.org/serve/getting_started.html), and [C++ Deployment Guide](https://pytorch.org/tutorials/advanced/cpp_export.html).
-### What are the installation steps for exporting YOLOv8 models to TorchScript?
+### What are the installation steps for exporting YOLO11 models to TorchScript?
-To install the required package for exporting YOLOv8 models, use the following command:
+To install the required package for exporting YOLO11 models, use the following command:
!!! tip "Installation"
=== "CLI"
```bash
- # Install the required package for YOLOv8
+ # Install the required package for YOLO11
pip install ultralytics
```
For detailed instructions, visit the [Ultralytics Installation guide](../quickstart.md). If any issues arise during installation, consult the [Common Issues guide](../guides/yolo-common-issues.md).
-### How do I deploy my exported TorchScript YOLOv8 models?
+### How do I deploy my exported TorchScript YOLO11 models?
-After exporting YOLOv8 models to the TorchScript format, you can deploy them across a variety of platforms:
+After exporting YOLO11 models to the TorchScript format, you can deploy them across a variety of platforms:
- **C++ API**: Ideal for low-overhead, highly efficient production environments.
- **Mobile Deployment**: Use [PyTorch Mobile](https://pytorch.org/mobile/home/) for iOS and Android applications.
diff --git a/docs/en/integrations/vscode.md b/docs/en/integrations/vscode.md
index b6785d1529..521abde311 100644
--- a/docs/en/integrations/vscode.md
+++ b/docs/en/integrations/vscode.md
@@ -134,7 +134,7 @@ The `ultra.examples` snippets are to useful for anyone looking to learn how to g
```python
from ultralytics import ASSETS, YOLO
- model = YOLO("yolov8n.pt", task="detect")
+ model = YOLO("yolo11n.pt", task="detect")
results = model(source=ASSETS / "bus.jpg")
for result in results:
diff --git a/docs/en/integrations/weights-biases.md b/docs/en/integrations/weights-biases.md
index cb9dc95131..9f2cbb2fa0 100644
--- a/docs/en/integrations/weights-biases.md
+++ b/docs/en/integrations/weights-biases.md
@@ -1,12 +1,12 @@
---
comments: true
-description: Learn how to enhance YOLOv8 experiment tracking and visualization with Weights & Biases for better model performance and management.
-keywords: YOLOv8, Weights & Biases, model training, experiment tracking, Ultralytics, machine learning, computer vision, model visualization
+description: Learn how to enhance YOLO11 experiment tracking and visualization with Weights & Biases for better model performance and management.
+keywords: YOLO11, Weights & Biases, model training, experiment tracking, Ultralytics, machine learning, computer vision, model visualization
---
-# Enhancing YOLOv8 Experiment Tracking and Visualization with Weights & Biases
+# Enhancing YOLO11 Experiment Tracking and Visualization with Weights & Biases
-[Object detection](https://www.ultralytics.com/glossary/object-detection) models like [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) have become integral to many [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) applications. However, training, evaluating, and deploying these complex models introduces several challenges. Tracking key training metrics, comparing model variants, analyzing model behavior, and detecting issues require substantial instrumentation and experiment management.
+[Object detection](https://www.ultralytics.com/glossary/object-detection) models like [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics) have become integral to many [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) applications. However, training, evaluating, and deploying these complex models introduces several challenges. Tracking key training metrics, comparing model variants, analyzing model behavior, and detecting issues require substantial instrumentation and experiment management.
@@ -16,10 +16,10 @@ keywords: YOLOv8, Weights & Biases, model training, experiment tracking, Ultraly
allowfullscreen>
- Watch: How to use Ultralytics YOLOv8 with Weights and Biases
+ Watch: How to use Ultralytics YOLO11 with Weights and Biases
diff --git a/docs/en/models/mobile-sam.md b/docs/en/models/mobile-sam.md
index 26c92f6829..0d7df2a2ca 100644
--- a/docs/en/models/mobile-sam.md
+++ b/docs/en/models/mobile-sam.md
@@ -4,7 +4,7 @@ description: Discover MobileSAM, a lightweight and fast image segmentation model
keywords: MobileSAM, image segmentation, lightweight model, fast segmentation, mobile applications, SAM, ViT encoder, Tiny-ViT, Ultralytics
---
-
+
# Mobile Segment Anything (MobileSAM)
@@ -12,6 +12,17 @@ The MobileSAM paper is now available on [arXiv](https://arxiv.org/pdf/2306.14289
A demonstration of MobileSAM running on a CPU can be accessed at this [demo link](https://huggingface.co/spaces/dhkim2810/MobileSAM). The performance on a Mac i5 CPU takes approximately 3 seconds. On the Hugging Face demo, the interface and lower-performance CPUs contribute to a slower response, but it continues to function effectively.
+
+
+
+
+ Watch: How to Run Inference with MobileSAM using Ultralytics | Step-by-Step Guide 🎉
+
+
+
+
+ Watch: How to Run Inference with Meta's SAM2 using Ultralytics | Step-by-Step Guide 🎉
+
+
+
+
+ Watch: Ultralytics YOLO11 Announcement at YOLO Vision 2024
+
@@ -50,7 +50,7 @@ Once your model is trained and validated, the next logical step is to evaluate i
## Usage Examples
-Run YOLOv8n benchmarks on all supported export formats including ONNX, TensorRT etc. See Arguments section below for a full list of export arguments.
+Run YOLO11n benchmarks on all supported export formats including ONNX, TensorRT etc. See Arguments section below for a full list of export arguments.
!!! example
@@ -60,13 +60,13 @@ Run YOLOv8n benchmarks on all supported export formats including ONNX, TensorRT
from ultralytics.utils.benchmarks import benchmark
# Benchmark on GPU
- benchmark(model="yolov8n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)
+ benchmark(model="yolo11n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)
```
=== "CLI"
```bash
- yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
+ yolo benchmark model=yolo11n.pt data='coco8.yaml' imgsz=640 half=False device=0
```
## Arguments
@@ -75,7 +75,7 @@ Arguments such as `model`, `data`, `imgsz`, `half`, `device`, and `verbose` prov
| Key | Default Value | Description |
| --------- | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `model` | `None` | Specifies the path to the model file. Accepts both `.pt` and `.yaml` formats, e.g., `"yolov8n.pt"` for pre-trained models or configuration files. |
+| `model` | `None` | Specifies the path to the model file. Accepts both `.pt` and `.yaml` formats, e.g., `"yolo11n.pt"` for pre-trained models or configuration files. |
| `data` | `None` | Path to a YAML file defining the dataset for benchmarking, typically including paths and settings for [validation data](https://www.ultralytics.com/glossary/validation-data). Example: `"coco8.yaml"`. |
| `imgsz` | `640` | The input image size for the model. Can be a single integer for square images or a tuple `(width, height)` for non-square, e.g., `(640, 480)`. |
| `half` | `False` | Enables FP16 (half-precision) inference, reducing memory usage and possibly increasing speed on compatible hardware. Use `half=True` to enable. |
@@ -93,9 +93,9 @@ See full `export` details in the [Export](../modes/export.md) page.
## FAQ
-### How do I benchmark my YOLOv8 model's performance using Ultralytics?
+### How do I benchmark my YOLO11 model's performance using Ultralytics?
-Ultralytics YOLOv8 offers a Benchmark mode to assess your model's performance across different export formats. This mode provides insights into key metrics such as [mean Average Precision](https://www.ultralytics.com/glossary/mean-average-precision-map) (mAP50-95), accuracy, and inference time in milliseconds. To run benchmarks, you can use either Python or CLI commands. For example, to benchmark on a GPU:
+Ultralytics YOLO11 offers a Benchmark mode to assess your model's performance across different export formats. This mode provides insights into key metrics such as [mean Average Precision](https://www.ultralytics.com/glossary/mean-average-precision-map) (mAP50-95), accuracy, and inference time in milliseconds. To run benchmarks, you can use either Python or CLI commands. For example, to benchmark on a GPU:
!!! example
@@ -105,29 +105,29 @@ Ultralytics YOLOv8 offers a Benchmark mode to assess your model's performance ac
from ultralytics.utils.benchmarks import benchmark
# Benchmark on GPU
- benchmark(model="yolov8n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)
+ benchmark(model="yolo11n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)
```
=== "CLI"
```bash
- yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
+ yolo benchmark model=yolo11n.pt data='coco8.yaml' imgsz=640 half=False device=0
```
For more details on benchmark arguments, visit the [Arguments](#arguments) section.
-### What are the benefits of exporting YOLOv8 models to different formats?
+### What are the benefits of exporting YOLO11 models to different formats?
-Exporting YOLOv8 models to different formats such as ONNX, TensorRT, and OpenVINO allows you to optimize performance based on your deployment environment. For instance:
+Exporting YOLO11 models to different formats such as ONNX, TensorRT, and OpenVINO allows you to optimize performance based on your deployment environment. For instance:
- **ONNX:** Provides up to 3x CPU speedup.
- **TensorRT:** Offers up to 5x GPU speedup.
- **OpenVINO:** Specifically optimized for Intel hardware.
These formats enhance both the speed and accuracy of your models, making them more efficient for various real-world applications. Visit the [Export](../modes/export.md) page for complete details.
-### Why is benchmarking crucial in evaluating YOLOv8 models?
+### Why is benchmarking crucial in evaluating YOLO11 models?
-Benchmarking your YOLOv8 models is essential for several reasons:
+Benchmarking your YOLO11 models is essential for several reasons:
- **Informed Decisions:** Understand the trade-offs between speed and accuracy.
- **Resource Allocation:** Gauge the performance across different hardware options.
@@ -135,9 +135,9 @@ Benchmarking your YOLOv8 models is essential for several reasons:
- **Cost Efficiency:** Optimize hardware usage based on benchmark results.
Key metrics such as mAP50-95, Top-5 accuracy, and inference time help in making these evaluations. Refer to the [Key Metrics](#key-metrics-in-benchmark-mode) section for more information.
-### Which export formats are supported by YOLOv8, and what are their advantages?
+### Which export formats are supported by YOLO11, and what are their advantages?
-YOLOv8 supports a variety of export formats, each tailored for specific hardware and use cases:
+YOLO11 supports a variety of export formats, each tailored for specific hardware and use cases:
- **ONNX:** Best for CPU performance.
- **TensorRT:** Ideal for GPU efficiency.
@@ -145,11 +145,11 @@ YOLOv8 supports a variety of export formats, each tailored for specific hardware
- **CoreML & [TensorFlow](https://www.ultralytics.com/glossary/tensorflow):** Useful for iOS and general ML applications.
For a complete list of supported formats and their respective advantages, check out the [Supported Export Formats](#supported-export-formats) section.
-### What arguments can I use to fine-tune my YOLOv8 benchmarks?
+### What arguments can I use to fine-tune my YOLO11 benchmarks?
When running benchmarks, several arguments can be customized to suit specific needs:
-- **model:** Path to the model file (e.g., "yolov8n.pt").
+- **model:** Path to the model file (e.g., "yolo11n.pt").
- **data:** Path to a YAML file defining the dataset (e.g., "coco8.yaml").
- **imgsz:** The input image size, either as a single integer or a tuple.
- **half:** Enable FP16 inference for better performance.
diff --git a/docs/en/modes/export.md b/docs/en/modes/export.md
index 706dd91cdc..4be5bd5b90 100644
--- a/docs/en/modes/export.md
+++ b/docs/en/modes/export.md
@@ -1,7 +1,7 @@
---
comments: true
-description: Learn how to export your YOLOv8 model to various formats like ONNX, TensorRT, and CoreML. Achieve maximum compatibility and performance.
-keywords: YOLOv8, Model Export, ONNX, TensorRT, CoreML, Ultralytics, AI, Machine Learning, Inference, Deployment
+description: Learn how to export your YOLO11 model to various formats like ONNX, TensorRT, and CoreML. Achieve maximum compatibility and performance.
+keywords: YOLO11, Model Export, ONNX, TensorRT, CoreML, Ultralytics, AI, Machine Learning, Inference, Deployment
---
# Model Export with Ultralytics YOLO
@@ -10,7 +10,7 @@ keywords: YOLOv8, Model Export, ONNX, TensorRT, CoreML, Ultralytics, AI, Machine
## Introduction
-The ultimate goal of training a model is to deploy it for real-world applications. Export mode in Ultralytics YOLOv8 offers a versatile range of options for exporting your trained model to different formats, making it deployable across various platforms and devices. This comprehensive guide aims to walk you through the nuances of model exporting, showcasing how to achieve maximum compatibility and performance.
+The ultimate goal of training a model is to deploy it for real-world applications. Export mode in Ultralytics YOLO11 offers a versatile range of options for exporting your trained model to different formats, making it deployable across various platforms and devices. This comprehensive guide aims to walk you through the nuances of model exporting, showcasing how to achieve maximum compatibility and performance.
@@ -20,10 +20,10 @@ The ultimate goal of training a model is to deploy it for real-world application
allowfullscreen>
- Watch: How To Export Custom Trained Ultralytics YOLOv8 Model and Run Live Inference on Webcam.
+ Watch: How To Export Custom Trained Ultralytics YOLO Model and Run Live Inference on Webcam.
## Introduction
-Ultralytics YOLOv8 is not just another object detection model; it's a versatile framework designed to cover the entire lifecycle of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models—from data ingestion and model training to validation, deployment, and real-world tracking. Each mode serves a specific purpose and is engineered to offer you the flexibility and efficiency required for different tasks and use-cases.
+Ultralytics YOLO11 is not just another object detection model; it's a versatile framework designed to cover the entire lifecycle of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) models—from data ingestion and model training to validation, deployment, and real-world tracking. Each mode serves a specific purpose and is engineered to offer you the flexibility and efficiency required for different tasks and use-cases.
@@ -25,7 +25,7 @@ Ultralytics YOLOv8 is not just another object detection model; it's a versatile
### Modes at a Glance
-Understanding the different **modes** that Ultralytics YOLOv8 supports is critical to getting the most out of your models:
+Understanding the different **modes** that Ultralytics YOLO11 supports is critical to getting the most out of your models:
- **Train** mode: Fine-tune your model on custom or preloaded datasets.
- **Val** mode: A post-training checkpoint to validate model performance.
@@ -34,49 +34,49 @@ Understanding the different **modes** that Ultralytics YOLOv8 supports is critic
- **Track** mode: Extend your object detection model into real-time tracking applications.
- **Benchmark** mode: Analyze the speed and accuracy of your model in diverse deployment environments.
-This comprehensive guide aims to give you an overview and practical insights into each mode, helping you harness the full potential of YOLOv8.
+This comprehensive guide aims to give you an overview and practical insights into each mode, helping you harness the full potential of YOLO11.
## [Train](train.md)
-Train mode is used for training a YOLOv8 model on a custom dataset. In this mode, the model is trained using the specified dataset and hyperparameters. The training process involves optimizing the model's parameters so that it can accurately predict the classes and locations of objects in an image.
+Train mode is used for training a YOLO11 model on a custom dataset. In this mode, the model is trained using the specified dataset and hyperparameters. The training process involves optimizing the model's parameters so that it can accurately predict the classes and locations of objects in an image.
[Train Examples](train.md){ .md-button }
## [Val](val.md)
-Val mode is used for validating a YOLOv8 model after it has been trained. In this mode, the model is evaluated on a validation set to measure its accuracy and generalization performance. This mode can be used to tune the hyperparameters of the model to improve its performance.
+Val mode is used for validating a YOLO11 model after it has been trained. In this mode, the model is evaluated on a validation set to measure its accuracy and generalization performance. This mode can be used to tune the hyperparameters of the model to improve its performance.
[Val Examples](val.md){ .md-button }
## [Predict](predict.md)
-Predict mode is used for making predictions using a trained YOLOv8 model on new images or videos. In this mode, the model is loaded from a checkpoint file, and the user can provide images or videos to perform inference. The model predicts the classes and locations of objects in the input images or videos.
+Predict mode is used for making predictions using a trained YOLO11 model on new images or videos. In this mode, the model is loaded from a checkpoint file, and the user can provide images or videos to perform inference. The model predicts the classes and locations of objects in the input images or videos.
[Predict Examples](predict.md){ .md-button }
## [Export](export.md)
-Export mode is used for exporting a YOLOv8 model to a format that can be used for deployment. In this mode, the model is converted to a format that can be used by other software applications or hardware devices. This mode is useful when deploying the model to production environments.
+Export mode is used for exporting a YOLO11 model to a format that can be used for deployment. In this mode, the model is converted to a format that can be used by other software applications or hardware devices. This mode is useful when deploying the model to production environments.
[Export Examples](export.md){ .md-button }
## [Track](track.md)
-Track mode is used for tracking objects in real-time using a YOLOv8 model. In this mode, the model is loaded from a checkpoint file, and the user can provide a live video stream to perform real-time object tracking. This mode is useful for applications such as surveillance systems or self-driving cars.
+Track mode is used for tracking objects in real-time using a YOLO11 model. In this mode, the model is loaded from a checkpoint file, and the user can provide a live video stream to perform real-time object tracking. This mode is useful for applications such as surveillance systems or self-driving cars.
[Track Examples](track.md){ .md-button }
## [Benchmark](benchmark.md)
-Benchmark mode is used to profile the speed and accuracy of various export formats for YOLOv8. The benchmarks provide information on the size of the exported format, its `mAP50-95` metrics (for object detection, segmentation, and pose) or `accuracy_top5` metrics (for classification), and the inference time in milliseconds per image across various formats like ONNX, OpenVINO, TensorRT, and others. This information can help users choose the optimal export format for their specific use case based on their requirements for speed and accuracy.
+Benchmark mode is used to profile the speed and accuracy of various export formats for YOLO11. The benchmarks provide information on the size of the exported format, its `mAP50-95` metrics (for object detection, segmentation, and pose) or `accuracy_top5` metrics (for classification), and the inference time in milliseconds per image across various formats like ONNX, OpenVINO, TensorRT, and others. This information can help users choose the optimal export format for their specific use case based on their requirements for speed and accuracy.
[Benchmark Examples](benchmark.md){ .md-button }
## FAQ
-### How do I train a custom [object detection](https://www.ultralytics.com/glossary/object-detection) model with Ultralytics YOLOv8?
+### How do I train a custom [object detection](https://www.ultralytics.com/glossary/object-detection) model with Ultralytics YOLO11?
-Training a custom object detection model with Ultralytics YOLOv8 involves using the train mode. You need a dataset formatted in YOLO format, containing images and corresponding annotation files. Use the following command to start the training process:
+Training a custom object detection model with Ultralytics YOLO11 involves using the train mode. You need a dataset formatted in YOLO format, containing images and corresponding annotation files. Use the following command to start the training process:
!!! example
@@ -85,22 +85,25 @@ Training a custom object detection model with Ultralytics YOLOv8 involves using
```python
from ultralytics import YOLO
- # Train a custom model
- model = YOLO("yolov8n.pt")
+ # Load a pre-trained YOLO model (you can choose n, s, m, l, or x versions)
+ model = YOLO("yolo11n.pt")
+
+ # Start training on your custom dataset
model.train(data="path/to/dataset.yaml", epochs=100, imgsz=640)
```
=== "CLI"
```bash
+ # Train a YOLO model from the command line
yolo train data=path/to/dataset.yaml epochs=100 imgsz=640
```
For more detailed instructions, you can refer to the [Ultralytics Train Guide](../modes/train.md).
-### What metrics does Ultralytics YOLOv8 use to validate the model's performance?
+### What metrics does Ultralytics YOLO11 use to validate the model's performance?
-Ultralytics YOLOv8 uses various metrics during the validation process to assess model performance. These include:
+Ultralytics YOLO11 uses various metrics during the validation process to assess model performance. These include:
- **mAP (mean Average Precision)**: This evaluates the accuracy of object detection.
- **IOU (Intersection over Union)**: Measures the overlap between predicted and ground truth bounding boxes.
@@ -115,22 +118,25 @@ You can run the following command to start the validation:
```python
from ultralytics import YOLO
- # Validate the model
- model = YOLO("yolov8n.pt")
+ # Load a pre-trained or custom YOLO model
+ model = YOLO("yolo11n.pt")
+
+ # Run validation on your dataset
model.val(data="path/to/validation.yaml")
```
=== "CLI"
```bash
+ # Validate a YOLO model from the command line
yolo val data=path/to/validation.yaml
```
Refer to the [Validation Guide](../modes/val.md) for further details.
-### How can I export my YOLOv8 model for deployment?
+### How can I export my YOLO11 model for deployment?
-Ultralytics YOLOv8 offers export functionality to convert your trained model into various deployment formats such as ONNX, TensorRT, CoreML, and more. Use the following example to export your model:
+Ultralytics YOLO11 offers export functionality to convert your trained model into various deployment formats such as ONNX, TensorRT, CoreML, and more. Use the following example to export your model:
!!! example
@@ -139,22 +145,25 @@ Ultralytics YOLOv8 offers export functionality to convert your trained model int
```python
from ultralytics import YOLO
- # Export the model
- model = YOLO("yolov8n.pt")
+ # Load your trained YOLO model
+ model = YOLO("yolo11n.pt")
+
+ # Export the model to ONNX format (you can specify other formats as needed)
model.export(format="onnx")
```
=== "CLI"
```bash
- yolo export model=yolov8n.pt format=onnx
+ # Export a YOLO model to ONNX format from the command line
+ yolo export model=yolo11n.pt format=onnx
```
Detailed steps for each export format can be found in the [Export Guide](../modes/export.md).
-### What is the purpose of the benchmark mode in Ultralytics YOLOv8?
+### What is the purpose of the benchmark mode in Ultralytics YOLO11?
-Benchmark mode in Ultralytics YOLOv8 is used to analyze the speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) of various export formats such as ONNX, TensorRT, and OpenVINO. It provides metrics like model size, `mAP50-95` for object detection, and inference time across different hardware setups, helping you choose the most suitable format for your deployment needs.
+Benchmark mode in Ultralytics YOLO11 is used to analyze the speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) of various export formats such as ONNX, TensorRT, and OpenVINO. It provides metrics like model size, `mAP50-95` for object detection, and inference time across different hardware setups, helping you choose the most suitable format for your deployment needs.
!!! example
@@ -163,21 +172,24 @@ Benchmark mode in Ultralytics YOLOv8 is used to analyze the speed and [accuracy]
```python
from ultralytics.utils.benchmarks import benchmark
- # Benchmark on GPU
- benchmark(model="yolov8n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)
+ # Run benchmark on GPU (device 0)
+ # You can adjust parameters like model, dataset, image size, and precision as needed
+ benchmark(model="yolo11n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)
```
=== "CLI"
```bash
- yolo benchmark model=yolov8n.pt data='coco8.yaml' imgsz=640 half=False device=0
+ # Benchmark a YOLO model from the command line
+ # Adjust parameters as needed for your specific use case
+ yolo benchmark model=yolo11n.pt data='coco8.yaml' imgsz=640 half=False device=0
```
For more details, refer to the [Benchmark Guide](../modes/benchmark.md).
-### How can I perform real-time object tracking using Ultralytics YOLOv8?
+### How can I perform real-time object tracking using Ultralytics YOLO11?
-Real-time object tracking can be achieved using the track mode in Ultralytics YOLOv8. This mode extends object detection capabilities to track objects across video frames or live feeds. Use the following example to enable tracking:
+Real-time object tracking can be achieved using the track mode in Ultralytics YOLO11. This mode extends object detection capabilities to track objects across video frames or live feeds. Use the following example to enable tracking:
!!! example
@@ -186,14 +198,19 @@ Real-time object tracking can be achieved using the track mode in Ultralytics YO
```python
from ultralytics import YOLO
- # Track objects in a video
- model = YOLO("yolov8n.pt")
+ # Load a pre-trained YOLO model
+ model = YOLO("yolo11n.pt")
+
+ # Start tracking objects in a video
+ # You can also use live video streams or webcam input
model.track(source="path/to/video.mp4")
```
=== "CLI"
```bash
+ # Perform object tracking on a video from the command line
+ # You can specify different sources like webcam (0) or RTSP streams
yolo track source=path/to/video.mp4
```
diff --git a/docs/en/modes/predict.md b/docs/en/modes/predict.md
index 196d9e2028..cb8ca25e7e 100644
--- a/docs/en/modes/predict.md
+++ b/docs/en/modes/predict.md
@@ -1,7 +1,7 @@
---
comments: true
-description: Harness the power of Ultralytics YOLOv8 for real-time, high-speed inference on various data sources. Learn about predict mode, key features, and practical applications.
-keywords: Ultralytics, YOLOv8, model prediction, inference, predict mode, real-time inference, computer vision, machine learning, streaming, high performance
+description: Harness the power of Ultralytics YOLO11 for real-time, high-speed inference on various data sources. Learn about predict mode, key features, and practical applications.
+keywords: Ultralytics, YOLO11, model prediction, inference, predict mode, real-time inference, computer vision, machine learning, streaming, high performance
---
# Model Prediction with Ultralytics YOLO
@@ -10,7 +10,7 @@ keywords: Ultralytics, YOLOv8, model prediction, inference, predict mode, real-t
## Introduction
-In the world of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv), the process of making sense out of visual data is called 'inference' or 'prediction'. Ultralytics YOLOv8 offers a powerful feature known as **predict mode** that is tailored for high-performance, real-time inference on a wide range of data sources.
+In the world of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv), the process of making sense out of visual data is called 'inference' or 'prediction'. Ultralytics YOLO11 offers a powerful feature known as **predict mode** that is tailored for high-performance, real-time inference on a wide range of data sources.
@@ -20,7 +20,7 @@ In the world of [machine learning](https://www.ultralytics.com/glossary/machine-
allowfullscreen>
- Watch: How to Extract the Outputs from Ultralytics YOLOv8 Model for Custom Projects.
+ Watch: How to Extract the Outputs from Ultralytics YOLO Model for Custom Projects.
@@ -20,12 +20,12 @@ Training a [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl
allowfullscreen>
- Watch: How to Train a YOLOv8 model on Your Custom Dataset in Google Colab.
+ Watch: How to Train a YOLO model on Your Custom Dataset in Google Colab.
@@ -25,7 +25,7 @@ Validation is a critical step in the [machine learning](https://www.ultralytics.
## Why Validate with Ultralytics YOLO?
-Here's why using YOLOv8's Val mode is advantageous:
+Here's why using YOLO11's Val mode is advantageous:
- **Precision:** Get accurate metrics like mAP50, mAP75, and mAP50-95 to comprehensively evaluate your model.
- **Convenience:** Utilize built-in features that remember training settings, simplifying the validation process.
@@ -34,7 +34,7 @@ Here's why using YOLOv8's Val mode is advantageous:
### Key Features of Val Mode
-These are the notable functionalities offered by YOLOv8's Val mode:
+These are the notable functionalities offered by YOLO11's Val mode:
- **Automated Settings:** Models remember their training configurations for straightforward validation.
- **Multi-Metric Support:** Evaluate your model based on a range of accuracy metrics.
@@ -43,11 +43,11 @@ These are the notable functionalities offered by YOLOv8's Val mode:
!!! tip
- * YOLOv8 models automatically remember their training settings, so you can validate a model at the same image size and on the original dataset easily with just `yolo val model=yolov8n.pt` or `model('yolov8n.pt').val()`
+ * YOLO11 models automatically remember their training settings, so you can validate a model at the same image size and on the original dataset easily with just `yolo val model=yolo11n.pt` or `model('yolo11n.pt').val()`
## Usage Examples
-Validate trained YOLOv8n model [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8 dataset. No arguments are needed as the `model` retains its training `data` and arguments as model attributes. See Arguments section below for a full list of export arguments.
+Validate trained YOLO11n model [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8 dataset. No arguments are needed as the `model` retains its training `data` and arguments as model attributes. See Arguments section below for a full list of export arguments.
!!! example
@@ -57,7 +57,7 @@ Validate trained YOLOv8n model [accuracy](https://www.ultralytics.com/glossary/a
from ultralytics import YOLO
# Load a model
- model = YOLO("yolov8n.pt") # load an official model
+ model = YOLO("yolo11n.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom model
# Validate the model
@@ -71,7 +71,7 @@ Validate trained YOLOv8n model [accuracy](https://www.ultralytics.com/glossary/a
=== "CLI"
```bash
- yolo detect val model=yolov8n.pt # val official model
+ yolo detect val model=yolo11n.pt # val official model
yolo detect val model=path/to/best.pt # val custom model
```
@@ -95,7 +95,7 @@ The below examples showcase YOLO model validation with custom arguments in Pytho
from ultralytics import YOLO
# Load a model
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Customize validation settings
validation_results = model.val(data="coco8.yaml", imgsz=640, batch=16, conf=0.25, iou=0.6, device="0")
@@ -104,20 +104,20 @@ The below examples showcase YOLO model validation with custom arguments in Pytho
=== "CLI"
```bash
- yolo val model=yolov8n.pt data=coco8.yaml imgsz=640 batch=16 conf=0.25 iou=0.6 device=0
+ yolo val model=yolo11n.pt data=coco8.yaml imgsz=640 batch=16 conf=0.25 iou=0.6 device=0
```
## FAQ
-### How do I validate my YOLOv8 model with Ultralytics?
+### How do I validate my YOLO11 model with Ultralytics?
-To validate your YOLOv8 model, you can use the Val mode provided by Ultralytics. For example, using the Python API, you can load a model and run validation with:
+To validate your YOLO11 model, you can use the Val mode provided by Ultralytics. For example, using the Python API, you can load a model and run validation with:
```python
from ultralytics import YOLO
# Load a model
-model = YOLO("yolov8n.pt")
+model = YOLO("yolo11n.pt")
# Validate the model
metrics = model.val()
@@ -127,14 +127,14 @@ print(metrics.box.map) # map50-95
Alternatively, you can use the command-line interface (CLI):
```bash
-yolo val model=yolov8n.pt
+yolo val model=yolo11n.pt
```
For further customization, you can adjust various arguments like `imgsz`, `batch`, and `conf` in both Python and CLI modes. Check the [Arguments for YOLO Model Validation](#arguments-for-yolo-model-validation) section for the full list of parameters.
-### What metrics can I get from YOLOv8 model validation?
+### What metrics can I get from YOLO11 model validation?
-YOLOv8 model validation provides several key metrics to assess model performance. These include:
+YOLO11 model validation provides several key metrics to assess model performance. These include:
- mAP50 (mean Average Precision at IoU threshold 0.5)
- mAP75 (mean Average Precision at IoU threshold 0.75)
@@ -156,16 +156,16 @@ For a complete performance evaluation, it's crucial to review all these metrics.
Using Ultralytics YOLO for validation provides several advantages:
-- **[Precision](https://www.ultralytics.com/glossary/precision):** YOLOv8 offers accurate performance metrics including mAP50, mAP75, and mAP50-95.
+- **[Precision](https://www.ultralytics.com/glossary/precision):** YOLO11 offers accurate performance metrics including mAP50, mAP75, and mAP50-95.
- **Convenience:** The models remember their training settings, making validation straightforward.
- **Flexibility:** You can validate against the same or different datasets and image sizes.
- **Hyperparameter Tuning:** Validation metrics help in fine-tuning models for better performance.
These benefits ensure that your models are evaluated thoroughly and can be optimized for superior results. Learn more about these advantages in the [Why Validate with Ultralytics YOLO](#why-validate-with-ultralytics-yolo) section.
-### Can I validate my YOLOv8 model using a custom dataset?
+### Can I validate my YOLO11 model using a custom dataset?
-Yes, you can validate your YOLOv8 model using a [custom dataset](https://docs.ultralytics.com/datasets/). Specify the `data` argument with the path to your dataset configuration file. This file should include paths to the [validation data](https://www.ultralytics.com/glossary/validation-data), class names, and other relevant details.
+Yes, you can validate your YOLO11 model using a [custom dataset](https://docs.ultralytics.com/datasets/). Specify the `data` argument with the path to your dataset configuration file. This file should include paths to the [validation data](https://www.ultralytics.com/glossary/validation-data), class names, and other relevant details.
Example in Python:
@@ -173,7 +173,7 @@ Example in Python:
from ultralytics import YOLO
# Load a model
-model = YOLO("yolov8n.pt")
+model = YOLO("yolo11n.pt")
# Validate with a custom dataset
metrics = model.val(data="path/to/your/custom_dataset.yaml")
@@ -183,12 +183,12 @@ print(metrics.box.map) # map50-95
Example using CLI:
```bash
-yolo val model=yolov8n.pt data=path/to/your/custom_dataset.yaml
+yolo val model=yolo11n.pt data=path/to/your/custom_dataset.yaml
```
For more customizable options during validation, see the [Example Validation with Arguments](#example-validation-with-arguments) section.
-### How do I save validation results to a JSON file in YOLOv8?
+### How do I save validation results to a JSON file in YOLO11?
To save the validation results to a JSON file, you can set the `save_json` argument to `True` when running validation. This can be done in both the Python API and CLI.
@@ -198,7 +198,7 @@ Example in Python:
from ultralytics import YOLO
# Load a model
-model = YOLO("yolov8n.pt")
+model = YOLO("yolo11n.pt")
# Save validation results to JSON
metrics = model.val(save_json=True)
@@ -207,7 +207,7 @@ metrics = model.val(save_json=True)
Example using CLI:
```bash
-yolo val model=yolov8n.pt save_json=True
+yolo val model=yolo11n.pt save_json=True
```
This functionality is particularly useful for further analysis or integration with other tools. Check the [Arguments for YOLO Model Validation](#arguments-for-yolo-model-validation) for more details.
diff --git a/docs/en/quickstart.md b/docs/en/quickstart.md
index 7b5a3a27c0..204623cca4 100644
--- a/docs/en/quickstart.md
+++ b/docs/en/quickstart.md
@@ -1,12 +1,12 @@
---
comments: true
-description: Learn how to install Ultralytics using pip, conda, or Docker. Follow our step-by-step guide for a seamless setup of YOLOv8 with thorough instructions.
-keywords: Ultralytics, YOLOv8, Install Ultralytics, pip, conda, Docker, GitHub, machine learning, object detection
+description: Learn how to install Ultralytics using pip, conda, or Docker. Follow our step-by-step guide for a seamless setup of YOLO with thorough instructions.
+keywords: Ultralytics, YOLO11, Install Ultralytics, pip, conda, Docker, GitHub, machine learning, object detection
---
## Install Ultralytics
-Ultralytics provides various installation methods including pip, conda, and Docker. Install YOLOv8 via the `ultralytics` pip package for the latest stable release or by cloning the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics) for the most up-to-date version. Docker can be used to execute the package in an isolated container, avoiding local installation.
+Ultralytics provides various installation methods including pip, conda, and Docker. Install YOLO via the `ultralytics` pip package for the latest stable release or by cloning the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics) for the most up-to-date version. Docker can be used to execute the package in an isolated container, avoiding local installation.
@@ -151,7 +151,7 @@ See the `ultralytics` [pyproject.toml](https://github.com/ultralytics/ultralytic
## Use Ultralytics with CLI
-The Ultralytics command line interface (CLI) allows for simple single-line commands without the need for a Python environment. CLI requires no customization or Python code. You can simply run all tasks from the terminal with the `yolo` command. Check out the [CLI Guide](usage/cli.md) to learn more about using YOLOv8 from the command line.
+The Ultralytics command line interface (CLI) allows for simple single-line commands without the need for a Python environment. CLI requires no customization or Python code. You can simply run all tasks from the terminal with the `yolo` command. Check out the [CLI Guide](usage/cli.md) to learn more about using YOLO from the command line.
!!! example
@@ -172,28 +172,28 @@ The Ultralytics command line interface (CLI) allows for simple single-line comma
Train a detection model for 10 [epochs](https://www.ultralytics.com/glossary/epoch) with an initial learning_rate of 0.01
```bash
- yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
+ yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
```
=== "Predict"
Predict a YouTube video using a pretrained segmentation model at image size 320:
```bash
- yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+ yolo predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
```
=== "Val"
Val a pretrained detection model at batch-size 1 and image size 640:
```bash
- yolo val model=yolov8n.pt data=coco8.yaml batch=1 imgsz=640
+ yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
```
=== "Export"
- Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
+ Export a yolo11n classification model to ONNX format at image size 224 by 128 (no TASK required)
```bash
- yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+ yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128
```
=== "Special"
@@ -212,18 +212,18 @@ The Ultralytics command line interface (CLI) allows for simple single-line comma
Arguments must be passed as `arg=val` pairs, split by an equals `=` sign and delimited by spaces between pairs. Do not use `--` argument prefixes or commas `,` between arguments.
- - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25` ✅
- - `yolo predict model yolov8n.pt imgsz 640 conf 0.25` ❌ (missing `=`)
- - `yolo predict model=yolov8n.pt, imgsz=640, conf=0.25` ❌ (do not use `,`)
- - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25` ❌ (do not use `--`)
+ - `yolo predict model=yolo11n.pt imgsz=640 conf=0.25` ✅
+ - `yolo predict model yolo11n.pt imgsz 640 conf 0.25` ❌ (missing `=`)
+ - `yolo predict model=yolo11n.pt, imgsz=640, conf=0.25` ❌ (do not use `,`)
+ - `yolo predict --model yolo11n.pt --imgsz 640 --conf 0.25` ❌ (do not use `--`)
[CLI Guide](usage/cli.md){ .md-button }
## Use Ultralytics with Python
-YOLOv8's Python interface allows for seamless integration into your Python projects, making it easy to load, run, and process the model's output. Designed with simplicity and ease of use in mind, the Python interface enables users to quickly implement [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and classification in their projects. This makes YOLOv8's Python interface an invaluable tool for anyone looking to incorporate these functionalities into their Python projects.
+YOLO's Python interface allows for seamless integration into your Python projects, making it easy to load, run, and process the model's output. Designed with simplicity and ease of use in mind, the Python interface enables users to quickly implement [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and classification in their projects. This makes YOLO's Python interface an invaluable tool for anyone looking to incorporate these functionalities into their Python projects.
-For example, users can load a model, train it, evaluate its performance on a validation set, and even export it to ONNX format with just a few lines of code. Check out the [Python Guide](usage/python.md) to learn more about using YOLOv8 within your Python projects.
+For example, users can load a model, train it, evaluate its performance on a validation set, and even export it to ONNX format with just a few lines of code. Check out the [Python Guide](usage/python.md) to learn more about using YOLO within your Python projects.
!!! example
@@ -231,10 +231,10 @@ For example, users can load a model, train it, evaluate its performance on a val
from ultralytics import YOLO
# Create a new YOLO model from scratch
- model = YOLO("yolov8n.yaml")
+ model = YOLO("yolo11n.yaml")
# Load a pretrained YOLO model (recommended for training)
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
# Train the model using the 'coco8.yaml' dataset for 3 epochs
results = model.train(data="coco8.yaml", epochs=3)
@@ -345,9 +345,9 @@ As you navigate through your projects or experiments, be sure to revisit these s
## FAQ
-### How do I install Ultralytics YOLOv8 using pip?
+### How do I install Ultralytics using pip?
-To install Ultralytics YOLOv8 with pip, execute the following command:
+To install Ultralytics with pip, execute the following command:
```bash
pip install ultralytics
@@ -363,9 +363,9 @@ pip install git+https://github.com/ultralytics/ultralytics.git
Make sure to have the Git command-line tool installed on your system.
-### Can I install Ultralytics YOLOv8 using conda?
+### Can I install Ultralytics YOLO using conda?
-Yes, you can install Ultralytics YOLOv8 using conda by running:
+Yes, you can install Ultralytics YOLO using conda by running:
```bash
conda install -c conda-forge ultralytics
@@ -379,9 +379,9 @@ conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cu
For more instructions, visit the [Conda quickstart guide](guides/conda-quickstart.md).
-### What are the advantages of using Docker to run Ultralytics YOLOv8?
+### What are the advantages of using Docker to run Ultralytics YOLO?
-Using Docker to run Ultralytics YOLOv8 provides an isolated and consistent environment, ensuring smooth performance across different systems. It also eliminates the complexity of local installation. Official Docker images from Ultralytics are available on [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics), with different variants tailored for GPU, CPU, ARM64, NVIDIA Jetson, and Conda environments. Below are the commands to pull and run the latest image:
+Using Docker to run Ultralytics YOLO provides an isolated and consistent environment, ensuring smooth performance across different systems. It also eliminates the complexity of local installation. Official Docker images from Ultralytics are available on [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics), with different variants tailored for GPU, CPU, ARM64, NVIDIA Jetson, and Conda environments. Below are the commands to pull and run the latest image:
```bash
# Pull the latest ultralytics image from Docker Hub
@@ -410,9 +410,9 @@ pip install -e .
This approach allows you to contribute to the project or experiment with the latest source code. For more details, visit the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics).
-### Why should I use Ultralytics YOLOv8 CLI?
+### Why should I use Ultralytics YOLO CLI?
-The Ultralytics YOLOv8 command line interface (CLI) simplifies running object detection tasks without requiring Python code. You can execute single-line commands for tasks like training, validation, and prediction straight from your terminal. The basic syntax for `yolo` commands is:
+The Ultralytics YOLO command line interface (CLI) simplifies running object detection tasks without requiring Python code. You can execute single-line commands for tasks like training, validation, and prediction straight from your terminal. The basic syntax for `yolo` commands is:
```bash
yolo TASK MODE ARGS
@@ -421,7 +421,7 @@ yolo TASK MODE ARGS
For example, to train a detection model with specified parameters:
```bash
-yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
+yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
```
Check out the full [CLI Guide](usage/cli.md) to explore more commands and usage examples.
diff --git a/docs/en/reference/nn/modules/block.md b/docs/en/reference/nn/modules/block.md
index ed7a94ac75..da0ca655f3 100644
--- a/docs/en/reference/nn/modules/block.md
+++ b/docs/en/reference/nn/modules/block.md
@@ -143,6 +143,18 @@ keywords: Ultralytics, YOLO, neural networks, block modules, DFL, Proto, HGStem,
-YOLOv8 is an AI framework that supports multiple [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) **tasks**. The framework can be used to perform [detection](detect.md), [segmentation](segment.md), [obb](obb.md), [classification](classify.md), and [pose](pose.md) estimation. Each of these tasks has a different objective and use case.
+YOLO11 is an AI framework that supports multiple [computer vision](https://www.ultralytics.com/glossary/computer-vision-cv) **tasks**. The framework can be used to perform [detection](detect.md), [segmentation](segment.md), [obb](obb.md), [classification](classify.md), and [pose](pose.md) estimation. Each of these tasks has a different objective and use case.
@@ -19,48 +19,48 @@ YOLOv8 is an AI framework that supports multiple [computer vision](https://www.u
allowfullscreen>
- Watch: Explore Ultralytics YOLO Tasks: [Object Detection](https://www.ultralytics.com/glossary/object-detection), Segmentation, OBB, Tracking, and Pose Estimation.
+ Watch: Explore Ultralytics YOLO Tasks: Object Detection, Segmentation, OBB, Tracking, and Pose Estimation.
@@ -27,7 +27,7 @@ The output of an oriented object detector is a set of rotated bounding boxes tha
allowfullscreen>
- Watch: Object Detection using Ultralytics YOLOv8 Oriented Bounding Boxes (YOLOv8-OBB)
+ Watch: Object Detection using Ultralytics YOLO Oriented Bounding Boxes (YOLO-OBB)
@@ -94,7 +88,7 @@ Train YOLOv8n-obb on the `dota8.yaml` dataset for 100 [epochs](https://www.ultra
allowfullscreen>
- Watch: How to Train Ultralytics YOLOv8-OBB (Oriented Bounding Boxes) Models on DOTA Dataset using Ultralytics HUB
+ Watch: How to Train Ultralytics YOLO-OBB (Oriented Bounding Boxes) Models on DOTA Dataset using Ultralytics HUB
@@ -16,7 +16,7 @@ Welcome to the YOLOv8 Python Usage documentation! This guide is designed to help
allowfullscreen>
- Watch: Mastering Ultralytics YOLOv8: Python
+ Watch: Mastering Ultralytics YOLO11: Python
![\"Open](\"https://kaggle.com/static/images/open-in-kaggle.svg\")
\n",
" ![\"Discord\"](\"https://img.shields.io/discord/1089800235347353640?logo=discord&logoColor=white&label=Discord&color=blue\")
\n",
"\n",
- "Welcome to the Ultralytics YOLOv8 🚀 notebook! YOLOv8 is the latest version of the YOLO (You Only Look Once) AI models developed by Ultralytics. This notebook serves as the starting point for exploring the various resources available to help you get started with YOLOv8 and understand its features and capabilities.\n",
+ "Welcome to the Ultralytics YOLO11 🚀 notebook! YOLO11 is the latest version of the YOLO (You Only Look Once) AI models developed by Ultralytics. This notebook serves as the starting point for exploring the various resources available to help you get started with YOLO11 and understand its features and capabilities.\n",
"\n",
- "YOLOv8 models are fast, accurate, and easy to use, making them ideal for various object detection and image segmentation tasks. They can be trained on large datasets and run on diverse hardware platforms, from CPUs to GPUs.\n",
+ "YOLO11 models are fast, accurate, and easy to use, making them ideal for various object detection and image segmentation tasks. They can be trained on large datasets and run on diverse hardware platforms, from CPUs to GPUs.\n",
"\n",
- "We hope that the resources in this notebook will help you get the most out of YOLOv8. Please browse the YOLOv8 Heatmap Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
+ "We hope that the resources in this notebook will help you get the most out of YOLO11. Please browse the YOLO11 Heatmap Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
"\n",
""
]
@@ -56,7 +56,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Ultralytics YOLOv8.2.17 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+ "Ultralytics 8.2.17 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (T4, 15102MiB)\n",
"Setup complete ✅ (2 CPUs, 12.7 GB RAM, 29.8/78.2 GB disk)\n"
]
}
@@ -76,14 +76,14 @@
"source": [
"# Introduction to Heatmaps\n",
"\n",
- "A heatmap generated with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) transforms complex data into a vibrant, color-coded matrix. This visual tool employs a spectrum of colors to represent varying data values, where warmer hues indicate higher intensities and cooler tones signify lower values. Heatmaps excel in visualizing intricate data patterns, correlations, and anomalies, offering an accessible and engaging approach to data interpretation across diverse domains.\n",
+ "A heatmap generated with [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics/) transforms complex data into a vibrant, color-coded matrix. This visual tool employs a spectrum of colors to represent varying data values, where warmer hues indicate higher intensities and cooler tones signify lower values. Heatmaps excel in visualizing intricate data patterns, correlations, and anomalies, offering an accessible and engaging approach to data interpretation across diverse domains.\n",
"\n",
"## Real World Applications\n",
"\n",
"| Transportation | Retail |\n",
"|:-----------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------:|\n",
- "|  |  |\n",
- "| Ultralytics YOLOv8 Transportation Heatmap | Ultralytics YOLOv8 Retail Heatmap |\n"
+ "|  |  |\n",
+ "| Ultralytics YOLO11 Transportation Heatmap | Ultralytics YOLO11 Retail Heatmap |\n"
]
},
{
@@ -99,7 +99,7 @@
"from ultralytics import YOLO, solutions\n",
"\n",
"# Load YOLO model\n",
- "model = YOLO(\"yolov8n.pt\")\n",
+ "model = YOLO(\"yolo11n.pt\")\n",
"\n",
"# Open video file\n",
"cap = cv2.VideoCapture(\"path/to/video/file.mp4\")\n",
@@ -161,15 +161,15 @@
"- [About Us](https://ultralytics.com/about): Discover our mission, vision, and the story behind Ultralytics.\n",
"- [Join Our Team](https://ultralytics.com/work): Explore career opportunities and join our team of talented professionals.\n",
"\n",
- "## YOLOv8 🚀 Resources\n",
+ "## YOLO11 🚀 Resources\n",
"\n",
- "YOLOv8 is the latest evolution in the YOLO series, offering state-of-the-art performance in object detection and image segmentation. Here are some essential resources to help you get started with YOLOv8:\n",
+ "YOLO11 is the latest evolution in the YOLO series, offering state-of-the-art performance in object detection and image segmentation. Here are some essential resources to help you get started with YOLO11:\n",
"\n",
- "- [GitHub](https://github.com/ultralytics/ultralytics): Access the YOLOv8 repository on GitHub, where you can find the source code, contribute to the project, and report issues.\n",
- "- [Docs](https://docs.ultralytics.com/): Explore the official documentation for YOLOv8, including installation guides, tutorials, and detailed API references.\n",
+ "- [GitHub](https://github.com/ultralytics/ultralytics): Access the YOLO11 repository on GitHub, where you can find the source code, contribute to the project, and report issues.\n",
+ "- [Docs](https://docs.ultralytics.com/): Explore the official documentation for YOLO11, including installation guides, tutorials, and detailed API references.\n",
"- [Discord](https://ultralytics.com/discord): Join our Discord community to connect with other users, share your projects, and get help from the Ultralytics team.\n",
"\n",
- "These resources are designed to help you leverage the full potential of Ultralytics' offerings and YOLOv8. Whether you're a beginner or an experienced developer, you'll find the information and support you need to succeed."
+ "These resources are designed to help you leverage the full potential of Ultralytics' offerings and YOLO11. Whether you're a beginner or an experienced developer, you'll find the information and support you need to succeed."
]
}
],
diff --git a/examples/hub.ipynb b/examples/hub.ipynb
index ee6f3cae60..03382596ce 100644
--- a/examples/hub.ipynb
+++ b/examples/hub.ipynb
@@ -54,7 +54,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Ultralytics YOLOv8.2.3 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+ "Ultralytics 8.2.3 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (T4, 15102MiB)\n",
"Setup complete ✅ (2 CPUs, 12.7 GB RAM, 28.8/78.2 GB disk)\n"
]
}
diff --git a/examples/object_counting.ipynb b/examples/object_counting.ipynb
index 8c3d0ba6e8..8356d592d2 100644
--- a/examples/object_counting.ipynb
+++ b/examples/object_counting.ipynb
@@ -19,11 +19,11 @@
" \n",
" \n",
"\n",
- "Welcome to the Ultralytics YOLOv8 🚀 notebook! YOLOv8 is the latest version of the YOLO (You Only Look Once) AI models developed by Ultralytics. This notebook serves as the starting point for exploring the various resources available to help you get started with YOLOv8 and understand its features and capabilities.\n",
+ "Welcome to the Ultralytics YOLO11 🚀 notebook! YOLO11 is the latest version of the YOLO (You Only Look Once) AI models developed by Ultralytics. This notebook serves as the starting point for exploring the various resources available to help you get started with YOLO11 and understand its features and capabilities.\n",
"\n",
- "YOLOv8 models are fast, accurate, and easy to use, making them ideal for various object detection and image segmentation tasks. They can be trained on large datasets and run on diverse hardware platforms, from CPUs to GPUs.\n",
+ "YOLO11 models are fast, accurate, and easy to use, making them ideal for various object detection and image segmentation tasks. They can be trained on large datasets and run on diverse hardware platforms, from CPUs to GPUs.\n",
"\n",
- "We hope that the resources in this notebook will help you get the most out of YOLOv8. Please browse the YOLOv8 Object Counting Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
+ "We hope that the resources in this notebook will help you get the most out of YOLO11. Please browse the YOLO11 Object Counting Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
"\n",
""
]
@@ -56,7 +56,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Ultralytics YOLOv8.2.18 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+ "Ultralytics 8.2.18 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (T4, 15102MiB)\n",
"Setup complete ✅ (2 CPUs, 12.7 GB RAM, 29.8/78.2 GB disk)\n"
]
}
@@ -74,11 +74,11 @@
"id": "m7VkxQ2aeg7k"
},
"source": [
- "# Object Counting using Ultralytics YOLOv8 🚀\n",
+ "# Object Counting using Ultralytics YOLO11 🚀\n",
"\n",
"## What is Object Counting?\n",
"\n",
- "Object counting with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) involves accurate identification and counting of specific objects in videos and camera streams. YOLOv8 excels in real-time applications, providing efficient and precise object counting for various scenarios like crowd analysis and surveillance, thanks to its state-of-the-art algorithms and deep learning capabilities.\n",
+ "Object counting with [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics/) involves accurate identification and counting of specific objects in videos and camera streams. YOLO11 excels in real-time applications, providing efficient and precise object counting for various scenarios like crowd analysis and surveillance, thanks to its state-of-the-art algorithms and deep learning capabilities.\n",
"\n",
"## Advantages of Object Counting?\n",
"\n",
@@ -90,8 +90,8 @@
"\n",
"| Logistics | Aquaculture |\n",
"|:-------------------------------------------------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------:|\n",
- "|  |  |\n",
- "| Conveyor Belt Packets Counting Using Ultralytics YOLOv8 | Fish Counting in Sea using Ultralytics YOLOv8 |\n"
+ "|  |  |\n",
+ "| Conveyor Belt Packets Counting Using Ultralytics YOLO11 | Fish Counting in Sea using Ultralytics YOLO11 |\n"
]
},
{
@@ -106,8 +106,8 @@
"\n",
"from ultralytics import YOLO, solutions\n",
"\n",
- "# Load the pre-trained YOLOv8 model\n",
- "model = YOLO(\"yolov8n.pt\")\n",
+ "# Load the pre-trained YOLO11 model\n",
+ "model = YOLO(\"yolo11n.pt\")\n",
"\n",
"# Open the video file\n",
"cap = cv2.VideoCapture(\"path/to/video/file.mp4\")\n",
@@ -179,15 +179,15 @@
"- [About Us](https://ultralytics.com/about): Discover our mission, vision, and the story behind Ultralytics.\n",
"- [Join Our Team](https://ultralytics.com/work): Explore career opportunities and join our team of talented professionals.\n",
"\n",
- "## YOLOv8 🚀 Resources\n",
+ "## YOLO11 🚀 Resources\n",
"\n",
- "YOLOv8 is the latest evolution in the YOLO series, offering state-of-the-art performance in object detection and image segmentation. Here are some essential resources to help you get started with YOLOv8:\n",
+ "YOLO11 is the latest evolution in the YOLO series, offering state-of-the-art performance in object detection and image segmentation. Here are some essential resources to help you get started with YOLO11:\n",
"\n",
- "- [GitHub](https://github.com/ultralytics/ultralytics): Access the YOLOv8 repository on GitHub, where you can find the source code, contribute to the project, and report issues.\n",
- "- [Docs](https://docs.ultralytics.com/): Explore the official documentation for YOLOv8, including installation guides, tutorials, and detailed API references.\n",
+ "- [GitHub](https://github.com/ultralytics/ultralytics): Access the YOLO11 repository on GitHub, where you can find the source code, contribute to the project, and report issues.\n",
+ "- [Docs](https://docs.ultralytics.com/): Explore the official documentation for YOLO11, including installation guides, tutorials, and detailed API references.\n",
"- [Discord](https://ultralytics.com/discord): Join our Discord community to connect with other users, share your projects, and get help from the Ultralytics team.\n",
"\n",
- "These resources are designed to help you leverage the full potential of Ultralytics' offerings and YOLOv8. Whether you're a beginner or an experienced developer, you'll find the information and support you need to succeed."
+ "These resources are designed to help you leverage the full potential of Ultralytics' offerings and YOLO11. Whether you're a beginner or an experienced developer, you'll find the information and support you need to succeed."
]
}
],
diff --git a/examples/object_tracking.ipynb b/examples/object_tracking.ipynb
index 17c27c0ec0..53ca6b253c 100644
--- a/examples/object_tracking.ipynb
+++ b/examples/object_tracking.ipynb
@@ -19,11 +19,11 @@
" \n",
" \n",
"\n",
- "Welcome to the Ultralytics YOLOv8 🚀 notebook! YOLOv8 is the latest version of the YOLO (You Only Look Once) AI models developed by Ultralytics. This notebook serves as the starting point for exploring the various resources available to help you get started with YOLOv8 and understand its features and capabilities.\n",
+ "Welcome to the Ultralytics YOLO11 🚀 notebook! YOLO11 is the latest version of the YOLO (You Only Look Once) AI models developed by Ultralytics. This notebook serves as the starting point for exploring the various resources available to help you get started with YOLO11 and understand its features and capabilities.\n",
"\n",
- "YOLOv8 models are fast, accurate, and easy to use, making them ideal for various object detection and image segmentation tasks. They can be trained on large datasets and run on diverse hardware platforms, from CPUs to GPUs.\n",
+ "YOLO11 models are fast, accurate, and easy to use, making them ideal for various object detection and image segmentation tasks. They can be trained on large datasets and run on diverse hardware platforms, from CPUs to GPUs.\n",
"\n",
- "We hope that the resources in this notebook will help you get the most out of YOLOv8. Please browse the YOLOv8 Tracking Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
+ "We hope that the resources in this notebook will help you get the most out of YOLO11. Please browse the YOLO11 Tracking Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
"\n",
""
]
@@ -56,7 +56,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Ultralytics YOLOv8.2.17 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+ "Ultralytics 8.2.17 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (T4, 15102MiB)\n",
"Setup complete ✅ (2 CPUs, 12.7 GB RAM, 29.8/78.2 GB disk)\n"
]
}
@@ -76,7 +76,7 @@
"source": [
"# Ultralytics Object Tracking\n",
"\n",
- "[Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics/) instance segmentation involves identifying and outlining individual objects in an image, providing a detailed understanding of spatial distribution. Unlike semantic segmentation, it uniquely labels and precisely delineates each object, crucial for tasks like object detection and medical imaging.\n",
+ "[Ultralytics YOLO11](https://github.com/ultralytics/ultralytics/) instance segmentation involves identifying and outlining individual objects in an image, providing a detailed understanding of spatial distribution. Unlike semantic segmentation, it uniquely labels and precisely delineates each object, crucial for tasks like object detection and medical imaging.\n",
"\n",
"There are two types of instance segmentation tracking available in the Ultralytics package:\n",
"\n",
@@ -144,7 +144,7 @@
"track_history = defaultdict(lambda: [])\n",
"\n",
"# Load the YOLO model with segmentation capabilities\n",
- "model = YOLO(\"yolov8n-seg.pt\")\n",
+ "model = YOLO(\"yolo11n-seg.pt\")\n",
"\n",
"# Open the video file\n",
"cap = cv2.VideoCapture(\"path/to/video/file.mp4\")\n",
@@ -214,15 +214,15 @@
"- [About Us](https://ultralytics.com/about): Discover our mission, vision, and the story behind Ultralytics.\n",
"- [Join Our Team](https://ultralytics.com/work): Explore career opportunities and join our team of talented professionals.\n",
"\n",
- "## YOLOv8 🚀 Resources\n",
+ "## YOLO11 🚀 Resources\n",
"\n",
- "YOLOv8 is the latest evolution in the YOLO series, offering state-of-the-art performance in object detection and image segmentation. Here are some essential resources to help you get started with YOLOv8:\n",
+ "YOLO11 is the latest evolution in the YOLO series, offering state-of-the-art performance in object detection and image segmentation. Here are some essential resources to help you get started with YOLO11:\n",
"\n",
- "- [GitHub](https://github.com/ultralytics/ultralytics): Access the YOLOv8 repository on GitHub, where you can find the source code, contribute to the project, and report issues.\n",
- "- [Docs](https://docs.ultralytics.com/): Explore the official documentation for YOLOv8, including installation guides, tutorials, and detailed API references.\n",
+ "- [GitHub](https://github.com/ultralytics/ultralytics): Access the YOLO11 repository on GitHub, where you can find the source code, contribute to the project, and report issues.\n",
+ "- [Docs](https://docs.ultralytics.com/): Explore the official documentation for YOLO11, including installation guides, tutorials, and detailed API references.\n",
"- [Discord](https://ultralytics.com/discord): Join our Discord community to connect with other users, share your projects, and get help from the Ultralytics team.\n",
"\n",
- "These resources are designed to help you leverage the full potential of Ultralytics' offerings and YOLOv8. Whether you're a beginner or an experienced developer, you'll find the information and support you need to succeed."
+ "These resources are designed to help you leverage the full potential of Ultralytics' offerings and YOLO11. Whether you're a beginner or an experienced developer, you'll find the information and support you need to succeed."
]
}
],
diff --git a/examples/tutorial.ipynb b/examples/tutorial.ipynb
index 8fbe02d018..0992abf460 100644
--- a/examples/tutorial.ipynb
+++ b/examples/tutorial.ipynb
@@ -3,7 +3,7 @@
"nbformat_minor": 0,
"metadata": {
"colab": {
- "name": "YOLOv8 Tutorial",
+ "name": "YOLO11 Tutorial",
"provenance": [],
"toc_visible": true
},
@@ -36,11 +36,11 @@
" ![\"Ultralytics](\"https://img.shields.io/discourse/users?server=https%3A%2F%2Fcommunity.ultralytics.com&logo=discourse&label=Forums&color=blue\")
\n",
" ![\"Ultralytics](\"https://img.shields.io/reddit/subreddit-subscribers/ultralytics?style=flat&logo=reddit&logoColor=white&label=Reddit&color=blue\")
\n",
"\n",
- "Welcome to the Ultralytics YOLOv8 🚀 notebook! YOLOv8 is the latest version of the YOLO (You Only Look Once) AI models developed by Ultralytics. This notebook serves as the starting point for exploring the various resources available to help you get started with YOLOv8 and understand its features and capabilities.\n",
+ "Welcome to the Ultralytics YOLO11 🚀 notebook! YOLO11 is the latest version of the YOLO (You Only Look Once) AI models developed by Ultralytics. This notebook serves as the starting point for exploring the various resources available to help you get started with YOLO11 and understand its features and capabilities.\n",
"\n",
- "YOLOv8 models are fast, accurate, and easy to use, making them ideal for various object detection and image segmentation tasks. They can be trained on large datasets and run on diverse hardware platforms, from CPUs to GPUs.\n",
+ "YOLO11 models are fast, accurate, and easy to use, making them ideal for various object detection and image segmentation tasks. They can be trained on large datasets and run on diverse hardware platforms, from CPUs to GPUs.\n",
"\n",
- "We hope that the resources in this notebook will help you get the most out of YOLOv8. Please browse the YOLOv8 Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
+ "We hope that the resources in this notebook will help you get the most out of YOLO11. Please browse the YOLO11 Docs for details, raise an issue on GitHub for support, and join our Discord community for questions and discussions!\n",
"\n",
""
]
@@ -65,21 +65,21 @@
"colab": {
"base_uri": "https://localhost:8080/"
},
- "outputId": "96335d4c-20a9-4864-f7a4-bb2eb0077a9d"
+ "outputId": "2e992f9f-90bb-4668-de12-fed629975285"
},
"source": [
"%pip install ultralytics\n",
"import ultralytics\n",
"ultralytics.checks()"
],
- "execution_count": null,
+ "execution_count": 1,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
- "Ultralytics YOLOv8.2.3 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
- "Setup complete ✅ (2 CPUs, 12.7 GB RAM, 28.8/78.2 GB disk)\n"
+ "Ultralytics 8.3.2 🚀 Python-3.10.12 torch-2.4.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+ "Setup complete ✅ (2 CPUs, 12.7 GB RAM, 41.1/112.6 GB disk)\n"
]
}
]
@@ -92,7 +92,7 @@
"source": [
"# 1. Predict\n",
"\n",
- "YOLOv8 may be used directly in the Command Line Interface (CLI) with a `yolo` command for a variety of tasks and modes and accepts additional arguments, i.e. `imgsz=640`. See a full list of available `yolo` [arguments](https://docs.ultralytics.com/usage/cfg/) and other details in the [YOLOv8 Predict Docs](https://docs.ultralytics.com/modes/train/).\n"
+ "YOLO11 may be used directly in the Command Line Interface (CLI) with a `yolo` command for a variety of tasks and modes and accepts additional arguments, i.e. `imgsz=640`. See a full list of available `yolo` [arguments](https://docs.ultralytics.com/usage/cfg/) and other details in the [YOLO11 Predict Docs](https://docs.ultralytics.com/modes/train/).\n"
]
},
{
@@ -102,27 +102,27 @@
"colab": {
"base_uri": "https://localhost:8080/"
},
- "outputId": "84f32db2-80b0-4f35-9a2a-a56d11f7863f"
+ "outputId": "e3ebec6f-658a-4803-d80c-e07d12908767"
},
"source": [
- "# Run inference on an image with YOLOv8n\n",
- "!yolo predict model=yolov8n.pt source='https://ultralytics.com/images/zidane.jpg'"
+ "# Run inference on an image with YOLO11n\n",
+ "!yolo predict model=yolo11n.pt source='https://ultralytics.com/images/zidane.jpg'"
],
- "execution_count": null,
+ "execution_count": 2,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
- "Downloading https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n.pt to 'yolov8n.pt'...\n",
- "100% 6.23M/6.23M [00:00<00:00, 83.2MB/s]\n",
- "Ultralytics YOLOv8.2.3 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
- "YOLOv8n summary (fused): 168 layers, 3151904 parameters, 0 gradients, 8.7 GFLOPs\n",
+ "Downloading https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt to 'yolo11n.pt'...\n",
+ "100% 5.35M/5.35M [00:00<00:00, 72.7MB/s]\n",
+ "Ultralytics 8.3.2 🚀 Python-3.10.12 torch-2.4.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+ "YOLO11n summary (fused): 238 layers, 2,616,248 parameters, 0 gradients, 6.5 GFLOPs\n",
"\n",
"Downloading https://ultralytics.com/images/zidane.jpg to 'zidane.jpg'...\n",
- "100% 165k/165k [00:00<00:00, 11.1MB/s]\n",
- "image 1/1 /content/zidane.jpg: 384x640 2 persons, 1 tie, 21.4ms\n",
- "Speed: 1.9ms preprocess, 21.4ms inference, 6.2ms postprocess per image at shape (1, 3, 384, 640)\n",
+ "100% 49.2k/49.2k [00:00<00:00, 5.37MB/s]\n",
+ "image 1/1 /content/zidane.jpg: 384x640 2 persons, 1 tie, 63.4ms\n",
+ "Speed: 14.5ms preprocess, 63.4ms inference, 820.9ms postprocess per image at shape (1, 3, 384, 640)\n",
"Results saved to \u001b[1mruns/detect/predict\u001b[0m\n",
"💡 Learn more at https://docs.ultralytics.com/modes/predict\n"
]
@@ -146,7 +146,7 @@
},
"source": [
"# 2. Val\n",
- "Validate a model's accuracy on the [COCO](https://docs.ultralytics.com/datasets/detect/coco/) dataset's `val` or `test` splits. The latest YOLOv8 [models](https://github.com/ultralytics/ultralytics#models) are downloaded automatically the first time they are used. See [YOLOv8 Val Docs](https://docs.ultralytics.com/modes/val/) for more information."
+ "Validate a model's accuracy on the [COCO](https://docs.ultralytics.com/datasets/detect/coco/) dataset's `val` or `test` splits. The latest YOLO11 [models](https://github.com/ultralytics/ultralytics#models) are downloaded automatically the first time they are used. See [YOLO11 Val Docs](https://docs.ultralytics.com/modes/val/) for more information."
]
},
{
@@ -167,43 +167,43 @@
"cell_type": "code",
"metadata": {
"id": "X58w8JLpMnjH",
- "outputId": "bed10d45-ceb6-4b6f-86b7-9428208b142a",
+ "outputId": "af2a5deb-029b-466d-96a4-bd3e406987fa",
"colab": {
"base_uri": "https://localhost:8080/"
}
},
"source": [
- "# Validate YOLOv8n on COCO8 val\n",
- "!yolo val model=yolov8n.pt data=coco8.yaml"
+ "# Validate YOLO11n on COCO8 val\n",
+ "!yolo val model=yolo11n.pt data=coco8.yaml"
],
- "execution_count": null,
+ "execution_count": 3,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
- "Ultralytics YOLOv8.2.3 🚀 Python-3.10.12 torch-2.2.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
- "YOLOv8n summary (fused): 168 layers, 3151904 parameters, 0 gradients, 8.7 GFLOPs\n",
+ "Ultralytics 8.3.2 🚀 Python-3.10.12 torch-2.4.1+cu121 CUDA:0 (Tesla T4, 15102MiB)\n",
+ "YOLO11n summary (fused): 238 layers, 2,616,248 parameters, 0 gradients, 6.5 GFLOPs\n",
"\n",
"Dataset 'coco8.yaml' images not found ⚠️, missing path '/content/datasets/coco8/images/val'\n",
"Downloading https://ultralytics.com/assets/coco8.zip to '/content/datasets/coco8.zip'...\n",
- "100% 433k/433k [00:00<00:00, 14.2MB/s]\n",
- "Unzipping /content/datasets/coco8.zip to /content/datasets/coco8...: 100% 25/25 [00:00<00:00, 1093.93file/s]\n",
- "Dataset download success ✅ (1.3s), saved to \u001b[1m/content/datasets\u001b[0m\n",
+ "100% 433k/433k [00:00<00:00, 15.8MB/s]\n",
+ "Unzipping /content/datasets/coco8.zip to /content/datasets/coco8...: 100% 25/25 [00:00<00:00, 1188.35file/s]\n",
+ "Dataset download success ✅ (1.4s), saved to \u001b[1m/content/datasets\u001b[0m\n",
"\n",
"Downloading https://ultralytics.com/assets/Arial.ttf to '/root/.config/Ultralytics/Arial.ttf'...\n",
- "100% 755k/755k [00:00<00:00, 17.4MB/s]\n",
- "\u001b[34m\u001b[1mval: \u001b[0mScanning /content/datasets/coco8/labels/val... 4 images, 0 backgrounds, 0 corrupt: 100% 4/4 [00:00<00:00, 157.00it/s]\n",
+ "100% 755k/755k [00:00<00:00, 17.7MB/s]\n",
+ "\u001b[34m\u001b[1mval: \u001b[0mScanning /content/datasets/coco8/labels/val... 4 images, 0 backgrounds, 0 corrupt: 100% 4/4 [00:00<00:00, 142.04it/s]\n",
"\u001b[34m\u001b[1mval: \u001b[0mNew cache created: /content/datasets/coco8/labels/val.cache\n",
- " Class Images Instances Box(P R mAP50 mAP50-95): 100% 1/1 [00:06<00:00, 6.89s/it]\n",
- " all 4 17 0.621 0.833 0.888 0.63\n",
- " person 4 10 0.721 0.5 0.519 0.269\n",
- " dog 4 1 0.37 1 0.995 0.597\n",
- " horse 4 2 0.751 1 0.995 0.631\n",
- " elephant 4 2 0.505 0.5 0.828 0.394\n",
- " umbrella 4 1 0.564 1 0.995 0.995\n",
- " potted plant 4 1 0.814 1 0.995 0.895\n",
- "Speed: 0.3ms preprocess, 4.9ms inference, 0.0ms loss, 1.3ms postprocess per image\n",
+ " Class Images Instances Box(P R mAP50 mAP50-95): 100% 1/1 [00:04<00:00, 4.75s/it]\n",
+ " all 4 17 0.57 0.85 0.847 0.632\n",
+ " person 3 10 0.557 0.6 0.585 0.272\n",
+ " dog 1 1 0.548 1 0.995 0.697\n",
+ " horse 1 2 0.531 1 0.995 0.674\n",
+ " elephant 1 2 0.371 0.5 0.516 0.256\n",
+ " umbrella 1 1 0.569 1 0.995 0.995\n",
+ " potted plant 1 1 0.847 1 0.995 0.895\n",
+ "Speed: 1.0ms preprocess, 73.8ms inference, 0.0ms loss, 561.4ms postprocess per image\n",
"Results saved to \u001b[1mruns/detect/val\u001b[0m\n",
"💡 Learn more at https://docs.ultralytics.com/modes/val\n"
]
@@ -220,13 +220,13 @@
"\n",
"![](\"https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png\"/)
![](\"https://raw.githubusercontent.com/ultralytics/assets/main/im/banner-tasks.png\")
\n"
],
@@ -463,7 +461,7 @@
"source": [
"## 1. Detection\n",
"\n",
- "YOLOv8 _detection_ models have no suffix and are the default YOLOv8 models, i.e. `yolov8n.pt` and are pretrained on COCO. See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for full details.\n"
+ "YOLO11 _detection_ models have no suffix and are the default YOLO11 models, i.e. `yolo11n.pt` and are pretrained on COCO. See [Detection Docs](https://docs.ultralytics.com/tasks/detect/) for full details.\n"
],
"metadata": {
"id": "yq26lwpYK1lq"
@@ -472,10 +470,10 @@
{
"cell_type": "code",
"source": [
- "# Load YOLOv8n, train it on COCO128 for 3 epochs and predict an image with it\n",
+ "# Load YOLO11n, train it on COCO128 for 3 epochs and predict an image with it\n",
"from ultralytics import YOLO\n",
"\n",
- "model = YOLO('yolov8n.pt') # load a pretrained YOLOv8n detection model\n",
+ "model = YOLO('yolo11n.pt') # load a pretrained YOLO detection model\n",
"model.train(data='coco8.yaml', epochs=3) # train the model\n",
"model('https://ultralytics.com/images/bus.jpg') # predict on an image"
],
@@ -490,7 +488,7 @@
"source": [
"## 2. Segmentation\n",
"\n",
- "YOLOv8 _segmentation_ models use the `-seg` suffix, i.e. `yolov8n-seg.pt` and are pretrained on COCO. See [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for full details.\n"
+ "YOLO11 _segmentation_ models use the `-seg` suffix, i.e. `yolo11n-seg.pt` and are pretrained on COCO. See [Segmentation Docs](https://docs.ultralytics.com/tasks/segment/) for full details.\n"
],
"metadata": {
"id": "7ZW58jUzK66B"
@@ -499,10 +497,10 @@
{
"cell_type": "code",
"source": [
- "# Load YOLOv8n-seg, train it on COCO128-seg for 3 epochs and predict an image with it\n",
+ "# Load YOLO11n-seg, train it on COCO128-seg for 3 epochs and predict an image with it\n",
"from ultralytics import YOLO\n",
"\n",
- "model = YOLO('yolov8n-seg.pt') # load a pretrained YOLOv8n segmentation model\n",
+ "model = YOLO('yolo11n-seg.pt') # load a pretrained YOLO segmentation model\n",
"model.train(data='coco8-seg.yaml', epochs=3) # train the model\n",
"model('https://ultralytics.com/images/bus.jpg') # predict on an image"
],
@@ -517,7 +515,7 @@
"source": [
"## 3. Classification\n",
"\n",
- "YOLOv8 _classification_ models use the `-cls` suffix, i.e. `yolov8n-cls.pt` and are pretrained on ImageNet. See [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for full details.\n"
+ "YOLO11 _classification_ models use the `-cls` suffix, i.e. `yolo11n-cls.pt` and are pretrained on ImageNet. See [Classification Docs](https://docs.ultralytics.com/tasks/classify/) for full details.\n"
],
"metadata": {
"id": "ax3p94VNK9zR"
@@ -526,10 +524,10 @@
{
"cell_type": "code",
"source": [
- "# Load YOLOv8n-cls, train it on mnist160 for 3 epochs and predict an image with it\n",
+ "# Load YOLO11n-cls, train it on mnist160 for 3 epochs and predict an image with it\n",
"from ultralytics import YOLO\n",
"\n",
- "model = YOLO('yolov8n-cls.pt') # load a pretrained YOLOv8n classification model\n",
+ "model = YOLO('yolo11n-cls.pt') # load a pretrained YOLO classification model\n",
"model.train(data='mnist160', epochs=3) # train the model\n",
"model('https://ultralytics.com/images/bus.jpg') # predict on an image"
],
@@ -544,7 +542,7 @@
"source": [
"## 4. Pose\n",
"\n",
- "YOLOv8 _pose_ models use the `-pose` suffix, i.e. `yolov8n-pose.pt` and are pretrained on COCO Keypoints. See [Pose Docs](https://docs.ultralytics.com/tasks/pose/) for full details."
+ "YOLO11 _pose_ models use the `-pose` suffix, i.e. `yolo11n-pose.pt` and are pretrained on COCO Keypoints. See [Pose Docs](https://docs.ultralytics.com/tasks/pose/) for full details."
],
"metadata": {
"id": "SpIaFLiO11TG"
@@ -553,10 +551,10 @@
{
"cell_type": "code",
"source": [
- "# Load YOLOv8n-pose, train it on COCO8-pose for 3 epochs and predict an image with it\n",
+ "# Load YOLO11n-pose, train it on COCO8-pose for 3 epochs and predict an image with it\n",
"from ultralytics import YOLO\n",
"\n",
- "model = YOLO('yolov8n-pose.pt') # load a pretrained YOLOv8n pose model\n",
+ "model = YOLO('yolo11n-pose.pt') # load a pretrained YOLO pose model\n",
"model.train(data='coco8-pose.yaml', epochs=3) # train the model\n",
"model('https://ultralytics.com/images/bus.jpg') # predict on an image"
],
@@ -571,7 +569,7 @@
"source": [
"## 4. Oriented Bounding Boxes (OBB)\n",
"\n",
- "YOLOv8 _OBB_ models use the `-obb` suffix, i.e. `yolov8n-obb.pt` and are pretrained on the DOTA dataset. See [OBB Docs](https://docs.ultralytics.com/tasks/obb/) for full details."
+ "YOLO11 _OBB_ models use the `-obb` suffix, i.e. `yolo11n-obb.pt` and are pretrained on the DOTA dataset. See [OBB Docs](https://docs.ultralytics.com/tasks/obb/) for full details."
],
"metadata": {
"id": "cf5j_T9-B5F0"
@@ -580,10 +578,10 @@
{
"cell_type": "code",
"source": [
- "# Load YOLOv8n-obb, train it on DOTA8 for 3 epochs and predict an image with it\n",
+ "# Load YOLO11n-obb, train it on DOTA8 for 3 epochs and predict an image with it\n",
"from ultralytics import YOLO\n",
"\n",
- "model = YOLO('yolov8n-obb.pt') # load a pretrained YOLOv8n OBB model\n",
+ "model = YOLO('yolo11n-obb.pt') # load a pretrained YOLO OBB model\n",
"model.train(data='coco8-dota.yaml', epochs=3) # train the model\n",
"model('https://ultralytics.com/images/bus.jpg') # predict on an image"
],
@@ -646,7 +644,7 @@
"source": [
"# Validate multiple models\n",
"for x in 'nsmlx':\n",
- " !yolo val model=yolov8{x}.pt data=coco.yaml"
+ " !yolo val model=yolo11{x}.pt data=coco.yaml"
],
"metadata": {
"id": "Wdc6t_bfzDDk"
diff --git a/mkdocs.yml b/mkdocs.yml
index 1ec7c9c22e..f3e7d9d106 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -251,6 +251,7 @@ nav:
- YOLOv8: models/yolov8.md
- YOLOv9: models/yolov9.md
- YOLOv10: models/yolov10.md
+ - NEW 🚀 YOLO11: models/yolo11.md
- SAM (Segment Anything Model): models/sam.md
- SAM 2 (Segment Anything Model 2): models/sam-2.md
- MobileSAM (Mobile Segment Anything Model): models/mobile-sam.md
@@ -294,6 +295,7 @@ nav:
- COCO: datasets/pose/coco.md
- COCO8-pose: datasets/pose/coco8-pose.md
- Tiger-pose: datasets/pose/tiger-pose.md
+ - Hand-keypoints: datasets/pose/hand-keypoints.md
- Classification:
- datasets/classify/index.md
- Caltech 101: datasets/classify/caltech101.md
diff --git a/pyproject.toml b/pyproject.toml
index 51593636dc..0a88360baa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,14 +30,14 @@ description = "Ultralytics YOLO for SOTA object detection, multi-object tracking
readme = "README.md"
requires-python = ">=3.8"
license = { "text" = "AGPL-3.0" }
-keywords = ["machine-learning", "deep-learning", "computer-vision", "ML", "DL", "AI", "YOLO", "YOLOv3", "YOLOv5", "YOLOv8", "YOLOv9", "YOLOv10", "HUB", "Ultralytics"]
+keywords = ["machine-learning", "deep-learning", "computer-vision", "ML", "DL", "AI", "YOLO", "YOLOv3", "YOLOv5", "YOLOv8", "YOLOv9", "YOLOv10", "YOLO11", "HUB", "Ultralytics"]
authors = [
- { name = "Glenn Jocher", email = "glenn.jocher@ultralytics.com"},
- { name = "Jing Qiu", email = "jing.qiu@ultralytics.com"},
- { name = "Ayush Chaurasia" }
+ { name = "Glenn Jocher", email = "glenn.jocher@ultralytics.com" },
+ { name = "Jing Qiu", email = "jing.qiu@ultralytics.com" },
+ { name = "Ayush Chaurasia" },
]
maintainers = [
- { name = "Ultralytics", email = "hello@ultralytics.com" }
+ { name = "Ultralytics", email = "hello@ultralytics.com" },
]
classifiers = [
"Development Status :: 4 - Beta",
@@ -62,7 +62,7 @@ classifiers = [
# Required dependencies ------------------------------------------------------------------------------------------------
dependencies = [
- "numpy>=1.23.0,<2.0.0", # temporary patch for compat errors https://github.com/ultralytics/yolov5/actions/runs/9538130424/job/26286956354
+ "numpy>=1.23.0", # temporary patch for compat errors https://github.com/ultralytics/yolov5/actions/runs/9538130424/job/26286956354
"matplotlib>=3.3.0",
"opencv-python>=4.6.0",
"pillow>=7.1.2",
@@ -70,7 +70,7 @@ dependencies = [
"requests>=2.23.0",
"scipy>=1.4.1",
"torch>=1.8.0",
- "torch>=1.8.0,!=2.4.0; sys_platform == 'win32'", # Windows CPU errors w/ 2.4.0 https://github.com/ultralytics/ultralytics/issues/15049
+ "torch>=1.8.0,!=2.4.0; sys_platform == 'win32'", # Windows CPU errors w/ 2.4.0 https://github.com/ultralytics/ultralytics/issues/15049
"torchvision>=0.9.0",
"tqdm>=4.64.0", # progress bars
"psutil", # system utilization
@@ -98,11 +98,12 @@ dev = [
export = [
"onnx>=1.12.0", # ONNX export
"coremltools>=7.0; platform_system != 'Windows' and python_version <= '3.11'", # CoreML supported on macOS and Linux
+ "scikit-learn>=1.3.2; platform_system != 'Windows' and python_version <= '3.11'", # CoreML k-means quantization
"openvino>=2024.0.0", # OpenVINO export
"tensorflow>=2.0.0", # TF bug https://github.com/ultralytics/ultralytics/issues/5161
"tensorflowjs>=3.9.0", # TF.js export, automatically installs tensorflow
- "tensorstore>=0.1.63; platform_machine == 'aarch64' and python_version >= '3.9'", # for TF Raspberry Pi exports
- "keras", # not installed automatically by tensorflow>=2.16
+ "tensorstore>=0.1.63; platform_machine == 'aarch64' and python_version >= '3.9'", # for TF Raspberry Pi exports
+ "keras", # not installed automatically by tensorflow>=2.16
"flatbuffers>=23.5.26,<100; platform_machine == 'aarch64'", # update old 'flatbuffers' included inside tensorflow package
"numpy==1.23.5; platform_machine == 'aarch64'", # fix error: `np.bool` was a deprecated alias for the builtin `bool` when using TensorRT models on NVIDIA Jetson
"h5py!=3.11.0; platform_machine == 'aarch64'", # fix h5py build issues due to missing aarch64 wheels in 3.11 release
@@ -118,7 +119,7 @@ logging = [
"dvclive>=2.12.0",
]
extra = [
- "hub-sdk>=0.0.8", # Ultralytics HUB
+ "hub-sdk>=0.0.12", # Ultralytics HUB
"ipython", # interactive notebook
"albumentations>=1.4.6", # training augmentations
"pycocotools>=2.0.7", # COCO mAP
@@ -129,7 +130,7 @@ extra = [
"Source" = "https://github.com/ultralytics/ultralytics"
"Documentation" = "https://docs.ultralytics.com"
"Bug Reports" = "https://github.com/ultralytics/ultralytics/issues"
-"Changelog" = "https://github.com/ultralytics/ultralytics/releases"
+"Changelog" = "https://github.com/ultralytics/ultralytics/releases"
[project.scripts]
yolo = "ultralytics.cfg:entrypoint"
diff --git a/tests/__init__.py b/tests/__init__.py
index ea6b398292..ea8afff5a8 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -3,8 +3,8 @@
from ultralytics.utils import ASSETS, ROOT, WEIGHTS_DIR, checks
# Constants used in tests
-MODEL = WEIGHTS_DIR / "path with spaces" / "yolov8n.pt" # test spaces in path
-CFG = "yolov8n.yaml"
+MODEL = WEIGHTS_DIR / "path with spaces" / "yolo11n.pt" # test spaces in path
+CFG = "yolo11n.yaml"
SOURCE = ASSETS / "bus.jpg"
SOURCES_LIST = [ASSETS / "bus.jpg", ASSETS, ASSETS / "*", ASSETS / "**/*.jpg"]
TMP = (ROOT / "../tests/tmp").resolve() # temp directory for test files
diff --git a/tests/conftest.py b/tests/conftest.py
index faba91b2be..7b0539b467 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -74,7 +74,7 @@ def pytest_terminal_summary(terminalreporter, exitstatus, config):
# Remove files
models = [path for x in ["*.onnx", "*.torchscript"] for path in WEIGHTS_DIR.rglob(x)]
- for file in ["bus.jpg", "yolov8n.onnx", "yolov8n.torchscript"] + models:
+ for file in ["bus.jpg", "yolo11n.onnx", "yolo11n.torchscript"] + models:
Path(file).unlink(missing_ok=True)
# Remove directories
diff --git a/tests/test_cuda.py b/tests/test_cuda.py
index 3c3ba174d1..3b08edc699 100644
--- a/tests/test_cuda.py
+++ b/tests/test_cuda.py
@@ -10,6 +10,7 @@ from tests import CUDA_DEVICE_COUNT, CUDA_IS_AVAILABLE, MODEL, SOURCE
from ultralytics import YOLO
from ultralytics.cfg import TASK2DATA, TASK2MODEL, TASKS
from ultralytics.utils import ASSETS, WEIGHTS_DIR
+from ultralytics.utils.checks import check_amp
def test_checks():
@@ -18,6 +19,13 @@ def test_checks():
assert torch.cuda.device_count() == CUDA_DEVICE_COUNT
+@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
+def test_amp():
+ """Test AMP training checks."""
+ model = YOLO("yolo11n.pt").model.cuda()
+ assert check_amp(model)
+
+
@pytest.mark.slow
@pytest.mark.skipif(True, reason="CUDA export tests disabled pending additional Ultralytics GPU server availability")
@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
@@ -60,7 +68,7 @@ def test_train():
@pytest.mark.skipif(not CUDA_IS_AVAILABLE, reason="CUDA is not available")
def test_predict_multiple_devices():
"""Validate model prediction consistency across CPU and CUDA devices."""
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
model = model.cpu()
assert str(model.device) == "cpu"
_ = model(SOURCE) # CPU inference
diff --git a/tests/test_engine.py b/tests/test_engine.py
index 92373044ef..aa4b671eaa 100644
--- a/tests/test_engine.py
+++ b/tests/test_engine.py
@@ -21,13 +21,13 @@ def test_export():
exporter = Exporter()
exporter.add_callback("on_export_start", test_func)
assert test_func in exporter.callbacks["on_export_start"], "callback test failed"
- f = exporter(model=YOLO("yolov8n.yaml").model)
+ f = exporter(model=YOLO("yolo11n.yaml").model)
YOLO(f)(ASSETS) # exported model inference
def test_detect():
"""Test YOLO object detection training, validation, and prediction functionality."""
- overrides = {"data": "coco8.yaml", "model": "yolov8n.yaml", "imgsz": 32, "epochs": 1, "save": False}
+ overrides = {"data": "coco8.yaml", "model": "yolo11n.yaml", "imgsz": 32, "epochs": 1, "save": False}
cfg = get_cfg(DEFAULT_CFG)
cfg.data = "coco8.yaml"
cfg.imgsz = 32
@@ -66,7 +66,7 @@ def test_detect():
def test_segment():
"""Tests image segmentation training, validation, and prediction pipelines using YOLO models."""
- overrides = {"data": "coco8-seg.yaml", "model": "yolov8n-seg.yaml", "imgsz": 32, "epochs": 1, "save": False}
+ overrides = {"data": "coco8-seg.yaml", "model": "yolo11n-seg.yaml", "imgsz": 32, "epochs": 1, "save": False}
cfg = get_cfg(DEFAULT_CFG)
cfg.data = "coco8-seg.yaml"
cfg.imgsz = 32
@@ -88,7 +88,7 @@ def test_segment():
pred = segment.SegmentationPredictor(overrides={"imgsz": [64, 64]})
pred.add_callback("on_predict_start", test_func)
assert test_func in pred.callbacks["on_predict_start"], "callback test failed"
- result = pred(source=ASSETS, model=WEIGHTS_DIR / "yolov8n-seg.pt")
+ result = pred(source=ASSETS, model=WEIGHTS_DIR / "yolo11n-seg.pt")
assert len(result), "predictor test failed"
# Test resume
@@ -105,7 +105,7 @@ def test_segment():
def test_classify():
"""Test image classification including training, validation, and prediction phases."""
- overrides = {"data": "imagenet10", "model": "yolov8n-cls.yaml", "imgsz": 32, "epochs": 1, "save": False}
+ overrides = {"data": "imagenet10", "model": "yolo11n-cls.yaml", "imgsz": 32, "epochs": 1, "save": False}
cfg = get_cfg(DEFAULT_CFG)
cfg.data = "imagenet10"
cfg.imgsz = 32
diff --git a/tests/test_explorer.py b/tests/test_explorer.py
index b13bb86828..45b0a31e36 100644
--- a/tests/test_explorer.py
+++ b/tests/test_explorer.py
@@ -30,7 +30,7 @@ def test_similarity():
@pytest.mark.skipif(not TORCH_1_13, reason="Explorer requires torch>=1.13")
def test_det():
"""Test detection functionalities and verify embedding table includes bounding boxes."""
- exp = Explorer(data="coco8.yaml", model="yolov8n.pt")
+ exp = Explorer(data="coco8.yaml", model="yolo11n.pt")
exp.create_embeddings_table(force=True)
assert len(exp.table.head()["bboxes"]) > 0
similar = exp.get_similar(idx=[1, 2], limit=10)
@@ -44,7 +44,7 @@ def test_det():
@pytest.mark.skipif(not TORCH_1_13, reason="Explorer requires torch>=1.13")
def test_seg():
"""Test segmentation functionalities and ensure the embedding table includes segmentation masks."""
- exp = Explorer(data="coco8-seg.yaml", model="yolov8n-seg.pt")
+ exp = Explorer(data="coco8-seg.yaml", model="yolo11n-seg.pt")
exp.create_embeddings_table(force=True)
assert len(exp.table.head()["masks"]) > 0
similar = exp.get_similar(idx=[1, 2], limit=10)
@@ -57,7 +57,7 @@ def test_seg():
@pytest.mark.skipif(not TORCH_1_13, reason="Explorer requires torch>=1.13")
def test_pose():
"""Test pose estimation functionality and verify the embedding table includes keypoints."""
- exp = Explorer(data="coco8-pose.yaml", model="yolov8n-pose.pt")
+ exp = Explorer(data="coco8-pose.yaml", model="yolo11n-pose.pt")
exp.create_embeddings_table(force=True)
assert len(exp.table.head()["keypoints"]) > 0
similar = exp.get_similar(idx=[1, 2], limit=10)
diff --git a/tests/test_exports.py b/tests/test_exports.py
index 98e4049d79..e6e2ec1598 100644
--- a/tests/test_exports.py
+++ b/tests/test_exports.py
@@ -40,7 +40,6 @@ def test_export_openvino():
@pytest.mark.slow
-@pytest.mark.skipif(checks.IS_PYTHON_3_12, reason="OpenVINO not supported in Python 3.12")
@pytest.mark.skipif(not TORCH_1_13, reason="OpenVINO requires torch>=1.13")
@pytest.mark.parametrize(
"task, dynamic, int8, half, batch",
@@ -187,7 +186,7 @@ def test_export_pb():
YOLO(file)(SOURCE, imgsz=32)
-@pytest.mark.skipif(True, reason="Test disabled as Paddle protobuf and ONNX protobuf requirementsk conflict.")
+@pytest.mark.skipif(True, reason="Test disabled as Paddle protobuf and ONNX protobuf requirements conflict.")
def test_export_paddle():
"""Test YOLO exports to Paddle format, noting protobuf conflicts with ONNX."""
YOLO(MODEL).export(format="paddle", imgsz=32)
diff --git a/tests/test_integrations.py b/tests/test_integrations.py
index 3a0d1b48a7..4c8e066978 100644
--- a/tests/test_integrations.py
+++ b/tests/test_integrations.py
@@ -17,7 +17,7 @@ from ultralytics.utils.checks import check_requirements
@pytest.mark.skipif(not check_requirements("ray", install=False), reason="ray[tune] not installed")
def test_model_ray_tune():
"""Tune YOLO model using Ray for hyperparameter optimization."""
- YOLO("yolov8n-cls.yaml").tune(
+ YOLO("yolo11n-cls.yaml").tune(
use_ray=True, data="imagenet10", grace_period=1, iterations=1, imgsz=32, epochs=1, plots=False, device="cpu"
)
@@ -26,7 +26,7 @@ def test_model_ray_tune():
def test_mlflow():
"""Test training with MLflow tracking enabled (see https://mlflow.org/ for details)."""
SETTINGS["mlflow"] = True
- YOLO("yolov8n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=3, plots=False, device="cpu")
+ YOLO("yolo11n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=3, plots=False, device="cpu")
SETTINGS["mlflow"] = False
@@ -42,7 +42,7 @@ def test_mlflow_keep_run_active():
# Test with MLFLOW_KEEP_RUN_ACTIVE=True
os.environ["MLFLOW_KEEP_RUN_ACTIVE"] = "True"
- YOLO("yolov8n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
+ YOLO("yolo11n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
status = mlflow.active_run().info.status
assert status == "RUNNING", "MLflow run should be active when MLFLOW_KEEP_RUN_ACTIVE=True"
@@ -50,13 +50,13 @@ def test_mlflow_keep_run_active():
# Test with MLFLOW_KEEP_RUN_ACTIVE=False
os.environ["MLFLOW_KEEP_RUN_ACTIVE"] = "False"
- YOLO("yolov8n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
+ YOLO("yolo11n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
status = mlflow.get_run(run_id=run_id).info.status
assert status == "FINISHED", "MLflow run should be ended when MLFLOW_KEEP_RUN_ACTIVE=False"
# Test with MLFLOW_KEEP_RUN_ACTIVE not set
os.environ.pop("MLFLOW_KEEP_RUN_ACTIVE", None)
- YOLO("yolov8n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
+ YOLO("yolo11n-cls.yaml").train(data="imagenet10", imgsz=32, epochs=1, plots=False, device="cpu")
status = mlflow.get_run(run_id=run_id).info.status
assert status == "FINISHED", "MLflow run should be ended by default when MLFLOW_KEEP_RUN_ACTIVE is not set"
SETTINGS["mlflow"] = False
@@ -126,23 +126,23 @@ def test_pycocotools():
from ultralytics.models.yolo.segment import SegmentationValidator
# Download annotations after each dataset downloads first
- url = "https://github.com/ultralytics/assets/releases/download/v8.2.0/"
+ url = "https://github.com/ultralytics/assets/releases/download/v0.0.0/"
- args = {"model": "yolov8n.pt", "data": "coco8.yaml", "save_json": True, "imgsz": 64}
+ args = {"model": "yolo11n.pt", "data": "coco8.yaml", "save_json": True, "imgsz": 64}
validator = DetectionValidator(args=args)
validator()
validator.is_coco = True
download(f"{url}instances_val2017.json", dir=DATASETS_DIR / "coco8/annotations")
_ = validator.eval_json(validator.stats)
- args = {"model": "yolov8n-seg.pt", "data": "coco8-seg.yaml", "save_json": True, "imgsz": 64}
+ args = {"model": "yolo11n-seg.pt", "data": "coco8-seg.yaml", "save_json": True, "imgsz": 64}
validator = SegmentationValidator(args=args)
validator()
validator.is_coco = True
download(f"{url}instances_val2017.json", dir=DATASETS_DIR / "coco8-seg/annotations")
_ = validator.eval_json(validator.stats)
- args = {"model": "yolov8n-pose.pt", "data": "coco8-pose.yaml", "save_json": True, "imgsz": 64}
+ args = {"model": "yolo11n-pose.pt", "data": "coco8-pose.yaml", "save_json": True, "imgsz": 64}
validator = PoseValidator(args=args)
validator()
validator.is_coco = True
diff --git a/tests/test_python.py b/tests/test_python.py
index 55f087f008..117e6f802e 100644
--- a/tests/test_python.py
+++ b/tests/test_python.py
@@ -211,7 +211,7 @@ def test_train_scratch():
def test_train_pretrained():
"""Test training of the YOLO model starting from a pre-trained checkpoint."""
- model = YOLO(WEIGHTS_DIR / "yolov8n-seg.pt")
+ model = YOLO(WEIGHTS_DIR / "yolo11n-seg.pt")
model.train(data="coco8-seg.yaml", epochs=1, imgsz=32, cache="ram", copy_paste=0.5, mixup=0.5, name=0)
model(SOURCE)
@@ -281,13 +281,13 @@ def test_results(model):
def test_labels_and_crops():
"""Test output from prediction args for saving YOLO detection labels and crops; ensures accurate saving."""
imgs = [SOURCE, ASSETS / "zidane.jpg"]
- results = YOLO(WEIGHTS_DIR / "yolov8n.pt")(imgs, imgsz=160, save_txt=True, save_crop=True)
+ results = YOLO(WEIGHTS_DIR / "yolo11n.pt")(imgs, imgsz=160, save_txt=True, save_crop=True)
save_path = Path(results[0].save_dir)
for r in results:
im_name = Path(r.path).stem
cls_idxs = r.boxes.cls.int().tolist()
# Check correct detections
- assert cls_idxs == ([0, 0, 5, 0, 7] if r.path.endswith("bus.jpg") else [0, 0]) # bus.jpg and zidane.jpg classes
+ assert cls_idxs == ([0, 7, 0, 0] if r.path.endswith("bus.jpg") else [0, 0, 0]) # bus.jpg and zidane.jpg classes
# Check label path
labels = save_path / f"labels/{im_name}.txt"
assert labels.exists()
@@ -339,7 +339,7 @@ def test_data_annotator():
auto_annotate(
ASSETS,
- det_model=WEIGHTS_DIR / "yolov8n.pt",
+ det_model=WEIGHTS_DIR / "yolo11n.pt",
sam_model=WEIGHTS_DIR / "mobile_sam.pt",
output_dir=TMP / "auto_annotate_labels",
)
@@ -393,7 +393,7 @@ def test_utils_benchmarks():
"""Benchmark model performance using 'ProfileModels' from 'ultralytics.utils.benchmarks'."""
from ultralytics.utils.benchmarks import ProfileModels
- ProfileModels(["yolov8n.yaml"], imgsz=32, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
+ ProfileModels(["yolo11n.yaml"], imgsz=32, min_time=1, num_timed_runs=3, num_warmup_runs=1).profile()
def test_utils_torchutils():
@@ -568,14 +568,14 @@ def test_classify_transforms_train(image, auto_augment, erasing, force_color_jit
@pytest.mark.skipif(not ONLINE, reason="environment is offline")
def test_model_tune():
"""Tune YOLO model for performance improvement."""
- YOLO("yolov8n-pose.pt").tune(data="coco8-pose.yaml", plots=False, imgsz=32, epochs=1, iterations=2, device="cpu")
- YOLO("yolov8n-cls.pt").tune(data="imagenet10", plots=False, imgsz=32, epochs=1, iterations=2, device="cpu")
+ YOLO("yolo11n-pose.pt").tune(data="coco8-pose.yaml", plots=False, imgsz=32, epochs=1, iterations=2, device="cpu")
+ YOLO("yolo11n-cls.pt").tune(data="imagenet10", plots=False, imgsz=32, epochs=1, iterations=2, device="cpu")
def test_model_embeddings():
"""Test YOLO model embeddings."""
model_detect = YOLO(MODEL)
- model_segment = YOLO(WEIGHTS_DIR / "yolov8n-seg.pt")
+ model_segment = YOLO(WEIGHTS_DIR / "yolo11n-seg.pt")
for batch in [SOURCE], [SOURCE, SOURCE]: # test batch size 1 and 2
assert len(model_detect.embed(source=batch, imgsz=32)) == len(batch)
@@ -585,11 +585,11 @@ def test_model_embeddings():
@pytest.mark.skipif(checks.IS_PYTHON_3_12, reason="YOLOWorld with CLIP is not supported in Python 3.12")
def test_yolo_world():
"""Tests YOLO world models with CLIP support, including detection and training scenarios."""
- model = YOLO("yolov8s-world.pt") # no YOLOv8n-world model yet
+ model = YOLO("yolov8s-world.pt") # no YOLO11n-world model yet
model.set_classes(["tree", "window"])
model(SOURCE, conf=0.01)
- model = YOLO("yolov8s-worldv2.pt") # no YOLOv8n-world model yet
+ model = YOLO("yolov8s-worldv2.pt") # no YOLO11n-world model yet
# Training from a pretrained model. Eval is included at the final stage of training.
# Use dota8.yaml which has fewer categories to reduce the inference time of CLIP model
model.train(
@@ -603,7 +603,7 @@ def test_yolo_world():
# test WorWorldTrainerFromScratch
from ultralytics.models.yolo.world.train_world import WorldTrainerFromScratch
- model = YOLO("yolov8s-worldv2.yaml") # no YOLOv8n-world model yet
+ model = YOLO("yolov8s-worldv2.yaml") # no YOLO11n-world model yet
model.train(
data={"train": {"yolo_data": ["dota8.yaml"]}, "val": {"yolo_data": ["dota8.yaml"]}},
epochs=1,
diff --git a/tests/test_solutions.py b/tests/test_solutions.py
index fec1d74d0f..fabec621d3 100644
--- a/tests/test_solutions.py
+++ b/tests/test_solutions.py
@@ -14,7 +14,7 @@ WORKOUTS_SOLUTION_DEMO = "https://github.com/ultralytics/assets/releases/downloa
def test_major_solutions():
"""Test the object counting, heatmap, speed estimation and queue management solution."""
safe_download(url=MAJOR_SOLUTIONS_DEMO)
- model = YOLO("yolov8n.pt")
+ model = YOLO("yolo11n.pt")
names = model.names
cap = cv2.VideoCapture("solutions_ci_demo.mp4")
assert cap.isOpened(), "Error reading video file"
@@ -41,7 +41,7 @@ def test_major_solutions():
def test_aigym():
"""Test the workouts monitoring solution."""
safe_download(url=WORKOUTS_SOLUTION_DEMO)
- model = YOLO("yolov8n-pose.pt")
+ model = YOLO("yolo11n-pose.pt")
cap = cv2.VideoCapture("solution_ci_pose_demo.mp4")
assert cap.isOpened(), "Error reading video file"
gym_object = solutions.AIGym(line_thickness=2, pose_type="squat", kpts_to_check=[5, 11, 13])
@@ -60,7 +60,7 @@ def test_instance_segmentation():
"""Test the instance segmentation solution."""
from ultralytics.utils.plotting import Annotator, colors
- model = YOLO("yolov8n-seg.pt")
+ model = YOLO("yolo11n-seg.pt")
names = model.names
cap = cv2.VideoCapture("solutions_ci_demo.mp4")
assert cap.isOpened(), "Error reading video file"
diff --git a/ultralytics/__init__.py b/ultralytics/__init__.py
index 85944a543c..80b45c154b 100644
--- a/ultralytics/__init__.py
+++ b/ultralytics/__init__.py
@@ -1,7 +1,6 @@
# Ultralytics YOLO 🚀, AGPL-3.0 license
-__version__ = "8.2.100"
-
+__version__ = "8.3.4"
import os
diff --git a/ultralytics/cfg/__init__.py b/ultralytics/cfg/__init__.py
index 06356e7589..7058c3d4a5 100644
--- a/ultralytics/cfg/__init__.py
+++ b/ultralytics/cfg/__init__.py
@@ -42,11 +42,11 @@ TASK2DATA = {
"obb": "dota8.yaml",
}
TASK2MODEL = {
- "detect": "yolov8n.pt",
- "segment": "yolov8n-seg.pt",
- "classify": "yolov8n-cls.pt",
- "pose": "yolov8n-pose.pt",
- "obb": "yolov8n-obb.pt",
+ "detect": "yolo11n.pt",
+ "segment": "yolo11n-seg.pt",
+ "classify": "yolo11n-cls.pt",
+ "pose": "yolo11n-pose.pt",
+ "obb": "yolo11n-obb.pt",
}
TASK2METRIC = {
"detect": "metrics/mAP50-95(B)",
@@ -69,19 +69,19 @@ CLI_HELP_MSG = f"""
See all ARGS at https://docs.ultralytics.com/usage/cfg or with 'yolo cfg'
1. Train a detection model for 10 epochs with an initial learning_rate of 0.01
- yolo train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01
+ yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
2. Predict a YouTube video using a pretrained segmentation model at image size 320:
- yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+ yolo predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
3. Val a pretrained detection model at batch-size 1 and image size 640:
- yolo val model=yolov8n.pt data=coco8.yaml batch=1 imgsz=640
+ yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
- 4. Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
- yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+ 4. Export a YOLO11n classification model to ONNX format at image size 224 by 128 (no TASK required)
+ yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128
5. Explore your datasets using semantic search and SQL with a simple GUI powered by Ultralytics Explorer API
- yolo explorer data=data.yaml model=yolov8n.pt
+ yolo explorer data=data.yaml model=yolo11n.pt
6. Streamlit real-time webcam inference GUI
yolo streamlit-predict
@@ -517,7 +517,7 @@ def handle_yolo_settings(args: List[str]) -> None:
Examples:
>>> handle_yolo_settings(["reset"]) # Reset YOLO settings
- >>> handle_yolo_settings(["default_cfg_path=yolov8n.yaml"]) # Update a specific setting
+ >>> handle_yolo_settings(["default_cfg_path=yolo11n.yaml"]) # Update a specific setting
Notes:
- If no arguments are provided, the function will display the current settings.
@@ -557,7 +557,7 @@ def handle_explorer(args: List[str]):
Examples:
```bash
- yolo explorer data=data.yaml model=yolov8n.pt
+ yolo explorer data=data.yaml model=yolo11n.pt
```
Notes:
@@ -611,9 +611,9 @@ def parse_key_value_pair(pair: str = "key=value"):
AssertionError: If the value is missing or empty.
Examples:
- >>> key, value = parse_key_value_pair("model=yolov8n.pt")
+ >>> key, value = parse_key_value_pair("model=yolo11n.pt")
>>> print(f"Key: {key}, Value: {value}")
- Key: model, Value: yolov8n.pt
+ Key: model, Value: yolo11n.pt
>>> key, value = parse_key_value_pair("epochs=100")
>>> print(f"Key: {key}, Value: {value}")
@@ -686,13 +686,13 @@ def entrypoint(debug=""):
Examples:
Train a detection model for 10 epochs with an initial learning_rate of 0.01:
- >>> entrypoint("train data=coco8.yaml model=yolov8n.pt epochs=10 lr0=0.01")
+ >>> entrypoint("train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01")
Predict a YouTube video using a pretrained segmentation model at image size 320:
- >>> entrypoint("predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320")
+ >>> entrypoint("predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320")
Validate a pretrained detection model at batch-size 1 and image size 640:
- >>> entrypoint("val model=yolov8n.pt data=coco8.yaml batch=1 imgsz=640")
+ >>> entrypoint("val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640")
Notes:
- If no arguments are passed, the function will display the usage help message.
@@ -782,7 +782,7 @@ def entrypoint(debug=""):
# Model
model = overrides.pop("model", DEFAULT_CFG.model)
if model is None:
- model = "yolov8n.pt"
+ model = "yolo11n.pt"
LOGGER.warning(f"WARNING ⚠️ 'model' argument is missing. Using default 'model={model}'.")
overrides["model"] = model
stem = Path(model).stem.lower()
@@ -869,5 +869,5 @@ def copy_default_cfg():
if __name__ == "__main__":
- # Example: entrypoint(debug='yolo predict model=yolov8n.pt')
+ # Example: entrypoint(debug='yolo predict model=yolo11n.pt')
entrypoint(debug="")
diff --git a/ultralytics/cfg/datasets/hand-keypoints.yaml b/ultralytics/cfg/datasets/hand-keypoints.yaml
new file mode 100644
index 0000000000..475a7c0137
--- /dev/null
+++ b/ultralytics/cfg/datasets/hand-keypoints.yaml
@@ -0,0 +1,25 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# Hand Keypoints dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/pose/hand-keypoints/
+# Example usage: yolo train data=hand-keypoints.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+# └── hand-keypoints ← downloads here (369 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/hand-keypoints # dataset root dir
+train: train # train images (relative to 'path') 18776 images
+val: val # val images (relative to 'path') 7992 images
+
+# Keypoints
+kpt_shape: [21, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx:
+ [0, 1, 2, 4, 3, 10, 11, 12, 13, 14, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 20]
+
+# Classes
+names:
+ 0: hand
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/hand-keypoints.zip
diff --git a/ultralytics/cfg/default.yaml b/ultralytics/cfg/default.yaml
index a44f609411..da616d651e 100644
--- a/ultralytics/cfg/default.yaml
+++ b/ultralytics/cfg/default.yaml
@@ -115,6 +115,7 @@ bgr: 0.0 # (float) image channel BGR (probability)
mosaic: 1.0 # (float) image mosaic (probability)
mixup: 0.0 # (float) image mixup (probability)
copy_paste: 0.0 # (float) segment copy-paste (probability)
+copy_paste_mode: "flip" # (str) the method to do copy_paste augmentation (flip, mixup)
auto_augment: randaugment # (str) auto augmentation policy for classification (randaugment, autoaugment, augmix)
erasing: 0.4 # (float) probability of random erasing during classification training (0-0.9), 0 means no erasing, must be less than 1.0.
crop_fraction: 1.0 # (float) image crop fraction for classification (0.1-1), 1.0 means no crop, must be greater than 0.
diff --git a/ultralytics/cfg/models/11/yolo11-cls.yaml b/ultralytics/cfg/models/11/yolo11-cls.yaml
new file mode 100644
index 0000000000..ea21e7922f
--- /dev/null
+++ b/ultralytics/cfg/models/11/yolo11-cls.yaml
@@ -0,0 +1,30 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLO11-cls image classification model. For Usage examples see https://docs.ultralytics.com/tasks/classify
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-cls.yaml' will call yolo11-cls.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.50, 0.25, 1024] # summary: 151 layers, 1633584 parameters, 1633584 gradients, 3.3 GFLOPs
+ s: [0.50, 0.50, 1024] # summary: 151 layers, 5545488 parameters, 5545488 gradients, 12.2 GFLOPs
+ m: [0.50, 1.00, 512] # summary: 187 layers, 10455696 parameters, 10455696 gradients, 39.7 GFLOPs
+ l: [1.00, 1.00, 512] # summary: 309 layers, 12937104 parameters, 12937104 gradients, 49.9 GFLOPs
+ x: [1.00, 1.50, 512] # summary: 309 layers, 28458544 parameters, 28458544 gradients, 111.1 GFLOPs
+
+# YOLO11n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 2, C3k2, [256, False, 0.25]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 2, C3k2, [512, False, 0.25]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 2, C3k2, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 2, C3k2, [1024, True]]
+ - [-1, 2, C2PSA, [1024]] # 9
+
+# YOLO11n head
+head:
+ - [-1, 1, Classify, [nc]] # Classify
diff --git a/ultralytics/cfg/models/11/yolo11-obb.yaml b/ultralytics/cfg/models/11/yolo11-obb.yaml
new file mode 100644
index 0000000000..5540ed753d
--- /dev/null
+++ b/ultralytics/cfg/models/11/yolo11-obb.yaml
@@ -0,0 +1,47 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLO11 Oriented Bounding Boxes (OBB) model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/obb
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-obb.yaml' will call yolo11-obb.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.50, 0.25, 1024] # summary: 344 layers, 2695747 parameters, 2695731 gradients, 6.9 GFLOPs
+ s: [0.50, 0.50, 1024] # summary: 344 layers, 9744931 parameters, 9744915 gradients, 22.7 GFLOPs
+ m: [0.50, 1.00, 512] # summary: 434 layers, 20963523 parameters, 20963507 gradients, 72.2 GFLOPs
+ l: [1.00, 1.00, 512] # summary: 656 layers, 26220995 parameters, 26220979 gradients, 91.3 GFLOPs
+ x: [1.00, 1.50, 512] # summary: 656 layers, 58875331 parameters, 58875315 gradients, 204.3 GFLOPs
+
+# YOLO11n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 2, C3k2, [256, False, 0.25]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 2, C3k2, [512, False, 0.25]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 2, C3k2, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 2, C3k2, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+ - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 2, C3k2, [512, False]] # 13
+
+ - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 13], 1, Concat, [1]] # cat head P4
+ - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 10], 1, Concat, [1]] # cat head P5
+ - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+ - [[16, 19, 22], 1, OBB, [nc, 1]] # Detect(P3, P4, P5)
diff --git a/ultralytics/cfg/models/11/yolo11-pose.yaml b/ultralytics/cfg/models/11/yolo11-pose.yaml
new file mode 100644
index 0000000000..a744a33b6b
--- /dev/null
+++ b/ultralytics/cfg/models/11/yolo11-pose.yaml
@@ -0,0 +1,48 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLO11-pose keypoints/pose estimation model. For Usage examples see https://docs.ultralytics.com/tasks/pose
+
+# Parameters
+nc: 80 # number of classes
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+scales: # model compound scaling constants, i.e. 'model=yolo11n-pose.yaml' will call yolo11.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.50, 0.25, 1024] # summary: 344 layers, 2908507 parameters, 2908491 gradients, 7.7 GFLOPs
+ s: [0.50, 0.50, 1024] # summary: 344 layers, 9948811 parameters, 9948795 gradients, 23.5 GFLOPs
+ m: [0.50, 1.00, 512] # summary: 434 layers, 20973273 parameters, 20973257 gradients, 72.3 GFLOPs
+ l: [1.00, 1.00, 512] # summary: 656 layers, 26230745 parameters, 26230729 gradients, 91.4 GFLOPs
+ x: [1.00, 1.50, 512] # summary: 656 layers, 58889881 parameters, 58889865 gradients, 204.3 GFLOPs
+
+# YOLO11n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 2, C3k2, [256, False, 0.25]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 2, C3k2, [512, False, 0.25]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 2, C3k2, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 2, C3k2, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+ - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 2, C3k2, [512, False]] # 13
+
+ - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 13], 1, Concat, [1]] # cat head P4
+ - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 10], 1, Concat, [1]] # cat head P5
+ - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+ - [[16, 19, 22], 1, Pose, [nc, kpt_shape]] # Detect(P3, P4, P5)
diff --git a/ultralytics/cfg/models/11/yolo11-seg.yaml b/ultralytics/cfg/models/11/yolo11-seg.yaml
new file mode 100644
index 0000000000..0f02d96c06
--- /dev/null
+++ b/ultralytics/cfg/models/11/yolo11-seg.yaml
@@ -0,0 +1,47 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLO11-seg instance segmentation model. For Usage examples see https://docs.ultralytics.com/tasks/segment
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-seg.yaml' will call yolo11-seg.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.50, 0.25, 1024] # summary: 355 layers, 2876848 parameters, 2876832 gradients, 10.5 GFLOPs
+ s: [0.50, 0.50, 1024] # summary: 355 layers, 10113248 parameters, 10113232 gradients, 35.8 GFLOPs
+ m: [0.50, 1.00, 512] # summary: 445 layers, 22420896 parameters, 22420880 gradients, 123.9 GFLOPs
+ l: [1.00, 1.00, 512] # summary: 667 layers, 27678368 parameters, 27678352 gradients, 143.0 GFLOPs
+ x: [1.00, 1.50, 512] # summary: 667 layers, 62142656 parameters, 62142640 gradients, 320.2 GFLOPs
+
+# YOLO11n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 2, C3k2, [256, False, 0.25]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 2, C3k2, [512, False, 0.25]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 2, C3k2, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 2, C3k2, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+ - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 2, C3k2, [512, False]] # 13
+
+ - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 13], 1, Concat, [1]] # cat head P4
+ - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 10], 1, Concat, [1]] # cat head P5
+ - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+ - [[16, 19, 22], 1, Segment, [nc, 32, 256]] # Detect(P3, P4, P5)
diff --git a/ultralytics/cfg/models/11/yolo11.yaml b/ultralytics/cfg/models/11/yolo11.yaml
new file mode 100644
index 0000000000..8d06a12991
--- /dev/null
+++ b/ultralytics/cfg/models/11/yolo11.yaml
@@ -0,0 +1,47 @@
+# Ultralytics YOLO 🚀, AGPL-3.0 license
+# YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
+ # [depth, width, max_channels]
+ n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
+ s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
+ m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
+ l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
+ x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
+
+# YOLO11n backbone
+backbone:
+ # [from, repeats, module, args]
+ - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+ - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+ - [-1, 2, C3k2, [256, False, 0.25]]
+ - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+ - [-1, 2, C3k2, [512, False, 0.25]]
+ - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+ - [-1, 2, C3k2, [512, True]]
+ - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+ - [-1, 2, C3k2, [1024, True]]
+ - [-1, 1, SPPF, [1024, 5]] # 9
+ - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+ - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+ - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+ - [-1, 2, C3k2, [512, False]] # 13
+
+ - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+ - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+ - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+ - [-1, 1, Conv, [256, 3, 2]]
+ - [[-1, 13], 1, Concat, [1]] # cat head P4
+ - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+ - [-1, 1, Conv, [512, 3, 2]]
+ - [[-1, 10], 1, Concat, [1]] # cat head P5
+ - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+ - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)
diff --git a/ultralytics/cfg/models/README.md b/ultralytics/cfg/models/README.md
index bcaf8deda4..68a9238384 100644
--- a/ultralytics/cfg/models/README.md
+++ b/ultralytics/cfg/models/README.md
@@ -11,8 +11,8 @@ To get started, simply browse through the models in this directory and find one
Model `*.yaml` files may be used directly in the [Command Line Interface (CLI)](https://docs.ultralytics.com/usage/cli/) with a `yolo` command:
```bash
-# Train a YOLOv8n model using the coco8 dataset for 100 epochs
-yolo task=detect mode=train model=yolov8n.yaml data=coco8.yaml epochs=100
+# Train a YOLO11n model using the coco8 dataset for 100 epochs
+yolo task=detect mode=train model=yolo11n.yaml data=coco8.yaml epochs=100
```
They may also be used directly in a Python environment, and accept the same [arguments](https://docs.ultralytics.com/usage/cfg/) as in the CLI example above:
@@ -20,7 +20,7 @@ They may also be used directly in a Python environment, and accept the same [arg
```python
from ultralytics import YOLO
-# Initialize a YOLOv8n model from a YAML configuration file
+# Initialize a YOLO11n model from a YAML configuration file
model = YOLO("model.yaml")
# If a pre-trained model is available, use it instead
diff --git a/ultralytics/data/augment.py b/ultralytics/data/augment.py
index a20f85a08a..49bdc92235 100644
--- a/ultralytics/data/augment.py
+++ b/ultralytics/data/augment.py
@@ -1628,92 +1628,105 @@ class LetterBox:
return labels
-class CopyPaste:
+class CopyPaste(BaseMixTransform):
"""
- Implements Copy-Paste augmentation as described in https://arxiv.org/abs/2012.07177.
+ CopyPaste class for applying Copy-Paste augmentation to image datasets.
- This class applies Copy-Paste augmentation on images and their corresponding instances.
+ This class implements the Copy-Paste augmentation technique as described in the paper "Simple Copy-Paste is a Strong
+ Data Augmentation Method for Instance Segmentation" (https://arxiv.org/abs/2012.07177). It combines objects from
+ different images to create new training samples.
Attributes:
- p (float): Probability of applying the Copy-Paste augmentation. Must be between 0 and 1.
+ dataset (Any): The dataset to which Copy-Paste augmentation will be applied.
+ pre_transform (Callable | None): Optional transform to apply before Copy-Paste.
+ p (float): Probability of applying Copy-Paste augmentation.
Methods:
- __call__: Applies Copy-Paste augmentation to given image and instances.
+ get_indexes: Returns a random index from the dataset.
+ _mix_transform: Applies Copy-Paste augmentation to the input labels.
+ __call__: Applies the Copy-Paste transformation to images and annotations.
Examples:
- >>> copypaste = CopyPaste(p=0.5)
- >>> augmented_labels = copypaste(labels)
- >>> augmented_image = augmented_labels["img"]
+ >>> from ultralytics.data.augment import CopyPaste
+ >>> dataset = YourDataset(...) # Your image dataset
+ >>> copypaste = CopyPaste(dataset, p=0.5)
+ >>> augmented_labels = copypaste(original_labels)
"""
- def __init__(self, p=0.5) -> None:
- """
- Initializes the CopyPaste augmentation object.
+ def __init__(self, dataset=None, pre_transform=None, p=0.5, mode="flip") -> None:
+ """Initializes CopyPaste object with dataset, pre_transform, and probability of applying MixUp."""
+ super().__init__(dataset=dataset, pre_transform=pre_transform, p=p)
+ assert mode in {"flip", "mixup"}, f"Expected `mode` to be `flip` or `mixup`, but got {mode}."
+ self.mode = mode
- This class implements the Copy-Paste augmentation as described in the paper "Simple Copy-Paste is a Strong Data
- Augmentation Method for Instance Segmentation" (https://arxiv.org/abs/2012.07177). It applies the Copy-Paste
- augmentation on images and their corresponding instances with a given probability.
+ def get_indexes(self):
+ """Returns a list of random indexes from the dataset for CopyPaste augmentation."""
+ return random.randint(0, len(self.dataset) - 1)
- Args:
- p (float): The probability of applying the Copy-Paste augmentation. Must be between 0 and 1.
+ def _mix_transform(self, labels):
+ """Applies Copy-Paste augmentation to combine objects from another image into the current image."""
+ labels2 = labels["mix_labels"][0]
+ return self._transform(labels, labels2)
- Attributes:
- p (float): Stores the probability of applying the augmentation.
+ def __call__(self, labels):
+ """Applies Copy-Paste augmentation to an image and its labels."""
+ if len(labels["instances"].segments) == 0 or self.p == 0:
+ return labels
+ if self.mode == "flip":
+ return self._transform(labels)
- Examples:
- >>> augment = CopyPaste(p=0.7)
- >>> augmented_data = augment(original_data)
- """
- self.p = p
+ # Get index of one or three other images
+ indexes = self.get_indexes()
+ if isinstance(indexes, int):
+ indexes = [indexes]
- def __call__(self, labels):
- """
- Applies Copy-Paste augmentation to an image and its instances.
+ # Get images information will be used for Mosaic or MixUp
+ mix_labels = [self.dataset.get_image_and_label(i) for i in indexes]
- Args:
- labels (Dict): A dictionary containing:
- - 'img' (np.ndarray): The image to augment.
- - 'cls' (np.ndarray): Class labels for the instances.
- - 'instances' (ultralytics.engine.results.Instances): Object containing bounding boxes, segments, etc.
+ if self.pre_transform is not None:
+ for i, data in enumerate(mix_labels):
+ mix_labels[i] = self.pre_transform(data)
+ labels["mix_labels"] = mix_labels
- Returns:
- (Dict): Dictionary with augmented image and updated instances under 'img', 'cls', and 'instances' keys.
+ # Update cls and texts
+ labels = self._update_label_text(labels)
+ # Mosaic or MixUp
+ labels = self._mix_transform(labels)
+ labels.pop("mix_labels", None)
+ return labels
- Examples:
- >>> labels = {"img": np.random.rand(640, 640, 3), "cls": np.array([0, 1, 2]), "instances": Instances(...)}
- >>> augmenter = CopyPaste(p=0.5)
- >>> augmented_labels = augmenter(labels)
- """
- im = labels["img"]
- cls = labels["cls"]
+ def _transform(self, labels1, labels2={}):
+ """Applies Copy-Paste augmentation to combine objects from another image into the current image."""
+ im = labels1["img"]
+ cls = labels1["cls"]
h, w = im.shape[:2]
- instances = labels.pop("instances")
+ instances = labels1.pop("instances")
instances.convert_bbox(format="xyxy")
instances.denormalize(w, h)
- if self.p and len(instances.segments):
- _, w, _ = im.shape # height, width, channels
- im_new = np.zeros(im.shape, np.uint8)
-
- # Calculate ioa first then select indexes randomly
- ins_flip = deepcopy(instances)
- ins_flip.fliplr(w)
-
- ioa = bbox_ioa(ins_flip.bboxes, instances.bboxes) # intersection over area, (N, M)
- indexes = np.nonzero((ioa < 0.30).all(1))[0] # (N, )
- n = len(indexes)
- for j in random.sample(list(indexes), k=round(self.p * n)):
- cls = np.concatenate((cls, cls[[j]]), axis=0)
- instances = Instances.concatenate((instances, ins_flip[[j]]), axis=0)
- cv2.drawContours(im_new, instances.segments[[j]].astype(np.int32), -1, (1, 1, 1), cv2.FILLED)
-
- result = cv2.flip(im, 1) # augment segments (flip left-right)
- i = cv2.flip(im_new, 1).astype(bool)
- im[i] = result[i]
-
- labels["img"] = im
- labels["cls"] = cls
- labels["instances"] = instances
- return labels
+
+ im_new = np.zeros(im.shape, np.uint8)
+ instances2 = labels2.pop("instances", None)
+ if instances2 is None:
+ instances2 = deepcopy(instances)
+ instances2.fliplr(w)
+ ioa = bbox_ioa(instances2.bboxes, instances.bboxes) # intersection over area, (N, M)
+ indexes = np.nonzero((ioa < 0.30).all(1))[0] # (N, )
+ n = len(indexes)
+ sorted_idx = np.argsort(ioa.max(1)[indexes])
+ indexes = indexes[sorted_idx]
+ for j in indexes[: round(self.p * n)]:
+ cls = np.concatenate((cls, labels2.get("cls", cls)[[j]]), axis=0)
+ instances = Instances.concatenate((instances, instances2[[j]]), axis=0)
+ cv2.drawContours(im_new, instances2.segments[[j]].astype(np.int32), -1, (1, 1, 1), cv2.FILLED)
+
+ result = labels2.get("img", cv2.flip(im, 1)) # augment segments
+ i = im_new.astype(bool)
+ im[i] = result[i]
+
+ labels1["img"] = im
+ labels1["cls"] = cls
+ labels1["instances"] = instances
+ return labels1
class Albumentations:
@@ -2259,9 +2272,9 @@ class RandomLoadText:
def v8_transforms(dataset, imgsz, hyp, stretch=False):
"""
- Applies a series of image transformations for YOLOv8 training.
+ Applies a series of image transformations for training.
- This function creates a composition of image augmentation techniques to prepare images for YOLOv8 training.
+ This function creates a composition of image augmentation techniques to prepare images for YOLO training.
It includes operations such as mosaic, copy-paste, random perspective, mixup, and various color adjustments.
Args:
@@ -2280,20 +2293,28 @@ def v8_transforms(dataset, imgsz, hyp, stretch=False):
>>> transforms = v8_transforms(dataset, imgsz=640, hyp=hyp)
>>> augmented_data = transforms(dataset[0])
"""
- pre_transform = Compose(
- [
- Mosaic(dataset, imgsz=imgsz, p=hyp.mosaic),
- CopyPaste(p=hyp.copy_paste),
- RandomPerspective(
- degrees=hyp.degrees,
- translate=hyp.translate,
- scale=hyp.scale,
- shear=hyp.shear,
- perspective=hyp.perspective,
- pre_transform=None if stretch else LetterBox(new_shape=(imgsz, imgsz)),
- ),
- ]
+ mosaic = Mosaic(dataset, imgsz=imgsz, p=hyp.mosaic)
+ affine = RandomPerspective(
+ degrees=hyp.degrees,
+ translate=hyp.translate,
+ scale=hyp.scale,
+ shear=hyp.shear,
+ perspective=hyp.perspective,
+ pre_transform=None if stretch else LetterBox(new_shape=(imgsz, imgsz)),
)
+
+ pre_transform = Compose([mosaic, affine])
+ if hyp.copy_paste_mode == "flip":
+ pre_transform.insert(1, CopyPaste(p=hyp.copy_paste, mode=hyp.copy_paste_mode))
+ else:
+ pre_transform.append(
+ CopyPaste(
+ dataset,
+ pre_transform=Compose([Mosaic(dataset, imgsz=imgsz, p=hyp.mosaic), affine]),
+ p=hyp.copy_paste,
+ mode=hyp.copy_paste_mode,
+ )
+ )
flip_idx = dataset.data.get("flip_idx", []) # for keypoints augmentation
if dataset.use_keypoints:
kpt_shape = dataset.data.get("kpt_shape", None)
diff --git a/ultralytics/engine/exporter.py b/ultralytics/engine/exporter.py
index d4987f90be..73ee545f33 100644
--- a/ultralytics/engine/exporter.py
+++ b/ultralytics/engine/exporter.py
@@ -178,6 +178,16 @@ class Exporter:
if fmt in {"mlmodel", "mlpackage", "mlprogram", "apple", "ios", "coreml"}: # 'coreml' aliases
fmt = "coreml"
fmts = tuple(export_formats()["Argument"][1:]) # available export formats
+ if fmt not in fmts:
+ import difflib
+
+ # Get the closest match if format is invalid
+ matches = difflib.get_close_matches(fmt, fmts, n=1, cutoff=0.6) # 60% similarity required to match
+ if matches:
+ LOGGER.warning(f"WARNING ⚠️ Invalid export format='{fmt}', updating to format='{matches[0]}'")
+ fmt = matches[0]
+ else:
+ raise ValueError(f"Invalid export format='{fmt}'. Valid formats are {fmts}")
flags = [x == fmt for x in fmts]
if sum(flags) != 1:
raise ValueError(f"Invalid export format='{fmt}'. Valid formats are {fmts}")
diff --git a/ultralytics/engine/model.py b/ultralytics/engine/model.py
index 6775188915..c4db53426a 100644
--- a/ultralytics/engine/model.py
+++ b/ultralytics/engine/model.py
@@ -127,7 +127,7 @@ class Model(nn.Module):
# Check if Ultralytics HUB model from https://hub.ultralytics.com
if self.is_hub_model(model):
# Fetch model from HUB
- checks.check_requirements("hub-sdk>=0.0.8")
+ checks.check_requirements("hub-sdk>=0.0.12")
session = HUBTrainingSession.create_session(model)
model = session.model_file
if session.train_args: # training sent from HUB
@@ -377,7 +377,7 @@ class Model(nn.Module):
self.model.load(weights)
return self
- def save(self, filename: Union[str, Path] = "saved_model.pt", use_dill=True) -> None:
+ def save(self, filename: Union[str, Path] = "saved_model.pt") -> None:
"""
Saves the current model state to a file.
@@ -386,7 +386,6 @@ class Model(nn.Module):
Args:
filename (Union[str, Path]): The name of the file to save the model to.
- use_dill (bool): Whether to try using dill for serialization if available.
Raises:
AssertionError: If the model is not a PyTorch model.
@@ -408,7 +407,7 @@ class Model(nn.Module):
"license": "AGPL-3.0 License (https://ultralytics.com/license)",
"docs": "https://docs.ultralytics.com",
}
- torch.save({**self.ckpt, **updates}, filename, use_dill=use_dill)
+ torch.save({**self.ckpt, **updates}, filename)
def info(self, detailed: bool = False, verbose: bool = True):
"""
diff --git a/ultralytics/engine/trainer.py b/ultralytics/engine/trainer.py
index ae98540b03..9fcc697040 100644
--- a/ultralytics/engine/trainer.py
+++ b/ultralytics/engine/trainer.py
@@ -12,7 +12,7 @@ import os
import subprocess
import time
import warnings
-from copy import deepcopy
+from copy import copy, deepcopy
from datetime import datetime, timedelta
from pathlib import Path
@@ -538,6 +538,8 @@ class BaseTrainer:
self.best.write_bytes(serialized_ckpt) # save best.pt
if (self.save_period > 0) and (self.epoch % self.save_period == 0):
(self.wdir / f"epoch{self.epoch}.pt").write_bytes(serialized_ckpt) # save epoch, i.e. 'epoch3.pt'
+ # if self.args.close_mosaic and self.epoch == (self.epochs - self.args.close_mosaic - 1):
+ # (self.wdir / "last_mosaic.pt").write_bytes(serialized_ckpt) # save mosaic checkpoint
def get_dataset(self):
"""
@@ -698,7 +700,12 @@ class BaseTrainer:
resume = True
self.args = get_cfg(ckpt_args)
self.args.model = self.args.resume = str(last) # reinstate model
- for k in "imgsz", "batch", "device": # allow arg updates to reduce memory or update device on resume
+ for k in (
+ "imgsz",
+ "batch",
+ "device",
+ "close_mosaic",
+ ): # allow arg updates to reduce memory or update device on resume
if k in overrides:
setattr(self.args, k, overrides[k])
@@ -742,7 +749,7 @@ class BaseTrainer:
self.train_loader.dataset.mosaic = False
if hasattr(self.train_loader.dataset, "close_mosaic"):
LOGGER.info("Closing dataloader mosaic")
- self.train_loader.dataset.close_mosaic(hyp=self.args)
+ self.train_loader.dataset.close_mosaic(hyp=copy(self.args))
def build_optimizer(self, model, name="auto", lr=0.001, momentum=0.9, decay=1e-5, iterations=1e5):
"""
diff --git a/ultralytics/hub/__init__.py b/ultralytics/hub/__init__.py
index 33b0c3748d..9c9c9dfa16 100644
--- a/ultralytics/hub/__init__.py
+++ b/ultralytics/hub/__init__.py
@@ -38,7 +38,7 @@ def login(api_key: str = None, save=True) -> bool:
Returns:
(bool): True if authentication is successful, False otherwise.
"""
- checks.check_requirements("hub-sdk>=0.0.8")
+ checks.check_requirements("hub-sdk>=0.0.12")
from hub_sdk import HUBClient
api_key_url = f"{HUB_WEB_ROOT}/settings?tab=api+keys" # set the redirect URL
diff --git a/ultralytics/hub/session.py b/ultralytics/hub/session.py
index 170bb82b67..89b5ddfc1e 100644
--- a/ultralytics/hub/session.py
+++ b/ultralytics/hub/session.py
@@ -63,22 +63,24 @@ class HUBTrainingSession:
# Initialize client
self.client = HUBClient(credentials)
- # Load models if authenticated
- if self.client.authenticated:
+ # Load models
+ try:
if model_id:
self.load_model(model_id) # load existing model
else:
self.model = self.client.model() # load empty model
+ except Exception:
+ if identifier.startswith(f"{HUB_WEB_ROOT}/models/") and not self.client.authenticated:
+ LOGGER.warning(
+ f"{PREFIX}WARNING ⚠️ Please log in using 'yolo login API_KEY'. "
+ "You can find your API Key at: https://hub.ultralytics.com/settings?tab=api+keys."
+ )
@classmethod
def create_session(cls, identifier, args=None):
"""Class method to create an authenticated HUBTrainingSession or return None."""
try:
session = cls(identifier)
- if not session.client.authenticated:
- if identifier.startswith(f"{HUB_WEB_ROOT}/models/"):
- LOGGER.warning(f"{PREFIX}WARNING ⚠️ Login to Ultralytics HUB with 'yolo hub login API_KEY'.")
- return None
if args and not identifier.startswith(f"{HUB_WEB_ROOT}/models/"): # not a HUB model URL
session.create_model(args)
assert session.model.id, "HUB model not loaded correctly"
diff --git a/ultralytics/hub/utils.py b/ultralytics/hub/utils.py
index 2fc956fb34..469a1c37e7 100644
--- a/ultralytics/hub/utils.py
+++ b/ultralytics/hub/utils.py
@@ -170,7 +170,7 @@ def smart_request(method, url, retry=3, timeout=30, thread=True, code=-1, verbos
class Events:
"""
A class for collecting anonymous event analytics. Event analytics are enabled when sync=True in settings and
- disabled when sync=False. Run 'yolo settings' to see and update settings YAML file.
+ disabled when sync=False. Run 'yolo settings' to see and update settings.
Attributes:
url (str): The URL to send anonymous events.
diff --git a/ultralytics/models/sam/build.py b/ultralytics/models/sam/build.py
index 0e7ddedcf0..e110531244 100644
--- a/ultralytics/models/sam/build.py
+++ b/ultralytics/models/sam/build.py
@@ -210,8 +210,6 @@ def _build_sam(
state_dict = torch.load(f)
sam.load_state_dict(state_dict)
sam.eval()
- # sam.load_state_dict(torch.load(checkpoint), strict=True)
- # sam.eval()
return sam
diff --git a/ultralytics/models/sam/modules/sam.py b/ultralytics/models/sam/modules/sam.py
index c902153f17..2728b0b481 100644
--- a/ultralytics/models/sam/modules/sam.py
+++ b/ultralytics/models/sam/modules/sam.py
@@ -645,9 +645,7 @@ class SAM2Model(torch.nn.Module):
# The case of `self.num_maskmem == 0` below is primarily used for reproducing SAM on images.
# In this case, we skip the fusion with any memory.
if self.num_maskmem == 0: # Disable memory and skip fusion
- pix_feat = current_vision_feats[-1].permute(1, 2, 0).view(B, C, H, W)
- return pix_feat
-
+ return current_vision_feats[-1].permute(1, 2, 0).view(B, C, H, W)
num_obj_ptr_tokens = 0
# Step 1: condition the visual features of the current frame on previous memories
if not is_init_cond_frame:
diff --git a/ultralytics/models/sam/predict.py b/ultralytics/models/sam/predict.py
index 686ef70c63..768d63d8f1 100644
--- a/ultralytics/models/sam/predict.py
+++ b/ultralytics/models/sam/predict.py
@@ -196,6 +196,7 @@ class Predictor(BasePredictor):
bboxes = self.prompts.pop("bboxes", bboxes)
points = self.prompts.pop("points", points)
masks = self.prompts.pop("masks", masks)
+ labels = self.prompts.pop("labels", labels)
if all(i is None for i in [bboxes, points, masks]):
return self.generate(im, *args, **kwargs)
diff --git a/ultralytics/nn/modules/__init__.py b/ultralytics/nn/modules/__init__.py
index 2071a2895a..a840c5a71a 100644
--- a/ultralytics/nn/modules/__init__.py
+++ b/ultralytics/nn/modules/__init__.py
@@ -20,6 +20,7 @@ Example:
from .block import (
C1,
C2,
+ C2PSA,
C3,
C3TR,
CIB,
@@ -38,7 +39,9 @@ from .block import (
C2f,
C2fAttn,
C2fCIB,
+ C2fPSA,
C3Ghost,
+ C3k2,
C3x,
CBFuse,
CBLinear,
@@ -110,6 +113,10 @@ __all__ = (
"C2",
"C3",
"C2f",
+ "C3k2",
+ "SCDown",
+ "C2fPSA",
+ "C2PSA",
"C2fAttn",
"C3x",
"C3TR",
@@ -149,5 +156,4 @@ __all__ = (
"C2fCIB",
"Attention",
"PSA",
- "SCDown",
)
diff --git a/ultralytics/nn/modules/block.py b/ultralytics/nn/modules/block.py
index 07be2b8845..7208ea639b 100644
--- a/ultralytics/nn/modules/block.py
+++ b/ultralytics/nn/modules/block.py
@@ -40,6 +40,9 @@ __all__ = (
"SPPELAN",
"CBFuse",
"CBLinear",
+ "C3k2",
+ "C2fPSA",
+ "C2PSA",
"RepVGGDW",
"CIB",
"C2fCIB",
@@ -696,6 +699,49 @@ class CBFuse(nn.Module):
return torch.sum(torch.stack(res + xs[-1:]), dim=0)
+class C3f(nn.Module):
+ """Faster Implementation of CSP Bottleneck with 2 convolutions."""
+
+ def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
+ """Initialize CSP bottleneck layer with two convolutions with arguments ch_in, ch_out, number, shortcut, groups,
+ expansion.
+ """
+ super().__init__()
+ c_ = int(c2 * e) # hidden channels
+ self.cv1 = Conv(c1, c_, 1, 1)
+ self.cv2 = Conv(c1, c_, 1, 1)
+ self.cv3 = Conv((2 + n) * c_, c2, 1) # optional act=FReLU(c2)
+ self.m = nn.ModuleList(Bottleneck(c_, c_, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))
+
+ def forward(self, x):
+ """Forward pass through C2f layer."""
+ y = [self.cv2(x), self.cv1(x)]
+ y.extend(m(y[-1]) for m in self.m)
+ return self.cv3(torch.cat(y, 1))
+
+
+class C3k2(C2f):
+ """Faster Implementation of CSP Bottleneck with 2 convolutions."""
+
+ def __init__(self, c1, c2, n=1, c3k=False, e=0.5, g=1, shortcut=True):
+ """Initializes the C3k2 module, a faster CSP Bottleneck with 2 convolutions and optional C3k blocks."""
+ super().__init__(c1, c2, n, shortcut, g, e)
+ self.m = nn.ModuleList(
+ C3k(self.c, self.c, 2, shortcut, g) if c3k else Bottleneck(self.c, self.c, shortcut, g) for _ in range(n)
+ )
+
+
+class C3k(C3):
+ """C3k is a CSP bottleneck module with customizable kernel sizes for feature extraction in neural networks."""
+
+ def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5, k=3):
+ """Initializes the C3k module with specified channels, number of layers, and configurations."""
+ super().__init__(c1, c2, n, shortcut, g, e)
+ c_ = int(c2 * e) # hidden channels
+ # self.m = nn.Sequential(*(RepBottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
+ self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, k=(k, k), e=1.0) for _ in range(n)))
+
+
class RepVGGDW(torch.nn.Module):
"""RepVGGDW is a class that represents a depth wise separable convolutional block in RepVGG architecture."""
@@ -873,25 +919,69 @@ class Attention(nn.Module):
return x
+class PSABlock(nn.Module):
+ """
+ PSABlock class implementing a Position-Sensitive Attention block for neural networks.
+
+ This class encapsulates the functionality for applying multi-head attention and feed-forward neural network layers
+ with optional shortcut connections.
+
+ Attributes:
+ attn (Attention): Multi-head attention module.
+ ffn (nn.Sequential): Feed-forward neural network module.
+ add (bool): Flag indicating whether to add shortcut connections.
+
+ Methods:
+ forward: Performs a forward pass through the PSABlock, applying attention and feed-forward layers.
+
+ Examples:
+ Create a PSABlock and perform a forward pass
+ >>> psablock = PSABlock(c=128, attn_ratio=0.5, num_heads=4, shortcut=True)
+ >>> input_tensor = torch.randn(1, 128, 32, 32)
+ >>> output_tensor = psablock(input_tensor)
+ """
+
+ def __init__(self, c, attn_ratio=0.5, num_heads=4, shortcut=True) -> None:
+ """Initializes the PSABlock with attention and feed-forward layers for enhanced feature extraction."""
+ super().__init__()
+
+ self.attn = Attention(c, attn_ratio=attn_ratio, num_heads=num_heads)
+ self.ffn = nn.Sequential(Conv(c, c * 2, 1), Conv(c * 2, c, 1, act=False))
+ self.add = shortcut
+
+ def forward(self, x):
+ """Executes a forward pass through PSABlock, applying attention and feed-forward layers to the input tensor."""
+ x = x + self.attn(x) if self.add else self.attn(x)
+ x = x + self.ffn(x) if self.add else self.ffn(x)
+ return x
+
+
class PSA(nn.Module):
"""
- Position-wise Spatial Attention module.
+ PSA class for implementing Position-Sensitive Attention in neural networks.
- Args:
- c1 (int): Number of input channels.
- c2 (int): Number of output channels.
- e (float): Expansion factor for the intermediate channels. Default is 0.5.
+ This class encapsulates the functionality for applying position-sensitive attention and feed-forward networks to
+ input tensors, enhancing feature extraction and processing capabilities.
Attributes:
- c (int): Number of intermediate channels.
+ c (int): Number of hidden channels after applying the initial convolution.
cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c.
cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c.
- attn (Attention): Attention module for spatial attention.
- ffn (nn.Sequential): Feed-forward network module.
+ attn (Attention): Attention module for position-sensitive attention.
+ ffn (nn.Sequential): Feed-forward network for further processing.
+
+ Methods:
+ forward: Applies position-sensitive attention and feed-forward network to the input tensor.
+
+ Examples:
+ Create a PSA module and apply it to an input tensor
+ >>> psa = PSA(c1=128, c2=128, e=0.5)
+ >>> input_tensor = torch.randn(1, 128, 64, 64)
+ >>> output_tensor = psa.forward(input_tensor)
"""
def __init__(self, c1, c2, e=0.5):
- """Initializes convolution layers, attention module, and feed-forward network with channel reduction."""
+ """Initializes the PSA module with input/output channels and attention mechanism for feature extraction."""
super().__init__()
assert c1 == c2
self.c = int(c1 * e)
@@ -902,46 +992,117 @@ class PSA(nn.Module):
self.ffn = nn.Sequential(Conv(self.c, self.c * 2, 1), Conv(self.c * 2, self.c, 1, act=False))
def forward(self, x):
- """
- Forward pass of the PSA module.
-
- Args:
- x (torch.Tensor): Input tensor.
-
- Returns:
- (torch.Tensor): Output tensor.
- """
+ """Executes forward pass in PSA module, applying attention and feed-forward layers to the input tensor."""
a, b = self.cv1(x).split((self.c, self.c), dim=1)
b = b + self.attn(b)
b = b + self.ffn(b)
return self.cv2(torch.cat((a, b), 1))
+class C2PSA(nn.Module):
+ """
+ C2PSA module with attention mechanism for enhanced feature extraction and processing.
+
+ This module implements a convolutional block with attention mechanisms to enhance feature extraction and processing
+ capabilities. It includes a series of PSABlock modules for self-attention and feed-forward operations.
+
+ Attributes:
+ c (int): Number of hidden channels.
+ cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c.
+ cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c.
+ m (nn.Sequential): Sequential container of PSABlock modules for attention and feed-forward operations.
+
+ Methods:
+ forward: Performs a forward pass through the C2PSA module, applying attention and feed-forward operations.
+
+ Notes:
+ This module essentially is the same as PSA module, but refactored to allow stacking more PSABlock modules.
+
+ Examples:
+ >>> c2psa = C2PSA(c1=256, c2=256, n=3, e=0.5)
+ >>> input_tensor = torch.randn(1, 256, 64, 64)
+ >>> output_tensor = c2psa(input_tensor)
+ """
+
+ def __init__(self, c1, c2, n=1, e=0.5):
+ """Initializes the C2PSA module with specified input/output channels, number of layers, and expansion ratio."""
+ super().__init__()
+ assert c1 == c2
+ self.c = int(c1 * e)
+ self.cv1 = Conv(c1, 2 * self.c, 1, 1)
+ self.cv2 = Conv(2 * self.c, c1, 1)
+
+ self.m = nn.Sequential(*(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n)))
+
+ def forward(self, x):
+ """Processes the input tensor 'x' through a series of PSA blocks and returns the transformed tensor."""
+ a, b = self.cv1(x).split((self.c, self.c), dim=1)
+ b = self.m(b)
+ return self.cv2(torch.cat((a, b), 1))
+
+
+class C2fPSA(C2f):
+ """
+ C2fPSA module with enhanced feature extraction using PSA blocks.
+
+ This class extends the C2f module by incorporating PSA blocks for improved attention mechanisms and feature extraction.
+
+ Attributes:
+ c (int): Number of hidden channels.
+ cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c.
+ cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c.
+ m (nn.ModuleList): List of PSA blocks for feature extraction.
+
+ Methods:
+ forward: Performs a forward pass through the C2fPSA module.
+ forward_split: Performs a forward pass using split() instead of chunk().
+
+ Examples:
+ >>> import torch
+ >>> from ultralytics.models.common import C2fPSA
+ >>> model = C2fPSA(c1=64, c2=64, n=3, e=0.5)
+ >>> x = torch.randn(1, 64, 128, 128)
+ >>> output = model(x)
+ >>> print(output.shape)
+ """
+
+ def __init__(self, c1, c2, n=1, e=0.5):
+ """Initializes the C2fPSA module, a variant of C2f with PSA blocks for enhanced feature extraction."""
+ assert c1 == c2
+ super().__init__(c1, c2, n=n, e=e)
+ self.m = nn.ModuleList(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n))
+
+
class SCDown(nn.Module):
- """Spatial Channel Downsample (SCDown) module for reducing spatial and channel dimensions."""
+ """
+ SCDown module for downsampling with separable convolutions.
- def __init__(self, c1, c2, k, s):
- """
- Spatial Channel Downsample (SCDown) module.
+ This module performs downsampling using a combination of pointwise and depthwise convolutions, which helps in
+ efficiently reducing the spatial dimensions of the input tensor while maintaining the channel information.
- Args:
- c1 (int): Number of input channels.
- c2 (int): Number of output channels.
- k (int): Kernel size for the convolutional layer.
- s (int): Stride for the convolutional layer.
- """
+ Attributes:
+ cv1 (Conv): Pointwise convolution layer that reduces the number of channels.
+ cv2 (Conv): Depthwise convolution layer that performs spatial downsampling.
+
+ Methods:
+ forward: Applies the SCDown module to the input tensor.
+
+ Examples:
+ >>> import torch
+ >>> from ultralytics import SCDown
+ >>> model = SCDown(c1=64, c2=128, k=3, s=2)
+ >>> x = torch.randn(1, 64, 128, 128)
+ >>> y = model(x)
+ >>> print(y.shape)
+ torch.Size([1, 128, 64, 64])
+ """
+
+ def __init__(self, c1, c2, k, s):
+ """Initializes the SCDown module with specified input/output channels, kernel size, and stride."""
super().__init__()
self.cv1 = Conv(c1, c2, 1, 1)
self.cv2 = Conv(c2, c2, k=k, s=s, g=c2, act=False)
def forward(self, x):
- """
- Forward pass of the SCDown module.
-
- Args:
- x (torch.Tensor): Input tensor.
-
- Returns:
- (torch.Tensor): Output tensor after applying the SCDown module.
- """
+ """Applies convolution and downsampling to the input tensor in the SCDown module."""
return self.cv2(self.cv1(x))
diff --git a/ultralytics/nn/modules/conv.py b/ultralytics/nn/modules/conv.py
index 2d9c7c0679..aaa70f5745 100644
--- a/ultralytics/nn/modules/conv.py
+++ b/ultralytics/nn/modules/conv.py
@@ -209,7 +209,8 @@ class RepConv(nn.Module):
kernelid, biasid = self._fuse_bn_tensor(self.bn)
return kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1) + kernelid, bias3x3 + bias1x1 + biasid
- def _pad_1x1_to_3x3_tensor(self, kernel1x1):
+ @staticmethod
+ def _pad_1x1_to_3x3_tensor(kernel1x1):
"""Pads a 1x1 tensor to a 3x3 tensor."""
if kernel1x1 is None:
return 0
diff --git a/ultralytics/nn/modules/head.py b/ultralytics/nn/modules/head.py
index 1a02e2b258..5f2931777e 100644
--- a/ultralytics/nn/modules/head.py
+++ b/ultralytics/nn/modules/head.py
@@ -11,7 +11,7 @@ from torch.nn.init import constant_, xavier_uniform_
from ultralytics.utils.tal import TORCH_1_10, dist2bbox, dist2rbox, make_anchors
from .block import DFL, BNContrastiveHead, ContrastiveHead, Proto
-from .conv import Conv
+from .conv import Conv, DWConv
from .transformer import MLP, DeformableTransformerDecoder, DeformableTransformerDecoderLayer
from .utils import bias_init_with_prob, linear_init
@@ -41,7 +41,14 @@ class Detect(nn.Module):
self.cv2 = nn.ModuleList(
nn.Sequential(Conv(x, c2, 3), Conv(c2, c2, 3), nn.Conv2d(c2, 4 * self.reg_max, 1)) for x in ch
)
- self.cv3 = nn.ModuleList(nn.Sequential(Conv(x, c3, 3), Conv(c3, c3, 3), nn.Conv2d(c3, self.nc, 1)) for x in ch)
+ self.cv3 = nn.ModuleList(
+ nn.Sequential(
+ nn.Sequential(DWConv(x, x, 3), Conv(x, c3, 1)),
+ nn.Sequential(DWConv(c3, c3, 3), Conv(c3, c3, 1)),
+ nn.Conv2d(c3, self.nc, 1),
+ )
+ for x in ch
+ )
self.dfl = DFL(self.reg_max) if self.reg_max > 1 else nn.Identity()
if self.end2end:
diff --git a/ultralytics/nn/tasks.py b/ultralytics/nn/tasks.py
index ad860e93e4..4ae6dba72e 100644
--- a/ultralytics/nn/tasks.py
+++ b/ultralytics/nn/tasks.py
@@ -13,6 +13,7 @@ from ultralytics.nn.modules import (
AIFI,
C1,
C2,
+ C2PSA,
C3,
C3TR,
ELAN1,
@@ -28,7 +29,9 @@ from ultralytics.nn.modules import (
C2f,
C2fAttn,
C2fCIB,
+ C2fPSA,
C3Ghost,
+ C3k2,
C3x,
CBFuse,
CBLinear,
@@ -968,12 +971,15 @@ def parse_model(d, ch, verbose=True): # model_dict, input_channels(3)
GhostBottleneck,
SPP,
SPPF,
+ C2fPSA,
+ C2PSA,
DWConv,
Focus,
BottleneckCSP,
C1,
C2,
C2f,
+ C3k2,
RepNCSPELAN4,
ELAN1,
ADown,
@@ -1001,9 +1007,26 @@ def parse_model(d, ch, verbose=True): # model_dict, input_channels(3)
) # num heads
args = [c1, c2, *args[1:]]
- if m in {BottleneckCSP, C1, C2, C2f, C2fAttn, C3, C3TR, C3Ghost, C3x, RepC3, C2fCIB}:
+ if m in {
+ BottleneckCSP,
+ C1,
+ C2,
+ C2f,
+ C3k2,
+ C2fAttn,
+ C3,
+ C3TR,
+ C3Ghost,
+ C3x,
+ RepC3,
+ C2fPSA,
+ C2fCIB,
+ C2PSA,
+ }:
args.insert(2, n) # number of repeats
n = 1
+ if m is C3k2 and scale in "mlx": # for M/L/X sizes
+ args[3] = True
elif m is AIFI:
args = [ch[f], *args]
elif m in {HGStem, HGBlock}:
@@ -1080,7 +1103,7 @@ def guess_model_scale(model_path):
with contextlib.suppress(AttributeError):
import re
- return re.search(r"yolov\d+([nslmx])", Path(model_path).stem).group(1) # n, s, m, l, or x
+ return re.search(r"yolo[v]?\d+([nslmx])", Path(model_path).stem).group(1) # n, s, m, l, or x
return ""
diff --git a/ultralytics/solutions/object_counter.py b/ultralytics/solutions/object_counter.py
index 398629a8bc..cc7fe45946 100644
--- a/ultralytics/solutions/object_counter.py
+++ b/ultralytics/solutions/object_counter.py
@@ -176,22 +176,24 @@ class ObjectCounter:
# Count objects using line
elif len(self.reg_pts) == 2:
- if prev_position is not None and track_id not in self.count_ids:
- # Check if the object's movement segment intersects the counting line
- if LineString([(prev_position[0], prev_position[1]), (box[0], box[1])]).intersects(
+ if (
+ prev_position is not None
+ and track_id not in self.count_ids
+ and LineString([(prev_position[0], prev_position[1]), (box[0], box[1])]).intersects(
self.counting_line_segment
- ):
- self.count_ids.append(track_id)
-
- # Determine the direction of movement (IN or OUT)
- dx = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0])
- dy = (box[1] - prev_position[1]) * (self.counting_region.centroid.y - prev_position[1])
- if dx > 0 and dy > 0:
- self.in_counts += 1
- self.class_wise_count[self.names[cls]]["IN"] += 1
- else:
- self.out_counts += 1
- self.class_wise_count[self.names[cls]]["OUT"] += 1
+ )
+ ):
+ self.count_ids.append(track_id)
+
+ # Determine the direction of movement (IN or OUT)
+ dx = (box[0] - prev_position[0]) * (self.counting_region.centroid.x - prev_position[0])
+ dy = (box[1] - prev_position[1]) * (self.counting_region.centroid.y - prev_position[1])
+ if dx > 0 and dy > 0:
+ self.in_counts += 1
+ self.class_wise_count[self.names[cls]]["IN"] += 1
+ else:
+ self.out_counts += 1
+ self.class_wise_count[self.names[cls]]["OUT"] += 1
labels_dict = {}
diff --git a/ultralytics/solutions/parking_management.py b/ultralytics/solutions/parking_management.py
index 6128493377..ef58ad6274 100644
--- a/ultralytics/solutions/parking_management.py
+++ b/ultralytics/solutions/parking_management.py
@@ -128,14 +128,13 @@ class ParkingPtsSelection:
rg_data = [] # regions data
for box in self.rg_data:
- rs_box = [] # rescaled box list
- for x, y in box:
- rs_box.append(
- (
- int(x * self.imgw / self.canvas.winfo_width()), # width scaling
- int(y * self.imgh / self.canvas.winfo_height()),
- )
- ) # height scaling
+ rs_box = [
+ (
+ int(x * self.imgw / self.canvas.winfo_width()), # width scaling
+ int(y * self.imgh / self.canvas.winfo_height()), # height scaling
+ )
+ for x, y in box
+ ]
rg_data.append({"points": rs_box})
with open("bounding_boxes.json", "w") as f:
json.dump(rg_data, f, indent=4)
diff --git a/ultralytics/solutions/streamlit_inference.py b/ultralytics/solutions/streamlit_inference.py
index 85394350da..ea85cffba3 100644
--- a/ultralytics/solutions/streamlit_inference.py
+++ b/ultralytics/solutions/streamlit_inference.py
@@ -23,13 +23,13 @@ def inference(model=None):
# Main title of streamlit application
main_title_cfg = """