论文笔记系列：轻量级网络-- RepVGG
Posted GoAI
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了论文笔记系列：轻量级网络-- RepVGG相关的知识，希望对你有一定的参考价值。
✨写在前面：强烈推荐给大家一个优秀的人工智能学习网站，内容包括人工智能基础、机器学习、深度学习神经网络等，详细介绍各部分概念及实战教程，通俗易懂，非常适合人工智能领域初学者及研究者学习。➡️点击跳转到网站。
RepVGG笔记
论文名称：RepVGG: Making VGG-style ConvNets Great Again
论文下载地址：https://arxiv.org/abs/2101.03697
参考代码：GitHub - DingXiaoH/RepVGG: RepVGG: Making VGG-style ConvNets Great Again
RepVGG概念介绍
- RepVGG是一种简单的VGG式结构,大量使用3x3卷积，BN层，Relu激活函数，利用重参数化提升性能，准确率直逼其他SOTA网络，特点是训练时使用多分支网络，推理时融合多分支为单分支。主要解决原始VGG网络模型较大，不便于部署及性能较差提出VGG升级版本。
- 论文提出一种简单高效的卷积神经网络，该模型的推理结构类似于V G G \\rm VGGVGG，训练模型使用多分支结构。通过结构再参数化技术实现训练结构和推理结构的解耦，得到模型RepVGG。
RepVGG主要思路
（1）在VGG网络Block块中加入Identity和残差分支，相当于ResNet网络精华应用到VGG网络中；
（2）模型推理阶段，通过Op融合策略将所有的网络层都转换为Conv3*3，便于网络部署和加速。
RepVGG模型
RepVGG模型的整体结构：将20多层3x3卷积堆起来，分成5个stage，每个stage的第一层是stride=2的降采样，每个卷积层用ReLU作为激活函数。
RepVGG模型的详细结构：RepVGG-A的5个stage分别有[1, 2, 4, 14, 1]层，RepVGG-B的5个stage分别有[1, 4, 6, 16, 1]层，宽度是[64,128, 256, 512]的若干倍。
训练时，为每一个3x3卷积层添加平行的1x1卷积分支和恒等映射分支，构成一个RepVGG Block。借鉴ResNet的做法，区别在于ResNet是每隔两层或三层加一分支，RepVGG Block是每层都加。
部署时，我们将1x1卷积分支和恒等映射分支以及3x3卷积融合成一个3x3卷积达到单路结构的目的。
现有的计算库（如CuDNN,Intel MKL）和硬件针对3x3卷积有深度的优化，相比其他卷积核，3x3卷积计算密度更高，更加有效。
以残差块结构为例子，它有2个分支，其中主分支经过卷积层，假设前后张量维度相同，我们认为是一份显存消耗，另外一个旁路分支需要保存初始的输入结果，同样也是一份显存消耗，这样在运行的时候是占用了两份显存，直到最后一步将两个分支结果Add，显存才恢复成一份。而Plain结构只有一个主分支，所以其显存占用一直是一份。RepVGG主体部分只有一种算子：3x3卷积接ReLU。在设计专用芯片时，给定芯片尺寸或造价，我们可以集成海量的3x3卷积-ReLU计算单元来达到很高的效率。单路架构省内存的特性也可以帮我们少做存储单元.
多分支结构会引入网络结构的约束，比如Resnet的残差结构要求输入和卷积出来的张量维度要一致（这样才能相加），这种约束导致网络不易延伸拓展，也一定程度限制了通道剪枝。对应的单路结构就比较友好，剪枝后也能得到很好的加速比。
方法论：多分支融合
假设输入是5x5，stride=1
1x1卷积前后特征图大小不变
3x3卷积在原特征图补零，卷积前后特征图大小不变
将1x1卷积核加在3x3卷积核中间，就能完成卷积分支融合
融合示例图如下：
我们试想一下，输入与输出要相等，假设输入输出都是三通道
即每一个卷积核的通道数量，必须要求与输入通道数量一致，因为要对每一个通道的像素值要进行卷积运算，所以每一个卷积核的通道数量必须要与输入通道数量保持一致。
那么要保持原有三通道数据各权重应该如何初始化呢？
一个卷积核的尺寸为3x3x3，将对应通道的权重设为1其他为零，就能完好的保证输出原有值。
卷积+BN融合
在将identity分支和1x1卷积融合到3x3卷积后，我们将BN层融到卷积中去
Batch-Normalization (BN)是一种让神经网络训练更快、更稳定的方法(faster and more stable)。它计算每个mini-batch的均值和方差，并将其拉回到均值为0方差为1的标准正态分布。BN层通常在nonlinear function的前面/后面使用。
RepVGG的再参数化：
经过上述转换，我们可以得到一个3×3卷积，两个1 × 1 卷积和三个表示偏置的向量。然后，将三个偏置向量相加得到最后的偏置参数，然后使用零填充将1 × 1 卷积填充为3 × 3 大小，最后将所有3 × 3 大小的卷积相加，得到最后的卷积参数。
Architectural Specification
上图中的a和b 表示通道的缩放系数。
实验部分
基于不同a和b得到的RepVGG.
RepVGG for ImageNet Classification
Structural Re-parameterization is the Key
Ablation Studies
Comparison with variants and baselines
PyTorch实现RepVGG
RepVGG模块构建：
class RepVGGBlock(nn.Module):
def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, padding_mode='zeros', deploy=False):
super(RepVGGBlock, self).__init__()
self.deploy = deploy
self.groups = groups
self.in_channels = in_channels
assert kernel_size == 3
assert padding == 1
padding_11 = padding - kernel_size // 2
self.nonlinearity = nn.ReLU()
# 根据deploy决定构建训练模型还是推理模型
if deploy:
# 推理时仅有一个3x3卷积
self.rbr_reparam = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, dilation=dilation, groups=groups, bias=True, padding_mode=padding_mode)
else:
# 训练时包含一个恒等连接、一个3x3卷积核一个1x1卷积
self.rbr_identity = nn.BatchNorm2d(num_features=in_channels) if out_channels == in_channels and stride == 1 else None
self.rbr_dense = conv_bn(in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=padding, groups=groups)
self.rbr_1x1 = conv_bn(in_channels=in_channels, out_channels=out_channels, kernel_size=1, stride=stride, padding=padding_11, groups=groups)
print('RepVGG Block, identity = ', self.rbr_identity)
def forward(self, inputs):
if hasattr(self, 'rbr_reparam'):
return self.nonlinearity(self.rbr_reparam(inputs))
if self.rbr_identity is None:
id_out = 0
else:
id_out = self.rbr_identity(inputs)
return self.nonlinearity(self.rbr_dense(inputs) + self.rbr_1x1(inputs) + id_out)
# 核和偏置的转换，具体实现在_fuse_bn_tensor函数
def get_equivalent_kernel_bias(self):
kernel3x3, bias3x3 = self._fuse_bn_tensor(self.rbr_dense)
kernel1x1, bias1x1 = self._fuse_bn_tensor(self.rbr_1x1)
kernelid, biasid = self._fuse_bn_tensor(self.rbr_identity)
# 核和偏置合并
return kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1) + kernelid, bias3x3 + bias1x1 + biasid
def _pad_1x1_to_3x3_tensor(self, kernel1x1):
if kernel1x1 is None:
return 0
else:
return torch.nn.functional.pad(kernel1x1, [1,1,1,1])
def _fuse_bn_tensor(self, branch):
if branch is None:
return 0, 0
if isinstance(branch, nn.Sequential):
# 卷积层权重
kernel = branch.conv.weight
# μ
running_mean = branch.bn.running_mean
# σ
running_var = branch.bn.running_var
# BN层权重
gamma = branch.bn.weight
# BN层偏置
beta = branch.bn.bias
# BN层防止除零的参数
eps = branch.bn.eps
else:
assert isinstance(branch, nn.BatchNorm2d)
if not hasattr(self, 'id_tensor'):
input_dim = self.in_channels // self.groups
kernel_value = np.zeros((self.in_channels, input_dim, 3, 3), dtype=np.float32)
for i in range(self.in_channels):
kernel_value[i, i % input_dim, 1, 1] = 1
self.id_tensor = torch.from_numpy(kernel_value).to(branch.weight.device)
kernel = self.id_tensor
running_mean = branch.running_mean
running_var = branch.running_var
gamma = branch.weight
beta = branch.bias
eps = branch.eps
std = (running_var + eps).sqrt()
t = (gamma / std).reshape(-1, 1, 1, 1)
# 式(3)，返回 W'和 b'
return kernel * t, beta - running_mean * gamma / std
def repvgg_convert(self):
kernel, bias = self.get_equivalent_kernel_bias()
return kernel.detach().cpu().numpy(), bias.detach().cpu().numpy(),
RepVGG主体部分构建：
class RepVGG(nn.Module):
def __init__(self, num_blocks, num_classes=1000, width_multiplier=None, override_groups_map=None, deploy=False):
super(RepVGG, self).__init__()
assert len(width_multiplier) == 4
self.deploy = deploy
self.override_groups_map = override_groups_map or dict()
assert 0 not in self.override_groups_map
self.in_planes = min(64, int(64 * width_multiplier[0]))
# 构建RepVGG的各阶段
self.stage0 = RepVGGBlock(in_channels=3, out_channels=self.in_planes, kernel_size=3, stride=2, padding=1, deploy=self.deploy)
self.cur_layer_idx = 1
self.stage1 = self._make_stage(int(64 * width_multiplier[0]), num_blocks[0], stride=2)
self.stage2 = self._make_stage(int(128 * width_multiplier[1]), num_blocks[1], stride=2)
self.stage3 = self._make_stage(int(256 * width_multiplier[2]), num_blocks[2], stride=2)
self.stage4 = self._make_stage(int(512 * width_multiplier[3]), num_blocks[3], stride=2)
self.gap = nn.AdaptiveAvgPool2d(output_size=1)
# 用于分类的全连接层
self.linear = nn.Linear(int(512 * width_multiplier[3]), num_classes)
def _make_stage(self, planes, num_blocks, stride):
strides = [stride] + [1]*(num_blocks-1)
blocks = []
for stride in strides:
cur_groups = self.override_groups_map.get(self.cur_layer_idx, 1)
blocks.append(RepVGGBlock(in_channels=self.in_planes, out_channels=planes, kernel_size=3,
stride=stride, padding=1, groups=cur_groups, deploy=self.deploy))
self.in_planes = planes
self.cur_layer_idx += 1
return nn.Sequential(*blocks)
def forward(self, x):
out = self.stage0(x)
out = self.stage1(out)
out = self.stage2(out)
out = self.stage3(out)
out = self.stage4(out)
out = self.gap(out)
out = out.view(out.size(0), -1)
out = self.linear(out)
return out
RepVGG构建用于分类和分割等任务的模型，并返回推理模型：
def whole_model_convert(train_model:torch.nn.Module, deploy_model:torch.nn.Module, save_path=None):
all_weights =
for name, module in train_model.named_modules():
# 条件语句判断不同形式的层
if hasattr(module, 'repvgg_convert'):
# 获得转换后的卷积层权重和偏置
kernel, bias = module.repvgg_convert()
# 加载权重
all_weights[name + '.rbr_reparam.weight'] = kernel
all_weights[name + '.rbr_reparam.bias'] = bias
print('convert RepVGG block')
else:
for p_name, p_tensor in module.named_parameters():
full_name = name + '.' + p_name
if full_name not in all_weights:
all_weights[full_name] = p_tensor.detach().cpu().numpy()
for p_name, p_tensor in module.named_buffers():
full_name = name + '.' + p_name
if full_name not in all_weights:
all_weights[full_name] = p_tensor.cpu().numpy()
# 加载权重
deploy_model.load_state_dict(all_weights)
if save_path is not None:
torch.save(deploy_model.state_dict(), save_path)
return deploy_model
调用
# 1. 构建基于RepVGG的任务模型，如这里构建PSPNet
# 调用流程如下：
###################### 1 ######################
train_backbone = create_RepVGG_B2(deploy=False)
train_backbone.load_state_dict(torch.load('RepVGG-B2-train.pth'))
train_pspnet = build_pspnet(backbone=train_backbone)
segmentation_train(train_pspnet)
###################### 2 ######################
# 2. 构建PSPNet的推理模型
deploy_backbone = create_RepVGG_B2(deploy=True)
deploy_pspnet = build_pspnet(backbone=deploy_backbone)
whole_model_convert(train_pspnet, deploy_pspnet)
segmentation_test(deploy_pspnet)
RepVGG转换成推理模型：
def repvgg_model_convert(model:torch.nn.Module, build_func, save_path=None):
converted_weights =
for name, module in model.named_modules():
if hasattr(module, 'repvgg_convert'):
kernel, bias = module.repvgg_convert()
converted_weights[name + '.rbr_reparam.weight'] = kernel
converted_weights[name + '.rbr_reparam.bias'] = bias
elif isinstance(module, torch.nn.Linear):
converted_weights[name + '.weight'] = module.weight.detach().cpu().numpy()
converted_weights[name + '.bias'] = module.bias.detach().cpu().numpy()
del model
deploy_model = build_func(deploy=True)
for name, param in deploy_model.named_parameters():
print('deploy param: ', name, param.size(), np.mean(converted_weights[name]))
param.data = torch.from_numpy(converted_weights[name]).float()
if save_path is not None:
torch.save(deploy_model.state_dict(), save_path)
return deploy_model
调用
# 构建模型
train_model = create_RepVGG_A0(deploy=False)
# 训练模型
train train_model
# 转换模型
deploy_model = repvgg_convert(train_model, create_RepVGG_A0, save_path='repvgg_deploy.pth')
参考文章与资料推荐：
RepVGG网络简介(强推)
论文阅读 | 轻量级网络之RepVGG_zhangts20的博客
RepVGG：极简架构，SOTA性能，让VGG式模型再次伟大（CVPR-2021）
以上是关于论文笔记系列：轻量级网络-- RepVGG的主要内容，如果未能解决你的问题，请参考以下文章
芒果改进YOLOv5系列：2023年最新论文出品｜结合设计硬件感知神经网络设计的高效 Repvgg 式 ConvNet 网络结构 EfficientRep ，该网络结构效果SOTA，涨点利器