跳到主要内容

YoloV5的目标模型训练方法

检测目标​

确定需要检测的目标，如检测苹果、香蕉、橙子三种类型的水果

确定了检测目标，可以下载相应的数据集，如下载paddle paddle（百度飞浆）提供数据集，也可制作自己的数据集，下载相应的图片，通过AI数据标注软件（如labelme）和TensorFlow生成自己的数据集

训练步骤​

下载yolov5代码​

进入 https://github.com/ultralytics/yolov5/tree/v5.0 下载yolov5源码

环境安装​

进入刚下载的yolov5目录下，在CMD终端里输入：pip install -r requirements.txt然后回车

数据集​

这里使用paddle paddle（百度飞浆）提供的数据集，下载后放到yolov5目录下，文件夹名fruit_detection，目录下有两个文件夹Annotations和JPEGImages，分别存放解析后的数据文件和图片资源文件，其中文件apple_1.xml对应是就\JPEGImages\apple_1.jpg文件

<annotation>
	<folder>train</folder>
	<filename>apple_1.jpg</filename>
	<path>C:\tensorflow1\models\research\object_detection\images\train\apple_1.jpg</path>
	<source>
		<database>Unknown</database>
	</source>
	<size>
		<width>349</width>
		<height>349</height>
		<depth>3</depth>
	</size>
	<segmented>0</segmented>
	<object>
		<name>apple</name>
		<pose>Unspecified</pose>
		<truncated>0</truncated>
		<difficult>0</difficult>
		<bndbox>
			<xmin>8</xmin>
			<ymin>15</ymin>
			<xmax>331</xmax>
			<ymax>349</ymax>
		</bndbox>
	</object>
</annotation>

这个XML中object节点下的name就是类别名，很重要，就是训练时要配置的类名，也是识别后标识的名称

如：

图片

通过标注生成的VOC文件(xml格式)

<annotation>
	<folder>train</folder>
	<filename>apple_1.jpg</filename>
	<path>C:\tensorflow1\models\research\object_detection\images\train\apple_1.jpg</path>
	<source>
		<database>Unknown</database>
	</source>
	<size>
		<width>349</width>
		<height>349</height>
		<depth>3</depth>
	</size>
	<segmented>0</segmented>
	<object>
		<name>apple</name>
		<pose>Unspecified</pose>
		<truncated>0</truncated>
		<difficult>0</difficult>
		<bndbox>
			<xmin>8</xmin>
			<ymin>15</ymin>
			<xmax>331</xmax>
			<ymax>349</ymax>
		</bndbox>
	</object>
</annotation>

转成txt格式后

0 0.48567335243553006 0.5214899713467048 0.9255014326647564 0.9570200573065902

xml格式的标注文件转为txt格式​

VOC标签格式转yolo格式并划分训练集和测试集

下载数据集资源标签的格式都是VOC(xml格式)的，用yolov5训练所需要的文件格式是yolo(txt格式)的，所以要对xml格式的标签文件转换为txt文件。同时训练自己的yolov5检测模型的时候，数据集需要划分为训练集和验证集。

在yolov5目录下新建一个.py文件，如（make.py)，将以下代码复制进去并执行，执行完成会在数据集fruit_detection目录下产生images，labels，YOLOLabels文件夹

import xml.etree.ElementTree as ET
import pickle
import os
from os import listdir, getcwd
from os.path import join
import random
from shutil import copyfile

# 此函数用作把xml格式的标签，转为txt格式，并划分训练集合测试集
classes = ['apple', 'banana', 'orange']
# 训练集占得比例，80就是占80%
TRAIN_RATIO = 80

# 要处理的数据的主目录。前面的r不能删，后面的/一定要带上
dir1 = r"fruit_detection/"
# 要处理的数据的子目录。前面的r不能删，后面的/一定要带上
dir2 = r""

# 输入的图片所在的文件夹的名字。前面的r不能删，后面的/一定要带上
input_picPath_dir_name = r"JPEGimages/"
# 输入的xml标签所在的文件夹的名字。前面的r不能删，后面的/一定要带上
input_xmlPath_dir_name = r"Annotations/"
# 输出的txt标签所在的文件夹的名字。前面的r不能删，后面的/一定要带上
output_txtPath_dir_name = r"YOLOLabels/"

# 输入的图片所在文件夹路径。前面的r不能删，后面的/一定要带上
input_picPath = r"%s/%s/%s" % (dir1, dir2, input_picPath_dir_name)
# 输入的xml标签文件保存路径。前面的r不能删，后面的/一定要带上
input_xmlPath = r"%s/%s/%s" % (dir1, dir2, input_xmlPath_dir_name)
# 输出的txt标签所在文件夹路径。前面的r不能删，后面的/一定要带上
output_txtPath = r"%s/%s/%s" % (dir1, dir2, output_txtPath_dir_name)


def clear_hidden_files(path):
    dir_list = os.listdir(path)
    for i in dir_list:
        abspath = os.path.join(os.path.abspath(path), i)
        if os.path.isfile(abspath):
            if i.startswith("._"):
                os.remove(abspath)
        else:
            clear_hidden_files(abspath)


def convert(size, box):
    dw = 1. / size[0]
    dh = 1. / size[1]
    x = (box[0] + box[1]) / 2.0
    y = (box[2] + box[3]) / 2.0
    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):
    # print(os.path.exists('%s/%s.xml' % (input_xmlPath, image_id)))
    # print('%s/%s.txt' % (output_txtPath, image_id))
    # exit()
    in_file = open('%s/%s.xml' % (input_xmlPath, image_id))
    out_file = open('%s/%s.txt' % (output_txtPath, 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
        # 这里可能要改，类别的名字，打开你的xml文件看看里边叫什么
        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))
        bb = convert((w, h), b)
        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
    in_file.close()
    out_file.close()


wd = os.getcwd()
data_base_dir = os.path.join(wd, dir1)
if not os.path.isdir(data_base_dir):
    os.mkdir(data_base_dir)
work_sapce_dir = os.path.join(data_base_dir, dir2)
if not os.path.isdir(work_sapce_dir):
    os.mkdir(work_sapce_dir)
annotation_dir = os.path.join(work_sapce_dir, input_xmlPath_dir_name)
if not os.path.isdir(annotation_dir):
    os.mkdir(annotation_dir)
clear_hidden_files(annotation_dir)
image_dir = os.path.join(work_sapce_dir, input_picPath_dir_name)
if not os.path.isdir(image_dir):
    os.mkdir(image_dir)
clear_hidden_files(image_dir)
yolo_labels_dir = os.path.join(work_sapce_dir, output_txtPath_dir_name)
if not os.path.isdir(yolo_labels_dir):
    os.mkdir(yolo_labels_dir)
clear_hidden_files(yolo_labels_dir)
yolov5_images_dir = os.path.join(data_base_dir, "images/")
if not os.path.isdir(yolov5_images_dir):
    os.mkdir(yolov5_images_dir)
clear_hidden_files(yolov5_images_dir)
yolov5_labels_dir = os.path.join(data_base_dir, "labels/")
if not os.path.isdir(yolov5_labels_dir):
    os.mkdir(yolov5_labels_dir)
clear_hidden_files(yolov5_labels_dir)
yolov5_images_train_dir = os.path.join(yolov5_images_dir, "train/")
if not os.path.isdir(yolov5_images_train_dir):
    os.mkdir(yolov5_images_train_dir)
clear_hidden_files(yolov5_images_train_dir)
yolov5_images_test_dir = os.path.join(yolov5_images_dir, "val/")
if not os.path.isdir(yolov5_images_test_dir):
    os.mkdir(yolov5_images_test_dir)
clear_hidden_files(yolov5_images_test_dir)
yolov5_labels_train_dir = os.path.join(yolov5_labels_dir, "train/")
if not os.path.isdir(yolov5_labels_train_dir):
    os.mkdir(yolov5_labels_train_dir)
clear_hidden_files(yolov5_labels_train_dir)
yolov5_labels_test_dir = os.path.join(yolov5_labels_dir, "val/")
if not os.path.isdir(yolov5_labels_test_dir):
    os.mkdir(yolov5_labels_test_dir)
clear_hidden_files(yolov5_labels_test_dir)

train_file = open(os.path.join(wd, "yolov5_train.txt"), 'w')
test_file = open(os.path.join(wd, "yolov5_val.txt"), 'w')
train_file.close()
test_file.close()
train_file = open(os.path.join(wd, "yolov5_train.txt"), 'a')
test_file = open(os.path.join(wd, "yolov5_val.txt"), 'a')
list_imgs = os.listdir(image_dir)  # list image files
prob = random.randint(1, 100)
print("Probability: %d" % prob)

for i in range(0, len(list_imgs)):
    path = os.path.join(image_dir, list_imgs[i])
    if os.path.isfile(path):
        image_path = image_dir + list_imgs[i]
        voc_path = list_imgs[i]
        (nameWithoutExtention, extention) = os.path.splitext(os.path.basename(image_path))
        (voc_nameWithoutExtention, voc_extention) = os.path.splitext(os.path.basename(voc_path))
        annotation_name = nameWithoutExtention + '.xml'
        annotation_path = os.path.join(annotation_dir, annotation_name)
        label_name = nameWithoutExtention + '.txt'
        label_path = os.path.join(yolo_labels_dir, label_name)
    prob = random.randint(1, 100)
    print("Probability: %d" % prob)
    if (prob < TRAIN_RATIO):  # train dataset
        if os.path.exists(annotation_path):
            train_file.write(image_path + '\n')
            convert_annotation(nameWithoutExtention)  # convert label
            copyfile(image_path, yolov5_images_train_dir + voc_path)
            copyfile(label_path, yolov5_labels_train_dir + label_name)
    else:  # test dataset
        if os.path.exists(annotation_path):
            test_file.write(image_path + '\n')
            convert_annotation(nameWithoutExtention)  # convert label
            copyfile(image_path, yolov5_images_test_dir + voc_path)
            copyfile(label_path, yolov5_labels_test_dir + label_name)
train_file.close()
test_file.close()

下载预训练权重​

下载地址：https://github.com/ultralytics/yolov5/releases

以下载yolov5s.pt权重为例，找到yolov5s.pt，点击下载，下载后放到yolov5目录下weights文件夹下面

四种网络深度比较

网络深度是指网络的总层数。从下图中可以看出在s, m, l ,x四种版本中的CSP1_X中的X不同，而X表示Res Units的个数， Res Units越多，层数就越深。

以YOLOv5s为例，如下图所示，第一个BottleneckCSP层中的参数3记为n，YOLOv5s的深度参数为0.33记为gd，CSP1_X中的X表示残差组件数量，X = n * gd = 3 * 0.33 = 1。同理，第二个BottleneckCSP层中的n为9，CSP1_X中的X=3，就和上图的第二个CSP1对应起来了。YOLOv5m、YOLOv5l、YOLOv5x同理。

四种网络宽度

修改.yaml配置文件​

  1. 修改数据集配置文件：在data下找到voc.yaml,将其复制一份，并重命名为fruit_detection.yaml，然后打开它。需要修改的地方就只有3个，train和val改成你的训练和测试集的路径，nc改成你的类别数，names改成你的类别名，如图所示：

    这里class names就是上面提到的数据集xml文件中object的name

  2. **修改模型配置文件：**在models下找到yolov5s.yaml,将其复制一份，并重命名为fruit_detection.yaml，然后打开它。（这里使用的是yolov5s.pt这个权重，所以复制的是yolov5s.yaml这个配置文件，不同的权重对应不同的配置文件）需要修改的地方只有1个，把nc改成你的数据集类别数即可，如图所示：

修改train.py（训练）文件​

只需修改4行：，weights、cfg、data、epochs和batch-size，如图所示： weights：是下载的预训练的权重路径，照着我们操作的，就填：r'weights/yolov5s.pt' cfg：是模型配置文件的路径，照着我们操作的，就填：r'models/fruit_detection.yaml' data：是数据集配置文件的路径，照着我们操作的，就填：r'data/fruit_detection.yaml' epochs：是训练次数，我这里设置成200次，可以得到比较好的效果 batch-size：是训练的批次，尽量不要设置的太大，会报CUDA显存不足的错误，我的RTX 2080ti显卡有11g，所以batch-size设置成50，是可以运行的。如果只有6g显存的朋友，设置成25估计是可以运行的

常用的参数说明

	# --weights：初始化的权重文件的路径地址
    # --cfg：模型yaml文件的路径地址
    # --data：数据yaml文件的路径地址
    # --hyp：超参数文件路径地址
    # --epochs：训练轮次
    # --batch - size：喂入批次文件的多少
    # --img - size：输入图片尺寸
    # --rect: 是否采用矩形训练，默认False
    # --resume: 接着打断训练上次的结果接着训练
    # --nosave: 不保存模型，默认False
    # --notest: 不进行test，默认False
    # --noautoanchor: 不自动调整anchor，默认False
    # --evolve: 是否进行超参数进化，默认False
    # --bucket: 谷歌云盘bucket，一般不会用到
    # --cache - images: 是否提前缓存图片到内存，以加快训练速度，默认False
    # --image - weights：使用加权图像选择进行训练
    # --device: 训练的设备，cpu；0(表示一个gpu设备cuda: 0)；0, 1, 2, 3(多个gpu设备)
    # --multi - scale: 是否进行多尺度训练，默认False
    # --single - cls: 数据集是否只有一个类别，默认False
    # --adam: 是否使用adam优化器
    # --sync - bn: 是否使用跨卡同步BN, 在DDP模式使用
    # --local_rank：DDP参数，请勿修改
    # --workers：最大工作核心数
    # --project: 训练模型的保存位置
    # --name：模型保存的目录名称
    # --exist - ok：模型目录是否存在，不存在就创建

修改其他py文件​

  1. window的用户，在utils文件夹下，找到datasets.py这个文件，把里面的110附近行里面的参数num_workers改成0，如果未找到可以不改，如图所示：

  2. 复制以下代码到models文件夹的common.py里，粘贴到最下面即可

class SPPF(nn.Module):
    # Spatial Pyramid Pooling - Fast (SPPF) layer for YOLOv5 by Glenn Jocher
    def __init__(self, c1, c2, k=5):  # equivalent to SPP(k=(5, 9, 13))
        super().__init__()
        c_ = c1 // 2  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c_ * 4, c2, 1, 1)
        self.m = nn.MaxPool2d(kernel_size=k, stride=1, padding=k // 2)

    def forward(self, x):
        x = self.cv1(x)
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')  # suppress torch 1.9.0 max_pool2d() warning
            y1 = self.m(x)
            y2 = self.m(y1)
            return self.cv2(torch.cat([x, y1, y2, self.m(y2)], 1))

运行train.py文件开始训练​

运行train.py文件后，如果看到以下界面，已经成功地开始训练YOLO了！耐心等待训练结束即可，时间非常慢长，训练会在yolov5目录下产生文件夹\runs\train\exp\，exp目录下就是训练结果相关文件，其中weights目录下会产生两个训练的模型文件best.pt和last.bt。

运行detect.py文件进行测试​

成功运行结束后，根据提示在指定的输出目录查看测试效果，结束如图：

最后更新时间: 2026/7/31 13:40:36|访问次数: 0|豫ICP备2025159864号|