v1.0

docs/en/tasks/obb.md

+---
+comments: true
+description: Discover how to detect objects with rotation for higher precision using YOLO11 OBB models. Learn, train, validate, and export OBB models effortlessly.
+keywords: Oriented Bounding Boxes, OBB, Object Detection, YOLO11, Ultralytics, DOTAv1, Model Training, Model Export, AI, Machine Learning
+model_name: yolo11n-obb
+---
+
+# Oriented Bounding Boxes [Object Detection](https://www.ultralytics.com/glossary/object-detection)
+
+<!-- obb task poster -->
+
+Oriented object detection goes a step further than object detection and introduce an extra angle to locate objects more accurate in an image.
+
+The output of an oriented object detector is a set of rotated bounding boxes that exactly enclose the objects in the image, along with class labels and confidence scores for each box. Object detection is a good choice when you need to identify objects of interest in a scene, but don't need to know exactly where the object is or its exact shape.
+
+<!-- youtube video link for obb task -->
+
+!!! tip
+
+    YOLO11 OBB models use the `-obb` suffix, i.e. `yolo11n-obb.pt` and are pretrained on [DOTAv1](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/DOTAv1.yaml).
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/Z7Z9pHF8wJc"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Object Detection using Ultralytics YOLO Oriented Bounding Boxes (YOLO-OBB)
+</p>
+
+## Visual Samples
+
+|                                              Ships Detection using OBB                                               |                                               Vehicle Detection using OBB                                                |
+| :------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------: |
+| ![Ships Detection using OBB](https://github.com/ultralytics/docs/releases/download/0/ships-detection-using-obb.avif) | ![Vehicle Detection using OBB](https://github.com/ultralytics/docs/releases/download/0/vehicle-detection-using-obb.avif) |
+
+## [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/11)
+
+YOLO11 pretrained OBB models are shown here, which are pretrained on the [DOTAv1](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/DOTAv1.yaml) dataset.
+
+[Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+{% include "macros/yolo-obb-perf.md" %}
+
+- **mAP<sup>test</sup>** values are for single-model multiscale on [DOTAv1](https://captain-whu.github.io/DOTA/index.html) dataset. <br>Reproduce by `yolo val obb data=DOTAv1.yaml device=0 split=test` and submit merged results to [DOTA evaluation](https://captain-whu.github.io/DOTA/evaluation.html).
+- **Speed** averaged over DOTAv1 val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val obb data=DOTAv1.yaml batch=1 device=0|cpu`
+
+## Train
+
+Train YOLO11n-obb on the DOTA8 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) at image size 640. For a full list of available arguments see the [Configuration](../usage/cfg.md) page.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-obb.yaml")  # build a new model from YAML
+        model = YOLO("yolo11n-obb.pt")  # load a pretrained model (recommended for training)
+        model = YOLO("yolo11n-obb.yaml").load("yolo11n.pt")  # build from YAML and transfer weights
+
+        # Train the model
+        results = model.train(data="dota8.yaml", epochs=100, imgsz=640)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Build a new model from YAML and start training from scratch
+        yolo obb train data=dota8.yaml model=yolo11n-obb.yaml epochs=100 imgsz=640
+
+        # Start training from a pretrained *.pt model
+        yolo obb train data=dota8.yaml model=yolo11n-obb.pt epochs=100 imgsz=640
+
+        # Build a new model from YAML, transfer pretrained weights to it and start training
+        yolo obb train data=dota8.yaml model=yolo11n-obb.yaml pretrained=yolo11n-obb.pt epochs=100 imgsz=640
+        ```
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/uZ7SymQfqKI"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> How to Train Ultralytics YOLO-OBB (Oriented Bounding Boxes) Models on DOTA Dataset using Ultralytics HUB
+</p>
+
+### Dataset format
+
+OBB dataset format can be found in detail in the [Dataset Guide](../datasets/obb/index.md).
+
+## Val
+
+Validate trained YOLO11n-obb model [accuracy](https://www.ultralytics.com/glossary/accuracy) on the DOTA8 dataset. No arguments are needed as the `model` retains its training `data` and arguments as model attributes.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-obb.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom model
+
+        # Validate the model
+        metrics = model.val(data="dota8.yaml")  # no arguments needed, dataset and settings remembered
+        metrics.box.map  # map50-95(B)
+        metrics.box.map50  # map50(B)
+        metrics.box.map75  # map75(B)
+        metrics.box.maps  # a list contains map50-95(B) of each category
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo obb val model=yolo11n-obb.pt data=dota8.yaml  # val official model
+        yolo obb val model=path/to/best.pt data=path/to/data.yaml  # val custom model
+        ```
+
+## Predict
+
+Use a trained YOLO11n-obb model to run predictions on images.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-obb.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom model
+
+        # Predict with the model
+        results = model("https://ultralytics.com/images/boats.jpg")  # predict on an image
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo obb predict model=yolo11n-obb.pt source='https://ultralytics.com/images/boats.jpg'  # predict with official model
+        yolo obb predict model=path/to/best.pt source='https://ultralytics.com/images/boats.jpg'  # predict with custom model
+        ```
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/5XYdm5CYODA"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> How to Detect and Track Storage Tanks using Ultralytics YOLO-OBB | Oriented Bounding Boxes | DOTA
+</p>
+
+See full `predict` mode details in the [Predict](../modes/predict.md) page.
+
+## Export
+
+Export a YOLO11n-obb model to a different format like ONNX, CoreML, etc.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-obb.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom trained model
+
+        # Export the model
+        model.export(format="onnx")
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo export model=yolo11n-obb.pt format=onnx  # export official model
+        yolo export model=path/to/best.pt format=onnx  # export custom trained model
+        ```
+
+Available YOLO11-obb export formats are in the table below. You can export to any format using the `format` argument, i.e. `format='onnx'` or `format='engine'`. You can predict or validate directly on exported models, i.e. `yolo predict model=yolo11n-obb.onnx`. Usage examples are shown for your model after export completes.
+
+{% include "macros/export-table.md" %}
+
+See full `export` details in the [Export](../modes/export.md) page.
+
+## FAQ
+
+### What are Oriented Bounding Boxes (OBB) and how do they differ from regular bounding boxes?
+
+Oriented Bounding Boxes (OBB) include an additional angle to enhance object localization accuracy in images. Unlike regular bounding boxes, which are axis-aligned rectangles, OBBs can rotate to fit the orientation of the object better. This is particularly useful for applications requiring precise object placement, such as aerial or satellite imagery ([Dataset Guide](../datasets/obb/index.md)).
+
+### How do I train a YOLO11n-obb model using a custom dataset?
+
+To train a YOLO11n-obb model with a custom dataset, follow the example below using Python or CLI:
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a pretrained model
+        model = YOLO("yolo11n-obb.pt")
+
+        # Train the model
+        results = model.train(data="path/to/custom_dataset.yaml", epochs=100, imgsz=640)
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo obb train data=path/to/custom_dataset.yaml model=yolo11n-obb.pt epochs=100 imgsz=640
+        ```
+
+For more training arguments, check the [Configuration](../usage/cfg.md) section.
+
+### What datasets can I use for training YOLO11-OBB models?
+
+YOLO11-OBB models are pretrained on datasets like [DOTAv1](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/DOTAv1.yaml) but you can use any dataset formatted for OBB. Detailed information on OBB dataset formats can be found in the [Dataset Guide](../datasets/obb/index.md).
+
+### How can I export a YOLO11-OBB model to ONNX format?
+
+Exporting a YOLO11-OBB model to ONNX format is straightforward using either Python or CLI:
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-obb.pt")
+
+        # Export the model
+        model.export(format="onnx")
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo export model=yolo11n-obb.pt format=onnx
+        ```
+
+For more export formats and details, refer to the [Export](../modes/export.md) page.
+
+### How do I validate the accuracy of a YOLO11n-obb model?
+
+To validate a YOLO11n-obb model, you can use Python or CLI commands as shown below:
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-obb.pt")
+
+        # Validate the model
+        metrics = model.val(data="dota8.yaml")
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo obb val model=yolo11n-obb.pt data=dota8.yaml
+        ```
+
+See full validation details in the [Val](../modes/val.md) section.

docs/en/tasks/pose.md

+---
+comments: true
+description: Discover how to use YOLO11 for pose estimation tasks. Learn about model training, validation, prediction, and exporting in various formats.
+keywords: pose estimation, YOLO11, Ultralytics, keypoints, model training, image recognition, deep learning
+model_name: yolo11n-pose
+---
+
+# Pose Estimation
+
+<img width="1024" src="https://github.com/ultralytics/docs/releases/download/0/pose-estimation-examples.avif" alt="Pose estimation examples">
+
+Pose estimation is a task that involves identifying the location of specific points in an image, usually referred to as keypoints. The keypoints can represent various parts of the object such as joints, landmarks, or other distinctive features. The locations of the keypoints are usually represented as a set of 2D `[x, y]` or 3D `[x, y, visible]` coordinates.
+
+The output of a pose estimation model is a set of points that represent the keypoints on an object in the image, usually along with the confidence scores for each point. Pose estimation is a good choice when you need to identify specific parts of an object in a scene, and their location in relation to each other.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/AAkfToU3nAc"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Ultralytics YOLO11 Pose Estimation Tutorial | Real-Time Object Tracking and Human Pose Detection
+</p>
+
+!!! tip
+
+    YOLO11 _pose_ models use the `-pose` suffix, i.e. `yolo11n-pose.pt`. These models are trained on the [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) dataset and are suitable for a variety of pose estimation tasks.
+
+    In the default YOLO11 pose model, there are 17 keypoints, each representing a different part of the human body. Here is the mapping of each index to its respective body joint:
+
+    0: Nose
+    1: Left Eye
+    2: Right Eye
+    3: Left Ear
+    4: Right Ear
+    5: Left Shoulder
+    6: Right Shoulder
+    7: Left Elbow
+    8: Right Elbow
+    9: Left Wrist
+    10: Right Wrist
+    11: Left Hip
+    12: Right Hip
+    13: Left Knee
+    14: Right Knee
+    15: Left Ankle
+    16: Right Ankle
+
+## [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/11)
+
+YOLO11 pretrained Pose models are shown here. Detect, Segment and Pose models are pretrained on the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) dataset, while Classify models are pretrained on the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) dataset.
+
+[Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+{% include "macros/yolo-pose-perf.md" %}
+
+- **mAP<sup>val</sup>** values are for single-model single-scale on [COCO Keypoints val2017](https://cocodataset.org/) dataset. <br>Reproduce by `yolo val pose data=coco-pose.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val pose data=coco-pose.yaml batch=1 device=0|cpu`
+
+## Train
+
+Train a YOLO11-pose model on the COCO8-pose dataset.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-pose.yaml")  # build a new model from YAML
+        model = YOLO("yolo11n-pose.pt")  # load a pretrained model (recommended for training)
+        model = YOLO("yolo11n-pose.yaml").load("yolo11n-pose.pt")  # build from YAML and transfer weights
+
+        # Train the model
+        results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Build a new model from YAML and start training from scratch
+        yolo pose train data=coco8-pose.yaml model=yolo11n-pose.yaml epochs=100 imgsz=640
+
+        # Start training from a pretrained *.pt model
+        yolo pose train data=coco8-pose.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
+
+        # Build a new model from YAML, transfer pretrained weights to it and start training
+        yolo pose train data=coco8-pose.yaml model=yolo11n-pose.yaml pretrained=yolo11n-pose.pt epochs=100 imgsz=640
+        ```
+
+### Dataset format
+
+YOLO pose dataset format can be found in detail in the [Dataset Guide](../datasets/pose/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics.
+
+## Val
+
+Validate trained YOLO11n-pose model [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8-pose dataset. No arguments are needed as the `model` retains its training `data` and arguments as model attributes.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-pose.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom model
+
+        # Validate the model
+        metrics = model.val()  # no arguments needed, dataset and settings remembered
+        metrics.box.map  # map50-95
+        metrics.box.map50  # map50
+        metrics.box.map75  # map75
+        metrics.box.maps  # a list contains map50-95 of each category
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo pose val model=yolo11n-pose.pt  # val official model
+        yolo pose val model=path/to/best.pt  # val custom model
+        ```
+
+## Predict
+
+Use a trained YOLO11n-pose model to run predictions on images.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-pose.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom model
+
+        # Predict with the model
+        results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo pose predict model=yolo11n-pose.pt source='https://ultralytics.com/images/bus.jpg'  # predict with official model
+        yolo pose predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg'  # predict with custom model
+        ```
+
+See full `predict` mode details in the [Predict](../modes/predict.md) page.
+
+## Export
+
+Export a YOLO11n Pose model to a different format like ONNX, CoreML, etc.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-pose.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom trained model
+
+        # Export the model
+        model.export(format="onnx")
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo export model=yolo11n-pose.pt format=onnx  # export official model
+        yolo export model=path/to/best.pt format=onnx  # export custom trained model
+        ```
+
+Available YOLO11-pose export formats are in the table below. You can export to any format using the `format` argument, i.e. `format='onnx'` or `format='engine'`. You can predict or validate directly on exported models, i.e. `yolo predict model=yolo11n-pose.onnx`. Usage examples are shown for your model after export completes.
+
+{% include "macros/export-table.md" %}
+
+See full `export` details in the [Export](../modes/export.md) page.
+
+## FAQ
+
+### What is Pose Estimation with Ultralytics YOLO11 and how does it work?
+
+Pose estimation with Ultralytics YOLO11 involves identifying specific points, known as keypoints, in an image. These keypoints typically represent joints or other important features of the object. The output includes the `[x, y]` coordinates and confidence scores for each point. YOLO11-pose models are specifically designed for this task and use the `-pose` suffix, such as `yolo11n-pose.pt`. These models are pre-trained on datasets like [COCO keypoints](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco-pose.yaml) and can be used for various pose estimation tasks. For more information, visit the [Pose Estimation Page](#pose-estimation).
+
+### How can I train a YOLO11-pose model on a custom dataset?
+
+Training a YOLO11-pose model on a custom dataset involves loading a model, either a new model defined by a YAML file or a pre-trained model. You can then start the training process using your specified dataset and parameters.
+
+```python
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO("yolo11n-pose.yaml")  # build a new model from YAML
+model = YOLO("yolo11n-pose.pt")  # load a pretrained model (recommended for training)
+
+# Train the model
+results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)
+```
+
+For comprehensive details on training, refer to the [Train Section](#train).
+
+### How do I validate a trained YOLO11-pose model?
+
+Validation of a YOLO11-pose model involves assessing its accuracy using the same dataset parameters retained during training. Here's an example:
+
+```python
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO("yolo11n-pose.pt")  # load an official model
+model = YOLO("path/to/best.pt")  # load a custom model
+
+# Validate the model
+metrics = model.val()  # no arguments needed, dataset and settings remembered
+```
+
+For more information, visit the [Val Section](#val).
+
+### Can I export a YOLO11-pose model to other formats, and how?
+
+Yes, you can export a YOLO11-pose model to various formats like ONNX, CoreML, TensorRT, and more. This can be done using either Python or the Command Line Interface (CLI).
+
+```python
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO("yolo11n-pose.pt")  # load an official model
+model = YOLO("path/to/best.pt")  # load a custom trained model
+
+# Export the model
+model.export(format="onnx")
+```
+
+Refer to the [Export Section](#export) for more details.
+
+### What are the available Ultralytics YOLO11-pose models and their performance metrics?
+
+Ultralytics YOLO11 offers various pretrained pose models such as YOLO11n-pose, YOLO11s-pose, YOLO11m-pose, among others. These models differ in size, accuracy (mAP), and speed. For instance, the YOLO11n-pose model achieves a mAP<sup>pose</sup>50-95 of 50.4 and an mAP<sup>pose</sup>50 of 80.1. For a complete list and performance details, visit the [Models Section](#models).

docs/en/tasks/segment.md

+---
+comments: true
+description: Master instance segmentation using YOLO11. Learn how to detect, segment and outline objects in images with detailed guides and examples.
+keywords: instance segmentation, YOLO11, object detection, image segmentation, machine learning, deep learning, computer vision, COCO dataset, Ultralytics
+model_name: yolo11n-seg
+---
+
+# Instance Segmentation
+
+<img width="1024" src="https://github.com/ultralytics/docs/releases/download/0/instance-segmentation-examples.avif" alt="Instance segmentation examples">
+
+[Instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) goes a step further than object detection and involves identifying individual objects in an image and segmenting them from the rest of the image.
+
+The output of an instance segmentation model is a set of masks or contours that outline each object in the image, along with class labels and confidence scores for each object. Instance segmentation is useful when you need to know not only where objects are in an image, but also what their exact shape is.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/o4Zd-IeMlSY?si=37nusCzDTd74Obsp"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Run Segmentation with Pre-Trained Ultralytics YOLO Model in Python.
+</p>
+
+!!! tip
+
+    YOLO11 Segment models use the `-seg` suffix, i.e. `yolo11n-seg.pt` and are pretrained on [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml).
+
+## [Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models/11)
+
+YOLO11 pretrained Segment models are shown here. Detect, Segment and Pose models are pretrained on the [COCO](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml) dataset, while Classify models are pretrained on the [ImageNet](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/ImageNet.yaml) dataset.
+
+[Models](https://github.com/ultralytics/ultralytics/tree/main/ultralytics/cfg/models) download automatically from the latest Ultralytics [release](https://github.com/ultralytics/assets/releases) on first use.
+
+{% include "macros/yolo-seg-perf.md" %}
+
+- **mAP<sup>val</sup>** values are for single-model single-scale on [COCO val2017](https://cocodataset.org/) dataset. <br>Reproduce by `yolo val segment data=coco.yaml device=0`
+- **Speed** averaged over COCO val images using an [Amazon EC2 P4d](https://aws.amazon.com/ec2/instance-types/p4/) instance. <br>Reproduce by `yolo val segment data=coco.yaml batch=1 device=0|cpu`
+
+## Train
+
+Train YOLO11n-seg on the COCO8-seg dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) at image size 640. For a full list of available arguments see the [Configuration](../usage/cfg.md) page.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-seg.yaml")  # build a new model from YAML
+        model = YOLO("yolo11n-seg.pt")  # load a pretrained model (recommended for training)
+        model = YOLO("yolo11n-seg.yaml").load("yolo11n.pt")  # build from YAML and transfer weights
+
+        # Train the model
+        results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Build a new model from YAML and start training from scratch
+        yolo segment train data=coco8-seg.yaml model=yolo11n-seg.yaml epochs=100 imgsz=640
+
+        # Start training from a pretrained *.pt model
+        yolo segment train data=coco8-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
+
+        # Build a new model from YAML, transfer pretrained weights to it and start training
+        yolo segment train data=coco8-seg.yaml model=yolo11n-seg.yaml pretrained=yolo11n-seg.pt epochs=100 imgsz=640
+        ```
+
+### Dataset format
+
+YOLO segmentation dataset format can be found in detail in the [Dataset Guide](../datasets/segment/index.md). To convert your existing dataset from other formats (like COCO etc.) to YOLO format, please use [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) tool by Ultralytics.
+
+## Val
+
+Validate trained YOLO11n-seg model [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8-seg dataset. No arguments are needed as the `model` retains its training `data` and arguments as model attributes.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-seg.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom model
+
+        # Validate the model
+        metrics = model.val()  # no arguments needed, dataset and settings remembered
+        metrics.box.map  # map50-95(B)
+        metrics.box.map50  # map50(B)
+        metrics.box.map75  # map75(B)
+        metrics.box.maps  # a list contains map50-95(B) of each category
+        metrics.seg.map  # map50-95(M)
+        metrics.seg.map50  # map50(M)
+        metrics.seg.map75  # map75(M)
+        metrics.seg.maps  # a list contains map50-95(M) of each category
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo segment val model=yolo11n-seg.pt  # val official model
+        yolo segment val model=path/to/best.pt  # val custom model
+        ```
+
+## Predict
+
+Use a trained YOLO11n-seg model to run predictions on images.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-seg.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom model
+
+        # Predict with the model
+        results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo segment predict model=yolo11n-seg.pt source='https://ultralytics.com/images/bus.jpg'  # predict with official model
+        yolo segment predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg'  # predict with custom model
+        ```
+
+See full `predict` mode details in the [Predict](../modes/predict.md) page.
+
+## Export
+
+Export a YOLO11n-seg model to a different format like ONNX, CoreML, etc.
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n-seg.pt")  # load an official model
+        model = YOLO("path/to/best.pt")  # load a custom trained model
+
+        # Export the model
+        model.export(format="onnx")
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo export model=yolo11n-seg.pt format=onnx  # export official model
+        yolo export model=path/to/best.pt format=onnx  # export custom trained model
+        ```
+
+Available YOLO11-seg export formats are in the table below. You can export to any format using the `format` argument, i.e. `format='onnx'` or `format='engine'`. You can predict or validate directly on exported models, i.e. `yolo predict model=yolo11n-seg.onnx`. Usage examples are shown for your model after export completes.
+
+{% include "macros/export-table.md" %}
+
+See full `export` details in the [Export](../modes/export.md) page.
+
+## FAQ
+
+### How do I train a YOLO11 segmentation model on a custom dataset?
+
+To train a YOLO11 segmentation model on a custom dataset, you first need to prepare your dataset in the YOLO segmentation format. You can use tools like [JSON2YOLO](https://github.com/ultralytics/JSON2YOLO) to convert datasets from other formats. Once your dataset is ready, you can train the model using Python or CLI commands:
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a pretrained YOLO11 segment model
+        model = YOLO("yolo11n-seg.pt")
+
+        # Train the model
+        results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=640)
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo segment train data=path/to/your_dataset.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
+        ```
+
+Check the [Configuration](../usage/cfg.md) page for more available arguments.
+
+### What is the difference between [object detection](https://www.ultralytics.com/glossary/object-detection) and instance segmentation in YOLO11?
+
+Object detection identifies and localizes objects within an image by drawing bounding boxes around them, whereas instance segmentation not only identifies the bounding boxes but also delineates the exact shape of each object. YOLO11 instance segmentation models provide masks or contours that outline each detected object, which is particularly useful for tasks where knowing the precise shape of objects is important, such as medical imaging or autonomous driving.
+
+### Why use YOLO11 for instance segmentation?
+
+Ultralytics YOLO11 is a state-of-the-art model recognized for its high accuracy and real-time performance, making it ideal for instance segmentation tasks. YOLO11 Segment models come pretrained on the [COCO dataset](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco.yaml), ensuring robust performance across a variety of objects. Additionally, YOLO supports training, validation, prediction, and export functionalities with seamless integration, making it highly versatile for both research and industry applications.
+
+### How do I load and validate a pretrained YOLO segmentation model?
+
+Loading and validating a pretrained YOLO segmentation model is straightforward. Here's how you can do it using both Python and CLI:
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a pretrained model
+        model = YOLO("yolo11n-seg.pt")
+
+        # Validate the model
+        metrics = model.val()
+        print("Mean Average Precision for boxes:", metrics.box.map)
+        print("Mean Average Precision for masks:", metrics.seg.map)
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo segment val model=yolo11n-seg.pt
+        ```
+
+These steps will provide you with validation metrics like [Mean Average Precision](https://www.ultralytics.com/glossary/mean-average-precision-map) (mAP), crucial for assessing model performance.
+
+### How can I export a YOLO segmentation model to ONNX format?
+
+Exporting a YOLO segmentation model to ONNX format is simple and can be done using Python or CLI commands:
+
+!!! example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a pretrained model
+        model = YOLO("yolo11n-seg.pt")
+
+        # Export the model to ONNX format
+        model.export(format="onnx")
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo export model=yolo11n-seg.pt format=onnx
+        ```
+
+For more details on exporting to various formats, refer to the [Export](../modes/export.md) page.

docs/en/usage/callbacks.md

+---
+comments: true
+description: Explore Ultralytics callbacks for training, validation, exporting, and prediction. Learn how to use and customize them for your ML models.
+keywords: Ultralytics, callbacks, training, validation, export, prediction, ML models, YOLO11, Python, machine learning
+---
+
+## Callbacks
+
+Ultralytics framework supports callbacks as entry points in strategic stages of train, val, export, and predict modes. Each callback accepts a `Trainer`, `Validator`, or `Predictor` object depending on the operation type. All properties of these objects can be found in Reference section of the docs.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/GsXGnb-A4Kc?start=67"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Mastering Ultralytics YOLO: Callbacks
+</p>
+
+## Examples
+
+### Returning additional information with Prediction
+
+In this example, we want to return the original frame with each result object. Here's how we can do that
+
+```python
+from ultralytics import YOLO
+
+
+def on_predict_batch_end(predictor):
+    """Handle prediction batch end by combining results with corresponding frames; modifies predictor results."""
+    _, image, _, _ = predictor.batch
+
+    # Ensure that image is a list
+    image = image if isinstance(image, list) else [image]
+
+    # Combine the prediction results with the corresponding frames
+    predictor.results = zip(predictor.results, image)
+
+
+# Create a YOLO model instance
+model = YOLO("yolo11n.pt")
+
+# Add the custom callback to the model
+model.add_callback("on_predict_batch_end", on_predict_batch_end)
+
+# Iterate through the results and frames
+for result, frame in model.predict():  # or model.track()
+    pass
+```
+
+## All callbacks
+
+Here are all supported callbacks. See callbacks [source code](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/base.py) for additional details.
+
+### Trainer Callbacks
+
+| Callback                    | Description                                                                                 |
+| --------------------------- | ------------------------------------------------------------------------------------------- |
+| `on_pretrain_routine_start` | Triggered at the beginning of pre-training routine                                          |
+| `on_pretrain_routine_end`   | Triggered at the end of pre-training routine                                                |
+| `on_train_start`            | Triggered when the training starts                                                          |
+| `on_train_epoch_start`      | Triggered at the start of each training [epoch](https://www.ultralytics.com/glossary/epoch) |
+| `on_train_batch_start`      | Triggered at the start of each training batch                                               |
+| `optimizer_step`            | Triggered during the optimizer step                                                         |
+| `on_before_zero_grad`       | Triggered before gradients are zeroed                                                       |
+| `on_train_batch_end`        | Triggered at the end of each training batch                                                 |
+| `on_train_epoch_end`        | Triggered at the end of each training epoch                                                 |
+| `on_fit_epoch_end`          | Triggered at the end of each fit epoch                                                      |
+| `on_model_save`             | Triggered when the model is saved                                                           |
+| `on_train_end`              | Triggered when the training process ends                                                    |
+| `on_params_update`          | Triggered when model parameters are updated                                                 |
+| `teardown`                  | Triggered when the training process is being cleaned up                                     |
+
+### Validator Callbacks
+
+| Callback             | Description                                     |
+| -------------------- | ----------------------------------------------- |
+| `on_val_start`       | Triggered when the validation starts            |
+| `on_val_batch_start` | Triggered at the start of each validation batch |
+| `on_val_batch_end`   | Triggered at the end of each validation batch   |
+| `on_val_end`         | Triggered when the validation ends              |
+
+### Predictor Callbacks
+
+| Callback                     | Description                                       |
+| ---------------------------- | ------------------------------------------------- |
+| `on_predict_start`           | Triggered when the prediction process starts      |
+| `on_predict_batch_start`     | Triggered at the start of each prediction batch   |
+| `on_predict_postprocess_end` | Triggered at the end of prediction postprocessing |
+| `on_predict_batch_end`       | Triggered at the end of each prediction batch     |
+| `on_predict_end`             | Triggered when the prediction process ends        |
+
+### Exporter Callbacks
+
+| Callback          | Description                              |
+| ----------------- | ---------------------------------------- |
+| `on_export_start` | Triggered when the export process starts |
+| `on_export_end`   | Triggered when the export process ends   |
+
+## FAQ
+
+### What are Ultralytics callbacks and how can I use them?
+
+**Ultralytics callbacks** are specialized entry points triggered during key stages of model operations like training, validation, exporting, and prediction. These callbacks allow for custom functionality at specific points in the process, enabling enhancements and modifications to the workflow. Each callback accepts a `Trainer`, `Validator`, or `Predictor` object, depending on the operation type. For detailed properties of these objects, refer to the [Reference section](../reference/cfg/__init__.md).
+
+To use a callback, you can define a function and then add it to the model with the `add_callback` method. Here's an example of how to return additional information during prediction:
+
+```python
+from ultralytics import YOLO
+
+
+def on_predict_batch_end(predictor):
+    """Handle prediction batch end by combining results with corresponding frames; modifies predictor results."""
+    _, image, _, _ = predictor.batch
+    image = image if isinstance(image, list) else [image]
+    predictor.results = zip(predictor.results, image)
+
+
+model = YOLO("yolo11n.pt")
+model.add_callback("on_predict_batch_end", on_predict_batch_end)
+for result, frame in model.predict():
+    pass
+```
+
+### How can I customize Ultralytics training routine using callbacks?
+
+To customize your Ultralytics training routine using callbacks, you can inject your logic at specific stages of the training process. Ultralytics YOLO provides a variety of training callbacks such as `on_train_start`, `on_train_end`, and `on_train_batch_end`. These allow you to add custom metrics, processing, or logging.
+
+Here's an example of how to log additional metrics at the end of each training epoch:
+
+```python
+from ultralytics import YOLO
+
+
+def on_train_epoch_end(trainer):
+    """Custom logic for additional metrics logging at the end of each training epoch."""
+    additional_metric = compute_additional_metric(trainer)
+    trainer.log({"additional_metric": additional_metric})
+
+
+model = YOLO("yolo11n.pt")
+model.add_callback("on_train_epoch_end", on_train_epoch_end)
+model.train(data="coco.yaml", epochs=10)
+```
+
+Refer to the [Training Guide](../modes/train.md) for more details on how to effectively use training callbacks.
+
+### Why should I use callbacks during validation in Ultralytics YOLO?
+
+Using **callbacks during validation** in Ultralytics YOLO can enhance model evaluation by allowing custom processing, logging, or metrics calculation. Callbacks such as `on_val_start`, `on_val_batch_end`, and `on_val_end` provide entry points to inject custom logic, ensuring detailed and comprehensive validation processes.
+
+For instance, you might want to log additional validation metrics or save intermediate results for further analysis. Here's an example of how to log custom metrics at the end of validation:
+
+```python
+from ultralytics import YOLO
+
+
+def on_val_end(validator):
+    """Log custom metrics at end of validation."""
+    custom_metric = compute_custom_metric(validator)
+    validator.log({"custom_metric": custom_metric})
+
+
+model = YOLO("yolo11n.pt")
+model.add_callback("on_val_end", on_val_end)
+model.val(data="coco.yaml")
+```
+
+Check out the [Validation Guide](../modes/val.md) for further insights on incorporating callbacks into your validation process.
+
+### How do I attach a custom callback for the prediction mode in Ultralytics YOLO?
+
+To attach a custom callback for the **prediction mode** in Ultralytics YOLO, you define a callback function and register it with the prediction process. Common prediction callbacks include `on_predict_start`, `on_predict_batch_end`, and `on_predict_end`. These allow for modification of prediction outputs and integration of additional functionalities like data logging or result transformation.
+
+Here is an example where a custom callback is used to log predictions:
+
+```python
+from ultralytics import YOLO
+
+
+def on_predict_end(predictor):
+    """Log predictions at the end of prediction."""
+    for result in predictor.results:
+        log_prediction(result)
+
+
+model = YOLO("yolo11n.pt")
+model.add_callback("on_predict_end", on_predict_end)
+results = model.predict(source="image.jpg")
+```
+
+For more comprehensive usage, refer to the [Prediction Guide](../modes/predict.md) which includes detailed instructions and additional customization options.
+
+### What are some practical examples of using callbacks in Ultralytics YOLO?
+
+Ultralytics YOLO supports various practical implementations of callbacks to enhance and customize different phases like training, validation, and prediction. Some practical examples include:
+
+1. **Logging Custom Metrics**: Log additional metrics at different stages, such as the end of training or validation epochs.
+2. **[Data Augmentation](https://www.ultralytics.com/glossary/data-augmentation)**: Implement custom data transformations or augmentations during prediction or training batches.
+3. **Intermediate Results**: Save intermediate results such as predictions or frames for further analysis or visualization.
+
+Example: Combining frames with prediction results during prediction using `on_predict_batch_end`:
+
+```python
+from ultralytics import YOLO
+
+
+def on_predict_batch_end(predictor):
+    """Combine prediction results with frames."""
+    _, image, _, _ = predictor.batch
+    image = image if isinstance(image, list) else [image]
+    predictor.results = zip(predictor.results, image)
+
+
+model = YOLO("yolo11n.pt")
+model.add_callback("on_predict_batch_end", on_predict_batch_end)
+for result, frame in model.predict():
+    pass
+```
+
+Explore the [Complete Callback Reference](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/utils/callbacks/base.py) to find more options and examples.

docs/en/usage/cfg.md

+---
+comments: true
+description: Optimize your YOLO model's performance with the right settings and hyperparameters. Learn about training, validation, and prediction configurations.
+keywords: YOLO, hyperparameters, configuration, training, validation, prediction, model settings, Ultralytics, performance optimization, machine learning
+---
+
+YOLO settings and hyperparameters play a critical role in the model's performance, speed, and [accuracy](https://www.ultralytics.com/glossary/accuracy). These settings and hyperparameters can affect the model's behavior at various stages of the model development process, including training, validation, and prediction.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/GsXGnb-A4Kc?start=87"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Mastering Ultralytics YOLO: Configuration
+</p>
+
+Ultralytics commands use the following syntax:
+
+!!! example
+
+    === "CLI"
+
+        ```bash
+        yolo TASK MODE ARGS
+        ```
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a YOLO11 model from a pre-trained weights file
+        model = YOLO("yolo11n.pt")
+
+        # Run MODE mode using the custom arguments ARGS (guess TASK)
+        model.MODE(ARGS)
+        ```
+
+Where:
+
+- `TASK` (optional) is one of ([detect](../tasks/detect.md), [segment](../tasks/segment.md), [classify](../tasks/classify.md), [pose](../tasks/pose.md), [obb](../tasks/obb.md))
+- `MODE` (required) is one of ([train](../modes/train.md), [val](../modes/val.md), [predict](../modes/predict.md), [export](../modes/export.md), [track](../modes/track.md), [benchmark](../modes/benchmark.md))
+- `ARGS` (optional) are `arg=value` pairs like `imgsz=640` that override defaults.
+
+Default `ARG` values are defined on this page from the `cfg/defaults.yaml` [file](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/default.yaml).
+
+#### Tasks
+
+YOLO models can be used for a variety of tasks, including detection, segmentation, classification and pose. These tasks differ in the type of output they produce and the specific problem they are designed to solve.
+
+- **Detect**: For identifying and localizing objects or regions of interest in an image or video.
+- **Segment**: For dividing an image or video into regions or pixels that correspond to different objects or classes.
+- **Classify**: For predicting the class label of an input image.
+- **Pose**: For identifying objects and estimating their keypoints in an image or video.
+- **OBB**: Oriented (i.e. rotated) bounding boxes suitable for satellite or medical imagery.
+
+| Argument | Default    | Description                                                                                                                                                                                                                                                                                                                                                                  |
+| -------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `task`   | `'detect'` | Specifies the YOLO task to be executed. Options include `detect` for [object detection](https://www.ultralytics.com/glossary/object-detection), `segment` for segmentation, `classify` for classification, `pose` for pose estimation and `obb` for oriented bounding boxes. Each task is tailored to specific types of output and problems within image and video analysis. |
+
+[Tasks Guide](../tasks/index.md){ .md-button }
+
+#### Modes
+
+YOLO models can be used in different modes depending on the specific problem you are trying to solve. These modes include:
+
+- **Train**: For training a YOLO11 model on a custom dataset.
+- **Val**: For validating a YOLO11 model after it has been trained.
+- **Predict**: For making predictions using a trained YOLO11 model on new images or videos.
+- **Export**: For exporting a YOLO11 model to a format that can be used for deployment.
+- **Track**: For tracking objects in real-time using a YOLO11 model.
+- **Benchmark**: For benchmarking YOLO11 exports (ONNX, TensorRT, etc.) speed and accuracy.
+
+| Argument | Default   | Description                                                                                                                                                                                                                                                                                                                                                                                   |
+| -------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `mode`   | `'train'` | Specifies the mode in which the YOLO model operates. Options are `train` for model training, `val` for validation, `predict` for inference on new data, `export` for model conversion to deployment formats, `track` for object tracking, and `benchmark` for performance evaluation. Each mode is designed for different stages of the model lifecycle, from development through deployment. |
+
+[Modes Guide](../modes/index.md){ .md-button }
+
+## Train Settings
+
+The training settings for YOLO models encompass various hyperparameters and configurations used during the training process. These settings influence the model's performance, speed, and accuracy. Key training settings include batch size, [learning rate](https://www.ultralytics.com/glossary/learning-rate), momentum, and weight decay. Additionally, the choice of optimizer, [loss function](https://www.ultralytics.com/glossary/loss-function), and training dataset composition can impact the training process. Careful tuning and experimentation with these settings are crucial for optimizing performance.
+
+{% include "macros/train-args.md" %}
+
+!!! info "Note on Batch-size Settings"
+
+    The `batch` argument can be configured in three ways:
+
+    - **Fixed [Batch Size](https://www.ultralytics.com/glossary/batch-size)**: Set an integer value (e.g., `batch=16`), specifying the number of images per batch directly.
+    - **Auto Mode (60% GPU Memory)**: Use `batch=-1` to automatically adjust batch size for approximately 60% CUDA memory utilization.
+    - **Auto Mode with Utilization Fraction**: Set a fraction value (e.g., `batch=0.70`) to adjust batch size based on the specified fraction of GPU memory usage.
+
+[Train Guide](../modes/train.md){ .md-button }
+
+## Predict Settings
+
+The prediction settings for YOLO models encompass a range of hyperparameters and configurations that influence the model's performance, speed, and accuracy during inference on new data. Careful tuning and experimentation with these settings are essential to achieve optimal performance for a specific task. Key settings include the confidence threshold, Non-Maximum Suppression (NMS) threshold, and the number of classes considered. Additional factors affecting the prediction process are input data size and format, the presence of supplementary features such as masks or multiple labels per box, and the particular task the model is employed for.
+
+Inference arguments:
+
+{% include "macros/predict-args.md" %}
+
+Visualization arguments:
+
+{% include "macros/visualization-args.md" %}
+
+[Predict Guide](../modes/predict.md){ .md-button }
+
+## Validation Settings
+
+The val (validation) settings for YOLO models involve various hyperparameters and configurations used to evaluate the model's performance on a validation dataset. These settings influence the model's performance, speed, and accuracy. Common YOLO validation settings include batch size, validation frequency during training, and performance evaluation metrics. Other factors affecting the validation process include the validation dataset's size and composition, as well as the specific task the model is employed for.
+
+{% include "macros/validation-args.md" %}
+
+Careful tuning and experimentation with these settings are crucial to ensure optimal performance on the validation dataset and detect and prevent [overfitting](https://www.ultralytics.com/glossary/overfitting).
+
+[Val Guide](../modes/val.md){ .md-button }
+
+## Export Settings
+
+Export settings for YOLO models encompass configurations and options related to saving or exporting the model for use in different environments or platforms. These settings can impact the model's performance, size, and compatibility with various systems. Key export settings include the exported model file format (e.g., ONNX, TensorFlow SavedModel), the target device (e.g., CPU, GPU), and additional features such as masks or multiple labels per box. The export process may also be affected by the model's specific task and the requirements or constraints of the destination environment or platform.
+
+{% include "macros/export-args.md" %}
+
+It is crucial to thoughtfully configure these settings to ensure the exported model is optimized for the intended use case and functions effectively in the target environment.
+
+[Export Guide](../modes/export.md){ .md-button }
+
+## Augmentation Settings
+
+Augmentation techniques are essential for improving the robustness and performance of YOLO models by introducing variability into the [training data](https://www.ultralytics.com/glossary/training-data), helping the model generalize better to unseen data. The following table outlines the purpose and effect of each augmentation argument:
+
+{% include "macros/augmentation-args.md" %}
+
+These settings can be adjusted to meet the specific requirements of the dataset and task at hand. Experimenting with different values can help find the optimal augmentation strategy that leads to the best model performance.
+
+## Logging, Checkpoints and Plotting Settings
+
+Logging, checkpoints, plotting, and file management are important considerations when training a YOLO model.
+
+- Logging: It is often helpful to log various metrics and statistics during training to track the model's progress and diagnose any issues that may arise. This can be done using a logging library such as TensorBoard or by writing log messages to a file.
+- Checkpoints: It is a good practice to save checkpoints of the model at regular intervals during training. This allows you to resume training from a previous point if the training process is interrupted or if you want to experiment with different training configurations.
+- Plotting: Visualizing the model's performance and training progress can be helpful for understanding how the model is behaving and identifying potential issues. This can be done using a plotting library such as matplotlib or by generating plots using a logging library such as TensorBoard.
+- File management: Managing the various files generated during the training process, such as model checkpoints, log files, and plots, can be challenging. It is important to have a clear and organized file structure to keep track of these files and make it easy to access and analyze them as needed.
+
+Effective logging, checkpointing, plotting, and file management can help you keep track of the model's progress and make it easier to debug and optimize the training process.
+
+| Argument   | Default  | Description                                                                                                                                                                                                                                                                                                                         |
+| ---------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `project`  | `'runs'` | Specifies the root directory for saving training runs. Each run will be saved in a separate subdirectory within this directory.                                                                                                                                                                                                     |
+| `name`     | `'exp'`  | Defines the name of the experiment. If not specified, YOLO automatically increments this name for each run, e.g., `exp`, `exp2`, etc., to avoid overwriting previous experiments.                                                                                                                                                   |
+| `exist_ok` | `False`  | Determines whether to overwrite an existing experiment directory if one with the same name already exists. Setting this to `True` allows overwriting, while `False` prevents it.                                                                                                                                                    |
+| `plots`    | `False`  | Controls the generation and saving of training and validation plots. Set to `True` to create plots such as loss curves, [precision](https://www.ultralytics.com/glossary/precision)-[recall](https://www.ultralytics.com/glossary/recall) curves, and sample predictions. Useful for visually tracking model performance over time. |
+| `save`     | `False`  | Enables the saving of training checkpoints and final model weights. Set to `True` to periodically save model states, allowing training to be resumed from these checkpoints or models to be deployed.                                                                                                                               |
+
+## FAQ
+
+### How do I improve the performance of my YOLO model during training?
+
+Improving YOLO model performance involves tuning hyperparameters like batch size, learning rate, momentum, and weight decay. Adjusting augmentation settings, selecting the right optimizer, and employing techniques like early stopping or [mixed precision](https://www.ultralytics.com/glossary/mixed-precision) can also help. For detailed guidance on training settings, refer to the [Train Guide](../modes/train.md).
+
+### What are the key hyperparameters to consider for YOLO model accuracy?
+
+Key hyperparameters affecting YOLO model accuracy include:
+
+- **Batch Size (`batch`)**: Larger batch sizes can stabilize training but may require more memory.
+- **Learning Rate (`lr0`)**: Controls the step size for weight updates; smaller rates offer fine adjustments but slow convergence.
+- **Momentum (`momentum`)**: Helps accelerate gradient vectors in the right directions, dampening oscillations.
+- **Image Size (`imgsz`)**: Larger image sizes can improve accuracy but increase computational load.
+
+Adjust these values based on your dataset and hardware capabilities. Explore more in the [Train Settings](#train-settings) section.
+
+### How do I set the learning rate for training a YOLO model?
+
+The learning rate (`lr0`) is crucial for optimization. A common starting point is `0.01` for SGD or `0.001` for Adam. It's essential to monitor training metrics and adjust if necessary. Use cosine learning rate schedulers (`cos_lr`) or warmup techniques (`warmup_epochs`, `warmup_momentum`) to dynamically modify the rate during training. Find more details in the [Train Guide](../modes/train.md).
+
+### What are the default inference settings for YOLO models?
+
+Default inference settings include:
+
+- **Confidence Threshold (`conf=0.25`)**: Minimum confidence for detections.
+- **IoU Threshold (`iou=0.7`)**: For Non-Maximum Suppression (NMS).
+- **Image Size (`imgsz=640`)**: Resizes input images prior to inference.
+- **Device (`device=None`)**: Selects CPU or GPU for inference.
+
+For a comprehensive overview, visit the [Predict Settings](#predict-settings) section and the [Predict Guide](../modes/predict.md).
+
+### Why should I use mixed precision training with YOLO models?
+
+Mixed precision training, enabled with `amp=True`, helps reduce memory usage and can speed up training by utilizing the advantages of both FP16 and FP32. This is beneficial for modern GPUs, which support mixed precision natively, allowing more models to fit in memory and enable faster computations without significant loss in accuracy. Learn more about this in the [Train Guide](../modes/train.md).

docs/en/usage/cli.md

+---
+comments: true
+description: Explore the YOLO11 command line interface (CLI) for easy execution of detection tasks without needing a Python environment.
+keywords: YOLO11 CLI, command line interface, YOLO11 commands, detection tasks, Ultralytics, model training, model prediction
+---
+
+# Command Line Interface Usage
+
+The YOLO 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.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/GsXGnb-A4Kc?start=19"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Mastering Ultralytics YOLO: CLI
+</p>
+
+!!! example
+
+    === "Syntax"
+
+        Ultralytics `yolo` commands use the following syntax:
+        ```bash
+        yolo TASK MODE ARGS
+
+        Where   TASK (optional) is one of [detect, segment, classify, pose, obb]
+                MODE (required) is one of [train, val, predict, export, track, benchmark]
+                ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
+        ```
+        See all ARGS in the full [Configuration Guide](cfg.md) or with `yolo cfg`
+
+    === "Train"
+
+        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=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=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=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
+        ```
+
+    === "Export"
+
+        Export a YOLO11n classification model to ONNX format at image size 224 by 128 (no TASK required)
+        ```bash
+        yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128
+        ```
+
+    === "Special"
+
+        Run special commands to see version, view settings, run checks and more:
+        ```bash
+        yolo help
+        yolo checks
+        yolo version
+        yolo settings
+        yolo copy-cfg
+        yolo cfg
+        ```
+
+Where:
+
+- `TASK` (optional) is one of `[detect, segment, classify, pose, obb]`. If it is not passed explicitly YOLO11 will try to guess the `TASK` from the model type.
+- `MODE` (required) is one of `[train, val, predict, export, track, benchmark]`
+- `ARGS` (optional) are any number of custom `arg=value` pairs like `imgsz=320` that override defaults. For a full list of available `ARGS` see the [Configuration](cfg.md) page and `defaults.yaml`
+
+!!! warning
+
+    Arguments must be passed as `arg=val` pairs, split by an equals `=` sign and delimited by spaces ` ` between pairs. Do not use `--` argument prefixes or commas `,` between arguments.
+
+    - `yolo predict model=yolo11n.pt imgsz=640 conf=0.25` &nbsp; ✅
+    - `yolo predict model yolo11n.pt imgsz 640 conf 0.25` &nbsp; ❌
+    - `yolo predict --model yolo11n.pt --imgsz 640 --conf 0.25` &nbsp; ❌
+
+## Train
+
+Train YOLO11n on the COCO8 dataset for 100 epochs at image size 640. For a full list of available arguments see the [Configuration](cfg.md) page.
+
+!!! example
+
+    === "Train"
+
+        Start training YOLO11n on COCO8 for 100 epochs at image-size 640.
+        ```bash
+        yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640
+        ```
+
+    === "Resume"
+
+        Resume an interrupted training.
+        ```bash
+        yolo detect train resume model=last.pt
+        ```
+
+## Val
+
+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.
+
+!!! example
+
+    === "Official"
+
+        Validate an official YOLO11n model.
+        ```bash
+        yolo detect val model=yolo11n.pt
+        ```
+
+    === "Custom"
+
+        Validate a custom-trained model.
+        ```bash
+        yolo detect val model=path/to/best.pt
+        ```
+
+## Predict
+
+Use a trained YOLO11n model to run predictions on images.
+
+!!! example
+
+    === "Official"
+
+        Predict with an official YOLO11n model.
+        ```bash
+        yolo detect predict model=yolo11n.pt source='https://ultralytics.com/images/bus.jpg'
+        ```
+
+    === "Custom"
+
+        Predict with a custom model.
+        ```bash
+        yolo detect predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg'
+        ```
+
+## Export
+
+Export a YOLO11n model to a different format like ONNX, CoreML, etc.
+
+!!! example
+
+    === "Official"
+
+        Export an official YOLO11n model to ONNX format.
+        ```bash
+        yolo export model=yolo11n.pt format=onnx
+        ```
+
+    === "Custom"
+
+        Export a custom-trained model to ONNX format.
+        ```bash
+        yolo export model=path/to/best.pt format=onnx
+        ```
+
+Available YOLO11 export formats are in the table below. You can export to any format using the `format` argument, i.e. `format='onnx'` or `format='engine'`.
+
+{% include "macros/export-table.md" %}
+
+See full `export` details in the [Export](../modes/export.md) page.
+
+## Overriding default arguments
+
+Default arguments can be overridden by simply passing them as arguments in the CLI in `arg=value` pairs.
+
+!!! tip
+
+    === "Train"
+
+        Train a detection model for `10 epochs` with `learning_rate` of `0.01`
+        ```bash
+        yolo detect 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 segment predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+        ```
+
+    === "Val"
+
+        Validate a pretrained detection model at batch-size 1 and image size 640:
+        ```bash
+        yolo detect val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
+        ```
+
+## Overriding default config file
+
+You can override the `default.yaml` config file entirely by passing a new file with the `cfg` arguments, i.e. `cfg=custom.yaml`.
+
+To do this first create a copy of `default.yaml` in your current working dir with the `yolo copy-cfg` command.
+
+This will create `default_copy.yaml`, which you can then pass as `cfg=default_copy.yaml` along with any additional args, like `imgsz=320` in this example:
+
+!!! example
+
+    === "CLI"
+
+        ```bash
+        yolo copy-cfg
+        yolo cfg=default_copy.yaml imgsz=320
+        ```
+
+## FAQ
+
+### How do I use the Ultralytics YOLO11 command line interface (CLI) for model training?
+
+To train a YOLO11 model using the CLI, you can execute a simple one-line command in the terminal. For example, to train a detection model for 10 epochs with a [learning rate](https://www.ultralytics.com/glossary/learning-rate) of 0.01, you would run:
+
+```bash
+yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
+```
+
+This command uses the `train` mode with specific arguments. Refer to the full list of available arguments in the [Configuration Guide](cfg.md).
+
+### What tasks can I perform with the Ultralytics YOLO11 CLI?
+
+The Ultralytics YOLO11 CLI supports a variety of tasks including detection, segmentation, classification, validation, prediction, export, and tracking. For instance:
+
+- **Train a Model**: Run `yolo train data=<data.yaml> model=<model.pt> epochs=<num>`.
+- **Run Predictions**: Use `yolo predict model=<model.pt> source=<data_source> imgsz=<image_size>`.
+- **Export a Model**: Execute `yolo export model=<model.pt> format=<export_format>`.
+
+Each task can be customized with various arguments. For detailed syntax and examples, see the respective sections like [Train](#train), [Predict](#predict), and [Export](#export).
+
+### How can I validate the accuracy of a trained YOLO11 model using the CLI?
+
+To validate a YOLO11 model's accuracy, use the `val` mode. For example, to validate a pretrained detection model with a [batch size](https://www.ultralytics.com/glossary/batch-size) of 1 and image size of 640, run:
+
+```bash
+yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
+```
+
+This command evaluates the model on the specified dataset and provides performance metrics. For more details, refer to the [Val](#val) section.
+
+### What formats can I export my YOLO11 models to using the CLI?
+
+YOLO11 models can be exported to various formats such as ONNX, CoreML, TensorRT, and more. For instance, to export a model to ONNX format, run:
+
+```bash
+yolo export model=yolo11n.pt format=onnx
+```
+
+For complete details, visit the [Export](../modes/export.md) page.
+
+### How do I customize YOLO11 CLI commands to override default arguments?
+
+To override default arguments in YOLO11 CLI commands, pass them as `arg=value` pairs. For example, to train a model with custom arguments, use:
+
+```bash
+yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
+```
+
+For a full list of available arguments and their descriptions, refer to the [Configuration Guide](cfg.md). Ensure arguments are formatted correctly, as shown in the [Overriding default arguments](#overriding-default-arguments) section.

docs/en/usage/engine.md

+---
+comments: true
+description: Learn to customize the YOLO11 Trainer for specific tasks. Step-by-step instructions with Python examples for maximum model performance.
+keywords: Ultralytics, YOLO11, Trainer Customization, Python, Machine Learning, AI, Model Training, DetectionTrainer, Custom Models
+---
+
+Both the Ultralytics YOLO command-line and Python interfaces are simply a high-level abstraction on the base engine executors. Let's take a look at the Trainer engine.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/GsXGnb-A4Kc?start=104"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Mastering Ultralytics YOLO: Advanced Customization
+</p>
+
+## BaseTrainer
+
+BaseTrainer contains the generic boilerplate training routine. It can be customized for any task based over overriding the required functions or operations as long the as correct formats are followed. For example, you can support your own custom model and dataloader by just overriding these functions:
+
+- `get_model(cfg, weights)` - The function that builds the model to be trained
+- `get_dataloader()` - The function that builds the dataloader More details and source code can be found in [`BaseTrainer` Reference](../reference/engine/trainer.md)
+
+## DetectionTrainer
+
+Here's how you can use the YOLO11 `DetectionTrainer` and customize it.
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+
+trainer = DetectionTrainer(overrides={...})
+trainer.train()
+trained_model = trainer.best  # get best model
+```
+
+### Customizing the DetectionTrainer
+
+Let's customize the trainer **to train a custom detection model** that is not supported directly. You can do this by simply overloading the existing the `get_model` functionality:
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+
+
+class CustomTrainer(DetectionTrainer):
+    def get_model(self, cfg, weights):
+        """Loads a custom detection model given configuration and weight files."""
+        ...
+
+
+trainer = CustomTrainer(overrides={...})
+trainer.train()
+```
+
+You now realize that you need to customize the trainer further to:
+
+- Customize the `loss function`.
+- Add `callback` that uploads model to your Google Drive after every 10 `epochs` Here's how you can do it:
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+from ultralytics.nn.tasks import DetectionModel
+
+
+class MyCustomModel(DetectionModel):
+    def init_criterion(self):
+        """Initializes the loss function and adds a callback for uploading the model to Google Drive every 10 epochs."""
+        ...
+
+
+class CustomTrainer(DetectionTrainer):
+    def get_model(self, cfg, weights):
+        """Returns a customized detection model instance configured with specified config and weights."""
+        return MyCustomModel(...)
+
+
+# callback to upload model weights
+def log_model(trainer):
+    """Logs the path of the last model weight used by the trainer."""
+    last_weight_path = trainer.last
+    print(last_weight_path)
+
+
+trainer = CustomTrainer(overrides={...})
+trainer.add_callback("on_train_epoch_end", log_model)  # Adds to existing callback
+trainer.train()
+```
+
+To know more about Callback triggering events and entry point, checkout our [Callbacks Guide](callbacks.md)
+
+## Other engine components
+
+There are other components that can be customized similarly like `Validators` and `Predictors`. See Reference section for more information on these.
+
+## FAQ
+
+### How do I customize the Ultralytics YOLO11 DetectionTrainer for specific tasks?
+
+To customize the Ultralytics YOLO11 `DetectionTrainer` for a specific task, you can override its methods to adapt to your custom model and dataloader. Start by inheriting from `DetectionTrainer` and then redefine methods like `get_model` to implement your custom functionalities. Here's an example:
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+
+
+class CustomTrainer(DetectionTrainer):
+    def get_model(self, cfg, weights):
+        """Loads a custom detection model given configuration and weight files."""
+        ...
+
+
+trainer = CustomTrainer(overrides={...})
+trainer.train()
+trained_model = trainer.best  # get best model
+```
+
+For further customization like changing the `loss function` or adding a `callback`, you can reference our [Callbacks Guide](../usage/callbacks.md).
+
+### What are the key components of the BaseTrainer in Ultralytics YOLO11?
+
+The `BaseTrainer` in Ultralytics YOLO11 serves as the foundation for training routines and can be customized for various tasks by overriding its generic methods. Key components include:
+
+- `get_model(cfg, weights)` to build the model to be trained.
+- `get_dataloader()` to build the dataloader.
+
+For more details on the customization and source code, see the [`BaseTrainer` Reference](../reference/engine/trainer.md).
+
+### How can I add a callback to the Ultralytics YOLO11 DetectionTrainer?
+
+You can add callbacks to monitor and modify the training process in Ultralytics YOLO11 `DetectionTrainer`. For instance, here's how you can add a callback to log model weights after every training [epoch](https://www.ultralytics.com/glossary/epoch):
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+
+
+# callback to upload model weights
+def log_model(trainer):
+    """Logs the path of the last model weight used by the trainer."""
+    last_weight_path = trainer.last
+    print(last_weight_path)
+
+
+trainer = DetectionTrainer(overrides={...})
+trainer.add_callback("on_train_epoch_end", log_model)  # Adds to existing callbacks
+trainer.train()
+```
+
+For further details on callback events and entry points, refer to our [Callbacks Guide](../usage/callbacks.md).
+
+### Why should I use Ultralytics YOLO11 for model training?
+
+Ultralytics YOLO11 offers a high-level abstraction on powerful engine executors, making it ideal for rapid development and customization. Key benefits include:
+
+- **Ease of Use**: Both command-line and Python interfaces simplify complex tasks.
+- **Performance**: Optimized for real-time [object detection](https://www.ultralytics.com/glossary/object-detection) and various vision AI applications.
+- **Customization**: Easily extendable for custom models, [loss functions](https://www.ultralytics.com/glossary/loss-function), and dataloaders.
+
+Learn more about YOLO11's capabilities by visiting [Ultralytics YOLO](https://www.ultralytics.com/yolo).
+
+### Can I use the Ultralytics YOLO11 DetectionTrainer for non-standard models?
+
+Yes, Ultralytics YOLO11 `DetectionTrainer` is highly flexible and can be customized for non-standard models. By inheriting from `DetectionTrainer`, you can overload different methods to support your specific model's needs. Here's a simple example:
+
+```python
+from ultralytics.models.yolo.detect import DetectionTrainer
+
+
+class CustomDetectionTrainer(DetectionTrainer):
+    def get_model(self, cfg, weights):
+        """Loads a custom detection model."""
+        ...
+
+
+trainer = CustomDetectionTrainer(overrides={...})
+trainer.train()
+```
+
+For more comprehensive instructions and examples, review the [DetectionTrainer](../reference/engine/trainer.md) documentation.

docs/en/usage/python.md

+---
+comments: true
+description: Learn to integrate YOLO11 in Python for object detection, segmentation, and classification. Load, train models, and make predictions easily with our comprehensive guide.
+keywords: YOLO11, Python, object detection, segmentation, classification, machine learning, AI, pretrained models, train models, make predictions
+---
+
+# Python Usage
+
+Welcome to the YOLO11 Python Usage documentation! This guide is designed to help you seamlessly integrate YOLO11 into your Python projects for [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and classification. Here, you'll learn how to load and use pretrained models, train new models, and perform predictions on images. The easy-to-use Python interface is a valuable resource for anyone looking to incorporate YOLO11 into their Python projects, allowing you to quickly implement advanced object detection capabilities. Let's get started!
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/GsXGnb-A4Kc?start=58"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Mastering Ultralytics YOLO11: Python
+</p>
+
+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.
+
+!!! example "Python"
+
+    ```python
+    from ultralytics import YOLO
+
+    # Create a new YOLO model from scratch
+    model = YOLO("yolo11n.yaml")
+
+    # Load a pretrained YOLO model (recommended for training)
+    model = YOLO("yolo11n.pt")
+
+    # Train the model using the 'coco8.yaml' dataset for 3 epochs
+    results = model.train(data="coco8.yaml", epochs=3)
+
+    # Evaluate the model's performance on the validation set
+    results = model.val()
+
+    # Perform object detection on an image using the model
+    results = model("https://ultralytics.com/images/bus.jpg")
+
+    # Export the model to ONNX format
+    success = model.export(format="onnx")
+    ```
+
+## [Train](../modes/train.md)
+
+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.
+
+!!! example "Train"
+
+    === "From pretrained (recommended)"
+
+        ```python
+        from ultralytics import YOLO
+
+        model = YOLO("yolo11n.pt")  # pass any model type
+        results = model.train(epochs=5)
+        ```
+
+    === "From scratch"
+
+        ```python
+        from ultralytics import YOLO
+
+        model = YOLO("yolo11n.yaml")
+        results = model.train(data="coco8.yaml", epochs=5)
+        ```
+
+    === "Resume"
+
+        ```python
+        model = YOLO("last.pt")
+        results = model.train(resume=True)
+        ```
+
+[Train Examples](../modes/train.md){ .md-button }
+
+## [Val](../modes/val.md)
+
+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](https://www.ultralytics.com/glossary/accuracy) and generalization performance. This mode can be used to tune the hyperparameters of the model to improve its performance.
+
+!!! example "Val"
+
+    === "Val after training"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a YOLO11 model
+        model = YOLO("yolo11n.yaml")
+
+        # Train the model
+        model.train(data="coco8.yaml", epochs=5)
+
+        # Validate on training data
+        model.val()
+        ```
+
+    === "Val on another dataset"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a YOLO11 model
+        model = YOLO("yolo11n.yaml")
+
+        # Train the model
+        model.train(data="coco8.yaml", epochs=5)
+
+        # Validate on separate data
+        model.val(data="path/to/separate/data.yaml")
+        ```
+
+[Val Examples](../modes/val.md){ .md-button }
+
+## [Predict](../modes/predict.md)
+
+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.
+
+!!! example "Predict"
+
+    === "From source"
+
+        ```python
+        import cv2
+        from PIL import Image
+
+        from ultralytics import YOLO
+
+        model = YOLO("model.pt")
+        # accepts all formats - image/dir/Path/URL/video/PIL/ndarray. 0 for webcam
+        results = model.predict(source="0")
+        results = model.predict(source="folder", show=True)  # Display preds. Accepts all YOLO predict arguments
+
+        # from PIL
+        im1 = Image.open("bus.jpg")
+        results = model.predict(source=im1, save=True)  # save plotted images
+
+        # from ndarray
+        im2 = cv2.imread("bus.jpg")
+        results = model.predict(source=im2, save=True, save_txt=True)  # save predictions as labels
+
+        # from list of PIL/ndarray
+        results = model.predict(source=[im1, im2])
+        ```
+
+    === "Results usage"
+
+        ```python
+        # results would be a list of Results object including all the predictions by default
+        # but be careful as it could occupy a lot memory when there're many images,
+        # especially the task is segmentation.
+        # 1. return as a list
+        results = model.predict(source="folder")
+
+        # results would be a generator which is more friendly to memory by setting stream=True
+        # 2. return as a generator
+        results = model.predict(source=0, stream=True)
+
+        for result in results:
+            # Detection
+            result.boxes.xyxy  # box with xyxy format, (N, 4)
+            result.boxes.xywh  # box with xywh format, (N, 4)
+            result.boxes.xyxyn  # box with xyxy format but normalized, (N, 4)
+            result.boxes.xywhn  # box with xywh format but normalized, (N, 4)
+            result.boxes.conf  # confidence score, (N, 1)
+            result.boxes.cls  # cls, (N, 1)
+
+            # Segmentation
+            result.masks.data  # masks, (N, H, W)
+            result.masks.xy  # x,y segments (pixels), List[segment] * N
+            result.masks.xyn  # x,y segments (normalized), List[segment] * N
+
+            # Classification
+            result.probs  # cls prob, (num_class, )
+
+        # Each result is composed of torch.Tensor by default,
+        # in which you can easily use following functionality:
+        result = result.cuda()
+        result = result.cpu()
+        result = result.to("cpu")
+        result = result.numpy()
+        ```
+
+[Predict Examples](../modes/predict.md){ .md-button }
+
+## [Export](../modes/export.md)
+
+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.
+
+!!! example "Export"
+
+    === "Export to ONNX"
+
+        Export an official YOLO11n model to ONNX with dynamic batch-size and image-size.
+        ```python
+        from ultralytics import YOLO
+
+        model = YOLO("yolo11n.pt")
+        model.export(format="onnx", dynamic=True)
+        ```
+
+    === "Export to TensorRT"
+
+        Export an official YOLO11n model to TensorRT on `device=0` for acceleration on CUDA devices.
+        ```python
+        from ultralytics import YOLO
+
+        model = YOLO("yolo11n.pt")
+        model.export(format="onnx", device=0)
+        ```
+
+[Export Examples](../modes/export.md){ .md-button }
+
+## [Track](../modes/track.md)
+
+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.
+
+!!! example "Track"
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO("yolo11n.pt")  # load an official detection model
+        model = YOLO("yolo11n-seg.pt")  # load an official segmentation model
+        model = YOLO("path/to/best.pt")  # load a custom model
+
+        # Track with the model
+        results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True)
+        results = model.track(source="https://youtu.be/LNwODJXcvt4", show=True, tracker="bytetrack.yaml")
+        ```
+
+[Track Examples](../modes/track.md){ .md-button }
+
+## [Benchmark](../modes/benchmark.md)
+
+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 and segmentation) or `accuracy_top5` metrics (for classification), and the inference time in milliseconds per image across various export 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.
+
+!!! example "Benchmark"
+
+    === "Python"
+
+        Benchmark an official YOLO11n model across all export formats.
+        ```python
+        from ultralytics.utils.benchmarks import benchmark
+
+        # Benchmark
+        benchmark(model="yolo11n.pt", data="coco8.yaml", imgsz=640, half=False, device=0)
+        ```
+
+[Benchmark Examples](../modes/benchmark.md){ .md-button }
+
+## Using Trainers
+
+`YOLO` model class is a high-level wrapper on the Trainer classes. Each YOLO task has its own trainer that inherits from `BaseTrainer`.
+
+!!! tip "Detection Trainer Example"
+
+    ```python
+    from ultralytics.models.yolo import DetectionPredictor, DetectionTrainer, DetectionValidator
+
+    # trainer
+    trainer = DetectionTrainer(overrides={})
+    trainer.train()
+    trained_model = trainer.best
+
+    # Validator
+    val = DetectionValidator(args=...)
+    val(model=trained_model)
+
+    # predictor
+    pred = DetectionPredictor(overrides={})
+    pred(source=SOURCE, model=trained_model)
+
+    # resume from last weight
+    overrides["resume"] = trainer.last
+    trainer = detect.DetectionTrainer(overrides=overrides)
+    ```
+
+You can easily customize Trainers to support custom tasks or explore R&D ideas. Learn more about Customizing `Trainers`, `Validators` and `Predictors` to suit your project needs in the Customization Section.
+
+[Customization tutorials](engine.md){ .md-button }
+
+## FAQ
+
+### How can I integrate YOLO11 into my Python project for object detection?
+
+Integrating Ultralytics YOLO11 into your Python projects is simple. You can load a pre-trained model or train a new model from scratch. Here's how to get started:
+
+```python
+from ultralytics import YOLO
+
+# Load a pretrained YOLO model
+model = YOLO("yolo11n.pt")
+
+# Perform object detection on an image
+results = model("https://ultralytics.com/images/bus.jpg")
+
+# Visualize the results
+for result in results:
+    result.show()
+```
+
+See more detailed examples in our [Predict Mode](../modes/predict.md) section.
+
+### What are the different modes available in YOLO11?
+
+Ultralytics YOLO11 provides various modes to cater to different [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) workflows. These include:
+
+- **[Train](../modes/train.md)**: Train a model using custom datasets.
+- **[Val](../modes/val.md)**: Validate model performance on a validation set.
+- **[Predict](../modes/predict.md)**: Make predictions on new images or video streams.
+- **[Export](../modes/export.md)**: Export models to various formats like ONNX, TensorRT.
+- **[Track](../modes/track.md)**: Real-time object tracking in video streams.
+- **[Benchmark](../modes/benchmark.md)**: Benchmark model performance across different configurations.
+
+Each mode is designed to provide comprehensive functionalities for different stages of model development and deployment.
+
+### How do I train a custom YOLO11 model using my dataset?
+
+To train a custom YOLO11 model, you need to specify your dataset and other hyperparameters. Here's a quick example:
+
+```python
+from ultralytics import YOLO
+
+# Load the YOLO model
+model = YOLO("yolo11n.yaml")
+
+# Train the model with custom dataset
+model.train(data="path/to/your/dataset.yaml", epochs=10)
+```
+
+For more details on training and hyperlinks to example usage, visit our [Train Mode](../modes/train.md) page.
+
+### How do I export YOLO11 models for deployment?
+
+Exporting YOLO11 models in a format suitable for deployment is straightforward with the `export` function. For example, you can export a model to ONNX format:
+
+```python
+from ultralytics import YOLO
+
+# Load the YOLO model
+model = YOLO("yolo11n.pt")
+
+# Export the model to ONNX format
+model.export(format="onnx")
+```
+
+For various export options, refer to the [Export Mode](../modes/export.md) documentation.
+
+### Can I validate my YOLO11 model on different datasets?
+
+Yes, validating YOLO11 models on different datasets is possible. After training, you can use the validation mode to evaluate the performance:
+
+```python
+from ultralytics import YOLO
+
+# Load a YOLO11 model
+model = YOLO("yolo11n.yaml")
+
+# Train the model
+model.train(data="coco8.yaml", epochs=5)
+
+# Validate the model on a different dataset
+model.val(data="path/to/separate/data.yaml")
+```
+
+Check the [Val Mode](../modes/val.md) page for detailed examples and usage.

docs/en/usage/simple-utilities.md

+---
+comments: true
+description: Explore essential utilities in the Ultralytics package to speed up and enhance your workflows. Learn about data processing, annotations, conversions, and more.
+keywords: Ultralytics, utilities, data processing, auto annotation, YOLO, dataset conversion, bounding boxes, image compression, machine learning tools
+---
+
+# Simple Utilities
+
+<p align="center">
+  <img src="https://github.com/ultralytics/docs/releases/download/0/code-with-perspective.avif" alt="code with perspective">
+</p>
+
+The `ultralytics` package comes with a myriad of utilities that can support, enhance, and speed up your workflows. There are many more available, but here are some that will be useful for most developers. They're also a great reference point to use when learning to program.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/1bPY2LRG590"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> Ultralytics Utilities | Auto Annotation, Explorer API and Dataset Conversion
+</p>
+
+## Data
+
+### Auto Labeling / Annotations
+
+Dataset annotation is a very resource intensive and time-consuming process. If you have a YOLO [object detection](https://www.ultralytics.com/glossary/object-detection) model trained on a reasonable amount of data, you can use it and [SAM](../models/sam.md) to auto-annotate additional data (segmentation format).
+
+```{ .py .annotate }
+from ultralytics.data.annotator import auto_annotate
+
+auto_annotate(  # (1)!
+    data="path/to/new/data",
+    det_model="yolo11n.pt",
+    sam_model="mobile_sam.pt",
+    device="cuda",
+    output_dir="path/to/save_labels",
+)
+```
+
+1. Nothing returns from this function
+
+- [See the reference section for `annotator.auto_annotate`](../reference/data/annotator.md#ultralytics.data.annotator.auto_annotate) for more insight on how the function operates.
+
+- Use in combination with the [function `segments2boxes`](#convert-segments-to-bounding-boxes) to generate object detection bounding boxes as well
+
+### Convert Segmentation Masks into YOLO Format
+
+![Segmentation Masks to YOLO Format](https://github.com/ultralytics/docs/releases/download/0/segmentation-masks-to-yolo-format.avif)
+
+Use to convert a dataset of segmentation mask images to the `YOLO` segmentation format.
+This function takes the directory containing the binary format mask images and converts them into YOLO segmentation format.
+
+The converted masks will be saved in the specified output directory.
+
+```python
+from ultralytics.data.converter import convert_segment_masks_to_yolo_seg
+
+# The classes here is the total classes in the dataset, for COCO dataset we have 80 classes
+convert_segment_masks_to_yolo_seg(masks_dir="path/to/masks_dir", output_dir="path/to/output_dir", classes=80)
+```
+
+### Convert COCO into YOLO Format
+
+Use to convert COCO JSON annotations into proper YOLO format. For object detection (bounding box) datasets, `use_segments` and `use_keypoints` should both be `False`
+
+```{ .py .annotate }
+from ultralytics.data.converter import convert_coco
+
+convert_coco(  # (1)!
+    "../datasets/coco/annotations/",
+    use_segments=False,
+    use_keypoints=False,
+    cls91to80=True,
+)
+```
+
+1. Nothing returns from this function
+
+For additional information about the `convert_coco` function, [visit the reference page](../reference/data/converter.md#ultralytics.data.converter.convert_coco)
+
+### Get [Bounding Box](https://www.ultralytics.com/glossary/bounding-box) Dimensions
+
+```{.py .annotate }
+from ultralytics.utils.plotting import Annotator
+from ultralytics import YOLO
+import cv2
+
+model = YOLO('yolo11n.pt')  # Load pretrain or fine-tune model
+
+# Process the image
+source = cv2.imread('path/to/image.jpg')
+results = model(source)
+
+# Extract results
+annotator = Annotator(source, example=model.names)
+
+for box in results[0].boxes.xyxy.cpu():
+    width, height, area = annotator.get_bbox_dimension(box)
+    print("Bounding Box Width {}, Height {}, Area {}".format(
+        width.item(), height.item(), area.item()))
+```
+
+### Convert Bounding Boxes to Segments
+
+With existing `x y w h` bounding box data, convert to segments using the `yolo_bbox2segment` function. The files for images and annotations need to be organized like this:
+
+```
+data
+|__ images
+    ├─ 001.jpg
+    ├─ 002.jpg
+    ├─ ..
+    └─ NNN.jpg
+|__ labels
+    ├─ 001.txt
+    ├─ 002.txt
+    ├─ ..
+    └─ NNN.txt
+```
+
+```{ .py .annotate }
+from ultralytics.data.converter import yolo_bbox2segment
+
+yolo_bbox2segment(  # (1)!
+    im_dir="path/to/images",
+    save_dir=None,  # saved to "labels-segment" in images directory
+    sam_model="sam_b.pt",
+)
+```
+
+1. Nothing returns from this function
+
+[Visit the `yolo_bbox2segment` reference page](../reference/data/converter.md#ultralytics.data.converter.yolo_bbox2segment) for more information regarding the function.
+
+### Convert Segments to Bounding Boxes
+
+If you have a dataset that uses the [segmentation dataset format](../datasets/segment/index.md) you can easily convert these into up-right (or horizontal) bounding boxes (`x y w h` format) with this function.
+
+```python
+import numpy as np
+
+from ultralytics.utils.ops import segments2boxes
+
+segments = np.array(
+    [
+        [805, 392, 797, 400, ..., 808, 714, 808, 392],
+        [115, 398, 113, 400, ..., 150, 400, 149, 298],
+        [267, 412, 265, 413, ..., 300, 413, 299, 412],
+    ]
+)
+
+segments2boxes([s.reshape(-1, 2) for s in segments])
+# >>> array([[ 741.66, 631.12, 133.31, 479.25],
+#           [ 146.81, 649.69, 185.62, 502.88],
+#           [ 281.81, 636.19, 118.12, 448.88]],
+#           dtype=float32) # xywh bounding boxes
+```
+
+To understand how this function works, visit the [reference page](../reference/utils/ops.md#ultralytics.utils.ops.segments2boxes)
+
+## Utilities
+
+### Image Compression
+
+Compresses a single image file to reduced size while preserving its aspect ratio and quality. If the input image is smaller than the maximum dimension, it will not be resized.
+
+```{ .py .annotate }
+from pathlib import Path
+
+from ultralytics.data.utils import compress_one_image
+
+for f in Path("path/to/dataset").rglob("*.jpg"):
+    compress_one_image(f)  # (1)!
+```
+
+1. Nothing returns from this function
+
+### Auto-split Dataset
+
+Automatically split a dataset into `train`/`val`/`test` splits and save the resulting splits into `autosplit_*.txt` files. This function will use random sampling, which is not included when using [`fraction` argument for training](../modes/train.md#train-settings).
+
+```{ .py .annotate }
+from ultralytics.data.utils import autosplit
+
+autosplit(  # (1)!
+    path="path/to/images",
+    weights=(0.9, 0.1, 0.0),  # (train, validation, test) fractional splits
+    annotated_only=False,  # split only images with annotation file when True
+)
+```
+
+1. Nothing returns from this function
+
+See the [Reference page](../reference/data/utils.md#ultralytics.data.utils.autosplit) for additional details on this function.
+
+### Segment-polygon to Binary Mask
+
+Convert a single polygon (as list) to a binary mask of the specified image size. Polygon in the form of `[N, 2]` with `N` as the number of `(x, y)` points defining the polygon contour.
+
+!!! warning
+
+    `N` <b><u>must always</b></u> be even.
+
+```python
+import numpy as np
+
+from ultralytics.data.utils import polygon2mask
+
+imgsz = (1080, 810)
+polygon = np.array([805, 392, 797, 400, ..., 808, 714, 808, 392])  # (238, 2)
+
+mask = polygon2mask(
+    imgsz,  # tuple
+    [polygon],  # input as list
+    color=255,  # 8-bit binary
+    downsample_ratio=1,
+)
+```
+
+## Bounding Boxes
+
+### Bounding Box (horizontal) Instances
+
+To manage bounding box data, the `Bboxes` class will help to convert between box coordinate formatting, scale box dimensions, calculate areas, include offsets, and more!
+
+```python
+import numpy as np
+
+from ultralytics.utils.instance import Bboxes
+
+boxes = Bboxes(
+    bboxes=np.array(
+        [
+            [22.878, 231.27, 804.98, 756.83],
+            [48.552, 398.56, 245.35, 902.71],
+            [669.47, 392.19, 809.72, 877.04],
+            [221.52, 405.8, 344.98, 857.54],
+            [0, 550.53, 63.01, 873.44],
+            [0.0584, 254.46, 32.561, 324.87],
+        ]
+    ),
+    format="xyxy",
+)
+
+boxes.areas()
+# >>> array([ 4.1104e+05,       99216,       68000,       55772,       20347,      2288.5])
+
+boxes.convert("xywh")
+print(boxes.bboxes)
+# >>> array(
+#     [[ 413.93, 494.05,  782.1, 525.56],
+#      [ 146.95, 650.63,  196.8, 504.15],
+#      [  739.6, 634.62, 140.25, 484.85],
+#      [ 283.25, 631.67, 123.46, 451.74],
+#      [ 31.505, 711.99,  63.01, 322.91],
+#      [  16.31, 289.67, 32.503,  70.41]]
+# )
+```
+
+See the [`Bboxes` reference section](../reference/utils/instance.md#ultralytics.utils.instance.Bboxes) for more attributes and methods available.
+
+!!! tip
+
+    Many of the following functions (and more) can be accessed using the [`Bboxes` class](#bounding-box-horizontal-instances) but if you prefer to work with the functions directly, see the next subsections on how to import these independently.
+
+### Scaling Boxes
+
+When scaling and image up or down, corresponding bounding box coordinates can be appropriately scaled to match using `ultralytics.utils.ops.scale_boxes`.
+
+```{ .py .annotate }
+import cv2 as cv
+import numpy as np
+
+from ultralytics.utils.ops import scale_boxes
+
+image = cv.imread("ultralytics/assets/bus.jpg")
+h, w, c = image.shape
+resized = cv.resize(image, None, (), fx=1.2, fy=1.2)
+new_h, new_w, _ = resized.shape
+
+xyxy_boxes = np.array(
+    [
+        [22.878, 231.27, 804.98, 756.83],
+        [48.552, 398.56, 245.35, 902.71],
+        [669.47, 392.19, 809.72, 877.04],
+        [221.52, 405.8, 344.98, 857.54],
+        [0, 550.53, 63.01, 873.44],
+        [0.0584, 254.46, 32.561, 324.87],
+    ]
+)
+
+new_boxes = scale_boxes(
+    img1_shape=(h, w),  # original image dimensions
+    boxes=xyxy_boxes,  # boxes from original image
+    img0_shape=(new_h, new_w),  # resized image dimensions (scale to)
+    ratio_pad=None,
+    padding=False,
+    xywh=False,
+)
+
+print(new_boxes)  # (1)!
+# >>> array(
+#     [[  27.454,  277.52,  965.98,   908.2],
+#     [   58.262,  478.27,  294.42,  1083.3],
+#     [   803.36,  470.63,  971.66,  1052.4],
+#     [   265.82,  486.96,  413.98,    1029],
+#     [        0,  660.64,  75.612,  1048.1],
+#     [   0.0701,  305.35,  39.073,  389.84]]
+# )
+```
+
+1. Bounding boxes scaled for the new image size
+
+### Bounding Box Format Conversions
+
+#### XYXY → XYWH
+
+Convert bounding box coordinates from (x1, y1, x2, y2) format to (x, y, width, height) format where (x1, y1) is the top-left corner and (x2, y2) is the bottom-right corner.
+
+```python
+import numpy as np
+
+from ultralytics.utils.ops import xyxy2xywh
+
+xyxy_boxes = np.array(
+    [
+        [22.878, 231.27, 804.98, 756.83],
+        [48.552, 398.56, 245.35, 902.71],
+        [669.47, 392.19, 809.72, 877.04],
+        [221.52, 405.8, 344.98, 857.54],
+        [0, 550.53, 63.01, 873.44],
+        [0.0584, 254.46, 32.561, 324.87],
+    ]
+)
+xywh = xyxy2xywh(xyxy_boxes)
+
+print(xywh)
+# >>> array(
+#     [[ 413.93,  494.05,   782.1, 525.56],
+#     [  146.95,  650.63,   196.8, 504.15],
+#     [   739.6,  634.62,  140.25, 484.85],
+#     [  283.25,  631.67,  123.46, 451.74],
+#     [  31.505,  711.99,   63.01, 322.91],
+#     [   16.31,  289.67,  32.503,  70.41]]
+# )
+```
+
+### All Bounding Box Conversions
+
+```python
+from ultralytics.utils.ops import (
+    ltwh2xywh,
+    ltwh2xyxy,
+    xywh2ltwh,  # xywh → top-left corner, w, h
+    xywh2xyxy,
+    xywhn2xyxy,  # normalized → pixel
+    xyxy2ltwh,  # xyxy → top-left corner, w, h
+    xyxy2xywhn,  # pixel → normalized
+)
+
+for func in (ltwh2xywh, ltwh2xyxy, xywh2ltwh, xywh2xyxy, xywhn2xyxy, xyxy2ltwh, xyxy2xywhn):
+    print(help(func))  # print function docstrings
+```
+
+See docstring for each function or visit the `ultralytics.utils.ops` [reference page](../reference/utils/ops.md) to read more about each function.
+
+## Plotting
+
+### Drawing Annotations
+
+Ultralytics includes an Annotator class that can be used to annotate any kind of data. It's easiest to use with [object detection bounding boxes](../modes/predict.md#boxes), [pose key points](../modes/predict.md#keypoints), and [oriented bounding boxes](../modes/predict.md#obb).
+
+#### Ultralytics Sweep Annotation
+
+!!! example "Python Examples using YOLO11 🚀"
+
+    === "Python"
+
+    ```python
+    import cv2
+
+    from ultralytics import YOLO
+    from ultralytics.utils.plotting import Annotator, colors
+
+    # User defined video path and model file
+    cap = cv2.VideoCapture("Path/to/video/file.mp4")
+    model = YOLO(model="yolo11s-seg.pt")  # Model file i.e. yolo11s.pt or yolo11m-seg.pt
+
+    if not cap.isOpened():
+        print("Error: Could not open video.")
+        exit()
+
+    # Initialize the video writer object.
+    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
+    video_writer = cv2.VideoWriter("ultralytics.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
+
+    masks = None  # Initialize variable to store masks data
+    f = 0  # Initialize frame count variable for enabling mouse event.
+    line_x = w  # Store width of line.
+    dragging = False  # Initialize bool variable for line dragging.
+    classes = model.names  # Store model classes names for plotting.
+    window_name = "Ultralytics Sweep Annotator"
+
+
+    def drag_line(event, x, y, flags, param):  # Mouse callback for dragging line.
+        global line_x, dragging
+        if event == cv2.EVENT_LBUTTONDOWN or (flags & cv2.EVENT_FLAG_LBUTTON):
+            line_x = max(0, min(x, w))
+            dragging = True
+
+
+    while cap.isOpened():  # Loop over the video capture object.
+        ret, im0 = cap.read()
+        if not ret:
+            break
+        f = f + 1  # Increment frame count.
+        count = 0  # Re-initialize count variable on every frame for precise counts.
+        annotator = Annotator(im0)
+        results = model.track(im0, persist=True)  # Track objects using track method.
+        if f == 1:
+            cv2.namedWindow(window_name)
+            cv2.setMouseCallback(window_name, drag_line)
+
+        if results[0].boxes.id is not None:
+            if results[0].masks is not None:
+                masks = results[0].masks.xy
+            track_ids = results[0].boxes.id.int().cpu().tolist()
+            clss = results[0].boxes.cls.cpu().tolist()
+            boxes = results[0].boxes.xyxy.cpu()
+
+            for mask, box, cls, t_id in zip(masks or [None] * len(boxes), boxes, clss, track_ids):
+                color = colors(t_id, True)  # Assign different color to each tracked object.
+                if mask is not None and mask.size > 0:
+                    # If you want to overlay the masks
+                    # mask[:, 0] = np.clip(mask[:, 0], line_x, w)
+                    # mask_img = cv2.fillPoly(im0.copy(), [mask.astype(int)], color)
+                    # cv2.addWeighted(mask_img, 0.5, im0, 0.5, 0, im0)
+
+                    if box[0] > line_x:
+                        count += 1
+                        annotator.seg_bbox(mask=mask, mask_color=color, label=str(classes[cls]))
+                else:
+                    if box[0] > line_x:
+                        count += 1
+                        annotator.box_label(box=box, color=color, label=str(classes[cls]))
+
+        annotator.sweep_annotator(line_x=line_x, line_y=h, label=f"COUNT:{count}")  # Display the sweep
+        cv2.imshow(window_name, im0)
+        video_writer.write(im0)
+        if cv2.waitKey(1) & 0xFF == ord("q"):
+            break
+
+    cap.release()  # Release the video capture.
+    video_writer.release()  # Release the video writer.
+    cv2.destroyAllWindows()  # Destroy all opened windows.
+    ```
+
+#### Horizontal Bounding Boxes
+
+```{ .py .annotate }
+import cv2 as cv
+import numpy as np
+
+from ultralytics.utils.plotting import Annotator, colors
+
+names = {  # (1)!
+    0: "person",
+    5: "bus",
+    11: "stop sign",
+}
+
+image = cv.imread("ultralytics/assets/bus.jpg")
+ann = Annotator(
+    image,
+    line_width=None,  # default auto-size
+    font_size=None,  # default auto-size
+    font="Arial.ttf",  # must be ImageFont compatible
+    pil=False,  # use PIL, otherwise uses OpenCV
+)
+
+xyxy_boxes = np.array(
+    [
+        [5, 22.878, 231.27, 804.98, 756.83],  # class-idx x1 y1 x2 y2
+        [0, 48.552, 398.56, 245.35, 902.71],
+        [0, 669.47, 392.19, 809.72, 877.04],
+        [0, 221.52, 405.8, 344.98, 857.54],
+        [0, 0, 550.53, 63.01, 873.44],
+        [11, 0.0584, 254.46, 32.561, 324.87],
+    ]
+)
+
+for nb, box in enumerate(xyxy_boxes):
+    c_idx, *box = box
+    label = f"{str(nb).zfill(2)}:{names.get(int(c_idx))}"
+    ann.box_label(box, label, color=colors(c_idx, bgr=True))
+
+image_with_bboxes = ann.result()
+```
+
+1. Names can be used from `model.names` when [working with detection results](../modes/predict.md#working-with-results)
+
+#### Oriented Bounding Boxes (OBB)
+
+```python
+import cv2 as cv
+import numpy as np
+
+from ultralytics.utils.plotting import Annotator, colors
+
+obb_names = {10: "small vehicle"}
+obb_image = cv.imread("datasets/dota8/images/train/P1142__1024__0___824.jpg")
+obb_boxes = np.array(
+    [
+        [0, 635, 560, 919, 719, 1087, 420, 803, 261],  # class-idx x1 y1 x2 y2 x3 y2 x4 y4
+        [0, 331, 19, 493, 260, 776, 70, 613, -171],
+        [9, 869, 161, 886, 147, 851, 101, 833, 115],
+    ]
+)
+ann = Annotator(
+    obb_image,
+    line_width=None,  # default auto-size
+    font_size=None,  # default auto-size
+    font="Arial.ttf",  # must be ImageFont compatible
+    pil=False,  # use PIL, otherwise uses OpenCV
+)
+for obb in obb_boxes:
+    c_idx, *obb = obb
+    obb = np.array(obb).reshape(-1, 4, 2).squeeze()
+    label = f"{obb_names.get(int(c_idx))}"
+    ann.box_label(
+        obb,
+        label,
+        color=colors(c_idx, True),
+        rotated=True,
+    )
+
+image_with_obb = ann.result()
+```
+
+#### Bounding Boxes Circle Annotation [Circle Label](https://docs.ultralytics.com/reference/utils/plotting/#ultralytics.utils.plotting.Annotator.circle_label)
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/c-S5M36XWmg"
+    title="YouTube video player" frameborder="0"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+  <br>
+  <strong>Watch:</strong> In-Depth Guide to Text & Circle Annotations with Python Live Demos | Ultralytics Annotations 🚀
+</p>
+
+```python
+import cv2
+
+from ultralytics import YOLO
+from ultralytics.utils.plotting import Annotator
+
+model = YOLO("yolo11s.pt")
+names = 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))
+writer = cv2.VideoWriter("Ultralytics circle annotation.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))
+
+while True:
+    ret, im0 = cap.read()
+    if not ret:
+        break
+
+    annotator = Annotator(im0)
+    results = model.predict(im0)
+    boxes = results[0].boxes.xyxy.cpu()
+    clss = results[0].boxes.cls.cpu().tolist()
+
+    for box, cls in zip(boxes, clss):
+        annotator.circle_label(box, label=names[int(cls)])
+
+    writer.write(im0)
+    cv2.imshow("Ultralytics circle annotation", im0)
+
+    if cv2.waitKey(1) & 0xFF == ord("q"):
+        break
+
+writer.release()
+cap.release()
+cv2.destroyAllWindows()
+```
+
+#### Bounding Boxes Text Annotation [Text Label](https://docs.ultralytics.com/reference/utils/plotting/#ultralytics.utils.plotting.Annotator.text_label)
+
+```python
+import cv2
+
+from ultralytics import YOLO
+from ultralytics.utils.plotting import Annotator
+
+model = YOLO("yolo11s.pt")
+names = 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))
+writer = cv2.VideoWriter("Ultralytics text annotation.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))
+
+while True:
+    ret, im0 = cap.read()
+    if not ret:
+        break
+
+    annotator = Annotator(im0)
+    results = model.predict(im0)
+    boxes = results[0].boxes.xyxy.cpu()
+    clss = results[0].boxes.cls.cpu().tolist()
+
+    for box, cls in zip(boxes, clss):
+        annotator.text_label(box, label=names[int(cls)])
+
+    writer.write(im0)
+    cv2.imshow("Ultralytics text annotation", im0)
+
+    if cv2.waitKey(1) & 0xFF == ord("q"):
+        break
+
+writer.release()
+cap.release()
+cv2.destroyAllWindows()
+```
+
+See the [`Annotator` Reference Page](../reference/utils/plotting.md#ultralytics.utils.plotting.Annotator) for additional insight.
+
+## Miscellaneous
+
+### Code Profiling
+
+Check duration for code to run/process either using `with` or as a decorator.
+
+```python
+from ultralytics.utils.ops import Profile
+
+with Profile(device="cuda:0") as dt:
+    pass  # operation to measure
+
+print(dt)
+# >>> "Elapsed time is 9.5367431640625e-07 s"
+```
+
+### Ultralytics Supported Formats
+
+Want or need to use the formats of [images or videos types supported](../modes/predict.md#image-and-video-formats) by Ultralytics programmatically? Use these constants if you need.
+
+```python
+from ultralytics.data.utils import IMG_FORMATS, VID_FORMATS
+
+print(IMG_FORMATS)
+# {'tiff', 'pfm', 'bmp', 'mpo', 'dng', 'jpeg', 'png', 'webp', 'tif', 'jpg'}
+
+print(VID_FORMATS)
+# {'avi', 'mpg', 'wmv', 'mpeg', 'm4v', 'mov', 'mp4', 'asf', 'mkv', 'ts', 'gif', 'webm'}
+```
+
+### Make Divisible
+
+Calculates the nearest whole number to `x` to make evenly divisible when divided by `y`.
+
+```python
+from ultralytics.utils.ops import make_divisible
+
+make_divisible(7, 3)
+# >>> 9
+make_divisible(7, 2)
+# >>> 8
+```
+
+## FAQ
+
+### What utilities are included in the Ultralytics package to enhance [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) workflows?
+
+The Ultralytics package includes a variety of utilities designed to streamline and optimize machine learning workflows. Key utilities include [auto-annotation](../reference/data/annotator.md#ultralytics.data.annotator.auto_annotate) for labeling datasets, converting COCO to YOLO format with [convert_coco](../reference/data/converter.md#ultralytics.data.converter.convert_coco), compressing images, and dataset auto-splitting. These tools aim to reduce manual effort, ensure consistency, and enhance data processing efficiency.
+
+### How can I use Ultralytics to auto-label my dataset?
+
+If you have a pre-trained Ultralytics YOLO object detection model, you can use it with the [SAM](../models/sam.md) model to auto-annotate your dataset in segmentation format. Here's an example:
+
+```python
+from ultralytics.data.annotator import auto_annotate
+
+auto_annotate(
+    data="path/to/new/data",
+    det_model="yolo11n.pt",
+    sam_model="mobile_sam.pt",
+    device="cuda",
+    output_dir="path/to/save_labels",
+)
+```
+
+For more details, check the [auto_annotate reference section](../reference/data/annotator.md#ultralytics.data.annotator.auto_annotate).
+
+### How do I convert COCO dataset annotations to YOLO format in Ultralytics?
+
+To convert COCO JSON annotations into YOLO format for object detection, you can use the `convert_coco` utility. Here's a sample code snippet:
+
+```python
+from ultralytics.data.converter import convert_coco
+
+convert_coco(
+    "../datasets/coco/annotations/",
+    use_segments=False,
+    use_keypoints=False,
+    cls91to80=True,
+)
+```
+
+For additional information, visit the [convert_coco reference page](../reference/data/converter.md#ultralytics.data.converter.convert_coco).
+
+### What is the purpose of the YOLO Data Explorer in the Ultralytics package?
+
+The [YOLO Explorer](../datasets/explorer/index.md) is a powerful tool introduced in the `8.1.0` update to enhance dataset understanding. It allows you to use text queries to find object instances in your dataset, making it easier to analyze and manage your data. This tool provides valuable insights into dataset composition and distribution, helping to improve model training and performance.
+
+### How can I convert bounding boxes to segments in Ultralytics?
+
+To convert existing bounding box data (in `x y w h` format) to segments, you can use the `yolo_bbox2segment` function. Ensure your files are organized with separate directories for images and labels.
+
+```python
+from ultralytics.data.converter import yolo_bbox2segment
+
+yolo_bbox2segment(
+    im_dir="path/to/images",
+    save_dir=None,  # saved to "labels-segment" in the images directory
+    sam_model="sam_b.pt",
+)
+```
+
+For more information, visit the [yolo_bbox2segment reference page](../reference/data/converter.md#ultralytics.data.converter.yolo_bbox2segment).

docs/en/yolov5/environments/aws_quickstart_tutorial.md

+---
+comments: true
+description: Discover how to set up and run YOLOv5 on AWS Deep Learning Instances. Follow our comprehensive guide to get started quickly and cost-effectively.
+keywords: YOLOv5, AWS, Deep Learning, Machine Learning, AWS EC2, YOLOv5 setup, Deep Learning Instances, AI, Object Detection
+---
+
+# YOLOv5 🚀 on AWS Deep Learning Instance: Your Complete Guide
+
+Setting up a high-performance deep learning environment can be daunting for newcomers, but fear not! 🛠️ With this guide, we'll walk you through the process of getting YOLOv5 up and running on an AWS Deep Learning instance. By leveraging the power of Amazon Web Services (AWS), even those new to [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) can get started quickly and cost-effectively. The AWS platform's scalability is perfect for both experimentation and production deployment.
+
+Other quickstart options for YOLOv5 include our [Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) <a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/models/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>, [GCP Deep Learning VM](./google_cloud_quickstart_tutorial.md), and our Docker image at [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) <a href="https://hub.docker.com/r/ultralytics/yolov5"><img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"></a>.
+
+## Step 1: AWS Console Sign-In
+
+Start by creating an account or signing in to the AWS console at [https://aws.amazon.com/console/](https://aws.amazon.com/console/). Once logged in, select the **EC2** service to manage and set up your instances.
+
+![Console](https://github.com/ultralytics/docs/releases/download/0/aws-console-sign-in.avif)
+
+## Step 2: Launch Your Instance
+
+In the EC2 dashboard, you'll find the **Launch Instance** button which is your gateway to creating a new virtual server.
+
+![Launch](https://github.com/ultralytics/docs/releases/download/0/launch-instance-button.avif)
+
+### Selecting the Right Amazon Machine Image (AMI)
+
+Here's where you choose the operating system and software stack for your instance. Type '[Deep Learning](https://www.ultralytics.com/glossary/deep-learning-dl)' into the search field and select the latest Ubuntu-based Deep Learning AMI, unless your needs dictate otherwise. Amazon's Deep Learning AMIs come pre-installed with popular frameworks and GPU drivers to streamline your setup process.
+
+![Choose AMI](https://github.com/ultralytics/docs/releases/download/0/choose-ami.avif)
+
+### Picking an Instance Type
+
+For deep learning tasks, selecting a GPU instance type is generally recommended as it can vastly accelerate model training. For instance size considerations, remember that the model's memory requirements should never exceed what your instance can provide.
+
+**Note:** The size of your model should be a factor in selecting an instance. If your model exceeds an instance's available RAM, select a different instance type with enough memory for your application.
+
+For a list of available GPU instance types, visit [EC2 Instance Types](https://aws.amazon.com/ec2/instance-types/), specifically under Accelerated Computing.
+
+![Choose Type](https://github.com/ultralytics/docs/releases/download/0/choose-instance-type.avif)
+
+For more information on GPU monitoring and optimization, see [GPU Monitoring and Optimization](https://docs.aws.amazon.com/dlami/latest/devguide/tutorial-gpu.html). For pricing, see [On-Demand Pricing](https://aws.amazon.com/ec2/pricing/on-demand/) and [Spot Pricing](https://aws.amazon.com/ec2/spot/pricing/).
+
+### Configuring Your Instance
+
+Amazon EC2 Spot Instances offer a cost-effective way to run applications as they allow you to bid for unused capacity at a fraction of the standard cost. For a persistent experience that retains data even when the Spot Instance goes down, opt for a persistent request.
+
+![Spot Request](https://github.com/ultralytics/docs/releases/download/0/spot-request.avif)
+
+Remember to adjust the rest of your instance settings and security configurations as needed in Steps 4-7 before launching.
+
+## Step 3: Connect to Your Instance
+
+Once your instance is running, select its checkbox and click Connect to access the SSH information. Use the displayed SSH command in your preferred terminal to establish a connection to your instance.
+
+![Connect](https://github.com/ultralytics/docs/releases/download/0/connect-to-instance.avif)
+
+## Step 4: Running YOLOv5
+
+Logged into your instance, you're now ready to clone the YOLOv5 repository and install dependencies within a Python 3.8 or later environment. YOLOv5's models and datasets will automatically download from the latest [release](https://github.com/ultralytics/yolov5/releases).
+
+```bash
+git clone https://github.com/ultralytics/yolov5  # clone repository
+cd yolov5
+pip install -r requirements.txt  # install dependencies
+```
+
+With your environment set up, you can begin training, validating, performing inference, and exporting your YOLOv5 models:
+
+```bash
+# Train a model on your data
+python train.py
+
+# Validate the trained model for Precision, Recall, and mAP
+python val.py --weights yolov5s.pt
+
+# Run inference using the trained model on your images or videos
+python detect.py --weights yolov5s.pt --source path/to/images
+
+# Export the trained model to other formats for deployment
+python export.py --weights yolov5s.pt --include onnx coreml tflite
+```
+
+## Optional Extras
+
+To add more swap memory, which can be a savior for large datasets, run:
+
+```bash
+sudo fallocate -l 64G /swapfile  # allocate 64GB swap file
+sudo chmod 600 /swapfile  # modify permissions
+sudo mkswap /swapfile  # set up a Linux swap area
+sudo swapon /swapfile  # activate swap file
+free -h  # verify swap memory
+```
+
+And that's it! 🎉 You've successfully created an AWS Deep Learning instance and run YOLOv5. Whether you're just starting with [object detection](https://www.ultralytics.com/glossary/object-detection) or scaling up for production, this setup can help you achieve your machine learning goals. Happy training, validating, and deploying! If you encounter any hiccups along the way, the robust AWS documentation and the active Ultralytics community are here to support you.

docs/en/yolov5/environments/azureml_quickstart_tutorial.md

+---
+comments: true
+description: Learn how to set up and run YOLOv5 on AzureML. Follow this quickstart guide for easy configuration and model training on an AzureML compute instance.
+keywords: YOLOv5, AzureML, machine learning, compute instance, quickstart, model training, virtual environment, Python, AI, deep learning
+---
+
+# YOLOv5 🚀 on AzureML
+
+This guide provides a quickstart to use YOLOv5 from an AzureML compute instance.
+
+Note that this guide is a quickstart for quick trials. If you want to unlock the full power AzureML, you can find the documentation to:
+
+- [Create a data asset](https://learn.microsoft.com/azure/machine-learning/how-to-create-data-assets)
+- [Create an AzureML job](https://learn.microsoft.com/azure/machine-learning/how-to-train-model)
+- [Register a model](https://learn.microsoft.com/azure/machine-learning/how-to-manage-models)
+
+## Prerequisites
+
+You need an [AzureML workspace](https://learn.microsoft.com/azure/machine-learning/concept-workspace?view=azureml-api-2).
+
+## Create a compute instance
+
+From your AzureML workspace, select Compute > Compute instances > New, select the instance with the resources you need.
+
+<img width="1741" alt="create-compute-arrow" src="https://github.com/ultralytics/docs/releases/download/0/create-compute-arrow.avif">
+
+## Open a Terminal
+
+Now from the Notebooks view, open a Terminal and select your compute.
+
+![open-terminal-arrow](https://github.com/ultralytics/docs/releases/download/0/open-terminal-arrow.avif)
+
+## Setup and run YOLOv5
+
+Now you can, create a virtual environment:
+
+```bash
+conda create --name yolov5env -y
+conda activate yolov5env
+conda install pip -y
+```
+
+Clone YOLOv5 repository with its submodules:
+
+```bash
+git clone https://github.com/ultralytics/yolov5
+cd yolov5
+git submodule update --init --recursive # Note that you might have a message asking you to add your folder as a safe.directory just copy the recommended command
+```
+
+Install the required dependencies:
+
+```bash
+pip install -r yolov5/requirements.txt
+pip install onnx>=1.10.0
+```
+
+Train the YOLOv5 model:
+
+```bash
+python train.py
+```
+
+Validate the model for [Precision](https://www.ultralytics.com/glossary/precision), [Recall](https://www.ultralytics.com/glossary/recall), and mAP
+
+```bash
+python val.py --weights yolov5s.pt
+```
+
+Run inference on images and videos:
+
+```bash
+python detect.py --weights yolov5s.pt --source path/to/images
+```
+
+Export models to other formats:
+
+```bash
+python detect.py --weights yolov5s.pt --source path/to/images
+```
+
+## Notes on using a notebook
+
+Note that if you want to run these commands from a Notebook, you need to [create a new Kernel](https://learn.microsoft.com/en-us/azure/machine-learning/how-to-access-terminal?view=azureml-api-2#add-new-kernels) and select your new Kernel on the top of your Notebook.
+
+If you create Python cells it will automatically use your custom environment, but if you add bash cells, you will need to run `source activate <your-env>` on each of these cells to make sure it uses your custom environment.
+
+For example:
+
+```bash
+%%bash
+source activate newenv
+python val.py --weights yolov5s.pt
+```

docs/en/yolov5/environments/docker_image_quickstart_tutorial.md

+---
+comments: true
+description: Learn how to set up and run YOLOv5 in a Docker container with step-by-step instructions. Explore other quickstart options for an easy setup.
+keywords: YOLOv5, Docker, Ultralytics, setup, guide, tutorial, machine learning, deep learning, AI, GPU, NVIDIA, container
+---
+
+# Get Started with YOLOv5 🚀 in Docker
+
+This tutorial will guide you through the process of setting up and running YOLOv5 in a Docker container.
+
+You can also explore other quickstart options for YOLOv5, such as our [Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) <a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/models/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>, [GCP Deep Learning VM](./google_cloud_quickstart_tutorial.md), and [Amazon AWS](./aws_quickstart_tutorial.md).
+
+## Prerequisites
+
+1. **NVIDIA Driver**: Version 455.23 or higher. Download from [NVIDIA's website](https://www.nvidia.com/Download/index.aspx).
+2. **NVIDIA-Docker**: Allows Docker to interact with your local GPU. Installation instructions are available on the [NVIDIA-Docker GitHub repository](https://github.com/NVIDIA/nvidia-docker).
+3. **Docker Engine - CE**: Version 19.03 or higher. Download and installation instructions can be found on the [Docker website](https://docs.docker.com/get-started/get-docker/).
+
+## Step 1: Pull the YOLOv5 Docker Image
+
+The Ultralytics YOLOv5 DockerHub repository is available at [https://hub.docker.com/r/ultralytics/yolov5](https://hub.docker.com/r/ultralytics/yolov5). Docker Autobuild ensures that the `ultralytics/yolov5:latest` image is always in sync with the most recent repository commit. To pull the latest image, run the following command:
+
+```bash
+sudo docker pull ultralytics/yolov5:latest
+```
+
+## Step 2: Run the Docker Container
+
+### Basic container:
+
+Run an interactive instance of the YOLOv5 Docker image (called a "container") using the `-it` flag:
+
+```bash
+sudo docker run --ipc=host -it ultralytics/yolov5:latest
+```
+
+### Container with local file access:
+
+To run a container with access to local files (e.g., COCO [training data](https://www.ultralytics.com/glossary/training-data) in `/datasets`), use the `-v` flag:
+
+```bash
+sudo docker run --ipc=host -it -v "$(pwd)"/datasets:/usr/src/datasets ultralytics/yolov5:latest
+```
+
+### Container with GPU access:
+
+To run a container with GPU access, use the `--gpus all` flag:
+
+```bash
+sudo docker run --ipc=host -it --gpus all ultralytics/yolov5:latest
+```
+
+## Step 3: Use YOLOv5 🚀 within the Docker Container
+
+Now you can train, test, detect, and export YOLOv5 models within the running Docker container:
+
+```bash
+# Train a model on your data
+python train.py
+
+# Validate the trained model for Precision, Recall, and mAP
+python val.py --weights yolov5s.pt
+
+# Run inference using the trained model on your images or videos
+python detect.py --weights yolov5s.pt --source path/to/images
+
+# Export the trained model to other formats for deployment
+python export.py --weights yolov5s.pt --include onnx coreml tflite
+```
+
+<p align="center"><img width="1000" src="https://github.com/ultralytics/docs/releases/download/0/gcp-running-docker.avif" alt="GCP running Docker"></p>

docs/en/yolov5/environments/google_cloud_quickstart_tutorial.md

+---
+comments: true
+description: Master YOLOv5 deployment on Google Cloud Platform Deep Learning VM. Perfect for AI beginners and experts to achieve high-performance object detection.
+keywords: YOLOv5, Google Cloud Platform, GCP, Deep Learning VM, object detection, AI, machine learning, tutorial
+---
+
+# Mastering YOLOv5 🚀 Deployment on Google Cloud Platform (GCP) Deep Learning Virtual Machine (VM) ⭐
+
+Embarking on the journey of [artificial intelligence](https://www.ultralytics.com/glossary/artificial-intelligence-ai) and machine learning can be exhilarating, especially when you leverage the power and flexibility of a cloud platform. Google Cloud Platform (GCP) offers robust tools tailored for machine learning enthusiasts and professionals alike. One such tool is the Deep Learning VM that is preconfigured for data science and ML tasks. In this tutorial, we will navigate through the process of setting up YOLOv5 on a GCP Deep Learning VM. Whether you're taking your first steps in ML or you're a seasoned practitioner, this guide is designed to provide you with a clear pathway to implementing object detection models powered by YOLOv5.
+
+🆓 Plus, if you're a fresh GCP user, you're in luck with a [$300 free credit offer](https://cloud.google.com/free/docs/free-cloud-features#free-trial) to kickstart your projects.
+
+In addition to GCP, explore other accessible quickstart options for YOLOv5, like our [Colab Notebook](https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb) <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"> for a browser-based experience, or the scalability of [Amazon AWS](./aws_quickstart_tutorial.md). Furthermore, container aficionados can utilize our official Docker image at [Docker Hub](https://hub.docker.com/r/ultralytics/yolov5) <img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"> for an encapsulated environment.
+
+## Step 1: Create and Configure Your [Deep Learning](https://www.ultralytics.com/glossary/deep-learning-dl) VM
+
+Let's begin by creating a virtual machine that's tuned for deep learning:
+
+1. Head over to the [GCP marketplace](https://console.cloud.google.com/marketplace/details/click-to-deploy-images/deeplearning) and select the **Deep Learning VM**.
+2. Opt for a **n1-standard-8** instance; it offers a balance of 8 vCPUs and 30 GB of memory, ideally suited for our needs.
+3. Next, select a GPU. This depends on your workload; even a basic one like the T4 will markedly accelerate your model training.
+4. Tick the box for 'Install NVIDIA GPU driver automatically on first startup?' for hassle-free setup.
+5. Allocate a 300 GB SSD Persistent Disk to ensure you don't bottleneck on I/O operations.
+6. Hit 'Deploy' and let GCP do its magic in provisioning your custom Deep Learning VM.
+
+This VM comes loaded with a treasure trove of preinstalled tools and frameworks, including the [Anaconda](https://www.anaconda.com/) Python distribution, which conveniently bundles all the necessary dependencies for YOLOv5.
+
+![GCP Marketplace illustration of setting up a Deep Learning VM](https://github.com/ultralytics/docs/releases/download/0/gcp-deep-learning-vm-setup.avif)
+
+## Step 2: Ready the VM for YOLOv5
+
+Following the environment setup, let's get YOLOv5 up and running:
+
+```bash
+# Clone the YOLOv5 repository
+git clone https://github.com/ultralytics/yolov5
+
+# Change the directory to the cloned repository
+cd yolov5
+
+# Install the necessary Python packages from requirements.txt
+pip install -r requirements.txt
+```
+
+This setup process ensures you're working with a Python environment version 3.8.0 or newer and [PyTorch](https://www.ultralytics.com/glossary/pytorch) 1.8 or above. Our scripts smoothly download [models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) rending from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases), making it hassle-free to start model training.
+
+## Step 3: Train and Deploy Your YOLOv5 Models 🌐
+
+With the setup complete, you're ready to delve into training and inference with YOLOv5 on your GCP VM:
+
+```bash
+# Train a model on your data
+python train.py
+
+# Validate the trained model for Precision, Recall, and mAP
+python val.py --weights yolov5s.pt
+
+# Run inference using the trained model on your images or videos
+python detect.py --weights yolov5s.pt --source path/to/images
+
+# Export the trained model to other formats for deployment
+python export.py --weights yolov5s.pt --include onnx coreml tflite
+```
+
+With just a few commands, YOLOv5 allows you to train custom [object detection](https://www.ultralytics.com/glossary/object-detection) models tailored to your specific needs or utilize pre-trained weights for quick results on a variety of tasks.
+
+![Terminal command image illustrating model training on a GCP Deep Learning VM](https://github.com/ultralytics/docs/releases/download/0/terminal-command-model-training.avif)
+
+## Allocate Swap Space (optional)
+
+For those dealing with hefty datasets, consider amplifying your GCP instance with an additional 64GB of swap memory:
+
+```bash
+sudo fallocate -l 64G /swapfile
+sudo chmod 600 /swapfile
+sudo mkswap /swapfile
+sudo swapon /swapfile
+free -h  # confirm the memory increment
+```
+
+### Concluding Thoughts
+
+Congratulations! You are now empowered to harness the capabilities of YOLOv5 with the computational prowess of Google Cloud Platform. This combination provides scalability, efficiency, and versatility for your object detection tasks. Whether for personal projects, academic research, or industrial applications, you have taken a pivotal step into the world of AI and [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) on the cloud.
+
+Do remember to document your journey, share insights with the Ultralytics community, and leverage the collaborative arenas such as [GitHub discussions](https://github.com/ultralytics/yolov5/discussions) to grow further. Now, go forth and innovate with YOLOv5 and GCP! 🌟
+
+Want to keep improving your ML skills and knowledge? Dive into our [documentation and tutorials](../../index.md) for more resources. Let your AI adventure continue!

docs/en/yolov5/index.md

+---
+comments: true
+description: Explore comprehensive YOLOv5 documentation with step-by-step tutorials on training, deployment, and model optimization. Empower your vision projects today!.
+keywords: YOLOv5, Ultralytics, object detection, computer vision, deep learning, AI, tutorials, PyTorch, model optimization, machine learning, neural networks
+---
+
+# Comprehensive Guide to Ultralytics YOLOv5
+
+<div align="center">
+  <p>
+    <a href="https://www.ultralytics.com/yolo" target="_blank">
+    <img width="100%" src="https://github.com/ultralytics/docs/releases/download/0/ultralytics-yolov5-splash.avif" alt="Ultralytics YOLOv5 v7.0 banner"></a>
+  </p>
+
+<a href="https://github.com/ultralytics/yolov5/actions/workflows/ci-testing.yml"><img src="https://github.com/ultralytics/yolov5/actions/workflows/ci-testing.yml/badge.svg" alt="YOLOv5 CI"></a>
+<a href="https://zenodo.org/badge/latestdoi/264818686"><img src="https://zenodo.org/badge/264818686.svg" alt="YOLOv5 Citation"></a>
+<a href="https://hub.docker.com/r/ultralytics/yolov5"><img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"></a>
+<br>
+<a href="https://bit.ly/yolov5-paperspace-notebook"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run on Gradient"></a>
+<a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a>
+<a href="https://www.kaggle.com/models/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>
+<br>
+<br>
+
+Welcome to the Ultralytics' <a href="https://github.com/ultralytics/yolov5">YOLOv5</a>🚀 Documentation! YOLOv5, the fifth iteration of the revolutionary "You Only Look Once" <a href="https://www.ultralytics.com/glossary/object-detection">object detection</a> model, is designed to deliver high-speed, high-accuracy results in real-time.
+
+<br><br>
+
+Built on PyTorch, this powerful <a href="https://www.ultralytics.com/glossary/deep-learning-dl">deep learning</a> framework has garnered immense popularity for its versatility, ease of use, and high performance. Our documentation guides you through the installation process, explains the architectural nuances of the model, showcases various use-cases, and provides a series of detailed tutorials. These resources will help you harness the full potential of YOLOv5 for your <a href="https://www.ultralytics.com/glossary/computer-vision-cv">computer vision</a> projects. Let's get started!
+
+</div>
+
+## Explore and Learn
+
+Here's a compilation of comprehensive tutorials that will guide you through different aspects of YOLOv5.
+
+- [Train Custom Data](tutorials/train_custom_data.md) 🚀 RECOMMENDED: Learn how to train the YOLOv5 model on your custom dataset.
+- [Tips for Best Training Results](tutorials/tips_for_best_training_results.md) ☘️: Uncover practical tips to optimize your model training process.
+- [Multi-GPU Training](tutorials/multi_gpu_training.md): Understand how to leverage multiple GPUs to expedite your training.
+- [PyTorch Hub](tutorials/pytorch_hub_model_loading.md) 🌟 NEW: Learn to load pre-trained models via PyTorch Hub.
+- [TFLite, ONNX, CoreML, TensorRT Export](tutorials/model_export.md) 🚀: Understand how to export your model to different formats.
+- [Test-Time Augmentation (TTA)](tutorials/test_time_augmentation.md): Explore how to use TTA to improve your model's prediction accuracy.
+- [Model Ensembling](tutorials/model_ensembling.md): Learn the strategy of combining multiple models for improved performance.
+- [Model Pruning/Sparsity](tutorials/model_pruning_and_sparsity.md): Understand pruning and sparsity concepts, and how to create a more efficient model.
+- [Hyperparameter Evolution](tutorials/hyperparameter_evolution.md): Discover the process of automated [hyperparameter tuning](https://www.ultralytics.com/glossary/hyperparameter-tuning) for better model performance.
+- [Transfer Learning with Frozen Layers](tutorials/transfer_learning_with_frozen_layers.md): Learn how to implement [transfer learning](https://www.ultralytics.com/glossary/transfer-learning) by freezing layers in YOLOv5.
+- [Architecture Summary](tutorials/architecture_description.md) 🌟 Delve into the structural details of the YOLOv5 model.
+- [Roboflow for Datasets](tutorials/roboflow_datasets_integration.md): Understand how to utilize Roboflow for dataset management, labeling, and [active learning](https://www.ultralytics.com/glossary/active-learning).
+- [ClearML Logging](tutorials/clearml_logging_integration.md) 🌟 Learn how to integrate ClearML for efficient logging during your model training.
+- [YOLOv5 with Neural Magic](tutorials/neural_magic_pruning_quantization.md) Discover how to use Neural Magic's Deepsparse to prune and quantize your YOLOv5 model.
+- [Comet Logging](tutorials/comet_logging_integration.md) 🌟 NEW: Explore how to utilize Comet for improved model training logging.
+
+## Supported Environments
+
+Ultralytics provides a range of ready-to-use environments, each pre-installed with essential dependencies such as [CUDA](https://developer.nvidia.com/cuda-zone), [CUDNN](https://developer.nvidia.com/cudnn), [Python](https://www.python.org/), and [PyTorch](https://pytorch.org/), to kickstart your projects.
+
+- **Free GPU Notebooks**: <a href="https://bit.ly/yolov5-paperspace-notebook"><img src="https://assets.paperspace.io/img/gradient-badge.svg" alt="Run on Gradient"></a> <a href="https://colab.research.google.com/github/ultralytics/yolov5/blob/master/tutorial.ipynb"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"></a> <a href="https://www.kaggle.com/models/ultralytics/yolov5"><img src="https://kaggle.com/static/images/open-in-kaggle.svg" alt="Open In Kaggle"></a>
+- **Google Cloud**: [GCP Quickstart Guide](environments/google_cloud_quickstart_tutorial.md)
+- **Amazon**: [AWS Quickstart Guide](environments/aws_quickstart_tutorial.md)
+- **Azure**: [AzureML Quickstart Guide](environments/azureml_quickstart_tutorial.md)
+- **Docker**: [Docker Quickstart Guide](environments/docker_image_quickstart_tutorial.md) <a href="https://hub.docker.com/r/ultralytics/yolov5"><img src="https://img.shields.io/docker/pulls/ultralytics/yolov5?logo=docker" alt="Docker Pulls"></a>
+
+## Project Status
+
+<a href="https://github.com/ultralytics/yolov5/actions/workflows/ci-testing.yml"><img src="https://github.com/ultralytics/yolov5/actions/workflows/ci-testing.yml/badge.svg" alt="YOLOv5 CI"></a>
+
+This badge indicates that all [YOLOv5 GitHub Actions](https://github.com/ultralytics/yolov5/actions) Continuous Integration (CI) tests are successfully passing. These CI tests rigorously check the functionality and performance of YOLOv5 across various key aspects: [training](https://github.com/ultralytics/yolov5/blob/master/train.py), [validation](https://github.com/ultralytics/yolov5/blob/master/val.py), [inference](https://github.com/ultralytics/yolov5/blob/master/detect.py), [export](https://github.com/ultralytics/yolov5/blob/master/export.py), and [benchmarks](https://github.com/ultralytics/yolov5/blob/master/benchmarks.py). They ensure consistent and reliable operation on macOS, Windows, and Ubuntu, with tests conducted every 24 hours and upon each new commit.
+
+<br>
+<div align="center">
+  <a href="https://github.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-github.png" width="3%" alt="Ultralytics GitHub"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://www.linkedin.com/company/ultralytics/"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-linkedin.png" width="3%" alt="Ultralytics LinkedIn"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://twitter.com/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-twitter.png" width="3%" alt="Ultralytics Twitter"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://youtube.com/ultralytics?sub_confirmation=1"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-youtube.png" width="3%" alt="Ultralytics YouTube"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://www.tiktok.com/@ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-tiktok.png" width="3%" alt="Ultralytics TikTok"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://ultralytics.com/bilibili"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-bilibili.png" width="3%" alt="Ultralytics BiliBili"></a>
+  <img src="https://github.com/ultralytics/assets/raw/main/social/logo-transparent.png" width="3%" alt="space">
+  <a href="https://discord.com/invite/ultralytics"><img src="https://github.com/ultralytics/assets/raw/main/social/logo-social-discord.png" width="3%" alt="Ultralytics Discord"></a>
+</div>
+
+## Connect and Contribute
+
+Your journey with YOLOv5 doesn't have to be a solitary one. Join our vibrant community on [GitHub](https://github.com/ultralytics/yolov5), connect with professionals on [LinkedIn](https://www.linkedin.com/company/ultralytics/), share your results on [Twitter](https://twitter.com/ultralytics), and find educational resources on [YouTube](https://www.youtube.com/ultralytics?sub_confirmation=1). Follow us on [TikTok](https://www.tiktok.com/@ultralytics) and [BiliBili](https://ultralytics.com/bilibili) for more engaging content.
+
+Interested in contributing? We welcome contributions of all forms; from code improvements and bug reports to documentation updates. Check out our [contributing guidelines](../help/contributing.md/) for more information.
+
+We're excited to see the innovative ways you'll use YOLOv5. Dive in, experiment, and revolutionize your computer vision projects! 🚀
+
+## FAQ
+
+### What are the key features of Ultralytics YOLOv5?
+
+Ultralytics YOLOv5 is renowned for its high-speed and high-[accuracy](https://www.ultralytics.com/glossary/accuracy) object detection capabilities. Built on [PyTorch](https://www.ultralytics.com/glossary/pytorch), it is versatile and user-friendly, making it suitable for various computer vision projects. Key features include real-time inference, support for multiple training tricks like Test-Time Augmentation (TTA) and Model Ensembling, and compatibility with export formats such as TFLite, ONNX, CoreML, and TensorRT. To delve deeper into how Ultralytics YOLOv5 can elevate your project, explore our [TFLite, ONNX, CoreML, TensorRT Export guide](tutorials/model_export.md).
+
+### How can I train a custom YOLOv5 model on my dataset?
+
+Training a custom YOLOv5 model on your dataset involves a few key steps. First, prepare your dataset in the required format, annotated with labels. Then, configure the YOLOv5 training parameters and start the training process using the `train.py` script. For an in-depth tutorial on this process, consult our [Train Custom Data guide](tutorials/train_custom_data.md). It provides step-by-step instructions to ensure optimal results for your specific use case.
+
+### Why should I use Ultralytics YOLOv5 over other object detection models like RCNN?
+
+Ultralytics YOLOv5 is preferred over models like RCNN due to its superior speed and accuracy in real-time object detection. YOLOv5 processes the entire image in one go, making it significantly faster compared to the region-based approach of RCNN, which involves multiple passes. Additionally, YOLOv5's seamless integration with various export formats and extensive documentation make it an excellent choice for both beginners and professionals. Learn more about the architectural advantages in our [Architecture Summary](tutorials/architecture_description.md).
+
+### How can I optimize YOLOv5 model performance during training?
+
+Optimizing YOLOv5 model performance involves tuning various hyperparameters and incorporating techniques like [data augmentation](https://www.ultralytics.com/glossary/data-augmentation) and transfer learning. Ultralytics provides comprehensive resources on hyperparameter evolution and pruning/sparsity to improve model efficiency. You can discover practical tips in our [Tips for Best Training Results guide](tutorials/tips_for_best_training_results.md), which offers actionable insights for achieving optimal performance during training.
+
+### What environments are supported for running YOLOv5 applications?
+
+Ultralytics YOLOv5 supports a variety of environments, including free GPU notebooks on Gradient, Google Colab, Kaggle, as well as major cloud platforms like Google Cloud, Amazon AWS, and Azure. Docker images are also available for convenient setup. For a detailed guide on setting up these environments, check our [Supported Environments](tutorials/roboflow_datasets_integration.md) section, which includes step-by-step instructions for each platform.

docs/en/yolov5/quickstart_tutorial.md

+---
+comments: true
+description: Kickstart your real-time object detection journey with YOLOv5! This guide covers installation, inference, and training to help you master YOLOv5 quickly.
+keywords: YOLOv5, Quickstart, real-time object detection, AI, ML, PyTorch, inference, training, Ultralytics, machine learning, deep learning
+---
+
+# YOLOv5 Quickstart 🚀
+
+Embark on your journey into the dynamic realm of real-time [object detection](https://www.ultralytics.com/glossary/object-detection) with YOLOv5! This guide is crafted to serve as a comprehensive starting point for AI enthusiasts and professionals aiming to master YOLOv5. From initial setup to advanced training techniques, we've got you covered. By the end of this guide, you'll have the knowledge to implement YOLOv5 into your projects confidently. Let's ignite the engines and soar into YOLOv5!
+
+## Install
+
+Prepare for launch by cloning the repository and establishing the environment. This ensures that all the necessary [requirements](https://github.com/ultralytics/yolov5/blob/master/requirements.txt) are installed. Check that you have [**Python>=3.8.0**](https://www.python.org/) and [**PyTorch>=1.8**](https://pytorch.org/get-started/locally/) ready for takeoff.
+
+```bash
+git clone https://github.com/ultralytics/yolov5  # clone repository
+cd yolov5
+pip install -r requirements.txt  # install dependencies
+```
+
+## Inference with [PyTorch](https://www.ultralytics.com/glossary/pytorch) Hub
+
+Experience the simplicity of YOLOv5 [PyTorch Hub](./tutorials/pytorch_hub_model_loading.md) inference, where [models](https://github.com/ultralytics/yolov5/tree/master/models) are seamlessly downloaded from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases).
+
+```python
+import torch
+
+# Model loading
+model = torch.hub.load("ultralytics/yolov5", "yolov5s")  # Can be 'yolov5n' - 'yolov5x6', or 'custom'
+
+# Inference on images
+img = "https://ultralytics.com/images/zidane.jpg"  # Can be a file, Path, PIL, OpenCV, numpy, or list of images
+
+# Run inference
+results = model(img)
+
+# Display results
+results.print()  # Other options: .show(), .save(), .crop(), .pandas(), etc.
+```
+
+## Inference with detect.py
+
+Harness `detect.py` for versatile inference on various sources. It automatically fetches [models](https://github.com/ultralytics/yolov5/tree/master/models) from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases) and saves results with ease.
+
+```bash
+python detect.py --weights yolov5s.pt --source 0                               # webcam
+                                               image.jpg                       # image
+                                               video.mp4                       # video
+                                               screen                          # screenshot
+                                               path/                           # directory
+                                               list.txt                        # list of images
+                                               list.streams                    # list of streams
+                                               'path/*.jpg'                    # glob
+                                               'https://youtu.be/LNwODJXcvt4'  # YouTube
+                                               'rtsp://example.com/media.mp4'  # RTSP, RTMP, HTTP stream
+```
+
+## Training
+
+Replicate the YOLOv5 [COCO](https://github.com/ultralytics/yolov5/blob/master/data/scripts/get_coco.sh) benchmarks with the instructions below. The necessary [models](https://github.com/ultralytics/yolov5/tree/master/models) and [datasets](https://github.com/ultralytics/yolov5/tree/master/data) are pulled directly from the latest YOLOv5 [release](https://github.com/ultralytics/yolov5/releases). Training YOLOv5n/s/m/l/x on a V100 GPU should typically take 1/2/4/6/8 days respectively (note that [Multi-GPU](./tutorials/multi_gpu_training.md) setups work faster). Maximize performance by using the highest possible `--batch-size` or use `--batch-size -1` for the YOLOv5 [AutoBatch](https://github.com/ultralytics/yolov5/pull/5092) feature. The following [batch sizes](https://www.ultralytics.com/glossary/batch-size) are ideal for V100-16GB GPUs.
+
+```bash
+python train.py --data coco.yaml --epochs 300 --weights '' --cfg yolov5n.yaml  --batch-size 128
+                                                                 yolov5s                    64
+                                                                 yolov5m                    40
+                                                                 yolov5l                    24
+                                                                 yolov5x                    16
+```
+
+<img width="800" src="https://github.com/ultralytics/docs/releases/download/0/yolov5-training-curves.avif" alt="YOLO training curves">
+
+To conclude, YOLOv5 is not only a state-of-the-art tool for object detection but also a testament to the power of [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) in transforming the way we interact with the world through visual understanding. As you progress through this guide and begin applying YOLOv5 to your projects, remember that you are at the forefront of a technological revolution, capable of achieving remarkable feats. Should you need further insights or support from fellow visionaries, you're invited to our [GitHub repository](https://github.com/ultralytics/yolov5) home to a thriving community of developers and researchers. Keep exploring, keep innovating, and enjoy the marvels of YOLOv5. Happy detecting! 🌠🔍

docs/en/yolov5/tutorials/architecture_description.md

+---
+comments: true
+description: Dive deep into the powerful YOLOv5 architecture by Ultralytics, exploring its model structure, data augmentation techniques, training strategies, and loss computations.
+keywords: YOLOv5 architecture, object detection, Ultralytics, YOLO, model structure, data augmentation, training strategies, loss computations, deep learning, machine learning
+---
+
+# Ultralytics YOLOv5 Architecture
+
+YOLOv5 (v6.0/6.1) is a powerful object detection algorithm developed by Ultralytics. This article dives deep into the YOLOv5 architecture, [data augmentation](https://www.ultralytics.com/glossary/data-augmentation) strategies, training methodologies, and loss computation techniques. This comprehensive understanding will help improve your practical application of object detection in various fields, including surveillance, autonomous vehicles, and [image recognition](https://www.ultralytics.com/glossary/image-recognition).
+
+## 1. Model Structure
+
+YOLOv5's architecture consists of three main parts:
+
+- **Backbone**: This is the main body of the network. For YOLOv5, the backbone is designed using the `New CSP-Darknet53` structure, a modification of the Darknet architecture used in previous versions.
+- **Neck**: This part connects the backbone and the head. In YOLOv5, `SPPF` and `New CSP-PAN` structures are utilized.
+- **Head**: This part is responsible for generating the final output. YOLOv5 uses the `YOLOv3 Head` for this purpose.
+
+The structure of the model is depicted in the image below. The model structure details can be found in `yolov5l.yaml`.
+
+![yolov5](https://github.com/ultralytics/docs/releases/download/0/yolov5-model-structure.avif)
+
+YOLOv5 introduces some minor changes compared to its predecessors:
+
+1. The `Focus` structure, found in earlier versions, is replaced with a `6x6 Conv2d` structure. This change boosts efficiency [#4825](https://github.com/ultralytics/yolov5/issues/4825).
+2. The `SPP` structure is replaced with `SPPF`. This alteration more than doubles the speed of processing.
+
+To test the speed of `SPP` and `SPPF`, the following code can be used:
+
+<details>
+<summary>SPP vs SPPF speed profiling example (click to open)</summary>
+
+```python
+import time
+
+import torch
+import torch.nn as nn
+
+
+class SPP(nn.Module):
+    def __init__(self):
+        """Initializes an SPP module with three different sizes of max pooling layers."""
+        super().__init__()
+        self.maxpool1 = nn.MaxPool2d(5, 1, padding=2)
+        self.maxpool2 = nn.MaxPool2d(9, 1, padding=4)
+        self.maxpool3 = nn.MaxPool2d(13, 1, padding=6)
+
+    def forward(self, x):
+        """Applies three max pooling layers on input `x` and concatenates results along channel dimension."""
+        o1 = self.maxpool1(x)
+        o2 = self.maxpool2(x)
+        o3 = self.maxpool3(x)
+        return torch.cat([x, o1, o2, o3], dim=1)
+
+
+class SPPF(nn.Module):
+    def __init__(self):
+        """Initializes an SPPF module with a specific configuration of MaxPool2d layer."""
+        super().__init__()
+        self.maxpool = nn.MaxPool2d(5, 1, padding=2)
+
+    def forward(self, x):
+        """Applies sequential max pooling and concatenates results with input tensor."""
+        o1 = self.maxpool(x)
+        o2 = self.maxpool(o1)
+        o3 = self.maxpool(o2)
+        return torch.cat([x, o1, o2, o3], dim=1)
+
+
+def main():
+    """Compares outputs and performance of SPP and SPPF on a random tensor (8, 32, 16, 16)."""
+    input_tensor = torch.rand(8, 32, 16, 16)
+    spp = SPP()
+    sppf = SPPF()
+    output1 = spp(input_tensor)
+    output2 = sppf(input_tensor)
+
+    print(torch.equal(output1, output2))
+
+    t_start = time.time()
+    for _ in range(100):
+        spp(input_tensor)
+    print(f"SPP time: {time.time() - t_start}")
+
+    t_start = time.time()
+    for _ in range(100):
+        sppf(input_tensor)
+    print(f"SPPF time: {time.time() - t_start}")
+
+
+if __name__ == "__main__":
+    main()
+```
+
+result:
+
+```
+True
+SPP time: 0.5373051166534424
+SPPF time: 0.20780706405639648
+```
+
+</details>
+
+## 2. Data Augmentation Techniques
+
+YOLOv5 employs various data augmentation techniques to improve the model's ability to generalize and reduce [overfitting](https://www.ultralytics.com/glossary/overfitting). These techniques include:
+
+- **Mosaic Augmentation**: An image processing technique that combines four training images into one in ways that encourage [object detection](https://www.ultralytics.com/glossary/object-detection) models to better handle various object scales and translations.
+
+    ![mosaic](https://github.com/ultralytics/docs/releases/download/0/mosaic-augmentation.avif)
+
+- **Copy-Paste Augmentation**: An innovative data augmentation method that copies random patches from an image and pastes them onto another randomly chosen image, effectively generating a new training sample.
+
+    ![copy-paste](https://github.com/ultralytics/docs/releases/download/0/copy-paste.avif)
+
+- **Random Affine Transformations**: This includes random rotation, scaling, translation, and shearing of the images.
+
+    ![random-affine](https://github.com/ultralytics/docs/releases/download/0/random-affine-transformations.avif)
+
+- **MixUp Augmentation**: A method that creates composite images by taking a linear combination of two images and their associated labels.
+
+    ![mixup](https://github.com/ultralytics/docs/releases/download/0/mixup.avif)
+
+- **Albumentations**: A powerful library for image augmenting that supports a wide variety of augmentation techniques.
+
+- **HSV Augmentation**: Random changes to the Hue, Saturation, and Value of the images.
+
+    ![hsv](https://github.com/ultralytics/docs/releases/download/0/hsv-augmentation.avif)
+
+- **Random Horizontal Flip**: An augmentation method that randomly flips images horizontally.
+
+    ![horizontal-flip](https://github.com/ultralytics/docs/releases/download/0/random-horizontal-flip.avif)
+
+## 3. Training Strategies
+
+YOLOv5 applies several sophisticated training strategies to enhance the model's performance. They include:
+
+- **Multiscale Training**: The input images are randomly rescaled within a range of 0.5 to 1.5 times their original size during the training process.
+- **AutoAnchor**: This strategy optimizes the prior anchor boxes to match the statistical characteristics of the ground truth boxes in your custom data.
+- **Warmup and Cosine LR Scheduler**: A method to adjust the [learning rate](https://www.ultralytics.com/glossary/learning-rate) to enhance model performance.
+- **Exponential Moving Average (EMA)**: A strategy that uses the average of parameters over past steps to stabilize the training process and reduce generalization error.
+- **[Mixed Precision](https://www.ultralytics.com/glossary/mixed-precision) Training**: A method to perform operations in half-[precision](https://www.ultralytics.com/glossary/precision) format, reducing memory usage and enhancing computational speed.
+- **Hyperparameter Evolution**: A strategy to automatically tune hyperparameters to achieve optimal performance.
+
+## 4. Additional Features
+
+### 4.1 Compute Losses
+
+The loss in YOLOv5 is computed as a combination of three individual loss components:
+
+- **Classes Loss (BCE Loss)**: Binary Cross-Entropy loss, measures the error for the classification task.
+- **Objectness Loss (BCE Loss)**: Another Binary Cross-Entropy loss, calculates the error in detecting whether an object is present in a particular grid cell or not.
+- **Location Loss (CIoU Loss)**: Complete IoU loss, measures the error in localizing the object within the grid cell.
+
+The overall [loss function](https://www.ultralytics.com/glossary/loss-function) is depicted by:
+
+![loss](https://latex.codecogs.com/svg.image?Loss=\lambda_1L_{cls}+\lambda_2L_{obj}+\lambda_3L_{loc})
+
+### 4.2 Balance Losses
+
+The objectness losses of the three prediction layers (`P3`, `P4`, `P5`) are weighted differently. The balance weights are `[4.0, 1.0, 0.4]` respectively. This approach ensures that the predictions at different scales contribute appropriately to the total loss.
+
+![obj_loss](https://latex.codecogs.com/svg.image?L_{obj}=4.0\cdot&space;L_{obj}^{small}+1.0\cdot&space;L_{obj}^{medium}+0.4\cdot&space;L_{obj}^{large})
+
+### 4.3 Eliminate Grid Sensitivity
+
+The YOLOv5 architecture makes some important changes to the box prediction strategy compared to earlier versions of YOLO. In YOLOv2 and YOLOv3, the box coordinates were directly predicted using the activation of the last layer.
+
+![b_x](<https://latex.codecogs.com/svg.image?b_x=\sigma(t_x)+c_x>)
+![b_y](<https://latex.codecogs.com/svg.image?b_y=\sigma(t_y)+c_y>)
+![b_w](https://latex.codecogs.com/svg.image?b_w=p_w\cdot&space;e^{t_w})
+![b_h](https://latex.codecogs.com/svg.image?b_h=p_h\cdot&space;e^{t_h})
+
+<img src="https://user-images.githubusercontent.com/31005897/158508027-8bf63c28-8290-467b-8a3e-4ad09235001a.png#pic_center" width=40% alt="YOLOv5 grid computation">
+
+However, in YOLOv5, the formula for predicting the box coordinates has been updated to reduce grid sensitivity and prevent the model from predicting unbounded box dimensions.
+
+The revised formulas for calculating the predicted [bounding box](https://www.ultralytics.com/glossary/bounding-box) are as follows:
+
+![bx](<https://latex.codecogs.com/svg.image?b_x=(2\cdot\sigma(t_x)-0.5)+c_x>)
+![by](<https://latex.codecogs.com/svg.image?b_y=(2\cdot\sigma(t_y)-0.5)+c_y>)
+![bw](<https://latex.codecogs.com/svg.image?b_w=p_w\cdot(2\cdot\sigma(t_w))^2>)
+![bh](<https://latex.codecogs.com/svg.image?b_h=p_h\cdot(2\cdot\sigma(t_h))^2>)
+
+Compare the center point offset before and after scaling. The center point offset range is adjusted from (0, 1) to (-0.5, 1.5). Therefore, offset can easily get 0 or 1.
+
+<img src="https://user-images.githubusercontent.com/31005897/158508052-c24bc5e8-05c1-4154-ac97-2e1ec71f582e.png#pic_center" width=40% alt="YOLOv5 grid scaling">
+
+Compare the height and width scaling ratio(relative to anchor) before and after adjustment. The original yolo/darknet box equations have a serious flaw. Width and Height are completely unbounded as they are simply out=exp(in), which is dangerous, as it can lead to runaway gradients, instabilities, NaN losses and ultimately a complete loss of training. [refer this issue](https://github.com/ultralytics/yolov5/issues/471#issuecomment-662009779)
+
+<img src="https://user-images.githubusercontent.com/31005897/158508089-5ac0c7a3-6358-44b7-863e-a6e45babb842.png#pic_center" width=40% alt="YOLOv5 unbounded scaling">
+
+### 4.4 Build Targets
+
+The build target process in YOLOv5 is critical for training efficiency and model [accuracy](https://www.ultralytics.com/glossary/accuracy). It involves assigning ground truth boxes to the appropriate grid cells in the output map and matching them with the appropriate anchor boxes.
+
+This process follows these steps:
+
+- Calculate the ratio of the ground truth box dimensions and the dimensions of each anchor template.
+
+![rw](https://latex.codecogs.com/svg.image?r_w=w_{gt}/w_{at})
+
+![rh](https://latex.codecogs.com/svg.image?r_h=h_{gt}/h_{at})
+
+![rwmax](<https://latex.codecogs.com/svg.image?r_w^{max}=max(r_w,1/r_w)>)
+
+![rhmax](<https://latex.codecogs.com/svg.image?r_h^{max}=max(r_h,1/r_h)>)
+
+![rmax](<https://latex.codecogs.com/svg.image?r^{max}=max(r_w^{max},r_h^{max})>)
+
+![match](https://latex.codecogs.com/svg.image?r^{max}<{\rm&space;anchor_t})
+
+<img src="https://user-images.githubusercontent.com/31005897/158508119-fbb2e483-7b8c-4975-8e1f-f510d367f8ff.png#pic_center" width=70% alt="YOLOv5 IoU computation">
+
+- If the calculated ratio is within the threshold, match the ground truth box with the corresponding anchor.
+
+<img src="https://user-images.githubusercontent.com/31005897/158508771-b6e7cab4-8de6-47f9-9abf-cdf14c275dfe.png#pic_center" width=70% alt="YOLOv5 grid overlap">
+
+- Assign the matched anchor to the appropriate cells, keeping in mind that due to the revised center point offset, a ground truth box can be assigned to more than one anchor. Because the center point offset range is adjusted from (0, 1) to (-0.5, 1.5). GT Box can be assigned to more anchors.
+
+<img src="https://user-images.githubusercontent.com/31005897/158508139-9db4e8c2-cf96-47e0-bc80-35d11512f296.png#pic_center" width=70% alt="YOLOv5 anchor selection">
+
+This way, the build targets process ensures that each ground truth object is properly assigned and matched during the training process, allowing YOLOv5 to learn the task of object detection more effectively.
+
+## Conclusion
+
+In conclusion, YOLOv5 represents a significant step forward in the development of real-time object detection models. By incorporating various new features, enhancements, and training strategies, it surpasses previous versions of the YOLO family in performance and efficiency.
+
+The primary enhancements in YOLOv5 include the use of a dynamic architecture, an extensive range of data augmentation techniques, innovative training strategies, as well as important adjustments in computing losses and the process of building targets. All these innovations significantly improve the accuracy and efficiency of object detection while retaining a high degree of speed, which is the trademark of YOLO models.

docs/en/yolov5/tutorials/clearml_logging_integration.md

+---
+comments: true
+description: Learn how to use ClearML for tracking YOLOv5 experiments, data versioning, hyperparameter optimization, and remote execution with ease.
+keywords: ClearML, YOLOv5, machine learning, experiment tracking, data versioning, hyperparameter optimization, remote execution, ML pipeline
+---
+
+# ClearML Integration
+
+<img align="center" src="https://github.com/thepycoder/clearml_screenshots/raw/main/logos_dark.png#gh-light-mode-only" alt="Clear|ML"><img align="center" src="https://github.com/thepycoder/clearml_screenshots/raw/main/logos_light.png#gh-dark-mode-only" alt="Clear|ML">
+
+## About ClearML
+
+[ClearML](https://clear.ml/) is an [open-source](https://github.com/allegroai/clearml) toolbox designed to save you time ⏱️.
+
+🔨 Track every YOLOv5 training run in the <b>experiment manager</b>
+
+🔧 Version and easily access your custom [training data](https://www.ultralytics.com/glossary/training-data) with the integrated ClearML <b>Data Versioning Tool</b>
+
+🔦 <b>Remotely train and monitor</b> your YOLOv5 training runs using ClearML Agent
+
+🔬 Get the very best mAP using ClearML <b>Hyperparameter Optimization</b>
+
+🔭 Turn your newly trained <b>YOLOv5 model into an API</b> with just a few commands using ClearML Serving
+
+<br>
+And so much more. It's up to you how many of these tools you want to use, you can stick to the experiment manager, or chain them all together into an impressive pipeline!
+<br>
+<br>
+
+![ClearML scalars dashboard](https://github.com/ultralytics/docs/releases/download/0/clearml-scalars-dashboard.avif)
+
+<br>
+<br>
+
+## 🦾 Setting Things Up
+
+To keep track of your experiments and/or data, ClearML needs to communicate to a server. You have 2 options to get one:
+
+Either sign up for free to the [ClearML Hosted Service](https://clear.ml/) or you can set up your own server, see [here](https://clear.ml/docs/latest/docs/deploying_clearml/clearml_server). Even the server is open-source, so even if you're dealing with sensitive data, you should be good to go!
+
+- Install the `clearml` python package:
+
+    ```bash
+    pip install clearml
+    ```
+
+- Connect the ClearML SDK to the server by [creating credentials](https://app.clear.ml/settings/workspace-configuration) (go right top to Settings -> Workspace -> Create new credentials), then execute the command below and follow the instructions:
+
+    ```bash
+    clearml-init
+    ```
+
+That's it! You're done 😎
+
+<br>
+
+## 🚀 Training YOLOv5 With ClearML
+
+To enable ClearML experiment tracking, simply install the ClearML pip package.
+
+```bash
+pip install clearml>=1.2.0
+```
+
+This will enable integration with the YOLOv5 training script. Every training run from now on, will be captured and stored by the ClearML experiment manager.
+
+If you want to change the `project_name` or `task_name`, use the `--project` and `--name` arguments of the `train.py` script, by default the project will be called `YOLOv5` and the task `Training`. PLEASE NOTE: ClearML uses `/` as a delimiter for subprojects, so be careful when using `/` in your project name!
+
+```bash
+python train.py --img 640 --batch 16 --epochs 3 --data coco8.yaml --weights yolov5s.pt --cache
+```
+
+or with custom project and task name:
+
+```bash
+python train.py --project my_project --name my_training --img 640 --batch 16 --epochs 3 --data coco8.yaml --weights yolov5s.pt --cache
+```
+
+This will capture:
+
+- Source code + uncommitted changes
+- Installed packages
+- (Hyper)parameters
+- Model files (use `--save-period n` to save a checkpoint every n epochs)
+- Console output
+- Scalars (mAP_0.5, mAP_0.5:0.95, precision, recall, losses, learning rates, ...)
+- General info such as machine details, runtime, creation date etc.
+- All produced plots such as label correlogram and [confusion matrix](https://www.ultralytics.com/glossary/confusion-matrix)
+- Images with bounding boxes per [epoch](https://www.ultralytics.com/glossary/epoch)
+- Mosaic per epoch
+- Validation images per epoch
+
+That's a lot right? 🤯 Now, we can visualize all of this information in the ClearML UI to get an overview of our training progress. Add custom columns to the table view (such as e.g. mAP_0.5) so you can easily sort on the best performing model. Or select multiple experiments and directly compare them!
+
+There even more we can do with all of this information, like hyperparameter optimization and remote execution, so keep reading if you want to see how that works!
+
+### 🔗 Dataset Version Management
+
+Versioning your data separately from your code is generally a good idea and makes it easy to acquire the latest version too. This repository supports supplying a dataset version ID, and it will make sure to get the data if it's not there yet. Next to that, this workflow also saves the used dataset ID as part of the task parameters, so you will always know for sure which data was used in which experiment!
+
+![ClearML Dataset Interface](https://github.com/ultralytics/docs/releases/download/0/clearml-dataset-interface.avif)
+
+### Prepare Your Dataset
+
+The YOLOv5 repository supports a number of different datasets by using YAML files containing their information. By default datasets are downloaded to the `../datasets` folder in relation to the repository root folder. So if you downloaded the `coco128` dataset using the link in the YAML or with the scripts provided by yolov5, you get this folder structure:
+
+```
+..
+|_ yolov5
+|_ datasets
+    |_ coco128
+        |_ images
+        |_ labels
+        |_ LICENSE
+        |_ README.txt
+```
+
+But this can be any dataset you wish. Feel free to use your own, as long as you keep to this folder structure.
+
+Next, ⚠️**copy the corresponding YAML file to the root of the dataset folder**⚠️. This YAML files contains the information ClearML will need to properly use the dataset. You can make this yourself too, of course, just follow the structure of the example YAMLs.
+
+Basically we need the following keys: `path`, `train`, `test`, `val`, `nc`, `names`.
+
+```
+..
+|_ yolov5
+|_ datasets
+    |_ coco128
+        |_ images
+        |_ labels
+        |_ coco128.yaml  # <---- HERE!
+        |_ LICENSE
+        |_ README.txt
+```
+
+### Upload Your Dataset
+
+To get this dataset into ClearML as a versioned dataset, go to the dataset root folder and run the following command:
+
+```bash
+cd coco128
+clearml-data sync --project YOLOv5 --name coco128 --folder .
+```
+
+The command `clearml-data sync` is actually a shorthand command. You could also run these commands one after the other:
+
+```bash
+# Optionally add --parent <parent_dataset_id> if you want to base
+# this version on another dataset version, so no duplicate files are uploaded!
+clearml-data create --name coco128 --project YOLOv5
+clearml-data add --files .
+clearml-data close
+```
+
+### Run Training Using A ClearML Dataset
+
+Now that you have a ClearML dataset, you can very simply use it to train custom YOLOv5 🚀 models!
+
+```bash
+python train.py --img 640 --batch 16 --epochs 3 --data clearml://<your_dataset_id> --weights yolov5s.pt --cache
+```
+
+<br>
+
+### 👀 Hyperparameter Optimization
+
+Now that we have our experiments and data versioned, it's time to take a look at what we can build on top!
+
+Using the code information, installed packages and environment details, the experiment itself is now **completely reproducible**. In fact, ClearML allows you to clone an experiment and even change its parameters. We can then just rerun it with these new parameters automatically, this is basically what HPO does!
+
+To **run hyperparameter optimization locally**, we've included a pre-made script for you. Just make sure a training task has been run at least once, so it is in the ClearML experiment manager, we will essentially clone it and change its hyperparameters.
+
+You'll need to fill in the ID of this `template task` in the script found at `utils/loggers/clearml/hpo.py` and then just run it :) You can change `task.execute_locally()` to `task.execute()` to put it in a ClearML queue and have a remote agent work on it instead.
+
+```bash
+# To use optuna, install it first, otherwise you can change the optimizer to just be RandomSearch
+pip install optuna
+python utils/loggers/clearml/hpo.py
+```
+
+![HPO](https://github.com/ultralytics/docs/releases/download/0/hpo-clearml-experiment.avif)
+
+## 🤯 Remote Execution (advanced)
+
+Running HPO locally is really handy, but what if we want to run our experiments on a remote machine instead? Maybe you have access to a very powerful GPU machine on-site, or you have some budget to use cloud GPUs. This is where the ClearML Agent comes into play. Check out what the agent can do here:
+
+- [YouTube video](https://youtu.be/MX3BrXnaULs)
+- [Documentation](https://clear.ml/docs/latest/docs/clearml_agent)
+
+In short: every experiment tracked by the experiment manager contains enough information to reproduce it on a different machine (installed packages, uncommitted changes etc.). So a ClearML agent does just that: it listens to a queue for incoming tasks and when it finds one, it recreates the environment and runs it while still reporting scalars, plots etc. to the experiment manager.
+
+You can turn any machine (a cloud VM, a local GPU machine, your own laptop ... ) into a ClearML agent by simply running:
+
+```bash
+clearml-agent daemon --queue <queues_to_listen_to> [--docker]
+```
+
+### Cloning, Editing And Enqueuing
+
+With our agent running, we can give it some work. Remember from the HPO section that we can clone a task and edit the hyperparameters? We can do that from the interface too!
+
+🪄 Clone the experiment by right-clicking it
+
+🎯 Edit the hyperparameters to what you wish them to be
+
+⏳ Enqueue the task to any of the queues by right-clicking it
+
+![Enqueue a task from the UI](https://github.com/ultralytics/docs/releases/download/0/enqueue-task-ui.avif)
+
+### Executing A Task Remotely
+
+Now you can clone a task like we explained above, or simply mark your current script by adding `task.execute_remotely()` and on execution it will be put into a queue, for the agent to start working on!
+
+To run the YOLOv5 training script remotely, all you have to do is add this line to the training.py script after the clearml logger has been instantiated:
+
+```python
+# ...
+# Loggers
+data_dict = None
+if RANK in {-1, 0}:
+    loggers = Loggers(save_dir, weights, opt, hyp, LOGGER)  # loggers instance
+    if loggers.clearml:
+        loggers.clearml.task.execute_remotely(queue="my_queue")  # <------ ADD THIS LINE
+        # Data_dict is either None is user did not choose for ClearML dataset or is filled in by ClearML
+        data_dict = loggers.clearml.data_dict
+# ...
+```
+
+When running the training script after this change, python will run the script up until that line, after which it will package the code and send it to the queue instead!
+
+### Autoscaling workers
+
+ClearML comes with autoscalers too! This tool will automatically spin up new remote machines in the cloud of your choice (AWS, GCP, Azure) and turn them into ClearML agents for you whenever there are experiments detected in the queue. Once the tasks are processed, the autoscaler will automatically shut down the remote machines, and you stop paying!
+
+Check out the autoscalers getting started video below.
+
+[![Watch the video](https://github.com/ultralytics/docs/releases/download/0/clearml-autoscalers-video-thumbnail.avif)](https://youtu.be/j4XVMAaUt3E)

docs/en/yolov5/tutorials/comet_logging_integration.md

+---
+comments: true
+description: Learn to track, visualize and optimize YOLOv5 model metrics with Comet for seamless machine learning workflows.
+keywords: YOLOv5, Comet, machine learning, model tracking, hyperparameters, visualization, deep learning, logging, metrics
+---
+
+![Comet](https://cdn.comet.ml/img/notebook_logo.png)
+
+# YOLOv5 with Comet
+
+This guide will cover how to use YOLOv5 with [Comet](https://bit.ly/yolov5-readme-comet2)
+
+## About Comet
+
+Comet builds tools that help data scientists, engineers, and team leaders accelerate and optimize [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and [deep learning](https://www.ultralytics.com/glossary/deep-learning-dl) models.
+
+Track and visualize model metrics in real time, save your hyperparameters, datasets, and model checkpoints, and visualize your model predictions with [Comet Custom Panels](https://www.comet.com/docs/v2/guides/comet-dashboard/code-panels/about-panels/?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)! Comet makes sure you never lose track of your work and makes it easy to share results and collaborate across teams of all sizes!
+
+## Getting Started
+
+### Install Comet
+
+```shell
+pip install comet_ml
+```
+
+### Configure Comet Credentials
+
+There are two ways to configure Comet with YOLOv5.
+
+You can either set your credentials through environment variables
+
+**Environment Variables**
+
+```shell
+export COMET_API_KEY=<Your Comet API Key>
+export COMET_PROJECT_NAME=<Your Comet Project Name> # This will default to 'yolov5'
+```
+
+Or create a `.comet.config` file in your working directory and set your credentials there.
+
+**Comet Configuration File**
+
+```
+[comet]
+api_key=<Your Comet API Key>
+project_name=<Your Comet Project Name> # This will default to 'yolov5'
+```
+
+### Run the Training Script
+
+```shell
+# Train YOLOv5s on COCO128 for 5 epochs
+python train.py --img 640 --batch 16 --epochs 5 --data coco128.yaml --weights yolov5s.pt
+```
+
+That's it! Comet will automatically log your hyperparameters, command line arguments, training and validation metrics. You can visualize and analyze your runs in the Comet UI
+
+<img width="1920" alt="yolo-ui" src="https://github.com/ultralytics/docs/releases/download/0/yolo-ui.avif">
+
+## Try out an Example!
+
+Check out an example of a [completed run here](https://www.comet.com/examples/comet-example-yolov5/a0e29e0e9b984e4a822db2a62d0cb357?experiment-tab=chart&showOutliers=true&smoothing=0&transformY=smoothing&xAxis=step&utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
+
+Or better yet, try it out yourself in this Colab Notebook
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/drive/1RG0WOQyxlDlo5Km8GogJpIEJlg_5lyYO?usp=sharing)
+
+## Log automatically
+
+By default, Comet will log the following items
+
+## Metrics
+
+- Box Loss, Object Loss, Classification Loss for the training and [validation data](https://www.ultralytics.com/glossary/validation-data)
+- mAP_0.5, mAP_0.5:0.95 metrics for the validation data.
+- Precision and Recall for the validation data
+
+## Parameters
+
+- Model Hyperparameters
+- All parameters passed through the command line options
+
+## Visualizations
+
+- [Confusion Matrix](https://www.ultralytics.com/glossary/confusion-matrix) of the model predictions on the validation data
+- Plots for the PR and F1 curves across all classes
+- Correlogram of the Class Labels
+
+## Configure Comet Logging
+
+Comet can be configured to log additional data either through command line flags passed to the training script or through environment variables.
+
+```shell
+export COMET_MODE=online # Set whether to run Comet in 'online' or 'offline' mode. Defaults to online
+export COMET_MODEL_NAME=<your model name> #Set the name for the saved model. Defaults to yolov5
+export COMET_LOG_CONFUSION_MATRIX=false # Set to disable logging a Comet Confusion Matrix. Defaults to true
+export COMET_MAX_IMAGE_UPLOADS=<number of allowed images to upload to Comet> # Controls how many total image predictions to log to Comet. Defaults to 100.
+export COMET_LOG_PER_CLASS_METRICS=true # Set to log evaluation metrics for each detected class at the end of training. Defaults to false
+export COMET_DEFAULT_CHECKPOINT_FILENAME=<your checkpoint filename> # Set this if you would like to resume training from a different checkpoint. Defaults to 'last.pt'
+export COMET_LOG_BATCH_LEVEL_METRICS=true # Set this if you would like to log training metrics at the batch level. Defaults to false.
+export COMET_LOG_PREDICTIONS=true # Set this to false to disable logging model predictions
+```
+
+## Logging Checkpoints with Comet
+
+Logging Models to Comet is disabled by default. To enable it, pass the `save-period` argument to the training script. This will save the logged checkpoints to Comet based on the interval value provided by `save-period`
+
+```shell
+python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt \
+--save-period 1
+```
+
+## Logging Model Predictions
+
+By default, model predictions (images, ground truth labels and bounding boxes) will be logged to Comet.
+
+You can control the frequency of logged predictions and the associated images by passing the `bbox_interval` command line argument. Predictions can be visualized using Comet's [Object Detection](https://www.ultralytics.com/glossary/object-detection) Custom Panel. This frequency corresponds to every Nth batch of data per [epoch](https://www.ultralytics.com/glossary/epoch). In the example below, we are logging every 2nd batch of data for each epoch.
+
+**Note:** The YOLOv5 validation dataloader will default to a [batch size](https://www.ultralytics.com/glossary/batch-size) of 32, so you will have to set the logging frequency accordingly.
+
+Here is an [example project using the Panel](https://www.comet.com/examples/comet-example-yolov5?shareable=YcwMiJaZSXfcEXpGOHDD12vA1&utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
+
+```shell
+python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt \
+--bbox_interval 2
+```
+
+### Controlling the number of Prediction Images logged to Comet
+
+When logging predictions from YOLOv5, Comet will log the images associated with each set of predictions. By default a maximum of 100 validation images are logged. You can increase or decrease this number using the `COMET_MAX_IMAGE_UPLOADS` environment variable.
+
+```shell
+env COMET_MAX_IMAGE_UPLOADS=200 python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt \
+--bbox_interval 1
+```
+
+### Logging Class Level Metrics
+
+Use the `COMET_LOG_PER_CLASS_METRICS` environment variable to log mAP, [precision](https://www.ultralytics.com/glossary/precision), [recall](https://www.ultralytics.com/glossary/recall), f1 for each class.
+
+```shell
+env COMET_LOG_PER_CLASS_METRICS=true python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt
+```
+
+## Uploading a Dataset to Comet Artifacts
+
+If you would like to store your data using [Comet Artifacts](https://www.comet.com/docs/v2/guides/data-management/using-artifacts/#learn-more?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github), you can do so using the `upload_dataset` flag.
+
+The dataset be organized in the way described in the [YOLOv5 documentation](train_custom_data.md). The dataset config `yaml` file must follow the same format as that of the `coco128.yaml` file.
+
+```shell
+python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data coco128.yaml \
+--weights yolov5s.pt \
+--upload_dataset
+```
+
+You can find the uploaded dataset in the Artifacts tab in your Comet Workspace <img width="1073" alt="artifact-1" src="https://github.com/ultralytics/docs/releases/download/0/artifact-1.avif">
+
+You can preview the data directly in the Comet UI. <img width="1082" alt="artifact-2" src="https://github.com/ultralytics/docs/releases/download/0/artifact-2.avif">
+
+Artifacts are versioned and also support adding metadata about the dataset. Comet will automatically log the metadata from your dataset `yaml` file <img width="963" alt="artifact-3" src="https://github.com/ultralytics/docs/releases/download/0/artifact-metadata-logging.avif">
+
+### Using a saved Artifact
+
+If you would like to use a dataset from Comet Artifacts, set the `path` variable in your dataset `yaml` file to point to the following Artifact resource URL.
+
+```
+# contents of artifact.yaml file
+path: "comet://<workspace name>/<artifact name>:<artifact version or alias>"
+```
+
+Then pass this file to your training script in the following way
+
+```shell
+python train.py \
+--img 640 \
+--batch 16 \
+--epochs 5 \
+--data artifact.yaml \
+--weights yolov5s.pt
+```
+
+Artifacts also allow you to track the lineage of data as it flows through your Experimentation workflow. Here you can see a graph that shows you all the experiments that have used your uploaded dataset. <img width="1391" alt="artifact-4" src="https://github.com/ultralytics/docs/releases/download/0/artifact-lineage-graph.avif">
+
+## Resuming a Training Run
+
+If your training run is interrupted for any reason, e.g. disrupted internet connection, you can resume the run using the `resume` flag and the Comet Run Path.
+
+The Run Path has the following format `comet://<your workspace name>/<your project name>/<experiment id>`.
+
+This will restore the run to its state before the interruption, which includes restoring the model from a checkpoint, restoring all hyperparameters and training arguments and downloading Comet dataset Artifacts if they were used in the original run. The resumed run will continue logging to the existing Experiment in the Comet UI
+
+```shell
+python train.py \
+--resume "comet://<your run path>"
+```
+
+## Hyperparameter Search with the Comet Optimizer
+
+YOLOv5 is also integrated with Comet's Optimizer, making is simple to visualize hyperparameter sweeps in the Comet UI.
+
+### Configuring an Optimizer Sweep
+
+To configure the Comet Optimizer, you will have to create a JSON file with the information about the sweep. An example file has been provided in `utils/loggers/comet/optimizer_config.json`
+
+```shell
+python utils/loggers/comet/hpo.py \
+  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json"
+```
+
+The `hpo.py` script accepts the same arguments as `train.py`. If you wish to pass additional arguments to your sweep simply add them after the script.
+
+```shell
+python utils/loggers/comet/hpo.py \
+  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json" \
+  --save-period 1 \
+  --bbox_interval 1
+```
+
+### Running a Sweep in Parallel
+
+```shell
+comet optimizer -j <set number of workers> utils/loggers/comet/hpo.py \
+  utils/loggers/comet/optimizer_config.json"
+```
+
+## Visualizing Results
+
+Comet provides a number of ways to visualize the results of your sweep. Take a look at a [project with a completed sweep here](https://www.comet.com/examples/comet-example-yolov5/view/PrlArHGuuhDTKC1UuBmTtOSXD/panels?utm_source=yolov5&utm_medium=partner&utm_campaign=partner_yolov5_2022&utm_content=github)
+
+<img width="1626" alt="hyperparameter-yolo" src="https://github.com/ultralytics/docs/releases/download/0/hyperparameter-yolo.avif">