欢迎关注『跟我学 YOLO』系列
【跟我学YOLO】YOLO26（1）YOLO Vision 2025 最新发布的端到端视觉 AI 新突破
【跟我学YOLO】YOLO26（2）实时目标检测的关键架构改进与性能基准测试
【跟我学YOLO】YOLO26（3）模型下载、环境配置与目标检测


【跟我学YOLO】YOLO26（3）安装配置与快速使用


Ultralytics 发布了 YOLO 模型系列的最新突破——Ultralytics YOLO26！本文介绍 YOLO26 的下载、配置和检测。

YOLO26 是一款 更快、更轻、更准、易部署 的 Vision AI 产品，它不仅延续了 YOLO 系列一贯的速度与易用性，还在端到端架构、训练优化和多任务支持上带来了革命性突破。

YOLO26 可以执行各种计算机视觉任务，包括：

  • 检测（detect）：物体检测 识别并定位图像或视频中的物体；
  • 分割（segment）：实例分割将图像或视频划分为对应于不同对象或类别的区域；
  • 分类（classification）：图像分类 预测输入图像的类别标签；
  • 姿势估计（pose）：姿势估计识别图像或视频中的对象并估计其关键点；
  • 旋转框检测（OBB）：旋转边界框使用旋转的边界框，适用于卫星或医学图像。

在这里插入图片描述


1. YOLO26 环境配置与安装

1.1 创建 YOLO26 虚拟环境

虚拟环境可以将 YOLO26 训练所需的依赖包和其他项目的依赖包隔离开来，避免版本冲突，更加便于管理。本文推荐使用 miniconda 创建 Python 虚拟环境，其安装和使用可以参见：安装环境详解之 miniconda。

创建名称为 YOLO26 的 Python 环境，注意推荐Python 版本为3.8。激活 YOLO26 环境。

conda env list
conda create -n YOLO26 python=3.8
conda activate YOLO26

在这里插入图片描述


1.2 配置 Pycharm 编辑器

  1. 打开/创建 PyCharm 项目。
    启动 PyCharm，点击 “File → New Project” 新建项目，或点击 “File → Open” 选择 YOLO26 代码所在文件夹打开项目。

  2. 进入解释器配置界面。
    方法一：在 PyCharm 右下角状态栏找到当前解释器显示处（如 Python 3.x）→ 点击 “解释器设置（Python Interpreter）”。
    方法二：点击 “File → Settings → Project→ Python Interpreter”。
    点击右侧窗口中的 “添加解释器”，选择 “添加本地解释器”，弹出 “添加 Python 解释器” 窗口。

  3. 配置 Conda 环境，如下图所示。
    环境：选择 “使用现有环境”
    类型：从下拉框中选择 “Conda”
    conda 路径：根据 miniconda 安装路径选择 conda.exe（例如 “.\miniconda3\Scripts\conda.exe”）
    环境：从下拉框中选择刚才创建的虚拟环境 “YOLO26”

在这里插入图片描述


2. 安装 Ultralytics YOLO26

2.1 Pip 安装 Ultralytics

Ultralytics 提供了多种安装方法，包括 Pip、conda 和 Docker。本文推荐使用 Pip 安装 YOLO26（用于最新的稳定版本）。

  1. 打开 Anaconda Prompt，执行如下指令：
# Activate the YOLO26 environment
# conda activate YOLO26 2>$null ; if (!$?) { echo "环境不存在" }
conda activate YOLO26

# Install or upgrade the ultralytics package from PyPI
pip install -U ultralytics

说明：
（1）也可以在 PyCharm 工具栏点击 “终端（Terminal）” 或 按 “Alt+F12” 在底部 Powershell 执行以上指令。
（2）执行 pip install -U ultralytics 时，pip 会自动读取 ultralytics 包在 PyPI 上声明的 install_requires 依赖列表，并递归安装所有必需的第三方库。

  1. 安装测试：
    输入 “yolo help” ，系统输出 YOLO26 的帮助提示信息，说明安装成功。

在这里插入图片描述


2.2 克隆 Ultralytics GitHub 仓库

如果希望试用最新版本的源代码，可以通过克隆 Ultralytics GitHub 仓库来安装 YOLO26。

Github-YOLO26 ： github.com/ultralytics/ultralytics

  1. 方法一：克隆 repo。克隆后导航到该目录，并将软件包以可编辑模式安装 -e 。
# Clone the ultralytics repository
git clone https://github.com/ultralytics/ultralytics

# Navigate to the cloned directory
cd ultralytics

# Install the package in editable mode for development
pip install -e .

说明：pip install -e .用于以"可编辑模式"（editable mode）安装当前目录的 Python 包。注意安装命令中的 -e 和 . 之间有一个空格。

  1. 方法二：直接从 GitHub 网页下载压缩文件。
    没有安装 git 的用户，可以在 GitHub 网站的 YOLO26 项目页面，点击绿色的 “<>Code”，选择 “Download ZIP”，下载 YOLO26 项目的压缩包。

在这里插入图片描述

下载完成后，打开 Anaconda Prompt，激活 YOLO26虚拟环境并切换到下载解压的 YOLO26 文件夹，以可编辑模式安装 YOLO26。

conda activate YOLO26
cd C:\Python\Projects\YOLO26 # 下载解压的 YOLO26 文件夹
pip install -e .
  1. 安装测试：
    输入 “yolo help” ，系统输出 YOLO26 的帮助提示信息，说明安装成功。

2.3 安装 项目依赖

执行 pip install -U ultralytics 时，pip 会自动读取 ultralytics 包在 PyPI 上声明的 install_requires 依赖列表，并递归安装所有必需的第三方库。


  1. PyTorch 版本问题：
    虽然 pip install -U ultralytics 会安装 PyTorch，但安装的可能是 CPU 版本。如果需要GPU加速，建议采用以下两种方式之一：
# Activate the YOLO26 environment
conda activate YOLO26

# Install PyTorch (https://pytorch.org/)
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu121

# Install or upgrade the ultralytics package from PyPI
pip install -U ultralytics
  • （2）方式二：
    安装 ultralytics 后，手动替换为 GPU 版 PyTorch。
pip uninstall torch torchvision -y
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu121

安装 GPU 版 PyTorch 后，可以在 Python 环境中（如 PyCharm）运行如下验证代码：

import torch
import torchvision
import sys

print("Python 版本:", sys.version)          # 应为 3.8.x
print("PyTorch 版本:", torch.__version__)   # 应显示 2.4.1+cu121
print("TorchVision 版本:", torchvision.__version__)  # 应显示 0.19.1+cu121
print("CUDA 可用:", torch.cuda.is_available())  # 应为 True
print("CUDA 版本:", torch.version.cuda)     # 应显示 12.1

在这里插入图片描述

  1. 运行时缺少 YOLO26 项目依赖
    如果未能自动安装 YOLO26 所有第三方库（通常是由于网络环境或版本冲突问题），可以根据报错安装缺少的依赖项目。
    依赖项列表请参阅 ultralytics 项目 pyproject.toml 文件中的描述如下。
# Required dependencies
dependencies = [
    "numpy>=1.23.0",
    "matplotlib>=3.3.0",
    "opencv-python>=4.6.0",
    "pillow>=7.1.2",
    "pyyaml>=5.3.1",
    "requests>=2.23.0",
    "scipy>=1.4.1",
    "torch>=1.8.0",
    "torch>=1.8.0,!=2.4.0; sys_platform == 'win32'", # Windows CPU errors w/ 2.4.0 https://github.com/ultralytics/ultralytics/issues/15049
    "torchvision>=0.9.0",
    "psutil>=5.8.0", # system utilization
    "polars>=0.20.0",
    "ultralytics-thop>=2.0.18", # FLOPs computation https://github.com/ultralytics/thop
]

3. YOLO26 快速入门

3.1 CLI 方式运行

命令行界面（command line interface, CLI）提供了一种直接使用 Ultralytics YOLO 模型的方法，可以直接从终端运行各种任务 而无需 Python 环境。

YOLO26 支持使用命令行界面在各种任务和版本上训练、验证或推断模型，不需要定制或代码。

  1. 基本语法：
    yolo 命令基本语法如下：
yolo TASK MODE ARGS

其中：
（1）MODE：设置模式，可设为 [train, val, predict, export, track, benchmark] 之一，必需项。
（2）TASK：设置视觉任务，可设为 [detect, segment, classify, pose, obb] 之一，可选项，缺省时将自动推断 TASK 。
（3）ARGS：自定义参数，可选项，参数必须以 arg=value 形式设置，用于覆盖默认值。不要使用 -- 参数前缀。多个参数之间用空格分隔， 不要使用逗号分隔。
有关可用 ARGS，请参阅 配置 页面和 default.yaml.

  1. 模式（mode）：
    Ultralytics YOLO 模型以不同的模式运行，默认值为 “train”。
    （1）训练（train）：在自定义数据集上训练 YOLO 模型。
    （2）验证（val）：验证已训练的 YOLO 模型。
    （3）预测（predict）：使用训练好的 YOLO 模型对新图像或视频进行预测。
    （4）导出（export）：导出 YOLO 模型以进行部署。
    （5）跟踪（track）：使用 YOLO 模型实时跟踪对象。
    （6）基准测试（benchmark）：对 YOLO 导出（ONNX、TensorRT 等）的速度和准确性进行基准测试。

  2. 视觉任务（task）：
    （1）检测（detect）：物体检测 识别并定位图像或视频中的物体；
    （2）分割（segment）：实例分割将图像或视频划分为对应于不同对象或类别的区域；
    （3）分类（classification）：图像分类 预测输入图像的类别标签；
    （4）姿势估计（pose）：姿势估计识别图像或视频中的对象并估计其关键点；
    （5）旋转框检测（OBB）：旋转边界框使用旋转的边界框，适用于卫星或医学图像。

  3. 使用方法：

# 1. 训练：在 COCO8 数据集上训练 YOLO26n 模型，共 100 个 epoch，图像尺寸为 640
yolo detect train data=coco8.yaml model=yolo26n.pt epochs=100 imgsz=640

# 2. 预测：使用预训练的分割模型在YouTube视频上以 320 的图像尺寸进行预测
yolo predict model=yolo26n-seg.pt source='https://youtu.be/LNwODJXcvt4' imgsz=320

# 3. 验证：使用 1 张 640 大小的图像验证预训练的检测模型
yolo val model=yolo26n.pt data=coco8.yaml batch=1 imgsz=640

# 4. 导出：将 YOLO 分类模型导出为 ONNX 格式，图像大小为 224x128
yolo export model=yolo26n-cls.pt format=onnx imgsz=224,128

# 5. 特殊命令
yolo help  # 帮助命令，查看 YOLO 可用命令、参数和使用示例
yolo checks  # 检查 YOLO 运行环境
yolo version  # 查看当前安装的 YOLO 版本信息
yolo settings  # 管理 YOLO 的全局配置设置
yolo copy-cfg  # 将 YOLO 的默认配置文件复制到指定路径（或当前目录）
yolo cfg  # 查看或导出 YOLO 合并后的最终配置
  1. 应用实例：
    使用 miniconda Prompt 命令行，或在 PyCharm 的命令行窗口，都可以以CLI 方式运行 yolo 命令进行物体检测任务，具体操作步骤如下：

（1）使用 miniconda Prompt 命令行，激活 YOLO26 虚拟环境，输入如下命令对指定图片进行检测。

conda activate YOLO26
cd c:\Python\Projects2025\Yolo26
yolo predict model=yolo26n.pt source="./data/images/bus.jpg"

在这里插入图片描述

（2）在 PyCharm 的命令行窗口，激活 YOLO26 虚拟环境，输入如下命令对指定图片进行检测。

conda activate YOLO26
yolo predict model=yolo26n.pt source="./data/images/bus.jpg"

检测结果默认保存在 “.\runs\detect\predict” 目录下，也可以在命令中使用 “project” 参数，指定保存预测结果的项目目录名称。

在这里插入图片描述


3.2 Python 程序运行

YOLO26 也提供了 Python 接口的调用方式。它提供了加载和运行模型以及处理模型输出的函数。Python 接口设计简单、易于使用，用户可以快速实现对象检测、分割和分类。这使得 YOLO python 接口成为将这些功能集成到 python 项目中的宝贵工具。

使用预训练模型 YOLO26n.pt 进行推理的 Python 例程如下。

from ultralytics import YOLO

# 加载预训练的YOLO26模型
model = YOLO("YOLO26n.pt")

# 使用模型对图像执行对象检测
result = model(source="./data/images/roadflow.png", save=True)

# Export the model to ONNX format
success = model.export(format="onnx")

运行程序，就实现对指定图像文件的检测，并将检测结果保存到文件夹 “./runs/detect/predict”。

在这里插入图片描述


4. YOLO26 预训练模型

使用 YOLO26 进行推理，首先要下载 YOLO26 预训练模型。使用 YOLO26 训练自己的模型，也常用 YOLO26 预训练模型作为初始模型。

YOLO26 有多个不同规模的模型，从小到大依次是：YOLO26N、YOLO26S、YOLO26L、YOLO26X。这些模型与各种操作模式兼容，包括推理、验证、训练和导出，便于在部署和开发的不同阶段使用。

YOLO26 运行时如果在本地没有检测到预训练模型，将会自动从最新的 Ultralytics 版本 下载模型，但下载速度可能很慢甚至连接失败（视网络条件和限制），因此推荐先将 YOLO26 预训练模型下载到本地。


4.1 模型下载

如下表所示，点击所需的模型即可下载相应的预训练模型。

在这里插入图片描述


  1. 目标检测 (Detect)
    目标检测任务需要识别图像或视频流中目标的位置和类别。目标检测器的输出是一组边界框，这些边界框包围了图像中的目标，以及每个框的类别标签和置信度分数。
    这些模型在 COCO 数据集上训练，包含 80 个对象类别。
模型名称 下载地址 尺寸
(像素)		 mAPval
50-95		 mAPval
50-95(e2e)		 速度
CPU ONNX
(毫秒)		 参数
(百万)		 FLOPs
(十亿)
YOLO26n YOLO26n.pt 640 40.9 40.1 38.9 ± 0.7 2.4 5.4
YOLO26s YOLO26s.pt 640 48.6 47.8 87.2 ± 0.9 9.5 20.7
YOLO26m YOLO26m.pt 640 53.1 52.5 220.0 ± 1.4 20.4 68.2
YOLO26l YOLO26l.pt 640 55.0 54.4 286.2 ± 2.0 24.8 86.4
YOLO26x YOLO26x.pt 640 57.5 56.9 525.8 ± 4.0 55.7 193.9

  1. 实例分割 (Segment)
    实例分割任务需要识别图像中的各个对象并将它们与图像的其余部分分割开来。实例分割模型的输出是一组掩码或轮廓，它们勾勒出图像中每个对象，以及每个对象的类别标签和置信度分数。
    这些模型在 COCO-Seg 数据集上训练，包含 80 个类别。
模型名称 下载地址 尺寸
(像素)		 mAPbox
50-95(e2e)		 mAPmask
50-95(e2e)		 参数
(百万)		 FLOPs
(十亿)
YOLO26n-seg YOLO26n-seg.pt 640 39.6 33.9 2.7 9.1
YOLO26s-seg YOLO26s-seg.pt 640 47.3 40.0 10.4 34.2
YOLO26m-seg YOLO26m-seg.pt 640 52.5 44.1 23.6 121.5
YOLO26l-seg YOLO26l-seg.pt 640 54.4 45.5 28.0 139.8
YOLO26x-seg YOLO26x-seg.pt 640 56.5 47.0 62.8 313.5

  1. 图像分类 (Classify)
    图像分类要将整个图像分类到一组预定义的类别中。图像分类器的输出是单个类别标签和一个置信度分数。
    这些模型在 ImageNet 数据集上训练，涵盖 1000 个类别。
模型名称 下载地址 尺寸
(像素)		 acc
top1		 acc
top5		 参数
(百万)		 FLOPs
(十亿)
YOLO26n-cls YOLO26n-cls.pt 224 71.4 90.1 2.8 0.5
YOLO26s-cls YOLO26s-cls.pt 224 76.0 92.9 6.7 1.6
YOLO26m-cls YOLO26m-cls.pt 224 78.1 94.2 11.6 4.9
YOLO26l-cls YOLO26l-cls.pt 224 79.0 94.6 14.1 6.2
YOLO26x-cls YOLO26x-cls.pt 224 79.9 95.0 29.6 13.6

  1. 姿态估计(Pose)
    姿势估计是一项涉及识别图像中特定点的位置的任务，这些点通常称为关键点。关键点可以代表对象的各个部分，例如关节、地标或其他独特特征。关键点的位置通常表示为一组 2D [x, y] 或 3D [x, y, visible] 坐标。姿势估计模型的输出是一组点，这些点代表图像中对象上的关键点，通常还包括每个点的置信度分数。
    这些模型在 COCO-Pose 数据集上训练，专注于 ‘person’ 类别。
模型名称 下载地址 尺寸
(像素)		 mAPpose
50-95		 mAPpose
50		 参数
(百万)		 FLOPs
(十亿)
YOLO26n-pose yolo26n-pose.pt 640 57.2 83.3 2.9 7.5
YOLO26s-pose yolo26s-pose.pt 640 63.0 86.6 10.4 23.9
YOLO26m-pose yolo26m-pose.pt 640 68.8 89.6 21.5 73.1
YOLO26l-pose yolo26l-pose.pt 640 70.4 90.5 25.9 91.3
YOLO26x-pose yolo26x-pose.pt 640 71.7 91.6 57.6 201.7

  1. 定向边界框 (Oriented Bounding Boxes)
    定向对象检测通过引入一个额外的角度来更准确地定位图像中的对象，从而比目标检测更进一步。定向目标检测器的输出是一组旋转的边界框，这些边界框精确地包围了图像中的目标，以及每个框的类别标签和置信度分数。
    这些模型在 DOTAv1 数据集上训练。
模型名称 下载地址 尺寸
(像素)		 mAPtest
50(e2e)		 参数
(百万)		 FLOPs
(十亿)
YOLO26n-obb yolo26n-obb.pt 1024 78.9 2.5 14.0
YOLO26s-obb yolo26s-obb.pt 1024 80.9 9.8 55.1
YOLO26m-obb yolo26m-obb.pt 1024 81.0 21.2 183.3
YOLO26l-obb yolo26l-obb.pt 1024 81.6 25.6 230.0
YOLO26x-obb yolo26x-obb.pt 1024 81.7 57.6 516.5

4.2 模型验证

使用以下代码在 COCO 数据集上验证 YOLO26 模型。请确保将 {n/s/l/x} 替换为所需的模型规模。

from ultralytics import YOLO

model = YOLO('YOLO26{n/s/l/x}.pt')  # 替换为所需的模型规模

5. YOLO26 模型与参数解析

5.1 模型配置文件解析

以检测任务模型为例，YOLO26 的模型配置文件 “.\ultralytics\cfg\models\26\yolo26.yaml” 文件内容如下，主要包括 模型参数（Parameters）、主干模型（backbone）和检测头（head）三部分。

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# Ultralytics YOLO26 object detection model with P3/8 - P5/32 outputs
# Model docs: https://docs.ultralytics.com/models/yolo26
# Task docs: https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
end2end: True # whether to use end-to-end mode
reg_max: 1 # DFL bins
scales: # model compound scaling constants, i.e. 'model=yolo26n.yaml' will call yolo26.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 260 layers, 2,572,280 parameters, 2,572,280 gradients, 6.1 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 260 layers, 10,009,784 parameters, 10,009,784 gradients, 22.8 GFLOPs
  m: [0.50, 1.00, 512] # summary: 280 layers, 21,896,248 parameters, 21,896,248 gradients, 75.4 GFLOPs
  l: [1.00, 1.00, 512] # summary: 392 layers, 26,299,704 parameters, 26,299,704 gradients, 93.8 GFLOPs
  x: [1.00, 1.50, 512] # summary: 392 layers, 58,993,368 parameters, 58,993,368 gradients, 209.5 GFLOPs

# YOLO26n 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, 3, True]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO26n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, True]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, True]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, True]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 1, C3k2, [1024, True, 0.5, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.2 参数配置

YOLO26 的参数配置文件 “./ultralytics/cfg/default.yaml” 文件内容如下。

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# Global configuration YAML with settings and hyperparameters for YOLO training, validation, prediction and export
# For documentation see https://docs.ultralytics.com/usage/cfg/

task: detect # (str) YOLO task, i.e. detect, segment, classify, pose, obb
mode: train # (str) YOLO mode, i.e. train, val, predict, export, track, benchmark

# Train settings -------------------------------------------------------------------------------------------------------
model: # (str, optional) path to model file, i.e. yolov8n.pt or yolov8n.yaml
data: # (str, optional) path to data file, i.e. coco8.yaml
epochs: 100 # (int) number of epochs to train for
time: # (float, optional) max hours to train; overrides epochs if set
patience: 100 # (int) early stop after N epochs without val improvement
batch: 16 # (int) batch size; use -1 for AutoBatch
imgsz: 640 # (int | list) train/val use int (square); predict/export may use [h,w]
save: True # (bool) save train checkpoints and predict results
save_period: -1 # (int) save checkpoint every N epochs; disabled if < 1
cache: False # (bool | str) cache images in RAM (True/'ram') or on 'disk' to speed dataloading; False disables
device: # (int | str | list) device: 0 or [0,1,2,3] for CUDA, 'cpu'/'mps', or -1/[-1,-1] to auto-select idle GPUs
workers: 8 # (int) dataloader workers (per RANK if DDP)
project: # (str, optional) project name for results root
name: # (str, optional) experiment name; results in 'project/name'
exist_ok: False # (bool) overwrite existing 'project/name' if True
pretrained: True # (bool | str) use pretrained weights (bool) or load weights from path (str)
optimizer: auto # (str) optimizer: SGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp, or auto
verbose: True # (bool) print verbose logs during training/val
seed: 0 # (int) random seed for reproducibility
deterministic: True # (bool) enable deterministic ops; reproducible but may be slower
single_cls: False # (bool) treat all classes as a single class
rect: False # (bool) rectangular batches for train; rectangular batching for val when mode='val'
cos_lr: False # (bool) cosine learning rate scheduler
close_mosaic: 10 # (int) disable mosaic augmentation for final N epochs (0 to keep enabled)
resume: False # (bool) resume training from last checkpoint in the run dir
amp: True # (bool) Automatic Mixed Precision (AMP) training; True runs AMP capability check
fraction: 1.0 # (float) fraction of training dataset to use (1.0 = all)
profile: False # (bool) profile ONNX/TensorRT speeds during training for loggers
freeze: # (int | list, optional) freeze first N layers (int) or specific layer indices (list)
multi_scale: 0.0 # (float) multi-scale range as a fraction of imgsz; sizes are rounded to stride multiples
compile: False # (bool | str) enable torch.compile() backend='inductor'; True="default", False=off, or "default|reduce-overhead|max-autotune-no-cudagraphs"

# Segmentation
overlap_mask: True # (bool) merge instance masks into one mask during training (segment only)
mask_ratio: 4 # (int) mask downsample ratio (segment only)

# Classification
dropout: 0.0 # (float) dropout for classification head (classify only)

# Val/Test settings ----------------------------------------------------------------------------------------------------
val: True # (bool) run validation/testing during training
split: val # (str) dataset split to evaluate: 'val', 'test' or 'train'
save_json: False # (bool) save results to COCO JSON for external evaluation
conf: # (float, optional) confidence threshold; defaults: predict=0.25, val=0.001
iou: 0.7 # (float) IoU threshold used for NMS
max_det: 300 # (int) maximum number of detections per image
half: False # (bool) use half precision (FP16) if supported
dnn: False # (bool) use OpenCV DNN for ONNX inference
plots: True # (bool) save plots and images during train/val
end2end: # (bool, optional) whether to use end2end head(YOLO26, YOLOv10) for predict/val/export

# Predict settings -----------------------------------------------------------------------------------------------------
source: # (str, optional) path/dir/URL/stream for images or videos; e.g. 'ultralytics/assets' or '0' for webcam
vid_stride: 1 # (int) read every Nth frame for video sources
stream_buffer: False # (bool) True buffers all frames; False keeps the most recent frame for low-latency streams
visualize: False # (bool) visualize model features (predict) or TP/FP/FN confusion (val)
augment: False # (bool) apply test-time augmentation during prediction
agnostic_nms: False # (bool) class-agnostic NMS
classes: # (int | list[int], optional) filter by class id(s), e.g. 0 or [0,2,3]
retina_masks: False # (bool) use high-resolution segmentation masks (segment)
embed: # (list[int], optional) return feature embeddings from given layer indices

# Visualize settings ---------------------------------------------------------------------------------------------------
show: False # (bool) show images/videos in a window if supported
save_frames: False # (bool) save individual frames from video predictions
save_txt: False # (bool) save results as .txt files (xywh format)
save_conf: False # (bool) save confidence scores with results
save_crop: False # (bool) save cropped prediction regions to files
show_labels: True # (bool) draw class labels on images, e.g. 'person'
show_conf: True # (bool) draw confidence values on images, e.g. '0.99'
show_boxes: True # (bool) draw bounding boxes on images
line_width: # (int, optional) line width of boxes; auto-scales with image size if not set

# Export settings ------------------------------------------------------------------------------------------------------
format: torchscript # (str) target format, e.g. torchscript|onnx|openvino|engine|coreml|saved_model|pb|tflite|edgetpu|tfjs|paddle|mnn|ncnn|imx|rknn|executorch
keras: False # (bool) TF SavedModel only (format=saved_model); enable Keras layers during export
optimize: False # (bool) TorchScript only; apply mobile optimizations to the scripted model
int8: False # (bool) INT8/PTQ where supported (openvino, tflite, tfjs, engine, imx); needs calibration data/fraction
dynamic: False # (bool) dynamic shapes for torchscript, onnx, openvino, engine; enable variable image sizes
simplify: True # (bool) ONNX/engine only; run graph simplifier for cleaner ONNX before runtime conversion
opset: # (int, optional) ONNX/engine only; opset version for export; leave unset to use a tested default
workspace: # (float, optional) engine (TensorRT) only; workspace size in GiB, e.g. 4
nms: False # (bool) fuse NMS into exported model when backend supports; if True, conf/iou apply (agnostic_nms except coreml)

# Hyperparameters ------------------------------------------------------------------------------------------------------
lr0: 0.01 # (float) initial learning rate (SGD=1e-2, Adam/AdamW=1e-3)
lrf: 0.01 # (float) final LR fraction; final LR = lr0 * lrf
momentum: 0.937 # (float) SGD momentum or Adam beta1
weight_decay: 0.0005 # (float) weight decay (L2 regularization)
warmup_epochs: 3.0 # (float) warmup epochs (fractions allowed)
warmup_momentum: 0.8 # (float) initial momentum during warmup
warmup_bias_lr: 0.1 # (float) bias learning rate during warmup
box: 7.5 # (float) box loss gain
cls: 0.5 # (float) classification loss gain
dfl: 1.5 # (float) distribution focal loss gain
pose: 12.0 # (float) pose loss gain (pose tasks)
kobj: 1.0 # (float) keypoint objectness loss gain (pose tasks)
rle: 1.0 # (float) rle loss gain (pose tasks)
angle: 1.0 # (float) oriented angle loss gain (obb tasks)
nbs: 64 # (int) nominal batch size used for loss normalization
hsv_h: 0.015 # (float) HSV hue augmentation fraction
hsv_s: 0.7 # (float) HSV saturation augmentation fraction
hsv_v: 0.4 # (float) HSV value (brightness) augmentation fraction
degrees: 0.0 # (float) rotation degrees (+/-)
translate: 0.1 # (float) translation fraction (+/-)
scale: 0.5 # (float) scale gain (+/-)
shear: 0.0 # (float) shear degrees (+/-)
perspective: 0.0 # (float) perspective fraction (0–0.001 typical)
flipud: 0.0 # (float) vertical flip probability
fliplr: 0.5 # (float) horizontal flip probability
bgr: 0.0 # (float) RGB↔BGR channel swap probability
mosaic: 1.0 # (float) mosaic augmentation probability
mixup: 0.0 # (float) MixUp augmentation probability
cutmix: 0.0 # (float) CutMix augmentation probability
copy_paste: 0.0 # (float) segmentation copy-paste probability
copy_paste_mode: flip # (str) copy-paste strategy for segmentation: flip or mixup
auto_augment: randaugment # (str) classification auto augmentation policy: randaugment, autoaugment, augmix
erasing: 0.4 # (float) random erasing probability for classification (0–0.9), <1.0

# Custom config.yaml ---------------------------------------------------------------------------------------------------
cfg: # (str, optional) path to a config.yaml that overrides defaults

# Tracker settings ------------------------------------------------------------------------------------------------------
tracker: botsort.yaml # (str) tracker config file: botsort.yaml or bytetrack.yaml
  1. 训练设置
    YOLO 模型的训练设置包括影响模型性能、速度和准确性的超参数和配置。 关键设置包括批量大小、学习率、动量和权重衰减。 优化器、损失函数和数据集组成的选定也会影响训练。 调整和实验对于获得最佳性能至关重要。
参数 类型 默认值 描述
model str None 指定用于训练的模型文件。接受指向 .pt 预训练模型或 .yaml 配置文件的路径。对于定义模型结构或初始化权重至关重要。
data str None 数据集配置文件的路径（例如， coco8.yaml）。此文件包含数据集特定的参数，包括训练和验证数据的路径，类别名称和类别数量。
epochs int 100 训练的总轮数。每个epoch代表对整个数据集的一次完整遍历。调整此值会影响训练时长和模型性能。
time float None 最长训练时间（以小时为单位）。如果设置此参数，它将覆盖 epochs 参数，允许训练在指定时长后自动停止。适用于时间受限的训练场景。
patience int 100 在验证指标没有改善的情况下，等待多少个epoch后提前停止训练。通过在性能停滞时停止训练，有助于防止过拟合。
batch int 或 float 16 批次大小，具有三种模式：设置为整数（例如， batch=16），自动模式，GPU 内存利用率为 60%（batch=-1），或具有指定利用率分数的自动模式（batch=0.70）。
imgsz int 640 用于训练的目标图像大小。图像被调整为边长等于指定值的正方形（如果 rect=False），为 YOLO 模型保留宽高比，但不为 RT-DETR 保留。影响模型准确性和计算复杂度。
save bool True 启用保存训练检查点和最终模型权重。可用于恢复训练或模型部署。
save_period int -1 保存模型检查点的频率，以 epoch 为单位指定。值为 -1 时禁用此功能。适用于在长时间训练期间保存临时模型。
cache bool False 启用在内存中缓存数据集图像（True/ram），在磁盘上缓存（disk），或禁用缓存（False）。通过减少磁盘 I/O 来提高训练速度，但会增加内存使用量。
device int 或 str 或 list None 指定用于训练的计算设备：单个 GPU（device=0），多个 GPU（device=[0,1]），CPU（device=cpu），适用于 Apple 芯片的 MPS（device=mps），或自动选择最空闲的 GPU（device=-1）或多个空闲 GPU （device=[-1,-1])
workers int 8 用于数据加载的工作线程数（每个 RANK ，如果是多 GPU 训练）。影响数据预处理和输入模型的速度，在多 GPU 设置中尤其有用。
project str None 项目目录的名称，训练输出保存在此目录中。允许有组织地存储不同的实验。
name str None 训练运行的名称。用于在项目文件夹中创建一个子目录，训练日志和输出存储在该子目录中。
exist_ok bool False 如果为 True，则允许覆盖现有的 project/name 目录。适用于迭代实验，无需手动清除之前的输出。
pretrained bool 或 str True 确定是否从预训练模型开始训练。可以是一个布尔值，也可以是加载权重的特定模型的字符串路径。增强训练效率和模型性能。
optimizer str ‘auto’ 训练优化器的选择。选项包括 SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp或 auto 用于基于模型配置自动选择。影响收敛速度和稳定性。
seed int 0 设置训练的随机种子，确保在相同配置下运行结果的可重复性。
deterministic bool True 强制使用确定性算法，确保可重复性，但由于限制了非确定性算法，可能会影响性能和速度。
verbose bool True 在训练期间启用详细输出，在控制台中显示进度条、每 epoch 指标和额外的训练信息。
single_cls bool False 在多类别数据集中，将所有类别视为单个类别进行训练。适用于二元分类任务或侧重于对象是否存在而非分类时。
classes list[int] None 指定要训练的类 ID 列表。可用于在训练期间过滤掉并仅关注某些类。
rect bool False 启用最小填充策略——批量中的图像被最小程度地填充以达到一个共同的大小，最长边等于 imgsz。可以提高效率和速度，但可能会影响模型精度。
multi_scale float 0.0 随机变化 imgsz 每批次误差为± multi_scale （例如 0.25 -> 0.75x 到 1.25x)，四舍五入至模型步长倍数； 0.0 禁用多尺度训练。
cos_lr bool False 使用余弦学习率调度器，在 epochs 上按照余弦曲线调整学习率。有助于管理学习率，从而实现更好的收敛。
close_mosaic int 10 在最后 N 个 epochs 中禁用 mosaic 数据增强，以在完成前稳定训练。设置为 0 可禁用此功能。
resume bool False 从上次保存的检查点恢复训练。自动加载模型权重、优化器状态和 epoch 计数，无缝继续训练。
amp bool True 启用自动混合精度（AMP）训练，减少内存使用，并可能在对准确性影响最小的情况下加快训练速度。
fraction float 1.0 指定用于训练的数据集比例。允许在完整数据集的子集上进行训练，这在实验或资源有限时非常有用。
profile bool False 在训练期间启用 ONNX 和 TensorRT 速度的分析，有助于优化模型部署。
freeze int 或 list None 冻结模型的前 N 层或按索引指定的层，从而减少可训练参数的数量。适用于微调或迁移学习。
lr0 float 0.01 初始学习率（即 SGD=1E-2, Adam=1E-3)。调整此值对于优化过程至关重要，它会影响模型权重更新的速度。
lrf float 0.01 最终学习率作为初始速率的一部分 = (lr0 * lrf），与调度器结合使用以随时间调整学习率。
momentum float 0.937 SGD 的动量因子或 Adam 优化器的 beta1，影响当前更新中过去梯度的整合。
weight_decay float 0.0005 L2 正则化项，惩罚大权重以防止过拟合。
warmup_epochs float 3.0 学习率预热的 epochs 数，将学习率从低值逐渐增加到初始学习率，以在早期稳定训练。
warmup_momentum float 0.8 预热阶段的初始动量，在预热期间逐渐调整到设定的动量。
warmup_bias_lr float 0.1 预热阶段偏差参数的学习率，有助于稳定初始 epochs 中的模型训练。
box float 7.5 损失函数中框损失分量的权重，影响对准确预测边界框坐标的重视程度。
cls float 0.5 分类损失在总损失函数中的权重，影响正确类别预测相对于其他成分的重要性。
dfl float 1.5 分布焦点损失的权重，在某些 YOLO 版本中用于细粒度分类。
pose float 12.0 在为姿势估计训练的模型中，姿势损失的权重会影响对准确预测姿势关键点的强调。
kobj float 1.0 姿势估计模型中关键点对象性损失的权重，用于平衡检测置信度和姿势准确性。
rle float 1.0 姿势估计模型中残差对数似然估计损失的权重，影响关键点定位的精度。
angle float 1.0 obb模型中角度损失的权重，影响定向边界框角度预测的精度。
nbs int 64 用于损失归一化的标称批量大小。
overlap_mask bool True 确定是否应将对象掩码合并为单个掩码以进行训练，还是为每个对象保持分离。如果发生重叠，则在合并期间，较小的掩码会覆盖在较大的掩码之上。
mask_ratio int 4 分割掩码的下采样率，影响训练期间使用的掩码分辨率。
dropout float 0.0 分类任务中用于正则化的 Dropout 率，通过在训练期间随机省略单元来防止过拟合。
val bool True 在训练期间启用验证，从而可以定期评估模型在单独数据集上的性能。
plots bool True 生成并保存训练和验证指标的图表，以及预测示例，从而提供对模型性能和学习进度的可视化见解。
compile bool 或 str False 启用 PyTorch 2.x torch.compile 使用以下方式进行图形编译 backend=‘inductor’。接受 True → “default”, False → 禁用，或字符串模式，例如 “default”, “reduce-overhead”, “max-autotune-no-cudagraphs”。如果不支持，则会发出警告并回退到 Eager 模式。
max_det int 300 指定在训练的验证阶段保留的最大对象数量。

  1. 预测设置
    YOLO模型的预测设置包括影响推理过程中性能、速度和准确性的超参数和配置。关键设置包括置信度阈值、非极大值抑制 (NMS)阈值以及类别数量。输入数据的大小、格式以及掩码等辅助特征也会影响预测。调整这些设置对于实现最佳性能至关重要。
参数 类型 默认值 描述
source str ‘ultralytics/assets’ 指定推理的数据源。可以是图像路径、视频文件、目录、URL 或实时馈送的设备 ID。支持多种格式和来源，从而可以在不同类型的输入上灵活应用。
conf float 0.25 设置检测的最小置信度阈值。将忽略置信度低于此阈值的检测到的对象。调整此值有助于减少误报。
iou float 0.7 交并比（IoU）是用于非极大值抑制（NMS）的阈值。较低的值会通过消除重叠框来减少检测数量，这对于减少重复项很有用。
imgsz int 或 tuple 640 定义推理的图像大小。可以是一个整数 640 表示正方形调整大小，也可以是 (height, width) 元组。适当的大小调整可以提高检测准确性和处理速度。
rect bool True 如果启用，则对图像较短的一边进行最小填充，直到可以被步长整除，以提高推理速度。如果禁用，则在推理期间将图像填充为正方形。
half bool False 启用半精度 (FP16) 推理，这可以加快在支持的 GPU 上的模型推理速度，同时对准确性的影响极小。
device str None 指定用于推理的设备（例如， cpu, cuda:0 或 0）。允许用户在 CPU、特定 GPU 或其他计算设备之间进行选择，以执行模型。
batch int 1 指定推理的批处理大小（仅在源为以下情况时有效：一个目录、视频文件，或 .txt 文件）。更大的批处理大小可以提供更高的吞吐量，从而缩短推理所需的总时间。
max_det int 300 每张图像允许的最大 detect 数量。限制模型在单次推理中可以 detect 的对象总数，防止在密集场景中产生过多输出。
vid_stride int 1 视频输入的帧步长。允许跳过视频中的帧，以加快处理速度，但会降低时间分辨率。值为 1 时处理每一帧，值越高跳过的帧越多。
stream_buffer bool False 确定是否为视频流排队传入帧。如果 False，旧帧会被丢弃以适应新帧（针对实时应用进行了优化）。如果 True，在缓冲区中对新帧进行排队，确保不跳过任何帧，但如果推理 FPS 低于流 FPS，则会导致延迟。
visualize bool False 激活推理期间模型特征的可视化，从而深入了解模型正在“看到”的内容。这对于调试和模型解释非常有用。
augment bool False 启用测试时增强 (TTA) 进行预测，可能会提高检测的鲁棒性，但会降低推理速度。
agnostic_nms bool False 启用类别无关的非极大值抑制 (NMS)，它合并不同类别的重叠框。在类别重叠常见的多类别 detect 场景中非常有用。
classes list[int] None 将预测结果筛选到一组类别 ID。只会返回属于指定类别的检测结果。这对于专注于多类别检测任务中的相关对象非常有用。
retina_masks bool False 返回高分辨率分割掩码。返回的掩码（masks.data）如果启用，将与原始图像大小匹配。如果禁用，它们将具有推理期间使用的图像大小。
embed list[int] None 指定从中提取特征向量或 embeddings 的层。对于诸如聚类或相似性搜索之类的下游任务非常有用。
project str None 如果 save 已启用，则为保存预测输出的项目目录的名称。
name str None 预测运行的名称。用于在项目文件夹中创建一个子目录，如果 save 已启用，则为保存预测输出的项目目录的名称。
stream bool False 通过返回 Results 对象的生成器而不是一次将所有帧加载到内存中，从而为长视频或大量图像启用内存高效处理。
verbose bool True 控制是否在终端中显示详细的推理日志，从而提供有关预测过程的实时反馈。
compile bool 或 str False 启用 PyTorch 2.x torch.compile 使用以下方式进行图形编译 backend=‘inductor’。接受 True → “default”, False → 禁用，或字符串模式，例如 “default”, “reduce-overhead”, “max-autotune-no-cudagraphs”。如果不支持，则会发出警告并回退到 Eager 模式。
end2end bool None 覆盖支持NMS推理的YOLO （YOLO26、YOLOv10）中的端到端模式。将其设置为 False 允许您使用传统的NMS 进行预测，使您能够利用 iou 参数生成。

  1. 验证设置
    YOLO 模型的验证设置涉及超参数和配置，以评估 验证数据集 上的性能。这些设置会影响性能、速度和准确性。常用设置包括批量大小、验证频率和性能指标。验证数据集的大小和组成以及特定任务也会影响该过程。
参数 类型 默认值 描述
data str None 指定数据集配置文件（例如， coco8.yaml）。此文件应包含指向验证数据的路径。
imgsz int 640 定义输入图像的大小。所有图像在处理前都会调整为此尺寸。较大的尺寸可能会提高小目标的准确性，但会增加计算时间。
batch int 16 设置每个批次的图像数量。较高的值能更有效地利用 GPU 内存，但需要更多的 VRAM。根据可用的硬件资源进行调整。
save_json bool False 可视化参数： True，将结果保存到 JSON 文件中，以便进一步分析、与其他工具集成或提交到 COCO 等评估服务器。
conf float 0.001 设置检测的最小置信度阈值。较低的值会提高召回率，但也可能引入更多的假阳性。在验证期间用于计算精确率-召回率曲线。
iou float 0.7 设置交并比（Intersection Over Union）阈值，用于非极大值抑制（Non-Maximum Suppression）。控制重复检测的消除。
max_det int 300 限制每幏图像的最大检测数量。在密集场景中非常有用，可防止过度检测和管理计算资源。
half bool False 启用半精度 (FP16) 计算，从而减少内存使用量，并可能在对准确性影响最小的情况下提高速度。
device str None 指定验证的设备（cpu, cuda:0，等等）。当 None，自动选择最佳可用设备。多个 CUDA 设备可以用逗号分隔指定。
dnn bool False 可视化参数： True，使用 OpenCV DNN 模块进行 ONNX 模型推理，从而提供了一种替代 PyTorch 推理方法。
plots bool True 当设置为 True，生成并保存预测与真实值的对比图、混淆矩阵和 PR 曲线，以便对模型性能进行可视化评估。
classes list[int] None 指定要评估的类别 ID 列表。这对于在评估期间筛选并仅关注某些类别非常有用。
rect bool True 可视化参数： True，使用矩形推理进行批处理，减少填充，并通过以原始宽高比处理图像来潜在地提高速度和效率。
split str ‘val’ 确定用于验证的数据集分割（val, test或 train）。允许灵活选择数据段以进行性能评估。
project str None 用于保存验证输出的项目目录的名称。有助于组织来自不同实验或模型的结果。
name str None 验证运行的名称。用于在项目文件夹中创建一个子目录，用于存储验证日志和输出。
verbose bool True 可视化参数： True，在验证过程中显示详细信息，包括每个类别的指标、批次进度和其他调试信息。
save_txt bool False 可视化参数： True，将检测结果保存在文本文件中，每个图像对应一个文件，可用于进一步分析、自定义后处理或与其他系统集成。
save_conf bool False 可视化参数： True，在保存的文本文件中包含置信度值，当 save_txt 已启用，提供更详细的输出以供分析和过滤。
workers int 8 用于数据加载的工作线程数。较高的值可以加快数据预处理速度，但可能会增加 CPU 使用率。设置为 0 使用主线程，这在某些环境中可能更稳定。
augment bool False 启用测试时增强（TTA），通过对输入的转换版本运行推理，从而可能提高检测精度，但会牺牲推理速度。
agnostic_nms bool False 启用与类别无关的非极大值抑制，它合并重叠的框，而不管其预测的类别如何。对于以实例为中心的应用程序很有用。
single_cls bool False 在验证期间将所有类别视为单一类别。这对于评估二元检测任务中的模型性能或类别区分并不重要时非常有用。
visualize bool False 可视化每张图像的真值、真阳性、假阳性以及假阴性。有助于调试和模型解释。
compile bool 或 str False 启用 PyTorch 2.x torch.compile 使用以下方式进行图形编译 backend=‘inductor’。接受 True → “default”, False → 禁用，或字符串模式，例如 “default”, “reduce-overhead”, “max-autotune-no-cudagraphs”。如果不支持，则会发出警告并回退到 Eager 模式。
end2end bool None 覆盖支持NMS推理的YOLO （YOLO26、YOLOv10）中的端到端模式。将其设置为 False 允许您使用NMS 运行验证，从而能够利用 iou 参数生成。

6. 小结

我们再回顾一下 YOLO26 的安装与使用的基本步骤如下。

# 1. 安装 Anaconda、Pycharm

# 2. 创建 Python 环境
conda create -n YOLO26 python=3.8 -y

# 3. 激活环境
conda activate YOLO26

# 4. 安装 PyTorch（示例）
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu121

# 5. 安装 Ultralytics
pip install -U ultralytics

# 6. 下载预训练模型权重
wget https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26n.pt
wget https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26s-seg.pt #（示例）
wget https://github.com/ultralytics/assets/releases/download/v8.4.0/yolo26m-cls.pt #（示例）

本文详细介绍了YOLO26的完整安装配置流程与快速使用方法，内容涵盖从环境搭建到模型应用的各个环节。

通过本文的学习，读者可以独立完成YOLO26的安装配置，并运行基本的检测任务。在下一篇内容中，我们将进一步深入，介绍如何使用自己的数据集训练YOLO26模型，包括数据集准备、标注格式转换、配置文件修改以及训练过程的监控与优化。


【本节完】


版权声明：
转发必须注明原文链接：【跟我学YOLO】YOLO26（3）安装配置与快速使用(https://blog.csdn.net/youcans/article/details/157207305)
Copyright 2026 by youcans@Xidian
Crated：2026-01


在这里插入图片描述

# 目标检测 # 计算机视觉 # 图像处理
Logo
2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

cover

小白程序员必看：如何利用AI快速成为运动控制领域专家？

avatar 2048 AI社区
cover

Google Gemini 3.1 Pro大模型发布，复杂问题解决新基线！

avatar 2048 AI社区
cover

2026年02月20日热门论文

avatar 2048 AI社区