YOLOv8、YOLOv10和最新的YOLO11 是一个流派，和yolov5区别还挺大，所以尝试使用YOLOv8来进行模型训练，只要YOLOv8学会了，YOLOv10、YOLO11也就会了,环境搭建、训练和YOLOv8基本一样，下面是详细使用流程：
一、环境搭建
1.1 Anaconda安装
Anaconda是一个强大的开源数据科学平台,它将很多好的工具整合在一起，极大地简化了使用者的工作流程，并能够帮助使用者解决一系列数据科学难题。anaconda安装在windows上安装简单，在Linux系统如麒麟系统还需要做一些权限设置，如sduo chmod +x命令。
Win+R输入cmd命令弹出对话框后输入命令，验证Anaconda是否安装成功
conda --version
conda info
python
exit()具体安装步骤可参考：
Anaconda安装-超详细版(2023)_anaconda安装哪个版本好-CSDN博客
1.2创建虚拟环境
在anaconda中，可以为每个项目创建独立的环境,确保项目之间的依赖关系互不干扰,也避免包冲突问题，例如yolov5项目就单独创建yolov5的环境，yolov8就单独创建yolov8的独立环境，如果是yolov10、yolo11就分别创建三个单独的环境。
启动Anaconda，创建yolov8独立环境，如果是yolov10、yolo11就分别创建三个单独的环境，命令如下：
（1）查看当前有哪些环境
conda env list（2）创建新的独立环境，一般python版本>=3.8,需要等待一段时间，还要手动选择“y”继续安装
conda create -n yolov8 python=3.8.10
（3）激活yolov8环境
conda activate yolov8（4）查看当前安装了哪些依赖
pip list （5）安装项目的requirement.txt依赖文件，可用豆瓣加速器下：https://pypi.douban.com/simple
pip install -r requirements.txt -i https://pypi.douban.com/simple（6）退出当前环境
conda deactivate 1.3安装CUDA
CUDA是NVIDIA发明的并行计算平台和编程模型。它通过利用图形处理单元 （GPU） 的强大功能，大幅提高计算性能。简单来说，CUDA 是一个通用的GPU编程平台，而cuDNN则是基于CUDA之上的一个专门用于深度学习的优化库。安装前提：必须有一块支持CUDA的英伟达显卡，如果电脑没有英伟达显卡，那没办法使用。
首先，Win+R输入cmd命令弹出对话框后输入命令，查看显卡驱动最高支持的CUDA版本。若版本过低需要更新显卡驱动地址
nvidia-smi
CUDA下载地址，点击CUDA Toolkit 11.8.0跳转页面后依次选择 。
Win+R输入cmd命令弹出对话框后输入命令，验证cuda是否安装成功
nvcc -V具体安装步骤参考：cuda和cudnn的安装教程(全网最详细保姆级教程)_安装cuda cudnn-CSDN博客
1.4安装CUDNN
NVIDIA CUDA® 深度神经网络库 (cuDNN) 是一个 GPU 加速的深度神经网络基元库,能够以高度优化的方式实现标准例程(如前向和反向卷积、池化层、归一化和激活层)。
cudnn下载网址，选择对应11.x的版本即可，将下载解压后将所有文件拷贝到CUDA目录里即可。
安装步骤参考：cuda和cudnn的安装教程(全网最详细保姆级教程)_安装cuda cudnn-CSDN博客
1.5安装pytorch
pytorch官网地址，找到cuda11.X对应的命令进行安装。
安装时需要激活yolov8环境，在里面进行安装：
1.6Pycharm工具安装和配置
安装地址：Download PyCharm: The Python IDE for data science and web development by JetBrains
可下载社区免费版本。
1.7下载yolov8、v10、yolo11源代码
1.7.1 yolov8下载
可以去github官网下载，但是需要梯子，其实国内网站同步更新，可在国内网站进行下载使用：
yolov8源码地址往下翻，找到权重文件，点击下载顺便一同放入之前下载的源码里 ，可以下载yolov8s.pt文件放在根目录中。
1.7.2 yolov10下载地址
https://github.com/THU-MIG/yolov10
下载完yolov10代码，再下翻下载所需要的预训练模型.
1.7.3 yolo11下载地址
https://github.com/ultralytics/ultralytics
下载完yolo11代码，再下翻下载所需要的预训练模型.
1.8安装requirements.txt
1.8.1 yolov8安装
对于旧版本的yolov8项目，自带的有requirement.txt文件，可以用命令下载相关依赖：
pip install -r requirements.txt -i https://pypi.douban.com/simple对于最新版本的yolov8项目，没有requirement.txt文件，可以在yolov8环境中，输入如下命令：
pip install ultralytics1.8.2 yolov10环境安装安装
conda activate yolov10
pip install -r requirements.txt -i https://pypi.douban.com/simple
pip install -e .1.8.3 yolo11环境安装
和yolov8一样，命令如下：
pip install ultralytics1.9安装标注工具labelImg
可以重新创建一个LabelImg独立环境，在独立环境中进行单独安装
conda create -n labelImg python=3.8.10pip install labelImg https://pypi.mirrors.ustc.edu.cn/simple启动Labelmg
LabelImg
如何标注自己的数据集？请参考这个链接：
LabelImg 安装与使用_labelimg安装-CSDN博客
将准备好的图片以.jpg的格式放入images文件夹中
利用labelimg进行标注后将生成的.xml文件保存至Annotations文件夹中
以上内容都是环境配置，看着就挺麻烦的，习惯就好。
二、创建个人数据集
创建个人数据集，yolov8、yolov10和yolo11都是一样的，保持一样就行。
2.1创建数据文件夹
（1）在ultralytics-main目录下新建data文件夹；
（2）再在data目录下新建四个文件夹:Annotations文件夹，images文件夹，ImageSets文件夹，labels文件夹。
其中：
- Annotations文件夹存放的是标注图片产生xml文件；
- images文件夹存放的是原始图片文件；
- ImageSets文件夹是将数据集划分为训练集train.txt、验证集val.txt、测试集test.txt，里面存放的就是用于训练、验证、测试的图片名称；
- labels文件夹存放的是图片的txt文件，还会在data文件夹下得到三个包含数据集路径的txt文件，train.txt，test.txt，val.txt这3个txt文件为划分后图像所在位置的绝对路径。
如下图所示：
2.2数据集划分
在ultralytics-main目录下创建数据集划分类（split.py），运行该类，数据集将进行划分。包括：训练、测试和验证数据集。
import os
import random
trainval_percent = 0.9
train_percent = 0.9
xmlfilepath = 'data/Annotations'
txtsavepath = 'data/ImageSets'
total_xml = os.listdir(xmlfilepath)
num = len(total_xml)
list = range(num)
tv = int(num * trainval_percent)
tr = int(tv * train_percent)
trainval = random.sample(list, tv)
train = random.sample(trainval, tr)
ftrainval = open('data/ImageSets/trainval.txt', 'w')
ftest = open('data/ImageSets/test.txt', 'w')
ftrain = open('data/ImageSets/train.txt', 'w')
fval = open('data/ImageSets/val.txt', 'w')
for i in list:
name = total_xml[i][:-4] + '\n'
if i in trainval:
ftrainval.write(name)
if i in train:
ftrain.write(name)
else:
fval.write(name)
else:
ftest.write(name)
ftrainval.close()
ftrain.close()
fval.close()
ftest.close()运行结果如下：
2.3转化数据集格式
在ultralytics-main目录下创建一个voc_label.py文件，运行下面代码后会生成转换后labels文件夹下图片的txt文件。
txt文件是yolo训练使用的专用格式文件，而我们用LabelImg标注产生的文件是xml文件，所以需要把xml文件转换为txt文件。
其中classes字段需要填写自己的训练类别，和xml文件中的<object>下面的<name>标签保持一致，有几个类别就写几个。比如标签是dog,就填写classes = ['dog']
import xml.etree.ElementTree as ET
import os
from os import getcwd
sets = ['train', 'val', 'test']
classes = ['填写自己的类别']
abs_path = os.getcwd()
print(abs_path)
def convert(size, box):
dw = 1. / (size[0])
dh = 1. / (size[1])
x = (box[0] + box[1]) / 2.0 - 1
y = (box[2] + box[3]) / 2.0 - 1
w = box[1] - box[0]
h = box[3] - box[2]
x = x * dw
w = w * dw
y = y * dh
h = h * dh
return x, y, w, h
def convert_annotation(image_id):
in_file = open('data/Annotations/%s.xml' % (image_id), encoding='UTF-8')
out_file = open('data/labels/%s.txt' % (image_id), 'w')
tree = ET.parse(in_file)
root = tree.getroot()
size = root.find('size')
w = int(size.find('width').text)
h = int(size.find('height').text)
for obj in root.iter('object'):
# difficult = obj.find('difficult').text
difficult = obj.find('difficult').text
cls = obj.find('name').text
if cls not in classes or int(difficult) == 1:
continue
cls_id = classes.index(cls)
xmlbox = obj.find('bndbox')
b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text),
float(xmlbox.find('ymax').text))
b1, b2, b3, b4 = b
# 标注越界修正
if b2 > w:
b2 = w
if b4 > h:
b4 = h
b = (b1, b2, b3, b4)
bb = convert((w, h), b)
out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
wd = getcwd()
for image_set in sets:
if not os.path.exists('data/labels/'):
os.makedirs('data/labels/')
image_ids = open('data/ImageSets/%s.txt' % (image_set)).read().strip().split()
list_file = open('data/%s.txt' % (image_set), 'w')
for image_id in image_ids:
list_file.write(abs_path + '/data/images/%s.jpg\n' % (image_id))
convert_annotation(image_id)
list_file.close()2.4创建数据集配置yaml文件
在ultralytics-main目录下创建 yolov8s_demo.yaml，nc和names字段要自己进行填写，names要和2.3的classes字段保持一致。代码内容如下：
train: D:/ultralytics-main/data/train.txt
val: D:/ultralytics-main/data/val.txt
test: D:/ultralytics-main/data/test.txt
nc: 5 # 填写类别数
names: ["填写自己的类别"] # 要和voc_label.py中的类别数目顺序一模一样
# train,val,test的路径根据自己情况而定以上就是创建个人数据集的全部内容。
如果感觉复杂，这里还有一种数据集创建的方法，具体请参考地址如下：
手把书教你使用YOLOv8训练自己的数据集(附YOLOv8模型结构图)_yolov8 训练数据集-CSDN博客
三、训练数据集
打开pycharm终端，运行以下代码，可以自己修改代码参数：
yolo train data=wheat.yaml model=yolov8s.pt epochs=300 imgsz=640 batch=8 workers=0 device=cpu其中：
- data为yaml配置文件，后边填写自己的配置文件的相对/绝对路径
- model为下载的预训练模型，之前下载的 yolov8s.pt 权重文件。
- epochs为训练轮数
- imagez为训练时ai看到的图片大小，检查大图片建议使用640，小图片可以320 越大越吃性能
- batch为一轮训练中每一次放入图片数量，越大越快效果越好，但是对性能要求越高
- device为使用的设备，使用cpu练就写cpu，使用显卡大多数都是0
运行代码后，执行结果如下图所示，开始训练
训练完成后，生成的的权重文件如下图所示：
也可以使用代码进行训练操作，注意需要替换自己的参数地址：
import os
# os.environ["OMP_NUM_THREADS"]='2'
""""
data：数据集配置文件的路径，指定用于训练的数据集配置文件
epochs：训练过程中整个数据集将被迭代多少次。
imgsz：用于设置输入图像尺寸。训练时，只能是整数32的倍数，测试和预测时，可以使用设置[1920,1080]。
batch：每个批次中的图像数量。
workers：用于设置数据加载过程中的线程数
device：模型运行的设置，多gpu时，用列表表示
cos_lr：余弦学习率调度器，设置为True可以帮助模型在训练过程中按照余弦函数的形状调整学习率，从而在训练初期使用较高的学习率，有助于快速收敛，而在训练后期逐渐降低学习率，有助于细致调整模型参数
close_mosaic：用于确定是否在最后几个训练周期中禁用马赛克数据增强
warmup_epochs：预热学习轮数，学习率从低值逐渐增加到初始学习率，以在早期稳定训练
"""
from ultralytics import YOLO
if __name__ == "__main__":
# Load a model
model_yaml = "ultralytics/cfg/models/v8/yolov8.yaml"
data_yaml = "wheat.yaml"
pre_model = "yolov8n.pt"
model = YOLO(model_yaml, task='detect').load(pre_model) # build from YAML and transfer weights
# model = YOLO(pre_model, task='detect') # load a pretrained model (recommended for training)
# Train the model
results = model.train(data=data_yaml, epochs=20, imgsz=640, batch=16, workers=8, device="cpu",
cos_lr=True, close_mosaic=200, waryolov8和yolo11训练代码相同，yolov10需要改一下包，如下：
from ultralytics import YOLOv10四、模型推理
用刚才自己训练的模型进行推理，model为自己模型的地址，source为测试的图片地址，可自行替换，代码如下：
yolo predict model=yolov8n.pt source='ultralytics/assets/bus.jpg'
使用代码进行推理，yolov10需要改一下包：
from ultralytics import YOLOv10# -*- coding: utf-8 -*-
from ultralytics import YOLO
#导入已经训练好的模型
model=YOLO('runs/detect/train6/weights/best.pt')
#图片或视频数据都可以，直接将数据传入接口即可
model.predict('datasets/phoneandmouse/test/images/4543aa199a884d46e28345e3835cc6b1.jpg',save=True)
model.predict('datasets/phoneandmouse/test/images/611576d261acf0f080a0ff226d9687a6.jpg',save=True)
model.predict('datasets/phoneandmouse/test/images/672368864be9e37074513e6e0acf3830.mp4',save=True)
推理结果保存路径：
五、Qt界面推理
可以简单的写个页面，或者让chatgpt写一个页面，可以更直观的看到推理过程：
from PySide6 import QtWidgets, QtCore, QtGui
import cv2 as cv
import os, time
from threading import Thread
# 屏蔽YOLO处理输出的调试信息
os.environ['YOLO_VERBOSE'] = 'False'
from ultralytics import YOLO
class MWindow(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
# 设置界面
self.setupUI()
self.camBtn.clicked.connect(self.startCamera)
self.videoBtn.clicked.connect(self.startVideoFile)
self.stopBtn.clicked.connect(self.stop)
# 定义定时器，用于控制显示摄像头视频的帧率
self.timer_camera = QtCore.QTimer()
# 定时到了，回调 self.show_camera
self.timer_camera.timeout.connect(self.show_camera)
# 加载 YOLO nano 模型，第一次比较耗时，要20秒左右
self.model = YOLO('yolov8m.pt')
# 要处理的视频帧图片队列，目前就放1帧图片
self.frameToAnalyze = []
# 启动处理视频帧独立线程
Thread(target=self.frameAnalyzeThreadFunc,daemon=True).start()
# 定义定时器，用于控制显示视频文件的帧率
self.timer_videoFile = QtCore.QTimer()
# 定时到了，回调 self.show_camera
self.timer_videoFile.timeout.connect(self.show_videoFile)
# 当前要播放的视频帧号
self.vframeIdx = 0
# cv.VideoCapture 实例
self.cap = None
self.stopFlag = False
def setupUI(self):
self.resize(1200, 800)
self.setWindowTitle(' YOLOv10-PyQt Demo')
# central Widget
centralWidget = QtWidgets.QWidget(self)
self.setCentralWidget(centralWidget)
# central Widget 里面的 主 layout
mainLayout = QtWidgets.QVBoxLayout(centralWidget)
# 界面的上半部分 : 图形展示部分
topLayout = QtWidgets.QHBoxLayout()
self.label_ori_video = QtWidgets.QLabel(self)
self.label_treated = QtWidgets.QLabel(self)
self.label_ori_video.setFixedSize(520,400)
self.label_treated.setFixedSize(520,400)
# self.label_ori_video.setMinimumSize(520,400)
# self.label_treated.setMinimumSize(520,400)
self.label_ori_video.setStyleSheet('border:1px solid #D7E2F9;')
self.label_treated.setStyleSheet('border:1px solid #D7E2F9;')
topLayout.addWidget(self.label_ori_video)
topLayout.addWidget(self.label_treated)
mainLayout.addLayout(topLayout)
# 界面下半部分： 输出框 和 按钮
groupBox = QtWidgets.QGroupBox(self)
bottomLayout = QtWidgets.QHBoxLayout(groupBox)
self.textLog = QtWidgets.QTextBrowser()
bottomLayout.addWidget(self.textLog)
mainLayout.addWidget(groupBox)
btnLayout = QtWidgets.QVBoxLayout()
self.videoBtn = QtWidgets.QPushButton('🎞️视频文件')
self.camBtn = QtWidgets.QPushButton('📹摄像头')
self.stopBtn = QtWidgets.QPushButton('🛑停止')
btnLayout.addWidget(self.videoBtn)
btnLayout.addWidget(self.camBtn)
btnLayout.addWidget(self.stopBtn)
bottomLayout.addLayout(btnLayout)
def startCamera(self):
# 参考 https://docs.opencv.org/3.4/dd/d43/tutorial_py_video_display.html
# 在 windows上指定使用 cv.CAP_DSHOW 会让打开摄像头快很多，
# 在 Linux/Mac上 指定 V4L, FFMPEG 或者 GSTREAMER
self.cap = cv.VideoCapture(0, cv.CAP_DSHOW)
if not self.cap.isOpened():
print("1号摄像头不能打开")
return
if self.timer_camera.isActive() == False: # 若定时器未启动
self.timer_camera.start(30)
self.stopFlag = False
def show_camera(self):
ret, frame = self.cap.read() # 从视频流中读取
if not ret:
return
# 把读到的帧的大小重新设置
frame = cv.resize(frame, (520, 400))
self.setFrameToOriLabel(frame)
def setFrameToOriLabel(self,frame):
# 视频色彩转换回RGB，OpenCV images as BGR
frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB)
qImage = QtGui.QImage(frame.data, frame.shape[1], frame.shape[0],
QtGui.QImage.Format_RGB888) # 变成QImage形式
# 往显示视频的Label里 显示QImage
self.label_ori_video.setPixmap(QtGui.QPixmap.fromImage(qImage))
# 如果当前没有处理任务
if not self.frameToAnalyze:
self.frameToAnalyze.append(frame)
def frameAnalyzeThreadFunc(self):
while True:
if not self.frameToAnalyze:
time.sleep(0.01)
continue
frame = self.frameToAnalyze.pop(0)
results = self.model(frame)[0]
img = results.plot(line_width=1)
qImage = QtGui.QImage(img.data, img.shape[1], img.shape[0],
QtGui.QImage.Format_RGB888) # 变成QImage形式
if self.stopFlag == False:
self.label_treated.setPixmap(QtGui.QPixmap.fromImage(qImage)) # 往显示Label里 显示QImage
time.sleep(0.5)
def stop(self, ):
self.stopFlag = True # 让 frameAnalyzeThreadFunc 不要再设置 label_treated
self.timer_camera.stop() # 关闭定时器
self.timer_videoFile.stop() # 关闭定时器
if self.cap:
self.cap.release() # 释放视频流
# 清空视频显示区域
self.label_ori_video.clear()
self.label_treated.clear()
# # 延时500ms清除，有的定时器处理任务可能会在当前时间点后处理完最后一帧
# QtCore.QTimer.singleShot(500, clearLabels)
def startVideoFile(self):
# 先关闭原来打开的
self.stop()
videoPath, _ = QtWidgets.QFileDialog.getOpenFileName(
self, # 父窗口对象
"选择视频文件", # 标题
".", # 起始目录
"图片类型 (*.mp4 *.avi)" # 选择类型过滤项，过滤内容在括号中
)
print('videoPath is', videoPath)
if not videoPath:
return
self.cap = cv.VideoCapture(videoPath)
if not self.cap.isOpened():
print("打开文件失败")
return
self.timer_videoFile.start(30)
self.stopFlag = False
print("ok")
def show_videoFile(self):
# 选取视频帧位置，
self.cap.set(cv.CAP_PROP_POS_FRAMES, self.vframeIdx)
self.vframeIdx += 1
ret, frame = self.cap.read() # 从视频流中读取
# 读取失败，应该是视频播放结束了
if not ret:
self.stop()
return
self.setFrameToOriLabel(frame)
app = QtWidgets.QApplication()
window = MWindow()
window.show()
app.exec()
效果展示：
期待下次更新吧！！！