23年 yolov5车辆识别+行人识别+车牌识别+车速检测代码(python)

news2024/11/15 18:41:48

行人识别yolov5和v7对比

yolo车距

yolo车距1

代码:yolov5车辆检测代码 已有1503人下载

代码无需更改,直接可以预测!!!

流程:

 

版本与配置声明

# YOLOv5 requirements
# Usage: pip install -r requirements.txt

# Base ----------------------------------------
matplotlib>=3.2.2
numpy>=1.18.5
opencv-python>=4.1.1
Pillow>=7.1.2
PyYAML>=5.3.1
requests>=2.23.0
scipy>=1.4.1  # Google Colab version
torch>=1.7.0
torchvision>=0.8.1
tqdm>=4.41.0
protobuf<4.21.3  # https://github.com/ultralytics/yolov5/issues/8012

# Logging -------------------------------------
tensorboard>=2.4.1
# wandb

# Plotting ------------------------------------
pandas>=1.1.4
seaborn>=0.11.0

# Export --------------------------------------
# coremltools>=4.1  # CoreML export
# onnx>=1.9.0  # ONNX export
# onnx-simplifier>=0.3.6  # ONNX simplifier
# scikit-learn==0.19.2  # CoreML quantization
# tensorflow>=2.4.1  # TFLite export
# tensorflowjs>=3.9.0  # TF.js export
# openvino-dev  # OpenVINO export

# Extras --------------------------------------
ipython  # interactive notebook
psutil  # system utilization
thop  # FLOPs computation
# albumentations>=1.0.3
# pycocotools>=2.0  # COCO mAP
# roboflow
 

 

import json
import os
 
name2id =  {'hero':0,'sodier':1,'tower':2}#标签名称
 
 
def convert(img_size, box):
    dw = 1. / (img_size[0])
    dh = 1. / (img_size[1])
    x = (box[0] + box[2]) / 2.0 - 1
    y = (box[1] + box[3]) / 2.0 - 1
    w = box[2] - box[0]
    h = box[3] - box[1]
    x = x * dw
    w = w * dw
    y = y * dh
    h = h * dh
    return (x, y, w, h)
 
 
def decode_json(json_floder_path, json_name):
    txt_name = 'C:\\Users\\86189\\Desktop\\' + json_name[0:-5] + '.txt'
    #存放txt的绝对路径
    txt_file = open(txt_name, 'w')
 
    json_path = os.path.join(json_floder_path, json_name)
    data = json.load(open(json_path, 'r', encoding='gb2312',errors='ignore'))
 
    img_w = data['imageWidth']
    img_h = data['imageHeight']
 
    for i in data['shapes']:
 
        label_name = i['label']
        if (i['shape_type'] == 'rectangle'):
            x1 = int(i['points'][0][0])
            y1 = int(i['points'][0][1])
            x2 = int(i['points'][1][0])
            y2 = int(i['points'][1][1])
 
            bb = (x1, y1, x2, y2)
            bbox = convert((img_w, img_h), bb)
            txt_file.write(str(name2id[label_name]) + " " + " ".join([str(a) for a in bbox]) + '\n')
 
 
if __name__ == "__main__":
 
    json_floder_path = 'C:\\Users\\86189\\Desktop\\哈哈哈\\'
    #存放json的文件夹的绝对路径
    json_names = os.listdir(json_floder_path)
    for json_name in json_names:
        decode_json(json_floder_path, json_name)

 

函数拆解

  下图中的左侧表格中为论文中提出的方法,右侧为官方原版的yoloV5中的YoloBody部分,分析左右两表中的差异,我们可以根据论文中的连接,将GSConv和VoV-GSCSP提取出来进行实验分析使用方法以及作用(SPPF&Concat&Upsample函数作用相同):

GSConv函数

import torch
import torch.nn as nn
import torch.nn.functional as F


def autopad(k, p=None):  # kernel, padding
    # Pad to 'same'
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p

class Mish(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self,x):
        x = x * (torch.tanh(F.softplus(x)))
        return x

class Conv(nn.Module):
    # Standard convolution
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, act=True):  # ch_in, ch_out, kernel, stride, padding, groups
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = Mish() if act else nn.Identity()


    def forward(self, x):
        return self.act(self.bn(self.conv(x)))

    def forward_fuse(self, x):
        return self.act(self.conv(x))

class GSConv(nn.Module):
    # GSConv https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, k=1, s=1, g=1, act=True):
        super().__init__()
        c_ = c2 // 2
        self.cv1 = Conv(c1, c_, k, s, None, g, act)
        self.cv2 = Conv(c_, c_, 5, 1, None, c_, act)

    def forward(self, x):
        x1 = self.cv1(x)
        x2 = torch.cat((x1, self.cv2(x1)), 1)
        # shuffle
        # y = x2.reshape(x2.shape[0], 2, x2.shape[1] // 2, x2.shape[2], x2.shape[3])
        # y = y.permute(0, 2, 1, 3, 4)
        # return y.reshape(y.shape[0], -1, y.shape[3], y.shape[4])

        b, n, h, w = x2.data.size()
        b_n = b * n // 2
        y = x2.reshape(b_n, 2, h * w)
        y = y.permute(1, 0, 2)
        y = y.reshape(2, -1, n // 2, h, w)

        return torch.cat((y[0], y[1]), 1)


if __name__ == "__main__":
    base_channels = 64
    P3Shape = (1, 256, 80, 80)
    P3 = torch.ones(P3Shape)

    gsc = GSConv(base_channels * 4, base_channels * 4, 3, 2)
    P = gsc(P3)
    print(P.shape)

  通过上述的代码我们可以得到在GSConv的输入参数这边输入的维度为256,当k=3,s=2时,H和S将会降一半;当H和S为默认的1时则不变。

VoV-GSCSP函数

  VoV-GSCSP函数是建立在GSConv函数上演变而来的,我们结合论文中的流程参数表可知,在VoV-GSCSP函数中我们仅需要确保输出与输出即可。

class GSBottleneck(nn.Module):
    # GS Bottleneck https://github.com/AlanLi1997/slim-neck-by-gsconv
    def __init__(self, c1, c2, k=3, s=1, e=0.5):
        super().__init__()
        c_ = int(c2*e)
        # for lighting
        self.conv_lighting = nn.Sequential(
            GSConv(c1, c_, 1, 1),
            GSConv(c_, c2, 3, 1, act=False))
        self.shortcut = Conv(c1, c2, 1, 1, act=False)

    def forward(self, x):
        return self.conv_lighting(x) + self.shortcut(x)

class VoVGSCSP(nn.Module):
    # VoVGSCSP module with GSBottleneck
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        # self.gc1 = GSConv(c_, c_, 1, 1)
        # self.gc2 = GSConv(c_, c_, 1, 1)
        # self.gsb = GSBottleneck(c_, c_, 1, 1)
        self.gsb = nn.Sequential(*(GSBottleneck(c_, c_, e=1.0) for _ in range(n)))
        self.res = Conv(c_, c_, 3, 1, act=False)
        self.cv3 = Conv(2 * c_, c2, 1)  #

    def forward(self, x):
        x1 = self.gsb(self.cv1(x))
        y = self.cv2(x)
        return self.cv3(torch.cat((y, x1), dim=1))


if __name__ == "__main__":
    base_channels = 64
    P3Shape = (1, 256, 80, 80)
    P3 = torch.ones(P3Shape)

    VOV = VoVGSCSP(base_channels * 4, base_channels * 4)
    P = VOV(P3)
复制代码

YoloBady构造

  由上述的网络基础函数部分的构建结合yoloV5经过 backbone 层后得到的feat1、feat1和 feat1(也即:P5、P4和P3)到最后网络的输出部分,可以得到从输入部分的H和W是保持同P层相同,那么可以结合论文中的流程参数图以及输入输出的关系得到如下的流程参数图。

  根据上文中流程表格参数图,我在重构的过程中省略了S=3的设定(本人的显存不够),另外根据论文中的流程示意图,我暂时无法没有找到下图中的红圈部分的参数,若大家需要可以自行添加,输入输出保持不变即可。

 

YoloBody部分

from torch import nn
from nets.CSPdarknet import CSPDarknet, SPPF, Concat, GSConv, VoVGSCSP


class YoloBody(nn.Module):
    def __init__(self, anchors_mask, num_classes, phi, pretrained=False, input_shape=[640, 640]):
        super(YoloBody, self).__init__()
        depth_dict = {'n': 0.33, 's': 0.33, 'm': 0.67, 'l': 1.00, 'x': 1.33, }
        width_dict = {'n': 0.25, 's': 0.50, 'm': 0.75, 'l': 1.00, 'x': 1.25, }
        dep_mul, wid_mul = depth_dict[phi], width_dict[phi]

        base_channels = int(wid_mul * 64)  # 64
        base_depth = max(round(dep_mul * 3), 1)  # 3
        # -----------------------------------------------#
        #   输入图片是640, 640, 3
        #   初始的基本通道是64
        # -----------------------------------------------#
        self.backbone = CSPDarknet(base_channels, base_depth, phi, pretrained)

        self.upsample = nn.Upsample(scale_factor=2, mode="nearest")
        self.concat = Concat(dimension=1)
        self.SPPF = SPPF(base_channels * 16, base_channels * 16)  # 1024 ---> 1024
        self.P5GSConv = GSConv(base_channels * 16, base_channels * 8)  # 1,1024,20,20 ---> 1,512,20,20
        self.P4VoV = VoVGSCSP(base_channels * 16, base_channels * 8)  # 1,512,40,40 ---> 1,1024,40,40
        """
        self.P4VoV = nn.Sequential(VoVGSCSP(base_channels * 16, base_channels * 8),
                           VoVGSCSP(base_channels * 8, base_channels * 8),
                           VoVGSCSP(base_channels * 8, base_channels * 8))
        """

        self.P4GSConv = GSConv(base_channels * 8, base_channels * 4)  # 1,512,40,40 ---> 1,256,40,40
        self.Head1VoV = VoVGSCSP(base_channels * 8, base_channels * 4)  # 1,512,80,80 ---> 1,256,80,80
        """
        self.Head1VoV = nn.Sequential(VoVGSCSP(base_channels * 8, base_channels * 4),
                                      VoVGSCSP(base_channels * 4, base_channels * 4),
                                      VoVGSCSP(base_channels * 4, base_channels * 4))
        """
        self.P3GSConv = GSConv(base_channels * 4, base_channels * 4, 3, 2)  # 1,256,80,80 ---> 1,256,40,40
        self.Head2VoV = VoVGSCSP(base_channels * 8, base_channels * 8)  # 1,512,40,40 ---> 1,512,40,40
        """
        self.Head2VoV = nn.Sequential(VoVGSCSP(base_channels * 8, base_channels * 8),
                              VoVGSCSP(base_channels * 8, base_channels * 8),
                              VoVGSCSP(base_channels * 8, base_channels * 8))
        """
        self.Head2GSConv = GSConv(base_channels * 8, base_channels * 8, 3, 2)  # 1,512,40,40 ---> 1,512,20,20
        self.Head3VoV = VoVGSCSP(base_channels * 16, base_channels * 16)  # 1,1024,20,20 ---> 1,1024,20,20

        """
        self.Head3VoV = nn.Sequential(VoVGSCSP(base_channels * 16, base_channels * 16),
                                        VoVGSCSP(base_channels * 16, base_channels * 16),
                                        VoVGSCSP(base_channels * 16, base_channels * 16))
        
        """
        self.yolo_head_P3 = nn.Conv2d(base_channels * 4, len(anchors_mask[2]) * (5 + num_classes), 1)
        self.yolo_head_P4 = nn.Conv2d(base_channels * 8, len(anchors_mask[1]) * (5 + num_classes), 1)
        self.yolo_head_P5 = nn.Conv2d(base_channels * 16, len(anchors_mask[0]) * (5 + num_classes), 1)

    def forward(self, x):
        P3, P4, P5 = self.backbone(x)
        P5 = self.SPPF(P5)
        P5 = self.P5GSConv(P5)
        P5_Up = self.upsample(P5)

        P4 = self.concat([P4, P5_Up])
        P4 = self.P4VoV(P4)
        P4 = self.P4GSConv(P4)
        P4_Up = self.upsample(P4)

        P3 = self.concat([P3, P4_Up])
        head1 = self.Head1VoV(P3)
        P3 = self.P3GSConv(head1)
        P34_Cat = self.concat([P3, P4])
        head2 = self.Head2VoV(P34_Cat)
        PHG = self.Head2GSConv(head2)
        PHG_Cat = self.concat([PHG, P5])
        head3 = self.Head3VoV(PHG_Cat)

        Out1 = self.yolo_head_P3(head1)  # 1,255,80,80
        Out2 = self.yolo_head_P4(head2)  # 1,255,40,40
        Out3 = self.yolo_head_P5(head3)  # 1,255,20,20

        return Out3, Out2, Out1


# if __name__ == "__main__":
#     anchors_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]
#     num_classes = 80
#     phi = 's'
#     model = YoloBody(anchors_mask, num_classes, phi, pretrained=False)
#     x = torch.ones((1, 3, 640, 640))
#     Out3, Out2, Out1 = model(x)
#     print()

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/187830.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

C语言--结构体初阶

目录前言结构体类型的声明什么是结构结构的声明结构体变量的定义结构成员的类型结构体变量的初始化结构体的成员访问结构体传参函数调用的参数压栈前言 在前面的C语言学习中&#xff0c;我们学习了形如char&#xff0c;short&#xff0c;int&#xff0c;float等的不同类型的变…

活动星投票臻我风采评选视频投票的功能在线投票程序

“臻我风采评选”网络评选投票_线上小程序的投票方式_视频投票的功能_在线投票程序用户在使用微信投票的时候&#xff0c;需要功能齐全&#xff0c;又快捷方便的投票小程序。而“活动星投票”这款软件使用非常的方便&#xff0c;用户可以随时使用手机微信小程序获得线上投票服务…

即时通讯开发之详解TCP/IP中的IP选路、动态选路

静态 IP 选路 1一个简单的路由表 选路是 IP 层最重要的一个功能之一。前面的部分已经简单的讲过路由器是通过何种规则来根据 IP 数据包的 IP 地址来选择路由。 这里就不重复了。 对于一个给定的路由器,可以打印出五种不同的 flag&#xff1a;  U 表明该路由可用。  G…

Qlik Sense Enterprise Windows版(非集群)——详细安装步骤

Qlik Sense分为客户端(Desktop)和服务器(Server)&#xff0c;本文主要介绍Qlik Sense Server的图形化界面安装操作。 安装方式也分为两种&#xff0c;一种是图形化界面安装&#xff0c;另一种是静默安装。一般只有在特殊报错情况下我们才使用静默安装&#xff0c;静默安装的方…

实现分页查询

实现分页查询一、分页要素与语法二、例&#xff1a;博客系统文章列表页2.1 原始前端代码2.2 实现&#xff1a;查询分页数据验证2.3 实现 “首页” “上一页” “下一页” “末页”前端代码添加得到总页数实现 四个点击效果验证一、分页要素与语法 分页要素&#xff1a; 1&…

Qt音视频开发13-视频解码线程基类的设计

一、前言 这个解码线程基类的设计&#xff0c;是到目前为止个人觉得自己设计的最好的基类之一&#xff0c;当然也不是一开始就知道这样设计&#xff0c;没有个三五年的摸爬滚打以及社会的毒打&#xff0c;是想不到要这样设计的&#xff0c;一方面是要不断提炼各种视频类视频组…

伪逆矩阵 的使用

伪逆矩阵&#xff08;pseudo-inverse&#xff09;_Uglyduckling911的博客-CSDN博客_伪逆矩阵 一、什么是伪逆矩阵 若任意矩阵Am*n,B 为A的广义逆矩阵&#xff0c;若B满足下述条件&#xff08;Moore-penrose条件&#xff09;&#xff1a; &#xff08;1&#xff09;BAB B&am…

4.门面模式,组合模式,享元模式

门面模式 为了保证接口的可复用性&#xff08;或者叫通用性&#xff09;&#xff0c;我们需要将接口尽量设计得细粒度一点&#xff0c;职责单一一点。但是&#xff0c;如果接口的粒度过小&#xff0c;在接口的使用者开发一个业务功能时&#xff0c;就会导致需要调用 n 多细粒度…

【手把手】教你使用JMH和Disruptor - 多线程与高并发工具

JMH JMH全称是Java Microbenchmark Harness&#xff08;Java微基准测试&#xff09;&#xff0c;简单讲其实就是测一个方法的性能好坏。这个测试的框架是2013年发出来的&#xff0c;由JLT的开发人员开发&#xff0c;后来归到了OpenJDK下面&#xff0c;官网地址&#xff1a;htt…

运维实践 | OpenMLDB 跨机房容灾方案

背景 在单集群部署环境下&#xff0c;OpenMLDB 具备集群内节点级别的高可用能力。但若受到机房断电或者自然灾害等不可抗拒因素&#xff0c;则将造成的机房或大部分节点无法正常运转的情况&#xff0c;从而引发该集群状态异常&#xff0c;导致在线服务中断。为此&#xff0c;Op…

悉数美剧《黑客军团》中的黑客工具

本篇文章中主要列举《Mr. Robot》电视剧中主要用到的黑客工具&#xff0c;并对它们所对应的现实中的黑客工具做一简要介绍。Mr. Robot2015年美剧出了一部关于黑客题材的电视剧&#xff0c;相信爱看黑客电视剧、电影的同学们已经看过或者正在追这部神秘的《Mr. Robot》&#xff…

零基础学MySQL(四)-- 数据库最常用的操作【查询基础篇 -- 单表查询】

目录&#x1f4d4;一、最简单的 select 语句1️⃣基本语法2️⃣基本练习3️⃣补充说明(1) 使用表达式对查询的列进行运算(2) 在 select 语句中可使用 as 语句取别名&#x1f4d5;二、使用 where 子句进行过滤查询1️⃣基本语法2️⃣在 where 子句中经常使用的运算符3️⃣基本练…

4道面试题让你了解 ThreadLocal 的那点小秘密

我收集了4个面试中出现频率较高的关于ThreadLocal的问题&#xff1a; 什么是ThreadLocal&#xff1f;什么场景下使用ThreadLocal&#xff1f;ThreadLocal的底层是如何实现的&#xff1f;ThreadLocal在什么情况下会出现内存泄漏&#xff1f;使用ThreadLocal要注意哪些内容&…

工赋开发者社区 | 事件驱动架构要避开的 5 个陷阱

事件驱动架构非常强大&#xff0c;非常适合用在分布式微服务环境中。事件驱动架构提供了解耦的架构、更容易实现的可伸缩性和更高程度的弹性。请求应答&#xff08;客户端和服务器&#xff09;与事件流&#xff08;发布和订阅&#xff09;但是&#xff0c;与请求和应答类型的架…

防范DDOS攻击的最佳方法

Botnets是由多个感染的计算机(称为"bots"或"zombies")组成的网络。这些感染的计算机受到攻击者的控制,可以同时发送大量的数据流量到目标网站,导致DDoS(分布式拒绝服务)攻击。Botnets也可以用于从感染的计算机中获取私人信息,传播病毒和蠕虫,或者执…

Git使用个人访问令牌提交代码到仓库

文章目录前言解决方法1、创建自己的token2.1、使用token(classic)2.2、使用token(方法二)参考链接前言 2021年8月13日开始&#xff0c;GitHub在使用Git操作远程仓库时不再支持使用用户名密码形式进行身份验证&#xff0c;需使用个人访问令牌。 使用Git操作GitHub仓库时使用用户…

整合spring cloud云服务架构 - 企业分布式微服务云架构构建

1. 介绍 Commonservice-system是一个大型分布式、微服务、面向企业的JavaEE体系快速研发平台&#xff0c;基于模块化、服务化、原子化、热插拔的设计思想&#xff0c;使用成熟领先的无商业限制的主流开源技术构建。采用服务化的组件开发模式&#xff0c;可实现复杂的业务功能。…

电脑开不了机怎么办?排查这3种情况

电脑开不了机不一定是电脑故障损坏的问题&#xff0c;也可能是硬件或者是线路松动导致的。电脑开不了机的原因有很多&#xff0c;电脑开不了机怎么办&#xff1f;我们先来了解下主要是哪些原因&#xff0c;排查出原因才好对症下药。 操作环境&#xff1a; 演示机型&#xff1a;…

Leetcode刷题注意点

时间复杂度&#xff1a;一个句子被执行多少次。 空间复杂度&#xff1a;一个算法在运行过程中临时占用存储空间大小的量度 列表可以用.append() 添加数据 字符串 用 s q 这个写法。 03 此题关键是哈希表的运用。 dic set() 表示取出nums中的key 并且set里面元素不重复 53…

python多光谱遥感数据处理、图像分类、定量评估及机器学习方法应用

普通数码相机记录了红、绿、蓝三种波长的光&#xff0c;多光谱成像技术除了记录这三种波长光之外&#xff0c;还可以记录其他波长&#xff08;例如&#xff1a;近红外、热红外等&#xff09;光的信息。与昂贵、不易获取的高光谱、高空间分辨率卫星数据相比&#xff0c;中等分辨…