Upload 101 files

README.md

@@ -1,3 +1,158 @@
----
-license: mit
----
+# 汉字识别YOLOv11项目
+
+## 运行环境配置
+
+1. Python环境:
+```bash
+conda create -n yolov11 python=3.11
+conda activate yolov11
+```
+
+2. 安装PyTorch (CUDA 12.6版本):
+```bash
+pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu126
+```
+
+3. 安装项目依赖:
+```bash
+pip install -r requirements.txt
+```
+
+4. 验证CUDA可用性:
+```python
+import torch
+print(torch.cuda.is_available())  # 应输出True
+print(torch.cuda.device_count())  # 应输出GPU数量
+```
+
+## 项目概述
+本项目基于YOLOv11实现汉字识别功能，包含完整的数据集准备、模型训练、测试评估和预测推理流程。
+
+## 文件结构说明
+```
+.
+├── get_dataset.py       # 数据集准备脚本
+├── load_model.py        # 模型加载工具，包括直接加载yolo模型或者选择加载底层的torch.nn.Module模型
+├── train.py            # 模型训练脚本
+├── test.py             # 模型测试脚本  
+├── predict.py          # 预测推理脚本
+├── yolo11n.pt          # 预训练模型
+|── best_model.pt        # 训练得到的最佳模型，对应为train9的得到的最好的模型
+├── runs/               # 训练结果和预测输出
+│   ├── detect/
+│   │   ├── train*/     # 训练、测试集测试日志和权重
+│   │   └── predict/    # 预测结果
+└── ultralytics/
+    └── cfg/
+        └── default.yaml # 训练配置文件
+```
+
+## 数据集准备
+1. 准备数据目录结构：
+```
+Data/
+└── data/
+    ├── 00001/  # 以Unicode编码命名的文件夹
+    │   ├── 1.jpg
+    │   └── ...
+    ├── 00002/
+    └── ...
+```
+
+2. 准备字符映射文件`char_dict.json`，格式示例：
+```json
+{
+    "1": "一",
+    "2": "二",
+    ...
+}
+```
+
+3. 运行数据准备脚本：
+```bash
+python get_dataset.py
+```
+脚本将自动：
+- 扫描图像文件并匹配类别
+- 划分训练集/验证集/测试集
+- 生成YOLO格式数据集和dataset.yaml，文件保存在项目同一级的根目录yolo_hanzi_dataset/
+- 特别注意您的原始数据集路径和字符映射文件路径，以及yolo格式的数据路径，因为这个路径在训练、测试和预测过程中都会用到。
+
+## 模型训练
+1. 修改训练配置：
+编辑`ultralytics/cfg/default.yaml`调整超参数
+
+2. 开始训练：
+```bash
+conda activate yolov11
+python train.py
+```
+训练过程将：
+- 加载预训练模型yolo11n.pt
+- 使用dataset.yaml配置数据集
+- 保存训练日志和权重到runs/detect/train*
+- 注意您的训练配置文件以及数据配置文件路径
+
+## 测试评估
+```bash
+conda activate yolov11
+python test.py
+```
+测试将：
+- 加载最佳模型(runs/detect/train*/weights/best.pt)
+- 在测试集上评估模型性能
+- 输出mAP指标和可视化结果
+- 注意您的测试配置文件路径以及测试模型路径
+
+## 预测推理
+```bash
+conda activate yolov11
+python predict.py
+```
+预测功能：
+- 加载训练好的模型
+- 对单张图片进行预测
+- 显示和保存预测结果
+- 打印检测到的汉字类别和置信度
+- 注意您的预测图像路径以及预测模型路径
+
+## 常见问题
+1. 数据集准备失败：
+- 检查数据目录结构是否正确
+- 确认char_dict.json编码和格式正确
+- 确保图像文件具有读取权限
+- 检查数据集路径配置正确
+
+2. 训练过程中断：
+- 检查CUDA内存是否不足，可减小batch size以及图片size
+- 确保数据集路径配置正确
+
+3. 训练测试效果不佳：
+- 模型过拟合：尝试使用更小的batch size和epochs，增大早停止的周期数。
+- 模型欠拟合：尝试使用更复杂的模型架构，汉字识别项目数据增强可能过度，导致不必要的增强。增加图片size大小可能能提高性能。
+
+4. 预测结果不准确：
+- 检查训练数据是否充足
+- 尝试调整置信度阈值(修改predict.py中的conf参数)
+- 考虑使用更精确的标注数据
+
+## 性能指标
+典型训练结果：
+- [email protected]: 0.90-0.95
+- [email protected]:0.95: 0.90-0.95
+
+![训练效果图](runs\detect\train9\results.png)
+
+典型测试结果：
+![测试效果图](runs\detect\val9\val_batch2_pred.jpg)
+![测试效果图](runs\detect\val9\confusion_matrix.png)
+
+典型预测结果：
+![预测效果图](runs\detect\predict2\image0.jpg)
+![预测效果图](runs\detect\predict\image0.jpg)
+
+
+
+## 后续改进
+1. 该模型的预测精度高达0.97，后期可以尝试使用更小的模型————在保证精度可控的范围内，缩短训练以及推理时间。
+2. 可以扩展到边缘设备，增加模型部署的效率。

best_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96c780db6ffc12f4832f30d424284dd7230cb4b65d79fdfa98f728361a632be5
+size 5814227

get_dataset.py

@@ -0,0 +1,389 @@
+import os
+import json
+import shutil
+import random
+from glob import glob
+from sklearn.model_selection import train_test_split
+from tqdm import tqdm  # For progress bars
+
+# --- 1. 配置参数 ---
+data_root = r'D:\不会编程\CVPR\class_project\Data\data'  # 包含501个文件夹的根目录，原始数据文件路径
+char_dict_path = r'D:\不会编程\CVPR\class_project\char_dict.json'# 字符映射文件
+output_dir = r'D:\不会编程\CVPR\class_project\yolo_hanzi_dataset'  # 输出 YOLO 格式数据集的目录名
+
+# 划分比例
+val_size = 0.15  # 验证集比例
+test_size = 0.15  # 测试集比例 (相对于原始总数)
+# train_size = 1.0 - val_size - test_size
+
+# 边界框假设 (覆盖整个图像)
+# <class_index> <x_center_norm> <y_center_norm> <width_norm> <height_norm>
+bbox_annotation = "0.5 0.5 1.0 1.0" # x_center, y_center, width, height (归一化)
+
+# 随机种子，确保结果可复现
+random_seed = 42
+random.seed(random_seed)
+
+# --- 2. 加载字符映射 ---
+print("加载 Char_dict.json...")
+try:
+    with open(char_dict_path, 'r', encoding='utf-8') as f: # 尝试UTF-8
+        char_dict_raw = json.load(f)
+except UnicodeDecodeError:
+    try:
+        with open(char_dict_path, 'r', encoding='ansi') as f: # 如果UTF-8失败，尝试ANSI (GBK/CP936等)
+            char_dict_raw = json.load(f)
+            print("警告: Char_dict.json 使用 ANSI 编码读取，建议转换为 UTF-8。")
+    except Exception as e:
+        print(f"错误: 无法读取 Char_dict.json。请确保文件存在且编码正确 (UTF-8 或 ANSI)。错误信息: {e}")
+        exit()
+except FileNotFoundError:
+    print(f"错误: 找不到 Char_dict.json 文件，路径: {char_dict_path}")
+    exit()
+except json.JSONDecodeError as e:
+    print(f"错误: Char_dict.json 文件格式无效。错误信息: {e}")
+    exit()
+
+
+
+
+
+print(f"从 JSON 文件加载了 {len(char_dict_raw)} 个原始映射条目。")
+
+# --- 扫描数据文件夹，获取实际存在的类别键 ---
+print(f"扫描数据目录 '{data_root}' 以确定实际存在的类别...")
+actual_unicode_keys = set()
+try:
+    data_folders = [d for d in os.listdir(data_root) if os.path.isdir(os.path.join(data_root, d))]
+    print(f"找到 {len(data_folders)} 个文件夹。")#获取实际存在的类别
+    for folder_name in data_folders:
+        try:
+            # 尝试将文件夹名 (如 "00699") 转为整数再转为字符串 (如 "699")
+            key = str(int(folder_name))
+            if key in char_dict_raw: # 检查这个键是否在原始 JSON 映射中存在
+                actual_unicode_keys.add(key)
+        except ValueError:
+            # 忽略非数字命名的文件夹
+            pass
+except FileNotFoundError:
+     print(f"错误：无法访问指定的 data_root 目录: {data_root}。")
+     exit()
+except Exception as e:
+    print(f"扫描数据目录时发生错误: {e}")
+    exit()
+
+if not actual_unicode_keys:
+    print(f"错误：在数据目录 '{data_root}' 中没有找到任何与 JSON 文件中的键匹配的文件夹。")
+    exit()
+
+print(f"根据文件夹名称，确定了 {len(actual_unicode_keys)} 个实际存在的有效类别键。")
+
+# ---基于实际存在的键来创建映射 ---
+# 对实际存在的键进行排序，以确保 class_id 分配顺序固定
+sorted_actual_keys = sorted(list(actual_unicode_keys), key=lambda x: int(x)) # 按数字大小排序
+
+unicode_to_classid = {}#
+classid_to_char = {}#实际存在的类别数量 
+num_classes = 0#类别的数量
+
+print("正在创建过滤后的类别映射...")
+for i, unicode_key in enumerate(sorted_actual_keys):
+    if unicode_key in char_dict_raw:
+        # 获取原始字符，并清理末尾的 \u0000 (空字符)
+        original_char = char_dict_raw[unicode_key]
+        cleaned_char = original_char.replace('\u0000', '') # 移除空字符
+
+        # 跳过空的类别名称 (来自 key "0": "")
+        if not cleaned_char:
+            print(f"警告：键 '{unicode_key}' 对应的字符为空，将跳过此类别。")
+            continue
+
+        class_id = num_classes # 分配从 0 开始的连续 ID
+        unicode_to_classid[unicode_key] = class_id
+        classid_to_char[class_id] = cleaned_char
+        num_classes += 1 # 只有成功添加了才增加类别计数
+    else:
+        #理论上这里不应该发生，因为 actual_unicode_keys 已经是过滤过的
+        print(f"内部错误：键 '{unicode_key}' 未在 char_dict_raw 中找到，尽管它在 actual_unicode_keys 中。")
+
+if num_classes == 0:
+    print("错误：过滤后没有有效的类别。请检查文件夹名称、JSON内容和脚本逻辑。")
+    exit()
+
+print(f"最终确定使用 {num_classes} 个有效类别进行处理。")
+
+print("有效类别映射 (部分示例):")
+# 打印前几个和后几个有效类别，检查是否正确
+example_keys = list(unicode_to_classid.keys())
+for i in range(min(5, num_classes)):
+    key = example_keys[i]
+    class_id = unicode_to_classid[key]
+    char = classid_to_char[class_id]
+    print(f"  Class ID: {class_id}, Key: {key}, Character: '{char}'")
+if num_classes > 10:
+    print("  ...")
+    for i in range(max(5, num_classes - 5), num_classes):
+        key = example_keys[i]
+        class_id = unicode_to_classid[key]
+        char = classid_to_char[class_id]
+        print(f"  Class ID: {class_id}, Key: {key}, Character: '{char}'")
+
+# --- 第 3 步扫描图像文件等）应该基于过滤后的 unicode_to_classid 工作 ---
+# 
+
+
+
+# --- 3. 发现所有图像文件 ---
+print("扫描图像文件...")
+# all_image_paths: 存储所有找到的图像文件路径
+# all_labels: 存储每个图像对应的类别ID (与all_image_paths一一对应)
+all_image_paths = []
+all_labels = []
+
+# 支持常见的图像格式 (用于glob模式匹配)
+image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.bmp', '*.gif']
+
+# --- 3.1 扫描数据目录 ---
+print(f"正在扫描根目录: {data_root}")
+# found_folders: 统计找到的文件夹总数
+# processed_folders: 统计成功处理(有对应类别)的文件夹数
+found_folders = 0
+processed_folders = 0
+
+# 显式列出data_root下的内容，帮助调试和验证
+# 注意: 这里会列出所有文件和文件夹，但只有符合数字命名规则的文件夹会被处理
+try:
+    root_contents = os.listdir(data_root)
+    print(f"在 {data_root} 中找到 {len(root_contents)} 个项目 (文件/文件夹)")
+    # print(f"前10个项目: {root_contents[:10]}") # 如果需要可以取消注释看具体名称
+except FileNotFoundError:
+    print(f"错误：无法访问指定的 data_root 目录: {data_root}。请确保路径正确且程序有权限访问。")
+    exit()
+except Exception as e:
+    print(f"访问目录 {data_root} 时发生未知错误: {e}")
+    exit()
+
+
+# 遍历根目录下的所有项目(文件/文件夹)
+# 使用tqdm显示进度条，desc参数设置进度条描述文本
+for item_name in tqdm(root_contents, desc="扫描项目"):
+    item_path = os.path.join(data_root, item_name)
+
+    if os.path.isdir(item_path):
+        found_folders += 1
+        # 文件夹名称，例如 "00699"
+        unicode_index_folder_padded = item_name
+
+        try:
+            # 尝试将带前导零的文件夹名称转换为整数，再转回普通字符串（去除前导零）
+            # 例如 "00699" -> 699 -> "699"
+            unicode_index_int = int(unicode_index_folder_padded)
+            unicode_index_key = str(unicode_index_int)
+
+            # 使用转换后的 key (如 "699") 在字典中查找
+            if unicode_index_key in unicode_to_classid:
+                processed_folders += 1
+                class_id = unicode_to_classid[unicode_index_key]
+                image_count_in_folder = 0
+                for ext in image_extensions:
+                    # 使用 glob 查找当前文件夹下所有匹配扩展名的图片
+                    # 注意这里使用 item_path
+                    folder_images = glob(os.path.join(item_path, ext))
+                    for img_path in folder_images:
+                        all_image_paths.append(img_path)
+                        all_labels.append(class_id)
+                        image_count_in_folder += 1
+
+
+            else:
+                # 如果转换后的 key 仍然找不到，显示警告 (只显示前几个)
+                if processed_folders < 5 and found_folders <= 20: # 控制警告数量
+                     print(f"警告: 从文件夹名称 '{unicode_index_folder_padded}' 导出的键 '{unicode_index_key}' 在 Char_dict.json 中没有对应的条目，将跳过此文件夹。")
+
+        except ValueError:
+            # 如果文件夹名称不是纯数字 (例如可能是 .git, Thumbs.db 或其他非数据文件夹)，则忽略
+            if found_folders <= 10: # 只显示前几个非数字文件夹警告
+                print(f"信息: 跳过非预期格式的文件夹/文件: '{unicode_index_folder_padded}'")
+        except Exception as e:
+             print(f"处理文件夹 {item_name} 时发生错误: {e}")
+
+
+
+print(f"总共扫描了 {found_folders} 个文件夹。")
+print(f"其中 {processed_folders} 个文件夹的名称与 Char_dict.json 中的键成功匹配。")
+
+
+if not all_image_paths:
+    print(f"错误: 在目录 '{data_root}' 下及其与 JSON 匹配的子文件夹中，没有找到任何支持的图像文件。")
+    print(f"请再次检查：")
+    print(f"1. 路径 '{data_root}' 是否正确?")
+    print(f"2. 匹配的文件夹 (如 {processed_folders} 个) 中是否真的包含 {', '.join(image_extensions)} 格式的图片文件?")
+    print(f"3. 文件权限是否允许读取?")
+    exit()
+
+print(f"总共找到 {len(all_image_paths)} 个图像文件。")
+
+
+
+
+
+
+
+
+# --- 4. 划分数据集 ---
+print("划分数据集 (Train/Validation/Test)...")
+# 使用sklearn的train_test_split进行分层抽样划分，确保每个集合中的类别分布均衡
+# 先分出测试集，再从剩余数据中分出验证集
+# 确保标签列表是整数类型，并且图像和标签列表长度一致
+assert len(all_image_paths) == len(all_labels)
+labels_int = [int(label) for label in all_labels] # 确保是整数
+
+# 第一次划分: 先分出测试集
+# test_size: 测试集占总数据的比例
+# stratify: 按标签分层抽样，保持类别分布
+train_val_paths, test_paths, train_val_labels, test_labels = train_test_split(
+    all_image_paths,
+    labels_int,
+    test_size=test_size,
+    random_state=random_seed,
+    stratify=labels_int # 确保测试集中类别分布与总体相似
+)
+
+# 第二次划分: 从剩余数据(train_val)中分出验证集
+# 计算验证集在剩余数据中的相对比例(relative_val_size)
+# 例如: 总数据1000，test_size=0.15 → 测试集150，剩余850
+# val_size=0.15 → 验证集应该是150/850 ≈ 0.1765
+relative_val_size = val_size / (1.0 - test_size)
+
+train_paths, val_paths, train_labels, val_labels = train_test_split(
+    train_val_paths,
+    train_val_labels,
+    test_size=relative_val_size,
+    random_state=random_seed, # 使用相同的随机种子确保可复现性（如果需要拆分独立）
+    stratify=train_val_labels # 确保验证集中类别分布与 (train+val) 相似
+)
+
+print(f"划分结果:")
+print(f"  训练集: {len(train_paths)} 张图片")
+print(f"  验证集: {len(val_paths)} 张图片")
+print(f"  测试集: {len(test_paths)} 张图片")
+
+# --- 5. 创建 YOLO 目录结构并处理文件 ---
+print(f"创建 YOLO 格式数据集到 '{output_dir}'...")
+
+# 定义数据集划分后的路径和标签
+# 使用字典存储三个数据集(train/val/test)的路径和对应标签
+sets = {
+    'train': (train_paths, train_labels),
+    'val': (val_paths, val_labels),
+    'test': (test_paths, test_labels)
+}
+
+if os.path.exists(output_dir):
+    print(f"警告: 输出目录 '{output_dir}' 已存在，将清空并重新创建。")
+    shutil.rmtree(output_dir)
+
+# 创建目录结构
+os.makedirs(os.path.join(output_dir, 'images', 'train'), exist_ok=True)
+os.makedirs(os.path.join(output_dir, 'labels', 'train'), exist_ok=True)
+os.makedirs(os.path.join(output_dir, 'images', 'val'), exist_ok=True)
+os.makedirs(os.path.join(output_dir, 'labels', 'val'), exist_ok=True)
+os.makedirs(os.path.join(output_dir, 'images', 'test'), exist_ok=True)
+os.makedirs(os.path.join(output_dir, 'labels', 'test'), exist_ok=True)
+
+# --- 5.1 处理文件：复制图像并创建标注文件 ---
+# 对每个数据集(train/val/test)分别处理:
+# 1. 复制图像文件到目标目录
+# 2. 创建对应的YOLO格式标注文件(.txt)
+# 3. 使用唯一文件名避免冲突(父文件夹名+原文件名)
+for set_name, (paths, labels) in sets.items():
+    print(f"处理 {set_name} 集...")
+    image_dir = os.path.join(output_dir, 'images', set_name)
+    label_dir = os.path.join(output_dir, 'labels', set_name)
+
+    for img_path, class_id in tqdm(zip(paths, labels), total=len(paths), desc=f"  拷贝和生成标注 ({set_name})"):
+        # 文件名处理:
+        # 1. 获取原始文件名（带扩展名）
+        base_filename = os.path.basename(img_path)
+        # 2. 获取文件名（不带扩展名）
+        filename_no_ext = os.path.splitext(base_filename)[0]
+
+        # --- 生成唯一文件名 ---
+        # 由于不同文件夹下的图片可能有相同的文件名（如都叫 001.jpg），
+        # 需要确保目标目录中的文件名唯一。
+        # 解决方案: 使用"父文件夹名_原文件名"作为新文件名
+        # 例如: "00699_001.jpg" 和 "00700_001.jpg" 可以共存
+        parent_folder_name = os.path.basename(os.path.dirname(img_path))
+        unique_filename_no_ext = f"{parent_folder_name}_{filename_no_ext}"
+        unique_base_filename = f"{unique_filename_no_ext}{os.path.splitext(base_filename)[1]}"
+
+        # 目标图像路径
+        dest_img_path = os.path.join(image_dir, unique_base_filename)
+        # 目标标注文件路径
+        dest_label_path = os.path.join(label_dir, f"{unique_filename_no_ext}.txt")
+
+        # 1. 复制图像文件
+        try:
+             shutil.copy2(img_path, dest_img_path) # copy2 保留元数据
+        except Exception as e:
+            print(f"\n错误: 无法复制文件 {img_path} 到 {dest_img_path}. 错误: {e}")
+            continue # 跳过这个文件
+
+        # 2. 创建并写入标注文件 (使用假设的边界框)
+        annotation_line = f"{class_id} {bbox_annotation}\n"
+        try:
+            with open(dest_label_path, 'w', encoding='utf-8') as f_label:
+                f_label.write(annotation_line)
+        except Exception as e:
+            print(f"\n错误: 无法写入标注文件 {dest_label_path}. 错误: {e}")
+            # 如果写入失败，最��也把对应的图片删除，避免数据不一致
+            if os.path.exists(dest_img_path):
+                os.remove(dest_img_path)
+
+# --- 6. 生成 dataset.yaml 文件 ---
+# YOLO训练需要此配置文件，包含:
+# - 数据集路径
+# - 训练/验证/测试集路径
+# - 类别数量和名称列表
+print("生成 dataset.yaml...")
+
+# 获取排序后的类别名称列表
+class_names = [classid_to_char[i] for i in range(num_classes)]
+
+# 创建 YAML 内容
+# 路径可以是相对路径（相对于你运行训练脚本的位置）或绝对路径
+# 这里使用相对路径，假设会在 yolo_hanzi_dataset 的上一级目录运行训练
+yaml_content = f"""
+# YOLOv11 dataset configuration file
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: {os.path.abspath(output_dir)}  # dataset root dir (绝对路径通常更可靠)
+train: images/train  # train images (relative to 'path')
+val: images/val  # val images (relative to 'path')
+test: images/test # test images (optional)
+
+# Classes
+nc: {num_classes}  # number of classes
+names: {json.dumps(class_names, ensure_ascii=False)} # Use json.dumps for proper list formatting and handling non-ASCII characters
+
+""" # ensure_ascii=False 很重要，用于正确显示汉字
+
+yaml_path = os.path.join(output_dir, 'dataset.yaml')
+try:
+    with open(yaml_path, 'w', encoding='utf-8') as f_yaml:
+        f_yaml.write(yaml_content)
+except Exception as e:
+    print(f"错误: 无法写入 dataset.yaml 文件到 {yaml_path}. 错误: {e}")
+
+print("-" * 30)
+print("数据集准备完成！")
+print(f"YOLO 格式的数据集已生成在: {os.path.abspath(output_dir)}")
+print(f"配置文件为: {os.path.abspath(yaml_path)}")
+print("-" * 30)
+print("重要提示:")
+print("1. 每个图像只包含一个居中的汉字，并为其生成了覆盖整个图像的边界框。")
+print("2. 检查 `dataset.yaml` 文件中的路径是否正确，特别是 `path` 字段。根据你的训练环境可能需要调整。")
+print("3. 检查生成的 `labels` 文件夹中的 .txt 文件内容是否符合预期格式。")
+print("4. 在开始训练前，建议随机抽查几个图片及其对应的标注文件，确保它们正确对应。")
+print("5. 确保 `Char_dict.json` 中的汉字编码与你的系统或训练环境兼容。YAML 文件已使用 UTF-8 编码保存。")
+print("-" * 30)

load_model.py

@@ -0,0 +1,89 @@
+from ultralytics import YOLO
+import torch
+import os
+from torch import nn
+def load_model(model_path: str, device: str = None):#这是返回yolo对象的模型
+    try:
+        # 检查模型路径是否存在
+        if not os.path.isfile(model_path):
+            raise FileNotFoundError(f"模型文件错误，请修改加载路径: {model_path}")
+            
+        # 自动选择设备为GPU
+        if device is None:
+            device = 'cuda' if torch.cuda.is_available() else 'cpu'
+            
+        # 验证设备是否可用
+        if device == 'cuda' and not torch.cuda.is_available():
+            print("警告: CUDA不可用，将使用CPU")
+            device = 'cpu'
+            
+        # 加载模型
+        model = YOLO(model_path).to(device)
+        print(f"成功加载模型到 {device.upper()}")
+        return model
+        
+    except Exception as e:
+        raise RuntimeError(f"加载模型失败: {str(e)}")
+    
+
+
+
+# --------------------------------------------------
+# load_pytorch_module (返回 torch.nn.Module)
+# --------------------------------------------------
+def load_pytorch_module(model_path: str, device: str = None) -> nn.Module:
+    """
+    加载 Ultralytics YOLO 模型文件，并返回底层的 PyTorch nn.Module。
+    这个函数专门用于需要直接获取 torch.nn.Module 实例的场景;例如，检查或特定集成。
+
+    Returns:
+        torch.nn.Module: 底层的 PyTorch 模型实例。
+    """
+    try:
+        # 检查模型路径是否存在
+        if not os.path.isfile(model_path):
+            raise FileNotFoundError(f"模型文件错误，请修改加载路径: {model_path}")
+
+        # 自动选择设备为GPU
+        if device is None:
+            device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+        # 验证设备是否可用
+        if device == 'cuda' and not torch.cuda.is_available():
+            print("警告: CUDA不可用，将使用CPU")
+            device = 'cpu'
+
+        # 1. 先加载 YOLO 对象
+        print(f"使用 YOLO 加载器加载: {model_path}")
+        yolo_wrapper = YOLO(model_path)
+        print("YOLO 加载器加载成功。")
+
+        # 2. 从 YOLO 对象中提取底层的 PyTorch 模型
+        #    通常，这个模型存储在 YOLO 对象的 .model 属性中
+        print("正在提取底层的 torch.nn.Module...")
+        pytorch_model = yolo_wrapper.model
+        if not isinstance(pytorch_model, nn.Module):
+             # 做个健壮性检查，以防未来 Ultralytics 内部结构改变
+             raise TypeError(f"从YOLO对象提取的 '.model' 属性不是 torch.nn.Module 的实例，实际类型为 {type(pytorch_model)}")
+        print(f"成功提取 PyTorch 模型，类型: {type(pytorch_model).__name__}")
+
+        # 3. 将提取出的 PyTorch 模型移动到指定设备
+        print(f"正在将 PyTorch 模型移动到 {device.upper()}...")
+        pytorch_model.to(device)
+        print(f"PyTorch 模型成功移动到 {device.upper()}")
+
+        # 4. 返回这个底层的 PyTorch 模型
+        return pytorch_model
+
+    except Exception as e:
+        raise RuntimeError(f"加载底层 PyTorch 模型失败: {str(e)}")
+    
+
+if __name__ == "__main__":
+    model_path = "best_model.pt"
+    device = "cpu"
+    model = load_pytorch_module(model_path, device)
+    model_yolo=load_model(model_path, device)
+    print('原始的torch模型：',model)
+
+    print('加载yolo模型：',model_yolo)

predict.py

@@ -0,0 +1,19 @@
+from ultralytics import YOLO
+import cv2
+from load_model import load_model 
+#对单张图片进行预测
+def predict(model,image_path):
+    image = cv2.imread(image_path)#加载图片
+    model = load_model(model)#加载yolo模型
+    results = model.predict(source=image, 
+                        save=True,  # 保存预测结果
+                        show=True,   # 显示预测结果
+                        conf=0.5)    # 置信度阈值
+    # 4. 打印预测结果
+    for result in results:
+        print("检测到的对象:")
+        for box in result.boxes:
+            print(f"- 类别: {result.names[box.cls[0].item()]}, 置信度: {box.conf[0].item():.2f}")
+    
+if __name__ == '__main__':
+    predict(r'runs\detect\train9\weights\best.pt',r'..\yolo_hanzi_dataset\images\test\00800_243401.png')

requirements.txt

@@ -0,0 +1,5 @@
+ultralytics>=8.0.0
+opencv-python>=4.5.0
+scikit-learn>=1.0.0
+tqdm>=4.0.0
+numpy>=1.20.0

test.py

@@ -0,0 +1,10 @@
+from load_model import load_model
+#测试集测试代码
+def test(model,data_path):
+    model=load_model(model)#加载测试的yolo模型
+    test_results=model.val(data=data_path, split='test',plots=True,save=True)  # 只在最终评估时使用测试集
+    print(f"测试集[email protected]: {test_results.box.map50:.3f}")
+    print(f"测试集[email protected]:0.95: {test_results.box.map:.3f}")
+
+if __name__ == '__main__':
+    test(r'runs\detect\train9\weights\best.pt',r'..\yolo_hanzi_dataset\dataset.yaml')

train.py

@@ -0,0 +1,14 @@
+import warnings
+warnings.filterwarnings('ignore')
+from load_model import load_model
+def train(base_model,data_path,cfg_path):
+    model = load_model(base_model)#这里直接加载yolo模型训练
+    model.train(data=data_path,#配置数据集的配置文件
+                cfg=cfg_path#数据增强、优化器、周期、模型保存、超参数等配置文件
+                )
+    
+if __name__ == '__main__':
+    train(r"yolo11n.pt",
+          r'..\yolo_hanzi_dataset\dataset.yaml',
+          r'ultralytics\cfg\default.yaml')
+    

ultralytics/cfg/__init__.py

@@ -0,0 +1,1029 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Any, Dict, List, Union
+
+import cv2
+
+from ultralytics.utils import (
+    ASSETS,
+    DEFAULT_CFG,
+    DEFAULT_CFG_DICT,
+    DEFAULT_CFG_PATH,
+    DEFAULT_SOL_DICT,
+    IS_VSCODE,
+    LOGGER,
+    RANK,
+    ROOT,
+    RUNS_DIR,
+    SETTINGS,
+    SETTINGS_FILE,
+    TESTS_RUNNING,
+    IterableSimpleNamespace,
+    __version__,
+    checks,
+    colorstr,
+    deprecation_warn,
+    vscode_msg,
+    yaml_load,
+    yaml_print,
+)
+
+# Define valid solutions
+SOLUTION_MAP = {
+    "count": "ObjectCounter",
+    "crop": "ObjectCropper",
+    "blur": "ObjectBlurrer",
+    "workout": "AIGym",
+    "heatmap": "Heatmap",
+    "isegment": "InstanceSegmentation",
+    "visioneye": "VisionEye",
+    "speed": "SpeedEstimator",
+    "queue": "QueueManager",
+    "analytics": "Analytics",
+    "inference": "Inference",
+    "trackzone": "TrackZone",
+    "help": None,
+}
+
+# Define valid tasks and modes
+MODES = frozenset({"train", "val", "predict", "export", "track", "benchmark"})
+TASKS = frozenset({"detect", "segment", "classify", "pose", "obb"})
+TASK2DATA = {
+    "detect": "coco8.yaml",
+    "segment": "coco8-seg.yaml",
+    "classify": "imagenet10",
+    "pose": "coco8-pose.yaml",
+    "obb": "dota8.yaml",
+}
+TASK2MODEL = {
+    "detect": "yolo11n.pt",
+    "segment": "yolo11n-seg.pt",
+    "classify": "yolo11n-cls.pt",
+    "pose": "yolo11n-pose.pt",
+    "obb": "yolo11n-obb.pt",
+}
+TASK2METRIC = {
+    "detect": "metrics/mAP50-95(B)",
+    "segment": "metrics/mAP50-95(M)",
+    "classify": "metrics/accuracy_top1",
+    "pose": "metrics/mAP50-95(P)",
+    "obb": "metrics/mAP50-95(B)",
+}
+MODELS = frozenset({TASK2MODEL[task] for task in TASKS})
+
+ARGV = sys.argv or ["", ""]  # sometimes sys.argv = []
+SOLUTIONS_HELP_MSG = f"""
+    Arguments received: {str(["yolo"] + ARGV[1:])}. Ultralytics 'yolo solutions' usage overview:
+
+        yolo solutions SOLUTION ARGS
+
+        Where SOLUTION (optional) is one of {list(SOLUTION_MAP.keys())[:-1]}
+              ARGS (optional) are any number of custom 'arg=value' pairs like 'show_in=True' that override defaults 
+                  at https://docs.ultralytics.com/usage/cfg
+                
+    1. Call object counting solution
+        yolo solutions count source="path/to/video.mp4" region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]"
+
+    2. Call heatmaps solution
+        yolo solutions heatmap colormap=cv2.COLORMAP_PARULA model=yolo11n.pt
+
+    3. Call queue management solution
+        yolo solutions queue region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]" model=yolo11n.pt
+
+    4. Call workouts monitoring solution for push-ups
+        yolo solutions workout model=yolo11n-pose.pt kpts=[6, 8, 10]
+
+    5. Generate analytical graphs
+        yolo solutions analytics analytics_type="pie"
+    
+    6. Track objects within specific zones
+        yolo solutions trackzone source="path/to/video.mp4" region="[(150, 150), (1130, 150), (1130, 570), (150, 570)]"
+        
+    7. Streamlit real-time webcam inference GUI
+        yolo streamlit-predict
+    """
+CLI_HELP_MSG = f"""
+    Arguments received: {str(["yolo"] + ARGV[1:])}. Ultralytics 'yolo' commands use the following syntax:
+
+        yolo TASK MODE ARGS
+
+        Where   TASK (optional) is one of {TASKS}
+                MODE (required) is one of {MODES}
+                ARGS (optional) are any number of custom 'arg=value' pairs like 'imgsz=320' that override defaults.
+                    See all ARGS at https://docs.ultralytics.com/usage/cfg or with 'yolo cfg'
+
+    1. Train a detection model for 10 epochs with an initial learning_rate of 0.01
+        yolo train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01
+
+    2. Predict a YouTube video using a pretrained segmentation model at image size 320:
+        yolo predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320
+
+    3. Val a pretrained detection model at batch-size 1 and image size 640:
+        yolo val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640
+
+    4. Export a YOLO11n classification model to ONNX format at image size 224 by 128 (no TASK required)
+        yolo export model=yolo11n-cls.pt format=onnx imgsz=224,128
+
+    5. Ultralytics solutions usage
+        yolo solutions count or in {list(SOLUTION_MAP.keys())[1:-1]} source="path/to/video.mp4"
+
+    6. Run special commands:
+        yolo help
+        yolo checks
+        yolo version
+        yolo settings
+        yolo copy-cfg
+        yolo cfg
+        yolo solutions help
+
+    Docs: https://docs.ultralytics.com
+    Solutions: https://docs.ultralytics.com/solutions/
+    Community: https://community.ultralytics.com
+    GitHub: https://github.com/ultralytics/ultralytics
+    """
+
+# Define keys for arg type checks
+CFG_FLOAT_KEYS = frozenset(
+    {  # integer or float arguments, i.e. x=2 and x=2.0
+        "warmup_epochs",
+        "box",
+        "cls",
+        "dfl",
+        "degrees",
+        "shear",
+        "time",
+        "workspace",
+        "batch",
+    }
+)
+CFG_FRACTION_KEYS = frozenset(
+    {  # fractional float arguments with 0.0<=values<=1.0
+        "dropout",
+        "lr0",
+        "lrf",
+        "momentum",
+        "weight_decay",
+        "warmup_momentum",
+        "warmup_bias_lr",
+        "hsv_h",
+        "hsv_s",
+        "hsv_v",
+        "translate",
+        "scale",
+        "perspective",
+        "flipud",
+        "fliplr",
+        "bgr",
+        "mosaic",
+        "mixup",
+        "copy_paste",
+        "conf",
+        "iou",
+        "fraction",
+    }
+)
+CFG_INT_KEYS = frozenset(
+    {  # integer-only arguments
+        "epochs",
+        "patience",
+        "workers",
+        "seed",
+        "close_mosaic",
+        "mask_ratio",
+        "max_det",
+        "vid_stride",
+        "line_width",
+        "nbs",
+        "save_period",
+    }
+)
+CFG_BOOL_KEYS = frozenset(
+    {  # boolean-only arguments
+        "save",
+        "exist_ok",
+        "verbose",
+        "deterministic",
+        "single_cls",
+        "rect",
+        "cos_lr",
+        "overlap_mask",
+        "val",
+        "save_json",
+        "save_hybrid",
+        "half",
+        "dnn",
+        "plots",
+        "show",
+        "save_txt",
+        "save_conf",
+        "save_crop",
+        "save_frames",
+        "show_labels",
+        "show_conf",
+        "visualize",
+        "augment",
+        "agnostic_nms",
+        "retina_masks",
+        "show_boxes",
+        "keras",
+        "optimize",
+        "int8",
+        "dynamic",
+        "simplify",
+        "nms",
+        "profile",
+        "multi_scale",
+    }
+)
+
+
+def cfg2dict(cfg: Union[str, Path, Dict, SimpleNamespace]) -> Dict:
+    """
+    Converts a configuration object to a dictionary.
+
+    Args:
+        cfg (str | Path | Dict | SimpleNamespace): Configuration object to be converted. Can be a file path,
+            a string, a dictionary, or a SimpleNamespace object.
+
+    Returns:
+        (dict): Configuration object in dictionary format.
+
+    Examples:
+        Convert a YAML file path to a dictionary:
+        >>> config_dict = cfg2dict("config.yaml")
+
+        Convert a SimpleNamespace to a dictionary:
+        >>> from types import SimpleNamespace
+        >>> config_sn = SimpleNamespace(param1="value1", param2="value2")
+        >>> config_dict = cfg2dict(config_sn)
+
+        Pass through an already existing dictionary:
+        >>> config_dict = cfg2dict({"param1": "value1", "param2": "value2"})
+
+    Notes:
+        - If cfg is a path or string, it's loaded as YAML and converted to a dictionary.
+        - If cfg is a SimpleNamespace object, it's converted to a dictionary using vars().
+        - If cfg is already a dictionary, it's returned unchanged.
+    """
+    if isinstance(cfg, (str, Path)):
+        cfg = yaml_load(cfg)  # load dict
+    elif isinstance(cfg, SimpleNamespace):
+        cfg = vars(cfg)  # convert to dict
+    return cfg
+
+
+def get_cfg(cfg: Union[str, Path, Dict, SimpleNamespace] = DEFAULT_CFG_DICT, overrides: Dict = None) -> SimpleNamespace:
+    """
+    Load and merge configuration data from a file or dictionary, with optional overrides.
+
+    Args:
+        cfg (str | Path | Dict | SimpleNamespace): Configuration data source. Can be a file path, dictionary, or
+            SimpleNamespace object.
+        overrides (Dict | None): Dictionary containing key-value pairs to override the base configuration.
+
+    Returns:
+        (SimpleNamespace): Namespace containing the merged configuration arguments.
+
+    Examples:
+        >>> from ultralytics.cfg import get_cfg
+        >>> config = get_cfg()  # Load default configuration
+        >>> config_with_overrides = get_cfg("path/to/config.yaml", overrides={"epochs": 50, "batch_size": 16})
+
+    Notes:
+        - If both `cfg` and `overrides` are provided, the values in `overrides` will take precedence.
+        - Special handling ensures alignment and correctness of the configuration, such as converting numeric
+          `project` and `name` to strings and validating configuration keys and values.
+        - The function performs type and value checks on the configuration data.
+    """
+    cfg = cfg2dict(cfg)
+
+    # Merge overrides
+    if overrides:
+        overrides = cfg2dict(overrides)
+        if "save_dir" not in cfg:
+            overrides.pop("save_dir", None)  # special override keys to ignore
+        check_dict_alignment(cfg, overrides)
+        cfg = {**cfg, **overrides}  # merge cfg and overrides dicts (prefer overrides)
+
+    # Special handling for numeric project/name
+    for k in "project", "name":
+        if k in cfg and isinstance(cfg[k], (int, float)):
+            cfg[k] = str(cfg[k])
+    if cfg.get("name") == "model":  # assign model to 'name' arg
+        cfg["name"] = str(cfg.get("model", "")).split(".")[0]
+        LOGGER.warning(f"WARNING ⚠️ 'name=model' automatically updated to 'name={cfg['name']}'.")
+
+    # Type and Value checks
+    check_cfg(cfg)
+
+    # Return instance
+    return IterableSimpleNamespace(**cfg)
+
+
+def check_cfg(cfg: Dict, hard: bool = True) -> None:
+    """
+    Checks configuration argument types and values for the Ultralytics library.
+
+    This function validates the types and values of configuration arguments, ensuring correctness and converting
+    them if necessary. It checks for specific key types defined in global variables such as `CFG_FLOAT_KEYS`,
+    `CFG_FRACTION_KEYS`, `CFG_INT_KEYS`, and `CFG_BOOL_KEYS`.
+
+    Args:
+        cfg (dict): Configuration dictionary to validate.
+        hard (bool): If True, raises exceptions for invalid types and values; if False, attempts to convert them.
+
+    Examples:
+        >>> config = {
+        ...     "epochs": 50,  # valid integer
+        ...     "lr0": 0.01,  # valid float
+        ...     "momentum": 1.2,  # invalid float (out of 0.0-1.0 range)
+        ...     "save": "true",  # invalid bool
+        ... }
+        >>> check_cfg(config, hard=False)
+        >>> print(config)
+        {'epochs': 50, 'lr0': 0.01, 'momentum': 1.2, 'save': False}  # corrected 'save' key
+
+    Notes:
+        - The function modifies the input dictionary in-place.
+        - None values are ignored as they may be from optional arguments.
+        - Fraction keys are checked to be within the range [0.0, 1.0].
+    """
+    for k, v in cfg.items():
+        if v is not None:  # None values may be from optional args
+            if k in CFG_FLOAT_KEYS and not isinstance(v, (int, float)):
+                if hard:
+                    raise TypeError(
+                        f"'{k}={v}' is of invalid type {type(v).__name__}. "
+                        f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')"
+                    )
+                cfg[k] = float(v)
+            elif k in CFG_FRACTION_KEYS:
+                if not isinstance(v, (int, float)):
+                    if hard:
+                        raise TypeError(
+                            f"'{k}={v}' is of invalid type {type(v).__name__}. "
+                            f"Valid '{k}' types are int (i.e. '{k}=0') or float (i.e. '{k}=0.5')"
+                        )
+                    cfg[k] = v = float(v)
+                if not (0.0 <= v <= 1.0):
+                    raise ValueError(f"'{k}={v}' is an invalid value. Valid '{k}' values are between 0.0 and 1.0.")
+            elif k in CFG_INT_KEYS and not isinstance(v, int):
+                if hard:
+                    raise TypeError(
+                        f"'{k}={v}' is of invalid type {type(v).__name__}. '{k}' must be an int (i.e. '{k}=8')"
+                    )
+                cfg[k] = int(v)
+            elif k in CFG_BOOL_KEYS and not isinstance(v, bool):
+                if hard:
+                    raise TypeError(
+                        f"'{k}={v}' is of invalid type {type(v).__name__}. "
+                        f"'{k}' must be a bool (i.e. '{k}=True' or '{k}=False')"
+                    )
+                cfg[k] = bool(v)
+
+
+def get_save_dir(args: SimpleNamespace, name: str = None) -> Path:
+    """
+    Returns the directory path for saving outputs, derived from arguments or default settings.
+
+    Args:
+        args (SimpleNamespace): Namespace object containing configurations such as 'project', 'name', 'task',
+            'mode', and 'save_dir'.
+        name (str | None): Optional name for the output directory. If not provided, it defaults to 'args.name'
+            or the 'args.mode'.
+
+    Returns:
+        (Path): Directory path where outputs should be saved.
+
+    Examples:
+        >>> from types import SimpleNamespace
+        >>> args = SimpleNamespace(project="my_project", task="detect", mode="train", exist_ok=True)
+        >>> save_dir = get_save_dir(args)
+        >>> print(save_dir)
+        my_project/detect/train
+    """
+    if getattr(args, "save_dir", None):
+        save_dir = args.save_dir
+    else:
+        from ultralytics.utils.files import increment_path
+
+        project = args.project or (ROOT.parent / "tests/tmp/runs" if TESTS_RUNNING else RUNS_DIR) / args.task
+        name = name or args.name or f"{args.mode}"
+        save_dir = increment_path(Path(project) / name, exist_ok=args.exist_ok if RANK in {-1, 0} else True)
+
+    return Path(save_dir)
+
+
+def _handle_deprecation(custom: Dict) -> Dict:
+    """
+    Handles deprecated configuration keys by mapping them to current equivalents with deprecation warnings.
+
+    Args:
+        custom (dict): Configuration dictionary potentially containing deprecated keys.
+
+    Examples:
+        >>> custom_config = {"boxes": True, "hide_labels": "False", "line_thickness": 2}
+        >>> _handle_deprecation(custom_config)
+        >>> print(custom_config)
+        {'show_boxes': True, 'show_labels': True, 'line_width': 2}
+
+    Notes:
+        This function modifies the input dictionary in-place, replacing deprecated keys with their current
+        equivalents. It also handles value conversions where necessary, such as inverting boolean values for
+        'hide_labels' and 'hide_conf'.
+    """
+    for key in custom.copy().keys():
+        if key == "boxes":
+            deprecation_warn(key, "show_boxes")
+            custom["show_boxes"] = custom.pop("boxes")
+        if key == "hide_labels":
+            deprecation_warn(key, "show_labels")
+            custom["show_labels"] = custom.pop("hide_labels") == "False"
+        if key == "hide_conf":
+            deprecation_warn(key, "show_conf")
+            custom["show_conf"] = custom.pop("hide_conf") == "False"
+        if key == "line_thickness":
+            deprecation_warn(key, "line_width")
+            custom["line_width"] = custom.pop("line_thickness")
+        if key == "label_smoothing":
+            deprecation_warn(key)
+            custom.pop("label_smoothing")
+
+    return custom
+
+
+def check_dict_alignment(base: Dict, custom: Dict, e: Exception = None) -> None:
+    """
+    Checks alignment between custom and base configuration dictionaries, handling deprecated keys and providing error
+    messages for mismatched keys.
+
+    Args:
+        base (dict): The base configuration dictionary containing valid keys.
+        custom (dict): The custom configuration dictionary to be checked for alignment.
+        e (Exception | None): Optional error instance passed by the calling function.
+
+    Raises:
+        SystemExit: If mismatched keys are found between the custom and base dictionaries.
+
+    Examples:
+        >>> base_cfg = {"epochs": 50, "lr0": 0.01, "batch_size": 16}
+        >>> custom_cfg = {"epoch": 100, "lr": 0.02, "batch_size": 32}
+        >>> try:
+        ...     check_dict_alignment(base_cfg, custom_cfg)
+        ... except SystemExit:
+        ...     print("Mismatched keys found")
+
+    Notes:
+        - Suggests corrections for mismatched keys based on similarity to valid keys.
+        - Automatically replaces deprecated keys in the custom configuration with updated equivalents.
+        - Prints detailed error messages for each mismatched key to help users correct their configurations.
+    """
+    custom = _handle_deprecation(custom)
+    base_keys, custom_keys = (frozenset(x.keys()) for x in (base, custom))
+    if mismatched := [k for k in custom_keys if k not in base_keys]:
+        from difflib import get_close_matches
+
+        string = ""
+        for x in mismatched:
+            matches = get_close_matches(x, base_keys)  # key list
+            matches = [f"{k}={base[k]}" if base.get(k) is not None else k for k in matches]
+            match_str = f"Similar arguments are i.e. {matches}." if matches else ""
+            string += f"'{colorstr('red', 'bold', x)}' is not a valid YOLO argument. {match_str}\n"
+        raise SyntaxError(string + CLI_HELP_MSG) from e
+
+
+def merge_equals_args(args: List[str]) -> List[str]:
+    """
+    Merges arguments around isolated '=' in a list of strings and joins fragments with brackets.
+
+    This function handles the following cases:
+        1. ['arg', '=', 'val'] becomes ['arg=val']
+        2. ['arg=', 'val'] becomes ['arg=val']
+        3. ['arg', '=val'] becomes ['arg=val']
+        4. Joins fragments with brackets, e.g., ['imgsz=[3,', '640,', '640]'] becomes ['imgsz=[3,640,640]']
+
+    Args:
+        args (List[str]): A list of strings where each element represents an argument or fragment.
+
+    Returns:
+        (List[str]): A list of strings where the arguments around isolated '=' are merged and fragments with brackets are joined.
+
+    Examples:
+        >>> args = ["arg1", "=", "value", "arg2=", "value2", "arg3", "=value3", "imgsz=[3,", "640,", "640]"]
+        >>> merge_equals_args(args)
+        ['arg1=value', 'arg2=value2', 'arg3=value3', 'imgsz=[3,640,640]']
+    """
+    new_args = []
+    current = ""
+    depth = 0
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+
+        # Handle equals sign merging
+        if arg == "=" and 0 < i < len(args) - 1:  # merge ['arg', '=', 'val']
+            new_args[-1] += f"={args[i + 1]}"
+            i += 2
+            continue
+        elif arg.endswith("=") and i < len(args) - 1 and "=" not in args[i + 1]:  # merge ['arg=', 'val']
+            new_args.append(f"{arg}{args[i + 1]}")
+            i += 2
+            continue
+        elif arg.startswith("=") and i > 0:  # merge ['arg', '=val']
+            new_args[-1] += arg
+            i += 1
+            continue
+
+        # Handle bracket joining
+        depth += arg.count("[") - arg.count("]")
+        current += arg
+        if depth == 0:
+            new_args.append(current)
+            current = ""
+
+        i += 1
+
+    # Append any remaining current string
+    if current:
+        new_args.append(current)
+
+    return new_args
+
+
+def handle_yolo_hub(args: List[str]) -> None:
+    """
+    Handles Ultralytics HUB command-line interface (CLI) commands for authentication.
+
+    This function processes Ultralytics HUB CLI commands such as login and logout. It should be called when executing a
+    script with arguments related to HUB authentication.
+
+    Args:
+        args (List[str]): A list of command line arguments. The first argument should be either 'login'
+            or 'logout'. For 'login', an optional second argument can be the API key.
+
+    Examples:
+        ```bash
+        yolo login YOUR_API_KEY
+        ```
+
+    Notes:
+        - The function imports the 'hub' module from ultralytics to perform login and logout operations.
+        - For the 'login' command, if no API key is provided, an empty string is passed to the login function.
+        - The 'logout' command does not require any additional arguments.
+    """
+    from ultralytics import hub
+
+    if args[0] == "login":
+        key = args[1] if len(args) > 1 else ""
+        # Log in to Ultralytics HUB using the provided API key
+        hub.login(key)
+    elif args[0] == "logout":
+        # Log out from Ultralytics HUB
+        hub.logout()
+
+
+def handle_yolo_settings(args: List[str]) -> None:
+    """
+    Handles YOLO settings command-line interface (CLI) commands.
+
+    This function processes YOLO settings CLI commands such as reset and updating individual settings. It should be
+    called when executing a script with arguments related to YOLO settings management.
+
+    Args:
+        args (List[str]): A list of command line arguments for YOLO settings management.
+
+    Examples:
+        >>> handle_yolo_settings(["reset"])  # Reset YOLO settings
+        >>> handle_yolo_settings(["default_cfg_path=yolo11n.yaml"])  # Update a specific setting
+
+    Notes:
+        - If no arguments are provided, the function will display the current settings.
+        - The 'reset' command will delete the existing settings file and create new default settings.
+        - Other arguments are treated as key-value pairs to update specific settings.
+        - The function will check for alignment between the provided settings and the existing ones.
+        - After processing, the updated settings will be displayed.
+        - For more information on handling YOLO settings, visit:
+          https://docs.ultralytics.com/quickstart/#ultralytics-settings
+    """
+    url = "https://docs.ultralytics.com/quickstart/#ultralytics-settings"  # help URL
+    try:
+        if any(args):
+            if args[0] == "reset":
+                SETTINGS_FILE.unlink()  # delete the settings file
+                SETTINGS.reset()  # create new settings
+                LOGGER.info("Settings reset successfully")  # inform the user that settings have been reset
+            else:  # save a new setting
+                new = dict(parse_key_value_pair(a) for a in args)
+                check_dict_alignment(SETTINGS, new)
+                SETTINGS.update(new)
+
+        print(SETTINGS)  # print the current settings
+        LOGGER.info(f"💡 Learn more about Ultralytics Settings at {url}")
+    except Exception as e:
+        LOGGER.warning(f"WARNING ⚠️ settings error: '{e}'. Please see {url} for help.")
+
+
+def handle_yolo_solutions(args: List[str]) -> None:
+    """
+    Processes YOLO solutions arguments and runs the specified computer vision solutions pipeline.
+
+    Args:
+        args (List[str]): Command-line arguments for configuring and running the Ultralytics YOLO
+            solutions: https://docs.ultralytics.com/solutions/, It can include solution name, source,
+            and other configuration parameters.
+
+    Examples:
+        Run people counting solution with default settings:
+        >>> handle_yolo_solutions(["count"])
+
+        Run analytics with custom configuration:
+        >>> handle_yolo_solutions(["analytics", "conf=0.25", "source=path/to/video.mp4"])
+
+        Run inference with custom configuration, requires Streamlit version 1.29.0 or higher.
+        >>> handle_yolo_solutions(["inference", "model=yolo11n.pt"])
+
+    Notes:
+        - Default configurations are merged from DEFAULT_SOL_DICT and DEFAULT_CFG_DICT
+        - Arguments can be provided in the format 'key=value' or as boolean flags
+        - Available solutions are defined in SOLUTION_MAP with their respective classes and methods
+        - If an invalid solution is provided, defaults to 'count' solution
+        - Output videos are saved in 'runs/solution/{solution_name}' directory
+        - For 'analytics' solution, frame numbers are tracked for generating analytical graphs
+        - Video processing can be interrupted by pressing 'q'
+        - Processes video frames sequentially and saves output in .avi format
+        - If no source is specified, downloads and uses a default sample video
+        - The inference solution will be launched using the 'streamlit run' command.
+        - The Streamlit app file is located in the Ultralytics package directory.
+    """
+    full_args_dict = {
+        **DEFAULT_SOL_DICT,
+        **DEFAULT_CFG_DICT,
+        "blur_ratio": 0.5,
+        "vision_point": (20, 20),
+        "crop_dir": "cropped-detections",
+    }  # arguments dictionary
+    overrides = {}
+
+    # check dictionary alignment
+    for arg in merge_equals_args(args):
+        arg = arg.lstrip("-").rstrip(",")
+        if "=" in arg:
+            try:
+                k, v = parse_key_value_pair(arg)
+                overrides[k] = v
+            except (NameError, SyntaxError, ValueError, AssertionError) as e:
+                check_dict_alignment(full_args_dict, {arg: ""}, e)
+        elif arg in full_args_dict and isinstance(full_args_dict.get(arg), bool):
+            overrides[arg] = True
+    check_dict_alignment(full_args_dict, overrides)  # dict alignment
+
+    # Get solution name
+    if not args:
+        LOGGER.warning("⚠️ No solution name provided. i.e `yolo solutions count`. Defaulting to 'count'.")
+        args = ["count"]
+    if args[0] == "help":
+        LOGGER.info(SOLUTIONS_HELP_MSG)
+        return  # Early return for 'help' case
+    elif args[0] in SOLUTION_MAP:
+        solution_name = args.pop(0)  # Extract the solution name directly
+    else:
+        LOGGER.warning(
+            f"❌ '{args[0]}' is not a valid solution. 💡 Defaulting to 'count'.\n"
+            f"🚀 Available solutions: {', '.join(list(SOLUTION_MAP.keys())[:-1])}\n"
+        )
+        solution_name = "count"  # Default for invalid solution
+
+    if solution_name == "inference":
+        checks.check_requirements("streamlit>=1.29.0,<1.44.0")
+        LOGGER.info("💡 Loading Ultralytics live inference app...")
+        subprocess.run(
+            [  # Run subprocess with Streamlit custom argument
+                "streamlit",
+                "run",
+                str(ROOT / "solutions/streamlit_inference.py"),
+                "--server.headless",
+                "true",
+                overrides.pop("model", "yolo11n.pt"),
+            ]
+        )
+    else:
+        from ultralytics import solutions
+
+        solution = getattr(solutions, SOLUTION_MAP[solution_name])(is_cli=True, **overrides)  # class i.e ObjectCounter
+
+        cap = cv2.VideoCapture(solution.CFG["source"])  # read the video file
+        if solution_name != "crop":
+            # extract width, height and fps of the video file, create save directory and initialize video writer
+            w, h, fps = (
+                int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS)
+            )
+            if solution_name == "analytics":  # analytical graphs follow fixed shape for output i.e w=1920, h=1080
+                w, h = 1280, 720
+            save_dir = get_save_dir(SimpleNamespace(project="runs/solutions", name="exp", exist_ok=False))
+            save_dir.mkdir(parents=True)  # create the output directory i.e. runs/solutions/exp
+            vw = cv2.VideoWriter(str(save_dir / f"{solution_name}.avi"), cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))
+
+        try:  # Process video frames
+            f_n = 0  # frame number, required for analytical graphs
+            while cap.isOpened():
+                success, frame = cap.read()
+                if not success:
+                    break
+                results = solution(frame, f_n := f_n + 1) if solution_name == "analytics" else solution(frame)
+                if solution_name != "crop":
+                    vw.write(results.plot_im)
+                if cv2.waitKey(1) & 0xFF == ord("q"):
+                    break
+        finally:
+            cap.release()
+
+
+def parse_key_value_pair(pair: str = "key=value") -> tuple:
+    """
+    Parses a key-value pair string into separate key and value components.
+
+    Args:
+        pair (str): A string containing a key-value pair in the format "key=value".
+
+    Returns:
+        key (str): The parsed key.
+        value (str): The parsed value.
+
+    Raises:
+        AssertionError: If the value is missing or empty.
+
+    Examples:
+        >>> key, value = parse_key_value_pair("model=yolo11n.pt")
+        >>> print(f"Key: {key}, Value: {value}")
+        Key: model, Value: yolo11n.pt
+
+        >>> key, value = parse_key_value_pair("epochs=100")
+        >>> print(f"Key: {key}, Value: {value}")
+        Key: epochs, Value: 100
+
+    Notes:
+        - The function splits the input string on the first '=' character.
+        - Leading and trailing whitespace is removed from both key and value.
+        - An assertion error is raised if the value is empty after stripping.
+    """
+    k, v = pair.split("=", 1)  # split on first '=' sign
+    k, v = k.strip(), v.strip()  # remove spaces
+    assert v, f"missing '{k}' value"
+    return k, smart_value(v)
+
+
+def smart_value(v: str) -> Any:
+    """
+    Converts a string representation of a value to its appropriate Python type.
+
+    This function attempts to convert a given string into a Python object of the most appropriate type. It handles
+    conversions to None, bool, int, float, and other types that can be evaluated safely.
+
+    Args:
+        v (str): The string representation of the value to be converted.
+
+    Returns:
+        (Any): The converted value. The type can be None, bool, int, float, or the original string if no conversion
+            is applicable.
+
+    Examples:
+        >>> smart_value("42")
+        42
+        >>> smart_value("3.14")
+        3.14
+        >>> smart_value("True")
+        True
+        >>> smart_value("None")
+        None
+        >>> smart_value("some_string")
+        'some_string'
+
+    Notes:
+        - The function uses a case-insensitive comparison for boolean and None values.
+        - For other types, it attempts to use Python's eval() function, which can be unsafe if used on untrusted input.
+        - If no conversion is possible, the original string is returned.
+    """
+    v_lower = v.lower()
+    if v_lower == "none":
+        return None
+    elif v_lower == "true":
+        return True
+    elif v_lower == "false":
+        return False
+    else:
+        try:
+            return eval(v)
+        except Exception:
+            return v
+
+
+def entrypoint(debug: str = "") -> None:
+    """
+    Ultralytics entrypoint function for parsing and executing command-line arguments.
+
+    This function serves as the main entry point for the Ultralytics CLI, parsing command-line arguments and
+    executing the corresponding tasks such as training, validation, prediction, exporting models, and more.
+
+    Args:
+        debug (str): Space-separated string of command-line arguments for debugging purposes.
+
+    Examples:
+        Train a detection model for 10 epochs with an initial learning_rate of 0.01:
+        >>> entrypoint("train data=coco8.yaml model=yolo11n.pt epochs=10 lr0=0.01")
+
+        Predict a YouTube video using a pretrained segmentation model at image size 320:
+        >>> entrypoint("predict model=yolo11n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320")
+
+        Validate a pretrained detection model at batch-size 1 and image size 640:
+        >>> entrypoint("val model=yolo11n.pt data=coco8.yaml batch=1 imgsz=640")
+
+    Notes:
+        - If no arguments are passed, the function will display the usage help message.
+        - For a list of all available commands and their arguments, see the provided help messages and the
+          Ultralytics documentation at https://docs.ultralytics.com.
+    """
+    args = (debug.split(" ") if debug else ARGV)[1:]
+    if not args:  # no arguments passed
+        LOGGER.info(CLI_HELP_MSG)
+        return
+
+    special = {
+        "help": lambda: LOGGER.info(CLI_HELP_MSG),
+        "checks": checks.collect_system_info,
+        "version": lambda: LOGGER.info(__version__),
+        "settings": lambda: handle_yolo_settings(args[1:]),
+        "cfg": lambda: yaml_print(DEFAULT_CFG_PATH),
+        "hub": lambda: handle_yolo_hub(args[1:]),
+        "login": lambda: handle_yolo_hub(args),
+        "logout": lambda: handle_yolo_hub(args),
+        "copy-cfg": copy_default_cfg,
+        "solutions": lambda: handle_yolo_solutions(args[1:]),
+    }
+    full_args_dict = {**DEFAULT_CFG_DICT, **{k: None for k in TASKS}, **{k: None for k in MODES}, **special}
+
+    # Define common misuses of special commands, i.e. -h, -help, --help
+    special.update({k[0]: v for k, v in special.items()})  # singular
+    special.update({k[:-1]: v for k, v in special.items() if len(k) > 1 and k.endswith("s")})  # singular
+    special = {**special, **{f"-{k}": v for k, v in special.items()}, **{f"--{k}": v for k, v in special.items()}}
+
+    overrides = {}  # basic overrides, i.e. imgsz=320
+    for a in merge_equals_args(args):  # merge spaces around '=' sign
+        if a.startswith("--"):
+            LOGGER.warning(f"WARNING ⚠️ argument '{a}' does not require leading dashes '--', updating to '{a[2:]}'.")
+            a = a[2:]
+        if a.endswith(","):
+            LOGGER.warning(f"WARNING ⚠️ argument '{a}' does not require trailing comma ',', updating to '{a[:-1]}'.")
+            a = a[:-1]
+        if "=" in a:
+            try:
+                k, v = parse_key_value_pair(a)
+                if k == "cfg" and v is not None:  # custom.yaml passed
+                    LOGGER.info(f"Overriding {DEFAULT_CFG_PATH} with {v}")
+                    overrides = {k: val for k, val in yaml_load(checks.check_yaml(v)).items() if k != "cfg"}
+                else:
+                    overrides[k] = v
+            except (NameError, SyntaxError, ValueError, AssertionError) as e:
+                check_dict_alignment(full_args_dict, {a: ""}, e)
+
+        elif a in TASKS:
+            overrides["task"] = a
+        elif a in MODES:
+            overrides["mode"] = a
+        elif a.lower() in special:
+            special[a.lower()]()
+            return
+        elif a in DEFAULT_CFG_DICT and isinstance(DEFAULT_CFG_DICT[a], bool):
+            overrides[a] = True  # auto-True for default bool args, i.e. 'yolo show' sets show=True
+        elif a in DEFAULT_CFG_DICT:
+            raise SyntaxError(
+                f"'{colorstr('red', 'bold', a)}' is a valid YOLO argument but is missing an '=' sign "
+                f"to set its value, i.e. try '{a}={DEFAULT_CFG_DICT[a]}'\n{CLI_HELP_MSG}"
+            )
+        else:
+            check_dict_alignment(full_args_dict, {a: ""})
+
+    # Check keys
+    check_dict_alignment(full_args_dict, overrides)
+
+    # Mode
+    mode = overrides.get("mode")
+    if mode is None:
+        mode = DEFAULT_CFG.mode or "predict"
+        LOGGER.warning(f"WARNING ⚠️ 'mode' argument is missing. Valid modes are {MODES}. Using default 'mode={mode}'.")
+    elif mode not in MODES:
+        raise ValueError(f"Invalid 'mode={mode}'. Valid modes are {MODES}.\n{CLI_HELP_MSG}")
+
+    # Task
+    task = overrides.pop("task", None)
+    if task:
+        if task not in TASKS:
+            if task == "track":
+                LOGGER.warning(
+                    "WARNING ⚠️ invalid 'task=track', setting 'task=detect' and 'mode=track'. Valid tasks are {TASKS}.\n{CLI_HELP_MSG}."
+                )
+                task, mode = "detect", "track"
+            else:
+                raise ValueError(f"Invalid 'task={task}'. Valid tasks are {TASKS}.\n{CLI_HELP_MSG}")
+        if "model" not in overrides:
+            overrides["model"] = TASK2MODEL[task]
+
+    # Model
+    model = overrides.pop("model", DEFAULT_CFG.model)
+    if model is None:
+        model = "yolo11n.pt"
+        LOGGER.warning(f"WARNING ⚠️ 'model' argument is missing. Using default 'model={model}'.")
+    overrides["model"] = model
+    stem = Path(model).stem.lower()
+    if "rtdetr" in stem:  # guess architecture
+        from ultralytics import RTDETR
+
+        model = RTDETR(model)  # no task argument
+    elif "fastsam" in stem:
+        from ultralytics import FastSAM
+
+        model = FastSAM(model)
+    elif "sam_" in stem or "sam2_" in stem or "sam2.1_" in stem:
+        from ultralytics import SAM
+
+        model = SAM(model)
+    else:
+        from ultralytics import YOLO
+
+        model = YOLO(model, task=task)
+    if isinstance(overrides.get("pretrained"), str):
+        model.load(overrides["pretrained"])
+
+    # Task Update
+    if task != model.task:
+        if task:
+            LOGGER.warning(
+                f"WARNING ⚠️ conflicting 'task={task}' passed with 'task={model.task}' model. "
+                f"Ignoring 'task={task}' and updating to 'task={model.task}' to match model."
+            )
+        task = model.task
+
+    # Mode
+    if mode in {"predict", "track"} and "source" not in overrides:
+        overrides["source"] = (
+            "https://ultralytics.com/images/boats.jpg" if task == "obb" else DEFAULT_CFG.source or ASSETS
+        )
+        LOGGER.warning(f"WARNING ⚠️ 'source' argument is missing. Using default 'source={overrides['source']}'.")
+    elif mode in {"train", "val"}:
+        if "data" not in overrides and "resume" not in overrides:
+            overrides["data"] = DEFAULT_CFG.data or TASK2DATA.get(task or DEFAULT_CFG.task, DEFAULT_CFG.data)
+            LOGGER.warning(f"WARNING ⚠️ 'data' argument is missing. Using default 'data={overrides['data']}'.")
+    elif mode == "export":
+        if "format" not in overrides:
+            overrides["format"] = DEFAULT_CFG.format or "torchscript"
+            LOGGER.warning(f"WARNING ⚠️ 'format' argument is missing. Using default 'format={overrides['format']}'.")
+
+    # Run command in python
+    getattr(model, mode)(**overrides)  # default args from model
+
+    # Show help
+    LOGGER.info(f"💡 Learn more at https://docs.ultralytics.com/modes/{mode}")
+
+    # Recommend VS Code extension
+    if IS_VSCODE and SETTINGS.get("vscode_msg", True):
+        LOGGER.info(vscode_msg())
+
+
+# Special modes --------------------------------------------------------------------------------------------------------
+def copy_default_cfg() -> None:
+    """
+    Copies the default configuration file and creates a new one with '_copy' appended to its name.
+
+    This function duplicates the existing default configuration file (DEFAULT_CFG_PATH) and saves it
+    with '_copy' appended to its name in the current working directory. It provides a convenient way
+    to create a custom configuration file based on the default settings.
+
+    Examples:
+        >>> copy_default_cfg()
+        # Output: default.yaml copied to /path/to/current/directory/default_copy.yaml
+        # Example YOLO command with this new custom cfg:
+        #   yolo cfg='/path/to/current/directory/default_copy.yaml' imgsz=320 batch=8
+
+    Notes:
+        - The new configuration file is created in the current working directory.
+        - After copying, the function prints a message with the new file's location and an example
+          YOLO command demonstrating how to use the new configuration file.
+        - This function is useful for users who want to modify the default configuration without
+          altering the original file.
+    """
+    new_file = Path.cwd() / DEFAULT_CFG_PATH.name.replace(".yaml", "_copy.yaml")
+    shutil.copy2(DEFAULT_CFG_PATH, new_file)
+    LOGGER.info(
+        f"{DEFAULT_CFG_PATH} copied to {new_file}\n"
+        f"Example YOLO command with this new custom cfg:\n    yolo cfg='{new_file}' imgsz=320 batch=8"
+    )
+
+
+if __name__ == "__main__":
+    # Example: entrypoint(debug='yolo predict model=yolo11n.pt')
+    entrypoint(debug="")

ultralytics/cfg/datasets/Argoverse.yaml

@@ -0,0 +1,77 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Argoverse-HD dataset (ring-front-center camera) https://www.cs.cmu.edu/~mengtial/proj/streaming/ by Argo AI
+# Documentation: https://docs.ultralytics.com/datasets/detect/argoverse/
+# Example usage: yolo train data=Argoverse.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── Argoverse  ← downloads here (31.5 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/Argoverse # dataset root dir
+train: Argoverse-1.1/images/train/ # train images (relative to 'path') 39384 images
+val: Argoverse-1.1/images/val/ # val images (relative to 'path') 15062 images
+test: Argoverse-1.1/images/test/ # test images (optional) https://eval.ai/web/challenges/challenge-page/800/overview
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: bus
+  5: truck
+  6: traffic_light
+  7: stop_sign
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import json
+  from pathlib import Path
+
+  from tqdm import tqdm
+  from ultralytics.utils.downloads import download
+
+  def argoverse2yolo(set):
+      """Convert Argoverse dataset annotations to YOLO format for object detection tasks."""
+      labels = {}
+      a = json.load(open(set, "rb"))
+      for annot in tqdm(a["annotations"], desc=f"Converting {set} to YOLOv5 format..."):
+          img_id = annot["image_id"]
+          img_name = a["images"][img_id]["name"]
+          img_label_name = f"{img_name[:-3]}txt"
+
+          cls = annot["category_id"]  # instance class id
+          x_center, y_center, width, height = annot["bbox"]
+          x_center = (x_center + width / 2) / 1920.0  # offset and scale
+          y_center = (y_center + height / 2) / 1200.0  # offset and scale
+          width /= 1920.0  # scale
+          height /= 1200.0  # scale
+
+          img_dir = set.parents[2] / "Argoverse-1.1" / "labels" / a["seq_dirs"][a["images"][annot["image_id"]]["sid"]]
+          if not img_dir.exists():
+              img_dir.mkdir(parents=True, exist_ok=True)
+
+          k = str(img_dir / img_label_name)
+          if k not in labels:
+              labels[k] = []
+          labels[k].append(f"{cls} {x_center} {y_center} {width} {height}\n")
+
+      for k in labels:
+          with open(k, "w", encoding="utf-8") as f:
+              f.writelines(labels[k])
+
+
+  # Download 'https://argoverse-hd.s3.us-east-2.amazonaws.com/Argoverse-HD-Full.zip' (deprecated S3 link)
+  dir = Path(yaml["path"])  # dataset root dir
+  urls = ["https://drive.google.com/file/d/1st9qW3BeIwQsnR0t8mRpvbsSWIo16ACi/view?usp=drive_link"]
+  print("\n\nWARNING: Argoverse dataset MUST be downloaded manually, autodownload will NOT work.")
+  print(f"WARNING: Manually download Argoverse dataset '{urls[0]}' to '{dir}' and re-run your command.\n\n")
+  # download(urls, dir=dir)
+
+  # Convert
+  annotations_dir = "Argoverse-HD/annotations/"
+  (dir / "Argoverse-1.1" / "tracking").rename(dir / "Argoverse-1.1" / "images")  # rename 'tracking' to 'images'
+  for d in "train.json", "val.json":
+      argoverse2yolo(dir / annotations_dir / d)  # convert Argoverse annotations to YOLO labels

ultralytics/cfg/datasets/DOTAv1.5.yaml

@@ -0,0 +1,37 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# DOTA 1.5 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
+# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
+# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.5.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── dota1.5  ← downloads here (2GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/DOTAv1.5 # dataset root dir
+train: images/train # train images (relative to 'path') 1411 images
+val: images/val # val images (relative to 'path') 458 images
+test: images/test # test images (optional) 937 images
+
+# Classes for DOTA 1.5
+names:
+  0: plane
+  1: ship
+  2: storage tank
+  3: baseball diamond
+  4: tennis court
+  5: basketball court
+  6: ground track field
+  7: harbor
+  8: bridge
+  9: large vehicle
+  10: small vehicle
+  11: helicopter
+  12: roundabout
+  13: soccer ball field
+  14: swimming pool
+  15: container crane
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.5.zip

ultralytics/cfg/datasets/DOTAv1.yaml

@@ -0,0 +1,36 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# DOTA 1.0 dataset https://captain-whu.github.io/DOTA/index.html for object detection in aerial images by Wuhan University
+# Documentation: https://docs.ultralytics.com/datasets/obb/dota-v2/
+# Example usage: yolo train model=yolov8n-obb.pt data=DOTAv1.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── dota1  ← downloads here (2GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/DOTAv1 # dataset root dir
+train: images/train # train images (relative to 'path') 1411 images
+val: images/val # val images (relative to 'path') 458 images
+test: images/test # test images (optional) 937 images
+
+# Classes for DOTA 1.0
+names:
+  0: plane
+  1: ship
+  2: storage tank
+  3: baseball diamond
+  4: tennis court
+  5: basketball court
+  6: ground track field
+  7: harbor
+  8: bridge
+  9: large vehicle
+  10: small vehicle
+  11: helicopter
+  12: roundabout
+  13: soccer ball field
+  14: swimming pool
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/DOTAv1.zip

ultralytics/cfg/datasets/GlobalWheat2020.yaml

@@ -0,0 +1,68 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Global Wheat 2020 dataset https://www.global-wheat.com/ by University of Saskatchewan
+# Documentation: https://docs.ultralytics.com/datasets/detect/globalwheat2020/
+# Example usage: yolo train data=GlobalWheat2020.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── GlobalWheat2020  ← downloads here (7.0 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/GlobalWheat2020 # dataset root dir
+train: # train images (relative to 'path') 3422 images
+  - images/arvalis_1
+  - images/arvalis_2
+  - images/arvalis_3
+  - images/ethz_1
+  - images/rres_1
+  - images/inrae_1
+  - images/usask_1
+val: # val images (relative to 'path') 748 images (WARNING: train set contains ethz_1)
+  - images/ethz_1
+test: # test images (optional) 1276 images
+  - images/utokyo_1
+  - images/utokyo_2
+  - images/nau_1
+  - images/uq_1
+
+# Classes
+names:
+  0: wheat_head
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  from pathlib import Path
+
+  from ultralytics.utils.downloads import download
+
+  # Download
+  dir = Path(yaml["path"])  # dataset root dir
+  urls = [
+      "https://zenodo.org/record/4298502/files/global-wheat-codalab-official.zip",
+      "https://github.com/ultralytics/assets/releases/download/v0.0.0/GlobalWheat2020_labels.zip",
+  ]
+  download(urls, dir=dir)
+
+  # Make Directories
+  for p in "annotations", "images", "labels":
+      (dir / p).mkdir(parents=True, exist_ok=True)
+
+  # Move
+  for p in (
+      "arvalis_1",
+      "arvalis_2",
+      "arvalis_3",
+      "ethz_1",
+      "rres_1",
+      "inrae_1",
+      "usask_1",
+      "utokyo_1",
+      "utokyo_2",
+      "nau_1",
+      "uq_1",
+  ):
+      (dir / "global-wheat-codalab-official" / p).rename(dir / "images" / p)  # move to /images
+      f = (dir / "global-wheat-codalab-official" / p).with_suffix(".json")  # json file
+      if f.exists():
+          f.rename((dir / "annotations" / p).with_suffix(".json"))  # move to /annotations

ultralytics/cfg/datasets/ImageNet.yaml

@@ -0,0 +1,2025 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# ImageNet-1k dataset https://www.image-net.org/index.php by Stanford University
+# Simplified class names from https://github.com/anishathalye/imagenet-simple-labels
+# Documentation: https://docs.ultralytics.com/datasets/classify/imagenet/
+# Example usage: yolo train task=classify data=imagenet
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── imagenet  ← downloads here (144 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/imagenet # dataset root dir
+train: train # train images (relative to 'path') 1281167 images
+val: val # val images (relative to 'path') 50000 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: tench
+  1: goldfish
+  2: great white shark
+  3: tiger shark
+  4: hammerhead shark
+  5: electric ray
+  6: stingray
+  7: cock
+  8: hen
+  9: ostrich
+  10: brambling
+  11: goldfinch
+  12: house finch
+  13: junco
+  14: indigo bunting
+  15: American robin
+  16: bulbul
+  17: jay
+  18: magpie
+  19: chickadee
+  20: American dipper
+  21: kite
+  22: bald eagle
+  23: vulture
+  24: great grey owl
+  25: fire salamander
+  26: smooth newt
+  27: newt
+  28: spotted salamander
+  29: axolotl
+  30: American bullfrog
+  31: tree frog
+  32: tailed frog
+  33: loggerhead sea turtle
+  34: leatherback sea turtle
+  35: mud turtle
+  36: terrapin
+  37: box turtle
+  38: banded gecko
+  39: green iguana
+  40: Carolina anole
+  41: desert grassland whiptail lizard
+  42: agama
+  43: frilled-necked lizard
+  44: alligator lizard
+  45: Gila monster
+  46: European green lizard
+  47: chameleon
+  48: Komodo dragon
+  49: Nile crocodile
+  50: American alligator
+  51: triceratops
+  52: worm snake
+  53: ring-necked snake
+  54: eastern hog-nosed snake
+  55: smooth green snake
+  56: kingsnake
+  57: garter snake
+  58: water snake
+  59: vine snake
+  60: night snake
+  61: boa constrictor
+  62: African rock python
+  63: Indian cobra
+  64: green mamba
+  65: sea snake
+  66: Saharan horned viper
+  67: eastern diamondback rattlesnake
+  68: sidewinder
+  69: trilobite
+  70: harvestman
+  71: scorpion
+  72: yellow garden spider
+  73: barn spider
+  74: European garden spider
+  75: southern black widow
+  76: tarantula
+  77: wolf spider
+  78: tick
+  79: centipede
+  80: black grouse
+  81: ptarmigan
+  82: ruffed grouse
+  83: prairie grouse
+  84: peacock
+  85: quail
+  86: partridge
+  87: grey parrot
+  88: macaw
+  89: sulphur-crested cockatoo
+  90: lorikeet
+  91: coucal
+  92: bee eater
+  93: hornbill
+  94: hummingbird
+  95: jacamar
+  96: toucan
+  97: duck
+  98: red-breasted merganser
+  99: goose
+  100: black swan
+  101: tusker
+  102: echidna
+  103: platypus
+  104: wallaby
+  105: koala
+  106: wombat
+  107: jellyfish
+  108: sea anemone
+  109: brain coral
+  110: flatworm
+  111: nematode
+  112: conch
+  113: snail
+  114: slug
+  115: sea slug
+  116: chiton
+  117: chambered nautilus
+  118: Dungeness crab
+  119: rock crab
+  120: fiddler crab
+  121: red king crab
+  122: American lobster
+  123: spiny lobster
+  124: crayfish
+  125: hermit crab
+  126: isopod
+  127: white stork
+  128: black stork
+  129: spoonbill
+  130: flamingo
+  131: little blue heron
+  132: great egret
+  133: bittern
+  134: crane (bird)
+  135: limpkin
+  136: common gallinule
+  137: American coot
+  138: bustard
+  139: ruddy turnstone
+  140: dunlin
+  141: common redshank
+  142: dowitcher
+  143: oystercatcher
+  144: pelican
+  145: king penguin
+  146: albatross
+  147: grey whale
+  148: killer whale
+  149: dugong
+  150: sea lion
+  151: Chihuahua
+  152: Japanese Chin
+  153: Maltese
+  154: Pekingese
+  155: Shih Tzu
+  156: King Charles Spaniel
+  157: Papillon
+  158: toy terrier
+  159: Rhodesian Ridgeback
+  160: Afghan Hound
+  161: Basset Hound
+  162: Beagle
+  163: Bloodhound
+  164: Bluetick Coonhound
+  165: Black and Tan Coonhound
+  166: Treeing Walker Coonhound
+  167: English foxhound
+  168: Redbone Coonhound
+  169: borzoi
+  170: Irish Wolfhound
+  171: Italian Greyhound
+  172: Whippet
+  173: Ibizan Hound
+  174: Norwegian Elkhound
+  175: Otterhound
+  176: Saluki
+  177: Scottish Deerhound
+  178: Weimaraner
+  179: Staffordshire Bull Terrier
+  180: American Staffordshire Terrier
+  181: Bedlington Terrier
+  182: Border Terrier
+  183: Kerry Blue Terrier
+  184: Irish Terrier
+  185: Norfolk Terrier
+  186: Norwich Terrier
+  187: Yorkshire Terrier
+  188: Wire Fox Terrier
+  189: Lakeland Terrier
+  190: Sealyham Terrier
+  191: Airedale Terrier
+  192: Cairn Terrier
+  193: Australian Terrier
+  194: Dandie Dinmont Terrier
+  195: Boston Terrier
+  196: Miniature Schnauzer
+  197: Giant Schnauzer
+  198: Standard Schnauzer
+  199: Scottish Terrier
+  200: Tibetan Terrier
+  201: Australian Silky Terrier
+  202: Soft-coated Wheaten Terrier
+  203: West Highland White Terrier
+  204: Lhasa Apso
+  205: Flat-Coated Retriever
+  206: Curly-coated Retriever
+  207: Golden Retriever
+  208: Labrador Retriever
+  209: Chesapeake Bay Retriever
+  210: German Shorthaired Pointer
+  211: Vizsla
+  212: English Setter
+  213: Irish Setter
+  214: Gordon Setter
+  215: Brittany
+  216: Clumber Spaniel
+  217: English Springer Spaniel
+  218: Welsh Springer Spaniel
+  219: Cocker Spaniels
+  220: Sussex Spaniel
+  221: Irish Water Spaniel
+  222: Kuvasz
+  223: Schipperke
+  224: Groenendael
+  225: Malinois
+  226: Briard
+  227: Australian Kelpie
+  228: Komondor
+  229: Old English Sheepdog
+  230: Shetland Sheepdog
+  231: collie
+  232: Border Collie
+  233: Bouvier des Flandres
+  234: Rottweiler
+  235: German Shepherd Dog
+  236: Dobermann
+  237: Miniature Pinscher
+  238: Greater Swiss Mountain Dog
+  239: Bernese Mountain Dog
+  240: Appenzeller Sennenhund
+  241: Entlebucher Sennenhund
+  242: Boxer
+  243: Bullmastiff
+  244: Tibetan Mastiff
+  245: French Bulldog
+  246: Great Dane
+  247: St. Bernard
+  248: husky
+  249: Alaskan Malamute
+  250: Siberian Husky
+  251: Dalmatian
+  252: Affenpinscher
+  253: Basenji
+  254: pug
+  255: Leonberger
+  256: Newfoundland
+  257: Pyrenean Mountain Dog
+  258: Samoyed
+  259: Pomeranian
+  260: Chow Chow
+  261: Keeshond
+  262: Griffon Bruxellois
+  263: Pembroke Welsh Corgi
+  264: Cardigan Welsh Corgi
+  265: Toy Poodle
+  266: Miniature Poodle
+  267: Standard Poodle
+  268: Mexican hairless dog
+  269: grey wolf
+  270: Alaskan tundra wolf
+  271: red wolf
+  272: coyote
+  273: dingo
+  274: dhole
+  275: African wild dog
+  276: hyena
+  277: red fox
+  278: kit fox
+  279: Arctic fox
+  280: grey fox
+  281: tabby cat
+  282: tiger cat
+  283: Persian cat
+  284: Siamese cat
+  285: Egyptian Mau
+  286: cougar
+  287: lynx
+  288: leopard
+  289: snow leopard
+  290: jaguar
+  291: lion
+  292: tiger
+  293: cheetah
+  294: brown bear
+  295: American black bear
+  296: polar bear
+  297: sloth bear
+  298: mongoose
+  299: meerkat
+  300: tiger beetle
+  301: ladybug
+  302: ground beetle
+  303: longhorn beetle
+  304: leaf beetle
+  305: dung beetle
+  306: rhinoceros beetle
+  307: weevil
+  308: fly
+  309: bee
+  310: ant
+  311: grasshopper
+  312: cricket
+  313: stick insect
+  314: cockroach
+  315: mantis
+  316: cicada
+  317: leafhopper
+  318: lacewing
+  319: dragonfly
+  320: damselfly
+  321: red admiral
+  322: ringlet
+  323: monarch butterfly
+  324: small white
+  325: sulphur butterfly
+  326: gossamer-winged butterfly
+  327: starfish
+  328: sea urchin
+  329: sea cucumber
+  330: cottontail rabbit
+  331: hare
+  332: Angora rabbit
+  333: hamster
+  334: porcupine
+  335: fox squirrel
+  336: marmot
+  337: beaver
+  338: guinea pig
+  339: common sorrel
+  340: zebra
+  341: pig
+  342: wild boar
+  343: warthog
+  344: hippopotamus
+  345: ox
+  346: water buffalo
+  347: bison
+  348: ram
+  349: bighorn sheep
+  350: Alpine ibex
+  351: hartebeest
+  352: impala
+  353: gazelle
+  354: dromedary
+  355: llama
+  356: weasel
+  357: mink
+  358: European polecat
+  359: black-footed ferret
+  360: otter
+  361: skunk
+  362: badger
+  363: armadillo
+  364: three-toed sloth
+  365: orangutan
+  366: gorilla
+  367: chimpanzee
+  368: gibbon
+  369: siamang
+  370: guenon
+  371: patas monkey
+  372: baboon
+  373: macaque
+  374: langur
+  375: black-and-white colobus
+  376: proboscis monkey
+  377: marmoset
+  378: white-headed capuchin
+  379: howler monkey
+  380: titi
+  381: Geoffroy's spider monkey
+  382: common squirrel monkey
+  383: ring-tailed lemur
+  384: indri
+  385: Asian elephant
+  386: African bush elephant
+  387: red panda
+  388: giant panda
+  389: snoek
+  390: eel
+  391: coho salmon
+  392: rock beauty
+  393: clownfish
+  394: sturgeon
+  395: garfish
+  396: lionfish
+  397: pufferfish
+  398: abacus
+  399: abaya
+  400: academic gown
+  401: accordion
+  402: acoustic guitar
+  403: aircraft carrier
+  404: airliner
+  405: airship
+  406: altar
+  407: ambulance
+  408: amphibious vehicle
+  409: analog clock
+  410: apiary
+  411: apron
+  412: waste container
+  413: assault rifle
+  414: backpack
+  415: bakery
+  416: balance beam
+  417: balloon
+  418: ballpoint pen
+  419: Band-Aid
+  420: banjo
+  421: baluster
+  422: barbell
+  423: barber chair
+  424: barbershop
+  425: barn
+  426: barometer
+  427: barrel
+  428: wheelbarrow
+  429: baseball
+  430: basketball
+  431: bassinet
+  432: bassoon
+  433: swimming cap
+  434: bath towel
+  435: bathtub
+  436: station wagon
+  437: lighthouse
+  438: beaker
+  439: military cap
+  440: beer bottle
+  441: beer glass
+  442: bell-cot
+  443: bib
+  444: tandem bicycle
+  445: bikini
+  446: ring binder
+  447: binoculars
+  448: birdhouse
+  449: boathouse
+  450: bobsleigh
+  451: bolo tie
+  452: poke bonnet
+  453: bookcase
+  454: bookstore
+  455: bottle cap
+  456: bow
+  457: bow tie
+  458: brass
+  459: bra
+  460: breakwater
+  461: breastplate
+  462: broom
+  463: bucket
+  464: buckle
+  465: bulletproof vest
+  466: high-speed train
+  467: butcher shop
+  468: taxicab
+  469: cauldron
+  470: candle
+  471: cannon
+  472: canoe
+  473: can opener
+  474: cardigan
+  475: car mirror
+  476: carousel
+  477: tool kit
+  478: carton
+  479: car wheel
+  480: automated teller machine
+  481: cassette
+  482: cassette player
+  483: castle
+  484: catamaran
+  485: CD player
+  486: cello
+  487: mobile phone
+  488: chain
+  489: chain-link fence
+  490: chain mail
+  491: chainsaw
+  492: chest
+  493: chiffonier
+  494: chime
+  495: china cabinet
+  496: Christmas stocking
+  497: church
+  498: movie theater
+  499: cleaver
+  500: cliff dwelling
+  501: cloak
+  502: clogs
+  503: cocktail shaker
+  504: coffee mug
+  505: coffeemaker
+  506: coil
+  507: combination lock
+  508: computer keyboard
+  509: confectionery store
+  510: container ship
+  511: convertible
+  512: corkscrew
+  513: cornet
+  514: cowboy boot
+  515: cowboy hat
+  516: cradle
+  517: crane (machine)
+  518: crash helmet
+  519: crate
+  520: infant bed
+  521: Crock Pot
+  522: croquet ball
+  523: crutch
+  524: cuirass
+  525: dam
+  526: desk
+  527: desktop computer
+  528: rotary dial telephone
+  529: diaper
+  530: digital clock
+  531: digital watch
+  532: dining table
+  533: dishcloth
+  534: dishwasher
+  535: disc brake
+  536: dock
+  537: dog sled
+  538: dome
+  539: doormat
+  540: drilling rig
+  541: drum
+  542: drumstick
+  543: dumbbell
+  544: Dutch oven
+  545: electric fan
+  546: electric guitar
+  547: electric locomotive
+  548: entertainment center
+  549: envelope
+  550: espresso machine
+  551: face powder
+  552: feather boa
+  553: filing cabinet
+  554: fireboat
+  555: fire engine
+  556: fire screen sheet
+  557: flagpole
+  558: flute
+  559: folding chair
+  560: football helmet
+  561: forklift
+  562: fountain
+  563: fountain pen
+  564: four-poster bed
+  565: freight car
+  566: French horn
+  567: frying pan
+  568: fur coat
+  569: garbage truck
+  570: gas mask
+  571: gas pump
+  572: goblet
+  573: go-kart
+  574: golf ball
+  575: golf cart
+  576: gondola
+  577: gong
+  578: gown
+  579: grand piano
+  580: greenhouse
+  581: grille
+  582: grocery store
+  583: guillotine
+  584: barrette
+  585: hair spray
+  586: half-track
+  587: hammer
+  588: hamper
+  589: hair dryer
+  590: hand-held computer
+  591: handkerchief
+  592: hard disk drive
+  593: harmonica
+  594: harp
+  595: harvester
+  596: hatchet
+  597: holster
+  598: home theater
+  599: honeycomb
+  600: hook
+  601: hoop skirt
+  602: horizontal bar
+  603: horse-drawn vehicle
+  604: hourglass
+  605: iPod
+  606: clothes iron
+  607: jack-o'-lantern
+  608: jeans
+  609: jeep
+  610: T-shirt
+  611: jigsaw puzzle
+  612: pulled rickshaw
+  613: joystick
+  614: kimono
+  615: knee pad
+  616: knot
+  617: lab coat
+  618: ladle
+  619: lampshade
+  620: laptop computer
+  621: lawn mower
+  622: lens cap
+  623: paper knife
+  624: library
+  625: lifeboat
+  626: lighter
+  627: limousine
+  628: ocean liner
+  629: lipstick
+  630: slip-on shoe
+  631: lotion
+  632: speaker
+  633: loupe
+  634: sawmill
+  635: magnetic compass
+  636: mail bag
+  637: mailbox
+  638: tights
+  639: tank suit
+  640: manhole cover
+  641: maraca
+  642: marimba
+  643: mask
+  644: match
+  645: maypole
+  646: maze
+  647: measuring cup
+  648: medicine chest
+  649: megalith
+  650: microphone
+  651: microwave oven
+  652: military uniform
+  653: milk can
+  654: minibus
+  655: miniskirt
+  656: minivan
+  657: missile
+  658: mitten
+  659: mixing bowl
+  660: mobile home
+  661: Model T
+  662: modem
+  663: monastery
+  664: monitor
+  665: moped
+  666: mortar
+  667: square academic cap
+  668: mosque
+  669: mosquito net
+  670: scooter
+  671: mountain bike
+  672: tent
+  673: computer mouse
+  674: mousetrap
+  675: moving van
+  676: muzzle
+  677: nail
+  678: neck brace
+  679: necklace
+  680: nipple
+  681: notebook computer
+  682: obelisk
+  683: oboe
+  684: ocarina
+  685: odometer
+  686: oil filter
+  687: organ
+  688: oscilloscope
+  689: overskirt
+  690: bullock cart
+  691: oxygen mask
+  692: packet
+  693: paddle
+  694: paddle wheel
+  695: padlock
+  696: paintbrush
+  697: pajamas
+  698: palace
+  699: pan flute
+  700: paper towel
+  701: parachute
+  702: parallel bars
+  703: park bench
+  704: parking meter
+  705: passenger car
+  706: patio
+  707: payphone
+  708: pedestal
+  709: pencil case
+  710: pencil sharpener
+  711: perfume
+  712: Petri dish
+  713: photocopier
+  714: plectrum
+  715: Pickelhaube
+  716: picket fence
+  717: pickup truck
+  718: pier
+  719: piggy bank
+  720: pill bottle
+  721: pillow
+  722: ping-pong ball
+  723: pinwheel
+  724: pirate ship
+  725: pitcher
+  726: hand plane
+  727: planetarium
+  728: plastic bag
+  729: plate rack
+  730: plow
+  731: plunger
+  732: Polaroid camera
+  733: pole
+  734: police van
+  735: poncho
+  736: billiard table
+  737: soda bottle
+  738: pot
+  739: potter's wheel
+  740: power drill
+  741: prayer rug
+  742: printer
+  743: prison
+  744: projectile
+  745: projector
+  746: hockey puck
+  747: punching bag
+  748: purse
+  749: quill
+  750: quilt
+  751: race car
+  752: racket
+  753: radiator
+  754: radio
+  755: radio telescope
+  756: rain barrel
+  757: recreational vehicle
+  758: reel
+  759: reflex camera
+  760: refrigerator
+  761: remote control
+  762: restaurant
+  763: revolver
+  764: rifle
+  765: rocking chair
+  766: rotisserie
+  767: eraser
+  768: rugby ball
+  769: ruler
+  770: running shoe
+  771: safe
+  772: safety pin
+  773: salt shaker
+  774: sandal
+  775: sarong
+  776: saxophone
+  777: scabbard
+  778: weighing scale
+  779: school bus
+  780: schooner
+  781: scoreboard
+  782: CRT screen
+  783: screw
+  784: screwdriver
+  785: seat belt
+  786: sewing machine
+  787: shield
+  788: shoe store
+  789: shoji
+  790: shopping basket
+  791: shopping cart
+  792: shovel
+  793: shower cap
+  794: shower curtain
+  795: ski
+  796: ski mask
+  797: sleeping bag
+  798: slide rule
+  799: sliding door
+  800: slot machine
+  801: snorkel
+  802: snowmobile
+  803: snowplow
+  804: soap dispenser
+  805: soccer ball
+  806: sock
+  807: solar thermal collector
+  808: sombrero
+  809: soup bowl
+  810: space bar
+  811: space heater
+  812: space shuttle
+  813: spatula
+  814: motorboat
+  815: spider web
+  816: spindle
+  817: sports car
+  818: spotlight
+  819: stage
+  820: steam locomotive
+  821: through arch bridge
+  822: steel drum
+  823: stethoscope
+  824: scarf
+  825: stone wall
+  826: stopwatch
+  827: stove
+  828: strainer
+  829: tram
+  830: stretcher
+  831: couch
+  832: stupa
+  833: submarine
+  834: suit
+  835: sundial
+  836: sunglass
+  837: sunglasses
+  838: sunscreen
+  839: suspension bridge
+  840: mop
+  841: sweatshirt
+  842: swimsuit
+  843: swing
+  844: switch
+  845: syringe
+  846: table lamp
+  847: tank
+  848: tape player
+  849: teapot
+  850: teddy bear
+  851: television
+  852: tennis ball
+  853: thatched roof
+  854: front curtain
+  855: thimble
+  856: threshing machine
+  857: throne
+  858: tile roof
+  859: toaster
+  860: tobacco shop
+  861: toilet seat
+  862: torch
+  863: totem pole
+  864: tow truck
+  865: toy store
+  866: tractor
+  867: semi-trailer truck
+  868: tray
+  869: trench coat
+  870: tricycle
+  871: trimaran
+  872: tripod
+  873: triumphal arch
+  874: trolleybus
+  875: trombone
+  876: tub
+  877: turnstile
+  878: typewriter keyboard
+  879: umbrella
+  880: unicycle
+  881: upright piano
+  882: vacuum cleaner
+  883: vase
+  884: vault
+  885: velvet
+  886: vending machine
+  887: vestment
+  888: viaduct
+  889: violin
+  890: volleyball
+  891: waffle iron
+  892: wall clock
+  893: wallet
+  894: wardrobe
+  895: military aircraft
+  896: sink
+  897: washing machine
+  898: water bottle
+  899: water jug
+  900: water tower
+  901: whiskey jug
+  902: whistle
+  903: wig
+  904: window screen
+  905: window shade
+  906: Windsor tie
+  907: wine bottle
+  908: wing
+  909: wok
+  910: wooden spoon
+  911: wool
+  912: split-rail fence
+  913: shipwreck
+  914: yawl
+  915: yurt
+  916: website
+  917: comic book
+  918: crossword
+  919: traffic sign
+  920: traffic light
+  921: dust jacket
+  922: menu
+  923: plate
+  924: guacamole
+  925: consomme
+  926: hot pot
+  927: trifle
+  928: ice cream
+  929: ice pop
+  930: baguette
+  931: bagel
+  932: pretzel
+  933: cheeseburger
+  934: hot dog
+  935: mashed potato
+  936: cabbage
+  937: broccoli
+  938: cauliflower
+  939: zucchini
+  940: spaghetti squash
+  941: acorn squash
+  942: butternut squash
+  943: cucumber
+  944: artichoke
+  945: bell pepper
+  946: cardoon
+  947: mushroom
+  948: Granny Smith
+  949: strawberry
+  950: orange
+  951: lemon
+  952: fig
+  953: pineapple
+  954: banana
+  955: jackfruit
+  956: custard apple
+  957: pomegranate
+  958: hay
+  959: carbonara
+  960: chocolate syrup
+  961: dough
+  962: meatloaf
+  963: pizza
+  964: pot pie
+  965: burrito
+  966: red wine
+  967: espresso
+  968: cup
+  969: eggnog
+  970: alp
+  971: bubble
+  972: cliff
+  973: coral reef
+  974: geyser
+  975: lakeshore
+  976: promontory
+  977: shoal
+  978: seashore
+  979: valley
+  980: volcano
+  981: baseball player
+  982: bridegroom
+  983: scuba diver
+  984: rapeseed
+  985: daisy
+  986: yellow lady's slipper
+  987: corn
+  988: acorn
+  989: rose hip
+  990: horse chestnut seed
+  991: coral fungus
+  992: agaric
+  993: gyromitra
+  994: stinkhorn mushroom
+  995: earth star
+  996: hen-of-the-woods
+  997: bolete
+  998: ear
+  999: toilet paper
+
+# Imagenet class codes to human-readable names
+map:
+  n01440764: tench
+  n01443537: goldfish
+  n01484850: great_white_shark
+  n01491361: tiger_shark
+  n01494475: hammerhead
+  n01496331: electric_ray
+  n01498041: stingray
+  n01514668: cock
+  n01514859: hen
+  n01518878: ostrich
+  n01530575: brambling
+  n01531178: goldfinch
+  n01532829: house_finch
+  n01534433: junco
+  n01537544: indigo_bunting
+  n01558993: robin
+  n01560419: bulbul
+  n01580077: jay
+  n01582220: magpie
+  n01592084: chickadee
+  n01601694: water_ouzel
+  n01608432: kite
+  n01614925: bald_eagle
+  n01616318: vulture
+  n01622779: great_grey_owl
+  n01629819: European_fire_salamander
+  n01630670: common_newt
+  n01631663: eft
+  n01632458: spotted_salamander
+  n01632777: axolotl
+  n01641577: bullfrog
+  n01644373: tree_frog
+  n01644900: tailed_frog
+  n01664065: loggerhead
+  n01665541: leatherback_turtle
+  n01667114: mud_turtle
+  n01667778: terrapin
+  n01669191: box_turtle
+  n01675722: banded_gecko
+  n01677366: common_iguana
+  n01682714: American_chameleon
+  n01685808: whiptail
+  n01687978: agama
+  n01688243: frilled_lizard
+  n01689811: alligator_lizard
+  n01692333: Gila_monster
+  n01693334: green_lizard
+  n01694178: African_chameleon
+  n01695060: Komodo_dragon
+  n01697457: African_crocodile
+  n01698640: American_alligator
+  n01704323: triceratops
+  n01728572: thunder_snake
+  n01728920: ringneck_snake
+  n01729322: hognose_snake
+  n01729977: green_snake
+  n01734418: king_snake
+  n01735189: garter_snake
+  n01737021: water_snake
+  n01739381: vine_snake
+  n01740131: night_snake
+  n01742172: boa_constrictor
+  n01744401: rock_python
+  n01748264: Indian_cobra
+  n01749939: green_mamba
+  n01751748: sea_snake
+  n01753488: horned_viper
+  n01755581: diamondback
+  n01756291: sidewinder
+  n01768244: trilobite
+  n01770081: harvestman
+  n01770393: scorpion
+  n01773157: black_and_gold_garden_spider
+  n01773549: barn_spider
+  n01773797: garden_spider
+  n01774384: black_widow
+  n01774750: tarantula
+  n01775062: wolf_spider
+  n01776313: tick
+  n01784675: centipede
+  n01795545: black_grouse
+  n01796340: ptarmigan
+  n01797886: ruffed_grouse
+  n01798484: prairie_chicken
+  n01806143: peacock
+  n01806567: quail
+  n01807496: partridge
+  n01817953: African_grey
+  n01818515: macaw
+  n01819313: sulphur-crested_cockatoo
+  n01820546: lorikeet
+  n01824575: coucal
+  n01828970: bee_eater
+  n01829413: hornbill
+  n01833805: hummingbird
+  n01843065: jacamar
+  n01843383: toucan
+  n01847000: drake
+  n01855032: red-breasted_merganser
+  n01855672: goose
+  n01860187: black_swan
+  n01871265: tusker
+  n01872401: echidna
+  n01873310: platypus
+  n01877812: wallaby
+  n01882714: koala
+  n01883070: wombat
+  n01910747: jellyfish
+  n01914609: sea_anemone
+  n01917289: brain_coral
+  n01924916: flatworm
+  n01930112: nematode
+  n01943899: conch
+  n01944390: snail
+  n01945685: slug
+  n01950731: sea_slug
+  n01955084: chiton
+  n01968897: chambered_nautilus
+  n01978287: Dungeness_crab
+  n01978455: rock_crab
+  n01980166: fiddler_crab
+  n01981276: king_crab
+  n01983481: American_lobster
+  n01984695: spiny_lobster
+  n01985128: crayfish
+  n01986214: hermit_crab
+  n01990800: isopod
+  n02002556: white_stork
+  n02002724: black_stork
+  n02006656: spoonbill
+  n02007558: flamingo
+  n02009229: little_blue_heron
+  n02009912: American_egret
+  n02011460: bittern
+  n02012849: crane_(bird)
+  n02013706: limpkin
+  n02017213: European_gallinule
+  n02018207: American_coot
+  n02018795: bustard
+  n02025239: ruddy_turnstone
+  n02027492: red-backed_sandpiper
+  n02028035: redshank
+  n02033041: dowitcher
+  n02037110: oystercatcher
+  n02051845: pelican
+  n02056570: king_penguin
+  n02058221: albatross
+  n02066245: grey_whale
+  n02071294: killer_whale
+  n02074367: dugong
+  n02077923: sea_lion
+  n02085620: Chihuahua
+  n02085782: Japanese_spaniel
+  n02085936: Maltese_dog
+  n02086079: Pekinese
+  n02086240: Shih-Tzu
+  n02086646: Blenheim_spaniel
+  n02086910: papillon
+  n02087046: toy_terrier
+  n02087394: Rhodesian_ridgeback
+  n02088094: Afghan_hound
+  n02088238: basset
+  n02088364: beagle
+  n02088466: bloodhound
+  n02088632: bluetick
+  n02089078: black-and-tan_coonhound
+  n02089867: Walker_hound
+  n02089973: English_foxhound
+  n02090379: redbone
+  n02090622: borzoi
+  n02090721: Irish_wolfhound
+  n02091032: Italian_greyhound
+  n02091134: whippet
+  n02091244: Ibizan_hound
+  n02091467: Norwegian_elkhound
+  n02091635: otterhound
+  n02091831: Saluki
+  n02092002: Scottish_deerhound
+  n02092339: Weimaraner
+  n02093256: Staffordshire_bullterrier
+  n02093428: American_Staffordshire_terrier
+  n02093647: Bedlington_terrier
+  n02093754: Border_terrier
+  n02093859: Kerry_blue_terrier
+  n02093991: Irish_terrier
+  n02094114: Norfolk_terrier
+  n02094258: Norwich_terrier
+  n02094433: Yorkshire_terrier
+  n02095314: wire-haired_fox_terrier
+  n02095570: Lakeland_terrier
+  n02095889: Sealyham_terrier
+  n02096051: Airedale
+  n02096177: cairn
+  n02096294: Australian_terrier
+  n02096437: Dandie_Dinmont
+  n02096585: Boston_bull
+  n02097047: miniature_schnauzer
+  n02097130: giant_schnauzer
+  n02097209: standard_schnauzer
+  n02097298: Scotch_terrier
+  n02097474: Tibetan_terrier
+  n02097658: silky_terrier
+  n02098105: soft-coated_wheaten_terrier
+  n02098286: West_Highland_white_terrier
+  n02098413: Lhasa
+  n02099267: flat-coated_retriever
+  n02099429: curly-coated_retriever
+  n02099601: golden_retriever
+  n02099712: Labrador_retriever
+  n02099849: Chesapeake_Bay_retriever
+  n02100236: German_short-haired_pointer
+  n02100583: vizsla
+  n02100735: English_setter
+  n02100877: Irish_setter
+  n02101006: Gordon_setter
+  n02101388: Brittany_spaniel
+  n02101556: clumber
+  n02102040: English_springer
+  n02102177: Welsh_springer_spaniel
+  n02102318: cocker_spaniel
+  n02102480: Sussex_spaniel
+  n02102973: Irish_water_spaniel
+  n02104029: kuvasz
+  n02104365: schipperke
+  n02105056: groenendael
+  n02105162: malinois
+  n02105251: briard
+  n02105412: kelpie
+  n02105505: komondor
+  n02105641: Old_English_sheepdog
+  n02105855: Shetland_sheepdog
+  n02106030: collie
+  n02106166: Border_collie
+  n02106382: Bouvier_des_Flandres
+  n02106550: Rottweiler
+  n02106662: German_shepherd
+  n02107142: Doberman
+  n02107312: miniature_pinscher
+  n02107574: Greater_Swiss_Mountain_dog
+  n02107683: Bernese_mountain_dog
+  n02107908: Appenzeller
+  n02108000: EntleBucher
+  n02108089: boxer
+  n02108422: bull_mastiff
+  n02108551: Tibetan_mastiff
+  n02108915: French_bulldog
+  n02109047: Great_Dane
+  n02109525: Saint_Bernard
+  n02109961: Eskimo_dog
+  n02110063: malamute
+  n02110185: Siberian_husky
+  n02110341: dalmatian
+  n02110627: affenpinscher
+  n02110806: basenji
+  n02110958: pug
+  n02111129: Leonberg
+  n02111277: Newfoundland
+  n02111500: Great_Pyrenees
+  n02111889: Samoyed
+  n02112018: Pomeranian
+  n02112137: chow
+  n02112350: keeshond
+  n02112706: Brabancon_griffon
+  n02113023: Pembroke
+  n02113186: Cardigan
+  n02113624: toy_poodle
+  n02113712: miniature_poodle
+  n02113799: standard_poodle
+  n02113978: Mexican_hairless
+  n02114367: timber_wolf
+  n02114548: white_wolf
+  n02114712: red_wolf
+  n02114855: coyote
+  n02115641: dingo
+  n02115913: dhole
+  n02116738: African_hunting_dog
+  n02117135: hyena
+  n02119022: red_fox
+  n02119789: kit_fox
+  n02120079: Arctic_fox
+  n02120505: grey_fox
+  n02123045: tabby
+  n02123159: tiger_cat
+  n02123394: Persian_cat
+  n02123597: Siamese_cat
+  n02124075: Egyptian_cat
+  n02125311: cougar
+  n02127052: lynx
+  n02128385: leopard
+  n02128757: snow_leopard
+  n02128925: jaguar
+  n02129165: lion
+  n02129604: tiger
+  n02130308: cheetah
+  n02132136: brown_bear
+  n02133161: American_black_bear
+  n02134084: ice_bear
+  n02134418: sloth_bear
+  n02137549: mongoose
+  n02138441: meerkat
+  n02165105: tiger_beetle
+  n02165456: ladybug
+  n02167151: ground_beetle
+  n02168699: long-horned_beetle
+  n02169497: leaf_beetle
+  n02172182: dung_beetle
+  n02174001: rhinoceros_beetle
+  n02177972: weevil
+  n02190166: fly
+  n02206856: bee
+  n02219486: ant
+  n02226429: grasshopper
+  n02229544: cricket
+  n02231487: walking_stick
+  n02233338: cockroach
+  n02236044: mantis
+  n02256656: cicada
+  n02259212: leafhopper
+  n02264363: lacewing
+  n02268443: dragonfly
+  n02268853: damselfly
+  n02276258: admiral
+  n02277742: ringlet
+  n02279972: monarch
+  n02280649: cabbage_butterfly
+  n02281406: sulphur_butterfly
+  n02281787: lycaenid
+  n02317335: starfish
+  n02319095: sea_urchin
+  n02321529: sea_cucumber
+  n02325366: wood_rabbit
+  n02326432: hare
+  n02328150: Angora
+  n02342885: hamster
+  n02346627: porcupine
+  n02356798: fox_squirrel
+  n02361337: marmot
+  n02363005: beaver
+  n02364673: guinea_pig
+  n02389026: sorrel
+  n02391049: zebra
+  n02395406: hog
+  n02396427: wild_boar
+  n02397096: warthog
+  n02398521: hippopotamus
+  n02403003: ox
+  n02408429: water_buffalo
+  n02410509: bison
+  n02412080: ram
+  n02415577: bighorn
+  n02417914: ibex
+  n02422106: hartebeest
+  n02422699: impala
+  n02423022: gazelle
+  n02437312: Arabian_camel
+  n02437616: llama
+  n02441942: weasel
+  n02442845: mink
+  n02443114: polecat
+  n02443484: black-footed_ferret
+  n02444819: otter
+  n02445715: skunk
+  n02447366: badger
+  n02454379: armadillo
+  n02457408: three-toed_sloth
+  n02480495: orangutan
+  n02480855: gorilla
+  n02481823: chimpanzee
+  n02483362: gibbon
+  n02483708: siamang
+  n02484975: guenon
+  n02486261: patas
+  n02486410: baboon
+  n02487347: macaque
+  n02488291: langur
+  n02488702: colobus
+  n02489166: proboscis_monkey
+  n02490219: marmoset
+  n02492035: capuchin
+  n02492660: howler_monkey
+  n02493509: titi
+  n02493793: spider_monkey
+  n02494079: squirrel_monkey
+  n02497673: Madagascar_cat
+  n02500267: indri
+  n02504013: Indian_elephant
+  n02504458: African_elephant
+  n02509815: lesser_panda
+  n02510455: giant_panda
+  n02514041: barracouta
+  n02526121: eel
+  n02536864: coho
+  n02606052: rock_beauty
+  n02607072: anemone_fish
+  n02640242: sturgeon
+  n02641379: gar
+  n02643566: lionfish
+  n02655020: puffer
+  n02666196: abacus
+  n02667093: abaya
+  n02669723: academic_gown
+  n02672831: accordion
+  n02676566: acoustic_guitar
+  n02687172: aircraft_carrier
+  n02690373: airliner
+  n02692877: airship
+  n02699494: altar
+  n02701002: ambulance
+  n02704792: amphibian
+  n02708093: analog_clock
+  n02727426: apiary
+  n02730930: apron
+  n02747177: ashcan
+  n02749479: assault_rifle
+  n02769748: backpack
+  n02776631: bakery
+  n02777292: balance_beam
+  n02782093: balloon
+  n02783161: ballpoint
+  n02786058: Band_Aid
+  n02787622: banjo
+  n02788148: bannister
+  n02790996: barbell
+  n02791124: barber_chair
+  n02791270: barbershop
+  n02793495: barn
+  n02794156: barometer
+  n02795169: barrel
+  n02797295: barrow
+  n02799071: baseball
+  n02802426: basketball
+  n02804414: bassinet
+  n02804610: bassoon
+  n02807133: bathing_cap
+  n02808304: bath_towel
+  n02808440: bathtub
+  n02814533: beach_wagon
+  n02814860: beacon
+  n02815834: beaker
+  n02817516: bearskin
+  n02823428: beer_bottle
+  n02823750: beer_glass
+  n02825657: bell_cote
+  n02834397: bib
+  n02835271: bicycle-built-for-two
+  n02837789: bikini
+  n02840245: binder
+  n02841315: binoculars
+  n02843684: birdhouse
+  n02859443: boathouse
+  n02860847: bobsled
+  n02865351: bolo_tie
+  n02869837: bonnet
+  n02870880: bookcase
+  n02871525: bookshop
+  n02877765: bottlecap
+  n02879718: bow
+  n02883205: bow_tie
+  n02892201: brass
+  n02892767: brassiere
+  n02894605: breakwater
+  n02895154: breastplate
+  n02906734: broom
+  n02909870: bucket
+  n02910353: buckle
+  n02916936: bulletproof_vest
+  n02917067: bullet_train
+  n02927161: butcher_shop
+  n02930766: cab
+  n02939185: caldron
+  n02948072: candle
+  n02950826: cannon
+  n02951358: canoe
+  n02951585: can_opener
+  n02963159: cardigan
+  n02965783: car_mirror
+  n02966193: carousel
+  n02966687: carpenter's_kit
+  n02971356: carton
+  n02974003: car_wheel
+  n02977058: cash_machine
+  n02978881: cassette
+  n02979186: cassette_player
+  n02980441: castle
+  n02981792: catamaran
+  n02988304: CD_player
+  n02992211: cello
+  n02992529: cellular_telephone
+  n02999410: chain
+  n03000134: chainlink_fence
+  n03000247: chain_mail
+  n03000684: chain_saw
+  n03014705: chest
+  n03016953: chiffonier
+  n03017168: chime
+  n03018349: china_cabinet
+  n03026506: Christmas_stocking
+  n03028079: church
+  n03032252: cinema
+  n03041632: cleaver
+  n03042490: cliff_dwelling
+  n03045698: cloak
+  n03047690: clog
+  n03062245: cocktail_shaker
+  n03063599: coffee_mug
+  n03063689: coffeepot
+  n03065424: coil
+  n03075370: combination_lock
+  n03085013: computer_keyboard
+  n03089624: confectionery
+  n03095699: container_ship
+  n03100240: convertible
+  n03109150: corkscrew
+  n03110669: cornet
+  n03124043: cowboy_boot
+  n03124170: cowboy_hat
+  n03125729: cradle
+  n03126707: crane_(machine)
+  n03127747: crash_helmet
+  n03127925: crate
+  n03131574: crib
+  n03133878: Crock_Pot
+  n03134739: croquet_ball
+  n03141823: crutch
+  n03146219: cuirass
+  n03160309: dam
+  n03179701: desk
+  n03180011: desktop_computer
+  n03187595: dial_telephone
+  n03188531: diaper
+  n03196217: digital_clock
+  n03197337: digital_watch
+  n03201208: dining_table
+  n03207743: dishrag
+  n03207941: dishwasher
+  n03208938: disk_brake
+  n03216828: dock
+  n03218198: dogsled
+  n03220513: dome
+  n03223299: doormat
+  n03240683: drilling_platform
+  n03249569: drum
+  n03250847: drumstick
+  n03255030: dumbbell
+  n03259280: Dutch_oven
+  n03271574: electric_fan
+  n03272010: electric_guitar
+  n03272562: electric_locomotive
+  n03290653: entertainment_center
+  n03291819: envelope
+  n03297495: espresso_maker
+  n03314780: face_powder
+  n03325584: feather_boa
+  n03337140: file
+  n03344393: fireboat
+  n03345487: fire_engine
+  n03347037: fire_screen
+  n03355925: flagpole
+  n03372029: flute
+  n03376595: folding_chair
+  n03379051: football_helmet
+  n03384352: forklift
+  n03388043: fountain
+  n03388183: fountain_pen
+  n03388549: four-poster
+  n03393912: freight_car
+  n03394916: French_horn
+  n03400231: frying_pan
+  n03404251: fur_coat
+  n03417042: garbage_truck
+  n03424325: gasmask
+  n03425413: gas_pump
+  n03443371: goblet
+  n03444034: go-kart
+  n03445777: golf_ball
+  n03445924: golfcart
+  n03447447: gondola
+  n03447721: gong
+  n03450230: gown
+  n03452741: grand_piano
+  n03457902: greenhouse
+  n03459775: grille
+  n03461385: grocery_store
+  n03467068: guillotine
+  n03476684: hair_slide
+  n03476991: hair_spray
+  n03478589: half_track
+  n03481172: hammer
+  n03482405: hamper
+  n03483316: hand_blower
+  n03485407: hand-held_computer
+  n03485794: handkerchief
+  n03492542: hard_disc
+  n03494278: harmonica
+  n03495258: harp
+  n03496892: harvester
+  n03498962: hatchet
+  n03527444: holster
+  n03529860: home_theater
+  n03530642: honeycomb
+  n03532672: hook
+  n03534580: hoopskirt
+  n03535780: horizontal_bar
+  n03538406: horse_cart
+  n03544143: hourglass
+  n03584254: iPod
+  n03584829: iron
+  n03590841: jack-o'-lantern
+  n03594734: jean
+  n03594945: jeep
+  n03595614: jersey
+  n03598930: jigsaw_puzzle
+  n03599486: jinrikisha
+  n03602883: joystick
+  n03617480: kimono
+  n03623198: knee_pad
+  n03627232: knot
+  n03630383: lab_coat
+  n03633091: ladle
+  n03637318: lampshade
+  n03642806: laptop
+  n03649909: lawn_mower
+  n03657121: lens_cap
+  n03658185: letter_opener
+  n03661043: library
+  n03662601: lifeboat
+  n03666591: lighter
+  n03670208: limousine
+  n03673027: liner
+  n03676483: lipstick
+  n03680355: Loafer
+  n03690938: lotion
+  n03691459: loudspeaker
+  n03692522: loupe
+  n03697007: lumbermill
+  n03706229: magnetic_compass
+  n03709823: mailbag
+  n03710193: mailbox
+  n03710637: maillot_(tights)
+  n03710721: maillot_(tank_suit)
+  n03717622: manhole_cover
+  n03720891: maraca
+  n03721384: marimba
+  n03724870: mask
+  n03729826: matchstick
+  n03733131: maypole
+  n03733281: maze
+  n03733805: measuring_cup
+  n03742115: medicine_chest
+  n03743016: megalith
+  n03759954: microphone
+  n03761084: microwave
+  n03763968: military_uniform
+  n03764736: milk_can
+  n03769881: minibus
+  n03770439: miniskirt
+  n03770679: minivan
+  n03773504: missile
+  n03775071: mitten
+  n03775546: mixing_bowl
+  n03776460: mobile_home
+  n03777568: Model_T
+  n03777754: modem
+  n03781244: monastery
+  n03782006: monitor
+  n03785016: moped
+  n03786901: mortar
+  n03787032: mortarboard
+  n03788195: mosque
+  n03788365: mosquito_net
+  n03791053: motor_scooter
+  n03792782: mountain_bike
+  n03792972: mountain_tent
+  n03793489: mouse
+  n03794056: mousetrap
+  n03796401: moving_van
+  n03803284: muzzle
+  n03804744: nail
+  n03814639: neck_brace
+  n03814906: necklace
+  n03825788: nipple
+  n03832673: notebook
+  n03837869: obelisk
+  n03838899: oboe
+  n03840681: ocarina
+  n03841143: odometer
+  n03843555: oil_filter
+  n03854065: organ
+  n03857828: oscilloscope
+  n03866082: overskirt
+  n03868242: oxcart
+  n03868863: oxygen_mask
+  n03871628: packet
+  n03873416: paddle
+  n03874293: paddlewheel
+  n03874599: padlock
+  n03876231: paintbrush
+  n03877472: pajama
+  n03877845: palace
+  n03884397: panpipe
+  n03887697: paper_towel
+  n03888257: parachute
+  n03888605: parallel_bars
+  n03891251: park_bench
+  n03891332: parking_meter
+  n03895866: passenger_car
+  n03899768: patio
+  n03902125: pay-phone
+  n03903868: pedestal
+  n03908618: pencil_box
+  n03908714: pencil_sharpener
+  n03916031: perfume
+  n03920288: Petri_dish
+  n03924679: photocopier
+  n03929660: pick
+  n03929855: pickelhaube
+  n03930313: picket_fence
+  n03930630: pickup
+  n03933933: pier
+  n03935335: piggy_bank
+  n03937543: pill_bottle
+  n03938244: pillow
+  n03942813: ping-pong_ball
+  n03944341: pinwheel
+  n03947888: pirate
+  n03950228: pitcher
+  n03954731: plane
+  n03956157: planetarium
+  n03958227: plastic_bag
+  n03961711: plate_rack
+  n03967562: plow
+  n03970156: plunger
+  n03976467: Polaroid_camera
+  n03976657: pole
+  n03977966: police_van
+  n03980874: poncho
+  n03982430: pool_table
+  n03983396: pop_bottle
+  n03991062: pot
+  n03992509: potter's_wheel
+  n03995372: power_drill
+  n03998194: prayer_rug
+  n04004767: printer
+  n04005630: prison
+  n04008634: projectile
+  n04009552: projector
+  n04019541: puck
+  n04023962: punching_bag
+  n04026417: purse
+  n04033901: quill
+  n04033995: quilt
+  n04037443: racer
+  n04039381: racket
+  n04040759: radiator
+  n04041544: radio
+  n04044716: radio_telescope
+  n04049303: rain_barrel
+  n04065272: recreational_vehicle
+  n04067472: reel
+  n04069434: reflex_camera
+  n04070727: refrigerator
+  n04074963: remote_control
+  n04081281: restaurant
+  n04086273: revolver
+  n04090263: rifle
+  n04099969: rocking_chair
+  n04111531: rotisserie
+  n04116512: rubber_eraser
+  n04118538: rugby_ball
+  n04118776: rule
+  n04120489: running_shoe
+  n04125021: safe
+  n04127249: safety_pin
+  n04131690: saltshaker
+  n04133789: sandal
+  n04136333: sarong
+  n04141076: sax
+  n04141327: scabbard
+  n04141975: scale
+  n04146614: school_bus
+  n04147183: schooner
+  n04149813: scoreboard
+  n04152593: screen
+  n04153751: screw
+  n04154565: screwdriver
+  n04162706: seat_belt
+  n04179913: sewing_machine
+  n04192698: shield
+  n04200800: shoe_shop
+  n04201297: shoji
+  n04204238: shopping_basket
+  n04204347: shopping_cart
+  n04208210: shovel
+  n04209133: shower_cap
+  n04209239: shower_curtain
+  n04228054: ski
+  n04229816: ski_mask
+  n04235860: sleeping_bag
+  n04238763: slide_rule
+  n04239074: sliding_door
+  n04243546: slot
+  n04251144: snorkel
+  n04252077: snowmobile
+  n04252225: snowplow
+  n04254120: soap_dispenser
+  n04254680: soccer_ball
+  n04254777: sock
+  n04258138: solar_dish
+  n04259630: sombrero
+  n04263257: soup_bowl
+  n04264628: space_bar
+  n04265275: space_heater
+  n04266014: space_shuttle
+  n04270147: spatula
+  n04273569: speedboat
+  n04275548: spider_web
+  n04277352: spindle
+  n04285008: sports_car
+  n04286575: spotlight
+  n04296562: stage
+  n04310018: steam_locomotive
+  n04311004: steel_arch_bridge
+  n04311174: steel_drum
+  n04317175: stethoscope
+  n04325704: stole
+  n04326547: stone_wall
+  n04328186: stopwatch
+  n04330267: stove
+  n04332243: strainer
+  n04335435: streetcar
+  n04336792: stretcher
+  n04344873: studio_couch
+  n04346328: stupa
+  n04347754: submarine
+  n04350905: suit
+  n04355338: sundial
+  n04355933: sunglass
+  n04356056: sunglasses
+  n04357314: sunscreen
+  n04366367: suspension_bridge
+  n04367480: swab
+  n04370456: sweatshirt
+  n04371430: swimming_trunks
+  n04371774: swing
+  n04372370: switch
+  n04376876: syringe
+  n04380533: table_lamp
+  n04389033: tank
+  n04392985: tape_player
+  n04398044: teapot
+  n04399382: teddy
+  n04404412: television
+  n04409515: tennis_ball
+  n04417672: thatch
+  n04418357: theater_curtain
+  n04423845: thimble
+  n04428191: thresher
+  n04429376: throne
+  n04435653: tile_roof
+  n04442312: toaster
+  n04443257: tobacco_shop
+  n04447861: toilet_seat
+  n04456115: torch
+  n04458633: totem_pole
+  n04461696: tow_truck
+  n04462240: toyshop
+  n04465501: tractor
+  n04467665: trailer_truck
+  n04476259: tray
+  n04479046: trench_coat
+  n04482393: tricycle
+  n04483307: trimaran
+  n04485082: tripod
+  n04486054: triumphal_arch
+  n04487081: trolleybus
+  n04487394: trombone
+  n04493381: tub
+  n04501370: turnstile
+  n04505470: typewriter_keyboard
+  n04507155: umbrella
+  n04509417: unicycle
+  n04515003: upright
+  n04517823: vacuum
+  n04522168: vase
+  n04523525: vault
+  n04525038: velvet
+  n04525305: vending_machine
+  n04532106: vestment
+  n04532670: viaduct
+  n04536866: violin
+  n04540053: volleyball
+  n04542943: waffle_iron
+  n04548280: wall_clock
+  n04548362: wallet
+  n04550184: wardrobe
+  n04552348: warplane
+  n04553703: washbasin
+  n04554684: washer
+  n04557648: water_bottle
+  n04560804: water_jug
+  n04562935: water_tower
+  n04579145: whiskey_jug
+  n04579432: whistle
+  n04584207: wig
+  n04589890: window_screen
+  n04590129: window_shade
+  n04591157: Windsor_tie
+  n04591713: wine_bottle
+  n04592741: wing
+  n04596742: wok
+  n04597913: wooden_spoon
+  n04599235: wool
+  n04604644: worm_fence
+  n04606251: wreck
+  n04612504: yawl
+  n04613696: yurt
+  n06359193: web_site
+  n06596364: comic_book
+  n06785654: crossword_puzzle
+  n06794110: street_sign
+  n06874185: traffic_light
+  n07248320: book_jacket
+  n07565083: menu
+  n07579787: plate
+  n07583066: guacamole
+  n07584110: consomme
+  n07590611: hot_pot
+  n07613480: trifle
+  n07614500: ice_cream
+  n07615774: ice_lolly
+  n07684084: French_loaf
+  n07693725: bagel
+  n07695742: pretzel
+  n07697313: cheeseburger
+  n07697537: hotdog
+  n07711569: mashed_potato
+  n07714571: head_cabbage
+  n07714990: broccoli
+  n07715103: cauliflower
+  n07716358: zucchini
+  n07716906: spaghetti_squash
+  n07717410: acorn_squash
+  n07717556: butternut_squash
+  n07718472: cucumber
+  n07718747: artichoke
+  n07720875: bell_pepper
+  n07730033: cardoon
+  n07734744: mushroom
+  n07742313: Granny_Smith
+  n07745940: strawberry
+  n07747607: orange
+  n07749582: lemon
+  n07753113: fig
+  n07753275: pineapple
+  n07753592: banana
+  n07754684: jackfruit
+  n07760859: custard_apple
+  n07768694: pomegranate
+  n07802026: hay
+  n07831146: carbonara
+  n07836838: chocolate_sauce
+  n07860988: dough
+  n07871810: meat_loaf
+  n07873807: pizza
+  n07875152: potpie
+  n07880968: burrito
+  n07892512: red_wine
+  n07920052: espresso
+  n07930864: cup
+  n07932039: eggnog
+  n09193705: alp
+  n09229709: bubble
+  n09246464: cliff
+  n09256479: coral_reef
+  n09288635: geyser
+  n09332890: lakeside
+  n09399592: promontory
+  n09421951: sandbar
+  n09428293: seashore
+  n09468604: valley
+  n09472597: volcano
+  n09835506: ballplayer
+  n10148035: groom
+  n10565667: scuba_diver
+  n11879895: rapeseed
+  n11939491: daisy
+  n12057211: yellow_lady's_slipper
+  n12144580: corn
+  n12267677: acorn
+  n12620546: hip
+  n12768682: buckeye
+  n12985857: coral_fungus
+  n12998815: agaric
+  n13037406: gyromitra
+  n13040303: stinkhorn
+  n13044778: earthstar
+  n13052670: hen-of-the-woods
+  n13054560: bolete
+  n13133613: ear
+  n15075141: toilet_tissue
+
+# Download script/URL (optional)
+download: ultralytics/data/scripts/get_imagenet.sh

ultralytics/cfg/datasets/Objects365.yaml

@@ -0,0 +1,443 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Objects365 dataset https://www.objects365.org/ by Megvii
+# Documentation: https://docs.ultralytics.com/datasets/detect/objects365/
+# Example usage: yolo train data=Objects365.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── Objects365  ← downloads here (712 GB = 367G data + 345G zips)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/Objects365 # dataset root dir
+train: images/train # train images (relative to 'path') 1742289 images
+val: images/val # val images (relative to 'path') 80000 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: Person
+  1: Sneakers
+  2: Chair
+  3: Other Shoes
+  4: Hat
+  5: Car
+  6: Lamp
+  7: Glasses
+  8: Bottle
+  9: Desk
+  10: Cup
+  11: Street Lights
+  12: Cabinet/shelf
+  13: Handbag/Satchel
+  14: Bracelet
+  15: Plate
+  16: Picture/Frame
+  17: Helmet
+  18: Book
+  19: Gloves
+  20: Storage box
+  21: Boat
+  22: Leather Shoes
+  23: Flower
+  24: Bench
+  25: Potted Plant
+  26: Bowl/Basin
+  27: Flag
+  28: Pillow
+  29: Boots
+  30: Vase
+  31: Microphone
+  32: Necklace
+  33: Ring
+  34: SUV
+  35: Wine Glass
+  36: Belt
+  37: Monitor/TV
+  38: Backpack
+  39: Umbrella
+  40: Traffic Light
+  41: Speaker
+  42: Watch
+  43: Tie
+  44: Trash bin Can
+  45: Slippers
+  46: Bicycle
+  47: Stool
+  48: Barrel/bucket
+  49: Van
+  50: Couch
+  51: Sandals
+  52: Basket
+  53: Drum
+  54: Pen/Pencil
+  55: Bus
+  56: Wild Bird
+  57: High Heels
+  58: Motorcycle
+  59: Guitar
+  60: Carpet
+  61: Cell Phone
+  62: Bread
+  63: Camera
+  64: Canned
+  65: Truck
+  66: Traffic cone
+  67: Cymbal
+  68: Lifesaver
+  69: Towel
+  70: Stuffed Toy
+  71: Candle
+  72: Sailboat
+  73: Laptop
+  74: Awning
+  75: Bed
+  76: Faucet
+  77: Tent
+  78: Horse
+  79: Mirror
+  80: Power outlet
+  81: Sink
+  82: Apple
+  83: Air Conditioner
+  84: Knife
+  85: Hockey Stick
+  86: Paddle
+  87: Pickup Truck
+  88: Fork
+  89: Traffic Sign
+  90: Balloon
+  91: Tripod
+  92: Dog
+  93: Spoon
+  94: Clock
+  95: Pot
+  96: Cow
+  97: Cake
+  98: Dining Table
+  99: Sheep
+  100: Hanger
+  101: Blackboard/Whiteboard
+  102: Napkin
+  103: Other Fish
+  104: Orange/Tangerine
+  105: Toiletry
+  106: Keyboard
+  107: Tomato
+  108: Lantern
+  109: Machinery Vehicle
+  110: Fan
+  111: Green Vegetables
+  112: Banana
+  113: Baseball Glove
+  114: Airplane
+  115: Mouse
+  116: Train
+  117: Pumpkin
+  118: Soccer
+  119: Skiboard
+  120: Luggage
+  121: Nightstand
+  122: Tea pot
+  123: Telephone
+  124: Trolley
+  125: Head Phone
+  126: Sports Car
+  127: Stop Sign
+  128: Dessert
+  129: Scooter
+  130: Stroller
+  131: Crane
+  132: Remote
+  133: Refrigerator
+  134: Oven
+  135: Lemon
+  136: Duck
+  137: Baseball Bat
+  138: Surveillance Camera
+  139: Cat
+  140: Jug
+  141: Broccoli
+  142: Piano
+  143: Pizza
+  144: Elephant
+  145: Skateboard
+  146: Surfboard
+  147: Gun
+  148: Skating and Skiing shoes
+  149: Gas stove
+  150: Donut
+  151: Bow Tie
+  152: Carrot
+  153: Toilet
+  154: Kite
+  155: Strawberry
+  156: Other Balls
+  157: Shovel
+  158: Pepper
+  159: Computer Box
+  160: Toilet Paper
+  161: Cleaning Products
+  162: Chopsticks
+  163: Microwave
+  164: Pigeon
+  165: Baseball
+  166: Cutting/chopping Board
+  167: Coffee Table
+  168: Side Table
+  169: Scissors
+  170: Marker
+  171: Pie
+  172: Ladder
+  173: Snowboard
+  174: Cookies
+  175: Radiator
+  176: Fire Hydrant
+  177: Basketball
+  178: Zebra
+  179: Grape
+  180: Giraffe
+  181: Potato
+  182: Sausage
+  183: Tricycle
+  184: Violin
+  185: Egg
+  186: Fire Extinguisher
+  187: Candy
+  188: Fire Truck
+  189: Billiards
+  190: Converter
+  191: Bathtub
+  192: Wheelchair
+  193: Golf Club
+  194: Briefcase
+  195: Cucumber
+  196: Cigar/Cigarette
+  197: Paint Brush
+  198: Pear
+  199: Heavy Truck
+  200: Hamburger
+  201: Extractor
+  202: Extension Cord
+  203: Tong
+  204: Tennis Racket
+  205: Folder
+  206: American Football
+  207: earphone
+  208: Mask
+  209: Kettle
+  210: Tennis
+  211: Ship
+  212: Swing
+  213: Coffee Machine
+  214: Slide
+  215: Carriage
+  216: Onion
+  217: Green beans
+  218: Projector
+  219: Frisbee
+  220: Washing Machine/Drying Machine
+  221: Chicken
+  222: Printer
+  223: Watermelon
+  224: Saxophone
+  225: Tissue
+  226: Toothbrush
+  227: Ice cream
+  228: Hot-air balloon
+  229: Cello
+  230: French Fries
+  231: Scale
+  232: Trophy
+  233: Cabbage
+  234: Hot dog
+  235: Blender
+  236: Peach
+  237: Rice
+  238: Wallet/Purse
+  239: Volleyball
+  240: Deer
+  241: Goose
+  242: Tape
+  243: Tablet
+  244: Cosmetics
+  245: Trumpet
+  246: Pineapple
+  247: Golf Ball
+  248: Ambulance
+  249: Parking meter
+  250: Mango
+  251: Key
+  252: Hurdle
+  253: Fishing Rod
+  254: Medal
+  255: Flute
+  256: Brush
+  257: Penguin
+  258: Megaphone
+  259: Corn
+  260: Lettuce
+  261: Garlic
+  262: Swan
+  263: Helicopter
+  264: Green Onion
+  265: Sandwich
+  266: Nuts
+  267: Speed Limit Sign
+  268: Induction Cooker
+  269: Broom
+  270: Trombone
+  271: Plum
+  272: Rickshaw
+  273: Goldfish
+  274: Kiwi fruit
+  275: Router/modem
+  276: Poker Card
+  277: Toaster
+  278: Shrimp
+  279: Sushi
+  280: Cheese
+  281: Notepaper
+  282: Cherry
+  283: Pliers
+  284: CD
+  285: Pasta
+  286: Hammer
+  287: Cue
+  288: Avocado
+  289: Hami melon
+  290: Flask
+  291: Mushroom
+  292: Screwdriver
+  293: Soap
+  294: Recorder
+  295: Bear
+  296: Eggplant
+  297: Board Eraser
+  298: Coconut
+  299: Tape Measure/Ruler
+  300: Pig
+  301: Showerhead
+  302: Globe
+  303: Chips
+  304: Steak
+  305: Crosswalk Sign
+  306: Stapler
+  307: Camel
+  308: Formula 1
+  309: Pomegranate
+  310: Dishwasher
+  311: Crab
+  312: Hoverboard
+  313: Meatball
+  314: Rice Cooker
+  315: Tuba
+  316: Calculator
+  317: Papaya
+  318: Antelope
+  319: Parrot
+  320: Seal
+  321: Butterfly
+  322: Dumbbell
+  323: Donkey
+  324: Lion
+  325: Urinal
+  326: Dolphin
+  327: Electric Drill
+  328: Hair Dryer
+  329: Egg tart
+  330: Jellyfish
+  331: Treadmill
+  332: Lighter
+  333: Grapefruit
+  334: Game board
+  335: Mop
+  336: Radish
+  337: Baozi
+  338: Target
+  339: French
+  340: Spring Rolls
+  341: Monkey
+  342: Rabbit
+  343: Pencil Case
+  344: Yak
+  345: Red Cabbage
+  346: Binoculars
+  347: Asparagus
+  348: Barbell
+  349: Scallop
+  350: Noddles
+  351: Comb
+  352: Dumpling
+  353: Oyster
+  354: Table Tennis paddle
+  355: Cosmetics Brush/Eyeliner Pencil
+  356: Chainsaw
+  357: Eraser
+  358: Lobster
+  359: Durian
+  360: Okra
+  361: Lipstick
+  362: Cosmetics Mirror
+  363: Curling
+  364: Table Tennis
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  from pathlib import Path
+
+  import numpy as np
+  from tqdm import tqdm
+
+  from ultralytics.utils.checks import check_requirements
+  from ultralytics.utils.downloads import download
+  from ultralytics.utils.ops import xyxy2xywhn
+
+  check_requirements(("pycocotools>=2.0",))
+  from pycocotools.coco import COCO
+
+  # Make Directories
+  dir = Path(yaml["path"])  # dataset root dir
+  for p in "images", "labels":
+      (dir / p).mkdir(parents=True, exist_ok=True)
+      for q in "train", "val":
+          (dir / p / q).mkdir(parents=True, exist_ok=True)
+
+  # Train, Val Splits
+  for split, patches in [("train", 50 + 1), ("val", 43 + 1)]:
+      print(f"Processing {split} in {patches} patches ...")
+      images, labels = dir / "images" / split, dir / "labels" / split
+
+      # Download
+      url = f"https://dorc.ks3-cn-beijing.ksyun.com/data-set/2020Objects365%E6%95%B0%E6%8D%AE%E9%9B%86/{split}/"
+      if split == "train":
+          download([f"{url}zhiyuan_objv2_{split}.tar.gz"], dir=dir)  # annotations json
+          download([f"{url}patch{i}.tar.gz" for i in range(patches)], dir=images, curl=True, threads=8)
+      elif split == "val":
+          download([f"{url}zhiyuan_objv2_{split}.json"], dir=dir)  # annotations json
+          download([f"{url}images/v1/patch{i}.tar.gz" for i in range(15 + 1)], dir=images, curl=True, threads=8)
+          download([f"{url}images/v2/patch{i}.tar.gz" for i in range(16, patches)], dir=images, curl=True, threads=8)
+
+      # Move
+      for f in tqdm(images.rglob("*.jpg"), desc=f"Moving {split} images"):
+          f.rename(images / f.name)  # move to /images/{split}
+
+      # Labels
+      coco = COCO(dir / f"zhiyuan_objv2_{split}.json")
+      names = [x["name"] for x in coco.loadCats(coco.getCatIds())]
+      for cid, cat in enumerate(names):
+          catIds = coco.getCatIds(catNms=[cat])
+          imgIds = coco.getImgIds(catIds=catIds)
+          for im in tqdm(coco.loadImgs(imgIds), desc=f"Class {cid + 1}/{len(names)} {cat}"):
+              width, height = im["width"], im["height"]
+              path = Path(im["file_name"])  # image filename
+              try:
+                  with open(labels / path.with_suffix(".txt").name, "a", encoding="utf-8") as file:
+                      annIds = coco.getAnnIds(imgIds=im["id"], catIds=catIds, iscrowd=None)
+                      for a in coco.loadAnns(annIds):
+                          x, y, w, h = a["bbox"]  # bounding box in xywh (xy top-left corner)
+                          xyxy = np.array([x, y, x + w, y + h])[None]  # pixels(1,4)
+                          x, y, w, h = xyxy2xywhn(xyxy, w=width, h=height, clip=True)[0]  # normalized and clipped
+                          file.write(f"{cid} {x:.5f} {y:.5f} {w:.5f} {h:.5f}\n")
+              except Exception as e:
+                  print(e)

ultralytics/cfg/datasets/SKU-110K.yaml

@@ -0,0 +1,58 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# SKU-110K retail items dataset https://github.com/eg4000/SKU110K_CVPR19 by Trax Retail
+# Documentation: https://docs.ultralytics.com/datasets/detect/sku-110k/
+# Example usage: yolo train data=SKU-110K.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── SKU-110K  ← downloads here (13.6 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/SKU-110K # dataset root dir
+train: train.txt # train images (relative to 'path')  8219 images
+val: val.txt # val images (relative to 'path')  588 images
+test: test.txt # test images (optional)  2936 images
+
+# Classes
+names:
+  0: object
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import shutil
+  from pathlib import Path
+
+  import numpy as np
+  import pandas as pd
+  from tqdm import tqdm
+
+  from ultralytics.utils.downloads import download
+  from ultralytics.utils.ops import xyxy2xywh
+
+  # Download
+  dir = Path(yaml["path"])  # dataset root dir
+  parent = Path(dir.parent)  # download dir
+  urls = ["http://trax-geometry.s3.amazonaws.com/cvpr_challenge/SKU110K_fixed.tar.gz"]
+  download(urls, dir=parent)
+
+  # Rename directories
+  if dir.exists():
+      shutil.rmtree(dir)
+  (parent / "SKU110K_fixed").rename(dir)  # rename dir
+  (dir / "labels").mkdir(parents=True, exist_ok=True)  # create labels dir
+
+  # Convert labels
+  names = "image", "x1", "y1", "x2", "y2", "class", "image_width", "image_height"  # column names
+  for d in "annotations_train.csv", "annotations_val.csv", "annotations_test.csv":
+      x = pd.read_csv(dir / "annotations" / d, names=names).values  # annotations
+      images, unique_images = x[:, 0], np.unique(x[:, 0])
+      with open((dir / d).with_suffix(".txt").__str__().replace("annotations_", ""), "w", encoding="utf-8") as f:
+          f.writelines(f"./images/{s}\n" for s in unique_images)
+      for im in tqdm(unique_images, desc=f"Converting {dir / d}"):
+          cls = 0  # single-class dataset
+          with open((dir / "labels" / im).with_suffix(".txt"), "a", encoding="utf-8") as f:
+              for r in x[images == im]:
+                  w, h = r[6], r[7]  # image width, height
+                  xywh = xyxy2xywh(np.array([[r[1] / w, r[2] / h, r[3] / w, r[4] / h]]))[0]  # instance
+                  f.write(f"{cls} {xywh[0]:.5f} {xywh[1]:.5f} {xywh[2]:.5f} {xywh[3]:.5f}\n")  # write label

ultralytics/cfg/datasets/VOC.yaml

@@ -0,0 +1,106 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# PASCAL VOC dataset http://host.robots.ox.ac.uk/pascal/VOC by University of Oxford
+# Documentation: # Documentation: https://docs.ultralytics.com/datasets/detect/voc/
+# Example usage: yolo train data=VOC.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── VOC  ← downloads here (2.8 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/VOC
+train: # train images (relative to 'path')  16551 images
+  - images/train2012
+  - images/train2007
+  - images/val2012
+  - images/val2007
+val: # val images (relative to 'path')  4952 images
+  - images/test2007
+test: # test images (optional)
+  - images/test2007
+
+# Classes
+names:
+  0: aeroplane
+  1: bicycle
+  2: bird
+  3: boat
+  4: bottle
+  5: bus
+  6: car
+  7: cat
+  8: chair
+  9: cow
+  10: diningtable
+  11: dog
+  12: horse
+  13: motorbike
+  14: person
+  15: pottedplant
+  16: sheep
+  17: sofa
+  18: train
+  19: tvmonitor
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import xml.etree.ElementTree as ET
+  from pathlib import Path
+
+  from tqdm import tqdm
+
+  from ultralytics.utils.downloads import download
+
+
+  def convert_label(path, lb_path, year, image_id):
+      """Converts XML annotations from VOC format to YOLO format by extracting bounding boxes and class IDs."""
+
+      def convert_box(size, box):
+          dw, dh = 1.0 / size[0], 1.0 / size[1]
+          x, y, w, h = (box[0] + box[1]) / 2.0 - 1, (box[2] + box[3]) / 2.0 - 1, box[1] - box[0], box[3] - box[2]
+          return x * dw, y * dh, w * dw, h * dh
+
+      in_file = open(path / f"VOC{year}/Annotations/{image_id}.xml")
+      out_file = open(lb_path, "w")
+      tree = ET.parse(in_file)
+      root = tree.getroot()
+      size = root.find("size")
+      w = int(size.find("width").text)
+      h = int(size.find("height").text)
+
+      names = list(yaml["names"].values())  # names list
+      for obj in root.iter("object"):
+          cls = obj.find("name").text
+          if cls in names and int(obj.find("difficult").text) != 1:
+              xmlbox = obj.find("bndbox")
+              bb = convert_box((w, h), [float(xmlbox.find(x).text) for x in ("xmin", "xmax", "ymin", "ymax")])
+              cls_id = names.index(cls)  # class id
+              out_file.write(" ".join(str(a) for a in (cls_id, *bb)) + "\n")
+
+
+  # Download
+  dir = Path(yaml["path"])  # dataset root dir
+  url = "https://github.com/ultralytics/assets/releases/download/v0.0.0/"
+  urls = [
+      f"{url}VOCtrainval_06-Nov-2007.zip",  # 446MB, 5012 images
+      f"{url}VOCtest_06-Nov-2007.zip",  # 438MB, 4953 images
+      f"{url}VOCtrainval_11-May-2012.zip",  # 1.95GB, 17126 images
+  ]
+  download(urls, dir=dir / "images", curl=True, threads=3, exist_ok=True)  # download and unzip over existing (required)
+
+  # Convert
+  path = dir / "images/VOCdevkit"
+  for year, image_set in ("2012", "train"), ("2012", "val"), ("2007", "train"), ("2007", "val"), ("2007", "test"):
+      imgs_path = dir / "images" / f"{image_set}{year}"
+      lbs_path = dir / "labels" / f"{image_set}{year}"
+      imgs_path.mkdir(exist_ok=True, parents=True)
+      lbs_path.mkdir(exist_ok=True, parents=True)
+
+      with open(path / f"VOC{year}/ImageSets/Main/{image_set}.txt") as f:
+          image_ids = f.read().strip().split()
+      for id in tqdm(image_ids, desc=f"{image_set}{year}"):
+          f = path / f"VOC{year}/JPEGImages/{id}.jpg"  # old img path
+          lb_path = (lbs_path / f.name).with_suffix(".txt")  # new label path
+          f.rename(imgs_path / f.name)  # move image
+          convert_label(path, lb_path, year, id)  # convert labels to YOLO format

ultralytics/cfg/datasets/VisDrone.yaml

@@ -0,0 +1,77 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# VisDrone2019-DET dataset https://github.com/VisDrone/VisDrone-Dataset by Tianjin University
+# Documentation: https://docs.ultralytics.com/datasets/detect/visdrone/
+# Example usage: yolo train data=VisDrone.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── VisDrone  ← downloads here (2.3 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/VisDrone # dataset root dir
+train: VisDrone2019-DET-train/images # train images (relative to 'path')  6471 images
+val: VisDrone2019-DET-val/images # val images (relative to 'path')  548 images
+test: VisDrone2019-DET-test-dev/images # test images (optional)  1610 images
+
+# Classes
+names:
+  0: pedestrian
+  1: people
+  2: bicycle
+  3: car
+  4: van
+  5: truck
+  6: tricycle
+  7: awning-tricycle
+  8: bus
+  9: motor
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import os
+  from pathlib import Path
+
+  from ultralytics.utils.downloads import download
+
+
+  def visdrone2yolo(dir):
+      """Convert VisDrone annotations to YOLO format, creating label files with normalized bounding box coordinates."""
+      from PIL import Image
+      from tqdm import tqdm
+
+      def convert_box(size, box):
+          # Convert VisDrone box to YOLO xywh box
+          dw = 1.0 / size[0]
+          dh = 1.0 / size[1]
+          return (box[0] + box[2] / 2) * dw, (box[1] + box[3] / 2) * dh, box[2] * dw, box[3] * dh
+
+      (dir / "labels").mkdir(parents=True, exist_ok=True)  # make labels directory
+      pbar = tqdm((dir / "annotations").glob("*.txt"), desc=f"Converting {dir}")
+      for f in pbar:
+          img_size = Image.open((dir / "images" / f.name).with_suffix(".jpg")).size
+          lines = []
+          with open(f, encoding="utf-8") as file:  # read annotation.txt
+              for row in [x.split(",") for x in file.read().strip().splitlines()]:
+                  if row[4] == "0":  # VisDrone 'ignored regions' class 0
+                      continue
+                  cls = int(row[5]) - 1
+                  box = convert_box(img_size, tuple(map(int, row[:4])))
+                  lines.append(f"{cls} {' '.join(f'{x:.6f}' for x in box)}\n")
+                  with open(str(f).replace(f"{os.sep}annotations{os.sep}", f"{os.sep}labels{os.sep}"), "w", encoding="utf-8") as fl:
+                      fl.writelines(lines)  # write label.txt
+
+
+  # Download
+  dir = Path(yaml["path"])  # dataset root dir
+  urls = [
+      "https://github.com/ultralytics/assets/releases/download/v0.0.0/VisDrone2019-DET-train.zip",
+      "https://github.com/ultralytics/assets/releases/download/v0.0.0/VisDrone2019-DET-val.zip",
+      "https://github.com/ultralytics/assets/releases/download/v0.0.0/VisDrone2019-DET-test-dev.zip",
+      "https://github.com/ultralytics/assets/releases/download/v0.0.0/VisDrone2019-DET-test-challenge.zip",
+  ]
+  download(urls, dir=dir, curl=True, threads=4)
+
+  # Convert
+  for d in "VisDrone2019-DET-train", "VisDrone2019-DET-val", "VisDrone2019-DET-test-dev":
+      visdrone2yolo(dir / d)  # convert VisDrone annotations to YOLO labels

ultralytics/cfg/datasets/african-wildlife.yaml

@@ -0,0 +1,25 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# African-wildlife dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/african-wildlife/
+# Example usage: yolo train data=african-wildlife.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── african-wildlife  ← downloads here (100 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/african-wildlife # dataset root dir
+train: train/images # train images (relative to 'path') 1052 images
+val: valid/images # val images (relative to 'path') 225 images
+test: test/images # test images (relative to 'path') 227 images
+
+# Classes
+names:
+  0: buffalo
+  1: elephant
+  2: rhino
+  3: zebra
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/african-wildlife.zip

ultralytics/cfg/datasets/brain-tumor.yaml

@@ -0,0 +1,23 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Brain-tumor dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/brain-tumor/
+# Example usage: yolo train data=brain-tumor.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── brain-tumor  ← downloads here (4.05 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/brain-tumor # dataset root dir
+train: train/images # train images (relative to 'path') 893 images
+val: valid/images # val images (relative to 'path') 223 images
+test: # test images (relative to 'path')
+
+# Classes
+names:
+  0: negative
+  1: positive
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/brain-tumor.zip

ultralytics/cfg/datasets/carparts-seg.yaml

@@ -0,0 +1,44 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Carparts-seg dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/carparts-seg/
+# Example usage: yolo train data=carparts-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── carparts-seg  ← downloads here (132 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/carparts-seg # dataset root dir
+train: train/images # train images (relative to 'path') 3516 images
+val: valid/images # val images (relative to 'path') 276 images
+test: test/images # test images (relative to 'path') 401 images
+
+# Classes
+names:
+  0: back_bumper
+  1: back_door
+  2: back_glass
+  3: back_left_door
+  4: back_left_light
+  5: back_light
+  6: back_right_door
+  7: back_right_light
+  8: front_bumper
+  9: front_door
+  10: front_glass
+  11: front_left_door
+  12: front_left_light
+  13: front_light
+  14: front_right_door
+  15: front_right_light
+  16: hood
+  17: left_mirror
+  18: object
+  19: right_mirror
+  20: tailgate
+  21: trunk
+  22: wheel
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/carparts-seg.zip

ultralytics/cfg/datasets/coco-pose.yaml

@@ -0,0 +1,42 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO 2017 Keypoints dataset https://cocodataset.org by Microsoft
+# Documentation: https://docs.ultralytics.com/datasets/pose/coco/
+# Example usage: yolo train data=coco-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco-pose  ← downloads here (20.1 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco-pose # dataset root dir
+train: train2017.txt # train images (relative to 'path') 56599 images
+val: val2017.txt # val images (relative to 'path') 2346 images
+test: test-dev2017.txt # 20288 of 40670 images, submit to https://codalab.lisn.upsaclay.fr/competitions/7403
+
+# Keypoints
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
+
+# Classes
+names:
+  0: person
+
+# Download script/URL (optional)
+download: |
+  from pathlib import Path
+
+  from ultralytics.utils.downloads import download
+
+  # Download labels
+  dir = Path(yaml["path"])  # dataset root dir
+  url = "https://github.com/ultralytics/assets/releases/download/v0.0.0/"
+  urls = [f"{url}coco2017labels-pose.zip"]
+  download(urls, dir=dir.parent)
+  # Download data
+  urls = [
+      "http://images.cocodataset.org/zips/train2017.zip",  # 19G, 118k images
+      "http://images.cocodataset.org/zips/val2017.zip",  # 1G, 5k images
+      "http://images.cocodataset.org/zips/test2017.zip",  # 7G, 41k images (optional)
+  ]
+  download(urls, dir=dir / "images", threads=3)

ultralytics/cfg/datasets/coco.yaml

@@ -0,0 +1,118 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO 2017 dataset https://cocodataset.org by Microsoft
+# Documentation: https://docs.ultralytics.com/datasets/detect/coco/
+# Example usage: yolo train data=coco.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco  ← downloads here (20.1 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco # dataset root dir
+train: train2017.txt # train images (relative to 'path') 118287 images
+val: val2017.txt # val images (relative to 'path') 5000 images
+test: test-dev2017.txt # 20288 of 40670 images, submit to https://competitions.codalab.org/competitions/20794
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: |
+  from pathlib import Path
+
+  from ultralytics.utils.downloads import download
+
+  # Download labels
+  segments = True  # segment or box labels
+  dir = Path(yaml["path"])  # dataset root dir
+  url = "https://github.com/ultralytics/assets/releases/download/v0.0.0/"
+  urls = [url + ("coco2017labels-segments.zip" if segments else "coco2017labels.zip")]  # labels
+  download(urls, dir=dir.parent)
+  # Download data
+  urls = [
+      "http://images.cocodataset.org/zips/train2017.zip",  # 19G, 118k images
+      "http://images.cocodataset.org/zips/val2017.zip",  # 1G, 5k images
+      "http://images.cocodataset.org/zips/test2017.zip",  # 7G, 41k images (optional)
+  ]
+  download(urls, dir=dir / "images", threads=3)

ultralytics/cfg/datasets/coco128-seg.yaml

@@ -0,0 +1,101 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO128-seg dataset https://www.kaggle.com/datasets/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/coco/
+# Example usage: yolo train data=coco128.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco128-seg  ← downloads here (7 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco128-seg # dataset root dir
+train: images/train2017 # train images (relative to 'path') 128 images
+val: images/train2017 # val images (relative to 'path') 128 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco128-seg.zip

ultralytics/cfg/datasets/coco128.yaml

@@ -0,0 +1,101 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO128 dataset https://www.kaggle.com/datasets/ultralytics/coco128 (first 128 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/coco/
+# Example usage: yolo train data=coco128.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco128  ← downloads here (7 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco128 # dataset root dir
+train: images/train2017 # train images (relative to 'path') 128 images
+val: images/train2017 # val images (relative to 'path') 128 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco128.zip

ultralytics/cfg/datasets/coco8-pose.yaml

@@ -0,0 +1,26 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO8-pose dataset (first 8 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/pose/coco8-pose/
+# Example usage: yolo train data=coco8-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco8-pose  ← downloads here (1 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco8-pose # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+test: # test images (optional)
+
+# Keypoints
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15]
+
+# Classes
+names:
+  0: person
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-pose.zip

ultralytics/cfg/datasets/coco8-seg.yaml

@@ -0,0 +1,101 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO8-seg dataset (first 8 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/coco8-seg/
+# Example usage: yolo train data=coco8-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco8-seg  ← downloads here (1 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco8-seg # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8-seg.zip

ultralytics/cfg/datasets/coco8.yaml

@@ -0,0 +1,101 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# COCO8 dataset (first 8 images from COCO train2017) by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/coco8/
+# Example usage: yolo train data=coco8.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── coco8  ← downloads here (1 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/coco8 # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: person
+  1: bicycle
+  2: car
+  3: motorcycle
+  4: airplane
+  5: bus
+  6: train
+  7: truck
+  8: boat
+  9: traffic light
+  10: fire hydrant
+  11: stop sign
+  12: parking meter
+  13: bench
+  14: bird
+  15: cat
+  16: dog
+  17: horse
+  18: sheep
+  19: cow
+  20: elephant
+  21: bear
+  22: zebra
+  23: giraffe
+  24: backpack
+  25: umbrella
+  26: handbag
+  27: tie
+  28: suitcase
+  29: frisbee
+  30: skis
+  31: snowboard
+  32: sports ball
+  33: kite
+  34: baseball bat
+  35: baseball glove
+  36: skateboard
+  37: surfboard
+  38: tennis racket
+  39: bottle
+  40: wine glass
+  41: cup
+  42: fork
+  43: knife
+  44: spoon
+  45: bowl
+  46: banana
+  47: apple
+  48: sandwich
+  49: orange
+  50: broccoli
+  51: carrot
+  52: hot dog
+  53: pizza
+  54: donut
+  55: cake
+  56: chair
+  57: couch
+  58: potted plant
+  59: bed
+  60: dining table
+  61: toilet
+  62: tv
+  63: laptop
+  64: mouse
+  65: remote
+  66: keyboard
+  67: cell phone
+  68: microwave
+  69: oven
+  70: toaster
+  71: sink
+  72: refrigerator
+  73: book
+  74: clock
+  75: vase
+  76: scissors
+  77: teddy bear
+  78: hair drier
+  79: toothbrush
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/coco8.zip

ultralytics/cfg/datasets/crack-seg.yaml

@@ -0,0 +1,22 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Crack-seg dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/crack-seg/
+# Example usage: yolo train data=crack-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── crack-seg  ← downloads here (91.2 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/crack-seg # dataset root dir
+train: train/images # train images (relative to 'path') 3717 images
+val: valid/images # val images (relative to 'path') 112 images
+test: test/images # test images (relative to 'path') 200 images
+
+# Classes
+names:
+  0: crack
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/crack-seg.zip

ultralytics/cfg/datasets/dog-pose.yaml

@@ -0,0 +1,24 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Dogs dataset http://vision.stanford.edu/aditya86/ImageNetDogs/ by Stanford
+# Documentation: https://docs.ultralytics.com/datasets/pose/dog-pose/
+# Example usage: yolo train data=dog-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── dog-pose  ← downloads here (337 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/dog-pose # dataset root dir
+train: train # train images (relative to 'path') 6773 images
+val: val # val images (relative to 'path') 1703 images
+
+# Keypoints
+kpt_shape: [24, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+
+# Classes
+names:
+  0: dog
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/dog-pose.zip

ultralytics/cfg/datasets/dota8.yaml

@@ -0,0 +1,35 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# DOTA8 dataset 8 images from split DOTAv1 dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/obb/dota8/
+# Example usage: yolo train model=yolov8n-obb.pt data=dota8.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── dota8  ← downloads here (1MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/dota8 # dataset root dir
+train: images/train # train images (relative to 'path') 4 images
+val: images/val # val images (relative to 'path') 4 images
+
+# Classes for DOTA 1.0
+names:
+  0: plane
+  1: ship
+  2: storage tank
+  3: baseball diamond
+  4: tennis court
+  5: basketball court
+  6: ground track field
+  7: harbor
+  8: bridge
+  9: large vehicle
+  10: small vehicle
+  11: helicopter
+  12: roundabout
+  13: soccer ball field
+  14: swimming pool
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/dota8.zip

ultralytics/cfg/datasets/hand-keypoints.yaml

@@ -0,0 +1,26 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Hand Keypoints dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/pose/hand-keypoints/
+# Example usage: yolo train data=hand-keypoints.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── hand-keypoints  ← downloads here (369 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/hand-keypoints # dataset root dir
+train: train # train images (relative to 'path') 18776 images
+val: val # val images (relative to 'path') 7992 images
+
+# Keypoints
+kpt_shape: [21, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx:
+  [0, 1, 2, 4, 3, 10, 11, 12, 13, 14, 5, 6, 7, 8, 9, 15, 16, 17, 18, 19, 20]
+
+# Classes
+names:
+  0: hand
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/hand-keypoints.zip

ultralytics/cfg/datasets/lvis.yaml

@@ -0,0 +1,1240 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# LVIS dataset http://www.lvisdataset.org by Facebook AI Research.
+# Documentation: https://docs.ultralytics.com/datasets/detect/lvis/
+# Example usage: yolo train data=lvis.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── lvis  ← downloads here (20.1 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/lvis # dataset root dir
+train: train.txt # train images (relative to 'path') 100170 images
+val: val.txt # val images (relative to 'path') 19809 images
+minival: minival.txt # minival images (relative to 'path') 5000 images
+
+names:
+  0: aerosol can/spray can
+  1: air conditioner
+  2: airplane/aeroplane
+  3: alarm clock
+  4: alcohol/alcoholic beverage
+  5: alligator/gator
+  6: almond
+  7: ambulance
+  8: amplifier
+  9: anklet/ankle bracelet
+  10: antenna/aerial/transmitting aerial
+  11: apple
+  12: applesauce
+  13: apricot
+  14: apron
+  15: aquarium/fish tank
+  16: arctic/arctic type of shoe/galosh/golosh/rubber/rubber type of shoe/gumshoe
+  17: armband
+  18: armchair
+  19: armoire
+  20: armor/armour
+  21: artichoke
+  22: trash can/garbage can/wastebin/dustbin/trash barrel/trash bin
+  23: ashtray
+  24: asparagus
+  25: atomizer/atomiser/spray/sprayer/nebulizer/nebuliser
+  26: avocado
+  27: award/accolade
+  28: awning
+  29: ax/axe
+  30: baboon
+  31: baby buggy/baby carriage/perambulator/pram/stroller
+  32: basketball backboard
+  33: backpack/knapsack/packsack/rucksack/haversack
+  34: handbag/purse/pocketbook
+  35: suitcase/baggage/luggage
+  36: bagel/beigel
+  37: bagpipe
+  38: baguet/baguette
+  39: bait/lure
+  40: ball
+  41: ballet skirt/tutu
+  42: balloon
+  43: bamboo
+  44: banana
+  45: Band Aid
+  46: bandage
+  47: bandanna/bandana
+  48: banjo
+  49: banner/streamer
+  50: barbell
+  51: barge
+  52: barrel/cask
+  53: barrette
+  54: barrow/garden cart/lawn cart/wheelbarrow
+  55: baseball base
+  56: baseball
+  57: baseball bat
+  58: baseball cap/jockey cap/golf cap
+  59: baseball glove/baseball mitt
+  60: basket/handbasket
+  61: basketball
+  62: bass horn/sousaphone/tuba
+  63: bat/bat animal
+  64: bath mat
+  65: bath towel
+  66: bathrobe
+  67: bathtub/bathing tub
+  68: batter/batter food
+  69: battery
+  70: beachball
+  71: bead
+  72: bean curd/tofu
+  73: beanbag
+  74: beanie/beany
+  75: bear
+  76: bed
+  77: bedpan
+  78: bedspread/bedcover/bed covering/counterpane/spread
+  79: cow
+  80: beef/beef food/boeuf/boeuf food
+  81: beeper/pager
+  82: beer bottle
+  83: beer can
+  84: beetle
+  85: bell
+  86: bell pepper/capsicum
+  87: belt
+  88: belt buckle
+  89: bench
+  90: beret
+  91: bib
+  92: Bible
+  93: bicycle/bike/bike bicycle
+  94: visor/vizor
+  95: billboard
+  96: binder/ring-binder
+  97: binoculars/field glasses/opera glasses
+  98: bird
+  99: birdfeeder
+  100: birdbath
+  101: birdcage
+  102: birdhouse
+  103: birthday cake
+  104: birthday card
+  105: pirate flag
+  106: black sheep
+  107: blackberry
+  108: blackboard/chalkboard
+  109: blanket
+  110: blazer/sport jacket/sport coat/sports jacket/sports coat
+  111: blender/liquidizer/liquidiser
+  112: blimp
+  113: blinker/flasher
+  114: blouse
+  115: blueberry
+  116: gameboard
+  117: boat/ship/ship boat
+  118: bob/bobber/bobfloat
+  119: bobbin/spool/reel
+  120: bobby pin/hairgrip
+  121: boiled egg/coddled egg
+  122: bolo tie/bolo/bola tie/bola
+  123: deadbolt
+  124: bolt
+  125: bonnet
+  126: book
+  127: bookcase
+  128: booklet/brochure/leaflet/pamphlet
+  129: bookmark/bookmarker
+  130: boom microphone/microphone boom
+  131: boot
+  132: bottle
+  133: bottle opener
+  134: bouquet
+  135: bow/bow weapon
+  136: bow/bow decorative ribbons
+  137: bow-tie/bowtie
+  138: bowl
+  139: pipe bowl
+  140: bowler hat/bowler/derby hat/derby/plug hat
+  141: bowling ball
+  142: box
+  143: boxing glove
+  144: suspenders
+  145: bracelet/bangle
+  146: brass plaque
+  147: brassiere/bra/bandeau
+  148: bread-bin/breadbox
+  149: bread
+  150: breechcloth/breechclout/loincloth
+  151: bridal gown/wedding gown/wedding dress
+  152: briefcase
+  153: broccoli
+  154: broach
+  155: broom
+  156: brownie
+  157: brussels sprouts
+  158: bubble gum
+  159: bucket/pail
+  160: horse buggy
+  161: horned cow
+  162: bulldog
+  163: bulldozer/dozer
+  164: bullet train
+  165: bulletin board/notice board
+  166: bulletproof vest
+  167: bullhorn/megaphone
+  168: bun/roll
+  169: bunk bed
+  170: buoy
+  171: burrito
+  172: bus/bus vehicle/autobus/charabanc/double-decker/motorbus/motorcoach
+  173: business card
+  174: butter
+  175: butterfly
+  176: button
+  177: cab/cab taxi/taxi/taxicab
+  178: cabana
+  179: cabin car/caboose
+  180: cabinet
+  181: locker/storage locker
+  182: cake
+  183: calculator
+  184: calendar
+  185: calf
+  186: camcorder
+  187: camel
+  188: camera
+  189: camera lens
+  190: camper/camper vehicle/camping bus/motor home
+  191: can/tin can
+  192: can opener/tin opener
+  193: candle/candlestick
+  194: candle holder
+  195: candy bar
+  196: candy cane
+  197: walking cane
+  198: canister/canister
+  199: canoe
+  200: cantaloup/cantaloupe
+  201: canteen
+  202: cap/cap headwear
+  203: bottle cap/cap/cap container lid
+  204: cape
+  205: cappuccino/coffee cappuccino
+  206: car/car automobile/auto/auto automobile/automobile
+  207: railcar/railcar part of a train/railway car/railway car part of a train/railroad car/railroad car part of a train
+  208: elevator car
+  209: car battery/automobile battery
+  210: identity card
+  211: card
+  212: cardigan
+  213: cargo ship/cargo vessel
+  214: carnation
+  215: horse carriage
+  216: carrot
+  217: tote bag
+  218: cart
+  219: carton
+  220: cash register/register/register for cash transactions
+  221: casserole
+  222: cassette
+  223: cast/plaster cast/plaster bandage
+  224: cat
+  225: cauliflower
+  226: cayenne/cayenne spice/cayenne pepper/cayenne pepper spice/red pepper/red pepper spice
+  227: CD player
+  228: celery
+  229: cellular telephone/cellular phone/cellphone/mobile phone/smart phone
+  230: chain mail/ring mail/chain armor/chain armour/ring armor/ring armour
+  231: chair
+  232: chaise longue/chaise/daybed
+  233: chalice
+  234: chandelier
+  235: chap
+  236: checkbook/chequebook
+  237: checkerboard
+  238: cherry
+  239: chessboard
+  240: chicken/chicken animal
+  241: chickpea/garbanzo
+  242: chili/chili vegetable/chili pepper/chili pepper vegetable/chilli/chilli vegetable/chilly/chilly vegetable/chile/chile vegetable
+  243: chime/gong
+  244: chinaware
+  245: crisp/crisp potato chip/potato chip
+  246: poker chip
+  247: chocolate bar
+  248: chocolate cake
+  249: chocolate milk
+  250: chocolate mousse
+  251: choker/collar/neckband
+  252: chopping board/cutting board/chopping block
+  253: chopstick
+  254: Christmas tree
+  255: slide
+  256: cider/cyder
+  257: cigar box
+  258: cigarette
+  259: cigarette case/cigarette pack
+  260: cistern/water tank
+  261: clarinet
+  262: clasp
+  263: cleansing agent/cleanser/cleaner
+  264: cleat/cleat for securing rope
+  265: clementine
+  266: clip
+  267: clipboard
+  268: clippers/clippers for plants
+  269: cloak
+  270: clock/timepiece/timekeeper
+  271: clock tower
+  272: clothes hamper/laundry basket/clothes basket
+  273: clothespin/clothes peg
+  274: clutch bag
+  275: coaster
+  276: coat
+  277: coat hanger/clothes hanger/dress hanger
+  278: coatrack/hatrack
+  279: cock/rooster
+  280: cockroach
+  281: cocoa/cocoa beverage/hot chocolate/hot chocolate beverage/drinking chocolate
+  282: coconut/cocoanut
+  283: coffee maker/coffee machine
+  284: coffee table/cocktail table
+  285: coffeepot
+  286: coil
+  287: coin
+  288: colander/cullender
+  289: coleslaw/slaw
+  290: coloring material/colouring material
+  291: combination lock
+  292: pacifier/teething ring
+  293: comic book
+  294: compass
+  295: computer keyboard/keyboard/keyboard computer
+  296: condiment
+  297: cone/traffic cone
+  298: control/controller
+  299: convertible/convertible automobile
+  300: sofa bed
+  301: cooker
+  302: cookie/cooky/biscuit/biscuit cookie
+  303: cooking utensil
+  304: cooler/cooler for food/ice chest
+  305: cork/cork bottle plug/bottle cork
+  306: corkboard
+  307: corkscrew/bottle screw
+  308: edible corn/corn/maize
+  309: cornbread
+  310: cornet/horn/trumpet
+  311: cornice/valance/valance board/pelmet
+  312: cornmeal
+  313: corset/girdle
+  314: costume
+  315: cougar/puma/catamount/mountain lion/panther
+  316: coverall
+  317: cowbell
+  318: cowboy hat/ten-gallon hat
+  319: crab/crab animal
+  320: crabmeat
+  321: cracker
+  322: crape/crepe/French pancake
+  323: crate
+  324: crayon/wax crayon
+  325: cream pitcher
+  326: crescent roll/croissant
+  327: crib/cot
+  328: crock pot/earthenware jar
+  329: crossbar
+  330: crouton
+  331: crow
+  332: crowbar/wrecking bar/pry bar
+  333: crown
+  334: crucifix
+  335: cruise ship/cruise liner
+  336: police cruiser/patrol car/police car/squad car
+  337: crumb
+  338: crutch
+  339: cub/cub animal
+  340: cube/square block
+  341: cucumber/cuke
+  342: cufflink
+  343: cup
+  344: trophy cup
+  345: cupboard/closet
+  346: cupcake
+  347: hair curler/hair roller/hair crimper
+  348: curling iron
+  349: curtain/drapery
+  350: cushion
+  351: cylinder
+  352: cymbal
+  353: dagger
+  354: dalmatian
+  355: dartboard
+  356: date/date fruit
+  357: deck chair/beach chair
+  358: deer/cervid
+  359: dental floss/floss
+  360: desk
+  361: detergent
+  362: diaper
+  363: diary/journal
+  364: die/dice
+  365: dinghy/dory/rowboat
+  366: dining table
+  367: tux/tuxedo
+  368: dish
+  369: dish antenna
+  370: dishrag/dishcloth
+  371: dishtowel/tea towel
+  372: dishwasher/dishwashing machine
+  373: dishwasher detergent/dishwashing detergent/dishwashing liquid/dishsoap
+  374: dispenser
+  375: diving board
+  376: Dixie cup/paper cup
+  377: dog
+  378: dog collar
+  379: doll
+  380: dollar/dollar bill/one dollar bill
+  381: dollhouse/doll's house
+  382: dolphin
+  383: domestic ass/donkey
+  384: doorknob/doorhandle
+  385: doormat/welcome mat
+  386: doughnut/donut
+  387: dove
+  388: dragonfly
+  389: drawer
+  390: underdrawers/boxers/boxershorts
+  391: dress/frock
+  392: dress hat/high hat/opera hat/silk hat/top hat
+  393: dress suit
+  394: dresser
+  395: drill
+  396: drone
+  397: dropper/eye dropper
+  398: drum/drum musical instrument
+  399: drumstick
+  400: duck
+  401: duckling
+  402: duct tape
+  403: duffel bag/duffle bag/duffel/duffle
+  404: dumbbell
+  405: dumpster
+  406: dustpan
+  407: eagle
+  408: earphone/earpiece/headphone
+  409: earplug
+  410: earring
+  411: easel
+  412: eclair
+  413: eel
+  414: egg/eggs
+  415: egg roll/spring roll
+  416: egg yolk/yolk/yolk egg
+  417: eggbeater/eggwhisk
+  418: eggplant/aubergine
+  419: electric chair
+  420: refrigerator
+  421: elephant
+  422: elk/moose
+  423: envelope
+  424: eraser
+  425: escargot
+  426: eyepatch
+  427: falcon
+  428: fan
+  429: faucet/spigot/tap
+  430: fedora
+  431: ferret
+  432: Ferris wheel
+  433: ferry/ferryboat
+  434: fig/fig fruit
+  435: fighter jet/fighter aircraft/attack aircraft
+  436: figurine
+  437: file cabinet/filing cabinet
+  438: file/file tool
+  439: fire alarm/smoke alarm
+  440: fire engine/fire truck
+  441: fire extinguisher/extinguisher
+  442: fire hose
+  443: fireplace
+  444: fireplug/fire hydrant/hydrant
+  445: first-aid kit
+  446: fish
+  447: fish/fish food
+  448: fishbowl/goldfish bowl
+  449: fishing rod/fishing pole
+  450: flag
+  451: flagpole/flagstaff
+  452: flamingo
+  453: flannel
+  454: flap
+  455: flash/flashbulb
+  456: flashlight/torch
+  457: fleece
+  458: flip-flop/flip-flop sandal
+  459: flipper/flipper footwear/fin/fin footwear
+  460: flower arrangement/floral arrangement
+  461: flute glass/champagne flute
+  462: foal
+  463: folding chair
+  464: food processor
+  465: football/football American
+  466: football helmet
+  467: footstool/footrest
+  468: fork
+  469: forklift
+  470: freight car
+  471: French toast
+  472: freshener/air freshener
+  473: frisbee
+  474: frog/toad/toad frog
+  475: fruit juice
+  476: frying pan/frypan/skillet
+  477: fudge
+  478: funnel
+  479: futon
+  480: gag/muzzle
+  481: garbage
+  482: garbage truck
+  483: garden hose
+  484: gargle/mouthwash
+  485: gargoyle
+  486: garlic/ail
+  487: gasmask/respirator/gas helmet
+  488: gazelle
+  489: gelatin/jelly
+  490: gemstone
+  491: generator
+  492: giant panda/panda/panda bear
+  493: gift wrap
+  494: ginger/gingerroot
+  495: giraffe
+  496: cincture/sash/waistband/waistcloth
+  497: glass/glass drink container/drinking glass
+  498: globe
+  499: glove
+  500: goat
+  501: goggles
+  502: goldfish
+  503: golf club/golf-club
+  504: golfcart
+  505: gondola/gondola boat
+  506: goose
+  507: gorilla
+  508: gourd
+  509: grape
+  510: grater
+  511: gravestone/headstone/tombstone
+  512: gravy boat/gravy holder
+  513: green bean
+  514: green onion/spring onion/scallion
+  515: griddle
+  516: grill/grille/grillwork/radiator grille
+  517: grits/hominy grits
+  518: grizzly/grizzly bear
+  519: grocery bag
+  520: guitar
+  521: gull/seagull
+  522: gun
+  523: hairbrush
+  524: hairnet
+  525: hairpin
+  526: halter top
+  527: ham/jambon/gammon
+  528: hamburger/beefburger/burger
+  529: hammer
+  530: hammock
+  531: hamper
+  532: hamster
+  533: hair dryer
+  534: hand glass/hand mirror
+  535: hand towel/face towel
+  536: handcart/pushcart/hand truck
+  537: handcuff
+  538: handkerchief
+  539: handle/grip/handgrip
+  540: handsaw/carpenter's saw
+  541: hardback book/hardcover book
+  542: harmonium/organ/organ musical instrument/reed organ/reed organ musical instrument
+  543: hat
+  544: hatbox
+  545: veil
+  546: headband
+  547: headboard
+  548: headlight/headlamp
+  549: headscarf
+  550: headset
+  551: headstall/headstall for horses/headpiece/headpiece for horses
+  552: heart
+  553: heater/warmer
+  554: helicopter
+  555: helmet
+  556: heron
+  557: highchair/feeding chair
+  558: hinge
+  559: hippopotamus
+  560: hockey stick
+  561: hog/pig
+  562: home plate/home plate baseball/home base/home base baseball
+  563: honey
+  564: fume hood/exhaust hood
+  565: hook
+  566: hookah/narghile/nargileh/sheesha/shisha/water pipe
+  567: hornet
+  568: horse
+  569: hose/hosepipe
+  570: hot-air balloon
+  571: hotplate
+  572: hot sauce
+  573: hourglass
+  574: houseboat
+  575: hummingbird
+  576: hummus/humus/hommos/hoummos/humous
+  577: polar bear
+  578: icecream
+  579: popsicle
+  580: ice maker
+  581: ice pack/ice bag
+  582: ice skate
+  583: igniter/ignitor/lighter
+  584: inhaler/inhalator
+  585: iPod
+  586: iron/iron for clothing/smoothing iron/smoothing iron for clothing
+  587: ironing board
+  588: jacket
+  589: jam
+  590: jar
+  591: jean/blue jean/denim
+  592: jeep/landrover
+  593: jelly bean/jelly egg
+  594: jersey/T-shirt/tee shirt
+  595: jet plane/jet-propelled plane
+  596: jewel/gem/precious stone
+  597: jewelry/jewellery
+  598: joystick
+  599: jumpsuit
+  600: kayak
+  601: keg
+  602: kennel/doghouse
+  603: kettle/boiler
+  604: key
+  605: keycard
+  606: kilt
+  607: kimono
+  608: kitchen sink
+  609: kitchen table
+  610: kite
+  611: kitten/kitty
+  612: kiwi fruit
+  613: knee pad
+  614: knife
+  615: knitting needle
+  616: knob
+  617: knocker/knocker on a door/doorknocker
+  618: koala/koala bear
+  619: lab coat/laboratory coat
+  620: ladder
+  621: ladle
+  622: ladybug/ladybeetle/ladybird beetle
+  623: lamb/lamb animal
+  624: lamb-chop/lambchop
+  625: lamp
+  626: lamppost
+  627: lampshade
+  628: lantern
+  629: lanyard/laniard
+  630: laptop computer/notebook computer
+  631: lasagna/lasagne
+  632: latch
+  633: lawn mower
+  634: leather
+  635: legging/legging clothing/leging/leging clothing/leg covering
+  636: Lego/Lego set
+  637: legume
+  638: lemon
+  639: lemonade
+  640: lettuce
+  641: license plate/numberplate
+  642: life buoy/lifesaver/life belt/life ring
+  643: life jacket/life vest
+  644: lightbulb
+  645: lightning rod/lightning conductor
+  646: lime
+  647: limousine
+  648: lion
+  649: lip balm
+  650: liquor/spirits/hard liquor/liqueur/cordial
+  651: lizard
+  652: log
+  653: lollipop
+  654: speaker/speaker stereo equipment
+  655: loveseat
+  656: machine gun
+  657: magazine
+  658: magnet
+  659: mail slot
+  660: mailbox/mailbox at home/letter box/letter box at home
+  661: mallard
+  662: mallet
+  663: mammoth
+  664: manatee
+  665: mandarin orange
+  666: manager/through
+  667: manhole
+  668: map
+  669: marker
+  670: martini
+  671: mascot
+  672: mashed potato
+  673: masher
+  674: mask/facemask
+  675: mast
+  676: mat/mat gym equipment/gym mat
+  677: matchbox
+  678: mattress
+  679: measuring cup
+  680: measuring stick/ruler/ruler measuring stick/measuring rod
+  681: meatball
+  682: medicine
+  683: melon
+  684: microphone
+  685: microscope
+  686: microwave oven
+  687: milestone/milepost
+  688: milk
+  689: milk can
+  690: milkshake
+  691: minivan
+  692: mint candy
+  693: mirror
+  694: mitten
+  695: mixer/mixer kitchen tool/stand mixer
+  696: money
+  697: monitor/monitor computer equipment
+  698: monkey
+  699: motor
+  700: motor scooter/scooter
+  701: motor vehicle/automotive vehicle
+  702: motorcycle
+  703: mound/mound baseball/pitcher's mound
+  704: mouse/mouse computer equipment/computer mouse
+  705: mousepad
+  706: muffin
+  707: mug
+  708: mushroom
+  709: music stool/piano stool
+  710: musical instrument/instrument/instrument musical
+  711: nailfile
+  712: napkin/table napkin/serviette
+  713: neckerchief
+  714: necklace
+  715: necktie/tie/tie necktie
+  716: needle
+  717: nest
+  718: newspaper/paper/paper newspaper
+  719: newsstand
+  720: nightshirt/nightwear/sleepwear/nightclothes
+  721: nosebag/nosebag for animals/feedbag
+  722: noseband/noseband for animals/nosepiece/nosepiece for animals
+  723: notebook
+  724: notepad
+  725: nut
+  726: nutcracker
+  727: oar
+  728: octopus/octopus food
+  729: octopus/octopus animal
+  730: oil lamp/kerosene lamp/kerosine lamp
+  731: olive oil
+  732: omelet/omelette
+  733: onion
+  734: orange/orange fruit
+  735: orange juice
+  736: ostrich
+  737: ottoman/pouf/pouffe/hassock
+  738: oven
+  739: overalls/overalls clothing
+  740: owl
+  741: packet
+  742: inkpad/inking pad/stamp pad
+  743: pad
+  744: paddle/boat paddle
+  745: padlock
+  746: paintbrush
+  747: painting
+  748: pajamas/pyjamas
+  749: palette/pallet
+  750: pan/pan for cooking/cooking pan
+  751: pan/pan metal container
+  752: pancake
+  753: pantyhose
+  754: papaya
+  755: paper plate
+  756: paper towel
+  757: paperback book/paper-back book/softback book/soft-cover book
+  758: paperweight
+  759: parachute
+  760: parakeet/parrakeet/parroket/paraquet/paroquet/parroquet
+  761: parasail/parasail sports
+  762: parasol/sunshade
+  763: parchment
+  764: parka/anorak
+  765: parking meter
+  766: parrot
+  767: passenger car/passenger car part of a train/coach/coach part of a train
+  768: passenger ship
+  769: passport
+  770: pastry
+  771: patty/patty food
+  772: pea/pea food
+  773: peach
+  774: peanut butter
+  775: pear
+  776: peeler/peeler tool for fruit and vegetables
+  777: wooden leg/pegleg
+  778: pegboard
+  779: pelican
+  780: pen
+  781: pencil
+  782: pencil box/pencil case
+  783: pencil sharpener
+  784: pendulum
+  785: penguin
+  786: pennant
+  787: penny/penny coin
+  788: pepper/peppercorn
+  789: pepper mill/pepper grinder
+  790: perfume
+  791: persimmon
+  792: person/baby/child/boy/girl/man/woman/human
+  793: pet
+  794: pew/pew church bench/church bench
+  795: phonebook/telephone book/telephone directory
+  796: phonograph record/phonograph recording/record/record phonograph recording
+  797: piano
+  798: pickle
+  799: pickup truck
+  800: pie
+  801: pigeon
+  802: piggy bank/penny bank
+  803: pillow
+  804: pin/pin non jewelry
+  805: pineapple
+  806: pinecone
+  807: ping-pong ball
+  808: pinwheel
+  809: tobacco pipe
+  810: pipe/piping
+  811: pistol/handgun
+  812: pita/pita bread/pocket bread
+  813: pitcher/pitcher vessel for liquid/ewer
+  814: pitchfork
+  815: pizza
+  816: place mat
+  817: plate
+  818: platter
+  819: playpen
+  820: pliers/plyers
+  821: plow/plow farm equipment/plough/plough farm equipment
+  822: plume
+  823: pocket watch
+  824: pocketknife
+  825: poker/poker fire stirring tool/stove poker/fire hook
+  826: pole/post
+  827: polo shirt/sport shirt
+  828: poncho
+  829: pony
+  830: pool table/billiard table/snooker table
+  831: pop/pop soda/soda/soda pop/tonic/soft drink
+  832: postbox/postbox public/mailbox/mailbox public
+  833: postcard/postal card/mailing-card
+  834: poster/placard
+  835: pot
+  836: flowerpot
+  837: potato
+  838: potholder
+  839: pottery/clayware
+  840: pouch
+  841: power shovel/excavator/digger
+  842: prawn/shrimp
+  843: pretzel
+  844: printer/printing machine
+  845: projectile/projectile weapon/missile
+  846: projector
+  847: propeller/propellor
+  848: prune
+  849: pudding
+  850: puffer/puffer fish/pufferfish/blowfish/globefish
+  851: puffin
+  852: pug-dog
+  853: pumpkin
+  854: puncher
+  855: puppet/marionette
+  856: puppy
+  857: quesadilla
+  858: quiche
+  859: quilt/comforter
+  860: rabbit
+  861: race car/racing car
+  862: racket/racquet
+  863: radar
+  864: radiator
+  865: radio receiver/radio set/radio/tuner/tuner radio
+  866: radish/daikon
+  867: raft
+  868: rag doll
+  869: raincoat/waterproof jacket
+  870: ram/ram animal
+  871: raspberry
+  872: rat
+  873: razorblade
+  874: reamer/reamer juicer/juicer/juice reamer
+  875: rearview mirror
+  876: receipt
+  877: recliner/reclining chair/lounger/lounger chair
+  878: record player/phonograph/phonograph record player/turntable
+  879: reflector
+  880: remote control
+  881: rhinoceros
+  882: rib/rib food
+  883: rifle
+  884: ring
+  885: river boat
+  886: road map
+  887: robe
+  888: rocking chair
+  889: rodent
+  890: roller skate
+  891: Rollerblade
+  892: rolling pin
+  893: root beer
+  894: router/router computer equipment
+  895: rubber band/elastic band
+  896: runner/runner carpet
+  897: plastic bag/paper bag
+  898: saddle/saddle on an animal
+  899: saddle blanket/saddlecloth/horse blanket
+  900: saddlebag
+  901: safety pin
+  902: sail
+  903: salad
+  904: salad plate/salad bowl
+  905: salami
+  906: salmon/salmon fish
+  907: salmon/salmon food
+  908: salsa
+  909: saltshaker
+  910: sandal/sandal type of shoe
+  911: sandwich
+  912: satchel
+  913: saucepan
+  914: saucer
+  915: sausage
+  916: sawhorse/sawbuck
+  917: saxophone
+  918: scale/scale measuring instrument
+  919: scarecrow/strawman
+  920: scarf
+  921: school bus
+  922: scissors
+  923: scoreboard
+  924: scraper
+  925: screwdriver
+  926: scrubbing brush
+  927: sculpture
+  928: seabird/seafowl
+  929: seahorse
+  930: seaplane/hydroplane
+  931: seashell
+  932: sewing machine
+  933: shaker
+  934: shampoo
+  935: shark
+  936: sharpener
+  937: Sharpie
+  938: shaver/shaver electric/electric shaver/electric razor
+  939: shaving cream/shaving soap
+  940: shawl
+  941: shears
+  942: sheep
+  943: shepherd dog/sheepdog
+  944: sherbert/sherbet
+  945: shield
+  946: shirt
+  947: shoe/sneaker/sneaker type of shoe/tennis shoe
+  948: shopping bag
+  949: shopping cart
+  950: short pants/shorts/shorts clothing/trunks/trunks clothing
+  951: shot glass
+  952: shoulder bag
+  953: shovel
+  954: shower head
+  955: shower cap
+  956: shower curtain
+  957: shredder/shredder for paper
+  958: signboard
+  959: silo
+  960: sink
+  961: skateboard
+  962: skewer
+  963: ski
+  964: ski boot
+  965: ski parka/ski jacket
+  966: ski pole
+  967: skirt
+  968: skullcap
+  969: sled/sledge/sleigh
+  970: sleeping bag
+  971: sling/sling bandage/triangular bandage
+  972: slipper/slipper footwear/carpet slipper/carpet slipper footwear
+  973: smoothie
+  974: snake/serpent
+  975: snowboard
+  976: snowman
+  977: snowmobile
+  978: soap
+  979: soccer ball
+  980: sock
+  981: sofa/couch/lounge
+  982: softball
+  983: solar array/solar battery/solar panel
+  984: sombrero
+  985: soup
+  986: soup bowl
+  987: soupspoon
+  988: sour cream/soured cream
+  989: soya milk/soybean milk/soymilk
+  990: space shuttle
+  991: sparkler/sparkler fireworks
+  992: spatula
+  993: spear/lance
+  994: spectacles/specs/eyeglasses/glasses
+  995: spice rack
+  996: spider
+  997: crawfish/crayfish
+  998: sponge
+  999: spoon
+  1000: sportswear/athletic wear/activewear
+  1001: spotlight
+  1002: squid/squid food/calamari/calamary
+  1003: squirrel
+  1004: stagecoach
+  1005: stapler/stapler stapling machine
+  1006: starfish/sea star
+  1007: statue/statue sculpture
+  1008: steak/steak food
+  1009: steak knife
+  1010: steering wheel
+  1011: stepladder
+  1012: step stool
+  1013: stereo/stereo sound system
+  1014: stew
+  1015: stirrer
+  1016: stirrup
+  1017: stool
+  1018: stop sign
+  1019: brake light
+  1020: stove/kitchen stove/range/range kitchen appliance/kitchen range/cooking stove
+  1021: strainer
+  1022: strap
+  1023: straw/straw for drinking/drinking straw
+  1024: strawberry
+  1025: street sign
+  1026: streetlight/street lamp
+  1027: string cheese
+  1028: stylus
+  1029: subwoofer
+  1030: sugar bowl
+  1031: sugarcane/sugarcane plant
+  1032: suit/suit clothing
+  1033: sunflower
+  1034: sunglasses
+  1035: sunhat
+  1036: surfboard
+  1037: sushi
+  1038: mop
+  1039: sweat pants
+  1040: sweatband
+  1041: sweater
+  1042: sweatshirt
+  1043: sweet potato
+  1044: swimsuit/swimwear/bathing suit/swimming costume/bathing costume/swimming trunks/bathing trunks
+  1045: sword
+  1046: syringe
+  1047: Tabasco sauce
+  1048: table-tennis table/ping-pong table
+  1049: table
+  1050: table lamp
+  1051: tablecloth
+  1052: tachometer
+  1053: taco
+  1054: tag
+  1055: taillight/rear light
+  1056: tambourine
+  1057: army tank/armored combat vehicle/armoured combat vehicle
+  1058: tank/tank storage vessel/storage tank
+  1059: tank top/tank top clothing
+  1060: tape/tape sticky cloth or paper
+  1061: tape measure/measuring tape
+  1062: tapestry
+  1063: tarp
+  1064: tartan/plaid
+  1065: tassel
+  1066: tea bag
+  1067: teacup
+  1068: teakettle
+  1069: teapot
+  1070: teddy bear
+  1071: telephone/phone/telephone set
+  1072: telephone booth/phone booth/call box/telephone box/telephone kiosk
+  1073: telephone pole/telegraph pole/telegraph post
+  1074: telephoto lens/zoom lens
+  1075: television camera/tv camera
+  1076: television set/tv/tv set
+  1077: tennis ball
+  1078: tennis racket
+  1079: tequila
+  1080: thermometer
+  1081: thermos bottle
+  1082: thermostat
+  1083: thimble
+  1084: thread/yarn
+  1085: thumbtack/drawing pin/pushpin
+  1086: tiara
+  1087: tiger
+  1088: tights/tights clothing/leotards
+  1089: timer/stopwatch
+  1090: tinfoil
+  1091: tinsel
+  1092: tissue paper
+  1093: toast/toast food
+  1094: toaster
+  1095: toaster oven
+  1096: toilet
+  1097: toilet tissue/toilet paper/bathroom tissue
+  1098: tomato
+  1099: tongs
+  1100: toolbox
+  1101: toothbrush
+  1102: toothpaste
+  1103: toothpick
+  1104: cover
+  1105: tortilla
+  1106: tow truck
+  1107: towel
+  1108: towel rack/towel rail/towel bar
+  1109: toy
+  1110: tractor/tractor farm equipment
+  1111: traffic light
+  1112: dirt bike
+  1113: trailer truck/tractor trailer/trucking rig/articulated lorry/semi truck
+  1114: train/train railroad vehicle/railroad train
+  1115: trampoline
+  1116: tray
+  1117: trench coat
+  1118: triangle/triangle musical instrument
+  1119: tricycle
+  1120: tripod
+  1121: trousers/pants/pants clothing
+  1122: truck
+  1123: truffle/truffle chocolate/chocolate truffle
+  1124: trunk
+  1125: vat
+  1126: turban
+  1127: turkey/turkey food
+  1128: turnip
+  1129: turtle
+  1130: turtleneck/turtleneck clothing/polo-neck
+  1131: typewriter
+  1132: umbrella
+  1133: underwear/underclothes/underclothing/underpants
+  1134: unicycle
+  1135: urinal
+  1136: urn
+  1137: vacuum cleaner
+  1138: vase
+  1139: vending machine
+  1140: vent/blowhole/air vent
+  1141: vest/waistcoat
+  1142: videotape
+  1143: vinegar
+  1144: violin/fiddle
+  1145: vodka
+  1146: volleyball
+  1147: vulture
+  1148: waffle
+  1149: waffle iron
+  1150: wagon
+  1151: wagon wheel
+  1152: walking stick
+  1153: wall clock
+  1154: wall socket/wall plug/electric outlet/electrical outlet/outlet/electric receptacle
+  1155: wallet/billfold
+  1156: walrus
+  1157: wardrobe
+  1158: washbasin/basin/basin for washing/washbowl/washstand/handbasin
+  1159: automatic washer/washing machine
+  1160: watch/wristwatch
+  1161: water bottle
+  1162: water cooler
+  1163: water faucet/water tap/tap/tap water faucet
+  1164: water heater/hot-water heater
+  1165: water jug
+  1166: water gun/squirt gun
+  1167: water scooter/sea scooter/jet ski
+  1168: water ski
+  1169: water tower
+  1170: watering can
+  1171: watermelon
+  1172: weathervane/vane/vane weathervane/wind vane
+  1173: webcam
+  1174: wedding cake/bridecake
+  1175: wedding ring/wedding band
+  1176: wet suit
+  1177: wheel
+  1178: wheelchair
+  1179: whipped cream
+  1180: whistle
+  1181: wig
+  1182: wind chime
+  1183: windmill
+  1184: window box/window box for plants
+  1185: windshield wiper/windscreen wiper/wiper/wiper for windshield or screen
+  1186: windsock/air sock/air-sleeve/wind sleeve/wind cone
+  1187: wine bottle
+  1188: wine bucket/wine cooler
+  1189: wineglass
+  1190: blinder/blinder for horses
+  1191: wok
+  1192: wolf
+  1193: wooden spoon
+  1194: wreath
+  1195: wrench/spanner
+  1196: wristband
+  1197: wristlet/wrist band
+  1198: yacht
+  1199: yogurt/yoghurt/yoghourt
+  1200: yoke/yoke animal equipment
+  1201: zebra
+  1202: zucchini/courgette
+
+# Download script/URL (optional)
+download: |
+  from pathlib import Path
+
+  from ultralytics.utils.downloads import download
+
+  # Download labels
+  dir = Path(yaml["path"])  # dataset root dir
+  url = "https://github.com/ultralytics/assets/releases/download/v0.0.0/"
+  urls = [f"{url}lvis-labels-segments.zip"]
+  download(urls, dir=dir.parent)
+
+  # Download data
+  urls = [
+      "http://images.cocodataset.org/zips/train2017.zip",  # 19G, 118k images
+      "http://images.cocodataset.org/zips/val2017.zip",  # 1G, 5k images
+      "http://images.cocodataset.org/zips/test2017.zip",  # 7G, 41k images (optional)
+  ]
+  download(urls, dir=dir / "images", threads=3)

ultralytics/cfg/datasets/medical-pills.yaml

@@ -0,0 +1,22 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Medical-pills dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/medical-pills/
+# Example usage: yolo train data=medical-pills.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── medical-pills  ← downloads here (8.19 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/medical-pills # dataset root dir
+train: train/images # train images (relative to 'path') 92 images
+val: valid/images # val images (relative to 'path') 23 images
+test: # test images (relative to 'path')
+
+# Classes
+names:
+  0: pill
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/medical-pills.zip

ultralytics/cfg/datasets/open-images-v7.yaml

@@ -0,0 +1,666 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Open Images v7 dataset https://storage.googleapis.com/openimages/web/index.html by Google
+# Documentation: https://docs.ultralytics.com/datasets/detect/open-images-v7/
+# Example usage: yolo train data=open-images-v7.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── open-images-v7  ← downloads here (561 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/open-images-v7 # dataset root dir
+train: images/train # train images (relative to 'path') 1743042 images
+val: images/val # val images (relative to 'path') 41620 images
+test: # test images (optional)
+
+# Classes
+names:
+  0: Accordion
+  1: Adhesive tape
+  2: Aircraft
+  3: Airplane
+  4: Alarm clock
+  5: Alpaca
+  6: Ambulance
+  7: Animal
+  8: Ant
+  9: Antelope
+  10: Apple
+  11: Armadillo
+  12: Artichoke
+  13: Auto part
+  14: Axe
+  15: Backpack
+  16: Bagel
+  17: Baked goods
+  18: Balance beam
+  19: Ball
+  20: Balloon
+  21: Banana
+  22: Band-aid
+  23: Banjo
+  24: Barge
+  25: Barrel
+  26: Baseball bat
+  27: Baseball glove
+  28: Bat (Animal)
+  29: Bathroom accessory
+  30: Bathroom cabinet
+  31: Bathtub
+  32: Beaker
+  33: Bear
+  34: Bed
+  35: Bee
+  36: Beehive
+  37: Beer
+  38: Beetle
+  39: Bell pepper
+  40: Belt
+  41: Bench
+  42: Bicycle
+  43: Bicycle helmet
+  44: Bicycle wheel
+  45: Bidet
+  46: Billboard
+  47: Billiard table
+  48: Binoculars
+  49: Bird
+  50: Blender
+  51: Blue jay
+  52: Boat
+  53: Bomb
+  54: Book
+  55: Bookcase
+  56: Boot
+  57: Bottle
+  58: Bottle opener
+  59: Bow and arrow
+  60: Bowl
+  61: Bowling equipment
+  62: Box
+  63: Boy
+  64: Brassiere
+  65: Bread
+  66: Briefcase
+  67: Broccoli
+  68: Bronze sculpture
+  69: Brown bear
+  70: Building
+  71: Bull
+  72: Burrito
+  73: Bus
+  74: Bust
+  75: Butterfly
+  76: Cabbage
+  77: Cabinetry
+  78: Cake
+  79: Cake stand
+  80: Calculator
+  81: Camel
+  82: Camera
+  83: Can opener
+  84: Canary
+  85: Candle
+  86: Candy
+  87: Cannon
+  88: Canoe
+  89: Cantaloupe
+  90: Car
+  91: Carnivore
+  92: Carrot
+  93: Cart
+  94: Cassette deck
+  95: Castle
+  96: Cat
+  97: Cat furniture
+  98: Caterpillar
+  99: Cattle
+  100: Ceiling fan
+  101: Cello
+  102: Centipede
+  103: Chainsaw
+  104: Chair
+  105: Cheese
+  106: Cheetah
+  107: Chest of drawers
+  108: Chicken
+  109: Chime
+  110: Chisel
+  111: Chopsticks
+  112: Christmas tree
+  113: Clock
+  114: Closet
+  115: Clothing
+  116: Coat
+  117: Cocktail
+  118: Cocktail shaker
+  119: Coconut
+  120: Coffee
+  121: Coffee cup
+  122: Coffee table
+  123: Coffeemaker
+  124: Coin
+  125: Common fig
+  126: Common sunflower
+  127: Computer keyboard
+  128: Computer monitor
+  129: Computer mouse
+  130: Container
+  131: Convenience store
+  132: Cookie
+  133: Cooking spray
+  134: Corded phone
+  135: Cosmetics
+  136: Couch
+  137: Countertop
+  138: Cowboy hat
+  139: Crab
+  140: Cream
+  141: Cricket ball
+  142: Crocodile
+  143: Croissant
+  144: Crown
+  145: Crutch
+  146: Cucumber
+  147: Cupboard
+  148: Curtain
+  149: Cutting board
+  150: Dagger
+  151: Dairy Product
+  152: Deer
+  153: Desk
+  154: Dessert
+  155: Diaper
+  156: Dice
+  157: Digital clock
+  158: Dinosaur
+  159: Dishwasher
+  160: Dog
+  161: Dog bed
+  162: Doll
+  163: Dolphin
+  164: Door
+  165: Door handle
+  166: Doughnut
+  167: Dragonfly
+  168: Drawer
+  169: Dress
+  170: Drill (Tool)
+  171: Drink
+  172: Drinking straw
+  173: Drum
+  174: Duck
+  175: Dumbbell
+  176: Eagle
+  177: Earrings
+  178: Egg (Food)
+  179: Elephant
+  180: Envelope
+  181: Eraser
+  182: Face powder
+  183: Facial tissue holder
+  184: Falcon
+  185: Fashion accessory
+  186: Fast food
+  187: Fax
+  188: Fedora
+  189: Filing cabinet
+  190: Fire hydrant
+  191: Fireplace
+  192: Fish
+  193: Flag
+  194: Flashlight
+  195: Flower
+  196: Flowerpot
+  197: Flute
+  198: Flying disc
+  199: Food
+  200: Food processor
+  201: Football
+  202: Football helmet
+  203: Footwear
+  204: Fork
+  205: Fountain
+  206: Fox
+  207: French fries
+  208: French horn
+  209: Frog
+  210: Fruit
+  211: Frying pan
+  212: Furniture
+  213: Garden Asparagus
+  214: Gas stove
+  215: Giraffe
+  216: Girl
+  217: Glasses
+  218: Glove
+  219: Goat
+  220: Goggles
+  221: Goldfish
+  222: Golf ball
+  223: Golf cart
+  224: Gondola
+  225: Goose
+  226: Grape
+  227: Grapefruit
+  228: Grinder
+  229: Guacamole
+  230: Guitar
+  231: Hair dryer
+  232: Hair spray
+  233: Hamburger
+  234: Hammer
+  235: Hamster
+  236: Hand dryer
+  237: Handbag
+  238: Handgun
+  239: Harbor seal
+  240: Harmonica
+  241: Harp
+  242: Harpsichord
+  243: Hat
+  244: Headphones
+  245: Heater
+  246: Hedgehog
+  247: Helicopter
+  248: Helmet
+  249: High heels
+  250: Hiking equipment
+  251: Hippopotamus
+  252: Home appliance
+  253: Honeycomb
+  254: Horizontal bar
+  255: Horse
+  256: Hot dog
+  257: House
+  258: Houseplant
+  259: Human arm
+  260: Human beard
+  261: Human body
+  262: Human ear
+  263: Human eye
+  264: Human face
+  265: Human foot
+  266: Human hair
+  267: Human hand
+  268: Human head
+  269: Human leg
+  270: Human mouth
+  271: Human nose
+  272: Humidifier
+  273: Ice cream
+  274: Indoor rower
+  275: Infant bed
+  276: Insect
+  277: Invertebrate
+  278: Ipod
+  279: Isopod
+  280: Jacket
+  281: Jacuzzi
+  282: Jaguar (Animal)
+  283: Jeans
+  284: Jellyfish
+  285: Jet ski
+  286: Jug
+  287: Juice
+  288: Kangaroo
+  289: Kettle
+  290: Kitchen & dining room table
+  291: Kitchen appliance
+  292: Kitchen knife
+  293: Kitchen utensil
+  294: Kitchenware
+  295: Kite
+  296: Knife
+  297: Koala
+  298: Ladder
+  299: Ladle
+  300: Ladybug
+  301: Lamp
+  302: Land vehicle
+  303: Lantern
+  304: Laptop
+  305: Lavender (Plant)
+  306: Lemon
+  307: Leopard
+  308: Light bulb
+  309: Light switch
+  310: Lighthouse
+  311: Lily
+  312: Limousine
+  313: Lion
+  314: Lipstick
+  315: Lizard
+  316: Lobster
+  317: Loveseat
+  318: Luggage and bags
+  319: Lynx
+  320: Magpie
+  321: Mammal
+  322: Man
+  323: Mango
+  324: Maple
+  325: Maracas
+  326: Marine invertebrates
+  327: Marine mammal
+  328: Measuring cup
+  329: Mechanical fan
+  330: Medical equipment
+  331: Microphone
+  332: Microwave oven
+  333: Milk
+  334: Miniskirt
+  335: Mirror
+  336: Missile
+  337: Mixer
+  338: Mixing bowl
+  339: Mobile phone
+  340: Monkey
+  341: Moths and butterflies
+  342: Motorcycle
+  343: Mouse
+  344: Muffin
+  345: Mug
+  346: Mule
+  347: Mushroom
+  348: Musical instrument
+  349: Musical keyboard
+  350: Nail (Construction)
+  351: Necklace
+  352: Nightstand
+  353: Oboe
+  354: Office building
+  355: Office supplies
+  356: Orange
+  357: Organ (Musical Instrument)
+  358: Ostrich
+  359: Otter
+  360: Oven
+  361: Owl
+  362: Oyster
+  363: Paddle
+  364: Palm tree
+  365: Pancake
+  366: Panda
+  367: Paper cutter
+  368: Paper towel
+  369: Parachute
+  370: Parking meter
+  371: Parrot
+  372: Pasta
+  373: Pastry
+  374: Peach
+  375: Pear
+  376: Pen
+  377: Pencil case
+  378: Pencil sharpener
+  379: Penguin
+  380: Perfume
+  381: Person
+  382: Personal care
+  383: Personal flotation device
+  384: Piano
+  385: Picnic basket
+  386: Picture frame
+  387: Pig
+  388: Pillow
+  389: Pineapple
+  390: Pitcher (Container)
+  391: Pizza
+  392: Pizza cutter
+  393: Plant
+  394: Plastic bag
+  395: Plate
+  396: Platter
+  397: Plumbing fixture
+  398: Polar bear
+  399: Pomegranate
+  400: Popcorn
+  401: Porch
+  402: Porcupine
+  403: Poster
+  404: Potato
+  405: Power plugs and sockets
+  406: Pressure cooker
+  407: Pretzel
+  408: Printer
+  409: Pumpkin
+  410: Punching bag
+  411: Rabbit
+  412: Raccoon
+  413: Racket
+  414: Radish
+  415: Ratchet (Device)
+  416: Raven
+  417: Rays and skates
+  418: Red panda
+  419: Refrigerator
+  420: Remote control
+  421: Reptile
+  422: Rhinoceros
+  423: Rifle
+  424: Ring binder
+  425: Rocket
+  426: Roller skates
+  427: Rose
+  428: Rugby ball
+  429: Ruler
+  430: Salad
+  431: Salt and pepper shakers
+  432: Sandal
+  433: Sandwich
+  434: Saucer
+  435: Saxophone
+  436: Scale
+  437: Scarf
+  438: Scissors
+  439: Scoreboard
+  440: Scorpion
+  441: Screwdriver
+  442: Sculpture
+  443: Sea lion
+  444: Sea turtle
+  445: Seafood
+  446: Seahorse
+  447: Seat belt
+  448: Segway
+  449: Serving tray
+  450: Sewing machine
+  451: Shark
+  452: Sheep
+  453: Shelf
+  454: Shellfish
+  455: Shirt
+  456: Shorts
+  457: Shotgun
+  458: Shower
+  459: Shrimp
+  460: Sink
+  461: Skateboard
+  462: Ski
+  463: Skirt
+  464: Skull
+  465: Skunk
+  466: Skyscraper
+  467: Slow cooker
+  468: Snack
+  469: Snail
+  470: Snake
+  471: Snowboard
+  472: Snowman
+  473: Snowmobile
+  474: Snowplow
+  475: Soap dispenser
+  476: Sock
+  477: Sofa bed
+  478: Sombrero
+  479: Sparrow
+  480: Spatula
+  481: Spice rack
+  482: Spider
+  483: Spoon
+  484: Sports equipment
+  485: Sports uniform
+  486: Squash (Plant)
+  487: Squid
+  488: Squirrel
+  489: Stairs
+  490: Stapler
+  491: Starfish
+  492: Stationary bicycle
+  493: Stethoscope
+  494: Stool
+  495: Stop sign
+  496: Strawberry
+  497: Street light
+  498: Stretcher
+  499: Studio couch
+  500: Submarine
+  501: Submarine sandwich
+  502: Suit
+  503: Suitcase
+  504: Sun hat
+  505: Sunglasses
+  506: Surfboard
+  507: Sushi
+  508: Swan
+  509: Swim cap
+  510: Swimming pool
+  511: Swimwear
+  512: Sword
+  513: Syringe
+  514: Table
+  515: Table tennis racket
+  516: Tablet computer
+  517: Tableware
+  518: Taco
+  519: Tank
+  520: Tap
+  521: Tart
+  522: Taxi
+  523: Tea
+  524: Teapot
+  525: Teddy bear
+  526: Telephone
+  527: Television
+  528: Tennis ball
+  529: Tennis racket
+  530: Tent
+  531: Tiara
+  532: Tick
+  533: Tie
+  534: Tiger
+  535: Tin can
+  536: Tire
+  537: Toaster
+  538: Toilet
+  539: Toilet paper
+  540: Tomato
+  541: Tool
+  542: Toothbrush
+  543: Torch
+  544: Tortoise
+  545: Towel
+  546: Tower
+  547: Toy
+  548: Traffic light
+  549: Traffic sign
+  550: Train
+  551: Training bench
+  552: Treadmill
+  553: Tree
+  554: Tree house
+  555: Tripod
+  556: Trombone
+  557: Trousers
+  558: Truck
+  559: Trumpet
+  560: Turkey
+  561: Turtle
+  562: Umbrella
+  563: Unicycle
+  564: Van
+  565: Vase
+  566: Vegetable
+  567: Vehicle
+  568: Vehicle registration plate
+  569: Violin
+  570: Volleyball (Ball)
+  571: Waffle
+  572: Waffle iron
+  573: Wall clock
+  574: Wardrobe
+  575: Washing machine
+  576: Waste container
+  577: Watch
+  578: Watercraft
+  579: Watermelon
+  580: Weapon
+  581: Whale
+  582: Wheel
+  583: Wheelchair
+  584: Whisk
+  585: Whiteboard
+  586: Willow
+  587: Window
+  588: Window blind
+  589: Wine
+  590: Wine glass
+  591: Wine rack
+  592: Winter melon
+  593: Wok
+  594: Woman
+  595: Wood-burning stove
+  596: Woodpecker
+  597: Worm
+  598: Wrench
+  599: Zebra
+  600: Zucchini
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import warnings
+
+  from ultralytics.utils import LOGGER, SETTINGS, Path, get_ubuntu_version, is_ubuntu
+  from ultralytics.utils.checks import check_requirements, check_version
+
+  check_requirements("fiftyone")
+  if is_ubuntu() and check_version(get_ubuntu_version(), ">=22.04"):
+      # Ubuntu>=22.04 patch https://github.com/voxel51/fiftyone/issues/2961#issuecomment-1666519347
+      check_requirements("fiftyone-db-ubuntu2204")
+    
+  import fiftyone as fo
+  import fiftyone.zoo as foz
+
+  name = "open-images-v7"
+  fo.config.dataset_zoo_dir = Path(SETTINGS["datasets_dir"]) / "fiftyone" / name
+  fraction = 1.0  # fraction of full dataset to use
+  LOGGER.warning("WARNING ⚠️ Open Images V7 dataset requires at least **561 GB of free space. Starting download...")
+  for split in "train", "validation":  # 1743042 train, 41620 val images
+      train = split == "train"
+
+      # Load Open Images dataset
+      dataset = foz.load_zoo_dataset(
+          name,
+          split=split,
+          label_types=["detections"],
+          max_samples=round((1743042 if train else 41620) * fraction),
+      )
+
+      # Define classes
+      if train:
+          classes = dataset.default_classes  # all classes
+          # classes = dataset.distinct('ground_truth.detections.label')  # only observed classes
+
+      # Export to YOLO format
+      with warnings.catch_warnings():
+          warnings.filterwarnings("ignore", category=UserWarning, module="fiftyone.utils.yolo")
+          dataset.export(
+              export_dir=str(Path(SETTINGS["datasets_dir"]) / name),
+              dataset_type=fo.types.YOLOv5Dataset,
+              label_field="ground_truth",
+              split="val" if split == "validation" else split,
+              classes=classes,
+              overwrite=train,
+          )

ultralytics/cfg/datasets/package-seg.yaml

@@ -0,0 +1,22 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Package-seg dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/segment/package-seg/
+# Example usage: yolo train data=package-seg.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── package-seg  ← downloads here (102 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/package-seg # dataset root dir
+train: train/images # train images (relative to 'path') 1920 images
+val: valid/images # val images (relative to 'path') 89 images
+test: test/images # test images (relative to 'path') 188 images
+
+# Classes
+names:
+  0: package
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/package-seg.zip

ultralytics/cfg/datasets/signature.yaml

@@ -0,0 +1,21 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Signature dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/detect/signature/
+# Example usage: yolo train data=signature.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── signature  ← downloads here (11.2 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/signature # dataset root dir
+train: train/images # train images (relative to 'path') 143 images
+val: valid/images # val images (relative to 'path') 35 images
+
+# Classes
+names:
+  0: signature
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/signature.zip

ultralytics/cfg/datasets/tiger-pose.yaml

@@ -0,0 +1,25 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Tiger Pose dataset by Ultralytics
+# Documentation: https://docs.ultralytics.com/datasets/pose/tiger-pose/
+# Example usage: yolo train data=tiger-pose.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── tiger-pose  ← downloads here (75.3 MB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/tiger-pose # dataset root dir
+train: train # train images (relative to 'path') 210 images
+val: val # val images (relative to 'path') 53 images
+
+# Keypoints
+kpt_shape: [12, 2] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+flip_idx: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+
+# Classes
+names:
+  0: tiger
+
+# Download script/URL (optional)
+download: https://github.com/ultralytics/assets/releases/download/v0.0.0/tiger-pose.zip

ultralytics/cfg/datasets/xView.yaml

@@ -0,0 +1,155 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# DIUx xView 2018 Challenge https://challenge.xviewdataset.org by U.S. National Geospatial-Intelligence Agency (NGA)
+# --------  DOWNLOAD DATA MANUALLY and jar xf val_images.zip to 'datasets/xView' before running train command!  --------
+# Documentation: https://docs.ultralytics.com/datasets/detect/xview/
+# Example usage: yolo train data=xView.yaml
+# parent
+# ├── ultralytics
+# └── datasets
+#     └── xView  ← downloads here (20.7 GB)
+
+# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
+path: ../datasets/xView # dataset root dir
+train: images/autosplit_train.txt # train images (relative to 'path') 90% of 847 train images
+val: images/autosplit_val.txt # train images (relative to 'path') 10% of 847 train images
+
+# Classes
+names:
+  0: Fixed-wing Aircraft
+  1: Small Aircraft
+  2: Cargo Plane
+  3: Helicopter
+  4: Passenger Vehicle
+  5: Small Car
+  6: Bus
+  7: Pickup Truck
+  8: Utility Truck
+  9: Truck
+  10: Cargo Truck
+  11: Truck w/Box
+  12: Truck Tractor
+  13: Trailer
+  14: Truck w/Flatbed
+  15: Truck w/Liquid
+  16: Crane Truck
+  17: Railway Vehicle
+  18: Passenger Car
+  19: Cargo Car
+  20: Flat Car
+  21: Tank car
+  22: Locomotive
+  23: Maritime Vessel
+  24: Motorboat
+  25: Sailboat
+  26: Tugboat
+  27: Barge
+  28: Fishing Vessel
+  29: Ferry
+  30: Yacht
+  31: Container Ship
+  32: Oil Tanker
+  33: Engineering Vehicle
+  34: Tower crane
+  35: Container Crane
+  36: Reach Stacker
+  37: Straddle Carrier
+  38: Mobile Crane
+  39: Dump Truck
+  40: Haul Truck
+  41: Scraper/Tractor
+  42: Front loader/Bulldozer
+  43: Excavator
+  44: Cement Mixer
+  45: Ground Grader
+  46: Hut/Tent
+  47: Shed
+  48: Building
+  49: Aircraft Hangar
+  50: Damaged Building
+  51: Facility
+  52: Construction Site
+  53: Vehicle Lot
+  54: Helipad
+  55: Storage Tank
+  56: Shipping container lot
+  57: Shipping Container
+  58: Pylon
+  59: Tower
+
+# Download script/URL (optional) ---------------------------------------------------------------------------------------
+download: |
+  import json
+  import os
+  from pathlib import Path
+
+  import numpy as np
+  from PIL import Image
+  from tqdm import tqdm
+
+  from ultralytics.data.utils import autosplit
+  from ultralytics.utils.ops import xyxy2xywhn
+
+
+  def convert_labels(fname=Path("xView/xView_train.geojson")):
+      """Converts xView geoJSON labels to YOLO format, mapping classes to indices 0-59 and saving as text files."""
+      path = fname.parent
+      with open(fname, encoding="utf-8") as f:
+          print(f"Loading {fname}...")
+          data = json.load(f)
+
+      # Make dirs
+      labels = Path(path / "labels" / "train")
+      os.system(f"rm -rf {labels}")
+      labels.mkdir(parents=True, exist_ok=True)
+
+      # xView classes 11-94 to 0-59
+      xview_class2index = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, -1, 9, 10, 11,
+                           12, 13, 14, 15, -1, -1, 16, 17, 18, 19, 20, 21, 22, -1, 23, 24, 25, -1, 26, 27, -1, 28, -1,
+                           29, 30, 31, 32, 33, 34, 35, 36, 37, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, 46,
+                           47, 48, 49, -1, 50, 51, -1, 52, -1, -1, -1, 53, 54, -1, 55, -1, -1, 56, -1, 57, -1, 58, 59]
+
+      shapes = {}
+      for feature in tqdm(data["features"], desc=f"Converting {fname}"):
+          p = feature["properties"]
+          if p["bounds_imcoords"]:
+              id = p["image_id"]
+              file = path / "train_images" / id
+              if file.exists():  # 1395.tif missing
+                  try:
+                      box = np.array([int(num) for num in p["bounds_imcoords"].split(",")])
+                      assert box.shape[0] == 4, f"incorrect box shape {box.shape[0]}"
+                      cls = p["type_id"]
+                      cls = xview_class2index[int(cls)]  # xView class to 0-60
+                      assert 59 >= cls >= 0, f"incorrect class index {cls}"
+
+                      # Write YOLO label
+                      if id not in shapes:
+                          shapes[id] = Image.open(file).size
+                      box = xyxy2xywhn(box[None].astype(np.float), w=shapes[id][0], h=shapes[id][1], clip=True)
+                      with open((labels / id).with_suffix(".txt"), "a", encoding="utf-8") as f:
+                          f.write(f"{cls} {' '.join(f'{x:.6f}' for x in box[0])}\n")  # write label.txt
+                  except Exception as e:
+                      print(f"WARNING: skipping one label for {file}: {e}")
+
+
+  # Download manually from https://challenge.xviewdataset.org
+  dir = Path(yaml["path"])  # dataset root dir
+  # urls = [
+  #     "https://d307kc0mrhucc3.cloudfront.net/train_labels.zip",  # train labels
+  #     "https://d307kc0mrhucc3.cloudfront.net/train_images.zip",  # 15G, 847 train images
+  #     "https://d307kc0mrhucc3.cloudfront.net/val_images.zip",  # 5G, 282 val images (no labels)
+  # ]
+  # download(urls, dir=dir)
+
+  # Convert labels
+  convert_labels(dir / "xView_train.geojson")
+
+  # Move images
+  images = Path(dir / "images")
+  images.mkdir(parents=True, exist_ok=True)
+  Path(dir / "train_images").rename(dir / "images" / "train")
+  Path(dir / "val_images").rename(dir / "images" / "val")
+
+  # Split
+  autosplit(dir / "images" / "train")

ultralytics/cfg/default.yaml

@@ -0,0 +1,128 @@
+# Ultralytics 🚀 AGPL-3.0 许可证 - https://ultralytics.com/license
+
+# YOLO全局配置文件，包含训练、验证、预测和导出的设置和超参数
+# 文档参考 https://docs.ultralytics.com/usage/cfg/
+
+task: detect # (str) YOLO任务类型，可选: detect(检测), segment(分割), classify(分类), pose(姿态), obb(定向边界框)
+mode: train # (str) YOLO模式，可选: train(训练), val(验证), predict(预测), export(导出), track(跟踪), benchmark(基准测试)
+
+# 训练设置 -------------------------------------------------------------------------------------------------------
+model: # (str, 可选) 模型文件路径，
+data: # (str, 可选) 数据文件路径，
+epochs: 100 # (int) 训练的总epoch数
+time: # (float, 可选) 训练小时数，如果设置会覆盖epochs
+patience: 8 # (int) 早停等待的epoch数(当指标无改善时)
+batch: 64 # (int) 每批图像数量
+imgsz: 128 # (int | list) 输入图像尺寸，训练/验证时为int，预测/导出时为[h,w]列表
+save: True # (bool) 是否保存训练检查点和预测结果
+save_period: 20 # (int) 每x个epoch保存检查点(<1时禁用)
+cache: True # (bool) 数据加载缓存方式: True/ram(内存), disk(磁盘)或False(禁用)
+device: 0 # (int | str | list, 可选) 运行设备，如 cuda 设置device=0 或 多GPU device=0,1,2,3 或 device=cpu
+workers: 32 # (int) 数据加载的工作线程数(使用DDP时为每个RANK的线程数)
+project:  # (str, 可选) 项目名称
+name: # (str, 可选) 实验名称，结果保存到'project/name'目录
+exist_ok: False # (bool) 是否覆盖已有实验
+pretrained: True # (bool | str) 是否使用预训练模型(bool)或指定权重路径(str)
+optimizer: AdamW # (str) 优化器类型，可选: [SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, auto]
+verbose: True # (bool) 是否打印详细输出
+seed: 0 # (int) 随机种子(确保可复现性)
+deterministic: True # (bool) 是否启用确定性模式
+single_cls: False # (bool) 将多类数据作为单类训练
+rect: False # (bool) 矩形训练(模式='train')或矩形验证(模式='val')
+cos_lr: False # (bool) 使用余弦学习率调度器
+close_mosaic: 24 # (int) 最后x个epoch禁用马赛克增强(0表示不禁用)
+resume: false # (bool) 从上次检查点恢复训练
+amp: True # (bool) 自动混合精度(AMP)训练，True会运行AMP检查
+fraction: 1.0 # (float) 训练使用的数据集比例(1.0表示全部)
+profile: False # (bool) 在训练期间分析ONNX和TensorRT速度(用于日志记录)
+freeze: None # (int | list, 可选) 冻结前n层或指定层索引列表
+multi_scale: False # (bool) 是否在训练期间使用多尺度
+# 分割任务设置
+overlap_mask: True # (bool) 训练时将对象掩码合并为单个图像掩码(仅分割训练)
+mask_ratio: 4 # (int) 掩码下采样比例(仅分割训练)
+# 分类任务设置
+dropout: 0.5 # (float) 使用dropout正则化(仅分类训练)
+
+# 验证/测试设置 ----------------------------------------------------------------------------------------------------
+val: True # (bool) 训练期间是否进行验证/测试
+split: val # (str) 用于验证的数据集划分，可选: 'val', 'test' 或 'train'
+save_json: True # (bool) 是否将结果保存为JSON文件
+save_hybrid: False # (bool) 是否保存混合版本的标签(原始标签+额外预测)
+conf:  # (float, 可选) 检测的置信度阈值(预测默认为0.25，验证默认为0.001)
+iou: 0.7 # (float) NMS的IoU阈值
+max_det: 300 # (int) 每张图像的最大检测数
+half: true # (bool) 是否使用半精度(FP16)
+dnn: False # (bool) 是否使用OpenCV DNN进行ONNX推理
+plots: True # (bool) 训练/验证期间是否保存图表和图像
+
+# 预测设置 -----------------------------------------------------------------------------------------------------
+source: # (str, 可选) 图像或视频的源目录
+vid_stride: 1 # (int) 视频帧率步长
+stream_buffer: False # (bool) 缓冲所有流帧(True)或只返回最新帧(False)
+visualize: False # (bool) 是否可视化模型特征
+augment: False # (bool) 是否对预测源应用图像增强
+agnostic_nms: False # (bool) 是否使用类别无关的NMS
+classes: # (int | list[int], 可选) 按类别过滤结果，如 classes=0 或 classes=[0,2,3]
+retina_masks: False # (bool) 是否使用高分辨率分割掩码
+embed: # (list[int], 可选) 从指定层返回特征向量/嵌入
+
+# 可视化设置 ---------------------------------------------------------------------------------------------------
+show: False # (bool) 如果环境允许，是否显示预测的图像和视频
+save_frames: False # (bool) 是否保存预测的单个视频帧
+save_txt: True # (bool) 是否将结果保存为.txt文件
+save_conf: True # (bool) 是否保存带置信度的结果
+save_crop: False # (bool) 是否保存带结果的裁剪图像
+show_labels: false # (bool) 是否显示预测标签，如'person'
+show_conf: True # (bool) 是否显示预测置信度，如'0.99'
+show_boxes: True # (bool) 是否显示预测框
+line_width: # (int, 可选) 边界框线宽。如果为None则根据图像尺寸缩放。
+
+# 导出设置 ------------------------------------------------------------------------------------------------------
+format: torchscript # (str) 导出格式，选项见 https://docs.ultralytics.com/modes/export/#export-formats
+keras: False # (bool) 是否使用Keras
+optimize: False # (bool) TorchScript: 是否为移动端优化
+int8: False # (bool) CoreML/TF: INT8量化
+dynamic: False # (bool) ONNX/TF/TensorRT: 动态轴
+simplify: True # (bool) ONNX: 使用`onnxslim`简化模型
+opset: # (int, 可选) ONNX: opset版本
+workspace: 1 # (float, 可选) TensorRT: 工作空间大小(GiB)，`None`表示让TensorRT自动分配
+nms: False # (bool) CoreML: 是否添加NMS
+
+# 超参数设置 ------------------------------------------------------------------------------------------------------
+lr0: 0.001 # (float) 初始学习率(如SGD=1E-2, Adam=1E-3)
+lrf: 0.01 # (float) 最终学习率(lr0 * lrf)
+momentum: 0.937 # (float) SGD动量/Adam beta1
+weight_decay: 0.00075 # (float) 优化器权重衰减
+warmup_epochs: 5.0 # (float) 预热epoch数(可为小数)
+warmup_momentum: 0.8 # (float) 预热初始动量
+warmup_bias_lr: 0.1 # (float) 预热初始偏置学习率
+box: 7.5 # (float) 边界框损失权重
+cls: 0.5 # (float) 分类损失权重(与像素缩放)
+dfl: 1.5 # (float) DFL损失权重
+pose: 12.0 # (float) 姿态损失权重
+kobj: 1.0 # (float) 关键点对象损失权重
+nbs: 64 # (int) 标称批大小
+hsv_h: 0.015 # (float) 图像HSV色调增强(比例)
+hsv_s: 0.7 # (float) 图像HSV饱和度增强(比例)
+hsv_v: 0.4 # (float) 图像HSV明度增强(比例)
+degrees: 5.0 # (float) 图像旋转的角度
+translate: 0.1 # (float) 图像平移范围(+/- 比例)
+scale: 0.25 # (float) 图像缩放比例(+/- 增益)
+shear: 0 # (float) 图像剪切角度(+/- 度)
+perspective: 0 # (float) 图像透视变换比例(+/- 比例), 范围0-0.001
+flipud: 0.0 # (float) 图像上下翻转概率
+fliplr: 0.0 # (float) 图像左右翻转概率
+bgr: 0.0 # (float) 图像BGR通道转换概率
+mosaic: 0.24 # (float) 图像马赛克增强概率
+mixup: 0.0 # (float) 图像混合增强概率
+copy_paste: 0.0 # (float) 分割复制粘贴增强概率
+copy_paste_mode: "flip" # (str) 执行copy_paste增强的方法(flip, mixup)
+auto_augment: randaugment # (str) 分类任务的自动增强策略(randaugment, autoaugment, augmix)
+erasing: 0.4 # (float) 分类训练中随机擦除的概率(0-0.9), 0表示不擦除, 必须小于1.0
+crop_fraction: 1.0 # (float) 分类任务的图像裁剪比例(0.1-1), 1.0表示不裁剪, 必须大于0
+
+# Custom config.yaml ---------------------------------------------------------------------------------------------------
+cfg: # (str, 可选) 用于覆盖defaults.yaml的配置文件路径
+
+# Tracker settings ------------------------------------------------------------------------------------------------------
+tracker: botsort.yaml # (str) 跟踪器类型, 可选=[botsort.yaml, bytetrack.yaml]

ultralytics/cfg/models/11/yolo11-cls-resnet18.yaml

@@ -0,0 +1,17 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11-cls image classification model with ResNet18 backbone
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/classify
+
+# Parameters
+nc: 1000 # number of classes
+
+# ResNet18 backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, TorchVision, [512, resnet18, DEFAULT, True, 2]] # truncate two layers from the end
+
+# YOLO11n head
+head:
+  - [-1, 1, Classify, [nc]] # Classify

ultralytics/cfg/models/11/yolo11-cls.yaml

@@ -0,0 +1,33 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11-cls image classification model
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/classify
+
+# Parameters
+nc: 1000 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-cls.yaml' will call yolo11-cls.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 86 layers, 1633584 parameters, 1633584 gradients, 0.5 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 86 layers, 5545488 parameters, 5545488 gradients, 1.6 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 106 layers, 10455696 parameters, 10455696 gradients, 5.0 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 176 layers, 12937104 parameters, 12937104 gradients, 6.2 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 176 layers, 28458544 parameters, 28458544 gradients, 13.7 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 2, C2PSA, [1024]] # 9
+
+# YOLO11n head
+head:
+  - [-1, 1, Classify, [nc]] # Classify

ultralytics/cfg/models/11/yolo11-obb.yaml

@@ -0,0 +1,50 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11-obb Oriented Bounding Boxes (OBB) model with P3/8 - P5/32 outputs
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/obb
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-obb.yaml' will call yolo11-obb.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 196 layers, 2695747 parameters, 2695731 gradients, 6.9 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 196 layers, 9744931 parameters, 9744915 gradients, 22.7 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 246 layers, 20963523 parameters, 20963507 gradients, 72.2 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 372 layers, 26220995 parameters, 26220979 gradients, 91.3 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 372 layers, 58875331 parameters, 58875315 gradients, 204.3 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 1, SPPF, [1024, 5]] # 9
+  - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+  - [-1, 2, C3k2, [512, False]] # 13
+
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+  - [-1, 1, Conv, [256, 3, 2]]
+  - [[-1, 13], 1, Concat, [1]] # cat head P4
+  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+  - [-1, 1, Conv, [512, 3, 2]]
+  - [[-1, 10], 1, Concat, [1]] # cat head P5
+  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+  - [[16, 19, 22], 1, OBB, [nc, 1]] # Detect(P3, P4, P5)

ultralytics/cfg/models/11/yolo11-pose.yaml

@@ -0,0 +1,51 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11-pose keypoints/pose estimation model with P3/8 - P5/32 outputs
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/pose
+
+# Parameters
+nc: 80 # number of classes
+kpt_shape: [17, 3] # number of keypoints, number of dims (2 for x,y or 3 for x,y,visible)
+scales: # model compound scaling constants, i.e. 'model=yolo11n-pose.yaml' will call yolo11.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 196 layers, 2908507 parameters, 2908491 gradients, 7.7 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 196 layers, 9948811 parameters, 9948795 gradients, 23.5 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 246 layers, 20973273 parameters, 20973257 gradients, 72.3 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 372 layers, 26230745 parameters, 26230729 gradients, 91.4 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 372 layers, 58889881 parameters, 58889865 gradients, 204.3 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 1, SPPF, [1024, 5]] # 9
+  - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+  - [-1, 2, C3k2, [512, False]] # 13
+
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+  - [-1, 1, Conv, [256, 3, 2]]
+  - [[-1, 13], 1, Concat, [1]] # cat head P4
+  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+  - [-1, 1, Conv, [512, 3, 2]]
+  - [[-1, 10], 1, Concat, [1]] # cat head P5
+  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+  - [[16, 19, 22], 1, Pose, [nc, kpt_shape]] # Detect(P3, P4, P5)

ultralytics/cfg/models/11/yolo11-seg.yaml

@@ -0,0 +1,50 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11-seg instance segmentation model with P3/8 - P5/32 outputs
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/segment
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-seg.yaml' will call yolo11-seg.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 203 layers, 2876848 parameters, 2876832 gradients, 10.5 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 203 layers, 10113248 parameters, 10113232 gradients, 35.8 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 253 layers, 22420896 parameters, 22420880 gradients, 123.9 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 379 layers, 27678368 parameters, 27678352 gradients, 143.0 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 379 layers, 62142656 parameters, 62142640 gradients, 320.2 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 1, SPPF, [1024, 5]] # 9
+  - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+  - [-1, 2, C3k2, [512, False]] # 13
+
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+  - [-1, 1, Conv, [256, 3, 2]]
+  - [[-1, 13], 1, Concat, [1]] # cat head P4
+  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+  - [-1, 1, Conv, [512, 3, 2]]
+  - [[-1, 10], 1, Concat, [1]] # cat head P5
+  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+  - [[16, 19, 22], 1, Segment, [nc, 32, 256]] # Detect(P3, P4, P5)

ultralytics/cfg/models/11/yolo11.yaml

@@ -0,0 +1,50 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11 object detection model with P3/8 - P5/32 outputs
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/detect
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 181 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 181 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 231 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 357 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 357 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 1, SPPF, [1024, 5]] # 9
+  - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+  - [-1, 2, C3k2, [512, False]] # 13
+
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+  - [-1, 1, Conv, [256, 3, 2]]
+  - [[-1, 13], 1, Concat, [1]] # cat head P4
+  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+  - [-1, 1, Conv, [512, 3, 2]]
+  - [[-1, 10], 1, Concat, [1]] # cat head P5
+  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

ultralytics/cfg/models/11/yoloe-11-seg.yaml

@@ -0,0 +1,48 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# YOLO11-seg instance segmentation model. For Usage examples see https://docs.ultralytics.com/tasks/segment
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n-seg.yaml' will call yolo11-seg.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 355 layers, 2876848 parameters, 2876832 gradients, 10.5 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 355 layers, 10113248 parameters, 10113232 gradients, 35.8 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 445 layers, 22420896 parameters, 22420880 gradients, 123.9 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 667 layers, 27678368 parameters, 27678352 gradients, 143.0 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 667 layers, 62142656 parameters, 62142640 gradients, 320.2 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 1, SPPF, [1024, 5]] # 9
+  - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+  - [-1, 2, C3k2, [512, False]] # 13
+
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+  - [-1, 1, Conv, [256, 3, 2]]
+  - [[-1, 13], 1, Concat, [1]] # cat head P4
+  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+  - [-1, 1, Conv, [512, 3, 2]]
+  - [[-1, 10], 1, Concat, [1]] # cat head P5
+  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+  - [[16, 19, 22], 1, YOLOESegment, [nc, 32, 256, 512, True]] # Detect(P3, P4, P5)

ultralytics/cfg/models/11/yoloe-11.yaml

@@ -0,0 +1,48 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 1, SPPF, [1024, 5]] # 9
+  - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+  - [-1, 2, C3k2, [512, False]] # 13
+
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+  - [-1, 1, Conv, [256, 3, 2]]
+  - [[-1, 13], 1, Concat, [1]] # cat head P4
+  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+  - [-1, 1, Conv, [512, 3, 2]]
+  - [[-1, 10], 1, Concat, [1]] # cat head P5
+  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+  - [[16, 19, 22], 1, YOLOEDetect, [nc, 512, True]] # Detect(P3, P4, P5)

ultralytics/cfg/models/12/yolo12-cls.yaml

@@ -0,0 +1,32 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# YOLO12-cls image classification model
+# Model docs: https://docs.ultralytics.com/models/yolo12
+# Task docs: https://docs.ultralytics.com/tasks/classify
+
+# Parameters
+nc: 80 # number of classes
+scales: # model compound scaling constants, i.e. 'model=yolo12n-cls.yaml' will call yolo12-cls.yaml with scale 'n'
+  # [depth, width, max_channels]
+  n: [0.50, 0.25, 1024] # summary: 152 layers, 1,820,976 parameters, 1,820,976 gradients, 3.7 GFLOPs
+  s: [0.50, 0.50, 1024] # summary: 152 layers, 6,206,992 parameters, 6,206,992 gradients, 13.6 GFLOPs
+  m: [0.50, 1.00, 512] # summary: 172 layers, 12,083,088 parameters, 12,083,088 gradients, 44.2 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 312 layers, 15,558,640 parameters, 15,558,640 gradients, 56.9 GFLOPs
+  x: [1.00, 1.50, 512] # summary: 312 layers, 34,172,592 parameters, 34,172,592 gradients, 126.5 GFLOPs
+
+# YOLO12n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 4, A2C2f, [512, True, 4]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 4, A2C2f, [1024, True, 1]] # 8
+
+# YOLO12n head
+head:
+  - [-1, 1, Classify, [nc]] # Classify