本文详细介绍了如何使用YOLOv5进行目标检测，包括环境配置、数据准备、模型训练、测试及推理的全过程。从创建conda环境、安装依赖，到转换COCO格式标注数据，再到训练模型和批量检测，每个步骤都有清晰的代码示例。最后，文章还展示了如何将检测结果保存为txt和json格式。
一、环境配置所需资源
本教程使用到的工具有：
1.anaconda, pycharm
2.cuda≥10.1, cudnn与cuda版本对应上
3.pytorch≥1.7.0
二、前期准备
2.1 创建新环境并进入新环境
YOLOv5要求Python≥3.6.0，接下来的代码和例子均以我们服务器上的配置为例：
conda create -n test python=3.8 #选择自己的服务器名称
conda activate test
2.2 下载源代码
git clone https://github.com/ultralytics/yolov5.git
2.3 配置环境
首先我们需要根据自己CUDA版本安装PyTorch，具体可以参考PyTorch官网：https://pytorch.org/ (历史版本的可以在这里选择：https://pytorch.org/get-started/previous-versions/)
，例如这里我们只需要运行命令：
conda install pytorch torchvision torchaudio cudatoolkit=10.1 -c pytorch
接下来根据requirements.txt文件配置环境，或者直接在当前环境中执行：
pip install -r requirements.txt
在国内通常情况下，下载速度可能比较慢，而且随时可能会被中断。所以这里我们使用国内的一些镜像，例如清华镜像：
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
2.4 下载权重文件
进入/yolov5/weights/ 文件夹下，执行./download_weights.sh，会将最新的四种模型的配置文件下载到yolov5文件夹下。如果这种方式下载不了或者下载速度太慢，可以到官网上根据需要自行下载并放入项目文件夹yolov5中。
2.5测试
cd yolov5
python detect.py --source data/images --weights yolov5s.pt --conf 0.25
检测结果会保存到yolov5/runs/detect/exp文件夹下，原图在data/images文件夹中。
三、源码结构
Pytorch版本的YOLOv5 源码的一些参数设置如下所示：
-
train.py : 训练
-
test.py : 测试COCO指标
-
detect.py ：批量检测图片并生成检测图像；
-
data文件夹：包含自带验证的两张图像和相应训练数据地址，类别数量，类别名称等配置；
-
models文件夹： 包含网络结构的yaml文件以及网络实现所需的脚本文件；
-
runs文件夹： 包含每次执行detect.py / test.py / train.py 的结果；
-
utils文件夹： 包含网络训练、验证、测试所需要的脚本文件；
-
weights文件夹： 下载预训练脚本的.sh文件。
四、整体流程
4.1 准备自己的数据集
在yolov5同一级的目录下创建自己的数据集文件夹（例如我们这里文件夹的名字为waste）。
train: ../waste/train/images
val: ../waste/valid/images
test: ../waste/test/images
nc: 2
names: ['rubbish', 'no-rubbish']
训练集和验证集的文件夹中需要包含图片和对应标注的文件夹。
4.2 将标注数据转化为 YOLO 需要的 txt 格式
YOLO需要的标注数据是每个图片一个 txt 文件，一行代表一个目标，格式是：
| class | x_center | y_center | width | height |
|---|---|---|---|---|
| 0 | 0.493359 | 0.891146 | 0.069531 | 0.071875 |
第一列是class的索引，计数从0开始，比如这里的0代表的是rubbish，1代表的是no-rubbish；后4列是x_center/image_width、y_center/image_height、width/image_width、height/image_height，取值范围是0 ~ 1。
而通常情况下，我们找到的标注文件可能是COCO格式的json格式文件，这就需要把json格式的标注数据转化为YOLO需要的 txt 格式。
COCO格式的json标注数据文件内容包含：
- name：图片文件名
- category：类别id
- bbox：目标框信息有[左上角x坐标，左上角y坐标，框在x轴方向上的长度，框在y轴方向上的长度]
例如以我们的UAVVaste垃圾数据集为例，COCO格式的json标注数据文件中一个标注框包含的信息如下：
{"id": 17,
"image_id": 3,
"category_id": 0,
"segmentation": [[814, 35, 875, 17, 885, 67, 832, 77]],
"area": 2818.0,
"bbox": [814, 17, 71, 60],
"iscrowd": 0,
"file_name":
"BATCH_d07_img_880.jpg",
"height": 2160,
"width": 3840}
将COCO格式的json标注数据文件转换为YOLOv5需要的txt文件代码如下：
import os
import json
json_dir = 'train_annos.json' # json文件路径
out_dir = 'output/' # 输出的 txt 文件路径
def main():
# 读取 json 文件数据
with open(json_dir, 'r') as load_f:
content = json.load(load_f)
# 循环处理
for t in content:
tmp = t['file_name'].split('.')
filename = out_dir + tmp[0] + '.txt'
if os.path.exists(filename):
# 计算 yolo 数据格式所需要的中心点的 相对 x, y 坐标, w,h 的值
x = (t['bbox'][0] + t['bbox'][2]/2) / t['width']
y = (t['bbox'][1] + t['bbox'][3]/2) / t['height']
w = (t['bbox'][2]) / t['width']
h = (t['bbox'][3]) / t['height']
fp = open(filename, mode="r+", encoding="utf-8")
file_str = str(t['category_id']+1) + ' ' + str(round(x, 6)) + ' ' + str(round(y, 6)) + ' ' + str(round(w, 6)) + \
' ' + str(round(h, 6))
line_data = fp.readlines()
if len(line_data) != 0:
fp.write('\n' + file_str)
else:
fp.write(file_str)
fp.close()
# 不存在则创建文件
else:
fp = open(filename, mode="w", encoding="utf-8")
fp.close()
# 计算 yolo 数据格式所需要的中心点的 相对 x, y 坐标, w,h 的值
x = (t['bbox'][0] + t['bbox'][2]/2) / t['width']
y = (t['bbox'][1] + t['bbox'][3]/2) / t['height']
w = (t['bbox'][2]) / t['width']
h = (t['bbox'][3]) / t['height']
fp = open(filename, mode="r+", encoding="utf-8")
file_str = str(t['category_id']+1) + ' ' + str(round(x, 6)) + ' ' + str(round(y, 6)) + ' ' + str(round(w, 6)) + \
' ' + str(round(h, 6))
line_data = fp.readlines()
if len(line_data) != 0:
fp.write('\n' + file_str)
else:
fp.write(file_str)
fp.close()
if __name__ == '__main__':
main()
4.3 模型训练 train.py
train.py用于模型的训练主要需要有如下参数进行传递，可以使用配置参数传递的方式，也可以在源码中进行修改。
参数解释如下：
- epochs：指的就是训练过程中整个数据集将被迭代多少次，显卡差就调小一些
- batch-size：一次看完多少张图片才进行权重更新，梯度下降的mini-batch，显卡差就调小一些
- cfg：存储模型结构的配置文件
- data：存储训练、测试数据的文件
- img-size：输入图片宽高,显卡不行你就调小点
- rect：进行矩形训练
- resume：恢复最近保存的模型开始训练
- nosave：仅保存最终checkpoint
- notest：仅测试最后的epoch
- evolve：进化超参数
- bucket：gsutil bucket
- cache-images：缓存图像以加快训练速度
- weights：权重文件路径
- name： 重命名results.txt to results_name.txt
- device：cuda device, i.e. 0 or 0,1,2,3 or cpu
- adam：使用adam优化
- multi-scale：多尺度训练，img-size +/- 50%
- single-cls：单类别的训练集
之后运行的训练命令如下：
python train.py --img 640 --batch 16 --epochs 100 --data ../waste/data.yaml --cfg models/yolov5s.yaml --weights ''
按照上图修改执行后，会在runs/train/exp文件夹下生成训练的相关文件，可以对--project和--name修改其保存路径。
其中，模型会保存在runs/train/exp/weights文件夹下，最终会保存两个模型，其一为 best.pt，其二为 last.pt。另外，还会包含训练过程中的结果图、日志等相关信息；hyp.yaml中汇总了模型中使用超参数的值，可以根据模型的效果进行进一步调整（数据增强）。
4.4 模型检测 test.py
detect.py用于批量生成检测结果，参数主要包含以下参数。同样可以使用修改源码和传递参数两种方式进行参数传递。
通过下面的命令进行模型测试：
python test.py --weight ./runs/train/exp/weights/best.pt --data ../waste/data.yaml --task test
模型测试效果如下：
4.5 模型推理 detect.py
detect.py用于批量生成检测结果，支持多种输入，如：images, videos, directories, webcams, rtsp 和 http streams。参数主要包含以下参数。同样可以使用修改源码和传递参数两种方式进行参数传递。
以图片为例，使用下面的命令（该命令中save_txt选项用于生成结果的txt标注文件，不指定则只会生成结果图像），其中，weights使用最好的训练模型即可，source则提供一个包含所有测试图片的文件夹路径即可。
python detect.py --weights runs/exp/weights/best.pt --source ../waste/test/images --save-txt
测试完毕后，每个测试图片会在指定的inference/output输出文件夹中生成结果图片和同名的txt文件，每个txt文件的格式与我们训练时候使用的txt文件格式相同，如下：
官方给出的detect.py文件只能输出txt格式的标注框，如果想要将标注框输出为json文件格式，则可以使用自己修改的detect.py代码：
import argparse
import os
import shutil
import time
from pathlib import Path
import json
import cv2
import torch
import torch.backends.cudnn as cudnn
from numpy import random
from models.experimental import attempt_load
from utils.datasets import LoadStreams, LoadImages
from utils.general import (
check_img_size, non_max_suppression, apply_classifier, scale_coords,
xyxy2xywh, strip_optimizer, set_logging)
from utils.plots import plot_one_box
from utils.torch_utils import select_device, load_classifier, time_synchronized
def detect(save_img=False):
# 获取设置的参数数据
out, source, weights, view_img, save_txt, imgsz = \
opt.save_dir, opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size
webcam = source.isnumeric() or source.startswith(('rtsp://', 'rtmp://', 'http://')) or source.endswith('.txt')
# Initialize
set_logging()
device = select_device(opt.device)
if os.path.exists(out): # output dir
shutil.rmtree(out) # delete dir
os.makedirs(out) # make new dir
# 如果设备为GPU时， 使用Float16
half = device.type != 'cpu' # half precision only supported on CUDA
# Load model 确保用户设定的输入图片分辨率能整除32(如不能则调整为能整除并返回)
model = attempt_load(weights, map_location=device) # load FP32 model
imgsz = check_img_size(imgsz, s=model.stride.max()) # check img_size
if half:
model.half() # to FP16
# Second-stage classifier 设置第二次分类，默认不使用
classify = False
if classify:
modelc = load_classifier(name='resnet101', n=2) # initialize
modelc.load_state_dict(torch.load('weights/resnet101.pt', map_location=device)['model']) # load weights
modelc.to(device).eval()
# Set Dataloader 通过不同的输入源来设置不同的数据加载方式
vid_path, vid_writer = None, None
if webcam:
view_img = True
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz)
else:
# save_img = True
save_img= opt.save_img
dataset = LoadImages(source, img_size=imgsz)
# Get names and colors
# 获取类别名字
names = model.module.names if hasattr(model, 'module') else model.names
# 设置画框的颜色
colors = [[random.randint(0, 255) for _ in range(3)] for _ in range(len(names))]
# Run inference
t0 = time.time()
# 进行一次前向推理,测试程序是否正常
img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img
_ = model(img.half() if half else img) if device.type != 'cpu' else None # run once
# 输出json文件
#save_json = True
save_json = opt.save_json
content_json = []
# path 图片/视频路径
# img 进行resize+pad之后的图片
# img0 原size图片
# cap 当读取图片时为None，读取视频时为视频源
for path, img, im0s, vid_cap in dataset:
img = torch.from_numpy(img).to(device)
# 图片也设置为Float16
img = img.half() if half else img.float() # uint8 to fp16/32
img /= 255.0 # 0 - 255 to 0.0 - 1.0
# 没有batch_size的话则在最前面添加一个轴
if img.ndimension() == 3:
img = img.unsqueeze(0)
# Inference
t1 = time_synchronized()
"""
前向传播 返回pred的shape是(1, num_boxes, 5+num_class)
h,w为传入网络图片的长和宽，注意dataset在检测时使用了矩形推理，所以这里h不一定等于w
num_boxes = h/32 * w/32 + h/16 * w/16 + h/8 * w/8
pred[..., 0:4]为预测框坐标
预测框坐标为xywh(中心点+宽长)格式
pred[..., 4]为objectness置信度
pred[..., 5:-1]为分类结果
"""
pred = model(img, augment=opt.augment)[0]
# Apply NMS
"""
pred:前向传播的输出
conf_thres:置信度阈值
iou_thres:iou阈值
classes:是否只保留特定的类别
agnostic:进行nms是否也去除不同类别之间的框
经过nms之后，预测框格式：xywh-->xyxy(左上角右下角)
pred是一个列表list[torch.tensor]，长度为batch_size
每一个torch.tensor的shape为(num_boxes, 6),内容为box+conf+cls
"""
pred = non_max_suppression(pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms)
t2 = time_synchronized()
# Apply Classifier
# 添加二次分类，默认不使用
if classify:
pred = apply_classifier(pred, modelc, img, im0s)
# Process detections
# 对每一张图片作处理
for i, det in enumerate(pred): # detections per image
# 如果输入源是webcam，则batch_size不为1，取出dataset中的一张图片
if webcam: # batch_size >= 1
p, s, im0 = path[i], '%g: ' % i, im0s[i].copy()
else:
p, s, im0 = path, '', im0s
# 设置保存图片/视频的路径
save_path = str(Path(out) / Path(p).name)
# 设置保存框坐标txt文件的路径
txt_path = str(Path(out) / Path(p).stem) + ('_%g' % dataset.frame if dataset.mode == 'video' else '')
# 设置打印信息（图片长宽）
s += '%gx%g ' % img.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh
if det is not None and len(det):
# Rescale boxes from img_size to im0 size
# 调整预测框的坐标：基于resize+pad的图片的坐标-->基于原size图片的坐标
# 此时坐标格式为xyxy
det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
# Print results
# 打印检测到的类别数量
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += '%g %ss, ' % (n, names[int(c)]) # add to string
# Write results
for *xyxy, conf, cls in reversed(det):
if save_txt: # Write to file
# 将xyxy(左上角+右下角)格式转为xywh(中心点+宽长)格式，并除上w，h做归一化，转化为列表再保存
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
line = (cls, conf, *xywh) if opt.save_conf else (cls, *xywh) # label format
with open(txt_path + '.txt', 'a') as f:
# 在原图上画框
f.write(('%g ' * len(line) + '\n') % line)
if save_img or view_img: # Add bbox to image
label = '%s %.2f' % (names[int(cls)], conf)
plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=3)
# 输出 json 文件
if save_json:
# windows下使用
file_name = save_path.split('\\')
# Linux下使用
# file_name = save_path.split('/')
content_dic = {
"name": file_name[len(file_name)-1],
"category": (names[int(cls)]),
"bbox": torch.tensor(xyxy).view(1, 4).view(-1).tolist(),
"score": conf.tolist()
}
content_json.append(content_dic)
# Print time (inference + NMS)
# 打印前向传播时间
print('%sDone. (%.3fs)' % (s, t2 - t1))
# Stream results
# 如果设置展示，则show图片/视频
if view_img:
cv2.imshow(p, im0)
if cv2.waitKey(1) == ord('q'): # q to quit
raise StopIteration
# Save results (image with detections)
# 设置保存图片/视频
if save_img:
if dataset.mode == 'images':
cv2.imwrite(save_path, im0)
else:
if vid_path != save_path: # new video
vid_path = save_path
if isinstance(vid_writer, cv2.VideoWriter):
vid_writer.release() # release previous video writer
fourcc = 'mp4v' # output video codec
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
vid_writer = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*fourcc), fps, (w, h))
vid_writer.write(im0)
if save_txt or save_json:
print('Results saved to %s' % Path(out))
# 将 json 数据写入文件
with open(os.path.join(Path(out), 'result.json'), 'w') as f:
json.dump(content_json, f)
# 打印总时间
print('Done. (%.3fs)' % (time.time() - t0))
if __name__ == '__main__':
"""
weights:训练的权重
source:测试数据，可以是图片/视频路径，也可以是'0'(电脑自带摄像头),也可以是rtsp等视频流
output:网络预测之后的图片/视频的保存路径
img-size:网络输入图片大小
conf-thres:置信度阈值
iou-thres:做nms的iou阈值
device:设置设备
view-img:是否展示预测之后的图片/视频，默认False
save-txt:是否将预测的框坐标以txt文件形式保存，默认False
classes:设置只保留某一部分类别，形如0或者0 2 3
agnostic-nms:进行nms是否也去除不同类别之间的框，默认False
augment:推理的时候进行多尺度，翻转等操作(TTA)推理
update:如果为True，则对所有模型进行strip_optimizer操作，去除pt文件中的优化器等信息，默认为False
"""
parser = argparse.ArgumentParser()
parser.add_argument('--weights', nargs='+', type=str, default='best.pt', help='model.pt path(s)')
parser.add_argument('--source', type=str, default='../tile/testA_imgs', help='source') # file/folder, 0 for webcam
parser.add_argument('--img-size', type=int, default=1600, help='inference size (pixels)')
parser.add_argument('--conf-thres', type=float, default=0.1, help='object confidence threshold')
parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--view-img', action='store_true', help='display results')
parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
parser.add_argument('--save-dir', type=str, default='detect_img/output', help='directory to save results')
parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
parser.add_argument('--augment', action='store_true', help='augmented inference')
parser.add_argument('--update', action='store_true', help='update all models')
parser.add_argument('--save-img', action='store_true', help='save image')
parser.add_argument('--save-json', action='store_true', default=True, help='save json')
opt = parser.parse_args()
print(opt)
with torch.no_grad():
if opt.update: # update all models (to fix SourceChangeWarning)
for opt.weights in ['yolov5s.pt', 'yolov5m.pt', 'yolov5l.pt', 'yolov5x.pt']:
detect()
# 去除pt文件中的优化器等信息
strip_optimizer(opt.weights)
else:
detect()
至此YOLOv5训练自己的数据集整个过程：制作数据集–模型训练–模型测试–模型推理阶段 已全部完成。
参考
- 【GitHub】YOLO V5
- 最后感谢超宇的协助，才能完成本篇博客！
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
