YOLOv8环境搭建、创建数据集、训练推理教程（超级详细）

yolov8和yolov10 是一个流派，和yolov5区别还挺大，所以尝试使用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的独立环境。

启动Anaconda，创建yolov8独立环境，命令如下：

（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源代码下载

可以去github官网下载，但是需要梯子，其实国内网站同步更新，可在国内网站进行下载使用：

GitCode - 全球开发者的开源社区,开源代码托管平台

yolov8源码地址往下翻，找到权重文件，点击下载顺便一同放入之前下载的源码里 ，可以下载yolov8s.pt文件放在根目录中。

1.8安装requirements.txt

对于旧版本的yolov8项目，自带的有requirement.txt文件，可以用命令下载相关依赖：

 pip install -r requirements.txt  -i https://pypi.douban.com/simple

对于最新版本的yolov8项目，没有requirement.txt文件，可以在yolov8环境中，输入如下命令：

pip install ultralytics

1.9安装标注工具labelImg

可以重新创建一个LabelImg独立环境，在独立环境中进行单独安装

conda create -n labelImg python=3.8.10

pip install labelImg  https://pypi.mirrors.ustc.edu.cn/simple

 启动Labelmg

LabelImg

如何标注自己的数据集？请参考这个链接：

LabelImg 安装与使用_labelimg安装-CSDN博客
将准备好的图片以.jpg的格式放入images文件夹中
利用labelimg进行标注后将生成的.xml文件保存至Annotations文件夹中

二、创建个人数据集

2.1建数据文件夹

（1）在ultralytics-main目录下新建data文件夹；

（2）再在data目录下新建四个文件夹:Annotations文件夹，images文件夹，ImageSets文件夹，labels文件夹。

其中：

1. Annotations文件夹存放的是标注图片产生xml文件；
2. images文件夹存放的是原始图片文件；
3. ImageSets文件夹是将数据集划分为训练集train.txt、验证集val.txt、测试集test.txt，里面存放的就是用于训练、验证、测试的图片名称；
4. 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的路径根据自己情况而定

 以上就是创建个人数据集的全部内容。

三、训练数据集

打开pycharm终端，运行以下代码，可以自己修改代码参数：

yolo train data=wheat.yaml model=yolov8s.pt epochs=300 imgsz=640 batch=8 workers=0 device=cpu

其中：

1. data为yaml配置文件，后边填写自己的配置文件的相对/绝对路径
2. model为下载的预训练模型，之前下载的 yolov8s.pt 权重文件。
3. epochs为训练轮数
4. imagez为训练时ai看到的图片大小，检查大图片建议使用640，小图片可以320 越大越吃性能
5. batch为一轮训练中每一次放入图片数量，越大越快效果越好，但是对性能要求越高
6. device为使用的设备，使用cpu练就写cpu，使用显卡大多数都是0 

运行代码后，执行结果如下图所示，开始训练

训练完成后，生成的的权重文件如下图所示：

 

四、模型推理

用刚才自己训练的模型进行推理，model为自己模型的地址，source为测试的图片地址，可自行替换，代码如下：

yolo predict model=yolov8n.pt source='ultralytics/assets/bus.jpg'

 使用代码进行推理：

# -*- 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()

效果展示：

 后续继续更新yolov8的训练优化和部署内容。 

期待下次更新吧！！！