🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

这次我们来看一个面向零基础开发者的 YOLO 目标检测实战教程。YOLO（You Only Look Once）是目前应用最广泛的实时目标检测算法之一，而 Ultralytics 团队维护的 YOLO 系列框架，以其简洁的 API 和强大的功能，成为了从入门到部署的首选工具。无论你是想快速验证一个想法，还是需要为特定场景（如工业质检、安防监控、自动驾驶感知）训练一个定制模型，掌握 YOLO 的完整工作流都是必备技能。

本文将以最新的 Ultralytics YOLO 框架（涵盖 YOLOv8、YOLOv10 及未来的 YOLO26）为核心，手把手带你走通从环境搭建、模型推理、数据集制作到模型训练与评估的全过程。重点不是讲复杂的算法原理，而是让你能在自己的电脑上，用最少的配置，跑通一个完整的项目。我们会关注几个核心问题：需要什么样的硬件？显存占用多少？如何一键启动推理和训练？如何准备自己的数据？训练过程中遇到问题怎么排查？如果你之前被环境配置、数据格式、训练报错劝退过，那么这篇保姆级教程就是为你准备的。

1. 核心能力速览

在深入细节之前，我们先快速了解 Ultralytics YOLO 框架的核心特性和门槛，让你判断是否适合继续往下走。

关键点解读：

• 对新手友好：几行代码即可完成推理和训练，无需深入底层实现。
• 硬件门槛灵活：小模型可在消费级显卡甚至 CPU 上运行，大模型和训练则需要更强的 GPU。
• 功能全面：不止于检测，还支持分割、姿态估计等，且训练、验证、导出流水线完善。
• 部署生态成熟：支持导出为 ONNX、TensorRT、CoreML、NCNN 等多种格式，方便部署到各种平台。

2. 适用场景与使用边界

适合谁用？

1. 深度学习初学者：想快速入门计算机视觉和目标检测。
2. 算法工程师/研究员：需要快速验证新想法或为特定任务微调模型。
3. 嵌入式/边缘计算开发者：需要将模型部署到 Jetson、树莓派等设备。
4. 学生和教育者：用于课程设计、毕业项目或教学演示。
5. 传统视觉工程师：希望引入深度学习能力来解决复杂检测问题。

能解决什么问题？

• 通用物体检测：识别图片或视频中的物体（人、车、动物等）并给出位置。
• 特定场景检测：如生产线上的缺陷检测、遥感图像中的建筑物识别、医疗影像分析。
• 实时视频分析：安防监控、人流统计、自动驾驶感知。
• 模型轻量化与部署：将训练好的模型转换为高效格式，部署到服务器或边缘设备。

不适合什么场景？

• 需要极高检测精度（如军事、医疗诊断）：YOLO 虽强，但在某些极端场景下可能仍需更 specialized 的模型或后处理。
• 数据极度匮乏：YOLO 训练需要一定量的标注数据，如果只有几十张图片，效果可能不佳，需结合数据增强或迁移学习。
• 对模型解释性要求极高：YOLO 是端到端的黑盒模型，难以提供详细的决策依据。

版权、隐私与安全边界

• 模型权重：Ultralytics 提供的预训练权重基于 COCO 等开源数据集，可用于研究和商业项目，但需遵守其许可证（通常是 AGPL-3.0 或商业许可）。
• 自定义数据：你必须拥有所使用的训练图片的合法版权或使用权。涉及人脸、车牌等敏感信息时，务必确保已获得授权或进行脱敏处理，并遵守《个人信息保护法》等相关法律法规。
• 应用场景：禁止用于任何非法监控、侵犯他人隐私、制作虚假信息等用途。技术本身无善恶，使用者需承担全部责任。

3. 环境准备与前置条件

在开始敲代码之前，请确保你的开发环境满足以下要求。这是后续所有步骤的基础。

3.1 硬件与操作系统

• 操作系统：Windows 10/11, Ubuntu 18.04/20.04/22.04 或更高版本，macOS 10.14+。本文以Windows 11和Ubuntu 22.04为主要演示环境。
• CPU：现代多核处理器（Intel i5/Ryzen 5 或以上）。
• 内存：至少 8 GB，推荐 16 GB 或以上，尤其是训练时。
• GPU（强烈推荐）：NVIDIA GPU，显存至少 4GB（用于小模型推理），训练推荐 8GB 或以上。确保已安装正确版本的NVIDIA 显卡驱动。
• 磁盘空间：至少 10 GB 可用空间，用于安装 Python、库、模型和数据集。

3.2 软件环境

1. Python: 版本 3.8 到 3.11。不建议使用 Python 3.12+，可能遇到某些包不兼容。可通过python --version检查。
2. CUDA 和 cuDNN (仅 GPU 用户)：如果你使用 NVIDIA GPU 进行加速，需要安装 CUDA 和 cuDNN。Ultralytics 通常会自动安装匹配的 PyTorch 版本，但为了稳定，建议先确认你的显卡驱动支持的 CUDA 最高版本（通过nvidia-smi查看），然后安装对应的 PyTorch。
   • 查看驱动支持的CUDA版本：

     nvidia-smi

     在输出顶部找到 “CUDA Version: 12.4” 之类的信息。
3. 包管理工具：pip(Python 自带) 或conda(Anaconda/Miniconda)。本文使用pip。
4. 代码编辑器/IDE：VSCode、PyCharm 或 Jupyter Notebook 均可。

3.3 环境检查清单

在终端中执行以下命令，确保基础环境正常：

# 检查 Python 版本 python --version # 检查 pip 是否可用 pip --version # 如果有 GPU，检查驱动和 CUDA（Windows 可在 cmd 或 PowerShell 中运行 nvidia-smi） nvidia-smi

如果nvidia-smi命令报错或未显示 GPU 信息，说明 NVIDIA 驱动未正确安装，请先安装驱动。

4. 安装部署与启动方式

Ultralytics YOLO 的安装极其简单，主要通过 pip 完成。我们提供两种主流方式：纯净的 pip 安装和便于环境管理的 conda 安装。

4.1 方式一：使用 pip 安装（推荐）

这是最直接、最常用的方法。打开你的终端（Windows 用 CMD 或 PowerShell，Linux/macOS 用 Terminal）。

1. 创建并激活虚拟环境（可选但强烈推荐）： 虚拟环境可以隔离项目依赖，避免包冲突。

   # 创建名为 yolo_env 的虚拟环境 python -m venv yolo_env # 激活虚拟环境 # Windows: yolo_env\Scripts\activate # Linux/macOS: source yolo_env/bin/activate

   激活后，命令行提示符前会出现(yolo_env)字样。

2. 安装 Ultralytics 包：

   pip install ultralytics

   这个命令会自动安装 ultralytics 包及其所有依赖，包括 PyTorch。它会根据你的系统自动选择 CPU 或 GPU（CUDA）版本的 PyTorch。如果你想指定 PyTorch 版本，可以先安装 PyTorch，再安装 ultralytics。

3. 验证安装：

   python -c "from ultralytics import YOLO; print('Ultralytics YOLO 安装成功！')"

   如果没有报错，说明安装成功。

4.2 方式二：使用 Conda 安装

如果你习惯使用 Anaconda 管理环境。

1. 创建 Conda 环境：

   conda create -n yolo_env python=3.10 conda activate yolo_env

2. 安装 PyTorch (GPU版)： 前往 PyTorch 官网 获取适合你 CUDA 版本的安装命令。例如，对于 CUDA 12.1：

   conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia

3. 安装 Ultralytics：

   pip install ultralytics

4.3 “一键启动”推理体验

安装完成后，不需要任何额外配置，你就可以立即开始使用 YOLO。这可以算是最简单的“一键启动”。

使用 Python 脚本进行第一张图片的推理： 创建一个名为first_detection.py的文件，内容如下：

from ultralytics import YOLO import cv2 # 1. 加载一个预训练模型 (这里使用最小的 YOLOv8n 检测模型) model = YOLO('yolov8n.pt') # 会自动从 Ultralytics 服务器下载模型 # 2. 对一张图片进行推理 results = model('https://ultralytics.com/images/bus.jpg') # 可以使用网络图片URL，或本地路径如 ‘path/to/your/image.jpg’ # 3. 显示结果 # results[0].show() # 会使用默认图片查看器打开 # 或者使用 OpenCV 显示 for r in results: im_array = r.plot() # 绘制检测框的 numpy 数组 cv2.imshow('YOLO Detection', im_array) cv2.waitKey(0) cv2.destroyAllWindows() # 4. 打印检测到的物体信息 for result in results: boxes = result.boxes # 检测框对象 print(f"检测到 {len(boxes)} 个物体") for box in boxes: cls_id = int(box.cls) # 类别ID conf = float(box.conf) # 置信度 xyxy = box.xyxy.tolist()[0] # 框的坐标 [x1, y1, x2, y2] print(f" 类别: {result.names[cls_id]}, 置信度: {conf:.2f}, 位置: {xyxy}")

运行这个脚本：

python first_detection.py

你会看到程序自动下载yolov8n.pt模型文件，然后对示例公交车图片进行检测，并弹出窗口显示带框的结果，同时在终端打印检测到的物体信息。这就是你的第一个 YOLO 程序！

5. 功能测试与效果验证

安装成功并跑通第一个例子后，我们来系统性地测试 YOLO 的核心功能。我们将按照推理 -> 验证 -> 训练的主线进行。

5.1 基础推理功能测试

推理（Prediction）是 YOLO 最核心的功能，即用训练好的模型对新的图片或视频进行预测。

测试1：图片推理与结果保存

from ultralytics import YOLO model = YOLO('yolov8n.pt') # 使用 nano 模型，速度快 # 对单张图片推理并保存结果 results = model.predict(source='path/to/your/image.jpg', save=True, save_txt=True) # source: 图片路径、URL、目录或摄像头ID（如0） # save=True: 将可视化结果图片保存到 ‘runs/detect/predict’ 目录 # save_txt=True: 将检测结果（类别、位置、置信度）保存为 YOLO 格式的 .txt 文件 print(f"结果已保存至: {results[0].save_dir}")

预期结果：在项目根目录下会生成runs/detect/predict文件夹，里面包含画了检测框的图片image.jpg和对应的标签文件image.txt。

测试2：视频文件推理

results = model.predict(source='path/to/your/video.mp4', save=True, conf=0.5) # conf: 置信度阈值，低于此值的检测框将被过滤

预期结果：生成一个带有检测框的新视频文件。

测试3：实时摄像头推理

results = model.predict(source=0, show=True, save=False) # source=0 表示默认摄像头 # show=True: 实时显示检测画面

按q键退出显示窗口。

测试4：批量图片推理

results = model.predict(source='path/to/image/folder/', save=True)

预期结果：处理文件夹内所有支持的图片格式（jpg, png, bmp等），并分别保存结果。

5.2 模型验证与性能指标

在训练前或训练后，我们需要用验证集评估模型的性能。Ultralytics 内置了方便的验证功能。

from ultralytics import YOLO model = YOLO('yolov8n.pt') # 也可以是你的自定义模型 ‘best.pt’ # 在 COCO128 示例数据集上验证模型 metrics = model.val(data='coco8.yaml') # 使用内置的小型数据集配置 # 如果你有自己的数据集，使用 ‘data=‘path/to/your/data.yaml’’ print(metrics.box.map) # 打印 mAP50-95 print(metrics.box.map50) # 打印 mAP50 print(metrics.box.map75) # 打印 mAP75 print(metrics.speed) # 打印推理速度

关键指标解读：

• mAP50 (mAP@0.5)：交并比(IoU)阈值为0.5时的平均精度均值，是目标检测最常用的指标之一，值越高越好。
• mAP50-95 (mAP@[0.5:0.95])：IoU阈值从0.5到0.95（步长0.05）的平均mAP，更综合、更严格。
• 推理速度：包括预处理、推理、后处理的总时间，单位通常是毫秒每张图(ms/img)。

5.3 自定义数据集训练全流程

这是本教程的重中之重。我们将创建一个最简单的自定义数据集，并完成训练。

步骤1：准备数据集结构

YOLO 要求特定的数据集格式。假设我们要训练一个检测“猫”和“狗”的模型。

custom_dataset/ ├── images/ │ ├── train/ │ │ ├── image1.jpg │ │ ├── image2.jpg │ │ └── ... │ └── val/ │ ├── image100.jpg │ ├── image101.jpg │ └── ... └── labels/ ├── train/ │ ├── image1.txt │ ├── image2.txt │ └── ... └── val/ ├── image100.txt ├── image101.txt └── ...

• images/train/和images/val/分别存放训练和验证图片。
• labels/train/和labels/val/存放对应的标注文件，每个.txt文件与图片同名。
• 标注文件.txt格式：每一行代表一个物体class_id center_x center_y width height。坐标是归一化后的（0-1之间）。

  # 例如：图片 image1.jpg 中有一只猫（class_id=0）和一只狗（class_id=1） # image1.txt 内容： 0 0.5 0.5 0.3 0.4 1 0.7 0.3 0.2 0.3

步骤2：创建数据集配置文件data.yaml

在custom_dataset/目录下创建data.yaml文件：

# data.yaml path: /absolute/path/to/custom_dataset # 数据集的根目录 train: images/train # 训练图片的相对路径（相对于 path） val: images/val # 验证图片的相对路径 # 类别名称和数量 names: 0: cat 1: dog # 类别数量 nc: 2

步骤3：开始训练

使用 Python API 或 CLI 启动训练。这里展示 CLI 方式，更直观。

# 在终端中，确保处于虚拟环境，并切换到 custom_dataset 的父目录 yolo task=detect mode=train model=yolov8n.pt data=custom_dataset/data.yaml epochs=50 imgsz=640 batch=16

参数解释：

• task=detect: 指定任务为检测（还有segment,pose,classify）。
• mode=train: 训练模式。
• model=yolov8n.pt: 使用预训练的 YOLOv8n 模型作为起点（迁移学习）。
• data=...: 指向你的数据集配置文件。
• epochs=50: 训练轮数。
• imgsz=640: 输入图片缩放到的尺寸。
• batch=16: 批次大小。如果显存不足（报 CUDA out of memory），请减小此值（如 8, 4, 2）。

训练过程观察： 训练开始后，终端会显示进度条、损失曲线和关键指标。训练日志和模型权重会自动保存到runs/detect/train目录下。

步骤4：使用训练好的模型进行推理

训练完成后，最佳模型会保存在runs/detect/train/weights/best.pt。

from ultralytics import YOLO # 加载你训练好的模型 custom_model = YOLO(‘runs/detect/train/weights/best.pt’) # 用新图片测试 results = custom_model.predict(source=‘new_cat_image.jpg’, save=True, conf=0.5) results[0].show()

如果成功检测出猫或狗，恭喜你，自定义模型训练成功！

6. 接口 API 与批量任务

虽然 Ultralytics 没有内置的 HTTP 服务，但我们可以轻松地基于其 Python API 封装成 RESTful API，或构建高效的批量处理脚本。

6.1 构建简单的 Flask API 服务

创建一个app.py文件：

from flask import Flask, request, jsonify from ultralytics import YOLO import cv2 import numpy as np from PIL import Image import io app = Flask(__name__) model = YOLO(‘yolov8n.pt’) # 或加载你的 ‘best.pt’ @app.route(‘/predict’, methods=[‘POST’]) def predict(): if ‘file’ not in request.files: return jsonify({‘error’: ‘No file provided’}), 400 file = request.files[‘file’] image_bytes = file.read() image = Image.open(io.BytesIO(image_bytes)) image_np = np.array(image) # 执行推理 results = model(image_np) # 解析结果 detections = [] for r in results: for box in r.boxes: cls_id = int(box.cls) conf = float(box.conf) xyxy = box.xyxy.tolist()[0] detections.append({ ‘class’: model.names[cls_id], ‘confidence’: conf, ‘bbox’: xyxy # [x1, y1, x2, y2] }) return jsonify({ ‘detections’: detections, ‘original_shape’: image_np.shape }) if __name__ == ‘__main__’: app.run(host=‘0.0.0.0’, port=5000, debug=False)

运行服务：

python app.py

使用curl或 Postman 测试：

curl -X POST -F “file=@test.jpg” http://127.0.0.1:5000/predict

6.2 高效批量任务脚本

对于需要处理大量图片或视频的场景，一个健壮的批量脚本至关重要。

import os from pathlib import Path from ultralytics import YOLO import time class BatchProcessor: def __init__(self, model_path=‘yolov8n.pt’): self.model = YOLO(model_path) self.results_dir = Path(‘batch_results’) self.results_dir.mkdir(exist_ok=True) def process_folder(self, input_folder, output_folder=None, conf=0.25): input_path = Path(input_folder) if not input_path.exists(): print(f“输入目录不存在: {input_folder}”) return if output_folder is None: output_folder = self.results_dir / input_path.name output_path = Path(output_folder) output_path.mkdir(parents=True, exist_ok=True) # 支持的文件扩展名 supported_ext = [‘.jpg’, ‘.jpeg’, ‘.png’, ‘.bmp’, ‘.tiff’, ‘.mp4’, ‘.avi’, ‘.mov’] file_list = [] for ext in supported_ext: file_list.extend(input_path.rglob(f‘*{ext}’)) file_list.extend(input_path.rglob(f‘*{ext.upper()}’)) print(f“找到 {len(file_list)} 个待处理文件。”) for i, file_path in enumerate(file_list): print(f“处理中 ({i+1}/{len(file_list)}): {file_path.name}”) try: # 推理 results = self.model.predict( source=str(file_path), save=True, save_txt=True, conf=conf, project=str(output_path), name=‘predict’, exist_ok=True ) # 可以在这里添加自定义后处理逻辑，如保存到数据库等 time.sleep(0.01) # 避免过热或资源争抢 except Exception as e: print(f“处理文件 {file_path} 时出错: {e}”) with open(output_path / ‘error_log.txt’, ‘a’) as f: f.write(f“{file_path}: {e}\n”) print(f“批量处理完成！结果保存在: {output_path}”) if __name__ == ‘__main__’: processor = BatchProcessor(model_path=‘runs/detect/train/weights/best.pt’) # 使用自定义模型 processor.process_folder(input_folder=‘/path/to/your/images’, conf=0.5)

这个脚本提供了错误日志、进度显示和结果组织，适合生产环境。

7. 资源占用与性能观察

了解 YOLO 运行时的资源消耗，对于选择模型、调整参数和部署至关重要。

7.1 如何观察资源占用

• GPU 显存与利用率：
  • 命令行工具：在 Linux 上使用nvidia-smi，在 Windows 上可以使用任务管理器性能标签页，或nvidia-smi.exe（需将 NVIDIA GPU 工具加入 PATH）。
  • Python 监控：可以使用pynvml库在代码中动态读取。

    from pynvml import * nvmlInit() handle = nvmlDeviceGetHandleByIndex(0) # GPU 0 info = nvmlDeviceGetMemoryInfo(handle) print(f“GPU 显存占用: {info.used / 1024**2:.2f} MB / {info.total / 1024**2:.2f} MB”)

• CPU 与内存：使用系统自带的任务管理器、htop(Linux) 或psutilPython 库。

7.2 影响性能的关键因素

1. 模型尺寸：yolov8n.pt(nano) 速度最快，显存占用最小，但精度最低。yolov8x.pt(extra large) 精度最高，但最慢且最耗资源。根据任务在速度和精度间权衡。
2. 输入图像尺寸 (imgsz)：这是最重要的参数之一。尺寸越大，检测小物体能力可能越强，但显存占用呈平方增长，速度变慢。常见尺寸有 320, 640, 1280。训练和推理的imgsz应保持一致。
3. 批次大小 (batch)：训练时，增大批次大小可以提升 GPU 利用率，加快训练速度，但需要更多显存。推理时，批量处理也能提升吞吐量。
4. 置信度阈值 (conf)：值越高，返回的检测框越少、越可靠，后处理越快。根据应用调整。
5. 硬件：GPU 的 CUDA 核心数、显存带宽、CPU 的单核性能、内存速度都会影响整体流水线速度。

7.3 性能优化建议

• 训练阶段：如果显存不足，首先降低batch-size，其次降低imgsz。可以使用amp=True（自动混合精度）来节省显存并加速训练。
• 推理阶段：
  • 对于实时视频流，使用较小的模型（如yolov8n）和较小的imgsz（如 320）。
  • 对于服务器端批量处理，可以适当增大batch-size以提高吞吐量。
  • 考虑使用 TensorRT、OpenVINO 或 ONNX Runtime 对模型进行加速推理。
• 监控与日志：始终在脚本中添加资源监控和耗时日志，以便定位瓶颈。

8. 常见问题与排查方法

以下是 YOLO 使用过程中最常见的问题及其解决方法。

9. 最佳实践与使用建议

根据大量项目经验，遵循以下建议可以让你更顺畅地使用 YOLO。

1. 从小开始，快速迭代：

   • 第一次尝试时，使用最小的模型 (yolov8n.pt) 和官方示例数据集（如coco8.yaml）跑通全流程。
   • 使用自定义数据时，先用 50-100 张图片的小数据集进行快速训练（epochs=10），验证流程是否正确，再扩展到全量数据。

2. 数据管理是重中之重：

   • 目录结构标准化：严格遵循images/train/,labels/train/的格式。
   • 标注质量检查：训练前，务必用yolo val或可视化脚本检查标注文件是否有坐标越界、类别错误等问题。可以使用labelImg或CVAT等工具复核。
   • 数据集划分：通常按 8:1:1 或 7:2:1 划分训练集、验证集和测试集。验证集用于调参，测试集用于最终评估，两者不能混用。

3. 训练过程监控与调参：

   • 使用 TensorBoard：Ultralytics 默认会记录 TensorBoard 日志，在runs/detect/train目录下。运行tensorboard --logdir runs/detect/train可以在浏览器查看损失曲线、指标变化，非常直观。
   • 关键超参数：
     • lr0：初始学习率。太大易震荡，太小收敛慢。一般从默认值开始。
     • weight_decay：权重衰减，防止过拟合。
     • warmup_epochs：学习率热身轮数，有助于训练初期稳定。
   • 早停（Early Stopping）：如果验证集指标长时间不提升，可以提前停止训练，避免过拟合。Ultralytics 支持patience参数。

4. 模型版本管理与实验记录：

   • 每次训练，runs/detect/train下都会生成新的带时间戳的文件夹。在里面保存好本次实验的args.yaml（超参数）和results.csv。
   • 为不同的实验（如不同模型、不同数据增强）建立清晰的命名规则。

5. 部署前全面测试：

   • 在测试集上评估最终模型，确保指标达到预期。
   • 在真实场景的样例数据上进行推理测试，检查是否存在训练数据未覆盖的 corner case。
   • 测试模型在不同硬件（CPU/GPU）和推理引擎（PyTorch, ONNX, TensorRT）下的性能和精度差异。

6. 合规与伦理：

   • 数据授权：再次强调，用于训练的数据必须拥有合法版权或已获授权。
   • 隐私保护：如果模型会处理人脸、车牌等个人信息，必须在产品设计上考虑隐私保护，如本地处理、数据脱敏、用户知情同意等。
   • 模型偏见：注意训练数据是否具有代表性，避免模型对某些群体产生歧视性结果。

10. 总结与下一步

通过这篇教程，你应该已经掌握了 Ultralytics YOLO 从环境安装、模型推理到自定义数据集训练的核心流程。这个框架最强大的地方在于，它用极简的 API 封装了复杂的目标检测 pipeline，让开发者能快速聚焦于解决实际问题，而不是陷在环境配置和代码调试中。

最值得尝试的下一步：

1. 跑通你自己的数据：找一个小型、定义明确的目标检测任务（例如，检测办公室里的键盘、鼠标、水杯），按照第 5.3 节的步骤，完成从数据收集、标注到训练、测试的全过程。这是理解整个流程的关键。
2. 探索高级功能：在基础检测之外，尝试实例分割(task=segment，模型如yolov8n-seg.pt) 或姿态估计(task=pose，模型如yolov8n-pose.pt)。代码结构几乎完全一致，只需更换模型和任务参数。
3. 模型压缩与部署：尝试使用model.export(format=‘onnx’)导出模型，然后用 ONNX Runtime 进行推理，对比性能。更进一步，可以研究 TensorRT 或 OpenVINO 来获得极致的推理速度，这对于边缘部署至关重要。
4. 集成到你的项目：将训练好的模型封装成第 6 节所示的 API 服务，或者集成到你的桌面应用、Web 应用或移动应用中。

最容易踩的坑：

• 环境冲突：坚持使用虚拟环境，一劳永逸。
• 数据格式错误：data.yaml的路径和labels/下的.txt文件格式是新手最容易出错的地方，务必仔细检查。
• 显存不足：时刻牢记调整imgsz和batch-size是解决 OOM（内存溢出）的第一选择。

YOLO 的世界很大，本文只是一个起点。Ultralytics 的官方文档和活跃的社区是你遇到问题时最好的帮手。建议收藏本文，在实践每个步骤时回头查阅。当你成功训练出第一个能识别特定目标的模型时，你会发现，入门深度学习视觉应用，并没有想象中那么难。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度