YOLOv8在Windows下训练模型的完整步骤

一、环境配置

1. 安装CUDA（如果尚未安装）

确保已安装与GPU兼容的CUDA版本
从NVIDIA官网下载并安装CUDA Toolkit

2. 创建并配置Python虚拟环境

# 创建虚拟环境
conda create -n yolov8 python=3.8 -y
# 激活虚拟环境
conda activate yolov8
# 安装PyTorch和Torchvision（推荐使用GPU版本）
# 可以参考：https://pytorch.org/get-started/locally/
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
# 安装Ultralytics库（包含YOLOv8）
pip install ultralytics

注意：安装时确保使用与CUDA版本兼容的PyTorch版本

二、数据集准备

1. 收集并标注图像

使用LabelImg等工具标注图像数据集
安装LabelImg（推荐使用国内源）：

pip install labelimg -i https://pypi.tuna.tsinghua.edu.cn/simple

2. 数据集格式要求

图片文件：放在images/train/、images/val/、images/test/文件夹中
标签文件：与图片同名的.txt文件，放在labels/train/、labels/val/、labels/test/中
每个标签文件格式：

坐标归一化到[0,1]范围
以空格分隔

重要：如果使用LabelImg标注，需要将XML格式转换为YOLO格式（可使用脚本转换）

3. 创建数据集配置文件（如mydata.yaml）

train: ./images/train/
val: ./images/val/
test: ./images/test/
nc: 3  # 类别数量
names: ['class_1', 'class_2', 'class_3']  # 类别名称

三、模型训练

1. 使用命令行训练（推荐）

yolo train data=mydata.yaml model=yolov8n.pt epochs=100 imgsz=640 batch=16 device=0

参数说明：

data: 数据集配置文件路径
model: 预训练模型（如yolov8n.pt）
epochs: 训练轮数
imgsz: 输入图像尺寸（640为常用值）
batch: 批次大小（根据GPU显存调整）
device: 运行设备（0表示GPU，'cpu'表示CPU）

2. 使用Python脚本训练（如果命令行有问题）

创建train.py文件，内容如下：

from ultralytics import YOLO
# 加载模型
model = YOLO('yolov8n.pt')
# 训练模型
model.train(
    data='mydata.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device=0
)

然后在虚拟环境中运行：

python train.py

四、模型测试

训练完成后，使用以下命令测试模型：

yolo predict model=runs/train/exp/weights/best.pt source='your_image.jpg'

或者使用Python脚本：

from ultralytics import YOLO
# 加载训练好的模型
model = YOLO('runs/train/exp/weights/best.pt')
# 进行预测
results = model.predict('your_image.jpg', save=True)
# 查看结果
print(results)

五、常见问题解决

GPU无法使用：

确保CUDA版本与PyTorch兼容
在命令中指定device=0或device='cuda'

多线程问题：

如果遇到报错，尝试将训练代码放在if __name__ == '__main__':中

路径问题：

Windows路径使用正斜杠/或双反斜杠\\
示例：data='C:/datasets/mydata.yaml'

显存不足：

减小batch参数（如改为8或4）
降低imgsz（如改为416）

六、推荐工具

Roboflow：直接下载已标注数据集（https://universe.roboflow.com/）
Autodl云服务器：一键配置环境

重要提示：训练过程中，模型会自动保存在runs/train/exp/weights/目录下，其中best.pt是性能最好的模型。

YOLOv8n.pt 的获取方式

yolov8n.pt 不是 ultralytics 库安装后自带的，而是在首次使用时自动从互联网下载的。

详细说明：

安装 ultralytics 后不会自动下载模型文件：

pip install ultralytics 只会安装库本身
模型文件（如 yolov8n.pt）需要在首次使用时下载

YOLOv8现成标注好的数据集推荐

是的，YOLOv8有现成标注好的数据集，您可以直接使用开源数据集快速跑一个demo训练，无需自己标注数据。这里有一个现成的数据集推荐：

推荐数据集（直接可用）

链接：https://pan.quark.cn/s/17cbfbb4850c

这个数据集包含：

训练集（train）
验证集（val）
测试集（test）
配置文件（data.yaml）

重点：阿里云天池上有很多数据集

data.yaml格式介绍

train: ./train/images/
val: ./val/images/
test: ./test/images/
nc: 80  # 类别数量，需要根据实际数据集修改
names: ['class1', 'class2', 'class3', ...]  # 类别名称列表，需要根据实际数据集修改

如何确定类别数量和名称？

查看labels/train/目录下的txt文件，第一个数字就是类别ID
统计所有不同的类别ID，就是类别总数
例如，如果txt文件中只出现0、1、2，那么就是3个类别

使用示例

假设数据集有3个类别（person, car, bike），data.yaml内容应为：

yaml
编辑
train: ./train/images/
val: ./val/images/
test: ./test/images/
nc: 3
names: ['person', 'car', 'bike']

_annotations.coco.json 转成 yaml

例如，如果COCO JSON中的类别是：

"categories": [
  {"id": 0, "name": "person"},
  {"id": 1, "name": "car"},
  {"id": 2, "name": "bike"}
]

那么data.yaml应该是：

train: ./train/images/
val: ./val/images/
test: ./test/images/
nc: 3
names: ['person', 'car', 'bike']

"categories": [
        {
            "id": 0,
            "name": "animals",
            "supercategory": "none"
        },
        {
            "id": 1,
            "name": "cat",
            "supercategory": "animals"
        },
        {
            "id": 2,
            "name": "chicken",
            "supercategory": "animals"
        },
        {
            "id": 3,
            "name": "cow",
            "supercategory": "animals"
        },
        {
            "id": 4,
            "name": "dog",
            "supercategory": "animals"
        },
        {
            "id": 5,
            "name": "fox",
            "supercategory": "animals"
        },
        {
            "id": 6,
            "name": "goat",
            "supercategory": "animals"
        },
        {
            "id": 7,
            "name": "horse",
            "supercategory": "animals"
        },
        {
            "id": 8,
            "name": "person",
            "supercategory": "animals"
        },
        {
            "id": 9,
            "name": "racoon",
            "supercategory": "animals"
        },
        {
            "id": 10,
            "name": "skunk",
            "supercategory": "animals"
        }
    ],       _annotations.coco.json

_annotations.coco.json 中的 categories 信息，我将为您生成正确的 data.yaml 文件。需要特别注意：在目标检测中，我们只使用具体类别（如 "cat", "chicken"），而不是超类别 "animals"。

正确的 data.yaml 文件内容

train: ./train/images/
val: ./val/images/
test: ./test/images/
nc: 10  # 实际类别数量（10个具体类别，不包括超类别）
names: ['cat', 'chicken', 'cow', 'dog', 'fox', 'goat', 'horse', 'person', 'racoon', 'skunk']

详细说明

为什么 nc: 10 而不是 nc: 11？

COCO JSON 中有 11 个条目（包括超类别 "animals"）
但在目标检测中，超类别 "animals" 不是实际检测的类别，它只是类别分组
实际需要检测的类别是 10 个具体动物（id 1-10），所以 nc: 10

为什么 names 列表是这个顺序？

按照 COCO JSON 中的具体类别顺序（id 从 1 开始）：

id=1 → 'cat'
id=2 → 'chicken'
id=3 → 'cow'
... 以此类推

顺序必须与 COCO 中的 id 顺序一致

为什么排除 "animals"？

在标注文件中，实例的类别 ID 是具体类别（1-10），不会使用超类别 ID=0
例如：labels/train/0001.txt 中的类别 ID 会是 1（cat）而不是 0（animals）

验证步骤

检查一个标签文件：

打开 train/labels/0001.txt
确认第一列数字是 1-10 之间的值（例如 1 0.5 0.5 0.2 0.3）
不要是 0（因为超类别不会用于标注）

如果标签文件中出现 0：

这表示数据集使用了超类别
data.yaml 应该包含超类别：

nc: 11
names: ['animals', 'cat', 'chicken', 'cow', 'dog', 'fox', 'goat', 'horse', 'person', 'racoon', 'skunk']

但这种情况很少见，通常标注不会用超类别 ID

为什么这个配置是正确的？

COCO JSON 中的类别	是否实际检测	在 data.yaml 中	对应的 YOLO 标签 ID
animals (id=0)	❌ 不检测	不包含	不使用
cat (id=1)	✅ 检测	`names[0]`	0
chicken (id=2)	✅ 检测	`names[1]`	1
...	✅ 检测	...	...
skunk (id=10)	✅ 检测	`names[9]`	9

重要提示：在 YOLO 格式的标签文件中，类别 ID 是 0-9（对应 names 数组的索引），而不是 COCO 的 ID（1-10）。当您转换 COCO 标注到 YOLO 时，需要将 COCO ID 减 1（例如 COCO ID=1 → YOLO ID=0）。

YOLOv8训练指标详解

Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     89/100         0G     0.2285      0.285     0.8687         39        640: 100% ━━━━━━━━━━━━ 15/15 0.5it/s 27.9s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.0s
                   all         34         73      0.986      0.996      0.995      0.982
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     90/100         0G     0.2473     0.3071     0.8923         27        640: 100% ━━━━━━━━━━━━ 15/15 0.5it/s 29.0s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 0.9it/s 3.2s
                   all         34         73      0.985      0.986      0.995      0.981
Closing dataloader mosaic
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     91/100         0G     0.1395     0.2239     0.8099         16        640: 100% ━━━━━━━━━━━━ 15/15 0.5it/s 29.0s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.0s
                   all         34         73      0.986      0.986      0.995      0.983
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     92/100         0G     0.1447     0.2113     0.7987         14        640: 100% ━━━━━━━━━━━━ 15/15 0.6it/s 26.7s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.0s
                   all         34         73      0.985      0.986      0.994       0.98
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     93/100         0G     0.1417     0.2188     0.7837         14        640: 100% ━━━━━━━━━━━━ 15/15 0.6it/s 26.7s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.0s
                   all         34         73      0.973      0.998      0.995      0.977
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     94/100         0G     0.1402     0.2163     0.7834         14        640: 100% ━━━━━━━━━━━━ 15/15 0.6it/s 27.1s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.1s
                   all         34         73      0.973      0.998      0.995      0.978
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     95/100         0G     0.1381      0.217     0.7948         13        640: 100% ━━━━━━━━━━━━ 15/15 0.5it/s 29.7s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.1s
                   all         34         73      0.983      0.986      0.994      0.978
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     96/100         0G     0.1343     0.2164     0.7933         14        640: 100% ━━━━━━━━━━━━ 15/15 0.5it/s 29.0s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.0s
                   all         34         73      0.986      0.985      0.994      0.977
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     97/100         0G     0.1323     0.2146     0.7962         18        640: 100% ━━━━━━━━━━━━ 15/15 0.5it/s 27.4s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.1s
                   all         34         73      0.986      0.986      0.994       0.98
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     98/100         0G     0.1293      0.208     0.7907         13        640: 100% ━━━━━━━━━━━━ 15/15 0.5it/s 27.5s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.0s
                   all         34         73      0.986      0.984      0.994      0.983
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
     99/100         0G      0.124      0.199     0.7875         14        640: 100% ━━━━━━━━━━━━ 15/15 0.6it/s 26.7s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.0s
                   all         34         73      0.973      0.999      0.994      0.982
      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
    100/100         0G       0.13     0.1998     0.7924         12        640: 100% ━━━━━━━━━━━━ 15/15 0.5it/s 28.3s
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.0it/s 3.1s
                   all         34         73      0.986      0.985      0.994      0.981

从训练输出来看，这是一个训练效果非常好的模型。下面详细解释每一列的含义：

损失函数指标（越小越好）

box_loss (边界框损失)

衡量预测边界框与真实边界框之间的位置差异
值越小表示预测的边界框位置越准确
数据中在0.24-0.27之间，且呈下降趋势，说明模型在学习更准确的边界框位置

cls_loss (分类损失)

衡量预测类别与真实类别的差异
值越小表示分类越准确
数据中在0.29-0.32之间，也在逐渐减小

dfl_loss (Distribution Focal Loss，分布焦点损失)

YOLOv8特有的损失函数，用于优化边界框的尺寸预测
越小表示边界框尺寸预测越准确
数据在0.89-0.92之间，且在逐渐减小

模型评估指标（越大越好）

Box(P) (Precision，精度)

衡量预测为正例的样本中，真正为正例的比例
数据中接近1.0，表示预测的"狗"非常准确，几乎没有误报

R (Recall，召回率)

衡量所有正例中，被正确预测为正例的比例
数据中在0.96-0.998之间，表示模型几乎能检测到所有狗

mAP50 (IoU=0.5时的平均精度)

衡量模型在IoU阈值为0.5时的精度
数据在0.985-0.995之间，非常高

mAP50-95 (IoU从0.5到0.95的平均精度)

衡量模型在不同IoU阈值下的平均精度
数据在0.98-0.985之间，表示模型在不同精度要求下都表现优异

其他指标

Instances (实例数量)

每个epoch中检测到的目标数量
数据在23-36之间，表示每个epoch检测到的狗数量

Size (图像尺寸)

输入到模型的图像尺寸
数据是640，表示输入图像被缩放到640x640

为什么这些指标表现这么好？

从训练输出可以看出：

损失值(box_loss、cls_loss、dfl_loss)在逐渐减小
评估指标(Box(P)、R、mAP)在接近1.0
这表明模型训练得非常成功

YOLOv8训练结果解读

100 epochs completed in 0.872 hours.
Optimizer stripped from D:\dev_git\yancao_detect\runs\train\exp\weights\last.pt, 6.3MB
Optimizer stripped from D:\dev_git\yancao_detect\runs\train\exp\weights\best.pt, 6.3MB
Validating D:\dev_git\yancao_detect\runs\train\exp\weights\best.pt...
Ultralytics 8.3.203  Python-3.11.13 torch-2.8.0+cpu CPU (AMD Ryzen 7 5700X 8-Core Processor)
Model summary (fused): 72 layers, 3,005,843 parameters, 0 gradients, 8.1 GFLOPs
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 1.1it/s 2.8s
                   all         34         73      0.979      0.973      0.994      0.986
Speed: 2.1ms preprocess, 70.4ms inference, 0.0ms loss, 0.5ms postprocess per image
Results saved to D:\dev_git\yancao_detect\runs\train\exp

从上面训练结果来看，这是一个表现非常出色的模型。让我逐一解释关键指标：

核心指标（验证集上）

指标	值	含义	评价
Box(P) 精确率	0.979 (97.9%)	预测为"目标"的样本中，真正是目标的比例	极佳，意味着模型很少误报（把非目标当成目标）
R 召回率	0.973 (97.3%)	所有真实目标中，被正确识别的比例	极佳，意味着模型几乎能检测到所有目标
mAP50	0.994 (99.4%)	IoU=0.5时的平均精度	非常优秀，表示边界框与真实框重合50%以上时的准确率
mAP50-95	0.986 (98.6%)	IoU从0.5到0.95的平均精度	非常优秀，表示在不同精度要求下都保持高准确率

简单解释：mAP50-95是YOLO模型最重要的评估指标，它综合考虑了不同精度要求下的表现。值越高，模型越优秀。

模型速度

预处理: 2.1ms
推理: 70.4ms
后处理: 0.5ms
总耗时: 73ms/图像

这在CPU上运行是非常快的，意味着模型可以实时处理视频流。

模型规模

72层
3,005,843个参数
8.1 GFLOPs

这是一个轻量级模型，适合部署在资源有限的设备上。

为什么这个结果非常好？

mAP50-95达到98.6%："当重合部分除以两个总框总面积达到50%的时候，准确率达到70%-80%了，也很不错了"，而模型达到了99.4%的mAP50和98.6%的mAP50-95，远超行业平均水平。
精确率和召回率都接近98%：这表明模型既很少漏检（召回率高），又很少误检（精确率高），这是目标检测模型的黄金标准。
数据集小但效果好：验证集只有34张图像，73个实例，这么小的数据集能取得如此高的准确率，说明数据质量很高，标注也很准确。

打开 runs/train/exp/ 目录。可以看到很多文件

进阶：Windows 上使用 GPU 训练 YOLOv8 的完整指南

前提条件

NVIDIA 显卡：需要有 NVIDIA 显卡（如 RTX 系列）
最新 NVIDIA 驱动：确保驱动已更新到最新版本

步骤 1: 检查并更新 NVIDIA 驱动

检查当前驱动和 CUDA 版本：

在 Windows 搜索栏输入 nvidia-smi 并运行
查看 "CUDA Version"（例如：CUDA 12.4）

更新 NVIDIA 驱动：

访问 NVIDIA 驱动下载页面
选择显卡型号，下载并安装最新驱动
安装完成后重启电脑

重要提示：Windows 上的 NVIDIA 驱动更新是 GPU 训练的基础。

步骤 2: 安装 GPU 版本的 PyTorch

正确安装命令（Windows 专用）

# 先卸载当前 CPU 版本（避免冲突）
pip uninstall -y torch torchvision torchaudio
# 安装 GPU 版本（根据CUDA 版本选择）
# 例如：CUDA 12.4 -> cu124
pip install torch==2.8.0 torchvision==0.13.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu124

关键点：

使用 --index-url 指向 PyTorch 官方仓库，不要使用阿里云镜像
cu124 代表 CUDA 12.4，请根据 nvidia-smi 结果修改

验证安装

python -c "import torch; print(torch.__version__, torch.cuda.is_available())"

正确输出：2.8.0 True

错误输出：2.8.0 False → 说明安装失败

成功跑通

100 epochs completed in 0.082 hours.
Optimizer stripped from D:\dev_git\yancao_detect\runs\train\exp6\weights\last.pt, 6.3MB
Optimizer stripped from D:\dev_git\yancao_detect\runs\train\exp6\weights\best.pt, 6.3MB
Validating D:\dev_git\yancao_detect\runs\train\exp6\weights\best.pt...
Ultralytics 8.3.203  Python-3.11.13 torch-2.8.0+cu126 CUDA:0 (NVIDIA GeForce RTX 2080 Ti, 22528MiB)
Model summary (fused): 72 layers, 3,005,843 parameters, 0 gradients, 8.1 GFLOPs
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 3/3 5.9it/s 0.5s
                   all         34         73       0.99      0.973      0.994      0.987
Speed: 0.3ms preprocess, 2.8ms inference, 0.0ms loss, 1.0ms postprocess per image
Results saved to D:\dev_git\yancao_detect\runs\train\exp6

用GPU训练，耗时 5分钟。用CPU 训练，耗时 53分钟。效率提升10倍。

完整教程：从0到1在Windows下训练YOLOv8模型