最近在尝试将YOLO目标检测模型集成到自己的项目中时，你是否也遇到了这些难题：环境配置报错不断，依赖冲突让人头大；好不容易跑通官方Demo，却不知道如何用自己的图片进行推理；想训练自己的数据集，面对数据标注、格式转换、训练脚本修改等一系列步骤感到无从下手？网上的资料要么过于零散，不成体系，要么版本老旧，代码无法运行。

本文正是为了解决这些问题而生。我将为你梳理一套从零开始、闭环完整的YOLO实战入门路径，重点聚焦于 YOLOv8 这一当前最活跃、生态最完善的版本。无论你是刚接触深度学习的学生，还是希望快速在业务中应用目标检测的开发者，都能从本文中找到可复现的代码、清晰的配置说明以及避坑指南。我们将覆盖 环境安装与验证、使用预训练模型进行图片/视频推理、制作自定义数据集、训练专属模型 这四大核心环节，带你真正“跑通”YOLO，从入门到实战。

1. YOLO与目标检测核心概念

在开始动手之前，我们有必要厘清几个核心概念，这能帮助你更好地理解后续每一步操作的意义。

目标检测（Object Detection） 是计算机视觉中的一项基础任务，其目标不仅仅是识别出图像中有哪些物体（分类），还要精确地找出它们的位置（定位）。通常用 边界框（Bounding Box） 来标示位置，并给出对应的类别标签和置信度。

YOLO（You Only Look Once） 是一种经典且流行的目标检测算法。它的核心思想是“只看一次”：将输入图像划分为S×S的网格，每个网格负责预测中心点落在该网格内的物体。这种单阶段（One-Stage）的设计，使其在速度和精度之间取得了很好的平衡，特别适合实时检测场景。

YOLOv8 是Ultralytics公司发布的最新版本（截至当前主流应用），并非官方YOLO系列的第八代，但它集成了此前YOLOv5的易用性和YOLOX、YOLOv6等版本的先进技术，提供了更统一的API、更丰富的任务支持（检测、分割、分类、姿态估计）以及更完善的生态工具。对于初学者和工程落地而言，YOLOv8是目前最推荐的选择。

几个关键术语：

  • 预训练模型（Pre-trained Model） ：在大型通用数据集（如COCO）上训练好的模型，我们可以直接拿来用，进行推理。
  • 推理（Inference） ：使用训练好的模型对新的输入（图片、视频）进行预测的过程。
  • 自定义数据集（Custom Dataset） ：针对特定任务（如检测某种零件、特定动物）收集和标注的图片集合。
  • 训练（Training） ：使用自定义数据集，让模型学习识别新类别的过程，通常基于预训练模型进行微调（Fine-tuning），以加快收敛、提升效果。

接下来，我们将从最基础的环境搭建开始，一步步深入。

2. 环境准备与版本说明

一个干净、版本匹配的环境是成功的第一步。为了避免后续各种诡异的报错，请严格按照本节步骤操作。

2.1 基础软件环境

  • 操作系统 ：Windows 10/11, Ubuntu 18.04/20.04/22.04, 或 macOS。本文示例以 Windows 为主，Linux/macOS命令会附带说明。
  • Python ：推荐使用 Python 3.8 或 3.9 。Python 3.10+可能存在某些包兼容性问题。请确保已安装，并在终端使用 python --version 或 python3 --version 确认。
  • 包管理工具 ：使用 pip 。建议升级到最新版： pip install --upgrade pip 。
  • IDE/编辑器 ：VS Code, PyCharm, Jupyter Notebook 均可。选择你熟悉的即可。
  • CUDA与cuDNN（可选，但强烈推荐） ：如果你有NVIDIA显卡并希望使用GPU加速训练和推理，必须安装CUDA和cuDNN。YOLOv8官方推荐CUDA 11.8。你可以通过 nvidia-smi 命令查看显卡驱动支持的CUDA最高版本。对于大多数RTX系列显卡，安装CUDA 11.8是安全的选择。cuDNN需要从NVIDIA开发者网站下载对应版本。

重要提示 ：本文后续代码和命令将同时考虑 CPU 和 GPU 环境。如果你的环境没有GPU，所有操作依然可以完成，只是速度会慢很多。

2.2 创建虚拟环境

使用虚拟环境可以隔离项目依赖，避免污染系统Python环境。这是Python开发的最佳实践。

# 打开终端（Windows CMD/PowerShell, Linux/macOS Terminal）
# 1. 安装虚拟环境工具（如果未安装）
pip install virtualenv

# 2. 为YOLO项目创建一个新的虚拟环境，命名为 `yolo_env`
# Windows
python -m venv yolo_env
# Linux/macOS
python3 -m venv yolo_env

# 3. 激活虚拟环境
# Windows (CMD)
yolo_env\Scripts\activate
# Windows (PowerShell)
.\yolo_env\Scripts\Activate.ps1
# Linux/macOS
source yolo_env/bin/activate

# 激活后，命令行提示符前通常会显示 `(yolo_env)`，表示你已进入该环境。

2.3 安装YOLOv8

在激活的虚拟环境中，安装Ultralytics包，它包含了YOLOv8。

# 安装ultralytics，这将自动安装PyTorch、torchvision等核心依赖
pip install ultralytics

# 验证安装
python -c “from ultralytics import YOLO; print(‘YOLOv8安装成功！’)”

如果上述命令执行成功，输出“YOLOv8安装成功！”，则基础环境准备就绪。

关于PyTorch的特别说明 ： pip install ultralytics 会自动安装一个兼容的CPU版本PyTorch。 如果你有GPU并已配置好CUDA，需要卸载这个自动安装的PyTorch，然后安装对应CUDA版本的PyTorch。 

# 1. 卸载现有torch
pip uninstall torch torchvision torchaudio -y

# 2. 访问PyTorch官网 (https://pytorch.org/get-started/locally/) 获取安装命令。
# 例如，对于CUDA 11.8，命令通常是：
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
# 或者使用官方推荐的稳定命令（请以官网为准）
# pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 3. 验证GPU是否可用
python -c “import torch; print(f‘PyTorch版本: {torch.__version__}’); print(f‘CUDA是否可用: {torch.cuda.is_available()}’); if torch.cuda.is_available(): print(f‘GPU设备: {torch.cuda.get_device_name(0)}’)”

如果输出显示 CUDA是否可用: True 并打印出你的GPU型号，恭喜你，GPU环境配置成功！

3. 使用预训练模型进行推理

环境搞定后，我们立刻来体验YOLOv8的强大。使用官方在COCO数据集上预训练的模型，我们可以检测80种常见物体。

3.1 图片推理

创建一个Python脚本，例如 inference_image.py 。

# inference_image.py
from ultralytics import YOLO
import cv2

# 1. 加载预训练模型（这里使用YOLOv8n，是nano版本，体积小速度快，适合演示）
# 模型会自动从Ultralytics服务器下载，保存到本地缓存中
model = YOLO(‘yolov8n.pt’) # 你也可以尝试 ‘yolov8s.pt‘, ’yolov8m.pt‘ 等更大模型

# 2. 指定要检测的图片路径
image_path = ‘./path/to/your/image.jpg’ # 请替换为你的图片路径
# 例如，你可以放一张包含人、狗、汽车的图片在项目根目录，命名为 test.jpg
# image_path = ‘test.jpg’

# 3. 进行推理
# `conf`参数是置信度阈值，低于此值的检测框将被过滤掉
results = model(image_path, conf=0.5)

# 4. 可视化结果并保存
for r in results:
    # 使用OpenCV读取原始图片
    im_array = r.plot() # 这个plot()方法返回一个绘制了检测框的BGR图像数组
    # 将BGR转换为RGB（如果要用matplotlib显示则需要，用OpenCV保存则不需要）
    # im_rgb = cv2.cvtColor(im_array, cv2.COLOR_BGR2RGB)
    
    # 保存结果图片
    output_path = ‘./output/result.jpg’ # 指定输出路径
    cv2.imwrite(output_path, im_array)
    print(f“检测结果已保存至: {output_path}”)

    # 你也可以在窗口中显示（运行脚本的机器需要有图形界面）
    # cv2.imshow(‘YOLOv8 Detection’, im_array)
    # cv2.waitKey(0)
    # cv2.destroyAllWindows()

# 5. 打印检测到的目标信息
for r in results:
    boxes = r.boxes
    for box in boxes:
        # 获取坐标、置信度、类别ID
        x1, y1, x2, y2 = box.xyxy[0].tolist() # 左上右下坐标
        confidence = box.conf[0].item()
        class_id = int(box.cls[0].item())
        class_name = model.names[class_id]
        print(f“检测到: {class_name}, 置信度: {confidence:.2f}, 位置: [{x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f}]”)

运行这个脚本前，请确保在项目目录下创建了 output 文件夹，或者修改 output_path 到一个已存在的路径。运行后，你会在输出目录看到画有检测框的图片，并在终端看到详细的检测信息。

3.2 视频推理与实时摄像头检测

YOLO的实时性在视频流上表现尤为出色。

# inference_video.py
from ultralytics import YOLO
import cv2

model = YOLO(‘yolov8n.pt’)

# 方式一：处理视频文件
video_path = ‘./path/to/your/video.mp4’
cap = cv2.VideoCapture(video_path)

# 获取视频属性，用于创建输出视频
frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))
output_video_path = ‘./output/video_result.mp4’
# 定义编码器并创建VideoWriter对象
fourcc = cv2.VideoWriter_fourcc(*‘mp4v’)
out = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    
    # 对每一帧进行推理
    results = model(frame, conf=0.5, verbose=False) # verbose=False关闭冗余日志
    
    # 绘制检测框
    annotated_frame = results[0].plot()
    
    # 写入输出视频
    out.write(annotated_frame)
    
    # 实时显示（按‘q’退出）
    cv2.imshow(‘YOLOv8 Video Detection’, annotated_frame)
    if cv2.waitKey(1) & 0xFF == ord(‘q’):
        break

cap.release()
out.release()
cv2.destroyAllWindows()
print(f“视频处理完成，结果保存至: {output_video_path}”)

# 方式二：调用摄像头进行实时检测（注释掉方式一的代码，取消下面代码的注释）
"""
cap = cv2.VideoCapture(0) # 0 表示默认摄像头
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
    results = model(frame, conf=0.5, verbose=False)
    annotated_frame = results[0].plot()
    cv2.imshow(‘YOLOv8 Live Detection’, annotated_frame)
    if cv2.waitKey(1) & 0xFF == ord(‘q’):
        break
cap.release()
cv2.destroyAllWindows()
"""

通过以上代码，你已经掌握了使用YOLOv8进行推理的核心方法。接下来，我们将进入更核心的环节：训练自己的模型。

4. 准备自定义数据集

训练自己的模型，数据是根本。你需要收集图片，并进行标注。标注的格式有多种，YOLOv8推荐使用 YOLO格式 （一个 .txt 文件对应一张图片）。

4.1 数据集目录结构

一个规范的YOLO数据集目录应如下所示：

custom_dataset/
├── images/
│   ├── train/           # 训练集图片
│   │   ├── image1.jpg
│   │   ├── image2.jpg
│   │   └── ...
│   └── val/             # 验证集图片
│       ├── image101.jpg
│       ├── image102.jpg
│       └── ...
└── labels/
    ├── train/           # 训练集标签
    │   ├── image1.txt
    │   ├── image2.txt
    │   └── ...
    └── val/             # 验证集标签
        ├── image101.txt
        ├── image102.txt
        └── ...

划分建议 ：通常按 8:2 或 7:3 的比例随机划分训练集和验证集。

4.2 数据标注与标签格式

你需要使用标注工具，如 LabelImg , CVAT , Roboflow 等。这里以LabelImg为例。

  1. 安装LabelImg : pip install labelImg ，然后运行 labelImg 启动。
  2. 标注 ：打开图片，用矩形框画出目标，选择类别。 保存格式务必选择YOLO 。这会为每张图片生成一个同名的 .txt 文件。
  3. 理解YOLO标签格式 ：每个 .txt 文件可能包含多行，每一行代表一个目标物体，格式为： 
    <class_id> <x_center> <y_center> <width> <height>
    • class_id : 类别的整数索引，从0开始。
    • x_center, y_center : 边界框中心点的x、y坐标， 归一化 到 [0, 1]（即除以图片宽度和高度）。
    • width, height : 边界框的宽度和高度，同样归一化到 [0, 1]。

示例 ：一张500x400的图片中，有一个目标，类别ID为0（比如“cat”），其边界框左上角为(100, 120)，右下角为(300, 350)。则计算如下：

  • x_center = (100 + 300)/2 / 500 = 0.4
  • y_center = (120 + 350)/2 / 400 = 0.5875
  • width = (300 - 100) / 500 = 0.4
  • height = (350 - 120) / 400 = 0.575 对应的标签行即为： 0 0.4 0.5875 0.4 0.575

4.3 创建数据集配置文件

为了让YOLOv8知道你的数据在哪里、有哪些类别，需要创建一个数据集配置文件（如 custom_data.yaml ）。

# custom_data.yaml
# 数据集根目录路径（可以是绝对路径，也可以是相对于训练脚本的相对路径）
path: ./custom_dataset
# 训练集和验证集的图片目录（相对于`path`）
train: images/train
val: images/val

# 类别数量
nc: 2  # 假设你有2个类别，比如 ‘cat‘ 和 ’dog‘

# 类别名称列表，顺序必须与标注时的 class_id 对应
names: [‘cat’, ‘dog’]

将这个YAML文件放在你的项目根目录。至此，数据集准备完毕。

5. 训练自定义模型

有了数据集和配置文件，训练就变得非常简单。YOLOv8提供了极其简洁的API。

5.1 基础训练脚本

创建一个 train.py 文件。

# train.py
from ultralytics import YOLO

# 1. 加载一个预训练模型作为起点（微调）
# 使用 ‘yolov8n.pt‘ 作为基础模型，它会根据你的数据集调整输出层。
model = YOLO(‘yolov8n.pt’)

# 2. 开始训练
results = model.train(
    data=‘./custom_data.yaml’, # 数据集配置文件路径
    epochs=100,                # 训练轮数，根据数据集大小调整，小数据集可以少一些
    imgsz=640,                 # 输入图片的大小，必须是32的倍数
    batch=16,                  # 批大小，根据GPU内存调整 (16, 32, 64...)
    device=‘cuda’,             # 使用GPU训练，如果是CPU则改为 ‘cpu‘
    workers=4,                 # 数据加载的线程数
    project=‘runs/train’,      # 训练结果保存的根目录
    name=‘exp’,                # 实验名称，会在project下生成一个以name命名的文件夹
    exist_ok=True,             # 允许覆盖已有的实验目录
    pretrained=True,           # 使用预训练权重
    optimizer=‘auto’,          # 优化器，可选 ‘SGD‘, ’Adam‘, ’AdamW‘, ’auto‘
    lr0=0.01,                  # 初始学习率
    lrf=0.01,                  # 最终学习率因子 (lr0 * lrf)
    momentum=0.937,            # SGD动量
    weight_decay=0.0005,       # 权重衰减
    warmup_epochs=3.0,         # 热身轮数
    box=7.5,                   # 边界框损失权重
    cls=0.5,                   # 分类损失权重
    dfl=1.5,                   # DFL损失权重
    save=True,                 # 保存训练检查点和最终模型
    save_period=-1,            # 每N轮保存一次检查点（-1表示只在最后保存）
    cache=False,               # 是否缓存数据集到内存/磁盘以加速训练
    verbose=True,              # 打印训练日志
)

运行 python train.py ，训练就会开始。你会在终端看到详细的训练日志，包括损失值、评估指标等。

5.2 理解训练输出与结果

训练开始后，会在 runs/train/exp/ 目录下生成一系列文件和文件夹：

  • weights/ : 包含 best.pt （最佳模型）和 last.pt （最后一轮模型）。
  • args.yaml : 本次训练的所有参数配置。
  • results.csv / results.png : 训练过程中的指标曲线（损失、mAP等）。
  • confusion_matrix.png : 混淆矩阵。
  • val_batchX_labels.jpg / val_batchX_pred.jpg : 验证集的标签和预测结果可视化。

关键指标解读 ：

  • box_loss , cls_loss , dfl_loss : 各项损失，应随着训练轮数增加而下降。
  • metrics/mAP50(B) : 在IoU阈值为0.5时的平均精度（mean Average Precision），是衡量检测精度的核心指标，越高越好。
  • metrics/mAP50-95(B) : 在IoU阈值从0.5到0.95（步长0.05）的平均mAP，是更严格的指标。

训练完成后，你就可以使用训练得到的最佳模型 best.pt 像之前使用预训练模型一样进行推理了！

# 使用自定义训练好的模型进行推理
from ultralytics import YOLO
custom_model = YOLO(‘./runs/train/exp/weights/best.pt’)
results = custom_model(‘your_test_image.jpg’, conf=0.5)

6. 常见问题与排查思路

在实际操作中，你可能会遇到以下问题。这里提供一个快速排查指南。

问题现象 可能原因 解决思路
ModuleNotFoundError: No module named ‘ultralytics’ 未安装 ultralytics 包，或未在正确的虚拟环境中。 1. 确认虚拟环境已激活 ( (yolo_env) 在命令行前)。
2. 重新运行 pip install ultralytics 。
CUDA out of memory GPU内存不足。 1. 减小 batch-size 参数。
2. 减小 imgsz （如图片尺寸）。
3. 关闭其他占用GPU的程序。
4. 使用更小的模型（如 yolov8n 而非 yolov8m ）。
训练时损失 nan 学习率过高、数据有问题（如标签格式错误）。 1. 大幅降低学习率 lr0 （如设为0.001）。
2. 仔细检查数据集YAML文件路径和标签文件格式。
3. 确保图片能正常打开，标签坐标在[0,1]范围内。
RuntimeError: Expected all tensors to be on the same device 模型和数据不在同一个设备（CPU/GPU）。 1. 检查 model.to(device) 和 data.to(device) 是否一致。
2. 在训练或推理时，通过 model = YOLO(‘xx.pt’).to(‘cuda’) 指定设备，或使用 device=‘cuda’ 参数。
模型检测不到目标或精度极低 数据集量太少、类别不平衡、训练轮数不足、数据标注质量差。 1. 增加训练数据，至少每个类别数百张图片。
2. 检查验证集上的预测图片 ( val_batchX_pred.jpg )，看模型学到了什么。
3. 增加 epochs 。
4. 复查并修正错误标注。
推理速度非常慢（CPU环境） 在CPU上运行大模型。 1. 使用最小的模型 yolov8n.pt 。
2. 减小推理图片尺寸 ( imgsz )。
3. 考虑升级硬件或使用云GPU服务。
FileNotFoundError: [Errno 2] No such file or directory: ‘xxx.yaml’ 数据集配置文件路径错误。 1. 使用绝对路径。
2. 检查YAML文件中的 path , train , val 路径是否正确。

7. 最佳实践与工程建议

掌握了基础操作后，遵循一些最佳实践能让你的YOLO项目更加稳健和高效。

  1. 数据为王 ：

    • 数据质量 ：模糊、遮挡严重、光照极端的图片应尽量剔除或补充。标注要精确，框要紧贴目标。
    • 数据均衡 ：各个类别的图片数量不要相差太悬殊，否则模型会偏向数量多的类别。
    • 数据增强 ：YOLOv8训练时内置了丰富的数据增强（翻转、旋转、色彩抖动等）。你可以在 train() 参数中通过 hsv_h , hsv_s , hsv_v , degrees , translate , scale , shear 等参数进行控制。对于小数据集，增强尤为重要。

  2. 模型选择与超参数调优 ：

    • 模型尺寸 ：从 yolov8n (nano) 开始尝试。如果精度不够，再逐步换用 s , m , l , x 等更大模型，但代价是速度变慢、资源消耗增加。
    • 学习率 ： lr0 是最重要的超参数之一。太大容易震荡甚至发散（loss变成nan），太小收敛慢。可以从默认值（如0.01）开始，根据训练曲线调整。
    • 早停（Early Stopping） ：YOLOv8内置了早停机制 ( patience=50 )，如果验证集指标在指定轮数内没有提升，训练会自动停止，防止过拟合。你可以通过 patience 参数调整。

  3. 训练过程监控 ：

    • 务必关注 runs/train/exp/ 下的可视化结果。 results.png 中的损失曲线应平滑下降，mAP曲线应平滑上升。
    • 查看 val_batchX_pred.jpg ，直观感受模型在验证集上的检测效果，及早发现模型是否在学“错误”的东西。

  4. 模型导出与部署 ：

    • 训练完成后，你可能需要将PyTorch模型 ( *.pt ) 导出为其他格式以便在不同平台部署。
    from ultralytics import YOLO
model = YOLO(‘./runs/train/exp/weights/best.pt’)
# 导出为ONNX格式（广泛支持）
model.export(format=‘onnx’)
# 导出为TensorRT格式（NVIDIA GPU极致加速）
# model.export(format=‘engine’, device=0) # 需要提前安装TensorRT
# 导出为OpenVINO格式（Intel CPU/GPU）
# model.export(format=‘openvino’)
    • 导出的模型（如 best.onnx ）可以使用ONNX Runtime、OpenCV DNN等库在多种环境中高效运行。

  5. 版本管理与复现 ：

    • 记录每次实验的关键参数：模型结构、数据集、超参数（学习率、批大小等）。 args.yaml 文件自动保存了这些信息。
    • 考虑使用 wandb 或 TensorBoard 进行更专业的实验跟踪。YOLOv8支持与这些工具集成。

  6. 生产环境注意事项 ：

    • 性能测试 ：在目标部署硬件上测试模型的推理速度（FPS）和内存占用。
    • 错误处理 ：在推理代码中加入异常处理，如图片读取失败、模型加载失败等。
    • 资源管理 ：长时间运行的推理服务，注意内存泄漏和GPU内存管理。

从环境搭建到自定义训练，YOLOv8通过其高度封装的API极大地降低了目标检测的门槛。但真正的掌握源于实践和迭代。建议你找一个感兴趣的小目标（如检测办公室的水杯、识别某种特定的宠物），从头到尾走一遍完整的流程：收集数据 -> 标注 -> 训练 -> 评估 -> 优化。这个过程遇到的每一个错误和解决的每一个问题，都会让你对YOLO和目标检测有更深的理解。

# 目标检测
Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

Codex 和 Claude Code 怎么订阅？套餐、API计费与付款避坑指南

avatar AI编程社区
cover

AI编程成本越来越高，tokens越充越少，怎么降成本？

avatar AI编程社区
cover

AI编程模型横评2026：Claude Code vs Cursor vs Codex，Agent化编程正在杀死补全模式

avatar AI编程社区