文章目录

1.EfficientNet介绍
2.EfficientNet参数选择
3.EfficientNet网络结构
4.EfficientNet性能统计
5.EfficientNet的pytorch实现

paper链接：EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks
官方代码：https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet

paper核心思想：通过固定比例去缩放网络的宽度，深度，输入图像的分辨率来提高网络性能

1.EfficientNet介绍

扩大卷积神经网络被广泛用于提高精度。然而，扩大卷积神经网络的过程从来没有被很好地理解，目前有许多方法可以做到这一点。最常见的方法是通过深度或宽度（其实也就是增加channels）来放大卷积网。另一种不太常见但越来越流行的方法是根据图像分辨率放大模型。在以前的工作中，通常只缩放三个维度中的一个——深度、宽度和图像大小。虽然可以任意伸缩两个或三个维度，但任意伸缩需要繁琐的手动调优，而且通常仍会产生次优的精度和效率。

在EfficientNet中，从作者的研究证明平衡网络宽度/深度/分辨率的所有维度是至关重要的，令人惊讶的是，这种平衡可以通过固定比例缩放每个维度来实现。与传统的任意缩放这些因素不同，我们的方法统一缩放网络的宽度，深度，以及分辨率，一组固定的比例系数来解决问题。

传统的方法大多将卷积神经网络的规模分为以下几个维度之一:

Depth ( d )：更深层次的ConvNet能够捕获更丰富、更复杂的特性，并能很好地概括新任务。然而，由于梯度消失问题，更深的网络也更难以训练。虽然skip connections(和批处理归一化等技术缓解了训练问题，但是非常深的网络的准确率提高降低
Width ( w )：更广泛的网络往往能够捕获更多的细粒度特征，更容易训练。然而，极宽但较浅的网络往往难以捕获更高层次的特征。当网络变得更宽时，随着w的增大，准确率很快饱和
Resolution ( r )：增加输入网络的图像分辨率能够潜在得获得更高细粒度的特征模板，但对于非常高的输入分辨率，准确率的增益也会减小。并且大分辨率图像会增加计算量。

结论一：

放大网络宽度、深度或分辨率的任何维度都能提高精度，但对于更大的模型，精度增益会减小。

根据经验，我们观察到不同的尺度并不是独立的。直观地说，对于更高分辨率的图像，我们应该增加网络深度，这样更大的接受域可以帮助捕获更大图像中包含更多像素的相似特征。相应地，当分辨率较高时，我们也应该增加网络宽度，为了在高分辨率图像中捕获更多像素的更细粒度的模式。这些直觉表明，我们需要协调和平衡不同的尺度，而不是传统的一维尺度。

结论二：

为了追求更好的准确性和效率，在ConvNet缩放过程中，平衡网络宽度、深度和分辨率的所有维度是至关重要的。

2.EfficientNet参数选择

针对以上所提出的问题，现在所需要的求得在有限的资源里面如何确定平衡这网络的深度d，通道的宽度c，还有输入图像的分辨率r。

为了能够处理这个问题，作者将问题进行了抽象：

假设一个卷积层iii可以被定义为一个函数：Yi=Fi(Xi)Y_{i} = F_{i}(X_{i})Yi=Fi(Xi)，其中的XiX_{i}Xi表示输入的特征图，而YiY_{i}Yi是输出特征矩阵，FiF_{i}Fi就表示这一iii层的卷积操作。其中XiX_{i}Xi的tensor形状为<Hi，Wi，Ci><H_{i}，W_{i}，C_{i}><Hi，Wi，Ci>，其中HiH_{i}Hi与WiW_{i}Wi为空间维度，CiC_{i}Ci为通道维度。

而卷积网络可以由一系列这样的层结构组成：
N=Fk⨀…⨀F2⨀F1(X1)=⨀j=1…kFj(X1)N = F_{k}\bigodot \ldots \bigodot F_{2} \bigodot F_{1}(X_{1}) = \bigodot_{j = 1 \ldots k}F_{j}(X_{1}) N=Fk⨀…⨀F2⨀F1(X1)=j=1…k⨀Fj(X1)
在实践中，ConvNet层往往被划分为多个阶段，每个阶段的所有层都具有相同的架构。例如，ResNet有五个阶段，每个阶段的所有层都具有相同的卷积类型，除了第一层执行降采样（通过stride进行改变shape）。因此，我们可以将卷积网络定义为:
N=⨀j=1…sFiLi(X<Hi，Wi，Ci>)N = \bigodot_{j = 1 \ldots s}F_{i}^{L_{i}}(X_{<H_{i}，W_{i}，C_{i}>}) N=j=1…s⨀FiLi(X<Hi，Wi，Ci>)

其中，FiLiF_{i}^{L_{i}}FiLi为第iii阶段重复了LiL_{i}Li次的层FiF_{i}Fi，其中XiX_{i}Xi的tensor形状为<Hi，Wi，Ci><H_{i}，W_{i}，C_{i}><Hi，Wi，Ci>

下面这一段感觉可能难以理解：常规的ConvNet设计主要关注于寻找最佳的层架构Fi，而模型缩放试图在不改变基线网络的Fi预定义的情况下扩展网络长度(Li)、宽度(Ci)和/或分辨率(Hi, Wi)。我理解的应该就是不改变网络快结构，只是改变深度，宽度与输入的分辨率。通过修正FiFiFi，模型缩放简化了新的资源约束下的设计问题，但仍有很大的设计空间去探索不同的Li,Ci,Hi,WiLi, Ci, Hi, WiLi,Ci,Hi,Wi每一层。为了进一步减少设计空间，我们限制所有层必须按恒定比例均匀缩放。我们的目标是在任何给定的资源约束下最大化模型的精度。

为了探究d,r,wd , r , wd,r,w这三个因子对最终准确率的影响，则将d,r,wd , r , wd,r,w加入到公式中，我们可以得到抽象化后的优化问题：

其中w,d,rw, d, rw,d,r为网络宽度、深度和分辨率的缩放系数
其中Fi^，Li^，Hi^，Wi^，Ci^\hat{F_{i}}，\hat{L_{i}}，\hat{H_{i}}，\hat{W_{i}}，\hat{C_{i}}Fi^，Li^，Hi^，Wi^，Ci^为基准网络中的预定义参数

而为了能够统一width，depth，resolutionwidth，depth，resolutionwidth，depth，resolution的参数，作者使用了混合缩放方法 ( compound scaling method) ，利用一个混合因子φφφ去统一缩放这三者，具体的计算公式如下:

其中α，β，γα， β， γα，β，γ是常数，可以确定由一个小网格搜索。直观地说，φφφ是一个用户指定的系数，它控制了有多少更多的资源可以用于模型缩放，而α、β、γα、β、γα、β、γ分别指定了如何将这些额外的资源分配给网络宽度、深度和分辨率。
一个常规卷积运算的FLOPSFLOPSFLOPS与d,w2,r2d, w^{2}, r^{2}d,w2,r2成正比，即网络深度翻倍会使FLOPSFLOPSFLOPS翻倍，而网络宽度或分辨率翻倍则会使FLOPSFLOPSFLOPS增加四倍。因为，卷积层的FLOPSFLOPSFLOPS约等于featurew×featureh×featurec×kernelw×kernelh×kernelnumberfeature_{w} \times feature_{h} \times feature_{c} \times kernel_{w} \times kernel_{h} \times kernel_{number}featurew×featureh×featurec×kernelw×kernelh×kernelnumber,而widthwidthwidth翻倍，输入特征的featurecfeature_{c}featurec翻倍，输出特征的kernelnumberkernel_{number}kernelnumber也翻倍；而resolutionresolutionresolution翻倍，特征矩阵的宽度与高度featurewfeature_{w}featurew 与featurehfeature_{h}featureh翻倍

使用上述公式对卷积网络进行缩放，将使总FLOPSFLOPSFLOPS近似增加为(α∗β2∗γ2)φ(α*β^{2}*γ^{2})^{φ}(α∗β2∗γ2)φ,在EfficientNet中作者以α∗β2∗γ2≈2α*β^{2}*γ^{2}≈2α∗β2∗γ2≈2为约束条件，使任何新φφφ的总FLOPSFLOPSFLOPS约增加2φ2^{φ}2φ倍。

接下来作者在基准网络EfficientNetB-0使用NAS来搜索α,β,γ\alpha, \beta, \gammaα,β,γ这三个参数

步骤1：首先确定φ = 1，假设可用资源增加两倍，并根据公式2,3对α、β、γα、β、γα、β、γ进行小网格搜索。特别是，在α⋅β2⋅γ2≈2α·β^{2}·γ^{2}≈2α⋅β2⋅γ2≈2的约束下，我们发现EfficientNet-B0的最佳值为α = 1.2， β = 1.1， γ = 1.15。
步骤2：将α、β、γ固定为常数，利用公式3放大不同φ的基线网络，得到EfficientNet-B1到B7(详见表：表格引用与参考资料)

input_size：代表训练网络时输入网络的图像大小
width_coefficient：代表channel维度上的倍率因子，比如在 EfficientNetB0中Stage1的3x3卷积层所使用的卷积核个数是32，那么在B6中就是 32 × 1.8 = 57.6接着取整到离它最近的8的整数倍即56，其它Stage同理
depth_coefficient：代表depth维度上的倍率因子（仅针对Stage2 到Stage8），比如在EfficientNetB0中Stage7的L = 4 ，那么在B6中就是 4 × 2.6 = 10.4，接着向上取整即11
drop_connect_rate：是在MBConv结构中dropout层使用的drop_rate，在官方keras模块的实现中MBConv结构的drop_rate是从0递增到drop_connect_rate的（具体实现可以看下官方源码，注意，在源码实现中只有使用shortcut的时候才有Dropout层）。还需要注意的是，这里的Dropout层是Stochastic Depth，即会随机丢掉整个block的主分支（只剩捷径分支，相当于直接跳过了这个block）也可以理解为减少了网络的深度。
dropout_rate：是最后一个全连接层前的dropout层（在stage9的Pooling与FC之间）的dropout_rate。

3.EfficientNet网络结构

下表为EfficientNet-B0的网络框架（B1-B7就是在B0的基础上修改Resolution，Channels以及Layers），可以看出网络总共分成了9个Stage，第一个Stage就是一个卷积核大小为3x3步距为2的普通卷积层（包含BN和激活函数Swish），Stage2～Stage8都是在重复堆叠MBConv结构（最后一列的Layers表示该Stage重复MBConv结构多少次），而Stage9由一个普通的1x1的卷积层（包含BN和激活函数Swish）一个平均池化层和一个全连接层组成。表格中每个MBConv后会跟一个数字1或6，这里的1或6就是倍率因子n即MBConv中第一个1x1的卷积层会将输入特征矩阵的channels扩充为n倍，其中k3x3或k5x5表示MBConv中Depthwise Conv所采用的卷积核大小。Channels表示通过该Stage后输出特征矩阵的Channels。

MBConv结构

MBConv其实就是MobileNetV3网络中的InvertedResidualBlock，但也有些许区别。一个是采用的激活函数不一样（EfficientNet的MBConv中使用的都是Swish激活函数），另一个是在每个MBConv中都加入了SE（Squeeze-and-Excitation）模块。下图是引用参考资料的MBConv结构。

如图所示，MBConv结构主要由一个1x1的普通卷积（升维作用，包含BN和Swish），一个kxk的Depthwise Conv卷积（包含BN和Swish）k的具体值可看EfficientNet-B0的网络框架主要有3x3和5x5两种情况，一个SE模块，一个1x1的普通卷积（降维作用，包含BN），一个Droupout层构成。搭建过程中还需要注意几点：

第一个升维的1x1卷积层，它的卷积核个数是输入特征矩阵channel的n倍n∈{1,6}n \in \left\{1, 6\right\}n∈{1,6}
当n = 1 n=1n=1时，不要第一个升维的1x1卷积层，即Stage2中的MBConv结构都没有第一个升维的1x1卷积层（这和MobileNetV3网络类似）
关于shortcut连接，仅当输入MBConv结构的特征矩阵与输出的特征矩阵shape相同时才存在（代码中可通过stride == 1 and inputc_channels == output_channels条件来判断）
SE模块如下所示，由一个全局平均池化，两个全连接层组成。第一个全连接层的节点个数是输入该MBConv特征矩阵channels的 14\frac{1}{4}41，且使用Swish激活函数。第二个全连接层的节点个数等于Depthwise Conv层输出的特征矩阵channels，且使用Sigmoid激活函数。

EfficientNet(B0-B7)参数

4.EfficientNet性能统计

EfficientNet-B7超过了现有最好的GPipe精度，但使用的参数少了8.4倍，推理速度快了6.1倍。与广泛使用的ResNet-50 相比，EfficientNet-B4在类似FLOPS的情况下，将top-1的准确率从76.3%提高到了83.0%(+6.7%)。在8个广泛使用的数据集中有5个具有最先进的精度，同时比现有的ConvNets减少至多21倍的参数。

EfficientNet-B7实现了新的最先进的84.3%的顶级精度，但比GPipe小8.4倍，快6.1倍。EfficientNet-B1比ResNet-152小7.6倍，快5.7倍。

5.EfficientNet的pytorch实现

参考github代码：

import math
import torch
import torch.nn as nn# 激活函数需要继承nn.Module，然后进行正向传播
class Swish(nn.Module):def forward(self, x):return x * torch.sigmoid(x)# 3x3 DW卷积  其中'//'是取整运算符，eg: 3//2=1,
# 其中stride默认为1，也就是一般不需要进行尺寸减半操作，而通过padding扩充使得对于kernel_size为3/5均可自动补充
def ConvBNAct(in_channels,out_channels,kernel_size=3, stride=1, groups=1):return nn.Sequential(nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=kernel_size//2, groups=groups),nn.BatchNorm2d(out_channels),Swish())# pw卷积含激活函数
def Conv1x1BNAct(in_channels,out_channels):return nn.Sequential(nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1),nn.BatchNorm2d(out_channels),Swish())# pw卷积不含激活函数
def Conv1x1BN(in_channels,out_channels):return nn.Sequential(nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=1),nn.BatchNorm2d(out_channels))def Conv1(in_planes, places, stride=2):return nn.Sequential(nn.Conv2d(in_channels=in_planes,out_channels=places,kernel_size=7,stride=stride,padding=3, bias=False),nn.BatchNorm2d(places),Swish(),nn.MaxPool2d(kernel_size=3, stride=2, padding=1))# 打平操作
class Flatten(nn.Module):def forward(self, x):return x.view(x.shape[0], -1)# SE结构
class SEBlock(nn.Module):def __init__(self, channels, ratio=16):super().__init__()# 这里压缩的倍数的16倍，而在MobileNetv3中压缩的倍数是4倍mid_channels = channels // ratio# 基于通道的注意力self.se = nn.Sequential(nn.AdaptiveAvgPool2d(1),nn.Conv2d(channels, mid_channels, kernel_size=1, stride=1, padding=0, bias=True),Swish(),nn.Conv2d(mid_channels, channels, kernel_size=1, stride=1, padding=0, bias=True),)def forward(self, x):return x * torch.sigmoid(self.se(x))# MobileNetv3中的结构块，所以是MBBlock，需要注意，channels的扩充有因子expansion_factor=6
class MBConvBlock(nn.Module):def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, expansion_factor=6):super(MBConvBlock, self).__init__()self.stride = strideself.expansion_factor = expansion_factormid_channels = (in_channels * expansion_factor)self.bottleneck = nn.Sequential(# 首先PW卷积升维，扩充倍数是6倍Conv1x1BNAct(in_channels, mid_channels),# 然后DW卷积，维度不变，并且通过这一步将尺寸缩放ConvBNAct(mid_channels, mid_channels, kernel_size, stride, groups=mid_channels),# 添加一个注意力模块SEBlock(mid_channels),# 最后PW卷积降维操作，变回原来的channels数Conv1x1BN(mid_channels, out_channels))# 残差相加if self.stride == 1:self.shortcut = Conv1x1BN(in_channels, out_channels)def forward(self, x):out = self.bottleneck(x)out = (out + self.shortcut(x)) if self.stride==1 else outreturn out# 主网络
class EfficientNet(nn.Module):params = {'efficientnet_b0': (1.0, 1.0, 224, 0.2),'efficientnet_b1': (1.0, 1.1, 240, 0.2),'efficientnet_b2': (1.1, 1.2, 260, 0.3),'efficientnet_b3': (1.2, 1.4, 300, 0.3),'efficientnet_b4': (1.4, 1.8, 380, 0.4),'efficientnet_b5': (1.6, 2.2, 456, 0.4),'efficientnet_b6': (1.8, 2.6, 528, 0.5),'efficientnet_b7': (2.0, 3.1, 600, 0.5),}def __init__(self, subtype = 'efficientnet_b0', num_classes = 5):super(EfficientNet, self).__init__()self.width_coeff = self.params[subtype][0]      # 元组的第一个参数: 宽度的扩充因子 width_coefficientself.depth_coeff = self.params[subtype][1]      # 元组的第二个参数: 深度的扩充因子 depth_coefficientself.dropout_rate = self.params[subtype][3]     # 元组的第四个参数: 随机丢弃比例 最后一个全连接层前的dropout层self.depth_div = 8# 对于b0层: 输出的channels为32，特征尺寸需要减半处理，所以stride=2self.stage1 = ConvBNAct(3, self._calculate_width(32), kernel_size=3, stride=2)# 此处stride=1，所以尺寸不变self.stage2 = self.make_layer(self._calculate_width(32), self._calculate_width(16), kernel_size=3, stride=1, block=self._calculate_depth(1))self.stage3 = self.make_layer(self._calculate_width(16), self._calculate_width(24), kernel_size=3, stride=2, block=self._calculate_depth(2))self.stage4 = self.make_layer(self._calculate_width(24), self._calculate_width(40), kernel_size=5, stride=2, block=self._calculate_depth(2))self.stage5 = self.make_layer(self._calculate_width(40), self._calculate_width(80), kernel_size=3, stride=2, block=self._calculate_depth(3))# 此处stride=1，所以尺寸不变self.stage6 = self.make_layer(self._calculate_width(80), self._calculate_width(112), kernel_size=5, stride=1, block=self._calculate_depth(3))self.stage7 = self.make_layer(self._calculate_width(112), self._calculate_width(192), kernel_size=5, stride=2, block=self._calculate_depth(4))self.stage8 = self.make_layer(self._calculate_width(192), self._calculate_width(320), kernel_size=3, stride=1, block=self._calculate_depth(1))# 池化操作self.pooling = nn.Sequential(Conv1x1BNAct(self._calculate_width(320), self._calculate_width(1280)),nn.AdaptiveAvgPool2d(1),nn.Dropout2d(0.2),)# 全连接层self.fc = nn.Sequential(Flatten(),nn.Linear(self._calculate_width(1280), num_classes))self.init_weights()# 参数初始化def init_weights(self):for m in self.modules():if isinstance(m, nn.Conv2d):nn.init.kaiming_normal_(m.weight, mode="fan_out")elif isinstance(m, nn.Linear):init_range = 1.0 / math.sqrt(m.weight.shape[1])nn.init.uniform_(m.weight, -init_range, init_range)# width_coefficient因子取整到离它最近的8的整数倍def _calculate_width(self, x):# 对于输入的channels，需要乘上宽度的扩展因子x *= self.width_coeff# 当x偏向8整数倍的下方，通过加上4来判断new_x = max(self.depth_div, int(x + self.depth_div / 2) // self.depth_div * self.depth_div)if new_x < 0.9 * x:new_x += self.depth_divreturn int(new_x)# depth_coefficient因子得到小数后向上取整def _calculate_depth(self, x):return int(math.ceil(x * self.depth_coeff))     # ceil向上取整函数 eg: ceil(4.01)=5def make_layer(self, in_places, places, kernel_size, stride, block):layers = []# 通过块结构的第一层改变尺寸，所以需要传入stridelayers.append(MBConvBlock(in_places, places, kernel_size, stride))# 块结构的其他层不改变channels。注意，此处的in_channels = out_channels = placesfor i in range(1, block):layers.append(MBConvBlock(places, places, kernel_size))return nn.Sequential(*layers)# 以基本结构b0为例:# input: torch.Size([1, 3, 224, 224])def forward(self, x):x = self.stage1(x)      # torch.Size([1, 32, 112, 112])x = self.stage2(x)      # torch.Size([1, 16, 112, 112])x = self.stage3(x)      # torch.Size([1, 24, 56, 56])x = self.stage4(x)      # torch.Size([1, 40, 28, 28])x = self.stage5(x)      # torch.Size([1, 80, 14, 14])x = self.stage6(x)      # torch.Size([1, 112, 14, 14])x = self.stage7(x)      # torch.Size([1, 192, 7, 7])x = self.stage8(x)      # torch.Size([1, 320, 7, 7])x = self.pooling(x)     # torch.Size([1, 1280, 1, 1])x = self.fc(x)          # torch.Size([1, 5])return x# 最基本结构
def EfficientNet_b0():return EfficientNet('efficientnet_b0')# 以下结构为按比例的扩充模型
def EfficientNet_b1():return EfficientNet('efficientnet_b1')def EfficientNet_b2():return EfficientNet('efficientnet_b2')def EfficientNet_b3():return EfficientNet('efficientnet_b3')def EfficientNet_b4():return EfficientNet('efficientnet_b4')def EfficientNet_b5():return EfficientNet('efficientnet_b5')def EfficientNet_b6():return EfficientNet('efficientnet_b6')def EfficientNet_b7():return EfficientNet('efficientnet_b7')if __name__== '__main__':# model = EfficientNet_b0()# model = EfficientNet_b1()# model = EfficientNet_b2()# model = EfficientNet_b3()# model = EfficientNet_b4()# model = EfficientNet_b5()# model = EfficientNet_b6()model = EfficientNet_b7()# print(model)input = torch.randn(1, 3, 224, 224)out = model(input)print(out.shape)torch.save(model.state_dict(), 'EfficientNet_b7.mdl')

模型的大小如图所示：

可见，模型不算很小，所以这也是EfficientNetV2改进的一点。

参考资料：
https://blog.csdn.net/qq_37541097/article/details/114434046
https://www.bilibili.com/video/BV1XK4y1U7PX

轻量级网络——EfficientNet相关推荐

14种轻量级网络综述 — 主干网络篇
点击上方"3D视觉工坊",选择"星标" 干货第一时间送达作者丨VincentLee 来源丨晓飞的算法工程笔记编辑丨极市平台导读早期的卷积神经很少考虑参数 ...
大幅涨点！孙剑团队提出新激活层ACON和轻量级网络TFNet
知乎原文: https://zhuanlan.zhihu.com/p/363274457 论文链接: https://arxiv.org/pdf/2009.04759.pdf 代码: https:// ...
CVPR 2021 | 大幅涨点！新型动态激活函数和轻量级网络TFNet
点上方计算机视觉联盟获取更多干货仅作学术分享,不代表本公众号立场,侵权联系删除转载于:旷视研究院 AI博士笔记系列推荐周志华<机器学习>手推笔记正式开源!可打印版本附pdf下载链接 ...
轻量级网络综述 — 主干网络篇
点击上方"计算机视觉工坊",选择"星标" 干货第一时间送达轻量级网络的核心是在尽量保持精度的前提下,从体积和速度两方面对网络进行轻量化改造,本文对轻量级网络进 ...
检测、分割用什么轻量级网络呢？
点击上方"小白学视觉",选择加"星标"或"置顶" 重磅干货,第一时间送达由于深度学习的关系,计算机视觉领域发展迅速,各大榜单精度刷的很高, ...
混合深度卷积，更少参数下的轻量级网络
作者:Tom Hardy Date:2020-01-08 来源:混合深度卷积,更少参数下的轻量级网络
谷歌提出新型卷积网络EfficientNet：推理速度提升5.1倍，参数减少88%（附论文代码）...
来源:机器之心本文共1500字,建议阅读8分钟. 谷歌提出了一种新型CNN网络EfficientNet,该网络具备极高的参数效率和速度. [ 导读 ]谷歌提出了一项新型模型缩放方法:利用复合系数统一 ...
基于Attention机制的轻量级网络架构以及代码实现
点击上方,选择星标或置顶,不定期资源大放送! 阅读大概需要10分钟 Follow小博主,每天更新前沿干货导读之前详细介绍了轻量级网络架构的开源项目,详情请看深度学习中的轻量级网络架构总结与代码实现 ...
MobileNetV1/V2/V3简述 | 轻量级网络
MobileNet系列很重要的轻量级网络家族,出自谷歌,MobileNetV1使用深度可分离卷积来构建轻量级网络,MobileNetV2提出创新的inverted residual with line ...
谷歌提出新型卷积网络EfficientNet: 推理速度升5.1倍参数减少88%,需要我们的验证
推理速度升5.1倍参数减少88%:谷歌提出新型卷积网络EfficientNet 谷歌提出了一项新型模型缩放方法:利用复合系数统一缩放模型的所有维度,该方法极大地提升了模型的准确率和效率.谷歌研究人员基 ...

轻量级网络——EfficientNet