v1.0

docs/en/modes/train.md

+---
+comments: true
+description: Step-by-step guide to train YOLOv8 models with Ultralytics YOLO including examples of single-GPU and multi-GPU training
+keywords: Ultralytics, YOLOv8, YOLO, object detection, train mode, custom dataset, GPU training, multi-GPU, hyperparameters, CLI examples, Python examples
+---
+
+# Model Training with Ultralytics YOLO
+
+<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO ecosystem and integrations">
+
+## Introduction
+
+Training a deep learning model involves feeding it data and adjusting its parameters so that it can make accurate predictions. Train mode in Ultralytics YOLOv8 is engineered for effective and efficient training of object detection models, fully utilizing modern hardware capabilities. This guide aims to cover all the details you need to get started with training your own models using YOLOv8's robust set of features.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/LNwODJXcvt4?si=7n1UvGRLSd9p5wKs"
+    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 a YOLOv8 model on Your Custom Dataset in Google Colab.
+</p>
+
+## Why Choose Ultralytics YOLO for Training?
+
+Here are some compelling reasons to opt for YOLOv8's Train mode:
+
+- **Efficiency:** Make the most out of your hardware, whether you're on a single-GPU setup or scaling across multiple GPUs.
+- **Versatility:** Train on custom datasets in addition to readily available ones like COCO, VOC, and ImageNet.
+- **User-Friendly:** Simple yet powerful CLI and Python interfaces for a straightforward training experience.
+- **Hyperparameter Flexibility:** A broad range of customizable hyperparameters to fine-tune model performance.
+
+### Key Features of Train Mode
+
+The following are some notable features of YOLOv8's Train mode:
+
+- **Automatic Dataset Download:** Standard datasets like COCO, VOC, and ImageNet are downloaded automatically on first use.
+- **Multi-GPU Support:** Scale your training efforts seamlessly across multiple GPUs to expedite the process.
+- **Hyperparameter Configuration:** The option to modify hyperparameters through YAML configuration files or CLI arguments.
+- **Visualization and Monitoring:** Real-time tracking of training metrics and visualization of the learning process for better insights.
+
+!!! Tip "Tip"
+
+    * YOLOv8 datasets like COCO, VOC, ImageNet and many others automatically download on first use, i.e. `yolo train data=coco.yaml`
+
+## Usage Examples
+
+Train YOLOv8n on the COCO128 dataset for 100 epochs at image size 640. The training device can be specified using the `device` argument. If no argument is passed GPU `device=0` will be used if available, otherwise `device=cpu` will be used. See Arguments section below for a full list of training arguments.
+
+!!! Example "Single-GPU and CPU Training Example"
+
+    Device is determined automatically. If a GPU is available then it will be used, otherwise training will start on CPU.
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO('yolov8n.yaml')  # build a new model from YAML
+        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
+        model = YOLO('yolov8n.yaml').load('yolov8n.pt')  # build from YAML and transfer weights
+
+        # Train the model
+        results = model.train(data='coco128.yaml', epochs=100, imgsz=640)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Build a new model from YAML and start training from scratch
+        yolo detect train data=coco128.yaml model=yolov8n.yaml epochs=100 imgsz=640
+
+        # Start training from a pretrained *.pt model
+        yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640
+
+        # Build a new model from YAML, transfer pretrained weights to it and start training
+        yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640
+        ```
+
+### Multi-GPU Training
+
+Multi-GPU training allows for more efficient utilization of available hardware resources by distributing the training load across multiple GPUs. This feature is available through both the Python API and the command-line interface. To enable multi-GPU training, specify the GPU device IDs you wish to use.
+
+!!! Example "Multi-GPU Training Example"
+
+    To train with 2 GPUs, CUDA devices 0 and 1 use the following commands. Expand to additional GPUs as required.
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
+
+        # Train the model with 2 GPUs
+        results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device=[0, 1])
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Start training from a pretrained *.pt model using GPUs 0 and 1
+        yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=0,1
+        ```
+
+### Apple M1 and M2 MPS Training
+
+With the support for Apple M1 and M2 chips integrated in the Ultralytics YOLO models, it's now possible to train your models on devices utilizing the powerful Metal Performance Shaders (MPS) framework. The MPS offers a high-performance way of executing computation and image processing tasks on Apple's custom silicon.
+
+To enable training on Apple M1 and M2 chips, you should specify 'mps' as your device when initiating the training process. Below is an example of how you could do this in Python and via the command line:
+
+!!! Example "MPS Training Example"
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO('yolov8n.pt')  # load a pretrained model (recommended for training)
+
+        # Train the model with 2 GPUs
+        results = model.train(data='coco128.yaml', epochs=100, imgsz=640, device='mps')
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Start training from a pretrained *.pt model using GPUs 0 and 1
+        yolo detect train data=coco128.yaml model=yolov8n.pt epochs=100 imgsz=640 device=mps
+        ```
+
+While leveraging the computational power of the M1/M2 chips, this enables more efficient processing of the training tasks. For more detailed guidance and advanced configuration options, please refer to the [PyTorch MPS documentation](https://pytorch.org/docs/stable/notes/mps.html).
+
+### Resuming Interrupted Trainings
+
+Resuming training from a previously saved state is a crucial feature when working with deep learning models. This can come in handy in various scenarios, like when the training process has been unexpectedly interrupted, or when you wish to continue training a model with new data or for more epochs.
+
+When training is resumed, Ultralytics YOLO loads the weights from the last saved model and also restores the optimizer state, learning rate scheduler, and the epoch number. This allows you to continue the training process seamlessly from where it was left off.
+
+You can easily resume training in Ultralytics YOLO by setting the `resume` argument to `True` when calling the `train` method, and specifying the path to the `.pt` file containing the partially trained model weights.
+
+Below is an example of how to resume an interrupted training using Python and via the command line:
+
+!!! Example "Resume Training Example"
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO('path/to/last.pt')  # load a partially trained model
+
+        # Resume training
+        results = model.train(resume=True)
+        ```
+
+    === "CLI"
+
+        ```bash
+        # Resume an interrupted training
+        yolo train resume model=path/to/last.pt
+        ```
+
+By setting `resume=True`, the `train` function will continue training from where it left off, using the state stored in the 'path/to/last.pt' file. If the `resume` argument is omitted or set to `False`, the `train` function will start a new training session.
+
+Remember that checkpoints are saved at the end of every epoch by default, or at fixed interval using the `save_period` argument, so you must complete at least 1 epoch to resume a training run.
+
+## 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, momentum, and weight decay. Additionally, the choice of optimizer, loss function, and training dataset composition can impact the training process. Careful tuning and experimentation with these settings are crucial for optimizing performance.
+
+| Argument          | Default  | Description                                                                                                                                                                                                          |
+|-------------------|----------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `model`           | `None`   | Specifies the model file for training. Accepts a path to either a `.pt` pretrained model or a `.yaml` configuration file. Essential for defining the model structure or initializing weights.                        |
+| `data`            | `None`   | Path to the dataset configuration file (e.g., `coco128.yaml`). This file contains dataset-specific parameters, including paths to training and validation data, class names, and number of classes.                  |
+| `epochs`          | `100`    | Total number of training epochs. Each epoch represents a full pass over the entire dataset. Adjusting this value can affect training duration and model performance.                                                 |
+| `time`            | `None`   | Maximum training time in hours. If set, this overrides the `epochs` argument, allowing training to automatically stop after the specified duration. Useful for time-constrained training scenarios.                  |
+| `patience`        | `100`    | Number of epochs to wait without improvement in validation metrics before early stopping the training. Helps prevent overfitting by stopping training when performance plateaus.                                     |
+| `batch`           | `16`     | Batch size for training, indicating how many images are processed before the model's internal parameters are updated. AutoBatch (`batch=-1`) dynamically adjusts the batch size based on GPU memory availability.    |
+| `imgsz`           | `640`    | Target image size for training. All images are resized to this dimension before being fed into the model. Affects model accuracy and computational complexity.                                                       |
+| `save`            | `True`   | Enables saving of training checkpoints and final model weights. Useful for resuming training or model deployment.                                                                                                    |
+| `save_period`     | `-1`     | Frequency of saving model checkpoints, specified in epochs. A value of -1 disables this feature. Useful for saving interim models during long training sessions.                                                     |
+| `cache`           | `False`  | Enables caching of dataset images in memory (`True`/`ram`), on disk (`disk`), or disables it (`False`). Improves training speed by reducing disk I/O at the cost of increased memory usage.                          |
+| `device`          | `None`   | Specifies the computational device(s) for training: a single GPU (`device=0`), multiple GPUs (`device=0,1`), CPU (`device=cpu`), or MPS for Apple silicon (`device=mps`).                                            |
+| `workers`         | `8`      | Number of worker threads for data loading (per `RANK` if Multi-GPU training). Influences the speed of data preprocessing and feeding into the model, especially useful in multi-GPU setups.                          |
+| `project`         | `None`   | Name of the project directory where training outputs are saved. Allows for organized storage of different experiments.                                                                                               |
+| `name`            | `None`   | Name of the training run. Used for creating a subdirectory within the project folder, where training logs and outputs are stored.                                                                                    |
+| `exist_ok`        | `False`  | If True, allows overwriting of an existing project/name directory. Useful for iterative experimentation without needing to manually clear previous outputs.                                                          |
+| `pretrained`      | `True`   | Determines whether to start training from a pretrained model. Can be a boolean value or a string path to a specific model from which to load weights. Enhances training efficiency and model performance.            |
+| `optimizer`       | `'auto'` | Choice of optimizer for training. Options include `SGD`, `Adam`, `AdamW`, `NAdam`, `RAdam`, `RMSProp` etc., or `auto` for automatic selection based on model configuration. Affects convergence speed and stability. |
+| `verbose`         | `False`  | Enables verbose output during training, providing detailed logs and progress updates. Useful for debugging and closely monitoring the training process.                                                              |
+| `seed`            | `0`      | Sets the random seed for training, ensuring reproducibility of results across runs with the same configurations.                                                                                                     |
+| `deterministic`   | `True`   | Forces deterministic algorithm use, ensuring reproducibility but may affect performance and speed due to the restriction on non-deterministic algorithms.                                                            |
+| `single_cls`      | `False`  | Treats all classes in multi-class datasets as a single class during training. Useful for binary classification tasks or when focusing on object presence rather than classification.                                 |
+| `rect`            | `False`  | Enables rectangular training, optimizing batch composition for minimal padding. Can improve efficiency and speed but may affect model accuracy.                                                                      |
+| `cos_lr`          | `False`  | Utilizes a cosine learning rate scheduler, adjusting the learning rate following a cosine curve over epochs. Helps in managing learning rate for better convergence.                                                 |
+| `close_mosaic`    | `10`     | Disables mosaic data augmentation in the last N epochs to stabilize training before completion. Setting to 0 disables this feature.                                                                                  |
+| `resume`          | `False`  | Resumes training from the last saved checkpoint. Automatically loads model weights, optimizer state, and epoch count, continuing training seamlessly.                                                                |
+| `amp`             | `True`   | Enables Automatic Mixed Precision (AMP) training, reducing memory usage and possibly speeding up training with minimal impact on accuracy.                                                                           |
+| `fraction`        | `1.0`    | Specifies the fraction of the dataset to use for training. Allows for training on a subset of the full dataset, useful for experiments or when resources are limited.                                                |
+| `profile`         | `False`  | Enables profiling of ONNX and TensorRT speeds during training, useful for optimizing model deployment.                                                                                                               |
+| `freeze`          | `None`   | Freezes the first N layers of the model or specified layers by index, reducing the number of trainable parameters. Useful for fine-tuning or transfer learning.                                                      |
+| `lr0`             | `0.01`   | Initial learning rate (i.e. `SGD=1E-2`, `Adam=1E-3`) . Adjusting this value is crucial for the optimization process, influencing how rapidly model weights are updated.                                              |
+| `lrf`             | `0.01`   | Final learning rate as a fraction of the initial rate = (`lr0 * lrf`), used in conjunction with schedulers to adjust the learning rate over time.                                                                    |
+| `momentum`        | `0.937`  | Momentum factor for SGD or beta1 for Adam optimizers, influencing the incorporation of past gradients in the current update.                                                                                         |
+| `weight_decay`    | `0.0005` | L2 regularization term, penalizing large weights to prevent overfitting.                                                                                                                                             |
+| `warmup_epochs`   | `3.0`    | Number of epochs for learning rate warmup, gradually increasing the learning rate from a low value to the initial learning rate to stabilize training early on.                                                      |
+| `warmup_momentum` | `0.8`    | Initial momentum for warmup phase, gradually adjusting to the set momentum over the warmup period.                                                                                                                   |
+| `warmup_bias_lr`  | `0.1`    | Learning rate for bias parameters during the warmup phase, helping stabilize model training in the initial epochs.                                                                                                   |
+| `box`             | `7.5`    | Weight of the box loss component in the loss function, influencing how much emphasis is placed on accurately predicting bounding box coordinates.                                                                    |
+| `cls`             | `0.5`    | Weight of the classification loss in the total loss function, affecting the importance of correct class prediction relative to other components.                                                                     |
+| `dfl`             | `1.5`    | Weight of the distribution focal loss, used in certain YOLO versions for fine-grained classification.                                                                                                                |
+| `pose`            | `12.0`   | Weight of the pose loss in models trained for pose estimation, influencing the emphasis on accurately predicting pose keypoints.                                                                                     |
+| `kobj`            | `2.0`    | Weight of the keypoint objectness loss in pose estimation models, balancing detection confidence with pose accuracy.                                                                                                 |
+| `label_smoothing` | `0.0`    | Applies label smoothing, softening hard labels to a mix of the target label and a uniform distribution over labels, can improve generalization.                                                                      |
+| `nbs`             | `64`     | Nominal batch size for normalization of loss.                                                                                                                                                                        |
+| `overlap_mask`    | `True`   | Determines whether segmentation masks should overlap during training, applicable in instance segmentation tasks.                                                                                                     |
+| `mask_ratio`      | `4`      | Downsample ratio for segmentation masks, affecting the resolution of masks used during training.                                                                                                                     |
+| `dropout`         | `0.0`    | Dropout rate for regularization in classification tasks, preventing overfitting by randomly omitting units during training.                                                                                          |
+| `val`             | `True`   | Enables validation during training, allowing for periodic evaluation of model performance on a separate dataset.                                                                                                     |
+| `plots`           | `False`  | Generates and saves plots of training and validation metrics, as well as prediction examples, providing visual insights into model performance and learning progression.                                             |
+
+## Augmentation Settings and Hyperparameters
+
+Augmentation techniques are essential for improving the robustness and performance of YOLO models by introducing variability into the training data, helping the model generalize better to unseen data. The following table outlines the purpose and effect of each augmentation argument:
+
+| Argument       | Type    | Default       | Range         | Description                                                                                                                                                               |
+|----------------|---------|---------------|---------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `hsv_h`        | `float` | `0.015`       | `0.0 - 1.0`   | Adjusts the hue of the image by a fraction of the color wheel, introducing color variability. Helps the model generalize across different lighting conditions.            |
+| `hsv_s`        | `float` | `0.7`         | `0.0 - 1.0`   | Alters the saturation of the image by a fraction, affecting the intensity of colors. Useful for simulating different environmental conditions.                            |
+| `hsv_v`        | `float` | `0.4`         | `0.0 - 1.0`   | Modifies the value (brightness) of the image by a fraction, helping the model to perform well under various lighting conditions.                                          |
+| `degrees`      | `float` | `0.0`         | `-180 - +180` | Rotates the image randomly within the specified degree range, improving the model's ability to recognize objects at various orientations.                                 |
+| `translate`    | `float` | `0.1`         | `0.0 - 1.0`   | Translates the image horizontally and vertically by a fraction of the image size, aiding in learning to detect partially visible objects.                                 |
+| `scale`        | `float` | `0.5`         | `>=0.0`       | Scales the image by a gain factor, simulating objects at different distances from the camera.                                                                             |
+| `shear`        | `float` | `0.0`         | `-180 - +180` | Shears the image by a specified degree, mimicking the effect of objects being viewed from different angles.                                                               |
+| `perspective`  | `float` | `0.0`         | `0.0 - 0.001` | Applies a random perspective transformation to the image, enhancing the model's ability to understand objects in 3D space.                                                |
+| `flipud`       | `float` | `0.0`         | `0.0 - 1.0`   | Flips the image upside down with the specified probability, increasing the data variability without affecting the object's characteristics.                               |
+| `fliplr`       | `float` | `0.5`         | `0.0 - 1.0`   | Flips the image left to right with the specified probability, useful for learning symmetrical objects and increasing dataset diversity.                                   |
+| `bgr`          | `float` | `0.0`         | `0.0 - 1.0`   | Flips the image channels from RGB to BGR with the specified probability, useful for increasing robustness to incorrect channel ordering.                                  |
+| `mosaic`       | `float` | `1.0`         | `0.0 - 1.0`   | Combines four training images into one, simulating different scene compositions and object interactions. Highly effective for complex scene understanding.                |
+| `mixup`        | `float` | `0.0`         | `0.0 - 1.0`   | Blends two images and their labels, creating a composite image. Enhances the model's ability to generalize by introducing label noise and visual variability.             |
+| `copy_paste`   | `float` | `0.0`         | `0.0 - 1.0`   | Copies objects from one image and pastes them onto another, useful for increasing object instances and learning object occlusion.                                         |
+| `auto_augment` | `str`   | `randaugment` | -             | Automatically applies a predefined augmentation policy (`randaugment`, `autoaugment`, `augmix`), optimizing for classification tasks by diversifying the visual features. |
+| `erasing`      | `float` | `0.4`         | `0.0 - 1.0`   | Randomly erases a portion of the image during classification training, encouraging the model to focus on less obvious features for recognition.                           |
+
+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.
+
+!!! info
+
+    For more information about training augmentation operations, see the [reference section](../reference/data/augment.md).
+
+## Logging
+
+In training a YOLOv8 model, you might find it valuable to keep track of the model's performance over time. This is where logging comes into play. Ultralytics' YOLO provides support for three types of loggers - Comet, ClearML, and TensorBoard.
+
+To use a logger, select it from the dropdown menu in the code snippet above and run it. The chosen logger will be installed and initialized.
+
+### Comet
+
+[Comet](../integrations/comet.md) is a platform that allows data scientists and developers to track, compare, explain and optimize experiments and models. It provides functionalities such as real-time metrics, code diffs, and hyperparameters tracking.
+
+To use Comet:
+
+!!! Example
+
+    === "Python"
+
+        ```python
+        # pip install comet_ml
+        import comet_ml
+
+        comet_ml.init()
+        ```
+
+Remember to sign in to your Comet account on their website and get your API key. You will need to add this to your environment variables or your script to log your experiments.
+
+### ClearML
+
+[ClearML](https://www.clear.ml/) is an open-source platform that automates tracking of experiments and helps with efficient sharing of resources. It is designed to help teams manage, execute, and reproduce their ML work more efficiently.
+
+To use ClearML:
+
+!!! Example
+
+    === "Python"
+
+        ```python
+        # pip install clearml
+        import clearml
+
+        clearml.browser_login()
+        ```
+
+After running this script, you will need to sign in to your ClearML account on the browser and authenticate your session.
+
+### TensorBoard
+
+[TensorBoard](https://www.tensorflow.org/tensorboard) is a visualization toolkit for TensorFlow. It allows you to visualize your TensorFlow graph, plot quantitative metrics about the execution of your graph, and show additional data like images that pass through it.
+
+To use TensorBoard in [Google Colab](https://colab.research.google.com/github/ultralytics/ultralytics/blob/main/examples/tutorial.ipynb):
+
+!!! Example
+
+    === "CLI"
+
+        ```bash
+        load_ext tensorboard
+        tensorboard --logdir ultralytics/runs  # replace with 'runs' directory
+        ```
+
+To use TensorBoard locally run the below command and view results at http://localhost:6006/.
+
+!!! Example
+
+    === "CLI"
+
+        ```bash
+        tensorboard --logdir ultralytics/runs  # replace with 'runs' directory
+        ```
+
+This will load TensorBoard and direct it to the directory where your training logs are saved.
+
+After setting up your logger, you can then proceed with your model training. All training metrics will be automatically logged in your chosen platform, and you can access these logs to monitor your model's performance over time, compare different models, and identify areas for improvement.

docs/en/modes/val.md

+---
+comments: true
+description: Guide for Validating YOLOv8 Models. Learn how to evaluate the performance of your YOLO models using validation settings and metrics with Python and CLI examples.
+keywords: Ultralytics, YOLO Docs, YOLOv8, validation, model evaluation, hyperparameters, accuracy, metrics, Python, CLI
+---
+
+# Model Validation with Ultralytics YOLO
+
+<img width="1024" src="https://github.com/ultralytics/assets/raw/main/yolov8/banner-integrations.png" alt="Ultralytics YOLO ecosystem and integrations">
+
+## Introduction
+
+Validation is a critical step in the machine learning pipeline, allowing you to assess the quality of your trained models. Val mode in Ultralytics YOLOv8 provides a robust suite of tools and metrics for evaluating the performance of your object detection models. This guide serves as a complete resource for understanding how to effectively use the Val mode to ensure that your models are both accurate and reliable.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/j8uQc0qB91s?start=47"
+    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 Modes Tutorial: Validation
+</p>
+
+## Why Validate with Ultralytics YOLO?
+
+Here's why using YOLOv8's Val mode is advantageous:
+
+- **Precision:** Get accurate metrics like mAP50, mAP75, and mAP50-95 to comprehensively evaluate your model.
+- **Convenience:** Utilize built-in features that remember training settings, simplifying the validation process.
+- **Flexibility:** Validate your model with the same or different datasets and image sizes.
+- **Hyperparameter Tuning:** Use validation metrics to fine-tune your model for better performance.
+
+### Key Features of Val Mode
+
+These are the notable functionalities offered by YOLOv8's Val mode:
+
+- **Automated Settings:** Models remember their training configurations for straightforward validation.
+- **Multi-Metric Support:** Evaluate your model based on a range of accuracy metrics.
+- **CLI and Python API:** Choose from command-line interface or Python API based on your preference for validation.
+- **Data Compatibility:** Works seamlessly with datasets used during the training phase as well as custom datasets.
+
+!!! Tip "Tip"
+
+    * YOLOv8 models automatically remember their training settings, so you can validate a model at the same image size and on the original dataset easily with just `yolo val model=yolov8n.pt` or `model('yolov8n.pt').val()`
+
+## Usage Examples
+
+Validate trained YOLOv8n model accuracy on the COCO128 dataset. No argument need to passed as the `model` retains it's training `data` and arguments as model attributes. See Arguments section below for a full list of export arguments.
+
+!!! Example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+
+        # Load a model
+        model = YOLO('yolov8n.pt')  # load an official model
+        model = YOLO('path/to/best.pt')  # load a custom model
+
+        # Validate the model
+        metrics = model.val()  # no arguments needed, dataset and settings remembered
+        metrics.box.map    # map50-95
+        metrics.box.map50  # map50
+        metrics.box.map75  # map75
+        metrics.box.maps   # a list contains map50-95 of each category
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo detect val model=yolov8n.pt  # val official model
+        yolo detect val model=path/to/best.pt  # val custom model
+        ```
+
+## Arguments for YOLO Model Validation
+
+When validating YOLO models, several arguments can be fine-tuned to optimize the evaluation process. These arguments control aspects such as input image size, batch processing, and performance thresholds. Below is a detailed breakdown of each argument to help you customize your validation settings effectively.
+
+| Argument      | Type    | Default | Description                                                                                                                                                   |
+|---------------|---------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `data`        | `str`   | `None`  | Specifies the path to the dataset configuration file (e.g., `coco128.yaml`). This file includes paths to validation data, class names, and number of classes. |
+| `imgsz`       | `int`   | `640`   | Defines the size of input images. All images are resized to this dimension before processing.                                                                 |
+| `batch`       | `int`   | `16`    | Sets the number of images per batch. Use `-1` for AutoBatch, which automatically adjusts based on GPU memory availability.                                    |
+| `save_json`   | `bool`  | `False` | If `True`, saves the results to a JSON file for further analysis or integration with other tools.                                                             |
+| `save_hybrid` | `bool`  | `False` | If `True`, saves a hybrid version of labels that combines original annotations with additional model predictions.                                             |
+| `conf`        | `float` | `0.001` | Sets the minimum confidence threshold for detections. Detections with confidence below this threshold are discarded.                                          |
+| `iou`         | `float` | `0.6`   | Sets the Intersection Over Union (IoU) threshold for Non-Maximum Suppression (NMS). Helps in reducing duplicate detections.                                   |
+| `max_det`     | `int`   | `300`   | Limits the maximum number of detections per image. Useful in dense scenes to prevent excessive detections.                                                    |
+| `half`        | `bool`  | `True`  | Enables half-precision (FP16) computation, reducing memory usage and potentially increasing speed with minimal impact on accuracy.                            |
+| `device`      | `str`   | `None`  | Specifies the device for validation (`cpu`, `cuda:0`, etc.). Allows flexibility in utilizing CPU or GPU resources.                                            |
+| `dnn`         | `bool`  | `False` | If `True`, uses the OpenCV DNN module for ONNX model inference, offering an alternative to PyTorch inference methods.                                         |
+| `plots`       | `bool`  | `False` | When set to `True`, generates and saves plots of predictions versus ground truth for visual evaluation of the model's performance.                            |
+| `rect`        | `bool`  | `False` | If `True`, uses rectangular inference for batching, reducing padding and potentially increasing speed and efficiency.                                         |
+| `split`       | `str`   | `val`   | Determines the dataset split to use for validation (`val`, `test`, or `train`). Allows flexibility in choosing the data segment for performance evaluation.   |
+
+Each of these settings plays a vital role in the validation process, allowing for a customizable and efficient evaluation of YOLO models. Adjusting these parameters according to your specific needs and resources can help achieve the best balance between accuracy and performance.
+
+### Example Validation with Arguments
+
+The below examples showcase YOLO model validation with custom arguments in Python and CLI.
+
+!!! Example
+
+    === "Python"
+
+        ```python
+        from ultralytics import YOLO
+        
+        # Load a model
+        model = YOLO('yolov8n.pt')
+        
+        # Customize validation settings
+        validation_results = model.val(data='coco8.yaml',
+                                       imgsz=640,
+                                       batch=16,
+                                       conf=0.25,
+                                       iou=0.6,
+                                       device='0')
+        ```
+
+    === "CLI"
+
+        ```bash
+        yolo val model=yolov8n.pt data=coco8.yaml imgsz=640 batch=16 conf=0.25 iou=0.6 device=0
+        ```

docs/en/quickstart.md

+---
+comments: true
+description: Explore various methods to install Ultralytics using pip, conda, git and Docker. Learn how to use Ultralytics with command line interface or within your Python projects.
+keywords: Ultralytics installation, pip install Ultralytics, Docker install Ultralytics, Ultralytics command line interface, Ultralytics Python interface
+---
+
+## Install Ultralytics
+
+Ultralytics provides various installation methods including pip, conda, and Docker. Install YOLOv8 via the `ultralytics` pip package for the latest stable release or by cloning the [Ultralytics GitHub repository](https://github.com/ultralytics/ultralytics) for the most up-to-date version. Docker can be used to execute the package in an isolated container, avoiding local installation.
+
+<p align="center">
+  <br>
+  <iframe loading="lazy" width="720" height="405" src="https://www.youtube.com/embed/_a7cVL9hqnk"
+    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 YOLO Quick Start Guide
+</p>
+
+!!! Example "Install"
+
+    === "Pip install (recommended)"
+
+        Install the `ultralytics` package using pip, or update an existing installation by running `pip install -U ultralytics`. Visit the Python Package Index (PyPI) for more details on the `ultralytics` package: [https://pypi.org/project/ultralytics/](https://pypi.org/project/ultralytics/).
+
+        [![PyPI version](https://badge.fury.io/py/ultralytics.svg)](https://badge.fury.io/py/ultralytics) [![Downloads](https://static.pepy.tech/badge/ultralytics)](https://pepy.tech/project/ultralytics)
+
+        ```bash
+        # Install the ultralytics package from PyPI
+        pip install ultralytics
+        ```
+
+        You can also install the `ultralytics` package directly from the GitHub [repository](https://github.com/ultralytics/ultralytics). This might be useful if you want the latest development version. Make sure to have the Git command-line tool installed on your system. The `@main` command installs the `main` branch and may be modified to another branch, i.e. `@my-branch`, or removed entirely to default to `main` branch.
+
+        ```bash
+        # Install the ultralytics package from GitHub
+        pip install git+https://github.com/ultralytics/ultralytics.git@main
+        ```
+
+    === "Conda install"
+
+        Conda is an alternative package manager to pip which may also be used for installation. Visit Anaconda for more details at [https://anaconda.org/conda-forge/ultralytics](https://anaconda.org/conda-forge/ultralytics). Ultralytics feedstock repository for updating the conda package is at [https://github.com/conda-forge/ultralytics-feedstock/](https://github.com/conda-forge/ultralytics-feedstock/).
+
+
+        [![Conda Recipe](https://img.shields.io/badge/recipe-ultralytics-green.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics) [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/ultralytics.svg)](https://anaconda.org/conda-forge/ultralytics)
+
+        ```bash
+        # Install the ultralytics package using conda
+        conda install -c conda-forge ultralytics
+        ```
+
+        !!! Note
+
+            If you are installing in a CUDA environment best practice is to install `ultralytics`, `pytorch` and `pytorch-cuda` in the same command to allow the conda package manager to resolve any conflicts, or else to install `pytorch-cuda` last to allow it override the CPU-specific `pytorch` package if necessary.
+            ```bash
+            # Install all packages together using conda
+            conda install -c pytorch -c nvidia -c conda-forge pytorch torchvision pytorch-cuda=11.8 ultralytics
+            ```
+
+        ### Conda Docker Image
+
+        Ultralytics Conda Docker images are also available from [DockerHub](https://hub.docker.com/r/ultralytics/ultralytics). These images are based on [Miniconda3](https://docs.conda.io/projects/miniconda/en/latest/) and are an simple way to start using `ultralytics` in a Conda environment.
+
+        ```bash
+        # Set image name as a variable
+        t=ultralytics/ultralytics:latest-conda
+
+        # Pull the latest ultralytics image from Docker Hub
+        sudo docker pull $t
+
+        # Run the ultralytics image in a container with GPU support
+        sudo docker run -it --ipc=host --gpus all $t  # all GPUs
+        sudo docker run -it --ipc=host --gpus '"device=2,3"' $t  # specify GPUs
+        ```
+
+    === "Git clone"
+        Clone the `ultralytics` repository if you are interested in contributing to the development or wish to experiment with the latest source code. After cloning, navigate into the directory and install the package in editable mode `-e` using pip.
+        ```bash
+        # Clone the ultralytics repository
+        git clone https://github.com/ultralytics/ultralytics
+
+        # Navigate to the cloned directory
+        cd ultralytics
+
+        # Install the package in editable mode for development
+        pip install -e .
+        ```
+
+    === "Docker"
+
+        Utilize Docker to effortlessly execute the `ultralytics` package in an isolated container, ensuring consistent and smooth performance across various environments. By choosing one of the official `ultralytics` images from [Docker Hub](https://hub.docker.com/r/ultralytics/ultralytics), you not only avoid the complexity of local installation but also benefit from access to a verified working environment. Ultralytics offers 5 main supported Docker images, each designed to provide high compatibility and efficiency for different platforms and use cases:
+
+        <a href="https://hub.docker.com/r/ultralytics/ultralytics"><img src="https://img.shields.io/docker/pulls/ultralytics/ultralytics?logo=docker" alt="Docker Pulls"></a>
+
+        - **Dockerfile:** GPU image recommended for training.
+        - **Dockerfile-arm64:** Optimized for ARM64 architecture, allowing deployment on devices like Raspberry Pi and other ARM64-based platforms.
+        - **Dockerfile-cpu:** Ubuntu-based CPU-only version suitable for inference and environments without GPUs.
+        - **Dockerfile-jetson:** Tailored for NVIDIA Jetson devices, integrating GPU support optimized for these platforms.
+        - **Dockerfile-python:** Minimal image with just Python and necessary dependencies, ideal for lightweight applications and development.
+        - **Dockerfile-conda:** Based on Miniconda3 with conda installation of ultralytics package.
+
+        Below are the commands to get the latest image and execute it:
+
+        ```bash
+        # Set image name as a variable
+        t=ultralytics/ultralytics:latest
+
+        # Pull the latest ultralytics image from Docker Hub
+        sudo docker pull $t
+
+        # Run the ultralytics image in a container with GPU support
+        sudo docker run -it --ipc=host --gpus all $t  # all GPUs
+        sudo docker run -it --ipc=host --gpus '"device=2,3"' $t  # specify GPUs
+        ```
+
+        The above command initializes a Docker container with the latest `ultralytics` image. The `-it` flag assigns a pseudo-TTY and maintains stdin open, enabling you to interact with the container. The `--ipc=host` flag sets the IPC (Inter-Process Communication) namespace to the host, which is essential for sharing memory between processes. The `--gpus all` flag enables access to all available GPUs inside the container, which is crucial for tasks that require GPU computation.
+
+        Note: To work with files on your local machine within the container, use Docker volumes for mounting a local directory into the container:
+
+        ```bash
+        # Mount local directory to a directory inside the container
+        sudo docker run -it --ipc=host --gpus all -v /path/on/host:/path/in/container $t
+        ```
+
+        Alter `/path/on/host` with the directory path on your local machine, and `/path/in/container` with the desired path inside the Docker container for accessibility.
+
+        For advanced Docker usage, feel free to explore the [Ultralytics Docker Guide](https://docs.ultralytics.com/guides/docker-quickstart/).
+
+See the `ultralytics` [requirements.txt](https://github.com/ultralytics/ultralytics/blob/main/pyproject.toml) file for a list of dependencies. Note that all examples above install all required dependencies.
+
+!!! Tip "Tip"
+
+    PyTorch requirements vary by operating system and CUDA requirements, so it's recommended to install PyTorch first following instructions at [https://pytorch.org/get-started/locally](https://pytorch.org/get-started/locally).
+
+    <a href="https://pytorch.org/get-started/locally/">
+        <img width="800" alt="PyTorch Installation Instructions" src="https://user-images.githubusercontent.com/26833433/228650108-ab0ec98a-b328-4f40-a40d-95355e8a84e3.png">
+    </a>
+
+## Use Ultralytics with CLI
+
+The Ultralytics command line interface (CLI) allows for simple single-line commands without the need for a Python environment. CLI requires no customization or Python code. You can simply run all tasks from the terminal with the `yolo` command. Check out the [CLI Guide](usage/cli.md) to learn more about using YOLOv8 from the command line.
+
+!!! Example
+
+    === "Syntax"
+
+        Ultralytics `yolo` commands use the following syntax:
+        ```bash
+        yolo TASK MODE ARGS
+        ```
+
+        - `TASK` (optional) is one of ([detect](tasks/detect.md), [segment](tasks/segment.md), [classify](tasks/classify.md), [pose](tasks/pose.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))
+        - `ARGS` (optional) are `arg=value` pairs like `imgsz=640` that override defaults.
+
+        See all `ARGS` in the full [Configuration Guide](usage/cfg.md) or with the `yolo cfg` CLI command.
+
+    === "Train"
+
+        Train a detection model for 10 epochs with an initial learning_rate of 0.01
+        ```bash
+        yolo train data=coco128.yaml model=yolov8n.pt epochs=10 lr0=0.01
+        ```
+
+    === "Predict"
+
+        Predict a YouTube video using a pretrained segmentation model at image size 320:
+        ```bash
+        yolo predict model=yolov8n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+        ```
+
+    === "Val"
+
+        Val a pretrained detection model at batch-size 1 and image size 640:
+        ```bash
+        yolo val model=yolov8n.pt data=coco128.yaml batch=1 imgsz=640
+        ```
+
+    === "Export"
+
+        Export a YOLOv8n classification model to ONNX format at image size 224 by 128 (no TASK required)
+        ```bash
+        yolo export model=yolov8n-cls.pt format=onnx imgsz=224,128
+        ```
+
+    === "Special"
+
+        Run special commands to see version, view settings, run checks and more:
+        ```bash
+        yolo help
+        yolo checks
+        yolo version
+        yolo settings
+        yolo copy-cfg
+        yolo cfg
+        ```
+
+!!! Warning "Warning"
+
+    Arguments must be passed as `arg=val` pairs, split by an equals `=` sign and delimited by spaces between pairs. Do not use `--` argument prefixes or commas `,` between arguments.
+
+    - `yolo predict model=yolov8n.pt imgsz=640 conf=0.25`  ✅
+    - `yolo predict model yolov8n.pt imgsz 640 conf 0.25`  ❌ (missing `=`)
+    - `yolo predict model=yolov8n.pt, imgsz=640, conf=0.25`  ❌ (do not use `,`)
+    - `yolo predict --model yolov8n.pt --imgsz 640 --conf 0.25`  ❌ (do not use `--`)
+
+[CLI Guide](usage/cli.md){ .md-button }
+
+## Use Ultralytics with Python
+
+YOLOv8's Python interface allows for seamless integration into your Python projects, making it easy to load, run, and process the model's output. Designed with simplicity and ease of use in mind, the Python interface enables users to quickly implement object detection, segmentation, and classification in their projects. This makes YOLOv8's Python interface an invaluable tool for anyone looking to incorporate these functionalities into their Python projects.
+
+For example, users can load a model, train it, evaluate its performance on a validation set, and even export it to ONNX format with just a few lines of code. Check out the [Python Guide](usage/python.md) to learn more about using YOLOv8 within your Python projects.
+
+!!! Example
+
+    ```python
+    from ultralytics import YOLO
+
+    # Create a new YOLO model from scratch
+    model = YOLO('yolov8n.yaml')
+
+    # Load a pretrained YOLO model (recommended for training)
+    model = YOLO('yolov8n.pt')
+
+    # Train the model using the 'coco128.yaml' dataset for 3 epochs
+    results = model.train(data='coco128.yaml', epochs=3)
+
+    # Evaluate the model's performance on the validation set
+    results = model.val()
+
+    # Perform object detection on an image using the model
+    results = model('https://ultralytics.com/images/bus.jpg')
+
+    # Export the model to ONNX format
+    success = model.export(format='onnx')
+    ```
+
+[Python Guide](usage/python.md){.md-button .md-button--primary}
+
+## Ultralytics Settings
+
+The Ultralytics library provides a powerful settings management system to enable fine-grained control over your experiments. By making use of the `SettingsManager` housed within the `ultralytics.utils` module, users can readily access and alter their settings. These are stored in a YAML file and can be viewed or modified either directly within the Python environment or via the Command-Line Interface (CLI).
+
+### Inspecting Settings
+
+To gain insight into the current configuration of your settings, you can view them directly:
+
+!!! Example "View settings"
+
+    === "Python"
+        You can use Python to view your settings. Start by importing the `settings` object from the `ultralytics` module. Print and return settings using the following commands:
+        ```python
+        from ultralytics import settings
+
+        # View all settings
+        print(settings)
+
+        # Return a specific setting
+        value = settings['runs_dir']
+        ```
+
+    === "CLI"
+        Alternatively, the command-line interface allows you to check your settings with a simple command:
+        ```bash
+        yolo settings
+        ```
+
+### Modifying Settings
+
+Ultralytics allows users to easily modify their settings. Changes can be performed in the following ways:
+
+!!! Example "Update settings"
+
+    === "Python"
+        Within the Python environment, call the `update` method on the `settings` object to change your settings:
+        ```python
+        from ultralytics import settings
+
+        # Update a setting
+        settings.update({'runs_dir': '/path/to/runs'})
+
+        # Update multiple settings
+        settings.update({'runs_dir': '/path/to/runs', 'tensorboard': False})
+
+        # Reset settings to default values
+        settings.reset()
+        ```
+
+    === "CLI"
+        If you prefer using the command-line interface, the following commands will allow you to modify your settings:
+        ```bash
+        # Update a setting
+        yolo settings runs_dir='/path/to/runs'
+
+        # Update multiple settings
+        yolo settings runs_dir='/path/to/runs' tensorboard=False
+
+        # Reset settings to default values
+        yolo settings reset
+        ```
+
+### Understanding Settings
+
+The table below provides an overview of the settings available for adjustment within Ultralytics. Each setting is outlined along with an example value, the data type, and a brief description.
+
+| Name               | Example Value         | Data Type | Description                                                                                                      |
+|--------------------|-----------------------|-----------|------------------------------------------------------------------------------------------------------------------|
+| `settings_version` | `'0.0.4'`             | `str`     | Ultralytics _settings_ version (different from Ultralytics [pip](https://pypi.org/project/ultralytics/) version) |
+| `datasets_dir`     | `'/path/to/datasets'` | `str`     | The directory where the datasets are stored                                                                      |
+| `weights_dir`      | `'/path/to/weights'`  | `str`     | The directory where the model weights are stored                                                                 |
+| `runs_dir`         | `'/path/to/runs'`     | `str`     | The directory where the experiment runs are stored                                                               |
+| `uuid`             | `'a1b2c3d4'`          | `str`     | The unique identifier for the current settings                                                                   |
+| `sync`             | `True`                | `bool`    | Whether to sync analytics and crashes to HUB                                                                     |
+| `api_key`          | `''`                  | `str`     | Ultralytics HUB [API Key](https://hub.ultralytics.com/settings?tab=api+keys)                                     |
+| `clearml`          | `True`                | `bool`    | Whether to use ClearML logging                                                                                   |
+| `comet`            | `True`                | `bool`    | Whether to use [Comet ML](https://bit.ly/yolov8-readme-comet) for experiment tracking and visualization          |
+| `dvc`              | `True`                | `bool`    | Whether to use [DVC for experiment tracking](https://dvc.org/doc/dvclive/ml-frameworks/yolo) and version control |
+| `hub`              | `True`                | `bool`    | Whether to use [Ultralytics HUB](https://hub.ultralytics.com) integration                                        |
+| `mlflow`           | `True`                | `bool`    | Whether to use MLFlow for experiment tracking                                                                    |
+| `neptune`          | `True`                | `bool`    | Whether to use Neptune for experiment tracking                                                                   |
+| `raytune`          | `True`                | `bool`    | Whether to use Ray Tune for hyperparameter tuning                                                                |
+| `tensorboard`      | `True`                | `bool`    | Whether to use TensorBoard for visualization                                                                     |
+| `wandb`            | `True`                | `bool`    | Whether to use Weights & Biases logging                                                                          |
+
+As you navigate through your projects or experiments, be sure to revisit these settings to ensure that they are optimally configured for your needs.

docs/en/reference/cfg/__init__.md

+---
+description: Explore Ultralytics cfg functions like cfg2dict, handle_deprecation, merge_equal_args & more to handle YOLO settings and configurations efficiently.
+keywords: Ultralytics, YOLO, Configuration, cfg2dict, handle_deprecation, merge_equals_args, handle_yolo_settings, copy_default_cfg, Image Detection
+---
+
+# Reference for `ultralytics/cfg/__init__.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/__init__.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/__init__.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/cfg/__init__.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.cfg.cfg2dict
+
+<br><br>
+
+## ::: ultralytics.cfg.get_cfg
+
+<br><br>
+
+## ::: ultralytics.cfg.check_cfg
+
+<br><br>
+
+## ::: ultralytics.cfg.get_save_dir
+
+<br><br>
+
+## ::: ultralytics.cfg._handle_deprecation
+
+<br><br>
+
+## ::: ultralytics.cfg.check_dict_alignment
+
+<br><br>
+
+## ::: ultralytics.cfg.merge_equals_args
+
+<br><br>
+
+## ::: ultralytics.cfg.handle_yolo_hub
+
+<br><br>
+
+## ::: ultralytics.cfg.handle_yolo_settings
+
+<br><br>
+
+## ::: ultralytics.cfg.handle_explorer
+
+<br><br>
+
+## ::: ultralytics.cfg.parse_key_value_pair
+
+<br><br>
+
+## ::: ultralytics.cfg.smart_value
+
+<br><br>
+
+## ::: ultralytics.cfg.entrypoint
+
+<br><br>
+
+## ::: ultralytics.cfg.copy_default_cfg
+
+<br><br>

docs/en/reference/data/annotator.md

+---
+description: Enhance your machine learning model with Ultralytics’ auto_annotate function. Simplify data annotation for improved model training.
+keywords: Ultralytics, Auto-Annotate, Machine Learning, AI, Annotation, Data Processing, Model Training
+---
+
+# Reference for `ultralytics/data/annotator.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/annotator.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/annotator.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/annotator.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.annotator.auto_annotate
+
+<br><br>

docs/en/reference/data/augment.md

+---
+description: Detailed exploration into Ultralytics data augmentation methods including BaseTransform, MixUp, LetterBox, ToTensor, and more for enhancing model performance.
+keywords: Ultralytics, Data Augmentation, BaseTransform, MixUp, RandomHSV, LetterBox, Albumentations, classify_transforms, classify_albumentations
+---
+
+# Reference for `ultralytics/data/augment.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/augment.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/augment.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/augment.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.augment.BaseTransform
+
+<br><br>
+
+## ::: ultralytics.data.augment.Compose
+
+<br><br>
+
+## ::: ultralytics.data.augment.BaseMixTransform
+
+<br><br>
+
+## ::: ultralytics.data.augment.Mosaic
+
+<br><br>
+
+## ::: ultralytics.data.augment.MixUp
+
+<br><br>
+
+## ::: ultralytics.data.augment.RandomPerspective
+
+<br><br>
+
+## ::: ultralytics.data.augment.RandomHSV
+
+<br><br>
+
+## ::: ultralytics.data.augment.RandomFlip
+
+<br><br>
+
+## ::: ultralytics.data.augment.LetterBox
+
+<br><br>
+
+## ::: ultralytics.data.augment.CopyPaste
+
+<br><br>
+
+## ::: ultralytics.data.augment.Albumentations
+
+<br><br>
+
+## ::: ultralytics.data.augment.Format
+
+<br><br>
+
+## ::: ultralytics.data.augment.ClassifyLetterBox
+
+<br><br>
+
+## ::: ultralytics.data.augment.CenterCrop
+
+<br><br>
+
+## ::: ultralytics.data.augment.ToTensor
+
+<br><br>
+
+## ::: ultralytics.data.augment.v8_transforms
+
+<br><br>
+
+## ::: ultralytics.data.augment.classify_transforms
+
+<br><br>
+
+## ::: ultralytics.data.augment.classify_augmentations
+
+<br><br>

docs/en/reference/data/base.md

+---
+description: Explore BaseDataset in Ultralytics docs. Learn how this implementation simplifies dataset creation and manipulation.
+keywords: Ultralytics, docs, BaseDataset, data manipulation, dataset creation
+---
+
+# Reference for `ultralytics/data/base.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/base.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/base.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/base.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.base.BaseDataset
+
+<br><br>

docs/en/reference/data/build.md

+---
+description: Explore the Ultralytics YOLO v3 data build procedures, including the InfiniteDataLoader, seed_worker, build_dataloader, and load_inference_source.
+keywords: Ultralytics, YOLO v3, Data build, DataLoader, InfiniteDataLoader, seed_worker, build_dataloader, load_inference_source
+---
+
+# Reference for `ultralytics/data/build.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/build.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/build.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/build.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.build.InfiniteDataLoader
+
+<br><br>
+
+## ::: ultralytics.data.build._RepeatSampler
+
+<br><br>
+
+## ::: ultralytics.data.build.seed_worker
+
+<br><br>
+
+## ::: ultralytics.data.build.build_yolo_dataset
+
+<br><br>
+
+## ::: ultralytics.data.build.build_dataloader
+
+<br><br>
+
+## ::: ultralytics.data.build.check_source
+
+<br><br>
+
+## ::: ultralytics.data.build.load_inference_source
+
+<br><br>

docs/en/reference/data/converter.md

+---
+description: Explore Ultralytics data converter functions like coco91_to_coco80_class, merge_multi_segment, rle2polygon for efficient data handling.
+keywords: Ultralytics, Data Converter, coco91_to_coco80_class, merge_multi_segment, rle2polygon
+---
+
+# Reference for `ultralytics/data/converter.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/converter.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/converter.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/converter.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.converter.coco91_to_coco80_class
+
+<br><br>
+
+## ::: ultralytics.data.converter.coco80_to_coco91_class
+
+<br><br>
+
+## ::: ultralytics.data.converter.convert_coco
+
+<br><br>
+
+## ::: ultralytics.data.converter.convert_dota_to_yolo_obb
+
+<br><br>
+
+## ::: ultralytics.data.converter.min_index
+
+<br><br>
+
+## ::: ultralytics.data.converter.merge_multi_segment
+
+<br><br>
+
+## ::: ultralytics.data.converter.yolo_bbox2segment
+
+<br><br>

docs/en/reference/data/dataset.md

+---
+description: Explore the YOLODataset and SemanticDataset classes in YOLO data. Learn how to efficiently handle and manipulate your data with Ultralytics.
+keywords: Ultralytics, YOLO, YOLODataset, SemanticDataset, data handling, data manipulation
+---
+
+# Reference for `ultralytics/data/dataset.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/dataset.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/dataset.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/dataset.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.dataset.YOLODataset
+
+<br><br>
+
+## ::: ultralytics.data.dataset.ClassificationDataset
+
+<br><br>
+
+## ::: ultralytics.data.dataset.SemanticDataset
+
+<br><br>
+
+## ::: ultralytics.data.dataset.load_dataset_cache_file
+
+<br><br>
+
+## ::: ultralytics.data.dataset.save_dataset_cache_file
+
+<br><br>

docs/en/reference/data/explorer/explorer.md

+---
+comments: true
+description: Comprehensive reference for the Explorer API. Get a brief description of all the main classes utilised for creating and handling the data in the Ultralytics data explorer project.
+keywords: Ultralytics, explorer.py, data explorer, Semantic search, vector similarity search, class reference, documentation, ExplorerDataset, Explorer, data handling
+---
+
+# Reference for `ultralytics/data/explorer/explorer.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/explorer/explorer.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/explorer/explorer.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/explorer/explorer.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.explorer.explorer.ExplorerDataset
+
+<br><br>
+
+## ::: ultralytics.data.explorer.explorer.Explorer
+
+<br><br>

docs/en/reference/data/explorer/gui/dash.md

+---
+comments: true
+description: Detailed reference for the Explorer GUI. Includes brief descriptions for all the major functions used in the dashboard demo of Explorer API.
+keywords: Ultralytics, data explorer, gui, function reference, documentation, AI queries, image similarity, SQL queries, streamlit, semantic search
+---
+
+# Reference for `ultralytics/data/explorer/gui/dash.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/explorer/gui/dash.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/explorer/gui/dash.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/explorer/gui/dash.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash._get_explorer
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.init_explorer_form
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.query_form
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.ai_query_form
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.find_similar_imgs
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.similarity_form
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.run_sql_query
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.run_ai_query
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.reset_explorer
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.utralytics_explorer_docs_callback
+
+<br><br>
+
+## ::: ultralytics.data.explorer.gui.dash.layout
+
+<br><br>

docs/en/reference/data/explorer/utils.md

+---
+comments: true
+description: Detailed reference for the Explorer utils. Provides descriptions and details on important utility functions for managing and interacting with data in the Ultralytics explorer project.
+keywords: Ultralytics, data explorer, function reference, documentation, get table schema, get sim index schema, sanitize batch, plot query result, prompt SQL query
+---
+
+# Reference for `ultralytics/data/explorer/utils.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/explorer/utils.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/explorer/utils.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/explorer/utils.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.explorer.utils.get_table_schema
+
+<br><br>
+
+## ::: ultralytics.data.explorer.utils.get_sim_index_schema
+
+<br><br>
+
+## ::: ultralytics.data.explorer.utils.sanitize_batch
+
+<br><br>
+
+## ::: ultralytics.data.explorer.utils.plot_query_result
+
+<br><br>
+
+## ::: ultralytics.data.explorer.utils.prompt_sql_query
+
+<br><br>

docs/en/reference/data/loaders.md

+---
+description: Find detailed guides on Ultralytics YOLO data loaders, including LoadStreams, LoadImages and LoadTensor. Learn how to get the best YouTube URLs.
+keywords: Ultralytics, data loaders, LoadStreams, LoadImages, LoadTensor, YOLO, YouTube URLs
+---
+
+# Reference for `ultralytics/data/loaders.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/loaders.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/loaders.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/loaders.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.loaders.SourceTypes
+
+<br><br>
+
+## ::: ultralytics.data.loaders.LoadStreams
+
+<br><br>
+
+## ::: ultralytics.data.loaders.LoadScreenshots
+
+<br><br>
+
+## ::: ultralytics.data.loaders.LoadImagesAndVideos
+
+<br><br>
+
+## ::: ultralytics.data.loaders.LoadPilAndNumpy
+
+<br><br>
+
+## ::: ultralytics.data.loaders.LoadTensor
+
+<br><br>
+
+## ::: ultralytics.data.loaders.autocast_list
+
+<br><br>
+
+## ::: ultralytics.data.loaders.get_best_youtube_url
+
+<br><br>

docs/en/reference/data/split_dota.md

+---
+description: Detailed guide on using YOLO with DOTA dataset for object detection, including dataset preparation, image splitting, and label handling.
+keywords: Ultralytics, YOLO, DOTA dataset, object detection, image processing, python, dataset preparation, image splitting, label handling, YOLO with DOTA, computer vision, AI, machine learning
+---
+
+# Reference for `ultralytics/data/split_dota.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/split_dota.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/split_dota.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/split_dota.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.split_dota.bbox_iof
+
+<br><br>
+
+## ::: ultralytics.data.split_dota.load_yolo_dota
+
+<br><br>
+
+## ::: ultralytics.data.split_dota.get_windows
+
+<br><br>
+
+## ::: ultralytics.data.split_dota.get_window_obj
+
+<br><br>
+
+## ::: ultralytics.data.split_dota.crop_and_save
+
+<br><br>
+
+## ::: ultralytics.data.split_dota.split_images_and_labels
+
+<br><br>
+
+## ::: ultralytics.data.split_dota.split_trainval
+
+<br><br>
+
+## ::: ultralytics.data.split_dota.split_test
+
+<br><br>

docs/en/reference/data/utils.md

+---
+description: Uncover a detailed guide to Ultralytics data utilities. Learn functions from img2label_paths to autosplit, all boosting your YOLO model’s efficiency.
+keywords: Ultralytics, data utils, YOLO, img2label_paths, exif_size, polygon2mask, polygons2masks_overlap, check_cls_dataset, delete_dsstore, autosplit
+---
+
+# Reference for `ultralytics/data/utils.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/utils.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/data/utils.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/data/utils.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.data.utils.HUBDatasetStats
+
+<br><br>
+
+## ::: ultralytics.data.utils.img2label_paths
+
+<br><br>
+
+## ::: ultralytics.data.utils.get_hash
+
+<br><br>
+
+## ::: ultralytics.data.utils.exif_size
+
+<br><br>
+
+## ::: ultralytics.data.utils.verify_image
+
+<br><br>
+
+## ::: ultralytics.data.utils.verify_image_label
+
+<br><br>
+
+## ::: ultralytics.data.utils.polygon2mask
+
+<br><br>
+
+## ::: ultralytics.data.utils.polygons2masks
+
+<br><br>
+
+## ::: ultralytics.data.utils.polygons2masks_overlap
+
+<br><br>
+
+## ::: ultralytics.data.utils.find_dataset_yaml
+
+<br><br>
+
+## ::: ultralytics.data.utils.check_det_dataset
+
+<br><br>
+
+## ::: ultralytics.data.utils.check_cls_dataset
+
+<br><br>
+
+## ::: ultralytics.data.utils.compress_one_image
+
+<br><br>
+
+## ::: ultralytics.data.utils.autosplit
+
+<br><br>

docs/en/reference/engine/exporter.md

+---
+description: Explore the exporter functionality of Ultralytics. Learn about exporting formats, IOSDetectModel, and try exporting with examples.
+keywords: Ultralytics, Exporter, IOSDetectModel, Export Formats, Try export
+---
+
+# Reference for `ultralytics/engine/exporter.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/exporter.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/exporter.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/exporter.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.engine.exporter.Exporter
+
+<br><br>
+
+## ::: ultralytics.engine.exporter.IOSDetectModel
+
+<br><br>
+
+## ::: ultralytics.engine.exporter.export_formats
+
+<br><br>
+
+## ::: ultralytics.engine.exporter.gd_outputs
+
+<br><br>
+
+## ::: ultralytics.engine.exporter.try_export
+
+<br><br>

docs/en/reference/engine/model.md

+---
+description: Explore the detailed guide on using the Ultralytics YOLO Engine Model. Learn better ways to implement, train and evaluate YOLO models.
+keywords: Ultralytics, YOLO, engine model, documentation, guide, implementation, training, evaluation
+---
+
+# Reference for `ultralytics/engine/model.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/model.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/model.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/model.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.engine.model.Model
+
+<br><br>

docs/en/reference/engine/predictor.md

+---
+description: Learn about Ultralytics BasePredictor, an essential component of our engine that serves as the foundation for all prediction operations.
+keywords: Ultralytics, BasePredictor, YOLO, prediction, engine
+---
+
+# Reference for `ultralytics/engine/predictor.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/predictor.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/predictor.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/predictor.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.engine.predictor.BasePredictor
+
+<br><br>

docs/en/reference/engine/results.md

+---
+description: Master Ultralytics engine results including base tensors, boxes, and keypoints with our thorough documentation.
+keywords: Ultralytics, engine, results, base tensor, boxes, keypoints
+---
+
+# Reference for `ultralytics/engine/results.py`
+
+!!! Note
+
+    This file is available at [https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/results.py](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/engine/results.py). If you spot a problem please help fix it by [contributing](https://docs.ultralytics.com/help/contributing/) a [Pull Request](https://github.com/ultralytics/ultralytics/edit/main/ultralytics/engine/results.py) 🛠️. Thank you 🙏!
+
+<br><br>
+
+## ::: ultralytics.engine.results.BaseTensor
+
+<br><br>
+
+## ::: ultralytics.engine.results.Results
+
+<br><br>
+
+## ::: ultralytics.engine.results.Boxes
+
+<br><br>
+
+## ::: ultralytics.engine.results.Masks
+
+<br><br>
+
+## ::: ultralytics.engine.results.Keypoints
+
+<br><br>
+
+## ::: ultralytics.engine.results.Probs
+
+<br><br>
+
+## ::: ultralytics.engine.results.OBB
+
+<br><br>