Update YOLO11 Actions and Docs (#16596)
Signed-off-by: UltralyticsAssistant <web@ultralytics.com>
This commit is contained in:
Ultralytics Assistant
GitHub
parent
51e93d6111
commit
97f38409fb
124 changed files with 1948 additions and 1948 deletions
|
|
@ -36,7 +36,7 @@ To train a YOLO model on the Caltech-101 dataset for 100 epochs, you can use the
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="caltech101", epochs=100, imgsz=416)
|
||||
|
|
@ -46,7 +46,7 @@ To train a YOLO model on the Caltech-101 dataset for 100 epochs, you can use the
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=caltech101 model=yolov8n-cls.pt epochs=100 imgsz=416
|
||||
yolo classify train data=caltech101 model=yolo11n-cls.pt epochs=100 imgsz=416
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -98,7 +98,7 @@ To train an Ultralytics YOLO model on the Caltech-101 dataset, you can use the p
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="caltech101", epochs=100, imgsz=416)
|
||||
|
|
@ -108,7 +108,7 @@ To train an Ultralytics YOLO model on the Caltech-101 dataset, you can use the p
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=caltech101 model=yolov8n-cls.pt epochs=100 imgsz=416
|
||||
yolo classify train data=caltech101 model=yolo11n-cls.pt epochs=100 imgsz=416
|
||||
```
|
||||
|
||||
For more detailed arguments and options, refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ To train a YOLO model on the Caltech-256 dataset for 100 epochs, you can use the
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="caltech256", epochs=100, imgsz=416)
|
||||
|
|
@ -57,7 +57,7 @@ To train a YOLO model on the Caltech-256 dataset for 100 epochs, you can use the
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=caltech256 model=yolov8n-cls.pt epochs=100 imgsz=416
|
||||
yolo classify train data=caltech256 model=yolo11n-cls.pt epochs=100 imgsz=416
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -106,7 +106,7 @@ To train a YOLO model on the Caltech-256 dataset for 100 [epochs](https://www.ul
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="caltech256", epochs=100, imgsz=416)
|
||||
|
|
@ -116,7 +116,7 @@ To train a YOLO model on the Caltech-256 dataset for 100 [epochs](https://www.ul
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=caltech256 model=yolov8n-cls.pt epochs=100 imgsz=416
|
||||
yolo classify train data=caltech256 model=yolo11n-cls.pt epochs=100 imgsz=416
|
||||
```
|
||||
|
||||
### What are the most common use cases for the Caltech-256 dataset?
|
||||
|
|
@ -141,6 +141,6 @@ Ultralytics YOLO models offer several advantages for training on the Caltech-256
|
|||
- **High Accuracy**: YOLO models are known for their state-of-the-art performance in object detection tasks.
|
||||
- **Speed**: They provide real-time inference capabilities, making them suitable for applications requiring quick predictions.
|
||||
- **Ease of Use**: With Ultralytics HUB, users can train, validate, and deploy models without extensive coding.
|
||||
- **Pretrained Models**: Starting from pretrained models, like `yolov8n-cls.pt`, can significantly reduce training time and improve model [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
- **Pretrained Models**: Starting from pretrained models, like `yolo11n-cls.pt`, can significantly reduce training time and improve model [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
|
||||
For more details, explore our [comprehensive training guide](../../modes/train.md).
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ The [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) (Canadian Institute
|
|||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to Train an <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> Model with CIFAR-10 Dataset using Ultralytics YOLOv8
|
||||
<strong>Watch:</strong> How to Train an <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> Model with CIFAR-10 Dataset using Ultralytics YOLO11
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
|
@ -50,7 +50,7 @@ To train a YOLO model on the CIFAR-10 dataset for 100 epochs with an image size
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="cifar10", epochs=100, imgsz=32)
|
||||
|
|
@ -60,7 +60,7 @@ To train a YOLO model on the CIFAR-10 dataset for 100 epochs with an image size
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=cifar10 model=yolov8n-cls.pt epochs=100 imgsz=32
|
||||
yolo classify train data=cifar10 model=yolo11n-cls.pt epochs=100 imgsz=32
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -104,7 +104,7 @@ To train a YOLO model on the CIFAR-10 dataset using Ultralytics, you can follow
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="cifar10", epochs=100, imgsz=32)
|
||||
|
|
@ -114,7 +114,7 @@ To train a YOLO model on the CIFAR-10 dataset using Ultralytics, you can follow
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=cifar10 model=yolov8n-cls.pt epochs=100 imgsz=32
|
||||
yolo classify train data=cifar10 model=yolo11n-cls.pt epochs=100 imgsz=32
|
||||
```
|
||||
|
||||
For more details, refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ To train a YOLO model on the CIFAR-100 dataset for 100 [epochs](https://www.ultr
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="cifar100", epochs=100, imgsz=32)
|
||||
|
|
@ -49,7 +49,7 @@ To train a YOLO model on the CIFAR-100 dataset for 100 [epochs](https://www.ultr
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=cifar100 model=yolov8n-cls.pt epochs=100 imgsz=32
|
||||
yolo classify train data=cifar100 model=yolo11n-cls.pt epochs=100 imgsz=32
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -97,7 +97,7 @@ You can train a YOLO model on the CIFAR-100 dataset using either Python or CLI c
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="cifar100", epochs=100, imgsz=32)
|
||||
|
|
@ -107,7 +107,7 @@ You can train a YOLO model on the CIFAR-100 dataset using either Python or CLI c
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=cifar100 model=yolov8n-cls.pt epochs=100 imgsz=32
|
||||
yolo classify train data=cifar100 model=yolo11n-cls.pt epochs=100 imgsz=32
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, please refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ The [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset is
|
|||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> How to do <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> on Fashion MNIST Dataset using Ultralytics YOLOv8
|
||||
<strong>Watch:</strong> How to do <a href="https://www.ultralytics.com/glossary/image-classification">Image Classification</a> on Fashion MNIST Dataset using Ultralytics YOLO11
|
||||
</p>
|
||||
|
||||
## Key Features
|
||||
|
|
@ -64,7 +64,7 @@ To train a CNN model on the Fashion-MNIST dataset for 100 [epochs](https://www.u
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="fashion-mnist", epochs=100, imgsz=28)
|
||||
|
|
@ -74,7 +74,7 @@ To train a CNN model on the Fashion-MNIST dataset for 100 [epochs](https://www.u
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=fashion-mnist model=yolov8n-cls.pt epochs=100 imgsz=28
|
||||
yolo classify train data=fashion-mnist model=yolo11n-cls.pt epochs=100 imgsz=28
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -107,7 +107,7 @@ To train an Ultralytics YOLO model on the Fashion-MNIST dataset, you can use bot
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model
|
||||
model = YOLO("yolov8n-cls.pt")
|
||||
model = YOLO("yolo11n-cls.pt")
|
||||
|
||||
# Train the model on Fashion-MNIST
|
||||
results = model.train(data="fashion-mnist", epochs=100, imgsz=28)
|
||||
|
|
@ -117,7 +117,7 @@ To train an Ultralytics YOLO model on the Fashion-MNIST dataset, you can use bot
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify train data=fashion-mnist model=yolov8n-cls.pt epochs=100 imgsz=28
|
||||
yolo classify train data=fashion-mnist model=yolo11n-cls.pt epochs=100 imgsz=28
|
||||
```
|
||||
|
||||
For more detailed training parameters, refer to the [Training page](../../modes/train.md).
|
||||
|
|
@ -128,7 +128,7 @@ The [Fashion-MNIST](https://github.com/zalandoresearch/fashion-mnist) dataset is
|
|||
|
||||
### Can I use Ultralytics YOLO for image classification tasks like Fashion-MNIST?
|
||||
|
||||
Yes, Ultralytics YOLO models can be used for image classification tasks, including those involving the Fashion-MNIST dataset. YOLOv8, for example, supports various vision tasks such as detection, segmentation, and classification. To get started with image classification tasks, refer to the [Classification page](https://docs.ultralytics.com/tasks/classify/).
|
||||
Yes, Ultralytics YOLO models can be used for image classification tasks, including those involving the Fashion-MNIST dataset. YOLO11, for example, supports various vision tasks such as detection, segmentation, and classification. To get started with image classification tasks, refer to the [Classification page](https://docs.ultralytics.com/tasks/classify/).
|
||||
|
||||
### What are the key features and structure of the Fashion-MNIST dataset?
|
||||
|
||||
|
|
|
|||
|
|
@ -12,11 +12,11 @@ keywords: ImageNet, deep learning, visual recognition, computer vision, pretrain
|
|||
|
||||
| Model | size<br><sup>(pixels) | acc<br><sup>top1 | acc<br><sup>top5 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) at 640 |
|
||||
| -------------------------------------------------------------------------------------------- | --------------------- | ---------------- | ---------------- | ------------------------------ | ----------------------------------- | ------------------ | ------------------------ |
|
||||
| [YOLOv8n-cls](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n-cls.pt) | 224 | 69.0 | 88.3 | 12.9 | 0.31 | 2.7 | 4.3 |
|
||||
| [YOLOv8s-cls](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s-cls.pt) | 224 | 73.8 | 91.7 | 23.4 | 0.35 | 6.4 | 13.5 |
|
||||
| [YOLOv8m-cls](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m-cls.pt) | 224 | 76.8 | 93.5 | 85.4 | 0.62 | 17.0 | 42.7 |
|
||||
| [YOLOv8l-cls](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l-cls.pt) | 224 | 76.8 | 93.5 | 163.0 | 0.87 | 37.5 | 99.7 |
|
||||
| [YOLOv8x-cls](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x-cls.pt) | 224 | 79.0 | 94.6 | 232.0 | 1.01 | 57.4 | 154.8 |
|
||||
| [YOLO11n-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-cls.pt) | 224 | 69.0 | 88.3 | 12.9 | 0.31 | 2.7 | 4.3 |
|
||||
| [YOLO11s-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-cls.pt) | 224 | 73.8 | 91.7 | 23.4 | 0.35 | 6.4 | 13.5 |
|
||||
| [YOLO11m-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-cls.pt) | 224 | 76.8 | 93.5 | 85.4 | 0.62 | 17.0 | 42.7 |
|
||||
| [YOLO11l-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-cls.pt) | 224 | 76.8 | 93.5 | 163.0 | 0.87 | 37.5 | 99.7 |
|
||||
| [YOLO11x-cls](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-cls.pt) | 224 | 79.0 | 94.6 | 232.0 | 1.01 | 57.4 | 154.8 |
|
||||
|
||||
## Key Features
|
||||
|
||||
|
|
@ -49,7 +49,7 @@ To train a deep learning model on the ImageNet dataset for 100 [epochs](https://
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenet", epochs=100, imgsz=224)
|
||||
|
|
@ -59,7 +59,7 @@ To train a deep learning model on the ImageNet dataset for 100 [epochs](https://
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenet model=yolov8n-cls.pt epochs=100 imgsz=224
|
||||
yolo classify train data=imagenet model=yolo11n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -110,7 +110,7 @@ To use a pretrained Ultralytics YOLO model for image classification on the Image
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenet", epochs=100, imgsz=224)
|
||||
|
|
@ -120,14 +120,14 @@ To use a pretrained Ultralytics YOLO model for image classification on the Image
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenet model=yolov8n-cls.pt epochs=100 imgsz=224
|
||||
yolo classify train data=imagenet model=yolo11n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
For more in-depth training instruction, refer to our [Training page](../../modes/train.md).
|
||||
|
||||
### Why should I use the Ultralytics YOLOv8 pretrained models for my ImageNet dataset projects?
|
||||
### Why should I use the Ultralytics YOLO11 pretrained models for my ImageNet dataset projects?
|
||||
|
||||
Ultralytics YOLOv8 pretrained models offer state-of-the-art performance in terms of speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) for various computer vision tasks. For example, the YOLOv8n-cls model, with a top-1 accuracy of 69.0% and a top-5 accuracy of 88.3%, is optimized for real-time applications. Pretrained models reduce the computational resources required for training from scratch and accelerate development cycles. Learn more about the performance metrics of YOLOv8 models in the [ImageNet Pretrained Models section](#imagenet-pretrained-models).
|
||||
Ultralytics YOLO11 pretrained models offer state-of-the-art performance in terms of speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) for various computer vision tasks. For example, the YOLO11n-cls model, with a top-1 accuracy of 69.0% and a top-5 accuracy of 88.3%, is optimized for real-time applications. Pretrained models reduce the computational resources required for training from scratch and accelerate development cycles. Learn more about the performance metrics of YOLO11 models in the [ImageNet Pretrained Models section](#imagenet-pretrained-models).
|
||||
|
||||
### How is the ImageNet dataset structured, and why is it important?
|
||||
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ To test a deep learning model on the ImageNet10 dataset with an image size of 22
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenet10", epochs=5, imgsz=224)
|
||||
|
|
@ -45,7 +45,7 @@ To test a deep learning model on the ImageNet10 dataset with an image size of 22
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenet10 model=yolov8n-cls.pt epochs=5 imgsz=224
|
||||
yolo classify train data=imagenet10 model=yolo11n-cls.pt epochs=5 imgsz=224
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -94,7 +94,7 @@ To test your deep learning model on the ImageNet10 dataset with an image size of
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenet10", epochs=5, imgsz=224)
|
||||
|
|
@ -104,7 +104,7 @@ To test your deep learning model on the ImageNet10 dataset with an image size of
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenet10 model=yolov8n-cls.pt epochs=5 imgsz=224
|
||||
yolo classify train data=imagenet10 model=yolo11n-cls.pt epochs=5 imgsz=224
|
||||
```
|
||||
|
||||
Refer to the [Training](../../modes/train.md) page for a comprehensive list of available arguments.
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ To train a model on the ImageNette dataset for 100 epochs with a standard image
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenette", epochs=100, imgsz=224)
|
||||
|
|
@ -47,7 +47,7 @@ To train a model on the ImageNette dataset for 100 epochs with a standard image
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenette model=yolov8n-cls.pt epochs=100 imgsz=224
|
||||
yolo classify train data=imagenette model=yolo11n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -72,7 +72,7 @@ To use these datasets, simply replace 'imagenette' with 'imagenette160' or 'imag
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model with ImageNette160
|
||||
results = model.train(data="imagenette160", epochs=100, imgsz=160)
|
||||
|
|
@ -82,7 +82,7 @@ To use these datasets, simply replace 'imagenette' with 'imagenette160' or 'imag
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model with ImageNette160
|
||||
yolo classify train data=imagenette160 model=yolov8n-cls.pt epochs=100 imgsz=160
|
||||
yolo classify train data=imagenette160 model=yolo11n-cls.pt epochs=100 imgsz=160
|
||||
```
|
||||
|
||||
!!! example "Train Example with ImageNette320"
|
||||
|
|
@ -93,7 +93,7 @@ To use these datasets, simply replace 'imagenette' with 'imagenette160' or 'imag
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model with ImageNette320
|
||||
results = model.train(data="imagenette320", epochs=100, imgsz=320)
|
||||
|
|
@ -103,7 +103,7 @@ To use these datasets, simply replace 'imagenette' with 'imagenette160' or 'imag
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model with ImageNette320
|
||||
yolo classify train data=imagenette320 model=yolov8n-cls.pt epochs=100 imgsz=320
|
||||
yolo classify train data=imagenette320 model=yolo11n-cls.pt epochs=100 imgsz=320
|
||||
```
|
||||
|
||||
These smaller versions of the dataset allow for rapid iterations during the development process while still providing valuable and realistic image classification tasks.
|
||||
|
|
@ -130,7 +130,7 @@ To train a YOLO model on the ImageNette dataset for 100 [epochs](https://www.ult
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagenette", epochs=100, imgsz=224)
|
||||
|
|
@ -140,7 +140,7 @@ To train a YOLO model on the ImageNette dataset for 100 [epochs](https://www.ult
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagenette model=yolov8n-cls.pt epochs=100 imgsz=224
|
||||
yolo classify train data=imagenette model=yolo11n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
For more details, see the [Training](../../modes/train.md) documentation page.
|
||||
|
|
@ -167,7 +167,7 @@ Yes, the ImageNette dataset is also available in two resized versions: ImageNett
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt")
|
||||
model = YOLO("yolo11n-cls.pt")
|
||||
|
||||
# Train the model with ImageNette160
|
||||
results = model.train(data="imagenette160", epochs=100, imgsz=160)
|
||||
|
|
@ -177,7 +177,7 @@ Yes, the ImageNette dataset is also available in two resized versions: ImageNett
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model with ImageNette160
|
||||
yolo detect train data=imagenette160 model=yolov8n-cls.pt epochs=100 imgsz=160
|
||||
yolo detect train data=imagenette160 model=yolo11n-cls.pt epochs=100 imgsz=160
|
||||
```
|
||||
|
||||
For more information, refer to [Training with ImageNette160 and ImageNette320](#imagenette160-and-imagenette320).
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ To train a CNN model on the ImageWoof dataset for 100 [epochs](https://www.ultra
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="imagewoof", epochs=100, imgsz=224)
|
||||
|
|
@ -44,7 +44,7 @@ To train a CNN model on the ImageWoof dataset for 100 [epochs](https://www.ultra
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=imagewoof model=yolov8n-cls.pt epochs=100 imgsz=224
|
||||
yolo classify train data=imagewoof model=yolo11n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
## Dataset Variants
|
||||
|
|
@ -67,7 +67,7 @@ To use these variants in your training, simply replace 'imagewoof' in the datase
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# For medium-sized dataset
|
||||
model.train(data="imagewoof320", epochs=100, imgsz=224)
|
||||
|
|
@ -80,7 +80,7 @@ To use these variants in your training, simply replace 'imagewoof' in the datase
|
|||
|
||||
```bash
|
||||
# Load a pretrained model and train on the small-sized dataset
|
||||
yolo classify train model=yolov8n-cls.pt data=imagewoof320 epochs=100 imgsz=224
|
||||
yolo classify train model=yolo11n-cls.pt data=imagewoof320 epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
It's important to note that using smaller images will likely yield lower performance in terms of classification accuracy. However, it's an excellent way to iterate quickly in the early stages of model development and prototyping.
|
||||
|
|
@ -116,7 +116,7 @@ To train a [Convolutional Neural Network](https://www.ultralytics.com/glossary/c
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolov8n-cls.pt") # Load a pretrained model
|
||||
model = YOLO("yolo11n-cls.pt") # Load a pretrained model
|
||||
results = model.train(data="imagewoof", epochs=100, imgsz=224)
|
||||
```
|
||||
|
||||
|
|
@ -124,7 +124,7 @@ To train a [Convolutional Neural Network](https://www.ultralytics.com/glossary/c
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo classify train data=imagewoof model=yolov8n-cls.pt epochs=100 imgsz=224
|
||||
yolo classify train data=imagewoof model=yolo11n-cls.pt epochs=100 imgsz=224
|
||||
```
|
||||
|
||||
For more details on available training arguments, refer to the [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -86,7 +86,7 @@ This structured approach ensures that the model can effectively learn from well-
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="path/to/dataset", epochs=100, imgsz=640)
|
||||
|
|
@ -96,7 +96,7 @@ This structured approach ensures that the model can effectively learn from well-
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=path/to/data model=yolov8n-cls.pt epochs=100 imgsz=640
|
||||
yolo detect train data=path/to/data model=yolo11n-cls.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Supported Datasets
|
||||
|
|
@ -170,7 +170,7 @@ To use your own dataset with Ultralytics YOLO, ensure it follows the specified d
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="path/to/your/dataset", epochs=100, imgsz=640)
|
||||
|
|
@ -182,7 +182,7 @@ More details can be found in the [Adding your own dataset](#adding-your-own-data
|
|||
|
||||
Ultralytics YOLO offers several benefits for image classification, including:
|
||||
|
||||
- **Pretrained Models**: Load pretrained models like `yolov8n-cls.pt` to jump-start your training process.
|
||||
- **Pretrained Models**: Load pretrained models like `yolo11n-cls.pt` to jump-start your training process.
|
||||
- **Ease of Use**: Simple API and CLI commands for training and evaluation.
|
||||
- **High Performance**: State-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed, ideal for real-time applications.
|
||||
- **Support for Multiple Datasets**: Seamless integration with various popular datasets like CIFAR-10, ImageNet, and more.
|
||||
|
|
@ -202,7 +202,7 @@ Training a model using Ultralytics YOLO can be done easily in both Python and CL
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="path/to/dataset", epochs=100, imgsz=640)
|
||||
|
|
@ -213,7 +213,7 @@ Training a model using Ultralytics YOLO can be done easily in both Python and CL
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=path/to/data model=yolov8n-cls.pt epochs=100 imgsz=640
|
||||
yolo detect train data=path/to/data model=yolo11n-cls.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
These examples demonstrate the straightforward process of training a YOLO model using either approach. For more information, visit the [Usage](#usage) section.
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ To train a CNN model on the MNIST dataset for 100 [epochs](https://www.ultralyti
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="mnist", epochs=100, imgsz=32)
|
||||
|
|
@ -52,7 +52,7 @@ To train a CNN model on the MNIST dataset for 100 [epochs](https://www.ultralyti
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=mnist model=yolov8n-cls.pt epochs=100 imgsz=28
|
||||
yolo classify train data=mnist model=yolo11n-cls.pt epochs=100 imgsz=28
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -103,7 +103,7 @@ To train a model on the MNIST dataset using Ultralytics YOLO, you can follow the
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-cls.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-cls.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="mnist", epochs=100, imgsz=32)
|
||||
|
|
@ -113,7 +113,7 @@ To train a model on the MNIST dataset using Ultralytics YOLO, you can follow the
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo classify train data=mnist model=yolov8n-cls.pt epochs=100 imgsz=28
|
||||
yolo classify train data=mnist model=yolo11n-cls.pt epochs=100 imgsz=28
|
||||
```
|
||||
|
||||
For a detailed list of available training arguments, refer to the [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore our African Wildlife Dataset featuring images of buffalo, elephant, rhino, and zebra for training computer vision models. Ideal for research and conservation.
|
||||
keywords: African Wildlife Dataset, South African animals, object detection, computer vision, YOLOv8, wildlife research, conservation, dataset
|
||||
keywords: African Wildlife Dataset, South African animals, object detection, computer vision, YOLO11, wildlife research, conservation, dataset
|
||||
---
|
||||
|
||||
# African Wildlife Dataset
|
||||
|
|
@ -16,7 +16,7 @@ This dataset showcases four common animal classes typically found in South Afric
|
|||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> African Wildlife Animals Detection using Ultralytics YOLOv8
|
||||
<strong>Watch:</strong> African Wildlife Animals Detection using Ultralytics YOLO11
|
||||
</p>
|
||||
|
||||
## Dataset Structure
|
||||
|
|
@ -43,7 +43,7 @@ A YAML (Yet Another Markup Language) file defines the dataset configuration, inc
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the African wildlife dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the provided code samples. For a comprehensive list of available parameters, refer to the model's [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the African wildlife dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the provided code samples. For a comprehensive list of available parameters, refer to the model's [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -53,7 +53,7 @@ To train a YOLOv8n model on the African wildlife dataset for 100 [epochs](https:
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="african-wildlife.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -63,7 +63,7 @@ To train a YOLOv8n model on the African wildlife dataset for 100 [epochs](https:
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=african-wildlife.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=african-wildlife.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
|
@ -107,9 +107,9 @@ The dataset has been released available under the [AGPL-3.0 License](https://git
|
|||
|
||||
The African Wildlife Dataset includes images of four common animal species found in South African nature reserves: buffalo, elephant, rhino, and zebra. It is a valuable resource for training computer vision algorithms in object detection and animal identification. The dataset supports various tasks like object tracking, research, and conservation efforts. For more information on its structure and applications, refer to the [Dataset Structure](#dataset-structure) section and [Applications](#applications) of the dataset.
|
||||
|
||||
### How do I train a YOLOv8 model using the African Wildlife Dataset?
|
||||
### How do I train a YOLO11 model using the African Wildlife Dataset?
|
||||
|
||||
You can train a YOLOv8 model on the African Wildlife Dataset by using the `african-wildlife.yaml` configuration file. Below is an example of how to train the YOLOv8n model for 100 epochs with an image size of 640:
|
||||
You can train a YOLO11 model on the African Wildlife Dataset by using the `african-wildlife.yaml` configuration file. Below is an example of how to train the YOLO11n model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example
|
||||
|
||||
|
|
@ -119,7 +119,7 @@ You can train a YOLOv8 model on the African Wildlife Dataset by using the `afric
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="african-wildlife.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -129,7 +129,7 @@ You can train a YOLOv8 model on the African Wildlife Dataset by using the `afric
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=african-wildlife.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=african-wildlife.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For additional training parameters and options, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the Argoverse dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the Argoverse dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -53,7 +53,7 @@ To train a YOLOv8n model on the Argoverse dataset for 100 [epochs](https://www.u
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="Argoverse.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -63,7 +63,7 @@ To train a YOLOv8n model on the Argoverse dataset for 100 [epochs](https://www.u
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=Argoverse.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=Argoverse.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -104,7 +104,7 @@ The [Argoverse](https://www.argoverse.org/) dataset, developed by Argo AI, suppo
|
|||
|
||||
### How can I train an Ultralytics YOLO model using the Argoverse dataset?
|
||||
|
||||
To train a YOLOv8 model with the Argoverse dataset, use the provided YAML configuration file and the following code:
|
||||
To train a YOLO11 model with the Argoverse dataset, use the provided YAML configuration file and the following code:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -114,7 +114,7 @@ To train a YOLOv8 model with the Argoverse dataset, use the provided YAML config
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="Argoverse.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -125,7 +125,7 @@ To train a YOLOv8 model with the Argoverse dataset, use the provided YAML config
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=Argoverse.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=Argoverse.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a detailed explanation of the arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the brain tumor dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, utilize the provided code snippets. For a detailed list of available arguments, consult the model's [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the brain tumor dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, utilize the provided code snippets. For a detailed list of available arguments, consult the model's [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -52,7 +52,7 @@ To train a YOLOv8n model on the brain tumor dataset for 100 [epochs](https://www
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="brain-tumor.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -62,7 +62,7 @@ To train a YOLOv8n model on the brain tumor dataset for 100 [epochs](https://www
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=brain-tumor.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=brain-tumor.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
|
@ -106,9 +106,9 @@ The dataset has been released available under the [AGPL-3.0 License](https://git
|
|||
|
||||
The brain tumor dataset is divided into two subsets: the **training set** consists of 893 images with corresponding annotations, while the **testing set** comprises 223 images with paired annotations. This structured division aids in developing robust and accurate computer vision models for detecting brain tumors. For more information on the dataset structure, visit the [Dataset Structure](#dataset-structure) section.
|
||||
|
||||
### How can I train a YOLOv8 model on the brain tumor dataset using Ultralytics?
|
||||
### How can I train a YOLO11 model on the brain tumor dataset using Ultralytics?
|
||||
|
||||
You can train a YOLOv8 model on the brain tumor dataset for 100 epochs with an image size of 640px using both Python and CLI methods. Below are the examples for both:
|
||||
You can train a YOLO11 model on the brain tumor dataset for 100 epochs with an image size of 640px using both Python and CLI methods. Below are the examples for both:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -118,7 +118,7 @@ You can train a YOLOv8 model on the brain tumor dataset for 100 epochs with an i
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="brain-tumor.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -129,7 +129,7 @@ You can train a YOLOv8 model on the brain tumor dataset for 100 epochs with an i
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=brain-tumor.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=brain-tumor.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a detailed list of available arguments, refer to the [Training](../../modes/train.md) page.
|
||||
|
|
@ -138,9 +138,9 @@ For a detailed list of available arguments, refer to the [Training](../../modes/
|
|||
|
||||
Using the brain tumor dataset in AI projects enables early diagnosis and treatment planning for brain tumors. It helps in automating brain tumor identification through computer vision, facilitating accurate and timely medical interventions, and supporting personalized treatment strategies. This application holds significant potential in improving patient outcomes and medical efficiencies.
|
||||
|
||||
### How do I perform inference using a fine-tuned YOLOv8 model on the brain tumor dataset?
|
||||
### How do I perform inference using a fine-tuned YOLO11 model on the brain tumor dataset?
|
||||
|
||||
Inference using a fine-tuned YOLOv8 model can be performed with either Python or CLI approaches. Here are the examples:
|
||||
Inference using a fine-tuned YOLO11 model can be performed with either Python or CLI approaches. Here are the examples:
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
|
|
|
|||
|
|
@ -21,13 +21,13 @@ The [COCO](https://cocodataset.org/#home) (Common Objects in Context) dataset is
|
|||
|
||||
## COCO Pretrained Models
|
||||
|
||||
| Model | size<br><sup>(pixels) | mAP<sup>val<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
| Model | size<br><sup>(pixels) | mAP<sup>val<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>T4 TensorRT10<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
| ------------------------------------------------------------------------------------ | --------------------- | -------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
|
||||
| [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n.pt) | 640 | 37.3 | 80.4 | 0.99 | 3.2 | 8.7 |
|
||||
| [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt) | 640 | 44.9 | 128.4 | 1.20 | 11.2 | 28.6 |
|
||||
| [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m.pt) | 640 | 50.2 | 234.7 | 1.83 | 25.9 | 78.9 |
|
||||
| [YOLOv8l](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l.pt) | 640 | 52.9 | 375.2 | 2.39 | 43.7 | 165.2 |
|
||||
| [YOLOv8x](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x.pt) | 640 | 53.9 | 479.1 | 3.53 | 68.2 | 257.8 |
|
||||
| [YOLO11n](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt) | 640 | 39.5 | 56.1 ± 0.8 | 1.5 ± 0.0 | 2.6 | 6.5 |
|
||||
| [YOLO11s](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s.pt) | 640 | 47.0 | 90.0 ± 1.2 | 2.5 ± 0.0 | 9.4 | 21.5 |
|
||||
| [YOLO11m](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m.pt) | 640 | 51.5 | 183.2 ± 2.0 | 4.7 ± 0.1 | 20.1 | 68.0 |
|
||||
| [YOLO11l](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l.pt) | 640 | 53.4 | 238.6 ± 1.4 | 6.2 ± 0.1 | 25.3 | 86.9 |
|
||||
| [YOLO11x](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x.pt) | 640 | 54.7 | 462.8 ± 6.7 | 11.3 ± 0.2 | 56.9 | 194.9 |
|
||||
|
||||
## Key Features
|
||||
|
||||
|
|
@ -60,7 +60,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the COCO dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the COCO dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ To train a YOLOv8n model on the COCO dataset for 100 [epochs](https://www.ultral
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -80,7 +80,7 @@ To train a YOLOv8n model on the COCO dataset for 100 [epochs](https://www.ultral
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=coco.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -122,7 +122,7 @@ The [COCO dataset](https://cocodataset.org/#home) (Common Objects in Context) is
|
|||
|
||||
### How can I train a YOLO model using the COCO dataset?
|
||||
|
||||
To train a YOLOv8 model using the COCO dataset, you can use the following code snippets:
|
||||
To train a YOLO11 model using the COCO dataset, you can use the following code snippets:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -132,7 +132,7 @@ To train a YOLOv8 model using the COCO dataset, you can use the following code s
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -142,7 +142,7 @@ To train a YOLOv8 model using the COCO dataset, you can use the following code s
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=coco.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
Refer to the [Training page](../../modes/train.md) for more details on available arguments.
|
||||
|
|
@ -156,13 +156,13 @@ The COCO dataset includes:
|
|||
- Standardized evaluation metrics for object detection (mAP) and segmentation (mean Average Recall, mAR).
|
||||
- **Mosaicing** technique in training batches to enhance model generalization across various object sizes and contexts.
|
||||
|
||||
### Where can I find pretrained YOLOv8 models trained on the COCO dataset?
|
||||
### Where can I find pretrained YOLO11 models trained on the COCO dataset?
|
||||
|
||||
Pretrained YOLOv8 models on the COCO dataset can be downloaded from the links provided in the documentation. Examples include:
|
||||
Pretrained YOLO11 models on the COCO dataset can be downloaded from the links provided in the documentation. Examples include:
|
||||
|
||||
- [YOLOv8n](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n.pt)
|
||||
- [YOLOv8s](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s.pt)
|
||||
- [YOLOv8m](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m.pt)
|
||||
- [YOLO11n](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt)
|
||||
- [YOLO11s](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s.pt)
|
||||
- [YOLO11m](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m.pt)
|
||||
|
||||
These models vary in size, mAP, and inference speed, providing options for different performance and resource requirements.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore the Ultralytics COCO8 dataset, a versatile and manageable set of 8 images perfect for testing object detection models and training pipelines.
|
||||
keywords: COCO8, Ultralytics, dataset, object detection, YOLOv8, training, validation, machine learning, computer vision
|
||||
keywords: COCO8, Ultralytics, dataset, object detection, YOLO11, training, validation, machine learning, computer vision
|
||||
---
|
||||
|
||||
# COCO8 Dataset
|
||||
|
|
@ -21,7 +21,7 @@ keywords: COCO8, Ultralytics, dataset, object detection, YOLOv8, training, valid
|
|||
<strong>Watch:</strong> Ultralytics COCO Dataset Overview
|
||||
</p>
|
||||
|
||||
This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com/) and [YOLOv8](https://github.com/ultralytics/ultralytics).
|
||||
This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com/) and [YOLO11](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
|
|
@ -35,7 +35,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the COCO8 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the COCO8 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -45,7 +45,7 @@ To train a YOLOv8n model on the COCO8 dataset for 100 [epochs](https://www.ultra
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -55,7 +55,7 @@ To train a YOLOv8n model on the COCO8 dataset for 100 [epochs](https://www.ultra
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -95,9 +95,9 @@ We would like to acknowledge the COCO Consortium for creating and maintaining th
|
|||
|
||||
The Ultralytics COCO8 dataset is a compact yet versatile object detection dataset consisting of the first 8 images from the COCO train 2017 set, with 4 images for training and 4 for validation. It is designed for testing and debugging object detection models and experimentation with new detection approaches. Despite its small size, COCO8 offers enough diversity to act as a sanity check for your training pipelines before deploying larger datasets. For more details, view the [COCO8 dataset](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8.yaml).
|
||||
|
||||
### How do I train a YOLOv8 model using the COCO8 dataset?
|
||||
### How do I train a YOLO11 model using the COCO8 dataset?
|
||||
|
||||
To train a YOLOv8 model using the COCO8 dataset, you can employ either Python or CLI commands. Here's how you can start:
|
||||
To train a YOLO11 model using the COCO8 dataset, you can employ either Python or CLI commands. Here's how you can start:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -107,7 +107,7 @@ To train a YOLOv8 model using the COCO8 dataset, you can employ either Python or
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -117,19 +117,19 @@ To train a YOLOv8 model using the COCO8 dataset, you can employ either Python or
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### Why should I use Ultralytics HUB for managing my COCO8 training?
|
||||
|
||||
Ultralytics HUB is an all-in-one web tool designed to simplify the training and deployment of YOLO models, including the Ultralytics YOLOv8 models on the COCO8 dataset. It offers cloud training, real-time tracking, and seamless dataset management. HUB allows you to start training with a single click and avoids the complexities of manual setups. Discover more about [Ultralytics HUB](https://hub.ultralytics.com/) and its benefits.
|
||||
Ultralytics HUB is an all-in-one web tool designed to simplify the training and deployment of YOLO models, including the Ultralytics YOLO11 models on the COCO8 dataset. It offers cloud training, real-time tracking, and seamless dataset management. HUB allows you to start training with a single click and avoids the complexities of manual setups. Discover more about [Ultralytics HUB](https://hub.ultralytics.com/) and its benefits.
|
||||
|
||||
### What are the benefits of using mosaic augmentation in training with the COCO8 dataset?
|
||||
|
||||
Mosaic augmentation, demonstrated in the COCO8 dataset, combines multiple images into a single image during training. This technique increases the variety of objects and scenes in each training batch, improving the model's ability to generalize across different object sizes, aspect ratios, and contexts. This results in a more robust object detection model. For more details, refer to the [training guide](#usage).
|
||||
|
||||
### How can I validate my YOLOv8 model trained on the COCO8 dataset?
|
||||
### How can I validate my YOLO11 model trained on the COCO8 dataset?
|
||||
|
||||
Validation of your YOLOv8 model trained on the COCO8 dataset can be performed using the model's validation commands. You can invoke the validation mode via CLI or Python script to evaluate the model's performance using precise metrics. For detailed instructions, visit the [Validation](../../modes/val.md) page.
|
||||
Validation of your YOLO11 model trained on the COCO8 dataset can be performed using the model's validation commands. You can invoke the validation mode via CLI or Python script to evaluate the model's performance using precise metrics. For detailed instructions, visit the [Validation](../../modes/val.md) page.
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the Global Wheat Head Dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the Global Wheat Head Dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -48,7 +48,7 @@ To train a YOLOv8n model on the Global Wheat Head Dataset for 100 [epochs](https
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="GlobalWheat2020.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -58,7 +58,7 @@ To train a YOLOv8n model on the Global Wheat Head Dataset for 100 [epochs](https
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=GlobalWheat2020.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=GlobalWheat2020.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -96,9 +96,9 @@ We would like to acknowledge the researchers and institutions that contributed t
|
|||
|
||||
The Global Wheat Head Dataset is primarily used for developing and training deep learning models aimed at wheat head detection. This is crucial for applications in wheat phenotyping and crop management, allowing for more accurate estimations of wheat head density, size, and overall crop yield potential. Accurate detection methods help in assessing crop health and maturity, essential for efficient crop management.
|
||||
|
||||
### How do I train a YOLOv8n model on the Global Wheat Head Dataset?
|
||||
### How do I train a YOLO11n model on the Global Wheat Head Dataset?
|
||||
|
||||
To train a YOLOv8n model on the Global Wheat Head Dataset, you can use the following code snippets. Make sure you have the `GlobalWheat2020.yaml` configuration file specifying dataset paths and classes:
|
||||
To train a YOLO11n model on the Global Wheat Head Dataset, you can use the following code snippets. Make sure you have the `GlobalWheat2020.yaml` configuration file specifying dataset paths and classes:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -108,7 +108,7 @@ To train a YOLOv8n model on the Global Wheat Head Dataset, you can use the follo
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a pre-trained model (recommended for training)
|
||||
model = YOLO("yolov8n.pt")
|
||||
model = YOLO("yolo11n.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="GlobalWheat2020.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -118,7 +118,7 @@ To train a YOLOv8n model on the Global Wheat Head Dataset, you can use the follo
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=GlobalWheat2020.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=GlobalWheat2020.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ Here's how you can use these formats to train your model:
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -66,7 +66,7 @@ Here's how you can use these formats to train your model:
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Supported Datasets
|
||||
|
|
@ -158,11 +158,11 @@ Ultralytics YOLO supports a wide range of datasets, including:
|
|||
- [Objects365](objects365.md)
|
||||
- [OpenImagesV7](open-images-v7.md)
|
||||
|
||||
Each dataset page provides detailed information on the structure and usage tailored for efficient YOLOv8 training. Explore the full list in the [Supported Datasets](#supported-datasets) section.
|
||||
Each dataset page provides detailed information on the structure and usage tailored for efficient YOLO11 training. Explore the full list in the [Supported Datasets](#supported-datasets) section.
|
||||
|
||||
### How do I start training a YOLOv8 model using my dataset?
|
||||
### How do I start training a YOLO11 model using my dataset?
|
||||
|
||||
To start training a YOLOv8 model, ensure your dataset is formatted correctly and the paths are defined in a YAML file. Use the following script to begin training:
|
||||
To start training a YOLO11 model, ensure your dataset is formatted correctly and the paths are defined in a YAML file. Use the following script to begin training:
|
||||
|
||||
!!! example
|
||||
|
||||
|
|
@ -171,18 +171,18 @@ To start training a YOLOv8 model, ensure your dataset is formatted correctly and
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolov8n.pt") # Load a pretrained model
|
||||
model = YOLO("yolo11n.pt") # Load a pretrained model
|
||||
results = model.train(data="path/to/your_dataset.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=path/to/your_dataset.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=path/to/your_dataset.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
Refer to the [Usage](#usage) section for more details on utilizing different modes, including CLI commands.
|
||||
|
||||
### Where can I find practical examples of using Ultralytics YOLO for object detection?
|
||||
|
||||
Ultralytics provides numerous examples and practical guides for using YOLOv8 in diverse applications. For a comprehensive overview, visit the [Ultralytics Blog](https://www.ultralytics.com/blog) where you can find case studies, detailed tutorials, and community stories showcasing object detection, segmentation, and more with YOLOv8. For specific examples, check the [Usage](../../modes/predict.md) section in the documentation.
|
||||
Ultralytics provides numerous examples and practical guides for using YOLO11 in diverse applications. For a comprehensive overview, visit the [Ultralytics Blog](https://www.ultralytics.com/blog) where you can find case studies, detailed tutorials, and community stories showcasing object detection, segmentation, and more with YOLO11. For specific examples, check the [Usage](../../modes/predict.md) section in the documentation.
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the LVIS dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the LVIS dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -66,7 +66,7 @@ To train a YOLOv8n model on the LVIS dataset for 100 [epochs](https://www.ultral
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="lvis.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -76,7 +76,7 @@ To train a YOLOv8n model on the LVIS dataset for 100 [epochs](https://www.ultral
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=lvis.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=lvis.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -114,9 +114,9 @@ We would like to acknowledge the LVIS Consortium for creating and maintaining th
|
|||
|
||||
The [LVIS dataset](https://www.lvisdataset.org/) is a large-scale dataset with fine-grained vocabulary-level annotations developed by Facebook AI Research (FAIR). It is primarily used for object detection and instance segmentation, featuring over 1203 object categories and 2 million instance annotations. Researchers and practitioners use it to train and benchmark models like Ultralytics YOLO for advanced computer vision tasks. The dataset's extensive size and diversity make it an essential resource for pushing the boundaries of model performance in detection and segmentation.
|
||||
|
||||
### How can I train a YOLOv8n model using the LVIS dataset?
|
||||
### How can I train a YOLO11n model using the LVIS dataset?
|
||||
|
||||
To train a YOLOv8n model on the LVIS dataset for 100 epochs with an image size of 640, follow the example below. This process utilizes Ultralytics' framework, which offers comprehensive training features.
|
||||
To train a YOLO11n model on the LVIS dataset for 100 epochs with an image size of 640, follow the example below. This process utilizes Ultralytics' framework, which offers comprehensive training features.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ To train a YOLOv8n model on the LVIS dataset for 100 epochs with an image size o
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="lvis.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -137,7 +137,7 @@ To train a YOLOv8n model on the LVIS dataset for 100 epochs with an image size o
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=lvis.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=lvis.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For detailed training configurations, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
|
@ -148,7 +148,7 @@ The images in the LVIS dataset are the same as those in the [COCO dataset](./coc
|
|||
|
||||
### Why should I use Ultralytics YOLO for training on the LVIS dataset?
|
||||
|
||||
Ultralytics YOLO models, including the latest YOLOv8, are optimized for real-time object detection with state-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed. They support a wide range of annotations, such as the fine-grained ones provided by the LVIS dataset, making them ideal for advanced computer vision applications. Moreover, Ultralytics offers seamless integration with various [training](../../modes/train.md), [validation](../../modes/val.md), and [prediction](../../modes/predict.md) modes, ensuring efficient model development and deployment.
|
||||
Ultralytics YOLO models, including the latest YOLO11, are optimized for real-time object detection with state-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed. They support a wide range of annotations, such as the fine-grained ones provided by the LVIS dataset, making them ideal for advanced computer vision applications. Moreover, Ultralytics offers seamless integration with various [training](../../modes/train.md), [validation](../../modes/val.md), and [prediction](../../modes/predict.md) modes, ensuring efficient model development and deployment.
|
||||
|
||||
### Can I see some sample annotations from the LVIS dataset?
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore the Objects365 Dataset with 2M images and 30M bounding boxes across 365 categories. Enhance your object detection models with diverse, high-quality data.
|
||||
keywords: Objects365 dataset, object detection, machine learning, deep learning, computer vision, annotated images, bounding boxes, YOLOv8, high-resolution images, dataset configuration
|
||||
keywords: Objects365 dataset, object detection, machine learning, deep learning, computer vision, annotated images, bounding boxes, YOLO11, high-resolution images, dataset configuration
|
||||
---
|
||||
|
||||
# Objects365 Dataset
|
||||
|
|
@ -38,7 +38,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the Objects365 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the Objects365 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -48,7 +48,7 @@ To train a YOLOv8n model on the Objects365 dataset for 100 [epochs](https://www.
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="Objects365.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -58,7 +58,7 @@ To train a YOLOv8n model on the Objects365 dataset for 100 [epochs](https://www.
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=Objects365.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=Objects365.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -97,9 +97,9 @@ We would like to acknowledge the team of researchers who created and maintain th
|
|||
|
||||
The [Objects365 dataset](https://www.objects365.org/) is designed for object detection tasks in [machine learning](https://www.ultralytics.com/glossary/machine-learning-ml) and computer vision. It provides a large-scale, high-quality dataset with 2 million annotated images and 30 million bounding boxes across 365 categories. Leveraging such a diverse dataset helps improve the performance and generalization of object detection models, making it invaluable for research and development in the field.
|
||||
|
||||
### How can I train a YOLOv8 model on the Objects365 dataset?
|
||||
### How can I train a YOLO11 model on the Objects365 dataset?
|
||||
|
||||
To train a YOLOv8n model using the Objects365 dataset for 100 epochs with an image size of 640, follow these instructions:
|
||||
To train a YOLO11n model using the Objects365 dataset for 100 epochs with an image size of 640, follow these instructions:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -109,7 +109,7 @@ To train a YOLOv8n model using the Objects365 dataset for 100 epochs with an ima
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="Objects365.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -119,7 +119,7 @@ To train a YOLOv8n model using the Objects365 dataset for 100 epochs with an ima
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=Objects365.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=Objects365.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
Refer to the [Training](../../modes/train.md) page for a comprehensive list of available arguments.
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore the comprehensive Open Images V7 dataset by Google. Learn about its annotations, applications, and use YOLOv8 pretrained models for computer vision tasks.
|
||||
keywords: Open Images V7, Google dataset, computer vision, YOLOv8 models, object detection, image segmentation, visual relationships, AI research, Ultralytics
|
||||
description: Explore the comprehensive Open Images V7 dataset by Google. Learn about its annotations, applications, and use YOLO11 pretrained models for computer vision tasks.
|
||||
keywords: Open Images V7, Google dataset, computer vision, YOLO11 models, object detection, image segmentation, visual relationships, AI research, Ultralytics
|
||||
---
|
||||
|
||||
# Open Images V7 Dataset
|
||||
|
|
@ -69,7 +69,7 @@ Typically, datasets come with a YAML (Yet Another Markup Language) file that del
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the Open Images V7 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the Open Images V7 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! warning
|
||||
|
||||
|
|
@ -87,8 +87,8 @@ To train a YOLOv8n model on the Open Images V7 dataset for 100 [epochs](https://
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a COCO-pretrained YOLOv8n model
|
||||
model = YOLO("yolov8n.pt")
|
||||
# Load a COCO-pretrained YOLO11n model
|
||||
model = YOLO("yolo11n.pt")
|
||||
|
||||
# Train the model on the Open Images V7 dataset
|
||||
results = model.train(data="open-images-v7.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -97,8 +97,8 @@ To train a YOLOv8n model on the Open Images V7 dataset for 100 [epochs](https://
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a COCO-pretrained YOLOv8n model on the Open Images V7 dataset
|
||||
yolo detect train data=open-images-v7.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
# Train a COCO-pretrained YOLO11n model on the Open Images V7 dataset
|
||||
yolo detect train data=open-images-v7.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -136,9 +136,9 @@ A heartfelt acknowledgment goes out to the Google AI team for creating and maint
|
|||
|
||||
Open Images V7 is an extensive and versatile dataset created by Google, designed to advance research in computer vision. It includes image-level labels, object bounding boxes, object segmentation masks, visual relationships, and localized narratives, making it ideal for various computer vision tasks such as object detection, segmentation, and relationship detection.
|
||||
|
||||
### How do I train a YOLOv8 model on the Open Images V7 dataset?
|
||||
### How do I train a YOLO11 model on the Open Images V7 dataset?
|
||||
|
||||
To train a YOLOv8 model on the Open Images V7 dataset, you can use both Python and CLI commands. Here's an example of training the YOLOv8n model for 100 epochs with an image size of 640:
|
||||
To train a YOLO11 model on the Open Images V7 dataset, you can use both Python and CLI commands. Here's an example of training the YOLO11n model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -147,8 +147,8 @@ To train a YOLOv8 model on the Open Images V7 dataset, you can use both Python a
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Load a COCO-pretrained YOLOv8n model
|
||||
model = YOLO("yolov8n.pt")
|
||||
# Load a COCO-pretrained YOLO11n model
|
||||
model = YOLO("yolo11n.pt")
|
||||
|
||||
# Train the model on the Open Images V7 dataset
|
||||
results = model.train(data="open-images-v7.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -158,8 +158,8 @@ To train a YOLOv8 model on the Open Images V7 dataset, you can use both Python a
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a COCO-pretrained YOLOv8n model on the Open Images V7 dataset
|
||||
yolo detect train data=open-images-v7.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
# Train a COCO-pretrained YOLO11n model on the Open Images V7 dataset
|
||||
yolo detect train data=open-images-v7.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more details on arguments and settings, refer to the [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ Dataset benchmarking evaluates machine learning model performance on specific da
|
|||
if path.exists():
|
||||
# Fix YAML file and run training
|
||||
benchmark.fix_yaml(str(path))
|
||||
os.system(f"yolo detect train data={path} model=yolov8s.pt epochs=1 batch=16")
|
||||
os.system(f"yolo detect train data={path} model=yolo11s.pt epochs=1 batch=16")
|
||||
|
||||
# Run validation and evaluate
|
||||
os.system(f"yolo detect val data={path} model=runs/detect/train/weights/best.pt > {val_log_file} 2>&1")
|
||||
|
|
@ -165,7 +165,7 @@ To use the Roboflow 100 dataset for benchmarking, you can implement the RF100Ben
|
|||
if path.exists():
|
||||
# Fix YAML file and run training
|
||||
benchmark.fix_yaml(str(path))
|
||||
os.system(f"yolo detect train data={path} model=yolov8s.pt epochs=1 batch=16")
|
||||
os.system(f"yolo detect train data={path} model=yolo11n.pt epochs=1 batch=16")
|
||||
|
||||
# Run validation and evaluate
|
||||
os.system(f"yolo detect val data={path} model=runs/detect/train/weights/best.pt > {val_log_file} 2>&1")
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Discover the Signature Detection Dataset for training models to identify and verify human signatures in various documents. Perfect for document verification and fraud prevention.
|
||||
keywords: Signature Detection Dataset, document verification, fraud detection, computer vision, YOLOv8, Ultralytics, annotated signatures, training dataset
|
||||
keywords: Signature Detection Dataset, document verification, fraud detection, computer vision, YOLO11, Ultralytics, annotated signatures, training dataset
|
||||
---
|
||||
|
||||
# Signature Detection Dataset
|
||||
|
|
@ -31,7 +31,7 @@ A YAML (Yet Another Markup Language) file defines the dataset configuration, inc
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the signature detection dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the provided code samples. For a comprehensive list of available parameters, refer to the model's [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the signature detection dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, use the provided code samples. For a comprehensive list of available parameters, refer to the model's [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -41,7 +41,7 @@ To train a YOLOv8n model on the signature detection dataset for 100 [epochs](htt
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="signature.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -51,7 +51,7 @@ To train a YOLOv8n model on the signature detection dataset for 100 [epochs](htt
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=signature.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=signature.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
|
@ -95,9 +95,9 @@ The dataset has been released available under the [AGPL-3.0 License](https://git
|
|||
|
||||
The Signature Detection Dataset is a collection of annotated images aimed at detecting human signatures within various document types. It can be applied in computer vision tasks such as [object detection](https://www.ultralytics.com/glossary/object-detection) and tracking, primarily for document verification, fraud detection, and archival research. This dataset helps train models to recognize signatures in different contexts, making it valuable for both research and practical applications.
|
||||
|
||||
### How do I train a YOLOv8n model on the Signature Detection Dataset?
|
||||
### How do I train a YOLO11n model on the Signature Detection Dataset?
|
||||
|
||||
To train a YOLOv8n model on the Signature Detection Dataset, follow these steps:
|
||||
To train a YOLO11n model on the Signature Detection Dataset, follow these steps:
|
||||
|
||||
1. Download the `signature.yaml` dataset configuration file from [signature.yaml](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/signature.yaml).
|
||||
2. Use the following Python script or CLI command to start training:
|
||||
|
|
@ -110,7 +110,7 @@ To train a YOLOv8n model on the Signature Detection Dataset, follow these steps:
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model
|
||||
model = YOLO("yolov8n.pt")
|
||||
model = YOLO("yolo11n.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="signature.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -119,7 +119,7 @@ To train a YOLOv8n model on the Signature Detection Dataset, follow these steps:
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo detect train data=signature.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=signature.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more details, refer to the [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the SKU-110K dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the SKU-110K dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -61,7 +61,7 @@ To train a YOLOv8n model on the SKU-110K dataset for 100 [epochs](https://www.ul
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="SKU-110K.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -71,7 +71,7 @@ To train a YOLOv8n model on the SKU-110K dataset for 100 [epochs](https://www.ul
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=SKU-110K.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=SKU-110K.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -109,9 +109,9 @@ We would like to acknowledge Eran Goldman et al. for creating and maintaining th
|
|||
|
||||
The SKU-110k dataset consists of densely packed retail shelf images designed to aid research in object detection tasks. Developed by Eran Goldman et al., it includes over 110,000 unique SKU categories. Its importance lies in its ability to challenge state-of-the-art object detectors with diverse object appearances and close proximity, making it an invaluable resource for researchers and practitioners in computer vision. Learn more about the dataset's structure and applications in our [SKU-110k Dataset](#sku-110k-dataset) section.
|
||||
|
||||
### How do I train a YOLOv8 model using the SKU-110k dataset?
|
||||
### How do I train a YOLO11 model using the SKU-110k dataset?
|
||||
|
||||
Training a YOLOv8 model on the SKU-110k dataset is straightforward. Here's an example to train a YOLOv8n model for 100 epochs with an image size of 640:
|
||||
Training a YOLO11 model on the SKU-110k dataset is straightforward. Here's an example to train a YOLO11n model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ Training a YOLOv8 model on the SKU-110k dataset is straightforward. Here's an ex
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="SKU-110K.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -132,7 +132,7 @@ Training a YOLOv8 model on the SKU-110k dataset is straightforward. Here's an ex
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=SKU-110K.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=SKU-110K.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the VisDrone dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the VisDrone dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -57,7 +57,7 @@ To train a YOLOv8n model on the VisDrone dataset for 100 [epochs](https://www.ul
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -67,7 +67,7 @@ To train a YOLOv8n model on the VisDrone dataset for 100 [epochs](https://www.ul
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=VisDrone.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=VisDrone.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -113,9 +113,9 @@ The [VisDrone Dataset](https://github.com/VisDrone/VisDrone-Dataset) is a large-
|
|||
- **Diversity**: Collected across 14 cities, in urban and rural settings, under different weather and lighting conditions.
|
||||
- **Tasks**: Split into five main tasks—object detection in images and videos, single-object and multi-object tracking, and crowd counting.
|
||||
|
||||
### How can I use the VisDrone Dataset to train a YOLOv8 model with Ultralytics?
|
||||
### How can I use the VisDrone Dataset to train a YOLO11 model with Ultralytics?
|
||||
|
||||
To train a YOLOv8 model on the VisDrone dataset for 100 epochs with an image size of 640, you can follow these steps:
|
||||
To train a YOLO11 model on the VisDrone dataset for 100 epochs with an image size of 640, you can follow these steps:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -125,7 +125,7 @@ To train a YOLOv8 model on the VisDrone dataset for 100 epochs with an image siz
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a pretrained model
|
||||
model = YOLO("yolov8n.pt")
|
||||
model = YOLO("yolo11n.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="VisDrone.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -135,7 +135,7 @@ To train a YOLOv8 model on the VisDrone dataset for 100 epochs with an image siz
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=VisDrone.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=VisDrone.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For additional configuration options, please refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n model on the VOC dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n model on the VOC dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -49,7 +49,7 @@ To train a YOLOv8n model on the VOC dataset for 100 [epochs](https://www.ultraly
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -59,7 +59,7 @@ To train a YOLOv8n model on the VOC dataset for 100 [epochs](https://www.ultraly
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=VOC.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=VOC.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -99,9 +99,9 @@ We would like to acknowledge the PASCAL VOC Consortium for creating and maintain
|
|||
|
||||
The [PASCAL VOC](http://host.robots.ox.ac.uk/pascal/VOC/) (Visual Object Classes) dataset is a renowned benchmark for [object detection](https://www.ultralytics.com/glossary/object-detection), segmentation, and classification in computer vision. It includes comprehensive annotations like bounding boxes, class labels, and segmentation masks across 20 different object categories. Researchers use it widely to evaluate the performance of models like Faster R-CNN, YOLO, and Mask R-CNN due to its standardized evaluation metrics such as mean Average Precision (mAP).
|
||||
|
||||
### How do I train a YOLOv8 model using the VOC dataset?
|
||||
### How do I train a YOLO11 model using the VOC dataset?
|
||||
|
||||
To train a YOLOv8 model with the VOC dataset, you need the dataset configuration in a YAML file. Here's an example to start training a YOLOv8n model for 100 epochs with an image size of 640:
|
||||
To train a YOLO11 model with the VOC dataset, you need the dataset configuration in a YAML file. Here's an example to start training a YOLO11n model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -111,7 +111,7 @@ To train a YOLOv8 model with the VOC dataset, you need the dataset configuration
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="VOC.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -121,7 +121,7 @@ To train a YOLOv8 model with the VOC dataset, you need the dataset configuration
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=VOC.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=VOC.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What are the primary challenges included in the VOC dataset?
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ To train a model on the xView dataset for 100 [epochs](https://www.ultralytics.c
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="xView.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -62,7 +62,7 @@ To train a model on the xView dataset for 100 [epochs](https://www.ultralytics.c
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=xView.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=xView.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -114,7 +114,7 @@ To train a model on the xView dataset using Ultralytics YOLO, follow these steps
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="xView.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -125,7 +125,7 @@ To train a model on the xView dataset using Ultralytics YOLO, follow these steps
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo detect train data=xView.yaml model=yolov8n.pt epochs=100 imgsz=640
|
||||
yolo detect train data=xView.yaml model=yolo11n.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For detailed arguments and settings, refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ pip install ultralytics[explorer]
|
|||
from ultralytics import Explorer
|
||||
|
||||
# Create an Explorer object
|
||||
explorer = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
explorer = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
|
||||
# Create embeddings for your dataset
|
||||
explorer.create_embeddings_table()
|
||||
|
|
@ -75,7 +75,7 @@ You get a pandas dataframe with the `limit` number of most similar data points t
|
|||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
similar = exp.get_similar(img="https://ultralytics.com/images/bus.jpg", limit=10)
|
||||
|
|
@ -95,7 +95,7 @@ You get a pandas dataframe with the `limit` number of most similar data points t
|
|||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
similar = exp.get_similar(idx=1, limit=10)
|
||||
|
|
@ -118,7 +118,7 @@ You can also plot the similar images using the `plot_similar` method. This metho
|
|||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
plt = exp.plot_similar(img="https://ultralytics.com/images/bus.jpg", limit=10)
|
||||
|
|
@ -131,7 +131,7 @@ You can also plot the similar images using the `plot_similar` method. This metho
|
|||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
plt = exp.plot_similar(idx=1, limit=10)
|
||||
|
|
@ -150,7 +150,7 @@ Note: This works using LLMs under the hood so the results are probabilistic and
|
|||
from ultralytics.data.explorer import plot_query_result
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
df = exp.ask_ai("show me 100 images with exactly one person and 2 dogs. There can be other objects too")
|
||||
|
|
@ -171,7 +171,7 @@ You can run SQL queries on your dataset using the `sql_query` method. This metho
|
|||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
df = exp.sql_query("WHERE labels LIKE '%person%' AND labels LIKE '%dog%'")
|
||||
|
|
@ -188,7 +188,7 @@ You can also plot the results of a SQL query using the `plot_sql_query` method.
|
|||
from ultralytics import Explorer
|
||||
|
||||
# create an Explorer object
|
||||
exp = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
exp = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
exp.create_embeddings_table()
|
||||
|
||||
# plot the SQL Query
|
||||
|
|
@ -235,7 +235,7 @@ Here are some examples of what you can do with the table:
|
|||
```python
|
||||
from ultralytics import Explorer
|
||||
|
||||
exp = Explorer(model="yolov8n.pt")
|
||||
exp = Explorer(model="yolo11n.pt")
|
||||
exp.create_embeddings_table()
|
||||
table = exp.table
|
||||
|
||||
|
|
@ -359,7 +359,7 @@ You can use the Ultralytics Explorer API to perform similarity searches by creat
|
|||
from ultralytics import Explorer
|
||||
|
||||
# Create an Explorer object
|
||||
explorer = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
explorer = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
explorer.create_embeddings_table()
|
||||
|
||||
# Search for similar images to a given image
|
||||
|
|
@ -381,7 +381,7 @@ The Ask AI feature allows users to filter datasets using natural language querie
|
|||
from ultralytics import Explorer
|
||||
|
||||
# Create an Explorer object
|
||||
explorer = Explorer(data="coco128.yaml", model="yolov8n.pt")
|
||||
explorer = Explorer(data="coco128.yaml", model="yolo11n.pt")
|
||||
explorer.create_embeddings_table()
|
||||
|
||||
# Query with natural language
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@
|
|||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"exp = Explorer(\"VOC.yaml\", model=\"yolov8n.pt\")\n",
|
||||
"exp = Explorer(\"VOC.yaml\", model=\"yolo11n.pt\")\n",
|
||||
"exp.create_embeddings_table()"
|
||||
]
|
||||
},
|
||||
|
|
|
|||
|
|
@ -108,8 +108,8 @@ To train a model on the DOTA v1 dataset, you can utilize the following code snip
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Create a new YOLOv8n-OBB model from scratch
|
||||
model = YOLO("yolov8n-obb.yaml")
|
||||
# Create a new YOLO11n-OBB model from scratch
|
||||
model = YOLO("yolo11n-obb.yaml")
|
||||
|
||||
# Train the model on the DOTAv1 dataset
|
||||
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=1024)
|
||||
|
|
@ -118,8 +118,8 @@ To train a model on the DOTA v1 dataset, you can utilize the following code snip
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a new YOLOv8n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolov8n-obb.pt epochs=100 imgsz=1024
|
||||
# Train a new YOLO11n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolo11n-obb.pt epochs=100 imgsz=1024
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -176,8 +176,8 @@ To train a model on the DOTA dataset, you can use the following example with Ult
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Create a new YOLOv8n-OBB model from scratch
|
||||
model = YOLO("yolov8n-obb.yaml")
|
||||
# Create a new YOLO11n-OBB model from scratch
|
||||
model = YOLO("yolo11n-obb.yaml")
|
||||
|
||||
# Train the model on the DOTAv1 dataset
|
||||
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=1024)
|
||||
|
|
@ -186,8 +186,8 @@ To train a model on the DOTA dataset, you can use the following example with Ult
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a new YOLOv8n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolov8n-obb.pt epochs=100 imgsz=1024
|
||||
# Train a new YOLO11n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolo11n-obb.pt epochs=100 imgsz=1024
|
||||
```
|
||||
|
||||
For more details on how to split and preprocess the DOTA images, refer to the [split DOTA images section](#split-dota-images).
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore the DOTA8 dataset - a small, versatile oriented object detection dataset ideal for testing and debugging object detection models using Ultralytics YOLOv8.
|
||||
keywords: DOTA8 dataset, Ultralytics, YOLOv8, object detection, debugging, training models, oriented object detection, dataset YAML
|
||||
description: Explore the DOTA8 dataset - a small, versatile oriented object detection dataset ideal for testing and debugging object detection models using Ultralytics YOLO11.
|
||||
keywords: DOTA8 dataset, Ultralytics, YOLO11, object detection, debugging, training models, oriented object detection, dataset YAML
|
||||
---
|
||||
|
||||
# DOTA8 Dataset
|
||||
|
|
@ -10,7 +10,7 @@ keywords: DOTA8 dataset, Ultralytics, YOLOv8, object detection, debugging, train
|
|||
|
||||
[Ultralytics](https://www.ultralytics.com/) DOTA8 is a small, but versatile oriented [object detection](https://www.ultralytics.com/glossary/object-detection) dataset composed of the first 8 images of 8 images of the split DOTAv1 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging object detection models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
|
||||
|
||||
This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com/) and [YOLOv8](https://github.com/ultralytics/ultralytics).
|
||||
This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com/) and [YOLO11](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
|
|
@ -24,7 +24,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n-obb model on the DOTA8 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-obb model on the DOTA8 dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -34,7 +34,7 @@ To train a YOLOv8n-obb model on the DOTA8 dataset for 100 [epochs](https://www.u
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-obb.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-obb.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -44,7 +44,7 @@ To train a YOLOv8n-obb model on the DOTA8 dataset for 100 [epochs](https://www.u
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo obb train data=dota8.yaml model=yolov8n-obb.pt epochs=100 imgsz=640
|
||||
yolo obb train data=dota8.yaml model=yolo11n-obb.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -84,11 +84,11 @@ A special note of gratitude to the team behind the DOTA datasets for their comme
|
|||
|
||||
### What is the DOTA8 dataset and how can it be used?
|
||||
|
||||
The DOTA8 dataset is a small, versatile oriented object detection dataset made up of the first 8 images from the DOTAv1 split set, with 4 images designated for training and 4 for validation. It's ideal for testing and debugging object detection models like Ultralytics YOLOv8. Due to its manageable size and diversity, it helps in identifying pipeline errors and running sanity checks before deploying larger datasets. Learn more about object detection with [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics).
|
||||
The DOTA8 dataset is a small, versatile oriented object detection dataset made up of the first 8 images from the DOTAv1 split set, with 4 images designated for training and 4 for validation. It's ideal for testing and debugging object detection models like Ultralytics YOLO11. Due to its manageable size and diversity, it helps in identifying pipeline errors and running sanity checks before deploying larger datasets. Learn more about object detection with [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
### How do I train a YOLOv8 model using the DOTA8 dataset?
|
||||
### How do I train a YOLO11 model using the DOTA8 dataset?
|
||||
|
||||
To train a YOLOv8n-obb model on the DOTA8 dataset for 100 epochs with an image size of 640, you can use the following code snippets. For comprehensive argument options, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-obb model on the DOTA8 dataset for 100 epochs with an image size of 640, you can use the following code snippets. For comprehensive argument options, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -98,7 +98,7 @@ To train a YOLOv8n-obb model on the DOTA8 dataset for 100 epochs with an image s
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-obb.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-obb.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="dota8.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -108,7 +108,7 @@ To train a YOLOv8n-obb model on the DOTA8 dataset for 100 epochs with an image s
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo obb train data=dota8.yaml model=yolov8n-obb.pt epochs=100 imgsz=640
|
||||
yolo obb train data=dota8.yaml model=yolo11n-obb.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What are the key features of the DOTA dataset and where can I access the YAML file?
|
||||
|
|
@ -119,6 +119,6 @@ The DOTA dataset is known for its large-scale benchmark and the challenges it pr
|
|||
|
||||
Mosaicing combines multiple images into one during training, increasing the variety of objects and contexts within each batch. This improves a model's ability to generalize to different object sizes, aspect ratios, and scenes. This technique can be visually demonstrated through a training batch composed of mosaiced DOTA8 dataset images, helping in robust model development. Explore more about mosaicing and training techniques on our [Training](../../modes/train.md) page.
|
||||
|
||||
### Why should I use Ultralytics YOLOv8 for object detection tasks?
|
||||
### Why should I use Ultralytics YOLO11 for object detection tasks?
|
||||
|
||||
Ultralytics YOLOv8 provides state-of-the-art real-time object detection capabilities, including features like oriented bounding boxes (OBB), [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation), and a highly versatile training pipeline. It's suitable for various applications and offers pretrained models for efficient fine-tuning. Explore further about the advantages and usage in the [Ultralytics YOLOv8 documentation](https://github.com/ultralytics/ultralytics).
|
||||
Ultralytics YOLO11 provides state-of-the-art real-time object detection capabilities, including features like oriented bounding boxes (OBB), [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation), and a highly versatile training pipeline. It's suitable for various applications and offers pretrained models for efficient fine-tuning. Explore further about the advantages and usage in the [Ultralytics YOLO11 documentation](https://github.com/ultralytics/ultralytics).
|
||||
|
|
|
|||
|
|
@ -39,8 +39,8 @@ To train a model using these OBB formats:
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Create a new YOLOv8n-OBB model from scratch
|
||||
model = YOLO("yolov8n-obb.yaml")
|
||||
# Create a new YOLO11n-OBB model from scratch
|
||||
model = YOLO("yolo11n-obb.yaml")
|
||||
|
||||
# Train the model on the DOTAv1 dataset
|
||||
results = model.train(data="DOTAv1.yaml", epochs=100, imgsz=1024)
|
||||
|
|
@ -49,8 +49,8 @@ To train a model using these OBB formats:
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a new YOLOv8n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolov8n-obb.pt epochs=100 imgsz=1024
|
||||
# Train a new YOLO11n-OBB model on the DOTAv1 dataset
|
||||
yolo obb train data=DOTAv1.yaml model=yolo11n-obb.pt epochs=100 imgsz=1024
|
||||
```
|
||||
|
||||
## Supported Datasets
|
||||
|
|
@ -92,7 +92,7 @@ It's imperative to validate the compatibility of the dataset with your model and
|
|||
|
||||
Oriented Bounding Boxes (OBB) are a type of bounding box annotation where the box can be rotated to align more closely with the object being detected, rather than just being axis-aligned. This is particularly useful in aerial or satellite imagery where objects might not be aligned with the image axes. In Ultralytics YOLO models, OBBs are represented by their four corner points in the YOLO OBB format. This allows for more accurate object detection since the bounding boxes can rotate to fit the objects better.
|
||||
|
||||
### How do I convert my existing DOTA dataset labels to YOLO OBB format for use with Ultralytics YOLOv8?
|
||||
### How do I convert my existing DOTA dataset labels to YOLO OBB format for use with Ultralytics YOLO11?
|
||||
|
||||
You can convert DOTA dataset labels to YOLO OBB format using the `convert_dota_to_yolo_obb` function from Ultralytics. This conversion ensures compatibility with the Ultralytics YOLO models, enabling you to leverage the OBB capabilities for enhanced object detection. Here's a quick example:
|
||||
|
||||
|
|
@ -104,9 +104,9 @@ convert_dota_to_yolo_obb("path/to/DOTA")
|
|||
|
||||
This script will reformat your DOTA annotations into a YOLO-compatible format.
|
||||
|
||||
### How do I train a YOLOv8 model with oriented bounding boxes (OBB) on my dataset?
|
||||
### How do I train a YOLO11 model with oriented bounding boxes (OBB) on my dataset?
|
||||
|
||||
Training a YOLOv8 model with OBBs involves ensuring your dataset is in the YOLO OBB format and then using the Ultralytics API to train the model. Here's an example in both Python and CLI:
|
||||
Training a YOLO11 model with OBBs involves ensuring your dataset is in the YOLO OBB format and then using the Ultralytics API to train the model. Here's an example in both Python and CLI:
|
||||
|
||||
!!! example
|
||||
|
||||
|
|
@ -115,8 +115,8 @@ Training a YOLOv8 model with OBBs involves ensuring your dataset is in the YOLO
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
# Create a new YOLOv8n-OBB model from scratch
|
||||
model = YOLO("yolov8n-obb.yaml")
|
||||
# Create a new YOLO11n-OBB model from scratch
|
||||
model = YOLO("yolo11n-obb.yaml")
|
||||
|
||||
# Train the model on the custom dataset
|
||||
results = model.train(data="your_dataset.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -125,8 +125,8 @@ Training a YOLOv8 model with OBBs involves ensuring your dataset is in the YOLO
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
# Train a new YOLOv8n-OBB model on the custom dataset
|
||||
yolo obb train data=your_dataset.yaml model=yolov8n-obb.yaml epochs=100 imgsz=640
|
||||
# Train a new YOLO11n-OBB model on the custom dataset
|
||||
yolo obb train data=your_dataset.yaml model=yolo11n-obb.yaml epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
This ensures your model leverages the detailed OBB annotations for improved detection [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
|
|
@ -142,6 +142,6 @@ Currently, Ultralytics supports the following datasets for OBB training:
|
|||
|
||||
These datasets are tailored for scenarios where OBBs offer a significant advantage, such as aerial and satellite image analysis.
|
||||
|
||||
### Can I use my own dataset with oriented bounding boxes for YOLOv8 training, and if so, how?
|
||||
### Can I use my own dataset with oriented bounding boxes for YOLO11 training, and if so, how?
|
||||
|
||||
Yes, you can use your own dataset with oriented bounding boxes for YOLOv8 training. Ensure your dataset annotations are converted to the YOLO OBB format, which involves defining bounding boxes by their four corner points. You can then create a YAML configuration file specifying the dataset paths, classes, and other necessary details. For more information on creating and configuring your datasets, refer to the [Supported Datasets](#supported-datasets) section.
|
||||
Yes, you can use your own dataset with oriented bounding boxes for YOLO11 training. Ensure your dataset annotations are converted to the YOLO OBB format, which involves defining bounding boxes by their four corner points. You can then create a YAML configuration file specifying the dataset paths, classes, and other necessary details. For more information on creating and configuring your datasets, refer to the [Supported Datasets](#supported-datasets) section.
|
||||
|
|
|
|||
|
|
@ -14,12 +14,12 @@ The [COCO-Pose](https://cocodataset.org/#keypoints-2017) dataset is a specialize
|
|||
|
||||
| Model | size<br><sup>(pixels) | mAP<sup>pose<br>50-95 | mAP<sup>pose<br>50 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
| ---------------------------------------------------------------------------------------------------- | --------------------- | --------------------- | ------------------ | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
|
||||
| [YOLOv8n-pose](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
|
||||
| [YOLOv8s-pose](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
|
||||
| [YOLOv8m-pose](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
|
||||
| [YOLOv8l-pose](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
|
||||
| [YOLOv8x-pose](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
|
||||
| [YOLOv8x-pose-p6](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
|
||||
| [YOLO11n-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-pose.pt) | 640 | 50.4 | 80.1 | 131.8 | 1.18 | 3.3 | 9.2 |
|
||||
| [YOLO11s-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-pose.pt) | 640 | 60.0 | 86.2 | 233.2 | 1.42 | 11.6 | 30.2 |
|
||||
| [YOLO11m-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-pose.pt) | 640 | 65.0 | 88.8 | 456.3 | 2.00 | 26.4 | 81.0 |
|
||||
| [YOLO11l-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-pose.pt) | 640 | 67.6 | 90.0 | 784.5 | 2.59 | 44.4 | 168.6 |
|
||||
| [YOLO11x-pose](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-pose.pt) | 640 | 69.2 | 90.2 | 1607.1 | 3.73 | 69.4 | 263.2 |
|
||||
| [YOLO11x-pose-p6](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-pose-p6.pt) | 1280 | 71.6 | 91.2 | 4088.7 | 10.04 | 99.1 | 1066.4 |
|
||||
|
||||
## Key Features
|
||||
|
||||
|
|
@ -51,7 +51,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n-pose model on the COCO-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-pose model on the COCO-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -61,7 +61,7 @@ To train a YOLOv8n-pose model on the COCO-Pose dataset for 100 [epochs](https://
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco-pose.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -71,7 +71,7 @@ To train a YOLOv8n-pose model on the COCO-Pose dataset for 100 [epochs](https://
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=coco-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo pose train data=coco-pose.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -109,11 +109,11 @@ We would like to acknowledge the COCO Consortium for creating and maintaining th
|
|||
|
||||
### What is the COCO-Pose dataset and how is it used with Ultralytics YOLO for pose estimation?
|
||||
|
||||
The [COCO-Pose](https://cocodataset.org/#keypoints-2017) dataset is a specialized version of the COCO (Common Objects in Context) dataset designed for pose estimation tasks. It builds upon the COCO Keypoints 2017 images and annotations, allowing for the training of models like Ultralytics YOLO for detailed pose estimation. For instance, you can use the COCO-Pose dataset to train a YOLOv8n-pose model by loading a pretrained model and training it with a YAML configuration. For training examples, refer to the [Training](../../modes/train.md) documentation.
|
||||
The [COCO-Pose](https://cocodataset.org/#keypoints-2017) dataset is a specialized version of the COCO (Common Objects in Context) dataset designed for pose estimation tasks. It builds upon the COCO Keypoints 2017 images and annotations, allowing for the training of models like Ultralytics YOLO for detailed pose estimation. For instance, you can use the COCO-Pose dataset to train a YOLO11n-pose model by loading a pretrained model and training it with a YAML configuration. For training examples, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
||||
### How can I train a YOLOv8 model on the COCO-Pose dataset?
|
||||
### How can I train a YOLO11 model on the COCO-Pose dataset?
|
||||
|
||||
Training a YOLOv8 model on the COCO-Pose dataset can be accomplished using either Python or CLI commands. For example, to train a YOLOv8n-pose model for 100 epochs with an image size of 640, you can follow the steps below:
|
||||
Training a YOLO11 model on the COCO-Pose dataset can be accomplished using either Python or CLI commands. For example, to train a YOLO11n-pose model for 100 epochs with an image size of 640, you can follow the steps below:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -123,7 +123,7 @@ Training a YOLOv8 model on the COCO-Pose dataset can be accomplished using eithe
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco-pose.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -133,14 +133,14 @@ Training a YOLOv8 model on the COCO-Pose dataset can be accomplished using eithe
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=coco-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo pose train data=coco-pose.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more details on the training process and available arguments, check the [training page](../../modes/train.md).
|
||||
|
||||
### What are the different metrics provided by the COCO-Pose dataset for evaluating model performance?
|
||||
|
||||
The COCO-Pose dataset provides several standardized evaluation metrics for pose estimation tasks, similar to the original COCO dataset. Key metrics include the Object Keypoint Similarity (OKS), which evaluates the [accuracy](https://www.ultralytics.com/glossary/accuracy) of predicted keypoints against ground truth annotations. These metrics allow for thorough performance comparisons between different models. For instance, the COCO-Pose pretrained models such as YOLOv8n-pose, YOLOv8s-pose, and others have specific performance metrics listed in the documentation, like mAP<sup>pose</sup>50-95 and mAP<sup>pose</sup>50.
|
||||
The COCO-Pose dataset provides several standardized evaluation metrics for pose estimation tasks, similar to the original COCO dataset. Key metrics include the Object Keypoint Similarity (OKS), which evaluates the [accuracy](https://www.ultralytics.com/glossary/accuracy) of predicted keypoints against ground truth annotations. These metrics allow for thorough performance comparisons between different models. For instance, the COCO-Pose pretrained models such as YOLO11n-pose, YOLO11s-pose, and others have specific performance metrics listed in the documentation, like mAP<sup>pose</sup>50-95 and mAP<sup>pose</sup>50.
|
||||
|
||||
### How is the dataset structured and split for the COCO-Pose dataset?
|
||||
|
||||
|
|
@ -154,6 +154,6 @@ These subsets help organize the training, validation, and testing phases effecti
|
|||
|
||||
### What are the key features and applications of the COCO-Pose dataset?
|
||||
|
||||
The COCO-Pose dataset extends the COCO Keypoints 2017 annotations to include 17 keypoints for human figures, enabling detailed pose estimation. Standardized evaluation metrics (e.g., OKS) facilitate comparisons across different models. Applications of the COCO-Pose dataset span various domains, such as sports analytics, healthcare, and human-computer interaction, wherever detailed pose estimation of human figures is required. For practical use, leveraging pretrained models like those provided in the documentation (e.g., YOLOv8n-pose) can significantly streamline the process ([Key Features](#key-features)).
|
||||
The COCO-Pose dataset extends the COCO Keypoints 2017 annotations to include 17 keypoints for human figures, enabling detailed pose estimation. Standardized evaluation metrics (e.g., OKS) facilitate comparisons across different models. Applications of the COCO-Pose dataset span various domains, such as sports analytics, healthcare, and human-computer interaction, wherever detailed pose estimation of human figures is required. For practical use, leveraging pretrained models like those provided in the documentation (e.g., YOLO11n-pose) can significantly streamline the process ([Key Features](#key-features)).
|
||||
|
||||
If you use the COCO-Pose dataset in your research or development work, please cite the paper with the following [BibTeX entry](#citations-and-acknowledgments).
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore the compact, versatile COCO8-Pose dataset for testing and debugging object detection models. Ideal for quick experiments with YOLOv8.
|
||||
keywords: COCO8-Pose, Ultralytics, pose detection dataset, object detection, YOLOv8, machine learning, computer vision, training data
|
||||
description: Explore the compact, versatile COCO8-Pose dataset for testing and debugging object detection models. Ideal for quick experiments with YOLO11.
|
||||
keywords: COCO8-Pose, Ultralytics, pose detection dataset, object detection, YOLO11, machine learning, computer vision, training data
|
||||
---
|
||||
|
||||
# COCO8-Pose Dataset
|
||||
|
|
@ -10,7 +10,7 @@ keywords: COCO8-Pose, Ultralytics, pose detection dataset, object detection, YOL
|
|||
|
||||
[Ultralytics](https://www.ultralytics.com/) COCO8-Pose is a small, but versatile pose detection dataset composed of the first 8 images of the COCO train 2017 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging [object detection](https://www.ultralytics.com/glossary/object-detection) models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
|
||||
|
||||
This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com/) and [YOLOv8](https://github.com/ultralytics/ultralytics).
|
||||
This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com/) and [YOLO11](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
|
|
@ -24,7 +24,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n-pose model on the COCO8-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-pose model on the COCO8-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -34,7 +34,7 @@ To train a YOLOv8n-pose model on the COCO8-Pose dataset for 100 [epochs](https:/
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -44,7 +44,7 @@ To train a YOLOv8n-pose model on the COCO8-Pose dataset for 100 [epochs](https:/
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo pose train data=coco8-pose.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -80,13 +80,13 @@ We would like to acknowledge the COCO Consortium for creating and maintaining th
|
|||
|
||||
## FAQ
|
||||
|
||||
### What is the COCO8-Pose dataset, and how is it used with Ultralytics YOLOv8?
|
||||
### What is the COCO8-Pose dataset, and how is it used with Ultralytics YOLO11?
|
||||
|
||||
The COCO8-Pose dataset is a small, versatile pose detection dataset that includes the first 8 images from the COCO train 2017 set, with 4 images for training and 4 for validation. It's designed for testing and debugging object detection models and experimenting with new detection approaches. This dataset is ideal for quick experiments with [Ultralytics YOLOv8](https://docs.ultralytics.com/models/yolov8/). For more details on dataset configuration, check out the dataset YAML file [here](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-pose.yaml).
|
||||
The COCO8-Pose dataset is a small, versatile pose detection dataset that includes the first 8 images from the COCO train 2017 set, with 4 images for training and 4 for validation. It's designed for testing and debugging object detection models and experimenting with new detection approaches. This dataset is ideal for quick experiments with [Ultralytics YOLO11](https://docs.ultralytics.com/models/yolo11/). For more details on dataset configuration, check out the dataset YAML file [here](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-pose.yaml).
|
||||
|
||||
### How do I train a YOLOv8 model using the COCO8-Pose dataset in Ultralytics?
|
||||
### How do I train a YOLO11 model using the COCO8-Pose dataset in Ultralytics?
|
||||
|
||||
To train a YOLOv8n-pose model on the COCO8-Pose dataset for 100 epochs with an image size of 640, follow these examples:
|
||||
To train a YOLO11n-pose model on the COCO8-Pose dataset for 100 epochs with an image size of 640, follow these examples:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -96,7 +96,7 @@ To train a YOLOv8n-pose model on the COCO8-Pose dataset for 100 epochs with an i
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt")
|
||||
model = YOLO("yolo11n-pose.pt")
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -105,7 +105,7 @@ To train a YOLOv8n-pose model on the COCO8-Pose dataset for 100 epochs with an i
|
|||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo pose train data=coco8-pose.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of training arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
@ -120,12 +120,12 @@ The COCO8-Pose dataset offers several benefits:
|
|||
|
||||
For more about its features and usage, see the [Dataset Introduction](#introduction) section.
|
||||
|
||||
### How does mosaicing benefit the YOLOv8 training process using the COCO8-Pose dataset?
|
||||
### How does mosaicing benefit the YOLO11 training process using the COCO8-Pose dataset?
|
||||
|
||||
Mosaicing, demonstrated in the sample images of the COCO8-Pose dataset, combines multiple images into one, increasing the variety of objects and scenes within each training batch. This technique helps improve the model's ability to generalize across various object sizes, aspect ratios, and contexts, ultimately enhancing model performance. See the [Sample Images and Annotations](#sample-images-and-annotations) section for example images.
|
||||
|
||||
### Where can I find the COCO8-Pose dataset YAML file and how do I use it?
|
||||
|
||||
The COCO8-Pose dataset YAML file can be found [here](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-pose.yaml). This file defines the dataset configuration, including paths, classes, and other relevant information. Use this file with the YOLOv8 training scripts as mentioned in the [Train Example](#how-do-i-train-a-yolov8-model-using-the-coco8-pose-dataset-in-ultralytics) section.
|
||||
The COCO8-Pose dataset YAML file can be found [here](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/coco8-pose.yaml). This file defines the dataset configuration, including paths, classes, and other relevant information. Use this file with the YOLO11 training scripts as mentioned in the [Train Example](#how-do-i-train-a-yolo11-model-using-the-coco8-pose-dataset-in-ultralytics) section.
|
||||
|
||||
For more FAQs and detailed documentation, visit the [Ultralytics Documentation](https://docs.ultralytics.com/).
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ keywords: Hand KeyPoints, pose estimation, dataset, keypoints, MediaPipe, YOLO,
|
|||
|
||||
## Introduction
|
||||
|
||||
The hand-keypoints dataset contains 26,768 images of hands annotated with keypoints, making it suitable for training models like Ultralytics YOLO for pose estimation tasks. The annotations were generated using the Google MediaPipe library, ensuring high accuracy and consistency, and the dataset is compatible [Ultralytics YOLOv8](https://github.com/ultralytics/ultralytics) formats.
|
||||
The hand-keypoints dataset contains 26,768 images of hands annotated with keypoints, making it suitable for training models like Ultralytics YOLO for pose estimation tasks. The annotations were generated using the Google MediaPipe library, ensuring high accuracy and consistency, and the dataset is compatible [Ultralytics YOLO11](https://github.com/ultralytics/ultralytics) formats.
|
||||
|
||||
## Hand Landmarks
|
||||
|
||||
|
|
@ -30,7 +30,7 @@ Each hand has a total of 21 keypoints.
|
|||
## Key Features
|
||||
|
||||
- **Large Dataset**: 26,768 images with hand keypoint annotations.
|
||||
- **YOLOv8 Compatibility**: Ready for use with YOLOv8 models.
|
||||
- **YOLO11 Compatibility**: Ready for use with YOLO11 models.
|
||||
- **21 Keypoints**: Detailed hand pose representation.
|
||||
|
||||
## Dataset Structure
|
||||
|
|
@ -56,7 +56,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n-pose model on the Hand Keypoints dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-pose model on the Hand Keypoints dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -66,7 +66,7 @@ To train a YOLOv8n-pose model on the Hand Keypoints dataset for 100 [epochs](htt
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="hand-keypoints.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -76,7 +76,7 @@ To train a YOLOv8n-pose model on the Hand Keypoints dataset for 100 [epochs](htt
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=hand-keypoints.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo pose train data=hand-keypoints.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -109,9 +109,9 @@ We would also like to acknowledge the creator of this dataset, [Rion Dsilva](htt
|
|||
|
||||
## FAQ
|
||||
|
||||
### How do I train a YOLOv8 model on the Hand Keypoints dataset?
|
||||
### How do I train a YOLO11 model on the Hand Keypoints dataset?
|
||||
|
||||
To train a YOLOv8 model on the Hand Keypoints dataset, you can use either Python or the command line interface (CLI). Here's an example for training a YOLOv8n-pose model for 100 epochs with an image size of 640:
|
||||
To train a YOLO11 model on the Hand Keypoints dataset, you can use either Python or the command line interface (CLI). Here's an example for training a YOLO11n-pose model for 100 epochs with an image size of 640:
|
||||
|
||||
!!! Example
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ To train a YOLOv8 model on the Hand Keypoints dataset, you can use either Python
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="hand-keypoints.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -131,7 +131,7 @@ To train a YOLOv8 model on the Hand Keypoints dataset, you can use either Python
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=hand-keypoints.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo pose train data=hand-keypoints.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
|
@ -141,7 +141,7 @@ For a comprehensive list of available arguments, refer to the model [Training](.
|
|||
The Hand Keypoints dataset is designed for advanced pose estimation tasks and includes several key features:
|
||||
|
||||
- **Large Dataset**: Contains 26,768 images with hand keypoint annotations.
|
||||
- **YOLOv8 Compatibility**: Ready for use with YOLOv8 models.
|
||||
- **YOLO11 Compatibility**: Ready for use with YOLO11 models.
|
||||
- **21 Keypoints**: Detailed hand pose representation, including wrist and finger joints.
|
||||
|
||||
For more details, you can explore the [Hand Keypoints Dataset](#introduction) section.
|
||||
|
|
|
|||
|
|
@ -72,7 +72,7 @@ The `train` and `val` fields specify the paths to the directories containing the
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-pose.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -82,7 +82,7 @@ The `train` and `val` fields specify the paths to the directories containing the
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo pose train data=coco8-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo pose train data=coco8-pose.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Supported Datasets
|
||||
|
|
@ -171,7 +171,7 @@ To use the COCO-Pose dataset with Ultralytics YOLO:
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolov8n-pose.pt") # load pretrained model
|
||||
model = YOLO("yolo11n-pose.pt") # load pretrained model
|
||||
results = model.train(data="coco-pose.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
|
@ -188,7 +188,7 @@ To add your dataset:
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolov8n-pose.pt")
|
||||
model = YOLO("yolo11n-pose.pt")
|
||||
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore Ultralytics Tiger-Pose dataset with 263 diverse images. Ideal for testing, training, and refining pose estimation algorithms.
|
||||
keywords: Ultralytics, Tiger-Pose, dataset, pose estimation, YOLOv8, training data, machine learning, neural networks
|
||||
keywords: Ultralytics, Tiger-Pose, dataset, pose estimation, YOLO11, training data, machine learning, neural networks
|
||||
---
|
||||
|
||||
# Tiger-Pose Dataset
|
||||
|
|
@ -12,7 +12,7 @@ keywords: Ultralytics, Tiger-Pose, dataset, pose estimation, YOLOv8, training da
|
|||
|
||||
Despite its manageable size of 210 images, tiger-pose dataset offers diversity, making it suitable for assessing training pipelines, identifying potential errors, and serving as a valuable preliminary step before working with larger datasets for pose estimation.
|
||||
|
||||
This dataset is intended for use with [Ultralytics HUB](https://hub.ultralytics.com/) and [YOLOv8](https://github.com/ultralytics/ultralytics).
|
||||
This dataset is intended for use with [Ultralytics HUB](https://hub.ultralytics.com/) and [YOLO11](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
<p align="center">
|
||||
<br>
|
||||
|
|
@ -22,7 +22,7 @@ This dataset is intended for use with [Ultralytics HUB](https://hub.ultralytics.
|
|||
allowfullscreen>
|
||||
</iframe>
|
||||
<br>
|
||||
<strong>Watch:</strong> Train YOLOv8 Pose Model on Tiger-Pose Dataset Using Ultralytics HUB
|
||||
<strong>Watch:</strong> Train YOLO11 Pose Model on Tiger-Pose Dataset Using Ultralytics HUB
|
||||
</p>
|
||||
|
||||
## Dataset YAML
|
||||
|
|
@ -37,7 +37,7 @@ A YAML (Yet Another Markup Language) file serves as the means to specify the con
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n-pose model on the Tiger-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-pose model on the Tiger-Pose dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -47,7 +47,7 @@ To train a YOLOv8n-pose model on the Tiger-Pose dataset for 100 [epochs](https:/
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="tiger-pose.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -57,7 +57,7 @@ To train a YOLOv8n-pose model on the Tiger-Pose dataset for 100 [epochs](https:/
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo task=pose mode=train data=tiger-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo task=pose mode=train data=tiger-pose.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -101,11 +101,11 @@ The dataset has been released available under the [AGPL-3.0 License](https://git
|
|||
|
||||
### What is the Ultralytics Tiger-Pose dataset used for?
|
||||
|
||||
The Ultralytics Tiger-Pose dataset is designed for pose estimation tasks, consisting of 263 images sourced from a [YouTube video](https://www.youtube.com/watch?v=MIBAT6BGE6U&pp=ygUbVGlnZXIgd2Fsa2luZyByZWZlcmVuY2UubXA0). The dataset is divided into 210 training images and 53 validation images. It is particularly useful for testing, training, and refining pose estimation algorithms using [Ultralytics HUB](https://hub.ultralytics.com/) and [YOLOv8](https://github.com/ultralytics/ultralytics).
|
||||
The Ultralytics Tiger-Pose dataset is designed for pose estimation tasks, consisting of 263 images sourced from a [YouTube video](https://www.youtube.com/watch?v=MIBAT6BGE6U&pp=ygUbVGlnZXIgd2Fsa2luZyByZWZlcmVuY2UubXA0). The dataset is divided into 210 training images and 53 validation images. It is particularly useful for testing, training, and refining pose estimation algorithms using [Ultralytics HUB](https://hub.ultralytics.com/) and [YOLO11](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
### How do I train a YOLOv8 model on the Tiger-Pose dataset?
|
||||
### How do I train a YOLO11 model on the Tiger-Pose dataset?
|
||||
|
||||
To train a YOLOv8n-pose model on the Tiger-Pose dataset for 100 epochs with an image size of 640, use the following code snippets. For more details, visit the [Training](../../modes/train.md) page:
|
||||
To train a YOLO11n-pose model on the Tiger-Pose dataset for 100 epochs with an image size of 640, use the following code snippets. For more details, visit the [Training](../../modes/train.md) page:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -115,7 +115,7 @@ To train a YOLOv8n-pose model on the Tiger-Pose dataset for 100 epochs with an i
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-pose.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-pose.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="tiger-pose.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -126,16 +126,16 @@ To train a YOLOv8n-pose model on the Tiger-Pose dataset for 100 epochs with an i
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo task=pose mode=train data=tiger-pose.yaml model=yolov8n-pose.pt epochs=100 imgsz=640
|
||||
yolo task=pose mode=train data=tiger-pose.yaml model=yolo11n-pose.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What configurations does the `tiger-pose.yaml` file include?
|
||||
|
||||
The `tiger-pose.yaml` file is used to specify the configuration details of the Tiger-Pose dataset. It includes crucial data such as file paths and class definitions. To see the exact configuration, you can check out the [Ultralytics Tiger-Pose Dataset Configuration File](https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/tiger-pose.yaml).
|
||||
|
||||
### How can I run inference using a YOLOv8 model trained on the Tiger-Pose dataset?
|
||||
### How can I run inference using a YOLO11 model trained on the Tiger-Pose dataset?
|
||||
|
||||
To perform inference using a YOLOv8 model trained on the Tiger-Pose dataset, you can use the following code snippets. For a detailed guide, visit the [Prediction](../../modes/predict.md) page:
|
||||
To perform inference using a YOLO11 model trained on the Tiger-Pose dataset, you can use the following code snippets. For a detailed guide, visit the [Prediction](../../modes/predict.md) page:
|
||||
|
||||
!!! example "Inference Example"
|
||||
|
||||
|
|
@ -161,4 +161,4 @@ To perform inference using a YOLOv8 model trained on the Tiger-Pose dataset, you
|
|||
|
||||
### What are the benefits of using the Tiger-Pose dataset for pose estimation?
|
||||
|
||||
The Tiger-Pose dataset, despite its manageable size of 210 images for training, provides a diverse collection of images that are ideal for testing pose estimation pipelines. The dataset helps identify potential errors and acts as a preliminary step before working with larger datasets. Additionally, the dataset supports the training and refinement of pose estimation algorithms using advanced tools like [Ultralytics HUB](https://hub.ultralytics.com/) and [YOLOv8](https://github.com/ultralytics/ultralytics), enhancing model performance and [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
The Tiger-Pose dataset, despite its manageable size of 210 images for training, provides a diverse collection of images that are ideal for testing pose estimation pipelines. The dataset helps identify potential errors and acts as a preliminary step before working with larger datasets. Additionally, the dataset supports the training and refinement of pose estimation algorithms using advanced tools like [Ultralytics HUB](https://hub.ultralytics.com/) and [YOLO11](https://github.com/ultralytics/ultralytics), enhancing model performance and [accuracy](https://www.ultralytics.com/glossary/accuracy).
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train Ultralytics YOLOv8n model on the Carparts Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train Ultralytics YOLO11n model on the Carparts Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -55,7 +55,7 @@ To train Ultralytics YOLOv8n model on the Carparts Segmentation dataset for 100
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="carparts-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -65,7 +65,7 @@ To train Ultralytics YOLOv8n model on the Carparts Segmentation dataset for 100
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=carparts-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=carparts-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -108,9 +108,9 @@ We extend our thanks to the Roboflow team for their dedication in developing and
|
|||
|
||||
The [Roboflow Carparts Segmentation Dataset](https://universe.roboflow.com/gianmarco-russo-vt9xr/car-seg-un1pm?ref=ultralytics) is a curated collection of images and videos specifically designed for car part segmentation tasks in computer vision. This dataset includes a diverse range of visuals captured from multiple perspectives, making it an invaluable resource for training and testing segmentation models for automotive applications.
|
||||
|
||||
### How can I use the Carparts Segmentation Dataset with Ultralytics YOLOv8?
|
||||
### How can I use the Carparts Segmentation Dataset with Ultralytics YOLO11?
|
||||
|
||||
To train a YOLOv8 model on the Carparts Segmentation dataset, you can follow these steps:
|
||||
To train a YOLO11 model on the Carparts Segmentation dataset, you can follow these steps:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -120,7 +120,7 @@ To train a YOLOv8 model on the Carparts Segmentation dataset, you can follow the
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="carparts-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -130,7 +130,7 @@ To train a YOLOv8 model on the Carparts Segmentation dataset, you can follow the
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=carparts-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=carparts-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For more details, refer to the [Training](../../modes/train.md) documentation.
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Explore the COCO-Seg dataset, an extension of COCO, with detailed segmentation annotations. Learn how to train YOLO models with COCO-Seg.
|
||||
keywords: COCO-Seg, dataset, YOLO models, instance segmentation, object detection, COCO dataset, YOLOv8, computer vision, Ultralytics, machine learning
|
||||
keywords: COCO-Seg, dataset, YOLO models, instance segmentation, object detection, COCO dataset, YOLO11, computer vision, Ultralytics, machine learning
|
||||
---
|
||||
|
||||
# COCO-Seg Dataset
|
||||
|
|
@ -12,11 +12,11 @@ The [COCO-Seg](https://cocodataset.org/#home) dataset, an extension of the COCO
|
|||
|
||||
| Model | size<br><sup>(pixels) | mAP<sup>box<br>50-95 | mAP<sup>mask<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
| -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
|
||||
| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
|
||||
| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
|
||||
| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
|
||||
| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
|
||||
| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
|
||||
| [YOLO11n-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
|
||||
| [YOLO11s-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
|
||||
| [YOLO11m-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
|
||||
| [YOLO11l-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
|
||||
| [YOLO11x-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
|
||||
|
||||
## Key Features
|
||||
|
||||
|
|
@ -49,7 +49,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n-seg model on the COCO-Seg dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-seg model on the COCO-Seg dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -59,7 +59,7 @@ To train a YOLOv8n-seg model on the COCO-Seg dataset for 100 [epochs](https://ww
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -69,7 +69,7 @@ To train a YOLOv8n-seg model on the COCO-Seg dataset for 100 [epochs](https://ww
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=coco-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -109,9 +109,9 @@ We extend our thanks to the COCO Consortium for creating and maintaining this in
|
|||
|
||||
The [COCO-Seg](https://cocodataset.org/#home) dataset is an extension of the original COCO (Common Objects in Context) dataset, specifically designed for instance segmentation tasks. While it uses the same images as the COCO dataset, COCO-Seg includes more detailed segmentation annotations, making it a powerful resource for researchers and developers focusing on object instance segmentation.
|
||||
|
||||
### How can I train a YOLOv8 model using the COCO-Seg dataset?
|
||||
### How can I train a YOLO11 model using the COCO-Seg dataset?
|
||||
|
||||
To train a YOLOv8n-seg model on the COCO-Seg dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a detailed list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-seg model on the COCO-Seg dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a detailed list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ To train a YOLOv8n-seg model on the COCO-Seg dataset for 100 epochs with an imag
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -131,7 +131,7 @@ To train a YOLOv8n-seg model on the COCO-Seg dataset for 100 epochs with an imag
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=coco-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### What are the key features of the COCO-Seg dataset?
|
||||
|
|
@ -145,15 +145,15 @@ The COCO-Seg dataset includes several key features:
|
|||
|
||||
### What pretrained models are available for COCO-Seg, and what are their performance metrics?
|
||||
|
||||
The COCO-Seg dataset supports multiple pretrained YOLOv8 segmentation models with varying performance metrics. Here's a summary of the available models and their key metrics:
|
||||
The COCO-Seg dataset supports multiple pretrained YOLO11 segmentation models with varying performance metrics. Here's a summary of the available models and their key metrics:
|
||||
|
||||
| Model | size<br><sup>(pixels) | mAP<sup>box<br>50-95 | mAP<sup>mask<br>50-95 | Speed<br><sup>CPU ONNX<br>(ms) | Speed<br><sup>A100 TensorRT<br>(ms) | params<br><sup>(M) | FLOPs<br><sup>(B) |
|
||||
| -------------------------------------------------------------------------------------------- | --------------------- | -------------------- | --------------------- | ------------------------------ | ----------------------------------- | ------------------ | ----------------- |
|
||||
| [YOLOv8n-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
|
||||
| [YOLOv8s-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
|
||||
| [YOLOv8m-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
|
||||
| [YOLOv8l-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
|
||||
| [YOLOv8x-seg](https://github.com/ultralytics/assets/releases/download/v8.2.0/yolov8x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
|
||||
| [YOLO11n-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n-seg.pt) | 640 | 36.7 | 30.5 | 96.1 | 1.21 | 3.4 | 12.6 |
|
||||
| [YOLO11s-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11s-seg.pt) | 640 | 44.6 | 36.8 | 155.7 | 1.47 | 11.8 | 42.6 |
|
||||
| [YOLO11m-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11m-seg.pt) | 640 | 49.9 | 40.8 | 317.0 | 2.18 | 27.3 | 110.2 |
|
||||
| [YOLO11l-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11l-seg.pt) | 640 | 52.3 | 42.6 | 572.4 | 2.79 | 46.0 | 220.5 |
|
||||
| [YOLO11x-seg](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-seg.pt) | 640 | 53.4 | 43.4 | 712.1 | 4.02 | 71.8 | 344.1 |
|
||||
|
||||
### How is the COCO-Seg dataset structured and what subsets does it contain?
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
---
|
||||
comments: true
|
||||
description: Discover the versatile and manageable COCO8-Seg dataset by Ultralytics, ideal for testing and debugging segmentation models or new detection approaches.
|
||||
keywords: COCO8-Seg, Ultralytics, segmentation dataset, YOLOv8, COCO 2017, model training, computer vision, dataset configuration
|
||||
keywords: COCO8-Seg, Ultralytics, segmentation dataset, YOLO11, COCO 2017, model training, computer vision, dataset configuration
|
||||
---
|
||||
|
||||
# COCO8-Seg Dataset
|
||||
|
|
@ -10,7 +10,7 @@ keywords: COCO8-Seg, Ultralytics, segmentation dataset, YOLOv8, COCO 2017, model
|
|||
|
||||
[Ultralytics](https://www.ultralytics.com/) COCO8-Seg is a small, but versatile [instance segmentation](https://www.ultralytics.com/glossary/instance-segmentation) dataset composed of the first 8 images of the COCO train 2017 set, 4 for training and 4 for validation. This dataset is ideal for testing and debugging segmentation models, or for experimenting with new detection approaches. With 8 images, it is small enough to be easily manageable, yet diverse enough to test training pipelines for errors and act as a sanity check before training larger datasets.
|
||||
|
||||
This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com/) and [YOLOv8](https://github.com/ultralytics/ultralytics).
|
||||
This dataset is intended for use with Ultralytics [HUB](https://hub.ultralytics.com/) and [YOLO11](https://github.com/ultralytics/ultralytics).
|
||||
|
||||
## Dataset YAML
|
||||
|
||||
|
|
@ -24,7 +24,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train a YOLOv8n-seg model on the COCO8-Seg dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train a YOLO11n-seg model on the COCO8-Seg dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -34,7 +34,7 @@ To train a YOLOv8n-seg model on the COCO8-Seg dataset for 100 [epochs](https://w
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -44,7 +44,7 @@ To train a YOLOv8n-seg model on the COCO8-Seg dataset for 100 [epochs](https://w
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco8-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=coco8-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Images and Annotations
|
||||
|
|
@ -80,13 +80,13 @@ We would like to acknowledge the COCO Consortium for creating and maintaining th
|
|||
|
||||
## FAQ
|
||||
|
||||
### What is the COCO8-Seg dataset, and how is it used in Ultralytics YOLOv8?
|
||||
### What is the COCO8-Seg dataset, and how is it used in Ultralytics YOLO11?
|
||||
|
||||
The **COCO8-Seg dataset** is a compact instance segmentation dataset by Ultralytics, consisting of the first 8 images from the COCO train 2017 set—4 images for training and 4 for validation. This dataset is tailored for testing and debugging segmentation models or experimenting with new detection methods. It is particularly useful with Ultralytics [YOLOv8](https://github.com/ultralytics/ultralytics) and [HUB](https://hub.ultralytics.com/) for rapid iteration and pipeline error-checking before scaling to larger datasets. For detailed usage, refer to the model [Training](../../modes/train.md) page.
|
||||
The **COCO8-Seg dataset** is a compact instance segmentation dataset by Ultralytics, consisting of the first 8 images from the COCO train 2017 set—4 images for training and 4 for validation. This dataset is tailored for testing and debugging segmentation models or experimenting with new detection methods. It is particularly useful with Ultralytics [YOLO11](https://github.com/ultralytics/ultralytics) and [HUB](https://hub.ultralytics.com/) for rapid iteration and pipeline error-checking before scaling to larger datasets. For detailed usage, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
### How can I train a YOLOv8n-seg model using the COCO8-Seg dataset?
|
||||
### How can I train a YOLO11n-seg model using the COCO8-Seg dataset?
|
||||
|
||||
To train a **YOLOv8n-seg** model on the COCO8-Seg dataset for 100 epochs with an image size of 640, you can use Python or CLI commands. Here's a quick example:
|
||||
To train a **YOLO11n-seg** model on the COCO8-Seg dataset for 100 epochs with an image size of 640, you can use Python or CLI commands. Here's a quick example:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -96,7 +96,7 @@ To train a **YOLOv8n-seg** model on the COCO8-Seg dataset for 100 epochs with an
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # Load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # Load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -106,7 +106,7 @@ To train a **YOLOv8n-seg** model on the COCO8-Seg dataset for 100 epochs with an
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco8-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=coco8-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
For a thorough explanation of available arguments and configuration options, you can check the [Training](../../modes/train.md) documentation.
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ A YAML (Yet Another Markup Language) file is employed to outline the configurati
|
|||
|
||||
## Usage
|
||||
|
||||
To train Ultralytics YOLOv8n model on the Crack Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train Ultralytics YOLO11n model on the Crack Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -44,7 +44,7 @@ To train Ultralytics YOLOv8n model on the Crack Segmentation dataset for 100 [ep
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="crack-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -54,7 +54,7 @@ To train Ultralytics YOLOv8n model on the Crack Segmentation dataset for 100 [ep
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=crack-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=crack-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -98,9 +98,9 @@ We would like to acknowledge the Roboflow team for creating and maintaining the
|
|||
|
||||
The [Roboflow Crack Segmentation Dataset](https://universe.roboflow.com/university-bswxt/crack-bphdr?ref=ultralytics) is a comprehensive collection of 4029 static images designed specifically for transportation and public safety studies. It is ideal for tasks such as self-driving car model development and infrastructure maintenance. The dataset includes training, testing, and validation sets, aiding in accurate crack detection and segmentation.
|
||||
|
||||
### How do I train a model using the Crack Segmentation Dataset with Ultralytics YOLOv8?
|
||||
### How do I train a model using the Crack Segmentation Dataset with Ultralytics YOLO11?
|
||||
|
||||
To train an Ultralytics YOLOv8 model on the Crack Segmentation dataset, use the following code snippets. Detailed instructions and further parameters can be found on the model [Training](../../modes/train.md) page.
|
||||
To train an Ultralytics YOLO11 model on the Crack Segmentation dataset, use the following code snippets. Detailed instructions and further parameters can be found on the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -110,7 +110,7 @@ To train an Ultralytics YOLOv8 model on the Crack Segmentation dataset, use the
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="crack-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -120,7 +120,7 @@ To train an Ultralytics YOLOv8 model on the Crack Segmentation dataset, use the
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=crack-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=crack-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
### Why should I use the Crack Segmentation Dataset for my self-driving car project?
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ The `train` and `val` fields specify the paths to the directories containing the
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -84,7 +84,7 @@ The `train` and `val` fields specify the paths to the directories containing the
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=coco8-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=coco8-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Supported Datasets
|
||||
|
|
@ -137,13 +137,13 @@ To auto-annotate your dataset using the Ultralytics framework, you can use the `
|
|||
```python
|
||||
from ultralytics.data.annotator import auto_annotate
|
||||
|
||||
auto_annotate(data="path/to/images", det_model="yolov8x.pt", sam_model="sam_b.pt")
|
||||
auto_annotate(data="path/to/images", det_model="yolo11x.pt", sam_model="sam_b.pt")
|
||||
```
|
||||
|
||||
| Argument | Type | Description | Default |
|
||||
| ------------ | ----------------------- | ----------------------------------------------------------------------------------------------------------- | -------------- |
|
||||
| `data` | `str` | Path to a folder containing images to be annotated. | `None` |
|
||||
| `det_model` | `str, optional` | Pre-trained YOLO detection model. Defaults to `'yolov8x.pt'`. | `'yolov8x.pt'` |
|
||||
| `det_model` | `str, optional` | Pre-trained YOLO detection model. Defaults to `'yolo11x.pt'`. | `'yolo11x.pt'` |
|
||||
| `sam_model` | `str, optional` | Pre-trained SAM segmentation model. Defaults to `'sam_b.pt'`. | `'sam_b.pt'` |
|
||||
| `device` | `str, optional` | Device to run the models on. Defaults to an empty string (CPU or GPU, if available). | `''` |
|
||||
| `output_dir` | `str or None, optional` | Directory to save the annotated results. Defaults to a `'labels'` folder in the same directory as `'data'`. | `None` |
|
||||
|
|
@ -195,7 +195,7 @@ Auto-annotation in Ultralytics YOLO allows you to generate segmentation annotati
|
|||
```python
|
||||
from ultralytics.data.annotator import auto_annotate
|
||||
|
||||
auto_annotate(data="path/to/images", det_model="yolov8x.pt", sam_model="sam_b.pt")
|
||||
auto_annotate(data="path/to/images", det_model="yolo11x.pt", sam_model="sam_b.pt")
|
||||
```
|
||||
|
||||
This function automates the annotation process, making it faster and more efficient. For more details, explore the [Auto-Annotation](#auto-annotation) section.
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ A YAML (Yet Another Markup Language) file is used to define the dataset configur
|
|||
|
||||
## Usage
|
||||
|
||||
To train Ultralytics YOLOv8n model on the Package Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
To train Ultralytics YOLO11n model on the Package Segmentation dataset for 100 [epochs](https://www.ultralytics.com/glossary/epoch) with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model [Training](../../modes/train.md) page.
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -44,7 +44,7 @@ To train Ultralytics YOLOv8n model on the Package Segmentation dataset for 100 [
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model (recommended for training)
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model (recommended for training)
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="package-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -54,7 +54,7 @@ To train Ultralytics YOLOv8n model on the Package Segmentation dataset for 100 [
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=package-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=package-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
## Sample Data and Annotations
|
||||
|
|
@ -97,9 +97,9 @@ We express our gratitude to the Roboflow team for their efforts in creating and
|
|||
|
||||
The [Roboflow Package Segmentation Dataset](https://universe.roboflow.com/factorypackage/factory_package?ref=ultralytics) is a curated collection of images tailored for tasks involving package segmentation. It includes diverse images of packages in various contexts, making it invaluable for training and evaluating segmentation models. This dataset is particularly useful for applications in logistics, warehouse automation, and any project requiring precise package analysis. It helps optimize logistics and enhance vision models for accurate package identification and sorting.
|
||||
|
||||
### How do I train an Ultralytics YOLOv8 model on the Package Segmentation Dataset?
|
||||
### How do I train an Ultralytics YOLO11 model on the Package Segmentation Dataset?
|
||||
|
||||
You can train an Ultralytics YOLOv8n model using both Python and CLI methods. Use the snippets below:
|
||||
You can train an Ultralytics YOLO11n model using both Python and CLI methods. Use the snippets below:
|
||||
|
||||
!!! example "Train Example"
|
||||
|
||||
|
|
@ -109,7 +109,7 @@ You can train an Ultralytics YOLOv8n model using both Python and CLI methods. Us
|
|||
from ultralytics import YOLO
|
||||
|
||||
# Load a model
|
||||
model = YOLO("yolov8n-seg.pt") # load a pretrained model
|
||||
model = YOLO("yolo11n-seg.pt") # load a pretrained model
|
||||
|
||||
# Train the model
|
||||
results = model.train(data="package-seg.yaml", epochs=100, imgsz=640)
|
||||
|
|
@ -119,7 +119,7 @@ You can train an Ultralytics YOLOv8n model using both Python and CLI methods. Us
|
|||
|
||||
```bash
|
||||
# Start training from a pretrained *.pt model
|
||||
yolo segment train data=package-seg.yaml model=yolov8n-seg.pt epochs=100 imgsz=640
|
||||
yolo segment train data=package-seg.yaml model=yolo11n-seg.pt epochs=100 imgsz=640
|
||||
```
|
||||
|
||||
Refer to the model [Training](../../modes/train.md) page for more details.
|
||||
|
|
@ -134,9 +134,9 @@ The dataset is structured into three main components:
|
|||
|
||||
This structure ensures a balanced dataset for thorough model training, validation, and testing, enhancing the performance of segmentation algorithms.
|
||||
|
||||
### Why should I use Ultralytics YOLOv8 with the Package Segmentation Dataset?
|
||||
### Why should I use Ultralytics YOLO11 with the Package Segmentation Dataset?
|
||||
|
||||
Ultralytics YOLOv8 provides state-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed for real-time object detection and segmentation tasks. Using it with the Package Segmentation Dataset allows you to leverage YOLOv8's capabilities for precise package segmentation. This combination is especially beneficial for industries like logistics and warehouse automation, where accurate package identification is critical. For more information, check out our [page on YOLOv8 segmentation](https://docs.ultralytics.com/models/yolov8/).
|
||||
Ultralytics YOLO11 provides state-of-the-art [accuracy](https://www.ultralytics.com/glossary/accuracy) and speed for real-time object detection and segmentation tasks. Using it with the Package Segmentation Dataset allows you to leverage YOLO11's capabilities for precise package segmentation. This combination is especially beneficial for industries like logistics and warehouse automation, where accurate package identification is critical. For more information, check out our [page on YOLO11 segmentation](https://docs.ultralytics.com/models/yolo11/).
|
||||
|
||||
### How can I access and use the package-seg.yaml file for the Package Segmentation Dataset?
|
||||
|
||||
|
|
|
|||
|
|
@ -19,14 +19,14 @@ Multi-Object Detector doesn't need standalone training and directly supports pre
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolov8n.pt")
|
||||
model = YOLO("yolo11n.pt")
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
|
||||
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3, iou=0.5 show
|
||||
```
|
||||
|
||||
## FAQ
|
||||
|
|
@ -42,17 +42,17 @@ To use Multi-Object Tracking with Ultralytics YOLO, you can start by using the P
|
|||
```python
|
||||
from ultralytics import YOLO
|
||||
|
||||
model = YOLO("yolov8n.pt") # Load the YOLOv8 model
|
||||
model = YOLO("yolo11n.pt") # Load the YOLO11 model
|
||||
results = model.track(source="https://youtu.be/LNwODJXcvt4", conf=0.3, iou=0.5, show=True)
|
||||
```
|
||||
|
||||
=== "CLI"
|
||||
|
||||
```bash
|
||||
yolo track model=yolov8n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3 iou=0.5 show
|
||||
yolo track model=yolo11n.pt source="https://youtu.be/LNwODJXcvt4" conf=0.3 iou=0.5 show
|
||||
```
|
||||
|
||||
These commands load the YOLOv8 model and use it for tracking objects in the given video source with specific confidence (`conf`) and [Intersection over Union](https://www.ultralytics.com/glossary/intersection-over-union-iou) (`iou`) thresholds. For more details, refer to the [track mode documentation](../../modes/track.md).
|
||||
These commands load the YOLO11 model and use it for tracking objects in the given video source with specific confidence (`conf`) and [Intersection over Union](https://www.ultralytics.com/glossary/intersection-over-union-iou) (`iou`) thresholds. For more details, refer to the [track mode documentation](../../modes/track.md).
|
||||
|
||||
### What are the upcoming features for training trackers in Ultralytics?
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue