YOLOv8与PyQt5构建花卉识别桌面应用：从训练到打包全流程实战

在目标检测和图像分类这个圈子里，YOLOv8 和 PyQt5 的组合可以说是非常经典的“毕业设计级”项目了。说它经典不是因为简单，而是因为这套组合刚好覆盖了从模型训练到桌面应用落地的完整闭环：YOLOv8 负责把“识别”这件事做扎实，PyQt5 负责把“应用”这层皮撑起来。我用这个思路完整做了一个花卉识别桌面应用，从数据集整理、模型训练、推理封装到 GUI 开发和打包，踩过的坑不少，但最后跑通的那一刻，整条链路基本就能迁移到其他任何目标检测项目上。这篇文章就把整个流程拆开讲清楚，适合正在做毕业设计、或者想从“只会跑官方 demo”进阶到“能做出一个自己产品”的读者。

1. 项目整体设计与方案选型

1.1 先想清楚：这个软件到底要做什么

很多人在动手前容易犯一个错误：一上来就急着配环境、下模型、写界面，结果做到一半发现需求根本没想明白。我做这个项目的第一步，是先在纸上把软件的功能边界画出来。

花卉识别桌面应用，核心使用场景是“用户给一张图片，软件告诉用户图里有什么花、各自在什么位置、置信度是多少”。围绕这个核心，我最终确定了四个基本功能：

• 单张图片识别：点击按钮或拖拽图片，立即显示检测结果。
• 批量图片识别：选择一个文件夹，自动遍历所有图片并生成汇总结果。
• 结果显示区域：左侧显示带检测框的图片，右侧用表格列出每朵花的类别、置信度、坐标信息。
• 基础交互：打开图片、保存结果图、清空列表。

这里刻意没有加上训练功能、数据标注功能、摄像头实时识别等选项，原因是“桌面端做训练”本身就很别扭，而且会把项目复杂度推高一个量级。想明白这一点很重要：做项目不是功能越多越好，而是让每个功能都服务于核心场景。摄像头识别我是在第一版做完之后才作为扩展加进去的，这个后面会提到。

1.2 为什么是YOLOv8：检测任务和分类任务怎么选

花卉识别听起来是个分类问题，但真正落地的时候，你会发现“检测”比“分类”更实用。分类模型（比如 ResNet、ViT）只能告诉你“这张图里有玫瑰”，但没法告诉你“玫瑰在哪个位置”，如果一张图里有三种花，分类模型甚至可能只输出概率最高的那一种。而 YOLOv8 做的是目标检测，输出的是“目标类别 + 边界框坐标”，能够一次性定位多个目标。

YOLOv8 本身支持 detect（检测）、classify（分类）、segment（分割）、pose（姿态）等多种任务。如果你只做单花特写、背景简单的图片，用 classify 模型确实更轻量；但如果图片里有多朵花、背景复杂，或者未来想换到其他检测场景（比如水果检测、路口车流量统计），直接上 detect 检测更稳妥。我做选择时考虑的正是这个迁移成本：detect 任务的通用性最强，训练代码和数据格式换成任何其他目标检测项目都能复用。

选 YOLOv8 而不是 YOLOv5 或其他框架，有几个很现实的原因：

• YOLOv8 默认就是 Anchor-Free 结构，少了很多锚框调参的麻烦。
• 官方仓库维护活跃，生态好，预训练权重齐全，遇到问题更容易搜到答案。
• 它的模型结构里有 C2f 模块和改进的解耦检测头，整体精度在同等体积下通常优于 v5。
• 配套的 ultralytics 库把训练、验证、预测、导出封装得非常完善，对新手极度友好。

在 YOLOv8 的五个版本（n / s / m / l / x）里，我第一版选的是 yolov8s。原因很直接：yolov8n 虽然速度快但精度略低，yolov8m 以上对显存要求更高，而我的显卡是 GTX 1660Ti 6GB，跑 s 版本在 640 分辨率训练是相对平衡的选择。如果之后精度不够，再换 m 版本也不迟，因为数据、代码、配置基本都是通用的。

1.3 为什么是PyQt5：桌面端的实际考虑

做桌面 GUI 的方案其实很多：Tkinter、PyQt5/PySide、Electron、甚至直接用 Web 前端套壳。我最终选了 PyQt5，核心原因是它在“开发效率”和“界面能力”之间最平衡。

Tkinter 虽然不用装额外东西，但控件样式实在简陋，做出来的界面和现代软件差距大；Electron 做界面确实好看，但打包体积动辄一两百兆，而且前端知识要求高。PyQt5 的优势在于：

• 控件丰富且成熟：表格、树形、富文本、摄像头显示等都有现成控件。
• 信号槽机制天然适合“界面上点按钮→后台做推理→把结果显示出来”这种交互模型。
• 中文资料极多，遇到问题基本都能搜到答案。
• 可以和 OpenCV、NumPy 无缝配合，图像在 QImage 和 ndarray 之间转换很顺手。

当然 PyQt5 也有缺点，比如默认界面风格偏老旧、打包后体积偏大、在高 DPI 屏幕上偶尔有缩放问题。但这些都有解决办法，我在第 5 部分会专门讲。

2. 环境搭建：一套能跑的底座

2.1 基础环境：Python 虚拟环境与依赖安装

这个项目依赖的库并不复杂，核心就是 ultralytics、torch、PyQt5、opencv-python、numpy。我习惯用 conda 建虚拟环境，避免多个项目相互污染 Python 包。

conda create -n flower python==3.9 -y conda activate flower pip install ultralytics pip install pyqt5 pyqt5-tools pip install opencv-python

这里有个细节：Python 版本不要选太新的。目前 ultralytics 和 PyTorch 对 Python 3.12 的兼容性虽然没问题了，但国内许多镜像源和第三方插件链对 3.12 的支持还是不如 3.9/3.10 稳。除非你有特殊需求，否则我建议直接用 Python 3.9 或 3.10。

另外提醒一句，PyQt5 的安装包比较大，如果直接 pip 安装，下载速度会很折磨人，尤其 windows 上安装时长动不动就几分钟甚至超时。记得换国内镜像：

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

实测换源之后，PyQt5 的安装基本一分钟之内就能搞定。

2.2 PyQt5界面无显示？多半是OpenGL的坑

如果你是在远程桌面、虚拟机、或者部分旧显卡环境下运行 PyQt5 程序，很容易遇到一个诡异的问题：程序进程跑起来了，但窗口一片空白，甚至直接崩溃。这个问题的元凶通常是 OpenGL 驱动。

PyQt5 的底层渲染依赖 OpenGL，在缺少 GPU 驱动或只支持旧版 OpenGL 的环境中，Qt 默认的渲染路径就会失败。解决办法有两种：

第一种，软件渲染。找到 Python 安装目录下Lib\site-packages\PyQt5\Qt5\bin里的opengl32sw.dll，把它复制到你的项目主程序同目录下。Qt 在检测到硬件 OpenGL 加载失败时会自动回退到这个软件实现。我实际测试下来这个方法最省事。

第二种，强制指定软件渲染，在程序入口加环境变量：

import os os.environ["QT_OPENGL"] = "software"

如果程序是打包后发布，最好把opengl32sw.dll一起打进包里。这个问题不解决，后面你写的界面再漂亮也只能干瞪眼。

2.3 GPU推理环境推荐：1660Ti / 50系显卡该配哪套CUDA

主机上如果没有 NVIDIA 显卡，CPU 跑 yolov8s 也不是不行，但速度会比较感伤。有条件还是建议配好 GPU。关于 CUDA 版本组合，我的实测建议如下：

我自己的开发机是 GTX 1660Ti 6GB 显存，驱动版本较新，最终选了 CUDA 11.8 + cuDNN 8.9 + torch 2.1.2 的组合。这里要注意一个概念：PyTorch 的 CUDA 版本和系统里装的 CUDA Toolkit 不是一回事。PyTorch 是自带 CUDA 运行时库的，如果你只是用 PyTorch 做训练推理，甚至可以不用在系统里装完整的 CUDA Toolkit，只要装一个匹配的显卡驱动，然后安装对应版本的 torch 就行。

比如：

pip install torch==2.1.2 torchvision==0.16.2 --index-url https://download.pytorch.org/whl/cu118

如果是 RTX 5060 这类新卡，推荐直接上 CUDA 12.1 版本的 torch，因为新卡的驱动和计算能力对老 CUDA 的兼容性不一定好。选版本之前先用nvidia-smi看下驱动支持的 CUDA 版本，只要驱动支持的版本 >= PyTorch 要求的版本就行。

装完之后在 Python 里验证一下：

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

输出 True 和显卡型号，说明 GPU 环境 OK。

2.4 用一条命令验证YOLOv8环境

ultralytics 库安装成功之后，可以在命令行直接跑一次官方预训练模型：

yolo predict model=yolov8s.pt source=https://ultralytics.com/images/bus.jpg

第一次运行会自动下载yolov8s.pt权重文件（大概 22MB）和测试图片，然后打印检测结果。如果能看到检测框图片，说明 YOLOv8 的环境已经完全可用了。这一步跑通，后面所有训练和推理都有底气。

3. 数据集准备与模型训练

3.1 花卉数据集从哪里来：公开数据、爬图和标注

YOLOv8 训练自己的数据集，第一个绕不开的问题是数据。花卉识别这个领域其实有不错的公开数据集，最经典的是 Oxford 102 Flower Dataset，包含 102 个类别、每类 40-258 张图片。不过这个数据集是分类格式（每类一个文件夹），要做检测的话还需要转换成检测标注格式。

我的做法是混合思路：

• 从公开数据集中选出我希望支持的 10-20 种常见花卉（玫瑰、向日葵、郁金香、菊花等），尽量选择背景多样、姿态多样的图片。
• 对于数量不够的类别，从网络图库中爬取补充，但注意筛掉有水印、模糊、过度裁剪的图片。
• 用标注工具手动标注。LabelImg 是老牌选择，但我更推荐 X-AnyLabeling，它对 YOLO 格式支持好，操作也更顺畅。

YOLO 检测格式的目录结构长这样：

dataset/ images/ train/ val/ labels/ train/ val/

每张图片对应一个同名.txt标注文件，每一行内容为：

类别id 中心点x 中心点y 框宽 框高

注意：坐标全部是归一化到 0-1 之间的相对值，不是像素绝对坐标。比如一张 640x480 的图里，一个框左上角在 (160, 120)、右下角在 (320, 240)，那么标注行的值是：

0 0.375 0.375 0.25 0.25

因为中心点是 ((160+320)/2 / 640, (120+240)/2 / 480) = (0.375, 0.375)，宽高是 (320-160)/640 = 0.25、(240-120)/480 = 0.25。

数据集划分上，我用了train: 70%、val: 20%、test: 10%的比例，并且从一开始就保证每个类别的图片在这三个集合里都均匀出现，避免某个类在验证集里一张都没有。

3.2 数据集配置文件与训练参数详解

YOLOv8 训练前要准备一个.yaml数据配置文件，内容如下：

path: D:/flower_project/dataset train: images/train val: images/val test: images/test nc: 12 names: 0: rose 1: sunflower 2: tulip # ... 对应你自己的类别

path建议写成绝对路径，避免相对路径在各种工具之间切换时出问题。nc是类别数量，names是类别名称列表，顺序必须和标注时的类别 id 完全一致。

然后是训练命令。以我用的 yolov8s 为例：

yolo train \ model=yolov8s.pt \ data=flower.yaml \ epochs=100 \ imgsz=640 \ batch=8 \ patience=20 \ device=0 \ workers=4 \ optimizer=AdamW \ project=flower_train

这些参数里，我重点说几个容易被忽略的：

• epochs：不是越大越好。数据集小的时候训练到后期很容易过拟合。我设置了 100，但配合patience=20，意思是连续 20 个 epoch 验证集指标没有提升就提前停止，实际在第 60 轮左右就停了。
• batch：1660Ti 6GB 显存，yolov8s 加 640 分辨率，batch=8 勉强能跑，显存占用大概 5.2GB。如果显存不够，优先降到 batch=4，而不是盲目调小imgsz。
• freeze：如果你想用预训练模型做迁移学习，可以冻结部分层，比如freeze=10表示冻结前 10 层（backbone 大部分层），只训练后面的检测头。对于数据量比较小的入门项目，冻结 backbone 可以加快训练速度，也能减少过拟合风险。
• workers：Windows 上建议设成 4 以内，设太高高容易报 DataLoader worker 错误。
• optimizer：yolov8 默认是auto，在小数据集上我用 AdamW 会比 SGD 收敛更稳一些。

3.3 训练过程怎么看：loss曲线和训练日志

训练启动后，终端会实时打印每个 epoch 的损失值和验证指标。很多人只看mAP50在涨就放心了，但我建议养成看results.csv的习惯。ultralytics 会把训练过程的所有指标保存到project/exp/weights/results.csv里，包括 train/box_loss、train/cls_loss、train/dfl_loss、val 对应的损失、precision、recall、mAP50、mAP50-95。

用 pandas + matplotlib 画损失曲线：

import pandas as pd import matplotlib.pyplot as plt df = pd.read_csv('flower_train/exp/results.csv') df.columns = [c.strip() for c in df.columns] fig, ax = plt.subplots(1, 2, figsize=(14, 4)) ax[0].plot(df['epoch'], df['train/box_loss'], label='train box_loss') ax[0].plot(df['epoch'], df['val/box_loss'], label='val box_loss') ax[0].legend(); ax[0].set_title('box loss') ax[1].plot(df['epoch'], df['metrics/mAP50(B)'], label='mAP50') ax[1].plot(df['epoch'], df['metrics/mAP50-95(B)'], label='mAP50-95') ax[1].legend(); ax[1].set_title('mAP') plt.show()

如果看到 train loss 不断下降但 val loss 先降后升，说明开始过拟合了，应该调小 epochs 或加强数据增强；如果 train loss 和 val loss 都在高位横盘，说明学习率不合适或者模型容量不够，可以考虑调低 lr 或换大一点的模型。

3.4 选模型：best.pt还是last.pt，验证指标怎么看

训练结束后，weights文件夹下会有best.pt和last.pt两个文件。best.pt是验证集上 mAP 最高的权重，last.pt是最后一个 epoch 的权重。默认用best.pt，不用纠结，除非你是想继续接着训练。

对验证集做一次正式评估：

yolo val model=flower_train/exp/weights/best.pt data=flower.yaml

输出里重点看这几个指标：

• Precision：所有预测框里，真正是目标的占比。
• Recall：所有真实目标里，被模型找出来的占比。
• mAP50：IoU 阈值 0.5 时的平均精度，实用场景比较关心的指标。
• mAP50-95：IoU 阈值从 0.5 到 0.95 取平均，更严格、更学术。

依据这些指标，我第一版 yolov8s 在 12 类花卉上 mAP50 达到了 0.87 左右。对于入门项目，这个数字完全够用。如果你发现某个类别识别特别差，大概率是这类图片数量太少或者标注质量不高，优先去补充数据，而不是调参。

4. 推理封装：把模型变成能用的函数

4.1 写一个干净的推理类

模型训练好之后，接下来就是写推理代码。我不建议在业务代码里到处直接调用YOLO对象，因为后续要换模型版本、改阈值、输出不同格式时会非常痛苦。正确做法是写一个推理服务类，把所有 YOLOv8 的细节封装在内部。

from ultralytics import YOLO class FlowerDetector: def __init__(self, weights_path, conf_thres=0.4, device='cpu'): self.model = YOLO(weights_path) self.conf_thres = conf_thres self.device = device self.class_names = self.model.names def predict(self, img_bgr): results = self.model.predict( source=img_bgr, conf=self.conf_thres, device=self.device, verbose=False )[0] detections = [] if results.boxes is not None: for box in results.boxes: cls_id = int(box.cls[0]) conf = float(box.conf[0]) x1, y1, x2, y2 = [float(v) for v in box.xyxy[0]] detections.append({ 'class_id': cls_id, 'class_name': self.class_names[cls_id], 'confidence': conf, 'bbox': (x1, y1, x2, y2) }) return detections def predict_and_draw(self, img_bgr): annotated = img_bgr.copy() detections = self.predict(img_bgr) for det in detections: x1, y1, x2, y2 = det['bbox'] cv2.rectangle(annotated, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2) label = f"{det['class_name']} {det['confidence']:.2f}" cv2.putText(annotated, label, (int(x1), max(0, int(y1) - 8)), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) return annotated, detections

这里有一个容易踩坑的地方：ultralytics 默认模型输出的是英文类别名（比如 rose、sunflower），但桌面应用给用户看的是中文。所以我在FlowerDetector里加了一个中文映射字典：

CN_NAMES = { 'rose': '玫瑰', 'sunflower': '向日葵', 'tulip': '郁金香', # ... }

识别结果界面上显示中文，传给模型训练的还是英文原名。

4.2 输入数据类型：图片路径、PIL、numpy都能处理

YOLOv8 推理时source参数支持很多类型：图片路径、URL、PIL 图像、numpy 数组等。在桌面应用里，最常用的是 numpy 数组，因为 PyQt5 的 QImage 转 numpy 数组非常方便，而 OpenCV 处理过的图片也是 numpy 数组。

需要注意一个色彩通道问题：OpenCV 读图默认是 BGR 顺序，而 PyQt5 显示的 QImage 默认是 RGB 顺序。YOLOv8 内部训练时的图像处理是遵循 OpenCV 的 BGR 约定来的，所以推理时输入 BGR 数组是没问题的；但显示的时候必须先把 BGR 转成 RGB，否则画面会偏蓝。这个坑几乎每个做 Qt + OpenCV 项目的人都会踩一次：

rgb_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2RGB) height, width, channel = rgb_image.shape qimage = QImage(rgb_image.data, width, height, 3 * width, QImage.Format_RGB888) pixmap = QPixmap.fromImage(qimage)

QImage构造里bytesPerLine参数就是3 * width，因为 RGB888 每像素 3 字节，这个值填错会导致图片显示倾斜或花屏。

4.3 推理速度优化：1660Ti上能不能跑到实时

在 GTX 1660Ti 上，yolov8s 的推理速度大约是 25-35ms 每帧（imgsz=640），差不多 30 FPS 左右，对于桌面应用识别图片来说绰绰有余。如果你在 CPU 上跑，yolov8n 在 imgsz=320 可以做到 200ms 左右一张图，也能接受，但是识别精度会有所下降。

几个提速技巧：

• 显存够的情况下推理用half=True，FP16 半精度在 1660Ti 上能快 20% 左右。
• imgsz尽量和训练一致，640 就传 640，不要盲目增大。
• 如果只是识别整张图中的花，conf阈值可以适当提高到 0.5，减少误检框数量，界面显示更干净。
• 批量图片识别时，循环单张推理比一次性传 list 慢很多，尽量传 list 批量推理，YOLOv8 会动态 batch。

5. PyQt5桌面界面开发

5.1 界面布局：三块区域搞定核心功能

做 GUI 之前，先在大脑里过一遍用户操作路径：打开程序 → 点“选择图片” → 左边看到原始图/标注图 → 右边看到结果表格 → 需要的话保存结果。所以界面不需要花哨，三块区域足够：

• 顶部工具栏：放“打开图片”、“批量识别”、“摄像头识别”、“保存结果”四个按钮。
• 中央显示区：用 QLabel 或 QGraphicsView 显示图片，QLabel 简单够用，QGraphicsView 适合需要放大缩小的情况。
• 右侧结果面板：用 QTableWidget 显示表格，包含“花卉名称”“置信度”“位置”三列。

我建议界面代码用纯代码来写，而不是依赖 Qt Designer。原因很现实：Qt Designer 生成的.ui文件虽然可视化拖拽方便，但一旦你要在表格里放自定义控件、动态增删行、嵌入富文本，还是得手写代码。纯代码布局对初学者来说多练几次，控件的父子关系、布局器的嵌套会理解得更透。

核心主窗口骨架：

class MainWindow(QMainWindow): def __init__(self): super().__init__() self.setWindowTitle('花卉识别系统') self.resize(1100, 720) central = QWidget() self.setCentralWidget(central) toolbar = QHBoxLayout() self.btn_open = QPushButton('选择图片') self.btn_batch = QPushButton('批量识别') self.btn_camera = QPushButton('摄像头识别') toolbar.addWidget(self.btn_open) toolbar.addWidget(self.btn_batch) toolbar.addWidget(self.btn_camera) toolbar.addStretch() left = QLabel('请选择图片') left.setAlignment(Qt.AlignCenter) left.setStyleSheet('background:#f0f0f0; border:1px solid #ccc;') self.table = QTableWidget(0, 3) self.table.setHorizontalHeaderLabels(['花卉名称', '置信度', '位置']) splitter = QSplitter(Qt.Horizontal) splitter.addWidget(left) splitter.addWidget(self.table) splitter.setSizes([750, 350]) root = QVBoxLayout(central) root.addLayout(toolbar) root.addWidget(splitter)

用QSplitter的好处是用户能拖动分割条调整左右区域大小，体验比固定布局好很多。

5.2 核心功能实现：选图 → 推理 → 显示

打开图片并识别的完整流程：

def on_open_image(self): path, _ = QFileDialog.getOpenFileName( self, '选择图片', '', '图片文件 (*.jpg *.jpeg *.png *.bmp)') if not path: return img_bgr = cv2.imread(path) if img_bgr is None: QMessageBox.warning(self, '提示', '图片读取失败') return annotated, detections = self.detector.predict_and_draw(img_bgr) self.show_image(annotated) self.update_table(detections)

show_image里要注意缩放：原图分辨率如果大于显示区域，直接把 QPixmap 塞给 QLabel 会超出控件范围，需要用scaled方法按比例缩放：

def show_image(self, bgr_img): rgb = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2RGB) h, w, ch = rgb.shape qimg = QImage(rgb.data, w, h, 3 * w, QImage.Format_RGB888) pixmap = QPixmap.fromImage(qimg) scaled = pixmap.scaled(self.image_label.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation) self.image_label.setPixmap(scaled)

update_table就是把detections列表填进表格：

def update_table(self, detections): self.table.setRowCount(len(detections)) for row, det in enumerate(detections): cn_name = CN_NAMES.get(det['class_name'], det['class_name']) self.table.setItem(row, 0, QTableWidgetItem(cn_name)) self.table.setItem(row, 1, QTableWidgetItem(f"{det['confidence']:.2f}")) x1, y1, x2, y2 = det['bbox'] self.table.setItem(row, 2, QTableWidgetItem(f"({int(x1)}, {int(y1)}) ({int(x2)}, {int(y2)})"))

5.3 别让界面卡死：QThread做推理的正确姿势

如果不做多线程，直接在主线程里点“批量识别”，界面会立刻进入“假死”状态，用户一拖动窗口就崩溃。原因是训练好的模型推理虽然快，但批量识别一个文件夹几百张图，耗时可能十几秒，主线程被阻塞，事件循环无法处理界面刷新。

正确做法是：把推理放到 QThread 子线程里，通过信号把结果传回主线程更新界面。

class InferWorker(QThread): finished = pyqtSignal(object, object) # 原图列表, 检测结果列表 def __init__(self, detector, img_paths): super().__init__() self.detector = detector self.img_paths = img_paths def run(self): results = [] imgs = [] for path in self.img_paths: img = cv2.imread(path) if img is None: continue _, dets = self.detector.predict_and_draw(img) imgs.append(img) results.append((path, dets)) self.finished.emit(imgs, results)

主界面里启动线程后不做任何耗时操作，只在信号回调里更新界面。这个模式是做 Qt 桌面应用的基本功，也是后面做摄像头实时检测的基础。

5.4 进阶交互：HTML报告、QTreeWidget嵌ComboBox、摄像头识别

三个热词相关的能力，在这个项目里都能用上。

QTextBrowser显示 HTML 报告，非常适合生成“识别结果汇总”，比如批量识别完成后，生成一份包含图片名、花种、置信度的 HTML 报告：

html = '<h2>批量识别结果</h2><table border="1" cellpadding="4">' html += '<tr><th>文件名</th><th>识别结果</th><th>置信度</th></tr>' for path, dets in results: for det in dets: html += f"<tr><td>{path}</td><td>{CN_NAMES[det['class_name']]}</td><td>{det['confidence']:.2f}</td></tr>" html += '</table>' self.text_report.setHtml(html)

QTreeWidget里嵌入QComboBox的场景，是你在做人工修正标注时非常实用的交互。比如识别结果以树形结构展示：一级节点是图片名，二级节点是每朵花；每个二级节点旁边放一个组合框，允许用户把“玫瑰”手动改成“月季”，这样标注环节直接在应用内完成，不用来回切换软件。

item = QTreeWidgetItem([cn_name, f"{conf:.2f}"]) combo = QComboBox() combo.addItems(flower_names) combo.setCurrentText(cn_name) self.tree.setItemWidget(item, 0, combo)

摄像头识别则是把定时器 QTimer 和线程结合起来：每 200ms 从摄像头读一帧，丢给推理线程处理，处理完的帧在主线程显示。这样界面不会因为推理速度跟不上而严重卡顿。

5.5 高DPI与分辨率适配

PyQt5 在 Windows 高分屏上默认表现很差，控件和文字都会“发虚”。解决办法是在程序入口加上：

import sys from PyQt5.QtCore import Qt from PyQt5.QtWidgets import QApplication QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True) QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True) app = QApplication(sys.argv)

注意必须在创建QApplication之前设置。另外界面布局使用布局器（QVBoxLayout / QHBoxLayout）而不是绝对定位，这样不同分辨率下控件能自动伸缩。窗口初始大小用resize(1100, 720)而不是setFixedSize，允许用户自由缩放，是最稳妥的方案。

6. 常见问题与打包发布经验

6.1 问题速查表

做这个项目的过程中，我遇到并且最终解决的问题远不止前面提到的那些。下面整理了一张速查表，基本覆盖了你在 Windows 上从零做这个项目的所有高频坑：

中文路径这个问题容易被忽视：cv2.imread('D:/花卉数据集/result.jpg')在某些 Windows 环境下会直接返回 None。解决方案是用np.fromfile读二进制再解码：

def imread_unicode(path): data = np.fromfile(path, dtype=np.uint8) return cv2.imdecode(data, cv2.IMREAD_COLOR)

6.2 PyInstaller打包：从脚本到exe

项目开发完成后，要分享给其他人用，必然要打包成 exe。PyInstaller 是主流选择，但打包 PyQt5 + ultralytics 这个组合时有几个很重要的经验：

基础打包命令：

pyinstaller -w -F \ --name "FlowerApp" \ --add-data "best.pt;." \ --add-data "opengl32sw.dll;." \ main.py

解释几个关键参数：

• -w：不显示控制台窗口，纯 GUI 模式。
• -F：打成一个单独的 exe 文件，方便分发，但启动速度会稍慢。
• --add-data：把模型权重文件和 opengl32sw.dll 打进去。Windows 下路径分隔符用;，Linux/mac 下用:。

打包后体积通常在 150MB-200MB 左右，这是正常现象，因为 PyQt5 和 PyTorch 本身就很大。如果在意体积，可以尝试：

• 不用-F，改成目录模式（去掉-F），再手动剔除torch里用不到的部分，但操作复杂，对新手不友好。
• 模型从.pt转成onnx后用 onnxruntime 推理，可以完全绕过 PyTorch 依赖，体积能减少 60% 以上。不过需要自己处理前后处理逻辑。

之前看过有人尝试把 YOLOv8 转 TensorRT8.6 后用 C++ 部署，桌面端的启动速度和显存占用确实会更好，但开发量不在一个级别。作为第一个应用级项目，PyInstaller 打包已经足够。

6.3 从 .pt 到 Onnx：后续扩展的跳板

如果想进一步做性能优化或者跨平台部署，模型导出是绕不开的。ultralytics 提供了一行命令：

yolo export model=best.pt format=onnx opset=11

导出后在 Python 里用 onnxruntime 推理，显存占用会更低，适合低配机器。还有人在 RK3588 这类边缘设备上部署 YOLOv8，流程一般是：训练得到 .pt → 导出 onnx → 用 rknn-toolkit2 转成 RKNN 格式 → 在板卡上推理。这个方向对嵌入式感兴趣的话可以继续深入，但入门阶段先把自己的桌面应用跑稳。

写在最后的一点建议

项目做完了，最大的感受是：模型训练真不是这个项目最耗时的地方。数据准备和标注、界面逻辑的打磨、各种环境问题的排查，加起来至少占了 80% 的时间。很多新手只盯着训练那几行命令，结果一遇到数据格式不对、界面显示不出来，就卡住了，这才是真实世界的常态。做这一类项目，心态上要接受“慢就是快”，先把最小闭环跑通，界面丑一点没关系，功能先能用；再去逐步优化精度、速度、界面美观度。这个花卉识别桌面应用做完之后，你要换到水果识别、车牌识别、车流量统计，本质上只需要换数据集和类别文件，代码框架完全可以复用，这算是这个项目最大的隐性回报。