【人工智能笔记】第二十六节 tensorflow 2.0 实现 RepVGG 高效卷积

最新推荐文章于 2022-11-19 15:33:26 发布
最新推荐文章于 2022-11-19 15:33:26 发布
阅读量1.2k 收藏 15
点赞数 3
分类专栏： 深度学习 文章标签： tensorflow2 RepVGG 人工智能 python 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/highlevels/article/details/113339217
版权

该版本基于PyTouch版本改写。

作者提出了一个简单但功能强大的卷积神经网络架构，该架构具有类似于VGG的推理时间主体，该主体仅由3x3卷积和ReLU的堆栈组成，而训练时间模型具有多分支拓扑。训练时间和推理时间架构的这种解耦是通过结构性重新参数化技术实现的，因此该模型称为RepVGG。在ImageNet上，据我们所知，RepVGG的top-1准确性达到80％以上，这是纯模型首次实现该精度。在NVIDIA 1080Ti GPU上，RepVGG模型的运行速度比ResNet-50快83％，比ResNet-101快101％，具有更高的精度，并且与诸如EfficientNet和RegNet的最新模型相比，显示出良好的精度-速度折衷。

如下图，网络结构分成种，图中B结构是训练时的结构，C结构是推理时的结构。推理时按卷积原理，把3个分支的权重合并成1个卷积权重，以提高推理速度。

效率与精度如下：

实现代码如下，结果由于权重合并时的精度影响，输出值会有稍微的差异：

import tensorflow as tf

class ConvBn(tf.keras.layers.Layer):
  def __init__(self, filters, kernel_size, strides=1, padding='same', groups=1, **kwargs):
    super(ConvBn, self).__init__(**kwargs)
    self.conv = tf.keras.layers.Conv2D(filters, kernel_size, strides=strides, padding=padding,
                                       groups=groups, use_bias=False)
    self.bn = tf.keras.layers.BatchNormalization()

  def call(self, inputs, training):
    x = inputs
    x = self.conv(x)
    x = self.bn(x, training=training)
    return x

class RepVGGBlock(tf.keras.layers.Layer):
  def __init__(self, filters, kernel_size, strides=1, padding='same', groups=1, deploy=False, **kwargs):
    super(RepVGGBlock, self).__init__(**kwargs)
    self.filters = filters
    self.kernel_size = kernel_size
    self.strides = strides
    self.padding = padding
    self.groups = groups
    self.deploy = deploy

  def build(self, input_shape):
    self.in_channels = input_shape[-1]
    if self.deploy:
        # 部署
        self.rbr_reparam = tf.keras.layers.Conv2D(self.filters, self.kernel_size, strides=self.strides, padding=self.padding,
                                                  groups=self.groups, use_bias=True)
    else:
        # 训练
        self.rbr_identity = tf.keras.layers.BatchNormalization() if self.in_channels == self.filters and self.strides == 1 else None
        self.rbr_dense = ConvBn(self.filters, kernel_size=self.kernel_size, strides=self.strides, padding=self.padding, groups=self.groups)
        self.rbr_1x1 = ConvBn(self.filters, kernel_size=1, strides=self.strides, padding=self.padding, groups=self.groups)
        tf.print('RepVGG Block, identity = ', self.rbr_identity)
    super(RepVGGBlock, self).build(input_shape)

  def call(self, inputs, training):
    x = inputs
    if hasattr(self, 'rbr_reparam'):
      return tf.nn.relu(self.rbr_reparam(x))

    if self.rbr_identity:
      id_out = self.rbr_identity(x, training=training)
    else:
      id_out = 0

    x = tf.nn.relu(self.rbr_dense(x, training=training) + self.rbr_1x1(x, training=training) + id_out)
    return x
  
  def get_equivalent_kernel_bias(self):
    '''计算等价kernel与bias'''
    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 + tf.pad(kernel1x1, [[1,1],[1,1],[0,0],[0,0]]) + kernelid, bias3x3 + bias1x1 + biasid

  def _fuse_bn_tensor(self, branch):
    if branch is None:
      return 0, 0
    if isinstance(branch, ConvBn):
      kernel = branch.conv.kernel
      moving_mean = branch.bn.moving_mean
      moving_variance = branch.bn.moving_variance
      gamma = branch.bn.gamma
      beta = branch.bn.beta
      eps = branch.bn.epsilon
    else:
      assert isinstance(branch, tf.keras.layers.BatchNormalization)
      if not hasattr(self, 'id_tensor'):
        input_dim = self.in_channels // self.groups
        kernel_value = tf.zeros((3, 3, input_dim, self.in_channels), dtype=tf.float32)
        for i in range(self.in_channels):
          kernel_value = tf.tensor_scatter_nd_update(kernel_value, [[1, 1, i % input_dim, i]], [1])
        self.id_tensor = kernel_value
      kernel = self.id_tensor
      moving_mean = branch.moving_mean
      moving_variance = branch.moving_variance
      gamma = branch.gamma
      beta = branch.beta
      eps = branch.epsilon
    std = tf.math.sqrt(moving_variance + eps)
    t = tf.reshape(gamma / std, (1, 1, 1, -1))
    return kernel * t, beta - moving_mean * gamma / std

  def repvgg_convert(self):
    kernel, bias = self.get_equivalent_kernel_bias()
    return kernel, bias

class RepVGG(tf.keras.Model):
  def __init__(self, num_blocks, num_classes=1000, width_multiplier=None, override_groups_map=None, deploy=False, **kwargs):
    super(RepVGG, self).__init__(**kwargs)
    self.num_blocks = num_blocks
    self.num_classes = num_classes
    self.width_multiplier = width_multiplier
    self.override_groups_map = override_groups_map or dict()
    self.deploy = deploy

    assert len(self.width_multiplier) == 4
    assert 0 not in self.override_groups_map

    self.in_planes = min(64, int(64 * self.width_multiplier[0]))

  def build(self, input_shape):
    self.stage0 = RepVGGBlock(self.in_planes, kernel_size=3, strides=2, padding='same', deploy=self.deploy)
    self.cur_layer_idx = 1
    self.stage1 = self._make_stage(int(64 * self.width_multiplier[0]), self.num_blocks[0], stride=2)
    self.stage2 = self._make_stage(int(128 * self.width_multiplier[1]), self.num_blocks[1], stride=2)
    self.stage3 = self._make_stage(int(256 * self.width_multiplier[2]), self.num_blocks[2], stride=2)
    self.stage4 = self._make_stage(int(512 * self.width_multiplier[3]), self.num_blocks[3], stride=2)
    
    if self.num_classes:
      self.gap = tf.keras.layers.GlobalAveragePooling2D()
      self.dense = tf.keras.layers.Dense(self.num_classes)
    super(RepVGG, self).build(input_shape)


  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(planes, kernel_size=3,
                                strides=stride, padding='same', groups=cur_groups, deploy=self.deploy))
      self.in_planes = planes
      self.cur_layer_idx += 1
    return tf.keras.Sequential(blocks)


  def call(self, inputs, training):
    out = {}
    x = inputs
    x = self.stage0(x, training=training)
    out['stage0'] = x
    x = self.stage1(x, training=training)
    out['stage1'] = x
    x = self.stage2(x, training=training)
    out['stage2'] = x
    x = self.stage3(x, training=training)
    out['stage3'] = x
    x = self.stage4(x, training=training)
    out['stage4'] = x
    if self.num_classes:
      x = self.gap(x, training=training)
      x = self.dense(x)
      return x
    else:
      return out

  def get_all_layers(self):
    layers = {}
    for layer in self.layers:
      if isinstance(layer, tf.keras.Sequential):
        for l in layer.layers:
          layers[layer.name+'/'+l.name]=l
      else:
        layers[layer.name]=layer
    return layers

optional_groupwise_layers = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26]
g2_map = {l: 2 for l in optional_groupwise_layers}
g4_map = {l: 4 for l in optional_groupwise_layers}

def create_RepVGG_A0(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[2, 4, 14, 1], num_classes=num_classes,
                width_multiplier=[0.75, 0.75, 0.75, 2.5], override_groups_map=None, deploy=deploy)

def create_RepVGG_A1(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[2, 4, 14, 1], num_classes=num_classes,
                width_multiplier=[1, 1, 1, 2.5], override_groups_map=None, deploy=deploy)

def create_RepVGG_A2(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[2, 4, 14, 1], num_classes=num_classes,
                width_multiplier=[1.5, 1.5, 1.5, 2.75], override_groups_map=None, deploy=deploy)

def create_RepVGG_B0(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[1, 1, 1, 2.5], override_groups_map=None, deploy=deploy)

def create_RepVGG_B1(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[2, 2, 2, 4], override_groups_map=None, deploy=deploy)

def create_RepVGG_B1g2(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[2, 2, 2, 4], override_groups_map=g2_map, deploy=deploy)

def create_RepVGG_B1g4(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[2, 2, 2, 4], override_groups_map=g4_map, deploy=deploy)


def create_RepVGG_B2(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[2.5, 2.5, 2.5, 5], override_groups_map=None, deploy=deploy)

def create_RepVGG_B2g2(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[2.5, 2.5, 2.5, 5], override_groups_map=g2_map, deploy=deploy)

def create_RepVGG_B2g4(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[2.5, 2.5, 2.5, 5], override_groups_map=g4_map, deploy=deploy)


def create_RepVGG_B3(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[3, 3, 3, 5], override_groups_map=None, deploy=deploy)

def create_RepVGG_B3g2(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[3, 3, 3, 5], override_groups_map=g2_map, deploy=deploy)

def create_RepVGG_B3g4(num_classes=1000, deploy=False):
  return RepVGG(num_blocks=[4, 6, 16, 1], num_classes=num_classes,
                width_multiplier=[3, 3, 3, 5], override_groups_map=g4_map, deploy=deploy)


func_dict = {
  'RepVGG-A0': create_RepVGG_A0,
  'RepVGG-A1': create_RepVGG_A1,
  'RepVGG-A2': create_RepVGG_A2,
  'RepVGG-B0': create_RepVGG_B0,
  'RepVGG-B1': create_RepVGG_B1,
  'RepVGG-B1g2': create_RepVGG_B1g2,
  'RepVGG-B1g4': create_RepVGG_B1g4,
  'RepVGG-B2': create_RepVGG_B2,
  'RepVGG-B2g2': create_RepVGG_B2g2,
  'RepVGG-B2g4': create_RepVGG_B2g4,
  'RepVGG-B3': create_RepVGG_B3,
  'RepVGG-B3g2': create_RepVGG_B3g2,
  'RepVGG-B3g4': create_RepVGG_B3g4,
}
def get_RepVGG_func_by_name(name):
  return func_dict[name]

#   Use like this:
#   train_model = get_RepVGG_func_by_name('RepVGG-A0')(deploy=False)
#   train train_model
#   deploy_model = repvgg_convert(train_model, 'RepVGG-A0', save_path='repvgg_deploy.pth')
def repvgg_model_convert(model:RepVGG, model_name, save_path=None):
  converted_weights = {}
  for name, layer in model.get_all_layers().items():
    if hasattr(layer, 'repvgg_convert'):
      kernel, bias = layer.repvgg_convert()
      converted_weights[name + '/conv2d/kernel:0'] = kernel.numpy()
      converted_weights[name + '/conv2d/bias:0'] = bias.numpy()
    elif isinstance(layer, tf.keras.layers.Dense):
      converted_weights[name + '/kernel:0'] = layer.kernel.numpy()
      converted_weights[name + '/bias:0'] = layer.bias.numpy()
    else:
      print(name, type(layer))
  build_func = get_RepVGG_func_by_name(model_name)
  deploy_model = build_func(deploy=True)
  deploy_model.build((None, 160, 160, 3))
  trainable_variables = deploy_model.trainable_variables
  for i, var in enumerate(converted_weights.values()):
    deploy_var = trainable_variables[i]
    deploy_var.assign(var)
    tf.print('deploy param: ', deploy_var.name, deploy_var.shape, tf.math.reduce_mean(deploy_var))

  if save_path is not None:
    deploy_model.save(save_path)

  return deploy_model

def main():
  '''发布demo'''
  m = get_RepVGG_func_by_name('RepVGG-A0')(deploy=False)
  x = tf.random.uniform((1, 160, 160, 3), dtype=tf.float32)
  m.build((None, 160, 160, 3))
  m_deploy = repvgg_model_convert(m, 'RepVGG-A0')
  out1 = m(x, training=False)
  out2 = m_deploy(x, training=False)
  tf.print('out1:', out1['classes'])
  tf.print('out2:', out2['classes'])

if __name__ == '__main__':
  main()

本节内容到此结束，谢谢关注！ 

参考资料：

PPHT-H
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
RepVGG:RepVGG
03-08
RepVGG：使VGG样式的ConvNets再次变得出色（CVPR-2021）（PyTorch） 这是一个超级简单的ConvNet架构，通过3x3 conv和ReLU的堆栈在ImageNet上实现了80％的top-1精度！ 此存储库包含预训练的模型，用于构建模型，训练的代码以及从训练时模型到推理时的转换。 MegEngine版本： : 。 @upczww 使用C ++ API进行TensorRT实现。 做得好！ @zjykzj 另一个不错的PyTorch实现。 包含在一个著名的模型动物园中（超过7k星） 。 更新（2021年1月13日）：您可以随时以不同的方式获得等效的内核和偏差（repvgg.py中的get_equivalent_kernel_bias）。 这可能有助于基于训练的修剪或量化。 更新（2021年1月31日）：此训练脚本（超简单的PyTorch官方示例样式
【笔记】Keras搭建网络：搭建的第一层layer需要增加input_shape关键字参数
nyist_yangguang的博客
11-30 2056
附Dense源码： class Dense(Layer): def __init__(self, units, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regula
RepVGG-Tensorflow-2-main.zip
03-26
RepVGG-Tensorflow-2-main.zip
keras实现自定义层的关键步骤解析
热门推荐
MIss-Y的博客
05-24 1万+
前言：Keras提供众多常见的已编写好的层对象，例如常见的卷积层、池化层等，我们可以直接通过以下代码调用。Keras中的层大致上分为两种类型： 第一种是带有训练参数的：比如Dense层、Conv2D层，等等，我们在训练的过程中需要训练层的权重和偏置项； 第二种是不带训练参数的：比如dropout层、flatten层、等等，我们不需要训练它的权重，只需要对输入进行加工处理再输出就行了。...
transformer模型_Pytorch学习记录-Transformer（模型实现）
weixin_39959505的博客
11-28 369
Pytorch学习记录-torchtext和Pytorch的实例40. PyTorch Seq2Seq项目介绍在完成基本的torchtext之后，找到了这个教程，《基于Pytorch和torchtext来理解和实现seq2seq模型》。 这个项目主要包括了6个子项目~~使用神经网络训练Seq2Seq~~~~使用RNN encoder-decoder训练短语表示用于统计机器翻译~~~~使用共同学习完...
CVPR 2021 速览 | 旷视研究院入选学术成果盘点（下）
旷视开发者技术社区
04-01 1285
在近日正式揭晓论文接收情况的CVPR 2021中，旷视研究院共入选论文22篇，其中Oral论文2篇，研究领域涵盖激活函数、神经网络、神经网络架构搜索、光流估计、无监督学习、人体姿态估计、目...
RepVgg实战：使用RepVgg实现图像分类
10-12
所谓“VGG式”指的是： 1. 没有任何分支结构。即通常所说的plain或feed-forward架构。 2. 仅使用3x3卷积。 3. 仅使用ReLU作为激活函数。 详见： https://blog.csdn.net/hhhhhhhhhhwwwwwwwwww/article/details/126516646
RepVGG：让VGG风格的ConvNet再次伟大起来
qq_40107571的博客
11-19 648
RepVGG：让VGG风格的ConvNet再次伟大起来（RepVGG: Making VGG-style ConvNets Great Again）
CVPR 2021 | RepVGG: Making VGG-style ConvNets Great Again阅读分享（keras实现）
u011447962的博客
06-06 645
RepVGG: Making VGG-style ConvNets Great Again paper:https://arxiv.org/pdf/2101.03697.pdf code:https://github.com/DingXiaoH/RepVGG 摘要 提出了一个简单而强大的卷积神经网络结构，它具有一个类似VGG的推理时间体，只由3×3卷积和ReLU组成，而训练时间模型有一个多分支拓扑。训练时间和推理时间体系结构的解耦是通过结构再参数化技术实现的，因此该模型被命名为RepVGG。在Ima
keras代码集锦
左手coding，右手cooking
07-04 696
keras代码集锦
keras vgg 代码实例
04-30
keras vgg 训练自己的数据.详细的观看 https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html
基于tensorflow2.0实现图卷积神经网络GCN.zip
最新发布
08-22
图卷积神经网络(GCN)理解与 tensorflow2.0 代码实现 图(Graph)，一般用 G = ( V , E ) G=(V,E)G=(V,E) 表示，这里的V VV是图中节点的集合，E EE 为边的集合，节点的个数用N NN表示。在一个图中，有三个比较重要的...
Google老师亲授TensorFlow2.0入门到进阶（教学视频、笔记）
05-05
Google老师亲授TensorFlow2.0入门到进阶（教学视频、笔记） 第1章 Tensorflow简介与环境搭建 第2章 Tensorflow keras实战 第3章 Tensorflow基础API使用 第4章 Tensorflow dataset使用 第5章 Tensorflow Estimator...
阿里天池 Tensorflow2.0 教程笔记：卷积神经网络.md
09-05
包含卷积神经网络基本原理，代码介绍，并给出Le-Net5应用于MNIST手写数字识别的完整代码，并对代码中使用的compile()、fit()、evaluate()函数进行详细说明，适宜深度学习小白参考。
tensorflow2-docs-zh:TF2.0 TensorFlow 2.0 TensorFlow2.0 官方文档中文版
05-29
TensorFlow 2 / 2.0 官方文档中文版相关链接，，，目录(持续更新)基础 - 机器学习基础 ML basics过拟合与欠拟合 Overfitting and underfitting保存和恢复模型 Save and restore models基础 - 图像分类卷积神经网络 ...
TensorFlow2.0(十)–实现深度可分离卷积神经网络
12-21
深度可分离卷积网络实现2.1 导入相应的库2.2 数据集的加载与处理2.3 构建模型2.4 2.4 模型的编译与训练2.5 学习曲线绘制2.6 模型验证 1. 深度可分离卷积网络介绍 1. 1 深度可分离卷积网络与普通卷积网络 深度可分离...
【人工智能笔记】第二十节 efficientdet 目标检测模型，官方源码分析系列，BiFPN实现细节分析（二）
不定时更新AI技术tensorflow实现方式，欢迎关注，有问题请私信我。
10-22 3649
本章继续分析，BiFPN的实现部分。各种FPN结构如下： 如图，单个BiFPN有8个Node。在Efficientdet模型中，由如下类组成： FPNCells：按fpn_cell_repeats参数生成重复多个BiFPN。 FPNCell：代表单个BiFPN，包含8个Node。 FNode：将当前Node的多个输入融合，产生一个输出。 代码结构如下： FPNCells代码如下： class FPNCells(tf.keras.layers.Layer): .
Mask RCNN训练自己的数据集(修正及windows下使用labelme)
不定时更新AI技术tensorflow实现方式，欢迎关注，有问题请私信我。
10-11 2954
原文参考：https：//blog.csdn.net/l297969586/article/details/79140840/ labelme编译并使用： 源码：https：//github.com/tfwcn/labelme 源码已改成批量转Json的文件 Logs 2018/11/8 修改成自动保存到图片目录下到json文件夹中。需预先建立文件夹。 以前用过该工具的，请先删除C:...
MaskRCNN RPN网络分析
不定时更新AI技术tensorflow实现方式，欢迎关注，有问题请私信我。
11-03 2834
在每个锚生成5种大小和3种形状的候选框（每层特征对应一种大小，每个锚点对应3种形状）。并进行两层卷积后，做前景与背景的分类，与候选框的偏移量回归。与目标重叠> = 0.7则为前景，与目标重叠<= 0.3则为背景，其余框去掉。 ############################################################ # Region Propos...
使用tensorflow2.0版本，使用卷积神经网络对CIFAR-100数据集进行数据预处理并给出训练后的模型得分
06-14
好的，以下是使用TensorFlow 2.0版本，使用卷积神经网络对CIFAR-100数据集进行数据预处理并给出训练后的模型得分的步骤： 1. 导入必要的库 ```python import tensorflow as tf from tensorflow import keras from ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

PPHT-H

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值