企业官网建设流程全解析

自己做过一段时间YOLOv8目标检测，本来觉得已经够用了。直到有个项目要求把检测出来的目标轮廓抠出来，而不是简单画个框，我才真正意识到检测和分割之间那道分水岭。目标检测告诉你"这里有东西"，输出的是矩形框坐标；实例分割告诉你"这个东西具体占哪些像素"，输出的是逐像素的掩码。对于很多场景来说，后者才是真正能落地到业务里的结果。

这篇内容就围绕YOLOv8实例分割展开，从环境搭建、数据集制作、模型训练，到评估和部署，把全流程的实操细节和踩坑记录都过一遍。覆盖的环境是Windows + PyCharm + NVIDIA显卡，这套组合也是日常问得最多的。无论你是刚接触YOLO系列，想从检测转分割，还是已经在训练但结果不理想想排查问题，这篇都可以当一份操作手册来翻。

1. 为什么选YOLOv8做分割：模型家族与硬件匹配分析

1.1 实例分割和目标检测的本质差异

目标检测的输出很好理解：每个目标一个框，附带一个类别标签和置信度。YOLOv8检测模型的输出形式是(x_center, y_center, width, height, class_scores)，框是矩形，是目标的最小外接矩形。问题是真实物体几乎没有矩形轮廓，一个框很容易把背景也包含进去。

实例分割的输出是一个二进制掩码，对每个像素做判断——这个像素属于哪个目标实例。YOLOv8-seg模型的输出除了检测分支外，还额外有一个分割分支，输出原型掩码和掩码系数，两者做矩阵乘法得到最终的分割结果。这种方式比直接预测稠密掩码更高效，也是YOLOv8分割速度能保持实时的核心原因。

打个比方：检测像用粗笔圈出重点，分割像用精细的笔沿着边界描出来。前者快但粗糙，后者细但计算量大。实际项目中怎么选？如果你的下游任务只需要定位、计数、筛选，检测足够；如果要算面积、测量尺寸、做精细裁剪、判断边缘缺陷，那就必须上分割。

1.2 YOLOv8-seg模型家族与参数对比

YOLOv8分割系列同样分为n/s/m/l/x五个尺寸，从轻量到高精度依次递进。训练自己的数据集时，模型选型直接决定训练速度和最终效果，不能盲目上大模型。

热词里有人问GTX 1660 Ti能不能跑YOLOv8，这里明确回答：能跑，而且训练也没问题。GTX 1660 Ti是6GB显存，对应上表，用yolov8n-seg或yolov8s-seg搭配合理的batch size完全可行。我自己就在1660 Ti上跑过yolov8s-seg，batch size设8，图片缩放到640，训练一个3000张图的数据集，单epoch大概两三分钟，整体能接受。但如果想跑m或l版本，6GB显存会非常吃力，容易爆显存，不建议。

1.3 显存不够时的调参降级策略

很多人的显卡是6GB甚至4GB显存，又必须训练较大模型，这时候有几个降级方案，按优先级排：

• 降低batch size：这是最直接的手段，比如从16降到4，显存占用能减少一半以上。batch太小会导致梯度震荡，可以搭配梯度累积来弥补。
• 缩小输入分辨率：imgsz从640降到512或416，显存占用随分辨率平方级下降。代价是精度会有一定损失，小目标受影响最明显。
• 开启混合精度训练：YOLOv8默认已经开启AMP（自动混合精度），训练时显存占用能降低约30%，而且速度更快。
• 梯度累积：batch size设4，累积4步再更新梯度，等效于batch size 16的效果。这个操作需要手动改训练脚本或调用ultralytics库的底层API才能做到。

我的实际经验是，如果显存只有6GB，优先选s版本+imgsz 640+batch 8，这个组合在精度和训练速度之间最平衡。如果显存只有4GB，老老实实选n版本或者把imgsz降到512。

2. 环境配置的黄金组合：Windows + PyCharm下从零跑通YOLOv8-seg

2.1 版本组合避坑：CUDA、cuDNN、PyTorch三者如何匹配

环境配置这块是新手最大的拦路虎。很多人装了半天，最后torch.cuda.is_available()返回False，问题几乎都出在版本匹配上。先说结论，我推荐一套目前比较稳妥的组合：

为什么推荐CUDA 11.8而不是12.x？因为PyTorch 2.0.x的官方预编译包从CUDA 11.7和11.8开始支持，11.8版本生态最成熟，编译出来的wheel兼容性最好。CUDA 12.x能用，但需要确认你的驱动版本支持，PyTorch 2.1之后才完全适配CUDA 12.1。

注意：nvidia-smi里显示的CUDA Version是驱动支持的最高CUDA版本，不等于你要安装的CUDA工具包版本。比如驱动显示CUDA 12.1，你照样可以用CUDA 11.8的PyTorch，因为PyTorch自带CUDA运行库，不依赖系统里装的CUDA Toolkit。这个认知能帮你避开很多困惑。

Python版本建议3.9或3.10，3.11以上部分依赖包可能会有兼容问题，虽然ultralytics官方支持3.8到3.12，但我在3.11环境下遇到过某些第三方库编译失败的问题，老老实实用3.10最省心。

2.2 conda环境创建与安装命令

尽量用conda管理Python环境，与系统Python隔离，避免把环境搞乱。具体步骤如下：

# 创建Python 3.10环境 conda create -n yolov8 python=3.10 -y conda activate yolov8 # 安装PyTorch（CUDA 11.8版本） pip install torch==2.0.0 torchvision==0.15.0 --index-url https://download.pytorch.org/whl/cu118 # 安装ultralytics pip install ultralytics # 安装标注工具（后面数据集环节会用到） pip install labelme

如果显卡是30系或更老的20系，CUDA 11.8都能跑得很好。40系显卡也没问题，PyTorch 2.0对40系的Ada架构已经有完整支持。

2.3 验证环境是否成功

配置完环境先别急着训练，先做两个验证：

import torch print(torch.__version__) print(torch.cuda.is_available()) print(torch.cuda.get_device_name(0))

如果输出True和你的显卡型号，说明PyTorch正确调用了GPU。如果输出False，大概率是装成了CPU版本，或者CUDA版本不匹配。

然后跑一个最简单的预测脚本验证整体流程：

from ultralytics import YOLO # 加载预训练分割模型 model = YOLO('yolov8n-seg.pt') # 跑一张官方示例图 results = model('https://ultralytics.com/images/bus.jpg', save=True)

第一次运行会自动下载yolov8n-seg.pt权重文件，跑完会在当前目录生成runs/segment/predict文件夹，里面保存了分割可视化结果。能看到每个目标被不同颜色的掩码标记出来，说明整个环境链路已经通了。

2.4 PyCharm里的配置要点

在PyCharm里使用conda环境时，注意三点：

• 在Settings → Project → Python Interpreter中选择刚才创建的yolov8环境，而不是系统默认环境。
• 如果终端命令找不到conda activate，在Settings → Tools → Terminal里修改Shell path为cmd.exe，然后在终端里正常激活环境。
• 训练时如果提示内存不足，在PyCharm的Help → Change Memory Settings里把堆内存调大一点，虽然训练主要在GPU上，但数据加载阶段的CPU内存占用也不小。

3. 数据集准备：从LabelMe标注到YOLO格式转换全流程

3.1 标注工具选型对比

做实例分割，标注工具的选择直接影响效率。我对比过几个主流工具：

对于入门和中等规模数据集，LabelMe完全够用。如果数据量超过几千张，强烈建议用X-AnyLabeling的自动分割功能做预标注，然后人工修正，效率能提升好几倍。

3.2 LabelMe标注操作流程

安装完LabelMe后，命令行输入labelme启动，然后按以下流程操作：

1. 点击左侧"Open Dir"选择图片文件夹。
2. 点击"Edit" → "Create Polygons"，用鼠标沿着目标轮廓边缘打点，一个多边形可以打几十个点，点越多轮廓越精细。
3. 每画完一个多边形，弹窗里输入类别名，一定要和后续data.yaml中的names严格一致，这里最容易踩坑。
4. 点击"Save"保存JSON文件，默认保存到图片相同路径，建议后续统一规划目录时再移动。

标注小技巧：对于弯曲边缘，不必密集到每个像素都打点，多边形顶点间距在边缘弯曲处适当加密、直线处稀疏即可，YOLO的分割头对标注精度的容忍度比想象中高。但如果要计算面积或做精细质检，标注密度就要高一些。我自己标注的经验是，一条平滑弧线大概需要8-12个点，复杂轮廓可以到20个点。

3.3 JSON转YOLO格式的脚本实现

LabelMe保存的是JSON格式，YOLO训练需要的是TXT格式，每行代表一个目标，格式为：

class_id x1 y1 x2 y2 ... xn yn

其中坐标是归一化后的（除以图片宽高），n是顶点数。下面是我用的转换脚本，可以直接复制使用：

import json import os from pathlib import Path from PIL import Image def convert_labelme_json_to_yolo(json_path, output_dir, class_dict): """将LabelMe的JSON转换为YOLO分割格式TXT""" with open(json_path, 'r', encoding='utf-8') as f: data = json.load(f) image_path = data['imagePath'] image_full_path = os.path.join(os.path.dirname(json_path), image_path) with Image.open(image_full_path) as img: img_width, img_height = img.size output_lines = [] for shape in data['shapes']: label = shape['label'] if label not in class_dict: print(f'警告：未知类别 {label}，跳过') continue class_id = class_dict[label] points = shape['points'] # 坐标归一化 normalized_points = [] for x, y in points: nx = min(max(x / img_width, 0.0), 1.0) ny = min(max(y / img_height, 0.0), 1.0) normalized_points.extend([nx, ny]) line = f'{class_id} ' + ' '.join([f'{p:.6f}' for p in normalized_points]) output_lines.append(line) if output_lines: output_filename = Path(json_path).stem + '.txt' output_path = os.path.join(output_dir, output_filename) with open(output_path, 'w') as f: f.write('\n'.join(output_lines)) print(f'已转换: {output_filename}') else: print(f'跳过空标注: {json_path}') # 使用示例 class_dict = {'bottle': 0, 'cup': 1, 'chair': 2} # 类名和ID对应关系 # 注意：假设json_path是单个文件的路径，实际使用时用循环遍历整个目录 json_path = 'path/to/your/file.json' output_dir = 'path/to/output/labels' convert_labelme_json_to_yolo(json_path, output_dir, class_dict)

实际使用时，写一个循环处理整个目录的JSON文件，核心逻辑就是上面这段。坐标归一化有两个容易算错的地方：一是忘记除以图片宽高，二是把x除以高度、y除以宽度，这两个错误会导致训练时模型完全学不到东西。

3.4 数据校验：转换后必须做的一步

转换完标签后，建议写一个可视化脚本，把TXT里的坐标画回原图，检查标注是否错位。这一步能发现坐标归一化错误、类别ID错乱、标签文件与图片不匹配等问题。

import cv2 import numpy as np def verify_yolo_label(image_path, label_path, class_names): """将YOLO格式的标签可视化到原图上""" img = cv2.imread(image_path) h, w = img.shape[:2] with open(label_path, 'r') as f: lines = f.readlines() colors = [(0, 255, 0), (0, 0, 255), (255, 0, 0), (0, 255, 255)] for line in lines: parts = line.strip().split() if len(parts) < 7: # 至少需要class_id + 3个点 continue class_id = int(parts[0]) points = np.array([(float(parts[i]) * w, float(parts[i+1]) * h) for i in range(1, len(parts), 2)], dtype=np.int32) cv2.polylines(img, [points], True, colors[class_id % len(colors)], 2) cv2.putText(img, class_names[class_id], (points[0][0], points[0][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, colors[class_id % len(colors)], 2) return img # 使用 class_names = ['bottle', 'cup', 'chair'] img = verify_yolo_label('image.jpg', 'label.txt', class_names) cv2.imshow('Verify', img) cv2.waitKey(0)

如果看到多边形和目标轮廓完全吻合，说明标签数据没问题，可以放心进入训练环节。如果发现所有标注都偏移了一个固定量，多半是归一化时没有除以图片宽高，需要回头检查转换脚本。

4. 训练核心配置与参数调优：让别人踩坑你避坑

4.1 数据集目录结构与data.yaml配置

数据集目录我推荐按照YOLO官方约定的结构组织：

datasets/ ├── mydataset/ │ ├── images/ │ │ ├── train/ # 训练图片 │ │ └── val/ # 验证图片 │ ├── labels/ │ │ ├── train/ # 训练标签TXT │ │ └── val/ # 验证标签TXT │ └── data.yaml

图片和标签要严格按images/xxx.jpg对应labels/xxx.txt，文件名必须完全一致（不含扩展名的部分）。划分train/val时，建议按8:2或9:1的比例随机划分，但要注意同一场景的连续帧图片不要同时出现在训练集和验证集，否则会导致验证结果虚高。

data.yaml文件内容是训练配置的核心，位置放在mydataset/目录下：

path: D:/datasets/mydataset # 数据集根目录的绝对路径 train: images/train # 训练图片相对路径 val: images/val # 验证图片相对路径 nc: 3 # 类别数 names: ['bottle', 'cup', 'chair'] # 类别名称，必须和标注时的名称一致

这里特别提醒两个坑：

• path路径分隔符：Windows上用反斜杠\会出现转义问题，建议使用正斜杠/或者D:/datasets/mydataset这样的格式，YOLO在Windows上解析路径时对正斜杠支持更好。
• names和nc一致性：nc必须等于names列表的长度，且类别顺序要和你转换标签时的class_dict保持一致。如果标签里class_id是1代表cup，但names列表里第1位是bottle，类别就完全对不上了，训练出来预测结果会张冠李戴。

4.2 训练命令与关键参数解读

数据准备好后，一行命令启动训练：

yolo segment train data=D:/datasets/mydataset/data.yaml model=yolov8s-seg.pt epochs=100 imgsz=640 batch=8 device=0 workers=4

逐个解读关键参数：

• model：指定预训练权重。用yolov8s-seg.pt做预训练比从零训练收敛快很多，这叫迁移学习。YOLO的预训练权重是在COCO数据集上训练的，虽然你的数据集和COCO差异可能很大，但底层特征提取器的泛化能力仍然能迁移过来。
• epochs：训练轮数。起步建议100轮，然后根据损失曲线和mAP曲线决定是否继续。数据量小（几千张）时100轮足够，数据量大可以设200到300轮。
• imgsz：输入图片尺寸。训练和推理时会做letterbox缩放，保持长宽比不变。640是默认值，兼顾精度和速度。如果只有小目标可以适当增加到960或1280，但显存占用会显著上升。
• batch：批量大小，受显存限制。6GB显存设8，8GB显存设16，12GB以上可以设32或更大。
• device：指定GPU编号，device=0表示使用第一张显卡。CPU训练强烈不推荐，一个epoch可能要跑几十分钟。
• workers：数据加载线程数，Windows上建议设为2或4，设置过大会出现DataLoader worker错误。

训练开始后，终端会实时打印每个epoch的训练损失、验证损失、mAP50、mAP50-95等指标。训练过程中如果loss出现NaN，立即停止训练，先检查数据中是否有空标签文件或异常坐标，通常问题出在数据上。

4.3 损失函数曲线绘制：训练过程的可视化监控

训练过程中产生的所有指标都会保存到runs/segment/trainX/results.csv文件里，用pandas读出来画图，可以直观判断训练状态。热词里有人专门搜"yolov8画损失函数曲线图"，这里给出我一直在用的绘图脚本：

import pandas as pd import matplotlib.pyplot as plt # 读取训练日志 df = pd.read_csv('runs/segment/train2/results.csv') # 去除列名首尾空格 df.columns = df.columns.str.strip() # 创建子图 fig, axes = plt.subplots(2, 2, figsize=(12, 8)) # 绘制训练损失 axes[0, 0].plot(df['epoch'], df['train/box_loss'], label='Box Loss') axes[0, 0].plot(df['epoch'], df['train/seg_loss'], label='Seg Loss') axes[0, 0].plot(df['epoch'], df['train/cls_loss'], label='Cls Loss') axes[0, 0].set_title('Training Loss') axes[0, 0].legend() axes[0, 0].set_xlabel('Epoch') # 绘制验证损失 axes[0, 1].plot(df['epoch'], df['val/box_loss'], label='Val Box Loss') axes[0, 1].plot(df['epoch'], df['val/seg_loss'], label='Val Seg Loss') axes[0, 1].plot(df['epoch'], df['val/cls_loss'], label='Val Cls Loss') axes[0, 1].set_title('Validation Loss') axes[0, 1].legend() axes[0, 1].set_xlabel('Epoch') # 绘制mAP曲线 axes[1, 0].plot(df['epoch'], df['metrics/mAP50(B)'], label='mAP50') axes[1, 0].plot(df['epoch'], df['metrics/mAP50-95(B)'], label='mAP50-95') axes[1, 0].set_title('mAP') axes[1, 0].legend() axes[1, 0].set_xlabel('Epoch') # 绘制精确率和召回率 axes[1, 1].plot(df['epoch'], df['metrics/precision(B)'], label='Precision') axes[1, 1].plot(df['epoch'], df['metrics/recall(B)'], label='Recall') axes[1, 1].set_title('Precision & Recall') axes[1, 1].legend() axes[1, 1].set_xlabel('Epoch') plt.tight_layout() plt.savefig('training_curves.png', dpi=150) plt.show()

参数说明：df中的列名会因为YOLO版本不同而有差异，手动打印df.columns查看一下实际列名再画图。画出来的曲线怎么判断训练状态？

• 训练损失持续下降、验证损失也开始下降但还没到平台期：继续训练。
• 训练损失下降但验证损失不再下降甚至上升：开始过拟合，早停或减少epochs。
• 训练损失和验证损失都几乎不下降：学习率可能不合适，或者数据有问题（标注错误、类别错乱）。
• 所有loss都很低但mAP低：大概率是类别不平衡或数据分布问题，检测模型没学好少数类。

4.4 模型文件的保存与选择

训练结束后，runs/segment/trainX/weights/目录下会生成两个文件：

• best.pt：验证集上mAP最高的模型，后续推理和部署用它。
• last.pt：最后一个epoch的模型，用来继续训练（加resume=True参数）。

我见过很多人在测试时用了last.pt，发现效果不好，以为是训练失败了。实际上如果训练后期过拟合，last.pt可能比best.pt差很多。推理和部署一律选择best.pt，这是经验教训。

5. 模型评估、预测可视化与部署转换

5.1 评估指标怎么看：mAP50、mAP50-95和PR曲线

训练完不要急着部署，先在验证集上做一次评估，命令：

yolo segment val model=runs/segment/train2/weights/best.pt data=D:/datasets/mydataset/data.yaml

评估完成后会自动在runs/segment/valX/目录下生成混淆矩阵、PR曲线、F1曲线等图表。核心要关注两个指标：

• mAP50：IoU阈值0.5下的平均精度，反映"大致能检测到目标"的能力。
• mAP50-95：多个IoU阈值（0.5到0.95）下的平均精度，反映掩码边界预测的精确度，这个指标更严苛。

实际项目中我见过mAP50高达0.95但mAP50-95只有0.6的情况，说明模型能检测到目标，但分割的边界不够精细。如果是这种情况，可以在predict时把掩码后处理做得细致一点，或者收集更多边界复杂的数据重新训练。

5.2 用训练好的模型做预测

单张图片、图片文件夹、视频都可以用predict命令处理：

# 预测单张图片 yolo segment predict model=runs/segment/train2/weights/best.pt source=test.jpg conf=0.25 save=True # 预测整个文件夹 yolo segment predict model=runs/segment/train2/weights/best.pt source=./test_images/ conf=0.25 save=True # 预测视频 yolo segment predict model=runs/segment/train2/weights/best.pt source=test_video.mp4 conf=0.25 save=True # 摄像头实时预测 yolo segment predict model=runs/segment/train2/weights/best.pt source=0 conf=0.25 show=True

conf参数是置信度阈值，默认0.25。如果你的场景中目标容易被遮挡或形态复杂，可以降低到0.1或0.15来减少漏检；如果场景中误检很多，就提高到0.4或0.5。这个阈值需要在具体场景上测试调整，没有通用最优值。

在Python代码里调用更灵活，可以拿到掩码数组做后续处理：

from ultralytics import YOLO model = YOLO('runs/segment/train2/weights/best.pt') results = model('test.jpg', conf=0.25) for result in results: # 检测框坐标 boxes = result.boxes.xyxy.cpu().numpy() # 类别ID class_ids = result.boxes.cls.cpu().numpy().astype(int) # 分割掩码（多边形点坐标） masks = result.masks.xy # 每个目标的多边形坐标 # 分割掩码（布尔矩阵） mask_matrix = result.masks.data.cpu().numpy() # shape: [num_objects, H, W]

拿到mask_matrix后，可以对每个目标做面积计算、轮廓提取、图像裁剪等操作。比如要统计每个目标的像素面积，用mask_matrix.sum(axis=(1,2))就得到每个目标的面积占像素数，再结合相机标定参数可以映射到实际物理面积。

5.3 模型导出与边缘设备部署要点

训练好的.pt文件不能直接在手机上或边缘设备上运行，需要先做格式转换。YOLOv8支持的导出格式很多，常用的是ONNX和TensorRT：

# 导出ONNX格式 yolo export model=runs/segment/train2/weights/best.pt format=onnx imgsz=640 opset=12 # 导出TensorRT格式（仅限NVIDIA GPU） yolo export model=runs/segment/train2/weights/best.pt format=engine imgsz=640 half=True

ONNX是跨平台的中间格式，可以转到各个平台的推理引擎。热词里提到的RK3588和香橙派5这类边缘设备，部署流程通常是：PyTorch模型 → ONNX → RKNN（瑞芯微NPU的模型格式），转换过程中要注意几个点：

• 输入输出节点：确认ONNX模型的输入名和输出名，后续转RKNN时需要指定。
• 算子支持：RKNN对某些算子支持不完整，遇到不支持的算子需要改模型结构或换版本。YOLOv8基本都能转成功，但如果你改动了网络结构，就要小心了。
• 量化：边缘设备部署一般用INT8量化来提升推理速度，但量化后精度会掉1到3个百分点，实际接受不必要去调整。
• 输出后处理：RKNN的输出是未经过NMS的原始张量，需要在设备端自己实现NMS和掩码解码。

我在RK3588上部署YOLOv8n-seg时，全流程处理一张640x640图片大约需要30到50毫秒，基本满足实时需求。如果追求更高帧率，可以试试RK3588的NPU加速配合yolov8n-seg，帧率能到20fps以上，但精度会略低于GPU推理。

5.4 分割结果的后处理：掩码叠加与原图融合

预测出掩码后，如果要在图像上叠加半透明掩码，用OpenCV实现：

import cv2 import numpy as np def overlay_mask(image, mask_matrix, alpha=0.5): """将多个目标的掩码叠加到原图上""" overlay = image.copy() colors = [ (0, 255, 0), (0, 0, 255), (255, 0, 0), (0, 255, 255), (255, 255, 0), (255, 0, 255) ] for i in range(mask_matrix.shape[0]): mask = mask_matrix[i].astype(np.uint8) color = colors[i % len(colors)] colored_mask = np.zeros_like(image) colored_mask[mask == 1] = color overlay = cv2.addWeighted(overlay, 1, colored_mask, alpha, 0) return overlay

如果要保存分割后的目标本身（透明背景PNG），用mask索引原图即可：

# 提取第一个目标 mask = mask_matrix[0].astype(np.uint8) # mask中1的部分保留原图，0的部分设为透明 result = np.zeros((mask.shape[0], mask.shape[1], 4), dtype=np.uint8) result[mask == 1, :3] = image[mask == 1] result[mask == 1, 3] = 255 # 不透明

6. 实例分割实战中遇到的高频坑与完整排查思路

6.1 标注类别和names顺序对不上

这是问得最多的问题。症状是：训练过程loss正常下降，mAP曲线也正常，但predict时预测的类别和实际物体完全对不上。原因就是data.yaml的names列表顺序和转换脚本里的class_dict不一致。

我遇到过最典型的一次：标注时类别是person, car，class_dict定义为{'person': 0, 'car': 1}，但后来重新写yaml时写成了names: ['car', 'person']。训练出来的模型看到车识别为person，看到人识别为car，就是完全错位。

排查方法很简单：随机抽一张验证集图片，读取对应TXT文件的第一列（class_id），对照names里的名字判断名字是否对得上。训练前这一步必须做，不要偷懒。

6.2 图片与标签文件名不匹配

症状是：训练时提示找不到某些图片的标签文件，或者部分图片没有被加载。常见原因：标注时生成JSON的命名和原图不一致，或者转换脚本写错了stem导致TXT文件名和JPG文件名对不上。严格遵循images/train/xxx.jpg对应labels/train/xxx.txt的规则，空标签文件也要保留（它代表这张图没有目标），否则可能出现训练时图片和标签数目对不齐的问题。

写个批处理脚本检查一下：

import os image_dir = 'datasets/mydataset/images/train' label_dir = 'datasets/mydataset/labels/train' images = [f[:-4] for f in os.listdir(image_dir) if f.endswith('.jpg')] labels = [f[:-4] for f in os.listdir(label_dir) if f.endswith('.txt')] missing = set(images) - set(labels) print(f'缺少标签的图片数: {len(missing)}') for name in list(missing)[:10]: print(name)

6.3 训练时显存溢出（OOM）的排查链路

显存溢出是最直接、最常见的报错。遇到CUDA out of memory别慌，按顺序排查：

1. 检查batch size是否过大：1660 Ti（6GB）上用yolov8s-seg，batch从16降到8，通常就能解决。
2. 检查imgsz：从640降到512，显存占用能降一半。
3. 检查是否有其他程序占用显存：Windows下用nvidia-smi查看，关闭其他占用显存的进程。
4. 检查是否启用了AMP混合精度：默认开启，如果手动关闭了，显存占用会明显上升。
5. 如果以上都试过还是OOM，换更小的模型（s换n）或启用梯度累积。

6.4 训练损失不下降或下降极慢

训练了十几个epoch，loss纹丝不动，这种事遇到过好几回。原因排查按以下顺序：

1. 数据问题最大：检查标注坐标有没有异常值（比如超过1或小于0），标注点顺序对不对（坐标点可以不按顺时针排，YOLO的polygon处理对点的顺序鲁棒性还可以，但如果有重复点或相同点会出问题）。写个脚本检测所有TXT文件，看看有没有超出[0,1]范围的坐标。
2. 检查类别是否平衡：如果99%的目标是A类，只有1%是B类，模型倾向于全部预测A类，B类学不进去。可以考虑给B类增加数据，或者用类别权重。
3. 检查学习率：YOLO默认的学习率调度策略一般没问题，但如果你改了lr0参数，可以试试恢复到默认值0.01。
4. 检查数据量：少于500张图的数据集，分割任务很难收敛到理想效果，至少要1000张以上才算基本够用。

6.5 预测时完全没有检测结果

训练完跑predict，一张目标很明显的图却什么也没检测出来。排查思路：

1. 置信度阈值太高：把conf降到0.1试试，如果能看到结果，说明模型其实学到了，只是置信度不高。
2. imgsz不匹配：训练时用640，预测时如果设成1280，小目标可能被放大后变形导致检测不到，尽量保持训练和推理的imgsz一致。
3. 类别名称和数量不对：检查data.yaml的names，如果在推理时传入的names和训练时不一致，预测结果的类别索引会错乱。
4. 输入图片格式：有些PNG带透明通道，直接读图可能有问题，用OpenCV的cv2.imread读取时会自动丢弃alpha通道，但ultralytics库内部对不同格式处理不同，遇到奇怪问题先转成JPG测试一下。

关于模型推理速度与精度的进一步分析

在实际项目交付中，客户往往同时关注精度和速度，尤其是边缘设备或实时系统。YOLOv8-seg在COCO数据集上的速度-精度平衡已经很优秀，但换到自己的数据上，需要重新审视几个因素。

首先，如果训练数据中的目标大小分布和COCO差异很大，建议在训练时针对性地调整imgsz。小目标密集场景下，把imgsz从640提高到960或1280，往往能带来显著的mAP提升，但对显存要求成倍增加。如果显卡撑不住，优先减小batch size而不要减小imgsz。

其次，anchor-free的YOLOv8对不同长宽比目标的适应能力较强，但如果你的目标很大（几乎占满整张图）或很小（几个像素），默认模型不一定是最优解。可以尝试修改默认的模型结构，但这种操作需要比较深的模型修改经验，如果没有把握，先把数据量堆上去更实在。

最后，如果你的应用场景是视频实时推理，建议在部署时配合目标跟踪算法（比如ByteTrack或DeepSORT），避免重复检测造成的ID切换问题。YOLOv8-seg配合跟踪，可以做很多之前只能靠人工完成的工作，统计车流量、分析人流密度、检测生产线缺陷等。

我自己在使用中最大的感受是：实例分割模型的精度上限，往往不取决于模型本身，而取决于数据质量。同样的YOLOv8s-seg，在一份标注准确、类别平衡、样本充足的数据集上，效果可以超过在粗糙数据集上训练的YOLOv8x-seg。花在数据准备上的时间，永远是最值得的投资。