From 137552996a0aaeb90fa0c1d6da40f012f8801a00 Mon Sep 17 00:00:00 2001 From: Glenn Jocher Date: Thu, 22 Jun 2023 00:58:37 +0200 Subject: [PATCH] `ultralytics 8.0.121` RTDETR fix and Docs updates (#3314) --- docs/models/yolov5.md | 2 +- docs/models/yolov8.md | 2 +- docs/modes/train.md | 104 ++++++++++++++++++++++++---- ultralytics/__init__.py | 2 +- ultralytics/yolo/utils/downloads.py | 1 + 5 files changed, 96 insertions(+), 15 deletions(-) diff --git a/docs/models/yolov5.md b/docs/models/yolov5.md index 959c06a..884fea6 100644 --- a/docs/models/yolov5.md +++ b/docs/models/yolov5.md @@ -75,7 +75,7 @@ If you use YOLOv5 or YOLOv5u in your research, please cite the Ultralytics YOLOv ```bibtex @software{yolov5, - title = {YOLOv5 by Ultralytics}, + title = {Ultralytics YOLOv5}, author = {Glenn Jocher}, year = {2020}, version = {7.0}, diff --git a/docs/models/yolov8.md b/docs/models/yolov8.md index 8c78d87..8907248 100644 --- a/docs/models/yolov8.md +++ b/docs/models/yolov8.md @@ -103,7 +103,7 @@ If you use the YOLOv8 model or any other software from this repository in your w ```bibtex @software{yolov8_ultralytics, author = {Glenn Jocher and Ayush Chaurasia and Jing Qiu}, - title = {YOLO by Ultralytics}, + title = {Ultralytics YOLOv8}, version = {8.0.0}, year = {2023}, url = {https://github.com/ultralytics/ultralytics}, diff --git a/docs/modes/train.md b/docs/modes/train.md index 882c0d1..16c32ef 100644 --- a/docs/modes/train.md +++ b/docs/modes/train.md @@ -6,9 +6,7 @@ keywords: YOLOv8, train mode, train a custom YOLOv8 model, hyperparameters, trai -**Train mode** is used for training a YOLOv8 model on a custom dataset. In this mode, the model is trained using the -specified dataset and hyperparameters. The training process involves optimizing the model's parameters so that it can -accurately predict the classes and locations of objects in an image. +**Train mode** is used for training a YOLOv8 model on a custom dataset. In this mode, the model is trained using the specified dataset and hyperparameters. The training process involves optimizing the model's parameters so that it can accurately predict the classes and locations of objects in an image. !!! tip "Tip" @@ -16,10 +14,11 @@ accurately predict the classes and locations of objects in an image. ## Usage Examples -Train YOLOv8n on the COCO128 dataset for 100 epochs at image size 640. See Arguments section below for a full list of -training arguments. +Train YOLOv8n on the COCO128 dataset for 100 epochs at image size 640. See Arguments section below for a full list of training arguments. -!!! example "" +!!! 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" @@ -47,14 +46,95 @@ training arguments. yolo detect train data=coco128.yaml model=yolov8n.yaml pretrained=yolov8n.pt epochs=100 imgsz=640 ``` +### Multi-GPU Training + +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. + +!!! example "Multi-GPU 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 + 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 + 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 + 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. + ## Arguments -Training settings for YOLO models refer to the various hyperparameters and configurations used to train the model on a -dataset. These settings can affect the model's performance, speed, and accuracy. Some common YOLO training settings -include the batch size, learning rate, momentum, and weight decay. Other factors that may affect the training process -include the choice of optimizer, the choice of loss function, and the size and composition of the training dataset. It -is important to carefully tune and experiment with these settings to achieve the best possible performance for a given -task. +Training settings for YOLO models refer to the various hyperparameters and configurations used to train the model on a dataset. These settings can affect the model's performance, speed, and accuracy. Some common YOLO training settings include the batch size, learning rate, momentum, and weight decay. Other factors that may affect the training process include the choice of optimizer, the choice of loss function, and the size and composition of the training dataset. It is important to carefully tune and experiment with these settings to achieve the best possible performance for a given task. | Key | Value | Description | |-------------------|----------|-----------------------------------------------------------------------------------| diff --git a/ultralytics/__init__.py b/ultralytics/__init__.py index 759641f..4c48d71 100644 --- a/ultralytics/__init__.py +++ b/ultralytics/__init__.py @@ -1,6 +1,6 @@ # Ultralytics YOLO 🚀, AGPL-3.0 license -__version__ = '8.0.120' +__version__ = '8.0.121' from ultralytics.hub import start from ultralytics.vit.rtdetr import RTDETR diff --git a/ultralytics/yolo/utils/downloads.py b/ultralytics/yolo/utils/downloads.py index c69b18f..64f7329 100644 --- a/ultralytics/yolo/utils/downloads.py +++ b/ultralytics/yolo/utils/downloads.py @@ -18,6 +18,7 @@ from ultralytics.yolo.utils import LOGGER, checks, clean_url, emojis, is_online, GITHUB_ASSET_NAMES = [f'yolov8{k}{suffix}.pt' for k in 'nsmlx' for suffix in ('', '6', '-cls', '-seg', '-pose')] + \ [f'yolov5{k}u.pt' for k in 'nsmlx'] + \ [f'yolov3{k}u.pt' for k in ('', '-spp', '-tiny')] + \ + [f'yolo_nas_{k}.pt' for k in 'sml'] + \ [f'sam_{k}.pt' for k in 'bl'] + \ [f'rtdetr-{k}.pt' for k in 'lx'] GITHUB_ASSET_STEMS = [Path(k).stem for k in GITHUB_ASSET_NAMES]