基于树莓派4B的YOLOv5-Lite目标检测的移植与部署（含训练教程）

前言：本文为手把手教学树莓派4b项目——yolov5-lite目标检测，本次项目采用树莓派4b（cortex-a72）作为核心 cpu 进行部署。该篇博客算是深度学习理论的初步实战，选择的网络模型为 yolov5 模型的变种 yolov5-lite 模型。yolov5-lite 与 yolov5 相比虽然牺牲了部分网络模型精度，但是缺极大的提升了模型的推理速度，该模型属性将更适合实战部署使用。该项目的实践将帮助大家成功进入 “嵌入式ai” 领域，后续将在该项目上加入嵌入式的 “传统控制” 属性，读者朋友可以期待一下！（文末有代码开源！）

硬件实物图：

效果图：

一、yolov5-lite概述

1.1 yolov5概述

yolov5 官方代码中，给出的目标检测网络中一共有4个版本，分别是yolov5s、yolov5m、yolov5l、yolov5x四个模型。作者仅以 yolov5s 的网络结构为对象进行讲解，其他版本的读者朋友可以参考其他博客！

yolov5s 网络是 yolov5 系列中深度最小，特征图的宽度最小的网络。后面的3种都是在此基础上不断加深，不断加宽。yolov5 的网络结构图如下（源于江大白大佬的结构图）：

上图即 yolov5 的网络结构图，可以看出，还是分为输入端、backbone、neck、prediction四个部分。

（1）输入端：mosaic数据增强、自适应锚框计算、自适应图片缩放
（2）backbone：focus结构，csp结构
（3）neck：fpn+pan结构
（4）prediction：giou_loss

下面丢上 yolov5 作者的算法性能测试图：

到现在为止，yolov5 已经更新迭代到 v7.0 版本了，科研学术圈以 yolov5 为基础框架进行魔改的论文数不胜数。通过上述作者的概述读者朋友可能对 yolov5 有了一个大致的了解，不难发现 yolov5 是非常优秀的神经网络模型。

1.2 yolov5-lite详解

yolov5-lite 算法的模型结构如图下。该算法去除了 focus 结构层，减小了模型体量，使模型变得更为轻便；同时，去除了 4 次 slice 操作，减少了对计算机芯片缓存的占用，降低了计算机的处理负担。与 yolov5 算法相比，yolov5-lite 算法能避免反复使用 c3 layer 模块。c3 layer 模块会占用计算机很多运行空间，从而降低计算机的处理速度。这种方式能使 yolov5-lite 算法模型的精度控制在可靠范围内，从而使其更易部署。

在图像识别领域，主干网络结构(backbone)和检测头(head)中往往有一段中间层，即特征增强融合网络层(neck)，可更精准地提取融合特征。yolov5-lite 算法也采用 fpn＋pan 结构，但其对输出端(head)进行了通道剪枝，改进了 yolov4 算法和 yolov5 算法中的 fpn＋pan 的结构，具体表现在以下2个方面：

(1)、与 yolov5 算法不同，yolov5-lite 算法自身各结构的通道数量相同，即模型特征增强网络通道网格数也是20×20×96，这样可优化对内存的访问和使用，提高模型的运行效率；

(2)、yolov5-lite 算法采用 panet 结构，将 yolov5 算法的通道连接(cat)操作改进为叠加操作,这样可进一步优化对内存的使用，加快处理速度。如下图为 yolov5-lite 算法与 yolov4 和  yolov5 算法中的 pan 结构对比：

二、yolov5-lite训练

2.1 数据集制作

★常规的神经网络模型训练是需要收集到大量语义丰富的数据集进行训练的。但是考虑实际工程下可能仅需要对已知场地且固定实物进行目标检测追踪等任务，这个时候我们可以采取偷懒的下方作者使用的方法！

1、作者使用树莓派4b的 camera 直接在捕获需要识别目标物的图片信息（捕获期间转动待识别的目标物体）；

树莓派4b的 camera 定时捕获照片的python代码如下：

import cv2
from threading import thread
import uuid
import os
import time
count = 0
def image_collect(cap):
    global count
    while true:
        success, img = cap.read()
        if success:
            file_name = str(uuid.uuid4())+'.jpg'
            cv2.imwrite(os.path.join('images',file_name),img)
            count = count+1
            print("save %d %s"%(count,file_name))
        time.sleep(0.4)

if __name__ == "__main__":
    
    os.makedirs("images",exist_ok=true)
    
    # 打开摄像头
    cap = cv2.videocapture(0)

    m_thread = thread(target=image_collect, args=([cap]),daemon=true)
    
    while true:

        # 读取一帧图像

        success, img = cap.read()

        if not success:

            continue

        cv2.imshow("video",img)

        key =  cv2.waitkey(1) & 0xff   

        # 按键 "q" 退出
        if key ==  ord('c'):
            m_thread.start()
            continue
        elif key ==  ord('q'):
            break

    cap.release() 

按动 “c” 开始采集待识别目标图像，按动 “q” 退出摄像头 camera 的图片采集；

2、将捕获到的待识别目标物照片传输到pc端，利用 labelme 软件进行标注（labelme不会使用的建议相关博客）；

作者的标注了 3 类目标：drug，prime，glue；读者朋友可以根据自己实际情况标注自己需要的数据集！由于我们标注的数据的标签 label 默认是 json 格式的不能被 yolo 系列的神经网络模型直接进行利用训练。

3、使用 json 转 txt 的 yolo 格式 label 的python代码进行转换（可以直接使用作者提供的代码）：

dic_lab.py：

dic_labels= {'drug':0,
            'glue':1,
            'prime':2,
             'path_json':'labels',
             'ratio':0.9}

lablemetoyolo.py：

import os
import json
import random
import base64
import shutil
import argparse
from pathlib import path
from glob import glob
from dic_lab import dic_labels

def generate_labels(dic_labs):
    path_input_json = dic_labels['path_json']
    ratio = dic_labs['ratio']
    for index, labelme_annotation_path in enumerate(glob(f'{path_input_json}/*.json')):

        # 读取文件名
        image_id = os.path.basename(labelme_annotation_path).rstrip('.json')
        
        # 计算是train 还是 valid
        train_or_valid = 'train' if random.random() < ratio else 'valid'

        # 读取labelme格式的json文件
        labelme_annotation_file = open(labelme_annotation_path, 'r')
        labelme_annotation = json.load(labelme_annotation_file)

        # yolo 格式的 lables
        yolo_annotation_path = os.path.join(train_or_valid, 'labels',image_id + '.txt')
        yolo_annotation_file = open(yolo_annotation_path, 'w')
        
        # yolo 格式的图像保存
        yolo_image = base64.decodebytes(labelme_annotation['imagedata'].encode())
        yolo_image_path = os.path.join(train_or_valid, 'images', image_id + '.jpg')
        
        yolo_image_file = open(yolo_image_path, 'wb')
        yolo_image_file.write(yolo_image)
        yolo_image_file.close()
     

        # 获取位置信息
        for shape in labelme_annotation['shapes']:
            if shape['shape_type'] != 'rectangle':
                print(
                    f'invalid type `{shape["shape_type"]}` in annotation `annotation_path`')
                continue
           

            points = shape['points']
            scale_width = 1.0 / labelme_annotation['imagewidth']
            scale_height = 1.0 / labelme_annotation['imageheight']
            width = (points[1][0] - points[0][0]) * scale_width
            height = (points[1][1] - points[0][1]) * scale_height
            x = ((points[1][0] + points[0][0]) / 2) * scale_width
            y = ((points[1][1] + points[0][1]) / 2) * scale_height
            object_class = dic_labels[shape['label']]
            yolo_annotation_file.write(f'{object_class} {x} {y} {width} {height}\n')
        yolo_annotation_file.close()
        print("creat lab %d : %s"%(index,image_id))


if __name__ == "__main__":
    os.makedirs(os.path.join("train",'images'),exist_ok=true)
    os.makedirs(os.path.join("train",'labels'),exist_ok=true)
    os.makedirs(os.path.join("valid",'images'),exist_ok=true)
    os.makedirs(os.path.join("valid",'labels'),exist_ok=true)
    generate_labels(dic_labels)

我们需要根据自己的需要自定义字典 dic_lab，字典中的 ratio = 0.9 的作用是将数据集拆分成训练集和验证集 9：1。读者朋友可以根据自己的实际情况去修改字典的标签内容，成功执行 lablemetoyolo.py 代码后效果如下：

labels文件夹下的标签成功转换了 yolo 系列可以使用的 label 标签，到此时就已经成功准备好我们需要的训练集了！

2.2 yolov5-lite训练

yolov5-lite 训练就是常规的神经网络模型训练，我们从 github 上下载 yolov5-lite 的源代码，训练平台为：pycharm 2020.1 x64，gpu：rtx3060 6g，cpu：amd ryzen 7 5800h  3.2ghz。

读者朋友可以使用  pycharm 或者 vscode 打开 yolov5-lite 的源码（作者使用pycharm 2020.1 x64）；

在 yolov5-lite 的目录下找到 train.py (训练文件)的 main 函数入口，进行如下配置：

读者朋友一定要将数据集存放的地址位置搞正确！！！

mydata.yaml：

yolov5-lite 网络模型的训练可以不一定必须使用 cuda 进行加速，但是 pytorch 架构等依赖库一定需要满足，模型训练依赖要求如下：

# base ----------------------------------------
matplotlib>=3.2.2
numpy>=1.18.5
opencv-python>=4.1.2
pillow
pyyaml>=5.3.1
scipy>=1.4.1
torch>=1.8.0
torchvision>=0.9.0
tqdm>=4.41.0

# logging -------------------------------------
tensorboard>=2.4.1
# wandb

# plotting ------------------------------------
seaborn>=0.11.0
pandas

# export --------------------------------------
# coremltools>=4.1
# onnx>=1.9.1
# scikit-learn==0.19.2  # for coreml quantization

# extras --------------------------------------
thop  # flops computation
pycocotools>=2.0  # coco map

将训练环境与数据集都搞定之后，就可以点击运行按钮进行 yolov5-lite 的模型训练了！

训练成功之后，将会在当前目录下的 run 文件下的 trian 文件下找到 expx (x代表数字)，expx 则存放了第 x 次训练时候的各种数据内容，包括：历史最优权重best_weight，当前权重last_weight，训练结果result等等；

三、树莓派4b部署yolov5-lite

3.1 onnx概述

open neural network exchange(onnx)是一个开放的生态系统，它使人工智能开发人员在推进项目时选择合适的工具，不用被框架或者生态系统所束缚。onnx支持不同框架之间的互操作性，简化从研究到生产之间的道路。onnx支持许多框架（tensorflow, pytorch, keras, mxnet, matlab等等），这些框架中的模型都可以导出或者转换为标准onnx格式。模型采用onnx格式后，就可在各种平台和设备上运行。

开发者根据深度学习框架优劣选择某个框架，但是这些框架适应不同的开发阶段，由于必须进行转换，从而导致了研究和生产之间的重大延迟。onnx格式一个通用的ir，能够使得开发人员在开发或者部署的任何阶段选择最适合他们项目的框架。onnx通过提供计算图的通用表示，帮助开发人员为他们的任务选择合适的框架。

onnx可视化：onnx 模型可以通过 netron 进行可视化。

3.2 onnx模型转换和移植

如今的开源 yolo 系列神经网络模型的目录下作者都会预留 export.py 文件将该神经网络模型进行转换到 onnx 模型，方便大家实际情况下部署使用！

将我们训练好的最优训练权重 weights 存放到 yolov5-lite 主目录下，之后运行如下代码：

python export.py --weights best.pt

运行该指令后将会通过 best.pt 文件，生成 best.onnx 的 onnx 模型的权重文件；

同时为了成功运行 onnx 格式的 yolov5-lite 网络模型，需要在树莓派4b中安装 onnxruntim （可以直接使用作者提供的安装包），当然值得注意的是 onnxruntim 的安装需要依赖的 numpy版本1.21 以上（这点需要大家注意，当然如果使用了作者的镜像完全没有问题！）。

pip install onnx     （tab补全安装包）

将转换成 onnx 格式的权重文件导入到树莓派4b中，并于目标检测程序保持同一目录下：

到此 onnx 模型的转换与移植工作就可以完成了！

四、yolov5-lite目标检测

yolov5-lite 的目标检测前向推理程序是很简单的，可以直接借鉴作者如下提供的代码：

import cv2
import numpy as np
import onnxruntime as ort
import time

def plot_one_box(x, img, color=none, label=none, line_thickness=none):
    """
    description: plots one bounding box on image img,
                 this function comes from yolov5 project.
    param: 
        x:      a box likes [x1,y1,x2,y2]
        img:    a opencv image object
        color:  color to draw rectangle, such as (0,255,0)
        label:  str
        line_thickness: int
    return:
        no return
    """
    tl = (
        line_thickness or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1
    )  # line/font thickness
    color = color or [random.randint(0, 255) for _ in range(3)]
    c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
    cv2.rectangle(img, c1, c2, color, thickness=tl, linetype=cv2.line_aa)
    if label:
        tf = max(tl - 1, 1)  # font thickness
        t_size = cv2.gettextsize(label, 0, fontscale=tl / 3, thickness=tf)[0]
        c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3
        cv2.rectangle(img, c1, c2, color, -1, cv2.line_aa)  # filled
        cv2.puttext(
            img,
            label,
            (c1[0], c1[1] - 2),
            0,
            tl / 3,
            [225, 255, 255],
            thickness=tf,
            linetype=cv2.line_aa,
        )

def _make_grid( nx, ny):
        xv, yv = np.meshgrid(np.arange(ny), np.arange(nx))
        return np.stack((xv, yv), 2).reshape((-1, 2)).astype(np.float32)

def cal_outputs(outs,nl,na,model_w,model_h,anchor_grid,stride):
    
    row_ind = 0
    grid = [np.zeros(1)] * nl
    for i in range(nl):
        h, w = int(model_w/ stride[i]), int(model_h / stride[i])
        length = int(na * h * w)
        if grid[i].shape[2:4] != (h, w):
            grid[i] = _make_grid(w, h)

        outs[row_ind:row_ind + length, 0:2] = (outs[row_ind:row_ind + length, 0:2] * 2. - 0.5 + np.tile(
            grid[i], (na, 1))) * int(stride[i])
        outs[row_ind:row_ind + length, 2:4] = (outs[row_ind:row_ind + length, 2:4] * 2) ** 2 * np.repeat(
            anchor_grid[i], h * w, axis=0)
        row_ind += length
    return outs



def post_process_opencv(outputs,model_h,model_w,img_h,img_w,thred_nms,thred_cond):
    conf = outputs[:,4].tolist()
    c_x = outputs[:,0]/model_w*img_w
    c_y = outputs[:,1]/model_h*img_h
    w  = outputs[:,2]/model_w*img_w
    h  = outputs[:,3]/model_h*img_h
    p_cls = outputs[:,5:]
    if len(p_cls.shape)==1:
        p_cls = np.expand_dims(p_cls,1)
    cls_id = np.argmax(p_cls,axis=1)

    p_x1 = np.expand_dims(c_x-w/2,-1)
    p_y1 = np.expand_dims(c_y-h/2,-1)
    p_x2 = np.expand_dims(c_x+w/2,-1)
    p_y2 = np.expand_dims(c_y+h/2,-1)
    areas = np.concatenate((p_x1,p_y1,p_x2,p_y2),axis=-1)
    
    areas = areas.tolist()
    ids = cv2.dnn.nmsboxes(areas,conf,thred_cond,thred_nms)
    if len(ids)>0:
        return  np.array(areas)[ids],np.array(conf)[ids],cls_id[ids]
    else:
        return [],[],[]
def infer_img(img0,net,model_h,model_w,nl,na,stride,anchor_grid,thred_nms=0.4,thred_cond=0.5):
    # 图像预处理
    img = cv2.resize(img0, [model_w,model_h], interpolation=cv2.inter_area)
    img = cv2.cvtcolor(img, cv2.color_bgr2rgb)
    img = img.astype(np.float32) / 255.0
    blob = np.expand_dims(np.transpose(img, (2, 0, 1)), axis=0)

    # 模型推理
    outs = net.run(none, {net.get_inputs()[0].name: blob})[0].squeeze(axis=0)

    # 输出坐标矫正
    outs = cal_outputs(outs,nl,na,model_w,model_h,anchor_grid,stride)

    # 检测框计算
    img_h,img_w,_ = np.shape(img0)
    boxes,confs,ids = post_process_opencv(outs,model_h,model_w,img_h,img_w,thred_nms,thred_cond)

    return  boxes,confs,ids




if __name__ == "__main__":

    # 模型加载
    model_pb_path = "best.onnx"
    so = ort.sessionoptions()
    net = ort.inferencesession(model_pb_path, so)
    
    # 标签字典
    dic_labels= {0:'drug',
            1:'glue',
            2:'prime'}
    
    # 模型参数
    model_h = 320
    model_w = 320
    nl = 3
    na = 3
    stride=[8.,16.,32.]
    anchors = [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]]
    anchor_grid = np.asarray(anchors, dtype=np.float32).reshape(nl, -1, 2)
    
    video = 0
    cap = cv2.videocapture(video)
    flag_det = false
    while true:
        success, img0 = cap.read()
        if success:
            
            if flag_det:
                t1 = time.time()
                det_boxes,scores,ids = infer_img(img0,net,model_h,model_w,nl,na,stride,anchor_grid,thred_nms=0.4,thred_cond=0.5)
                t2 = time.time()
            
                
                for box,score,id in zip(det_boxes,scores,ids):
                    label = '%s:%.2f'%(dic_labels[id],score)
            
                    plot_one_box(box.astype(np.int16), img0, color=(255,0,0), label=label, line_thickness=none)
                    
                str_fps = "fps: %.2f"%(1./(t2-t1))
                
                cv2.puttext(img0,str_fps,(50,50),cv2.font_hershey_complex,1,(0,255,0),3)
                
            
            cv2.imshow("video",img0)
        key=cv2.waitkey(1) & 0xff    
        if key == ord('q'):
        
            break
        elif key & 0xff == ord('s'):
            flag_det = not flag_det
            print(flag_det)
            
    cap.release() 

就该目标检测算法作者简单给大家讲解一下：

上述基本除了 anchor 锚框这个数据，其余都是不需要改动的，这里 anchor 直接使用了默认值。如果大家想在目标检测的时候可以更好地框选出自己地识别目标，可以用 k-means 聚类算法去自适应 anchor 的大小，从小聚类出符合自己数据类型的 anchor ，这样目标检测的时候可能效果更好！

一切准备就绪，直接运行咱们的 test_video.py 程序进行目标检测：

python3 test_video.py

按键 “s” 开启目标检测功能，按键 “q” 退出当前目标检测程序！

五、项目效果

5.1 实战视频

5.2 作者有话

作者本次仅使用了 onnx 模型下直接跑 yolov5-lite 的网络模型，目前该状态下的fps仅维持在5左右，效果其实比直接跑 yolov5 网络模型已经好很多了（yolov5的fps在0.3fps左右）。但是距离可以与控制结合感觉还是差了点，所以，后续作者将对目标检测进行加速处理（使用ncnn，mnn等模型加速）。

当然，作者也会分享自己实验室提出的轻量化目标检测网络从网络模型出发加速推理。将计算机视觉与控制结合的嵌入式ai教学后续也会出博客分享给各位，希望给大家日常的工作或者是电赛提供些许帮助！

六、项目代码

代码地址：基于树莓派4b的yolov5-lite目标检测的资源包资源-csdn文库

如果积分不够的朋友，点波关注，评论区留下邮箱，作者无偿提供源码和后续问题解答。求求啦关注一波吧 ！！！