数据集概览
Ultralytics 支持用于计算机视觉任务的数据集,例如检测、实例分割、语义分割、深度估计、分类、姿态估计和有向边界框(OBB)。以下列出了主要的 Ultralytics 数据集,并概述了各类计算机视觉任务及其对应的数据集。跟踪模式可直接运行于检测、分割、姿态和 OBB 模型之上,无需针对跟踪器进行专门训练;请参阅跟踪数据集。
观看: Ultralytics 数据集概览
目标检测#
边界框目标检测是一种计算机视觉技术,通过在图像中的每个目标周围绘制边界框来检测并定位目标。
- African-wildlife:一个包含非洲野生动物图像的数据集,动物包括水牛、大象、犀牛和斑马。
- Argoverse:一个包含城市环境中 3D 跟踪和运动预测数据的数据集,并带有丰富的标注。
- 脑肿瘤:用于检测脑部 MRI 图像中脑肿瘤的数据集,肿瘤以单一类别的边界框标注。
- COCO:COCO(常见场景中的物体)是一个大规模目标检测、分割和图像描述数据集,包含 80 个目标类别。
- COCO8:从 COCO train2017 的前 8 张图像中选取的较小子集,其中 4 张用于训练,4 张用于验证,适合快速测试。
- COCO8-Grayscale:将 RGB 转换为灰度图像后生成的 COCO8 灰度版本,适用于单通道模型评估。
- COCO8-Multispectral:通过插值 RGB 波长生成的 COCO8 10 通道多光谱版本,适用于具备光谱感知能力的模型评估。
- COCO12-Formats:包含 12 张图像的测试数据集,覆盖 12 种受支持的图像格式(AVIF、BMP、DNG、HEIC、JP2、JPEG、JPG、MPO、PNG、TIF、TIFF、WebP),用于验证图像加载流程。
- COCO128:从 COCO train2017 的前 128 张图像中选取的较小子集,适用于测试。
- Construction-PPE:一个建筑工地影像数据集,标注了头盔、背心、手套、靴子和护目镜等关键安全装备,以及装备缺失情况,可用于开发合规性和工人保护相关的 AI 模型。
- Global Wheat 2020:一个包含 2020 年全球小麦挑战赛所用麦穗图像的数据集。
- HomeObjects-3K:一个带有标注的室内场景数据集,包含 12 种常见家居用品,非常适合开发和测试智能家居系统、机器人和增强现实领域的计算机视觉模型。
- KITTI:一个知名的自动驾驶数据集,包含立体视觉、LiDAR 和 GPS/IMU 输入,可用于多种道路场景中的 2D 目标检测。
- LVIS:一个大规模目标检测和实例分割数据集,包含 1,203 个目标类别。
- Medical-pills:一个包含已标注药片图像的数据集,旨在帮助开展药品质量控制、分拣和确保符合行业标准等工作。
- Objects365:一个高质量、大规模的目标检测数据集,包含 365 个目标类别和超过 170 万张已标注图像。
- Open Images V7:Google 的大型数据集,包含 601 个类别、170 万张训练图像和 4.2 万张验证图像。
- RF100:一个多样化的目标检测基准,涵盖七个图像领域的 100 个数据集,可用于全面评估模型。
- Signature:一个包含各种文档图像及签名标注的数据集,可支持文档验证和欺诈检测研究。
- SKU-110K:一个零售环境中的密集目标检测数据集,包含超过 1.1 万张图像和 170 万个边界框。
- TT100K:清华-腾讯 100K 交通标志数据集,包含 16,817 张街景图像,涵盖 221 种标志类别。
- Ultralytics 基准测试:一套由 Ultralytics 推出的基准测试套件,包含 37 个经过筛选的检测数据集,覆盖医疗、航空影像、工业、零售等领域,并采用固定协议来衡量模型在真实世界中的泛化能力。
- VisDrone:一个包含无人机拍摄图像中目标检测和多目标跟踪数据的数据集,拥有超过 1 万张图像和视频序列。
- VOC:Pascal Visual Object Classes(VOC)目标检测和分割数据集,包含 20 个目标类别和超过 2.1 万张图像。
- xView:一个用于俯视图像目标检测的数据集,包含 60 个目标类别和超过 100 万个已标注目标。
实例分割#
实例分割是一种计算机视觉技术,可在像素级别识别和定位图像中的目标。与仅对每个像素进行分类的语义分割不同,实例分割能够区分同一类别中的不同实例。
- Carparts-seg:专为车辆零部件识别打造的数据集,可满足设计、制造和研究需求。该数据集适用于目标检测和分割任务。
- COCO:一个用于目标检测、分割和图像描述任务的大规模数据集,包含超过 20 万张已标注图像。
- COCO8-seg:一个用于实例分割任务的小型数据集,包含 COCO 中 8 张带分割标注的图像子集。
- COCO128-seg:一个用于实例分割任务的小型数据集,包含 COCO 中 128 张带分割标注的图像子集。
- Crack-seg:专为检测道路和墙面裂缝打造的数据集,适用于目标检测和分割任务。
- Package-seg:专为识别仓库或工业环境中的包裹打造的数据集,适用于目标检测和分割应用。
语义分割#
语义分割为图像中的每个像素分配类别标签,生成稠密场景图,可用于自动驾驶、场景解析和土地覆盖制图等应用。
- Cityscapes:用于城市街景语义分割的数据集,包含 19 个训练类别。
- Cityscapes8:Cityscapes 的精简子集,仅包含 8 张图像,可用于快速检查语义分割流程。
- ADE20K:场景解析数据集,包含 150 个语义类别。
深度估计#
单目深度估计根据单张 RGB 图像预测以米为单位的逐像素深度图,可用于 3D 场景重建、机器人导航和 AR/VR 应用。
- Depth8:SUN RGB-D 的精简子集,仅包含 8 张图像,可用于快速检查流程。
- ARKitScenes:使用 Apple ARKit LiDAR 采集的真实室内 RGB-D 数据,是规模最大的真实训练数据源。
- SUN RGB-D:使用四种不同 RGB-D 传感器采集的真实室内场景。
- DIODE:使用测量级激光扫描仪采集的高密度室内和室外深度数据。
- Hypersim:具有完美逐像素深度数据的逼真合成室内场景。
- TartanAir:具有高密度深度数据的合成 AirSim 环境,深度约为 ~80 m。
- Virtual KITTI 2:对 KITTI 驾驶场景进行合成重建的数据集,具有高密度深度数据。
- KITTI:真实世界的室外自动驾驶场景,包含 Velodyne LiDAR 深度数据,也是 KITTI Eigen 基准。
- ImageNet(伪标签):带有 Depth Anything 3 伪标签的 ImageNet-1K 图像,可用于蒸馏。
- NYU Depth V2:使用 Microsoft Kinect v1 采集的标准室内深度基准数据集。
- ETH3D:高精度室内和室外激光扫描基准数据集。
- Make3D:分布外的室外校园基准数据集。
- iBims-1:用于深度边缘和平面表面的高质量室内基准数据集。
分类#
图像分类是一项计算机视觉任务,根据图像的视觉内容将图像归入一个或多个预定义的类别。
- Caltech 101:一个包含 101 个目标类别图像的数据集,可用于图像分类任务。
- Caltech 256:Caltech 101 的扩展版本,包含 256 个目标类别和更具挑战性的图像。
- CIFAR-10:一个包含 6 万张 32x32 彩色图像的数据集,分为 10 个类别,每个类别有 6,000 张图像。
- CIFAR-100:CIFAR-10 的扩展版本,包含 100 个目标类别,每个类别有 600 张图像。
- Fashion-MNIST:一个包含 70,000 张灰度图像的数据集,图像分为 10 个时尚类别,可用于图像分类任务。
- ImageNet:一个用于目标检测和图像分类的大规模数据集,包含超过 1,400 万张图像和 20,000 个类别。
- ImageNet-10:ImageNet 的较小子集,包含 10 个类别,可加快实验和测试。
- Imagenette:ImageNet 的较小子集,包含 10 个易于区分的类别,可加快训练和测试。
- Imagewoof:ImageNet 中更具挑战性的子集,包含 10 种犬类,可用于图像分类任务。
- MNIST:一个包含 70,000 张手写数字灰度图像的数据集,可用于图像分类任务。
- MNIST160:从 MNIST 训练集和测试集中分别选取数字 0-9 的前 8 张图像。该数据集总共包含 160 张图像。
姿态估计#
姿态估计是一种确定对象相对于相机或世界坐标系姿态的技术。该技术会识别对象上的关键点或关节,尤其适用于人或动物。
- COCO:一个带有人体姿态标注的大规模数据集,专为姿态估计任务设计。
- COCO8-pose:一个用于姿态估计任务的小型数据集,包含 COCO 中 8 张带有人体姿态标注的图像子集。
- Dog-pose:一个综合性数据集,包含约 8,500 张以狗为主题的图像,并为每只狗标注了 24 个关键点,专为姿态估计任务设计。
- Hand-Keypoints:包含超过 26,000 张以人手为主体的图像的数据集,每只手都标注了 21 个关键点,专为姿态估计任务设计。
- Tiger-pose:一个精简数据集,包含 263 张以老虎为主题的图像,并为每只老虎标注了 12 个关键点,可用于姿态估计任务。
有向边界框 (OBB)#
有向边界框(OBB)是一种计算机视觉方法,通过旋转边界框检测图像中的倾斜目标,常用于航空和卫星图像。与传统边界框相比,OBB 能更贴合不同方向的目标。
- DOTA-v2:一个广受欢迎的航空图像 OBB 数据集,包含 170 万个实例和 11,268 张图像。
- DOTA8:从 DOTAv1 划分集中前 8 张图像中选取的较小子集,其中 4 张用于训练,4 张用于验证,适合快速测试。
- DOTA128:DOTAv1 的 128 张图像子集,用于训练和验证,在规模与多样性之间取得良好平衡,适合测试 OBB 模型。
贡献新数据集#
贡献新数据集需要完成几个步骤,以确保数据集与现有基础设施良好兼容。以下是必要步骤:
观看: 如何为 Ultralytics 数据集做出贡献
贡献新数据集的步骤#
-
收集图像:收集图像,将其纳入数据集。图像可以来自公共数据库等不同来源,也可以来自你自己的素材。
-
标注图像:根据任务需要,为这些图像添加标注,包括边界框、分割区域或关键点。
-
导出标注:将这些标注转换为 Ultralytics 支持的 YOLO
*.txt文件格式。 -
整理数据集:按照正确的文件夹结构整理数据集。你应创建
images/和labels/顶层目录,并在每个目录下创建train/和val/子目录。dataset/ ├── images/ │ ├── train/ │ └── val/ └── labels/ ├── train/ └── val/ -
创建
data.yaml文件:在数据集根目录中,创建一个data.yaml文件,用于描述数据集、类别和其他必要信息。 -
优化图像(可选):如果你想缩小数据集,以提高处理效率,可以使用下面的代码优化图像。这不是必需步骤,但对于较小的数据集和更快的下载速度,建议这样做。
-
压缩数据集:将整个数据集文件夹压缩为 zip 文件。
-
编写文档并提交 PR:创建一个文档页面,介绍你的数据集以及它如何融入现有框架。然后提交一个拉取请求(PR)。有关如何提交 PR 的更多详细信息,请参阅 Ultralytics 贡献指南。
优化并压缩数据集的示例代码#
from pathlib import Path
from ultralytics.data.utils import compress_one_image
from ultralytics.utils.downloads import zip_directory
# 定义数据集目录
path = Path("path/to/dataset")
# 优化数据集中的图像(可选)
for f in path.rglob("*.jpg"):
compress_one_image(f)
# 将数据集压缩到 'path/to/dataset.zip'
zip_directory(path)按照这些步骤操作,你就可以贡献一个能够很好地融入 Ultralytics 现有结构的新数据集。
常见问题#
贡献新数据集需要完成以下几个步骤:
- 收集图像:从公共数据库或个人收藏中收集图像。
- 标注图像:根据任务需求,添加边界框、分割区域或关键点标注。
- 导出标注:将标注转换为 YOLO
*.txt格式。 - 整理数据集:按照文件夹结构组织数据,包含
images/和labels/目录,每个目录中都包含train/和val/子目录。 - 创建
data.yaml文件:添加数据集说明、类别和其他相关信息。 - 优化图像(可选):减小数据集大小以提高效率。
- 压缩数据集:将数据集压缩为 zip 文件。
- 编写文档并提交 PR:介绍你的数据集,并按照 Ultralytics 贡献指南 提交拉取请求。
访问 贡献新数据集,查看完整指南。
Ultralytics Platform提供数据集管理和分析功能,包括:
- 数据集管理:在一个地方上传、整理和管理数据集。
- 即时集成训练流程:直接使用已上传的数据集训练模型,无需额外设置。
- 可视化工具:浏览并可视化数据集图像和标注。
- 数据集分析:深入了解数据集的分布和特征。
数据集可以在同一平台上从管理环节直接进入模型训练。
Ultralytics YOLO 模型为计算机视觉任务提供多项独特功能:
- 实时性能:具备高速推理和训练能力,适用于对时效性要求高的应用。
- 多功能性:在统一框架中支持检测、实例分割、语义分割、深度估计、分类、姿态估计和有向边界框(OBB)任务。
- 预训练模型:可使用适用于各种应用的高性能预训练模型,缩短训练时间。
- 广泛的社区支持:活跃的社区和全面的文档,助你排查问题并开展开发工作。
- 易于集成:提供简单易用的 API,可集成到现有项目和工作流中。
按照以下代码示例,使用 Ultralytics 工具优化并压缩数据集:
优化并压缩数据集from pathlib import Path from ultralytics.data.utils import compress_one_image from ultralytics.utils.downloads import zip_directory # 定义数据集目录 path = Path("path/to/dataset") # 优化数据集中的图像(可选) for f in path.rglob("*.jpg"): compress_one_image(f) # 将数据集压缩到 'path/to/dataset.zip' zip_directory(path)此流程有助于减小数据集体积,以便更高效地存储并加快下载速度。
评论73
提出问题、分享结果,或帮助其他人。
Fatima-khanjar
Hello, I hope you're doing well.
I have a question regarding the imgsz argument in YOLO (imgsz=224).
How exactly does the resizing process work internally? Specifically:
- Are images resized with padding to maintain aspect ratio?
- What if the original images are very small (e.g., 50×50)? Are they upscaled with padding, or just stretched to fit the target size?
- Does this resizing strategy affect model performance or accuracy?
Thanks in advance for your clarification!
gdenis82(已编辑)
Hi. Please tell me how I can balance the class weights in data.yaml for yolo11x-seg:
train: path/to/dataset/train/images val: path/to/dataset/val/images nc: 2 # number of classes names: [class 0, class 1] # list of class name cls_pw: [0.9, 0.1] or pos_weight: [0.9, 0.1]I did not find an exact understanding of how to do this.
Glenn JocherUltralytics(已编辑)@gdenis82 hello! Class weights like
cls_pworpos_weightare not defined within thedata.yamlfile itself.These parameters are typically hard-coded within your Python training script.
gdenis82
Hello. Good documentation. You're the best at it. Thank you. I looked at it again, found a lot of interesting and useful things, but I still haven't found the answer to this question. Here is a simple example with a train. What argument do I need to use to balance the class weights?
from ultralytics import YOLO # Load a model model = YOLO("yolo11x-seg.pt") # load a pretrained model (recommended for training) # Train the model with 2 GPUs results = model.train(data="data.yaml", epochs=100, imgsz=640, device=[0, 1])
Glenn JocherUltralytics@gdenis82 to handle class imbalance in YOLO11x-seg training, you have a few options:
-
Use the
clsparameter in the training function to adjust the classification loss weight:model.train(data="data.yaml", epochs=100, imgsz=640, device=[0, 1], cls=0.7) # Adjust overall classification loss weight -
For more granular control, you can create a custom configuration file to define class weights. The class weights are typically handled in the loss function, not directly in the data.yaml.
-
For severely imbalanced datasets, consider these practical approaches:
- Adjust your dataset sampling to balance class representation
- Use techniques like oversampling of minority classes or undersampling of majority classes
- Apply data augmentation more heavily to underrepresented classes
Class-specific weights aren't directly specified as a training argument in the current API. If you need very fine-grained control, you might need to modify the loss function implementation.
Does this help with your class balancing needs?
-
gdenis82
@glenn-jocher Thank you. Do I understand correctly that this approach sets a reduced total weight of the classification error and corrects only the overall component of the loss function. For ** the entire cluster analysis**, and not separately for each class. This is useful if we have a small data imbalance and all classes can be adjusted in the same way. If each class should have individual weights (depending on the classes shown in the image), what should be done?
# Determine the weights of the classes # Assume 3 classes: 0 - majority class, 1 - minority class, 2 - rare class weights = torch.tensor([0.5, 2.0, 3.0]) # The weights should be the inverse of the frequency of occurrence of classes.
Glenn JocherUltralytics(已编辑)@gdenis82 you're correct - the
clsparameter adjusts the overall classification loss weight, not individual class weights. For implementing individual class weights in YOLO, you would need to modify the loss function directly in the source code.The most straightforward approach would be to:
- Clone the Ultralytics repository
- Locate the loss implementation (typically in
ultralytics/utils/loss.py) - Modify the classification loss calculation to incorporate your custom class weights
- Use your modified version for training
For example, you might need to add something like:
# In the loss function where classification loss is calculated class_weights = torch.tensor([0.5, 2.0, 3.0], device=targets.device) cls_loss = cls_loss * class_weights[targets.long()]Alternatively, data-based approaches are often more practical:
- Oversampling underrepresented classes
- Augmenting minority classes more aggressively
- Using techniques like focal loss (a
FocalLossclass exists inultralytics/utils/loss.py, but it is not used by default)
These approaches often yield better results than direct weight modification and don't require source code changes.
gdenis82
@glenn-jocher Hello. Thanks for your patience and detailed explanation. I got the answer to my question.
D3RK0
Hi,
Introduction
For a couple of days now, I am trying to set YOLOv8 in classification mode in order to classify flowers in the images of the Oxford Flower dataset (i.e. https://www.robots.ox.ac.uk/~vgg/data/flowers/102/). I am using ImageNet pretrained weights to start my training.
The error
However, I am the obtaining error:
Dataset not found ⚠️, missing path C:\Users\ <'my_path'> \Oxford-Flower-dataset\oxford_flower.yaml, attempting download... Downloading https://ultralytics.com/assets/C://Users/ <'my_path'> /Oxford-Flower-dataset/oxford_flower.yaml.zip to 'C:\Users\ <'my_path'> \Oxford-Flower-dataset\oxford_flower.yaml.zip'...
My code
-
Creation of model object: model = YOLO("yolov8m-cls.pt")
-
Model.training: model.train(mode="classify", data=data_file_path, epochs=num_epochs, batch=batch_size, imgsz=256, lr0=lr, optimizer="AdamW", cos_lr=True, momentum=0.937, weight_decay=weight_decay)
-
Note that variable "data_file_path" is the path to my .yaml file I created for the Oxford Flower dataset
My yaml file
The content of my .yaml file is:
names:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9 ....
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102 nc: 102 path: C:/Users/ <'my_path'> /Oxford-Flower-dataset/jpg train: train/images train_label_dir: train/labels val: val/images val_label_dir: val/labels
Data directories
The directories of my data is exactly the way your colleague / member "pderrenger" describes it in her message of March 30th 2024. It looks like:
dataset/ ├── train/ │ ├── images/ │ └── labels.txt └── val/ ├── images/ └── labels.txt
Labels.txt content
The content of labels.txt is:
image_06734.txt 1 image_06735.txt 1 image_06737.txt 1 image_06742.txt 1 image_06743.txt 1 image_06745.txt 1 image_06746.txt 1 image_06748.txt 1 image_06751.txt 1 image_06752.txt 1 ....
Question
Why is it unable to find the data? What I am I missing
D3RK0
The dashes in "My yaml file" section has been automatically changed bullet points. That is not intended. So, bullet points in that section are dashes.
Glenn JocherUltralytics(已编辑)@D3RK0 it seems the issue is with the dataset path. For classification,
datashould be the path to the dataset root directory (not a YAML file), containingtrain/andval/(ortest/) folders with one subfolder per class. The.yamlyou created is not used for classification, which is why Ultralytics tried to download it. For more details, visit https://docs.ultralytics.com/datasets/classify/.1D3RK0
@glenn-jocher Thank you for your quick reply!
Testing directories as they are in the .yaml file
All the directories in my .yaml file should exist:
Note that the prepare_dataset.data_dir variable is created by using a simple dialog:
filedialog.askdirectory(title="Select the image data folder:").Folder structure
As indicated by your colleague, I am using the following structure:
dataset/ ├── train/ │ ├── images/ │ └── labels.txt └── val/ ├── images/ └── labels.txt
Is this structure correct?
Note that in the dataset folder (which is called, in my case, the jpg folder) are all the original .jpeg images files. Originally, the Oxford Flower dataset did not had this structure; all the image files are in jpg folder. Therefore, I created the folder structure you see above and copied the image files (via a script) to the train/images and val/images. But, I did not remove the original image files in the jpg folders. Could not removing the originals be the problem?
Creating the
data_file_pathvariableComparably, to create
data_file_pathvariable, I usedata_file_path = filedialog.askopenfilename(title="Please select the dataset .yaml dataset file for YOLOv8:").Directories in the .yaml file
In the .yaml file, do indicate the labels directory with the extension e.g. train/labels.txt?
Glenn JocherUltralytics(已编辑)It looks like the issue is the dataset layout. For classification, pass the dataset root directory as
data(not a YAML file), and make sure it containstrain/andval/folders with one subfolder per class (the folder name is the class label). Nolabelsdirectory or label files are used.1D3RK0(已编辑)
@glenn-jocher Thank you for your quick reply :-D
Clarification about the
pathkey directoryNote that the
pathkey is not literallyC:/Users/ <'my_path'> /Oxford-Flower-dataset/jpg. With<'my_path'>, I omitted part of the path for privacy. More realistically, it is likeC:/Users/my_several_folders/Oxford-Flower-dataset/jpg. I hope we are the same page on that :-) .Folder structure
You are saying: "The labels should be in a directory, not a single file." So, then the correct folder structure is not the way your colleague 'pderrenger' describes it; it is:
dataset/ ├── train/ │ ├── images/ │ └── labels/ └── val/ ├── images/ └── labels/
This is thus the expected folder structure, is it not? I have changed my folder structure to match with the expected folder, as described above. In my case, it is now:
Where the jpg folder is the root directory of my dataset and to which the aforementioned
pathkey in my .yaml file points to. The image files are in the train/images and val/images folders. Lastly, the labels.txt files are the train/labels and val/labels folders.The content of current .yaml file
names:
- 1
- 2
- 3 ...
- 100
- 101
- 102 nc: 102 path: C:/Users/derk_/Documents/Universiteit/IRP/Research_Project/Oxford-Flower-dataset/jpg train: train/images train_label_dir: train/labels val: val/images val_label_dir: val/labels
In summary
pathkeyThe
pathkey is approximatelyC:/Users/my_several_folders/Oxford-Flower-dataset/jpg. This is my root directory of my dataset.Current folder structure
The current folder structure is:
Changes I made
- I changed the folder structure
- I did not change the .yaml file content, because I can not see how that is wrong
Result of the changes
Changing the folder structure did not solve the problem. It is still unable to find the dataset.
Additional questions
Could you please be explicit about what the correct folder structure is? Could you please give an example of what a correct .yaml structure looks like, as this is not reported in the Ultralytics documentation (unless I missed it)?
Many thanks!
Glenn JocherUltralytics(已编辑)It seems the folder structure is causing the issue. For classification, no label files are needed: place the images of each class in a folder named after the class, inside
train/andval/. Then pass the dataset root directory asdata. For more details, please refer to the classification dataset guide.1D3RK0
@glenn-jocher Many thanks for your quick responses!
Changes
I changed my code from making the single
labels.txtfile to making individual label .txt files. It now looks like:At the top of image is part of the directory. Below there are the label .txt files. In bottom-left is example of the content of such label file.
Are the names of the label .txt file correct?
Result
Still the same dataset not found error :(
Glenn JocherUltralytics(已编辑)Each image's class is taken from the name of the folder it sits in, so no label files are needed for classification. Make sure your data is organized as
dataset/train/<class_name>/*.jpganddataset/val/<class_name>/*.jpg, and pass the dataset root directory asdata.D3RK0
@glenn-jocher Thanks for responding!
I have solved the previous problem. I have another problem, however.
Output by the YOLOv8 model
YAML file created at: C:/Users/derk_/Documents/Universiteit/IRP/Research_Project/Oxford-Flower-dataset/jpg\oxford_flower.yaml New https://pypi.org/project/ultralytics/8.3.28 available 😃 Update with 'pip install -U ultralytics' engine\trainer: task=classify, mode=train, model=yolov8m-cls.pt, data=C:/Users/derk_/Documents/Universiteit/IRP/Research_Project/Oxford-Flower-dataset/jpg, epochs=1, time=None, patience=100, batch=16, imgsz=224, save=True, save_period=1, cache=False, device=cpu, workers=8, project=None, name=train38, exist_ok=False, pretrained=True, optimizer=AdamW, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=True, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=True, opset=None, workspace=4, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.01, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, label_smoothing=0.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, copy_paste_mode=flip, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=C:\runs\classify\train38 train: C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\Oxford-Flower-dataset\jpg\train... found 6149 images in 102 classes: ERROR ❌️ requires 2 classes, not 102 val: C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\Oxford-Flower-dataset\jpg\val... found 1020 images in 102 classes: ERROR ❌️ requires 2 classes, not 102 test: C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\Oxford-Flower-dataset\jpg\test... found 1020 images in 102 classes: ERROR ❌️ requires 2 classes, not 102 Overriding model.yaml nc=1000 with nc=2 from n params module arguments
0 -1 1 1392 ultralytics.nn.modules.conv.Conv [3, 48, 3, 2]
1 -1 1 41664 ultralytics.nn.modules.conv.Conv [48, 96, 3, 2]
2 -1 2 111360 ultralytics.nn.modules.block.C2f [96, 96, 2, True]
3 -1 1 166272 ultralytics.nn.modules.conv.Conv [96, 192, 3, 2]
4 -1 4 813312 ultralytics.nn.modules.block.C2f [192, 192, 4, True]
5 -1 1 664320 ultralytics.nn.modules.conv.Conv [192, 384, 3, 2]
6 -1 4 3248640 ultralytics.nn.modules.block.C2f [384, 384, 4, True]
7 -1 1 2655744 ultralytics.nn.modules.conv.Conv [384, 768, 3, 2]
8 -1 2 7084032 ultralytics.nn.modules.block.C2f [768, 768, 2, True]
9 -1 1 988162 ultralytics.nn.modules.head.Classify [768, 2]
YOLOv8m-cls summary: 141 layers, 15,774,898 parameters, 15,774,898 gradientsThe problem
The "[...] ERROR ❌️ requires 2 classes, not 102 [...]" is giving for all my data splits.
My yaml file.
The content of my yaml file:
names: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102] nc: 102 path: C:/Users/my_several_folders/Oxford-Flower-dataset/jpg test: test/images test_label_dir: test/labels train: train/images train_label_dir: train/labels val: val/images val_label_dir: val/labels
The length of names is equal to the value of nc, 102, so that is not disparate.
My folder structure
jpg/ ├── train/ │ ├── 1/ │ │ ├── img1.jpg │ │ └── img2.jpg │ ├── 2/ │ └── ... ├── val/ │ ├── 1/ │ ├── 2/ │ └── ... └── test/ ├── 1/ ├── 2/ └── ...
The names of the classes should thus correctly correspond to folder names of the folder wherein the images of that given class are stored.
Question
Are you familiar with the "[...] ERROR ❌️ requires 2 classes, not 102 [...]" error? What are the most common solutions to this problem?
Many thanks!
Glenn JocherUltralytics@D3RK0 it seems the model configuration is set to expect 2 classes instead of 102. Ensure that the
ncparameter in your model configuration matches the number of classes in your dataset. Adjust the model configuration tonc: 102to resolve this issue.D3RK0(已编辑)
@glenn-jocher Many thanks for your quick response!
How can I do that? I mean, as you can see from the content of my .yaml-file, the
ncparameter is already set to 102 andncis not an accepted hyperparameter in theYOLO()ormodel.train()function.
Glenn JocherUltralytics@D3RK0 ensure the model is correctly configured by setting
nc: 102in the model's YAML file before training. If the issue persists, verify that the model weights are compatible with the number of classes.xcf1
Hello, I'd like to ask you a question. In the evaluation results I generated, the scores.txt file shows AP: 0.429, AP_50: 0.702, AP_75: 0.457, AP_medium: 0.338, AP_large: 0.555, AR: 0.490, AR_50: 0.725, AR_75: 0.536, AR_medium: 0.385, AR_large: 0.632. However, in the stdout.txt file, 0.429 is the value for AP_0.50:0.95. So, I'm confused about where to find the official COCO AP and AR values. Below are screenshots of my two text files, the first being scores.txt and the second being stdout.txt.
Glenn JocherUltralytics(已编辑)The official COCO AP (Average Precision) metric is AP@0.50:0.95 which corresponds to the 0.429 value in your results. This matches both your scores.txt AP value and stdout.txt AP_0.50:0.95. For full details on COCO evaluation metrics, see the official COCO evaluation documentation.
-
rakezshre
Hi, I wanted to use MVTec dataset for training in Ultralytics framework with yolo. But the dataset doesnt have labelling but instead it has ground_truth with some parameters and masking. Is it possible to make a yaml file for the MVTec dataset (most easiest way)? If there is any method. Please let me know.
Thanks.
Glenn JocherUltralyticsTo use the MVTec dataset with YOLO, you'll need to convert the ground truth and masks into YOLO format. This involves creating bounding box annotations and a
data.yamlfile. You can refer to the Ultralytics documentation for guidance on dataset preparation and formatting. If you have further questions, feel free to ask!rakezshre
Is there any easyway to convert MVTec dataset with YOLO with ground truth and masks. It consists of large dataset and creating bounding box annotation seems time consuming. I can see the ultralytics format for data.yaml. But issue is with the bounding box consversion.
Glenn JocherUltralyticsTo convert the MVTec dataset for YOLO, you'll need to create bounding box annotations from the masks and ground truth. Tools like LabelImg can help with manual annotation. Once you have the annotations, you can format them into YOLO's required structure and create a
data.yamlfile. For more details, visit the Ultralytics documentation on dataset preparation.
Andriw75
I am usually interested in understanding what data I am adding to my dataset, as this can be beneficial or harmful depending on the project. I am trying to initialize the YOLO dataset to apply transformations required by the training parameters, but I often encounter errors. Thank you in advance for your help!
from ultralytics.data.dataset import YOLODataset, v8_transforms from ultralytics.engine.trainer import check_det_dataset
class Hyperparameters: def init(self, hyp_dict): for key, value in hyp_dict.items(): setattr(self, key, value)
Initialize the YOLO dataset
dataset = YOLODataset( img_path="path/to/images", # Replace with your image path data=check_det_dataset("path/to/dataset.yaml"), # Replace with your dataset configuration imgsz=640, batch_size=1 )
Define hyperparameters for transformations
hyp = { "mosaic": 1.0, "copy_paste": 0.5, "degrees": 10.0, "translate": 0.2, "scale": 0.9, "shear": 0.5, "perspective": 0.4, "copy_paste_mode": 'flip', 'mixup': 0.5, 'hsv_h': 0.1, 'hsv_s': 0.1, 'hsv_v': 0.1, 'flipud': 0.1, 'fliplr': 0.1 }
hyperparams = Hyperparameters(hyp)
Apply transformations to the dataset
transforms = v8_transforms(dataset, imgsz=640, hyp=hyperparams)
Attempt to augment data
augmented_data = transforms(dataset[0])
albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8)) albumentations: Blur(p=0.01, blur_limit=(3, 7)), MedianBlur(p=0.01, blur_limit=(3, 7)), ToGray(p=0.01, num_output_channels=3, method='weighted_average'), CLAHE(p=0.01, clip_limit=(1, 4.0), tile_grid_size=(8, 8))
Error Encountered When I run the code, I encounter the following error: ValueError: could not broadcast input array from shape (0,640,640) into shape (364,640,640) the size always changes
Glenn JocherUltralytics@Andriw75 it seems like the error might be due to mismatched image sizes. Ensure all images in your dataset are correctly sized to 640x640 before applying transformations. If the issue persists, double-check your dataset paths and configuration. For further details, you can refer to the Ultralytics documentation on datasets.
MehrsaMashhadi
Hello. I hope you are doing well. I have paired RGB and thermal images, and I want to train yolov9 with 4 channel data. I want the model to read the first 3 channels from the RGB folder, and the thermal image from the thermal folder. all of the paired images have the same name, they are in different folders named ir, and vi. can you please help me how I should address this to the model?
Glenn JocherUltralytics@MehrsaMashhadi to train YOLOv9 with 4-channel data, you'll need to modify the data loading process to combine RGB and thermal images into a single input. You can create a custom dataset class that reads images from both folders and concatenates them into a 4-channel tensor. Ensure your model architecture supports 4-channel input. For more details, refer to the dataset customization section in the Ultralytics documentation.
toxanbi
I am absolute newbiew in machine learning coming from the world of low-level and system programming (drivers, firmware, electronics and so on). I have some questions.
-
Is my understanding correct that in machine learning there is a term 'model' which denotes an interconnect of neurons, i.e. the topogy of a neural network, a data structure describing how neurons are connected to each other, and, on the other hand, there is a 'weights' or 'weight file' which holds coefficients describing how signals (stymulus, activations) of a particular neuron influences on other neurons? If this is correct, which one of these two is represented by .pt-file? Or .pt file holds both of these? What is anatomy of .pt-files and where can I learn about it?
-
Let's assume that we are going to make a NN which can classify or detect three types of objects: cats, frogs and birds. What is optimal strategy of mastering a dataset to learn it: a) A given images must contain either one of these object (annotated by bounding box) b) A given image must contain multiple objects of the same type. c) It's better for every image to have all three instances of these kinds on it c-a) And it's better to not overlap. c-b) And, countrary, it's better to have overlapping to learn NN to handle such cases.
Should I feed NN with a pictures which doesn't have objects of interest at all or it is useless?
-
Now instead of having three categories (cats, frogs and birds) we are going to add yet another one which is "other live-forms". Is it a good practive to feed NN with tonns of images of completely different (visually) animals all tagged (annotated) as "other live-forms" or it's better to annotate each animal (other than cat, frog or bird) by setting a class corresponding to their real-world kind? Won't it confuse a NN if crocodiles and kangooros are all annotated as the object of same class? I presume that a process of learning/training is all about finding a features which uniquelly distinguish one class of objects from the others by finding proper weights/coefficients and if vast variety of totally different objects must be considered all having the same type, it may be impossible to find proper weights at all. Or it's not the case? If it is, seems that for that particular task one should use two different NNs: one to distinguisth alive objects for non-alive, and the second stage NN to detect cats/frogs/dogs (and if the second one doesn't detect either of these, but the first one detected a life-form, then it is considered "other life-form").
-
It's stated that default YOLO models which are available on this website are pretrained on COCO dataset. I saw a discussion on whether it's better to learn your NN from scratch or use a model pretrained on COCO. From my point of view traning a model (which was originally trained on COCO dataset) on your own dataset does only make sense if your custom dataset has exactly the same combinartion of 80 classes as COCO? And if you have less categories than COCO or more categories or even exactly 80 but of completely different types (e.g. you are learning NN to distinguish 80 kinds of vehicle motors), then the only option is learning from scratch?
-
I can't find a complete and strict definition of that the term 'val' or 'validation' means in context of training a model? Does it affects behaviour of the model or it is just a way to see how well training went?
-
When we learn a model to detect cats we feed it with images of what is DEFINITELY a cat. But is there a way to show it depiciting objects that are DEFINITELY NOT a cat to avoid false-positives? Other than introducing separate categories for objects that looks very similar to a cat and may be confused with cats but are not really a cat.
-
Many articles and videos tell us that YOLO format of labels is just s plain-text file with separate line for every label and each line consists of 5 fields; class-id and normalized coordinates of a bounding-box. But what about instance segmentation tasks? Oriented boundong box detection? Bone prediction (aka post)? Doesn't it require completely different and more complex format of annotations (compared to just specifying bounding box)?
Glenn JocherUltralytics@toxanbi 1. Your understanding is correct. The
.ptfile in PyTorch contains both the model architecture and the weights. You can learn more about the anatomy of.ptfiles in the PyTorch documentation.-
For optimal dataset creation, include diverse scenarios: single objects, multiple objects, overlapping objects, and images without objects. This helps the model generalize better.
-
It's better to have specific classes for different animals rather than a generic "other live-forms" class. This avoids confusion and improves model accuracy.
-
Pretraining on COCO is beneficial even if your dataset differs. Transfer learning can help the model learn faster and perform better, even with different categories.
-
Validation (val) is used to evaluate the model's performance on a separate dataset during training. It doesn't affect the model's behavior but helps monitor training progress.
-
To reduce false positives, you can include images without the target object in your training dataset. This helps the model learn what not to detect.
-
For tasks like instance segmentation, oriented bounding boxes, and pose estimation, the annotation format is more complex. Refer to the specific task documentation for details on the required annotation formats.
-
-
WARHE8D
Hello, how can i update my model and dataset to public? I only see 2 options private and anyone with link. thanks!
Paula DerrengerUltralytics@WARHE8D to make your model and dataset public, you need to ensure they are properly shared on a platform that supports public access. Currently, the options you mentioned ("private" and "anyone with link") are likely platform-specific settings. If you're using a service like Google Drive or Dropbox, you may need to adjust the sharing settings to "public" or "anyone with the link can view." For more detailed steps on contributing datasets to Ultralytics, please refer to the Contribute New Datasets section in our documentation.
1
1729asraful
I have 47 classes csv file. each file contains 100 images in csv formate with label. now how I can traine it?
Glenn JocherUltralytics(已编辑)@1729asraful hi there!
To train your model using a CSV file containing 47 classes and 100 images per class, you'll need to follow a few steps to prepare your data and then use the Ultralytics YOLO framework for training. Here’s a concise guide to get you started:
Step 1: Convert CSV to YOLO Format
First, you need to convert your CSV annotations into the YOLO format. Each image should have a corresponding
.txtfile with annotations in the format:<class> <x_center> <y_center> <width> <height>Where:
<class>is the class index (0 to 46 for your 47 classes).<x_center>,<y_center>,<width>, and<height>are normalized values (between 0 and 1) relative to the image dimensions.
Step 2: Organize Your Dataset
Organize your dataset into the following structure:
dataset/ ├── train/ │ ├── images/ │ └── labels/ └── val/ ├── images/ └── labels/Place your images in the
images/directories and the corresponding YOLO format annotation files in thelabels/directories.Step 3: Create a
data.yamlFileCreate a
data.yamlfile in the root of your dataset directory with the following content:train: path/to/dataset/train/images val: path/to/dataset/val/images nc: 47 # number of classes names: [class0, class1, ..., class46] # list of class namesStep 4: Train Your Model
You can now train your model using the Ultralytics YOLO framework. Here’s an example using the CLI:
yolo detect train data=path/to/data.yaml model=yolo26n.pt epochs=100 imgsz=640Or using Python:
from ultralytics import YOLO # Load a model model = YOLO('yolo26n.pt') # load a pretrained model # Train the model results = model.train(data='path/to/data.yaml', epochs=100, imgsz=640)Additional Resources
For more detailed information on dataset preparation and training, please refer to the Ultralytics Datasets Documentation.
If you encounter any issues, please provide a minimum reproducible example so we can assist you better. You can find more details on how to create one here.
Happy training! 🚀
1729asraful
Thanks a lot
Glenn JocherUltralytics(已编辑)@1729asraful you're welcome! 😊
To train your model using a CSV file containing 47 classes and 100 images per class, you'll need to convert your CSV annotations into the YOLO format and organize your dataset accordingly. Here’s a step-by-step guide:
Step 1: Convert CSV to YOLO Format
First, convert your CSV annotations into the YOLO format. Each image should have a corresponding
.txtfile with annotations in the format:<class> <x_center> <y_center> <width> <height>Where:
<class>is the class index (0 to 46 for your 47 classes).<x_center>,<y_center>,<width>, and<height>are normalized values (between 0 and 1) relative to the image dimensions.
Step 2: Organize Your Dataset
Organize your dataset into the following structure:
dataset/ ├── train/ │ ├── images/ │ └── labels/ └── val/ ├── images/ └── labels/Place your images in the
images/directories and the corresponding YOLO format annotation files in thelabels/directories.Step 3: Create a
data.yamlFileCreate a
data.yamlfile in the root of your dataset directory with the following content:train: path/to/dataset/train/images val: path/to/dataset/val/images nc: 47 # number of classes names: [class0, class1, ..., class46] # list of class namesStep 4: Train Your Model
You can now train your model using the Ultralytics YOLO framework. Here’s an example using the CLI:
yolo detect train data=path/to/data.yaml model=yolo26n.pt epochs=100 imgsz=640Or using Python:
from ultralytics import YOLO # Load a model model = YOLO('yolo26n.pt') # load a pretrained model # Train the model results = model.train(data='path/to/data.yaml', epochs=100, imgsz=640)For more detailed information on dataset preparation and training, please refer to the Ultralytics Datasets Documentation.
If you encounter any issues, please provide a minimum reproducible example so we can assist you better. You can find more details on how to create one here.
Happy training! 🚀
Llll0l0l
Hello, I'm new to machine learning, is it possible to train videos? i turned them into imgs however will it understand that the label belongs to continuous imgs that are sequential ?
Thank you for reading
Paula DerrengerUltralytics(已编辑)@Llll0l0l hello,
Welcome to the world of machine learning! 🌟 Yes, it is indeed possible to train models using video data. Converting videos into sequential images is a common practice. However, to ensure that the model understands the temporal context (i.e., that the images are sequential and belong to a continuous video), you might want to consider using multi-object tracking (MOT) techniques.
In multi-object tracking, the model not only detects objects in each frame but also assigns a unique ID to each detected object, maintaining this ID across frames. This way, the model can track the movement and changes of objects over time, understanding the sequential nature of the data.
Here’s a brief overview of how you can approach this:
- Convert Video to Frames: You’ve already done this step by converting your video into images.
- Annotate Frames: Ensure that your images are annotated correctly. Each frame should have annotations that indicate the presence and location of objects.
- Use a Multi-Object Tracking Model: Ultralytics supports various models and configurations for multi-object tracking. You can use models like YOLO26 with trackers such as BoT-SORT or ByteTrack.
Here’s a simple example of how you can set up multi-object tracking using YOLO26:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # Load an official model # Perform tracking on a video source results = model.track("path/to/your/video.mp4", show=True) # Tracking with default trackerFor more detailed guidance, you can refer to the Ultralytics documentation on multi-object tracking.
If you encounter any issues or need further assistance, please ensure you are using the latest version of the Ultralytics packages. Additionally, providing a minimum reproducible example can greatly help in diagnosing and resolving any problems. You can find more information on creating a reproducible example here.
Happy experimenting, and feel free to reach out if you have more questions! 😊
Llll0l0l
Thank you very much)
Paula DerrengerUltralytics(已编辑)Hello @Llll0l0l,
Thank you for your kind words! 😊
Regarding your question about training on video data: converting videos into sequential images is a great start. However, to ensure the model understands the temporal context, you might want to explore multi-object tracking (MOT) techniques. These techniques help the model maintain object identities across frames, effectively understanding the continuity in the sequence.
Here's a brief guide on how to proceed:
- Convert Video to Frames: As you've done, convert your video into individual frames.
- Annotate Frames: Ensure each frame is annotated correctly. This involves labeling objects in each frame.
- Use Multi-Object Tracking: Utilize models like YOLO26 with trackers such as BoT-SORT or ByteTrack to maintain object identities across frames.
Here’s an example of how you can set up multi-object tracking using YOLO26:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # Load an official model # Perform tracking on a video source results = model.track("path/to/your/video.mp4", show=True) # Tracking with default trackerFor more detailed guidance, you can refer to the Ultralytics documentation on multi-object tracking.
If you encounter any issues, please ensure you are using the latest version of the Ultralytics packages. Providing a minimum reproducible example can also greatly help in diagnosing and resolving any problems. You can find more information on creating a reproducible example here.
Feel free to reach out if you have more questions. Happy experimenting! 🚀