PP-LCNet-YoloV5

最新推荐文章于 2024-04-11 19:42:53 发布
最新推荐文章于 2024-04-11 19:42:53 发布
阅读量3.7k 收藏 67
点赞数 6
分类专栏： 深度学习 文章标签： pytorch 深度学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46179553/article/details/120691104
版权

背景简介

前段时间看到了百度新出的一篇论文，提出了一种基于MKLDNN加速策略的轻量级CPU网络，即PP-LCNet，它提高了轻量级模型在多任务上的性能,对于计算机视觉的下游任务，如目标检测、语义分割等，也有很好的表现。以下是论文链接和开源的基于PaddlePaddle的实现。

arXiv: https://arxiv.org/pdf/2109.15099.pdf

code: https://github.com/PaddlePaddle/PaddleClas

论文很短，模型结构也十分简洁，没有特别创新的部分，应该是属于深挖技术细节并细心整理的工程应用梳理性质的文章，里面有一些极其实用的工程细节，非常值得一读。

Pytorch实现PP-LCNet

简单浏览了一下网上对该文章的解读。

快到飞起的轻量级网络怎能不让人心动？可惜原版PP-LCNet只有PaddlePaddle的实现，对于我这样的Pytorch玩家没法直接白嫖，不过好在PaddlePaddle和Pytorch的动态图机制极其相似，参考相关代码，实现起来也并不难，下面贴一下我用Pytorch的实现

import os
import torch
import torch.nn as nn

NET_CONFIG = {
    "blocks2":
    # k, in_c, out_c, s, use_se
    [[3, 16, 32, 1, False]],
    "blocks3": [[3, 32, 64, 2, False], [3, 64, 64, 1, False]],
    "blocks4": [[3, 64, 128, 2, False], [3, 128, 128, 1, False]],
    "blocks5": [[3, 128, 256, 2, False], [5, 256, 256, 1, False],
                [5, 256, 256, 1, False], [5, 256, 256, 1, False],
                [5, 256, 256, 1, False], [5, 256, 256, 1, False]],
    "blocks6": [[5, 256, 512, 2, True], [5, 512, 512, 1, True]]
}


def autopad(k, p=None):
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
    return p


def make_divisible(v, divisor=8, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v


class HardSwish(nn.Module):
    def __init__(self, inplace=True):
        super(HardSwish, self).__init__()
        self.relu6 = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return x * self.relu6(x+3) / 6


class HardSigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(HardSigmoid, self).__init__()
        self.relu6 = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return (self.relu6(x+3)) / 6


class SELayer(nn.Module):
    def __init__(self, channel, reduction=16):
        super(SELayer, self).__init__()
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel, bias=False),
            HardSigmoid()
        )

    def forward(self, x):
        b, c, h, w = x.size()
        y = self.avgpool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y.expand_as(x)


class DepthwiseSeparable(nn.Module):
    def __init__(self, inp, oup, dw_size, stride, use_se=False):
        super(DepthwiseSeparable, self).__init__()
        self.use_se = use_se
        self.stride = stride
        self.inp = inp
        self.oup = oup
        self.dw_size = dw_size
        self.dw_sp = nn.Sequential(
            nn.Conv2d(self.inp, self.inp, kernel_size=self.dw_size, stride=self.stride,
                      padding=autopad(self.dw_size, None), groups=self.inp, bias=False),
            nn.BatchNorm2d(self.inp),
            HardSwish(),

            nn.Conv2d(self.inp, self.oup, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(self.oup),
            HardSwish(),
        )
        self.se = SELayer(self.oup)

    def forward(self, x):
        x = self.dw_sp(x)
        if self.use_se:
            x = self.se(x)
        return x


class PP_LCNet(nn.Module):
    def __init__(self, scale=1.0, class_num=10, class_expand=1280, dropout_prob=0.2):
        super(PP_LCNet, self).__init__()
        self.scale = scale
        self.conv1 = nn.Conv2d(3, out_channels=make_divisible(16 * self.scale),
                               kernel_size=3, stride=2, padding=1, bias=False)
        # k, in_c, out_c, s, use_se   inp, oup, dw_size, stride, use_se=False
        self.blocks2 = nn.Sequential(*[
            DepthwiseSeparable(inp=make_divisible(in_c * self.scale),
                               oup=make_divisible(out_c * self.scale),
                               dw_size=k, stride=s, use_se=use_se)
            for i, (k, in_c, out_c, s, use_se) in enumerate(NET_CONFIG["blocks2"])
        ])

        self.blocks3 = nn.Sequential(*[
            DepthwiseSeparable(inp=make_divisible(in_c * self.scale),
                               oup=make_divisible(out_c * self.scale),
                               dw_size=k, stride=s, use_se=use_se)
            for i, (k, in_c, out_c, s, use_se) in enumerate(NET_CONFIG["blocks3"])
        ])

        self.blocks4 = nn.Sequential(*[
            DepthwiseSeparable(inp=make_divisible(in_c * self.scale),
                               oup=make_divisible(out_c * self.scale),
                               dw_size=k, stride=s, use_se=use_se)
            for i, (k, in_c, out_c, s, use_se) in enumerate(NET_CONFIG["blocks4"])
        ])
        # k, in_c, out_c, s, use_se  inp, oup, dw_size, stride, use_se=False
        self.blocks5 = nn.Sequential(*[
            DepthwiseSeparable(inp=make_divisible(in_c * self.scale),
                               oup=make_divisible(out_c * self.scale),
                               dw_size=k, stride=s, use_se=use_se)
            for i, (k, in_c, out_c, s, use_se) in enumerate(NET_CONFIG["blocks5"])
        ])

        self.blocks6 = nn.Sequential(*[
            DepthwiseSeparable(inp=make_divisible(in_c * self.scale),
                               oup=make_divisible(out_c * self.scale),
                               dw_size=k, stride=s, use_se=use_se)
            for i, (k, in_c, out_c, s, use_se) in enumerate(NET_CONFIG["blocks6"])
        ])

        self.GAP = nn.AdaptiveAvgPool2d(1)

        self.last_conv = nn.Conv2d(in_channels=make_divisible(NET_CONFIG["blocks6"][-1][2] * scale),
                                   out_channels=class_expand,
                                   kernel_size=1, stride=1, padding=0, bias=False)

        self.hardswish = HardSwish()
        self.dropout = nn.Dropout(p=dropout_prob)

        self.fc = nn.Linear(class_expand, class_num)

    def forward(self, x):
        x = self.conv1(x)

        x = self.blocks2(x)
        x = self.blocks3(x)
        x = self.blocks4(x)
        x = self.blocks5(x)
        x = self.blocks6(x)

        x = self.GAP(x)
        x = self.last_conv(x)
        x = self.hardswish(x)
        x = self.dropout(x)
        x = torch.flatten(x, start_dim=1, end_dim=-1)
        x = self.fc(x)
        return x


def PPLCNET_x0_25(**kwargs):
    model = PP_LCNet(scale=0.25, **kwargs)
    return model


def PPLCNET_x0_35(**kwargs):
    model = PP_LCNet(scale=0.35, **kwargs)
    return model


def PPLCNET_x0_5(**kwargs):
    model = PP_LCNet(scale=0.5, **kwargs)
    return model


def PPLCNET_x0_75(**kwargs):
    model = PP_LCNet(scale=0.75, **kwargs)
    return model


def PPLCNET_x1_0(**kwargs):
    model = PP_LCNet(scale=1.0, **kwargs)
    return model


def PPLCNET_x1_5(**kwargs):
    model = PP_LCNet(scale=1.5, **kwargs)
    return model


def PPLCNET_x2_0(**kwargs):
    model = PP_LCNet(scale=2.0, **kwargs)
    return model


def PPLCNET_x2_5(**kwargs):
    model = PP_LCNet(scale=2.5, **kwargs)
    return model


if __name__ == '__main__':
    model = PPLCNET_x1_5()
    input = torch.randn(1, 3, 224, 224)
    print(input.shape)
    output = model(input)
    print(output.shape)

PP-LCNet-YoloV5

既然已经实现了Pytorch版的PP-LCNet，接下里就是实际应用环节了，因为我的工作主要以检测、追踪为主，首先想到的自然就是目标检测的经典模型——YoloV5了,PP-LCNet有0.25,0.35，0.5,0.75，1.0,1.5,2.0,2.5一个八种模型，这里以PPLCNet_x_1_0为例,在原版YoloV5基础上修改以下三个文件

common.py
# 增加如下代码
#-------------------------------------PP_LCNet------------------------------------------------------
NET_CONFIG = {
    "blocks2":
    # k, in_c, out_c, s, use_se
    [[3, 16, 32, 1, False]],
    "blocks3": [[3, 32, 64, 2, False], [3, 64, 64, 1, False]],
    "blocks4": [[3, 64, 128, 2, False], [3, 128, 128, 1, False]],
    "blocks5": [[3, 128, 256, 2, False], [5, 256, 256, 1, False],
                [5, 256, 256, 1, False], [5, 256, 256, 1, False],
                [5, 256, 256, 1, False], [5, 256, 256, 1, False]],
    "blocks6": [[5, 256, 512, 2, True], [5, 512, 512, 1, True]]
}
BLOCK_LIST = ["blocks2", "blocks3", "blocks4", "blocks5", "blocks6"]

def make_divisible_LC(v, divisor=8, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v


class HardSwish(nn.Module):
    def __init__(self, inplace=True):
        super(HardSwish, self).__init__()
        self.relu6 = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return x * self.relu6(x+3) / 6


class HardSigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(HardSigmoid, self).__init__()
        self.relu6 = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return (self.relu6(x+3)) / 6


class SELayer(nn.Module):
    def __init__(self, channel, reduction=16):
        super(SELayer, self).__init__()
        self.avgpool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel, bias=False),
            HardSigmoid()
        )

    def forward(self, x):
        b, c, h, w = x.size()
        y = self.avgpool(x).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y.expand_as(x)


class DepthwiseSeparable(nn.Module):
    def __init__(self, inp, oup, dw_size, stride, use_se=False):
        super(DepthwiseSeparable, self).__init__()
        self.use_se = use_se
        self.stride = stride
        self.inp = inp
        self.oup = oup
        self.dw_size = dw_size
        self.dw_sp = nn.Sequential(
            nn.Conv2d(self.inp, self.inp, kernel_size=self.dw_size, stride=self.stride,
                      padding=autopad(self.dw_size, None), groups=self.inp, bias=False),
            nn.BatchNorm2d(self.inp),
            HardSwish(),

            nn.Conv2d(self.inp, self.oup, kernel_size=1, stride=1, padding=0, bias=False),
            nn.BatchNorm2d(self.oup),
            HardSwish(),
        )
        self.se = SELayer(self.oup)

    def forward(self, x):
        x = self.dw_sp(x)
        if self.use_se:
            x = self.se(x)
        return x

class PPLC_Conv(nn.Module):
    def __init__(self, scale):
        super(PPLC_Conv, self).__init__()
        self.scale = scale
        self.conv = nn.Conv2d(3, out_channels=make_divisible_LC(16 * self.scale),
                               kernel_size=3, stride=2, padding=1, bias=False)
    def forward(self, x):
        return self.conv(x)

class PPLC_Block(nn.Module):
    def __init__(self, scale, block_num):
        super(PPLC_Block, self).__init__()
        self.scale = scale
        self.block_num = BLOCK_LIST[block_num]
        self.block = nn.Sequential(*[
            DepthwiseSeparable(inp=make_divisible_LC(in_c * self.scale),
                               oup=make_divisible_LC(out_c * self.scale),
                               dw_size=k, stride=s, use_se=use_se)
            for i, (k, in_c, out_c, s, use_se) in enumerate(NET_CONFIG[self.block_num])
        ])
    def forward(self, x):
        return self.block(x)
yolo.py
# 修改parse_model函数
def parse_model(d, ch):  # model_dict, input_channels(3)
    LOGGER.info('\n%3s%18s%3s%10s  %-40s%-30s' % ('', 'from', 'n', 'params', 'module', 'arguments'))
    anchors, nc, gd, gw = d['anchors'], d['nc'], d['depth_multiple'], d['width_multiple']
    na = (len(anchors[0]) // 2) if isinstance(anchors, list) else anchors  # number of anchors
    no = na * (nc + 5)  # number of outputs = anchors * (classes + 5)

    layers, save, c2 = [], [], ch[-1]  # layers, savelist, ch out
    for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):  # from, number, module, args
        m = eval(m) if isinstance(m, str) else m  # eval strings
        for j, a in enumerate(args):
            try:
                args[j] = eval(a) if isinstance(a, str) else a  # eval strings
            except:
                pass

        n = n_ = max(round(n * gd), 1) if n > 1 else n  # depth gain
        if m in [Conv, GhostConv, Bottleneck, GhostBottleneck, SPP, SPPF, DWConv, MixConv2d, Focus, CrossConv,
                 BottleneckCSP, C3, C3TR, C3SPP, C3Ghost]:
            c1, c2 = ch[f], args[0]   
            if c2 != no:  # if not output
                c2 = make_divisible(c2 * gw, 8)

            args = [c1, c2, *args[1:]]

            if m in [BottleneckCSP, C3, C3TR, C3Ghost]:
                args.insert(2, n)  # number of repeats
                n = 1
        elif m is nn.BatchNorm2d:
            args = [ch[f]]
        elif m is Concat:
            c2 = sum([ch[x] for x in f])
        elif m is Detect:
            args.append([ch[x] for x in f])
            if isinstance(args[1], int):  # number of anchors
                args[1] = [list(range(args[1] * 2))] * len(f)
        elif m is Contract:
            c2 = ch[f] * args[0] ** 2
        elif m is Expand:
            c2 = ch[f] // args[0] ** 2
# 添加加该部分代码
#---------------------------------------------            
        elif m is PPLC_Conv:
            c2 = args[0]
            args = args[1:]
        elif m is PPLC_Block:
            c2 = args[0]
            args = args[1:]
#----------------------------------------------
        else:
            c2 = ch[f]

        m_ = nn.Sequential(*[m(*args) for _ in range(n)]) if n > 1 else m(*args)  # module
        t = str(m)[8:-2].replace('__main__.', '')  # module type
        np = sum([x.numel() for x in m_.parameters()])  # number params
        m_.i, m_.f, m_.type, m_.np = i, f, t, np  # attach index, 'from' index, type, number params
        LOGGER.info('%3s%18s%3s%10.0f  %-40s%-30s' % (i, f, n_, np, t, args))  # print
        save.extend(x % i for x in ([f] if isinstance(f, int) else f) if x != -1)  # append to savelist
        layers.append(m_)
        if i == 0:
            ch = []
        ch.append(c2)
    return nn.Sequential(*layers), sorted(save)
yolov5_LCNet.yaml
# YOLOv5 🚀 by Ultralytics, GPL-3.0 license

# Parameters
nc: 80  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
anchors:
  - [10,13, 16,30, 33,23]  # P3/8
  - [30,61, 62,45, 59,119]  # P4/16
  - [116,90, 156,198, 373,326]  # P5/32

# YOLOv5 backbone
backbone:
  [[-1, 1, PPLC_Conv, [16, 1]],
   [-1, 1, PPLC_Block, [32, 1, 0]],
   [-1, 1, PPLC_Block, [64, 1, 1]],
   [-1, 1, PPLC_Block, [128, 1, 2]],
   [-1, 1, PPLC_Block, [256, 1, 3]],
   [-1, 1, PPLC_Block, [512, 1, 4]],
  ]

# YOLOv5 head
head:
  [[-1, 1, Conv, [512, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 4], 1, Concat, [1]],  # cat backbone P4
   [-1, 3, C3, [512, False]],  # 13

   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 3], 1, Concat, [1]],  # cat backbone P3
   [-1, 3, C3, [256, False]],  # 17 (P3/8-small)

   [-1, 1, Conv, [256, 3, 2]],
   [[-1, 10], 1, Concat, [1]],  # cat head P4
   [-1, 3, C3, [512, False]],  # 20 (P4/16-medium)

   [-1, 1, Conv, [512, 3, 2]],
   [[-1, 6], 1, Concat, [1]],  # cat head P5
   [-1, 3, C3, [1024, False]],  # 23 (P5/32-large)

   [[13, 16, 19], 1, Detect, [nc, anchors]],  # Detect(P3, P4, P5)
  ]

想做一下消融实验做一下对比，但是看了一眼手里的1650Ti，留下了贫穷的泪水。。。后面有机会再更新一下效果吧。
完整项目见Github
https://github.com/OutBreak-hui/Yolov5-PP-LCNet

在这里插入图片描述

暴走辉
关注
  • 6
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 17
    评论
专栏目录
YOLOv5算法改进（10）— 替换主干网络之PP-LCNet（包括代码+添加步骤+网络结构图）
突然好想你
09-02 1240
本文提出了一种基于MKLDNN加速策略的轻量级CPU网络，即PPLCNet，它提高了轻量级模型在多任务上的性能,对于计算机视觉的下游任务，如目标检测、语义分割等，也有很好的表现。
速度提升2倍，超强悍CPU级骨干网络PP-LCNet
jacke121的专栏
10-26 2518
yolov5-pp-lcnet： GitHub - OutBreak-hui/Yolov5-PP-LCNet 分类网络的，结果还出来： https://github.com/ngnquan/PP-LCNet 分类网络，有精度： https://github.com/frotms/PP-LCNet-Pytorch 34m： PPLCNet_x2_5_ssld 0.8082 0.9533 从上图我们可以看出，PP-LCNet 在同样精度的情况下，速度...
百度发文，pp-LCnet网络，pp-PicoDet算法，pp-shitu应用
05-01
组会汇报，学习讨论
PP-LCNet：一种轻量级CPU卷积神经网络
最新发布
uncle_ll的博客
04-11 1329
PP-LCNet，一种轻量级CPU卷积神经网络
YOLOV5的多主干网络（backbone）实现.zip
03-05
# 复现TPH-YOLOv5 # 支持的backbone为Ghostnet、Shufflenetv2、Mobilenetv3Small、EagleEye、EfficientNetLite-0、PP-LCNet-1x、SwinTrans-YOLOv5
百度网盘AI大赛表格结构检测第七名模型+预测文件
01-02
百度网盘AI大赛表格结构检测第七名模型+预测文件 使用轻量级卷积模型LCNet+LCPAN+PicroHead进行训练 目前排名为第七名，后续将继续更新和优化参数。
目标检测算法——YOLOv5/YOLOv7改进之结合​PP-LCNet（轻量级CPU网络）
加勒比海带66——【YOLO魔法搭配&论文投稿咨询】
11-27 8563
​PP-LCNet——轻量级且超强悍的CPU级骨干网络！！PP-LCNet 在同样精度的情况下，速度远超当前所有的骨架网络！它应用在比如目标检测、语义分割等任务算法上，也可以使原本的网络有大幅度的性能提升。
轻量级网络整理及其在Yolov5上的实现
weixin_50862344的博客
08-03 1037
使用一些轻量级网络（pp-lcnet，mobilenet，ghostnet等）backbone优化yolov5
PPLcnet和YOLO的碰撞，真的能在cpu上快到起飞？
3D视觉工坊
10-15 1509
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达作者丨陈TEL来源丨GiantPandaCV【导语】这是一篇论证博客，前几天，baidu发布了PPLcnet，这是一款专门为cpu设计...
主干网络篇 | YOLOv5/v7 更换骨干网络之 PP-LCNet | 轻量级CPU卷积神经网络
YOLOv8项目贡献者
01-02 8900
YOLOv5/v7 更换骨干网络之 PP-LCNet
UPS-GCNet:深度未校准的光度学立体中学到了什么？ （ECCV 2020年）
05-04
不间断电源网 ， ，， ， 本文旨在发现一种深度的未校准光度立体（UPS）网络可以解决该问题的固有歧义，并在我们的分析基础上引入一种引导式认证网络（GCNet）。 概述： 我们提供： 在， ， ，和合成数据集上测试我们的方法的代码。 用于训练新模型的完整代码，包括调试，可视化和日志记录的代码。 目录 依存关系 测验 下载训练有素的模型 在DiLiGenT主数据集上测试GCNet 在Light Stage Data Gallery上测试GCNet 在Gourd＆Apple数据集上测试GCNet 在哈佛光度立体数据集上测试GCNet 在综合数据上测试GCNet 在上述数据集上测试LCNet 代码结构 训练 致谢 引文 依存关系 GCNet在实施PyTorch和与Ubuntu（14.04和16.04）和CentOS 7测试。 Python 3.7 PyTorch
快到起飞 | PP-LCNet在CPU上让模型起飞，精度提升且比MobileNetV3+快3倍
qq_42178122的博客
10-24 916
本文提出了一种基于MKLDNN加速策略的轻量级CPU网络，即PP-LCNet，它提高了轻量级模型在多任务上的性能,对于计算机视觉的下游任务，如目标检测、语义分割等，也有很好的表现。 1.简介 随着模型特征提取能力的提高及其模型参数和FLOPS数量的增加,在基于ARM架构的移动设备或者基于x86架构的cpu设备上实现快速推理变得困难.在这种情况下,已经提出了许多优秀的Mobile网络 ,但是由于MLKDNN的限制,这些网络的速度在启动MKLDNN的Interl CPU上并不理想. 在本文中,作者重新思考了在I
半小时搞定Yolov5安装配置及使用（详细过程）
热门推荐
HowieXue 薛永浩的博客
07-04 10万+
Yolov51. 下载Yolov52. 安装Yolov5 在下载配置Yolov5前，先要安装好Anaconda环境，可参考之前博文：最新Anaconda3的安装配置及使用教程（详细过程） 1. 下载Yolov5 首先下载Yolov5源码： Yolov5 Github地址：https://github.com/ultralytics/yolov5 直接git clone到本地工作目录，等待下载完成： Yolov5代码目录架构： 2. 安装Yolov5 源码下完后，下面开始安装Yolov5所需模块，
PaddleClas学习2——使用PPLCNet模型对车辆朝向进行识别（python）
WAF
11-17 887
新的属性定义变成了[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,可以在python终端中执行下面的命令，也可以将其写入一个文件，然后使用python convert.py的方式运行该文件。三个属性，因此要在上述19位标志的后面增加3位分别对应上面的3个方向。前10位中，位序号0的值为1，表示车辆颜色为"yellow"。后9位中，位序号11的值为1，表示车型为"suv"。].(括号内为新增属性位，最后一位为1，表示朝向为。
PaddleClas学习3——使用PPLCNet模型对车辆朝向进行识别（c++）
WAF
12-08 690
使用paddleclas对车辆属性进行多分类。
百度框架下的最轻量化模型 PP-LCNet，Pytorch版本代码
互相学习的小博客
02-28 1482
百度框架下的最轻量化模型 PP-LCNet，Pytorch版本代码
百度网盘AI大赛-文档图像方向识别赛第5名方案
m0_63642362的博客
09-27 396
百度网盘AI大赛-文档图像方向识别赛第5名方案
ConvNeXt-Yolo5
m0_46179553的博客
01-23 5337
背景简介 传说中的CV算法工程师抄作业必备手册，既然大佬们烧了那么多的电费为我们总结了这么多能work的trick,那岂有不抄的道理，具体论文的细节本文不做详述，论文地址如下： https://arxiv.org/abs/2201.03545 以及大佬对此的详细解读 https://mp.weixin.qq.com/s/c6MRbzQE9ErFUWdWKh8PQA 本文仅做对工程应用的整合。 ConvNeXt-YoloV5 仍然以目标检测经典模型yolov5为例，对源代码做如下的修改增加 common.py
pp-lcnet网络怎么样
11-17
pp-lcnet网络是一种比较新的网络技术，它采用了先进的深度学习算法，具有很强的计算能力和学习能力。该网络通过对大量的数据进行训练，能够实现对图像、语音、文本等多种类型数据进行高效准确地处理和分析。 pp-lcnet网络的性能非常优秀。首先，它具有较高的识别准确率和稳定性，可以准确地识别和分类各种复杂的数据。其次，该网络在处理大规模数据时具有较高的效率和速度，能够快速地完成复杂的计算任务。此外，pp-lcnet网络还具有较强的鲁棒性和泛化能力，可以应对不同的应用场景和数据特征。 pp-lcnet网络在许多领域有广泛的应用。比如，在图像识别方面，该网络可以实现目标检测、物体识别、人脸识别等任务，具有很大的应用前景。在语音识别方面，pp-lcnet网络可以实现语音的识别和理解，具有很大的实用性。此外，pp-lcnet网络还可以应用于自然语言处理、推荐系统、机器翻译等多个领域，可以为各种复杂的实际问题提供有效的解决方案。 总的来说，pp-lcnet网络是一种非常优秀的网络技术，具有较高的准确性、效率和应用能力。它在各个领域都有着广泛的应用前景，有助于推动人工智能技术的发展和应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 17
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值