Model Training with Ultralytics YOLO#

Giới thiệu#

Training a deep learning model involves feeding it data and adjusting its parameters so that it can make accurate predictions. Train mode in Ultralytics YOLO26 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 YOLO26's robust set of features. If you haven't installed Ultralytics yet, start with the Quickstart guide.

Xem bản xem trước YOLO27 chưa phát hành để biết các ví dụ huấn luyện được lên kế hoạch.

Why Choose Ultralytics YOLO for Training?#

Here are some compelling reasons to opt for YOLO26'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. For deeper control, you can customize the trainer itself.
• Cloud Training: Train on cloud GPUs through Ultralytics Platform with real-time metrics and automatic checkpointing.

Key Features of Train Mode#

The following are some notable features of YOLO26's Train mode:

• Automatic Dataset Download: Dataset configurations with a download source are downloaded automatically on first use, e.g., yolo train data=coco8.yaml. See the Datasets overview for supported formats and datasets.
• 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.

Ví dụ sử dụng#

Train YOLO26n on the COCO8 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 when available; otherwise device='cpu' will be used. See the Arguments section below for a full list of training arguments.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.yaml")  # build a new model from YAML
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n.yaml").load("yolo26n.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="coco8.yaml", 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.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model with 2 GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

# Train the model with the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

python -m torch.distributed.run --nproc_per_node 2 your_training_script.py

Huấn luyện GPU AMD sử dụng bản dựng PyTorch ROCm với cú pháp chuẩn device=0 hoặc device=cuda:0. Xem hướng dẫn tích hợp AMD để biết hướng dẫn cài đặt và trạng thái hỗ trợ MIGraphX, DirectML và Ryzen AI NPU hiện tại.

Intel GPU training uses device=xpu:0, or multiple XPU IDs with a PyTorch build that provides XCCL.

Huawei Ascend NPU Training#

Ultralytics hỗ trợ huấn luyện và xác thực trên NPU Huawei Ascend thông qua torch_npu. Cài đặt các phiên bản CANN, PyTorch và torch_npu tương thích lẫn nhau bằng cách làm theo hướng dẫn cài đặt Tiện ích mở rộng Ascend cho PyTorch, sau đó nạp môi trường CANN trước khi khởi động Ultralytics:

source /usr/local/Ascend/ascend-toolkit/set_env.sh

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Train on one Ascend NPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")

# Train across two Ascend NPUs with HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")

Các tính năng huấn luyện tiêu chuẩn, bao gồm AMP, xác thực, tạo checkpoint và khôi phục, sử dụng NPU đang hoạt động. AutoBatch khả dụng cho việc huấn luyện trên một NPU duy nhất, trong khi nhiều ID NPU khởi chạy huấn luyện phân tán thông qua HCCL. Xem hướng dẫn tích hợp Huawei Ascend để xuất model và triển khai sau khi huấn luyện.

Idle GPU Training#

Idle GPU Training enables automatic selection of the least utilized GPUs in multi-GPU systems, optimizing resource usage without manual GPU selection. This feature identifies available GPUs based on utilization metrics and VRAM availability.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train using the single most idle GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)

# Train using the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])

The auto-selection algorithm prioritizes GPUs with:

1. Lower current utilization percentages
2. Higher available memory (free VRAM)
3. Lower temperature and power consumption

This feature is especially valuable in shared computing environments or when running multiple training jobs across different models. It automatically adapts to changing system conditions, ensuring optimal resource allocation without manual intervention.

Apple Silicon MPS Training#

With the support for Apple silicon 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 silicon 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:

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load a pretrained model (recommended for training)

# Train the model with MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")

While leveraging the computational power of the Apple silicon 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.

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.

Khi tiếp tục quá trình huấn luyện, Ultralytics YOLO tải trọng số từ model đã lưu gần nhất và cũng khôi phục trạng thái bộ tối ưu hóa, bộ lập lịch learning rate, số epoch và dataset. Điều này cho phép bạn tiếp tục quá trình huấn luyện một cách liền mạch từ điểm dừng trước đó. Truyền một data= rõ ràng bên cạnh resume để tiếp tục trên một dataset khác thay vì trên checkpoint.

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:

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)

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 intervals using the save_period argument, so you must complete at least 1 epoch to resume a training run.

Thiết lập Train#

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.

Optimizer MuSGD#

In YOLO26, MuSGD is a hybrid optimizer that combines standard SGD updates with Muon-style orthogonalized updates.

It is recommended for longer YOLO26 training runs and larger datasets, where orthogonalized Muon updates can help stabilize optimization.

Only 2D linear weights and 4D convolutional filters (reshaped to 2D) receive the Muon style update together with SGD, while all other parameters, such as batch normalization weights and bias terms, remain on standard SGD.

When optimizer=auto is used, Ultralytics automatically selects MuSGD for longer training runs (typically when iterations > 10000). For shorter runs, the trainer falls back to AdamW.

Example usage:

yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGD

See the implementation in ultralytics/optim/muon.py and the optimizer auto-selection logic in BaseTrainer.build_optimizer.

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:

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.

Ghi log#

Các chỉ số huấn luyện, biểu đồ và điểm kiểm tra (checkpoint) luôn được ghi vào thư mục chạy, đồng thời Ultralytics cũng truyền phát chúng tới bất kỳ trình theo dõi thí nghiệm nào bạn đã cài đặt và bật: Comet, ClearML, TensorBoard, MLflow, Weights & Biases và DVCLive. Mỗi trình ghi nhật ký được bật tắt thông qua cài đặt Ultralytics, ví dụ như yolo settings tensorboard=True. Ba thiết lập phổ biến nhất được hiển thị bên dưới.

Comet#

Comet 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:

# 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 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:

# 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 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:

%load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directory

To use TensorBoard locally run the below command and view results at localhost:6006.

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.

Tiếp theo là gì?#

Validate your trained model against held-out data to check its real-world accuracy, then export it to ONNX, TensorRT, or another deployment format. Training on your own data instead of COCO8? Format it first with the Datasets guide.

FAQ#