剪枝与重参第八课：ACNet重参

已于 2023-05-02 16:26:05 修改
阅读量699 收藏 7
点赞数 1
分类专栏： 剪枝与重参 文章标签： 模型剪枝 模型重参数 深度学习
于 2023-04-17 12:56:34 首次发布
本博客上原创文章未经本人许可，不得用于商业用途。转载请注明出处，否则保留追究法律责任的权利
本文链接：https://blog.csdn.net/qq_40672115/article/details/130197562
版权

目录

ACNet重参

前言

手写AI推出的全新模型剪枝与重参课程。记录下个人学习笔记，仅供自己参考。

本次课程主要讲解ACNet的重参。

课程大纲可看下面的思维导图

在这里插入图片描述

1. 并行多分支结构

  • 并行多分支结构是近年来在深度学习领域中的一种常用技术(其作用是让特征提取得更有表征性，让模型的泛化能力更强)。以下是一些相关的里程碑论文和年份：

DenseNet

  • 论文：2016年，Densely Connected Convolutional Networks
  • 该论文提出了一种全新的网络结构，通过将每一层与之前所有层连接，形成了一种密集连接的网络结构。这种结构在训练时可以更好地利用特征重用，使得特征更具表征性。DenseNet 是多分支结构的一个重要代表

VOVNet

Res2Net

  • 论文：2019年，Res2Net: A New Multi-scale Backbone Architecture
  • 该论文提出了一种基于残差块的多尺度特征提取方法，通过使用多个尺度的卷积核来提取不同尺度的特征，并在残差块中使用注意力机制来调整特征的权重，可以提高模型的性能

PeleeNet

1.1. 并行多分支结构 Demo

我们先简单来实现一个并行多分支结构的网络，如下图所示：

在这里插入图片描述

示例代码如下所示：

import torch
import torch.nn as nn

class SimpleParallelNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.branch1 = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=4, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        self.branch2 = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=4, kernel_size=5, stride=1, padding=2),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        self.branch3 = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=4, kernel_size=7, stride=1, padding=3),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        
        self.conv = nn.Conv2d(12, 32, kernel_size=3, stride=1, padding=1)
        self.fc   = nn.Linear(8192, 10)
    
    def forward(self, x):
        x1 = self.branch1(x)
        x2 = self.branch2(x)
        x3 = self.branch3(x)
        x  = torch.cat((x1, x2, x3), dim=1)
        x  = self.conv(x)
        x  = x.view(int(x.size(0)), -1)
        x  = self.fc(x)
        return x

if __name__ == "__main__":
    model = SimpleParallelNet()
    dummy_input = torch.randn((1, 3, 32, 32))
    model(dummy_input)
    output_path = './test.onnx'
    torch.onnx.export(model, dummy_input, output_path)

2. ACNet

  • 多分支结构虽然有更强的表征性，但是计算量也随之增大，有没有办法可以在提高表征性的同时又减少计算量呢？
  • 答案：训练时多分支，推理时合并为单分支，ACNet就是开端
  • 重参是指网络的参数重新组织，通常会减少参数量并提高计算效率，同时尽量保持网络性能不受影响。具体地说，可以通过一些技巧来减少网络中的卷积运算，例如通过组合多个卷积操作，使其变为一个卷积操作等等。
  • ACNet中的重参操作可以看作是一种加速卷积的方法。它将原来需要进行三次卷积操作的网络结构改为一次卷积操作，从而减少了计算量和参数量。具体来说，ACNet在进行前后特征的融合时，使用了组合卷积的方式来替代原来的三次卷积操作。

2.1 ACNet简述

ACNet提出了一种替代卷积核的方法，用来增加模型对图像翻转和旋转的鲁棒性

这种方法在训练阶段中使用1x3卷积、3x1卷积和3x3卷积代替原来的3x3卷积，并将它们的计算结果进行融合得到卷积层的输出

在这里插入图片描述

这个过程，ACNet没有引入额外的超参数，也没有增加推理阶段的计算量。

在推理阶段，ACNet使用融合后的卷积核参数来初始化现有的网络，以提升模型的特征提取能力

ACNet的方法在实验中表现出强大的性能，尤其是在图像翻转和旋转的情况下，其鲁棒性远高于其它方法。这种方法的特定是引入了非对称卷积核，因此被称为Asymmetric Convolution。ACNet的方法可以为各种网络带来涨点，因为它提升了模型对图像翻转和旋转的鲁棒性，同时不会增加推理阶段的计算量。

2.2 init

ACNet的初始化函数

import torch.nn as nn

class ACNet(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size,
                 stride, padding = 0, dilation = 1,
                 groups = 1, padding_mode = 'zeros',
                 deploy = False, use_affine = True):
        super().__init__()
        self.deploy = deploy
        if self.deploy:
            self.fused_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(kernel_size, kernel_size),
                                        stride=stride, padding=padding, dilation=dilation,
                                        groups=groups, bias=True, padding_mode=padding_mode)
        else:
            self.square_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(kernel_size, kernel_size),
                                         stride=stride, padding=padding, dilation=dilation,
                                         groups=groups, bias=True, padding_mode=padding_mode)
            
            self.square_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine)

            if padding - kernel_size // 2 >= 0:
                self.crop = 0
                hor_padding = [padding - kernel_size // 2, padding]
                ver_padding = [padding, padding - kernel_size // 2]
            else:
                self.crop = kernel_size // 2 - padding
                hor_padding = [0, padding]
                ver_padding = [padding, 0]
            
            self.ver_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(kernel_size, 1),
                                      stride=stride, padding=ver_padding, dilation=dilation,
                                      groups=groups, bias=True, padding_mode=padding_mode)
            
            self.ver_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine)

            self.hor_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(1, kernel_size),
                                      stride=stride, padding=hor_padding, dilation=dilation,
                                      groups=groups, bias=True, padding_mode=padding_mode)
            
            self.hor_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine)

use_affine用于控制是否将 γ \gamma γ和 β \beta β设置为可学习参数

2.3 forward

ACNet的前向传播函数

import torch.nn as nn

class ACNet(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size,
                 stride, padding = 0, dilation = 1,
                 groups = 1, padding_mode = 'zeros',
                 deploy = False, use_affine = True):
        super().__init__()
        pass
    
    def forward(self, input):
        if self.deploy:
            return self.fused_conv(input)
        else:
            square_outputs = self.square_conv(input)
            square_outputs = self.square_bn(square_outputs)

            if self.crop > 0:
                ver_input = input[:, :, :, self.crop:-self.crop]
                hor_input = input[:, :, self.crop:-self.crop, :]
            else:
                ver_input = input
                hor_input = input
            vertical_outputs = self.ver_conv(ver_input)
            vertical_outputs = self.ver_bn(vertical_outputs)
            horizontal_outputs = self.hor_conv(hor_input)
            horizontal_outputs = self.hor_bn(horizontal_outputs)
            result = square_outputs + vertical_outputs + horizontal_outputs
            return result

2.4 swtich to deploy

ACNet的转换函数，将训练时3个卷积核转换为推理时的一个卷积核

import torch.nn as nn

class ACNet(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size,
                 stride, padding = 0, dilation = 1,
                 groups = 1, padding_mode = 'zeros',
                 deploy = False, use_affine = True):
        super().__init__()
        pass
        
    def forward(self, input):
        pass

    def swtich_to_deploy(self):
        self.deploy = True
        deploy_k, deploy_b = self.get_equivalent_kernel_bias()
        self.fused_conv = nn.Conv2d(in_channels=self.square_conv.in_channels,
                                    out_channels=self.square_conv.out_channels,
                                    kernel_size=self.square_conv.kernel_size,
                                    stride=self.square_conv.stride,
                                    padding=self.square_conv.padding,
                                    dilation=self.square_conv.dilation,
                                    groups=self.square_conv.groups,
                                    bias=True,
                                    padding_mode=self.square_conv.padding_mode)

        self.__delattr__('square_conv')
        self.__delattr__('square_bn')
        self.__delattr__('hor_conv')
        self.__delattr__('hor_bn')
        self.__delattr__('ver_conv')
        self.__delattr__('ver_bn')

        self.fused_conv.weight.data = deploy_k
        self.fused_conv.bias.data = deploy_b

    def get_equivalent_kernel_bias(self):
        pass

2.5 get_equivalent_kernel_bias

ACNet的重参具体实现函数

import torch.nn as nn

class ACNet(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size,
                 stride, padding = 0, dilation = 1,
                 groups = 1, padding_mode = 'zeros',
                 deploy = False, use_affine = True):
        super().__init__()
        pass
    
    def forward(self, input):
        pass

    def swtich_to_deploy(self):
        pass

    def get_equivalent_kernel_bias(self):
        hor_k, hor_b = self.fuse_bn_tensor(self.hor_conv, self.hor_bn)
        ver_k, ver_b = self.fuse_bn_tensor(self.ver_conv, self.ver_bn)
        square_k, square_b = self.fuse_bn_tensor(self.square_conv, self.square_bn)

        self.add_to_square_kernel(square_k, hor_k)
        self.add_to_square_kernel(square_k, ver_k)

        return square_k, hor_b + ver_b + square_b

    def fuse_bn_tensor(self, conv, bn):
        pass

    def add_to_square_kernel(self, square_kernel, asym_kernel):
        pass

2.6 Conv2d与BN的融合(重参)

ACNet的Conv2d与BN的融合函数，具体如下图所示，我们对Conv2d的Kernel都乘以 γ σ B 2 + ϵ \frac{\gamma}{\sqrt{\sigma_B^2+\epsilon}} σB2​+ϵ ​γ​，对Conv2d的bias都加上 - μ B σ B 2 + ϵ \textbf{-}\frac{\mu_B}{\sqrt{\sigma_B^{2}+\epsilon}} -σB2​+ϵ ​μB​​

在这里插入图片描述

import torch.nn as nn

class ACNet(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size,
                 stride, padding = 0, dilation = 1,
                 groups = 1, padding_mode = 'zeros',
                 deploy = False, use_affine = True):
        super().__init__()
        self.deploy = deploy
        pass
    
    def forward(self, input):
        pass

    def get_equivalent_kernel_bias(self):
        hor_k, hor_b = self.fuse_bn_tensor(self.hor_conv, self.hor_bn)
        ver_k, ver_b = self.fuse_bn_tensor(self.ver_conv, self.ver_bn)
        square_k, square_b = self.fuse_bn_tensor(self.square_conv, self.square_bn)

        self.add_to_square_kernel(square_k, hor_k)
        self.add_to_square_kernel(square_k, ver_k)

        return square_k, hor_b + ver_b + square_b

    def fuse_bn_tensor(self, conv, bn):
        std = (bn.running_var + bn.eps).sqrt()
        t = (bn.weight / std).reshape(-1, 1, 1, 1)
        return conv.weight * t, bn.bias - bn.running_mean * bn.weight / std

    def add_to_square_kernel(self, square_kernel, asym_kernel):
        pass

2.7 Conv1x3Conv3x1Conv3x3的融合(重参)

ACNet的卷积权重融合函数，具体如下图所示：

在这里插入图片描述

import torch.nn as nn

class ACNet(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size,
                 stride, padding = 0, dilation = 1,
                 groups = 1, padding_mode = 'zeros',
                 deploy = False, use_affine = True):
        super().__init__()
        self.deploy = deploy
        pass
    
    def forward(self, input):
        pass

    def swtich_to_deploy(self):
        pass

    def get_equivalent_kernel_bias(self):
        hor_k, hor_b = self.fuse_bn_tensor(self.hor_conv, self.hor_bn)
        ver_k, ver_b = self.fuse_bn_tensor(self.ver_conv, self.ver_bn)
        square_k, square_b = self.fuse_bn_tensor(self.square_conv, self.square_bn)

        self.add_to_square_kernel(square_k, hor_k)
        self.add_to_square_kernel(square_k, ver_k)

        return square_k, hor_b + ver_b + square_b

    def fuse_bn_tensor(self, conv, bn):
        std = (bn.running_var + bn.eps).sqrt()
        t = (bn.weight / std).reshape(-1, 1, 1, 1)
        return conv.weight * t, bn.bias - bn.running_mean * bn.weight / std

    def add_to_square_kernel(self, square_kernel, asym_kernel):
        asym_h = asym_kernel.size(2)
        asym_w = asym_kernel.size(3)

        square_h = square_kernel.size(2)
        square_w = square_kernel.size(2)

        square_kernel[:,
                      :,
                      square_h // 2 - asym_h // 2: square_h // 2 - asym_h // 2 + asym_h,
                      square_w // 2 - asym_w // 2: square_w // 2 - asym_w // 2 + asym_w] += asym_kernel

2.8 模型导出

ACNet网络的导出

import torch
import torch.nn as nn

class ACNet(nn.Module):
    pass

if __name__ == '__main__':
    
    dummy_input = torch.randn(1, 2, 62, 62)
    
    model = ACNet(in_channels=2, out_channels=8, kernel_size=3, padding=0, stride=1, deploy=False)
    
    model.eval()
    
    for module in model.modules():
        if isinstance(module, nn.BatchNorm2d):
            nn.init.uniform_(module.running_mean, 0, 0.1)
            nn.init.uniform_(module.running_var, 0, 0.2)
            nn.init.uniform_(module.weight, 0, 0.3)
            nn.init.uniform_(module.bias, 0, 0.4)
    
    output = model(dummy_input)
    print(model)
    torch.onnx.export(model=model, args=dummy_input, f='./ACNet.onnx', verbose=False)

    model.swtich_to_deploy()
    deployout = model(dummy_input)
    print(model)
    torch.onnx.export(model=model, args=dummy_input, f='./ACNet-deploy.onnx', verbose=False)

2.9 完整示例代码

完整的示例代码如下：

import torch
import torch.nn as nn

class ACNet(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size,
                 stride, padding = 0, dilation = 1,
                 groups = 1, padding_mode = 'zeros',
                 deploy = False, use_affine = True):
        super().__init__()
        self.deploy = deploy
        if self.deploy:
            self.fused_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(kernel_size, kernel_size),
                                        stride=stride, padding=padding, dilation=dilation,
                                        groups=groups, bias=True, padding_mode=padding_mode)
        else:
            self.square_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(kernel_size, kernel_size),
                                         stride=stride, padding=padding, dilation=dilation,
                                         groups=groups, bias=True, padding_mode=padding_mode)
            
            self.square_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine)

            if padding - kernel_size // 2 >= 0:
                self.crop = 0
                hor_padding = [padding - kernel_size // 2, padding]
                ver_padding = [padding, padding - kernel_size // 2]
            else:
                self.crop = kernel_size // 2 - padding
                hor_padding = [0, padding]
                ver_padding = [padding, 0]
            
            self.ver_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(kernel_size, 1),
                                      stride=stride, padding=ver_padding, dilation=dilation,
                                      groups=groups, bias=True, padding_mode=padding_mode)
            
            self.ver_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine)

            self.hor_conv = nn.Conv2d(in_channels=in_channels, out_channels=out_channels, kernel_size=(1, kernel_size),
                                      stride=stride, padding=hor_padding, dilation=dilation,
                                      groups=groups, bias=True, padding_mode=padding_mode)
            
            self.hor_bn = nn.BatchNorm2d(num_features=out_channels, affine=use_affine)
    
    def forward(self, input):
        if self.deploy:
            return self.fused_conv(input)
        else:
            square_outputs = self.square_conv(input)
            square_outputs = self.square_bn(square_outputs)

            if self.crop > 0:
                ver_input = input[:, :, :, self.crop:-self.crop]
                hor_input = input[:, :, self.crop:-self.crop, :]
            else:
                ver_input = input
                hor_input = input
            vertical_outputs = self.ver_conv(ver_input)
            vertical_outputs = self.ver_bn(vertical_outputs)
            horizontal_outputs = self.hor_conv(hor_input)
            horizontal_outputs = self.hor_bn(horizontal_outputs)
            result = square_outputs + vertical_outputs + horizontal_outputs
            return result

    def swtich_to_deploy(self):
        self.deploy = True
        deploy_k, deploy_b = self.get_equivalent_kernel_bias()
        self.fused_conv = nn.Conv2d(in_channels=self.square_conv.in_channels,
                                    out_channels=self.square_conv.out_channels,
                                    kernel_size=self.square_conv.kernel_size,
                                    stride=self.square_conv.stride,
                                    padding=self.square_conv.padding,
                                    dilation=self.square_conv.dilation,
                                    groups=self.square_conv.groups,
                                    bias=True,
                                    padding_mode=self.square_conv.padding_mode)

        self.__delattr__('square_conv')
        self.__delattr__('square_bn')
        self.__delattr__('hor_conv')
        self.__delattr__('hor_bn')
        self.__delattr__('ver_conv')
        self.__delattr__('ver_bn')

        self.fused_conv.weight.data = deploy_k
        self.fused_conv.bias.data = deploy_b

    def get_equivalent_kernel_bias(self):
        hor_k, hor_b = self.fuse_bn_tensor(self.hor_conv, self.hor_bn)
        ver_k, ver_b = self.fuse_bn_tensor(self.ver_conv, self.ver_bn)
        square_k, square_b = self.fuse_bn_tensor(self.square_conv, self.square_bn)

        self.add_to_square_kernel(square_k, hor_k)
        self.add_to_square_kernel(square_k, ver_k)

        return square_k, hor_b + ver_b + square_b

    def fuse_bn_tensor(self, conv, bn):
        std = (bn.running_var + bn.eps).sqrt()
        t = (bn.weight / std).reshape(-1, 1, 1, 1)
        return conv.weight * t, bn.bias - bn.running_mean * bn.weight / std

    def add_to_square_kernel(self, square_kernel, asym_kernel):
        asym_h = asym_kernel.size(2)
        asym_w = asym_kernel.size(3)

        square_h = square_kernel.size(2)
        square_w = square_kernel.size(2)

        square_kernel[:,
                      :,
                      square_h // 2 - asym_h // 2: square_h // 2 - asym_h // 2 + asym_h,
                      square_w // 2 - asym_w // 2: square_w // 2 - asym_w // 2 + asym_w] += asym_kernel

if __name__ == '__main__':
    
    dummy_input = torch.randn(1, 2, 62, 62)
    
    model = ACNet(in_channels=2, out_channels=8, kernel_size=3, padding=0, stride=1, deploy=False)
    
    model.eval()
    
    for module in model.modules():
        if isinstance(module, nn.BatchNorm2d):
            nn.init.uniform_(module.running_mean, 0, 0.1)
            nn.init.uniform_(module.running_var, 0, 0.2)
            nn.init.uniform_(module.weight, 0, 0.3)
            nn.init.uniform_(module.bias, 0, 0.4)
    
    output = model(dummy_input)
    print(model)
    torch.onnx.export(model=model, args=dummy_input, f='./ACNet.onnx', verbose=False)

    model.swtich_to_deploy()
    deployout = model(dummy_input)
    print(model)
    torch.onnx.export(model=model, args=dummy_input, f='./ACNet-deploy.onnx', verbose=False)

在ACNet的构造函数中，我们需要指定输入通道数，输出通道数，卷积核大小，步长，填充，膨胀率，分组数，padding_mode等参数。deploy参数为True表示进行部署模式，即在部署时使用融合后的卷积层，而不使用分离的卷积层。(from chatGPT)

如果deploy为False，我们会构造出square_conv，square_bn，ver_conv，ver_bn，hor_conv和hor_bn这些子模块。在forward函数中，我们首先对输入进行正方形卷积，然后分别对其进行垂直卷积和水平卷积，并将结果加起来。

在重参数化中，我们需要将所有的卷积层与它们的批量归一化层融合起来。在ACNet中，我们需要对水平卷积和垂直卷积的卷积核和偏置进行融合，并将它们与正方形卷积的卷积核和偏置相加。

在函数get_equivalent_kernel_bias中，我们调用了函数fuse_bn_tensor来融合卷积层和批量归一化层。对于卷积层的权重，我们将其乘以批量归一化层的缩放因子，然后对卷积层的偏置进行修正。

在函数add_to_square_kernel中，我们将水平卷积和垂直卷积的卷积核加到正方形卷积的卷积核上。

导出的ONNX对比图如下：

在这里插入图片描述

总结

本次课程从并行分支结构技术出发，介绍了其用途和参数量大的问题，引出关于重参的概念，学习了ACNet的重参的操作，在推理时刻将原来的三次卷积修改为一次卷积操作。期待下次DBB的重参😄

爱听歌的周童鞋
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ACNet：深度学习中的自适应卷积网络新星
gitblog_00084的博客
04-25 692
ACNet：深度学习中的自适应卷积网络新星 项目地址:https://gitcode.com/DingXiaoH/ACNet 在深度学习领域，卷积神经网络（CNN）一直是图像处理和计算机视觉任务的核心技术。然而，传统的固定大小的卷积核无法灵活适应不同区域的信息密度。针对这一问题，ACNet（Adaptive Convolution Network）项目应运而生，它引入了一种新型的自适应卷积层，旨...
剪枝与重参第一课：修剪结构和标准
周同学的博客
04-03 2360
剪枝与重参第一课笔记
ACNet
xiaochengJF的博客
11-08 5860
论文：ACNet: Strengthening the Kernel Skeletons for Powerful CNN via Asymmetric Convolution Blocks
剪枝与重参第九课：DBB重参
周同学的博客
05-02 1509
剪枝与重参第九课：DBB重参
剪枝与重参：课程总结
周同学的博客
05-02 1108
剪枝与重参课程总结
剪枝与重参第十课：RepVGG重参
周同学的博客
05-02 1107
剪枝与重参第十课：RepVGG重参
基于pytorch的yolo稀疏训练与模型剪枝
03-05
针对这些问题，"基于PyTorch的YOLO稀疏训练与模型剪枝"提供了有效的解决方案，旨在减少模型的冗余，提高运行效率，同时保持或提升模型性能。 稀疏训练（Sparse Training）是让模型在训练过程中学习到稀疏权重，即大...
TPS代码：联合令牌剪枝与压缩以实现视觉变形器更积极的压缩
08-20
联合令牌修剪和压缩模块（TPS） ，是为了解决 由修剪策略引起的错误可能...首先，TPS通过剪枝得到保留子集和剪枝子集。其次，TPS通过单向最近邻匹配和基于相似性的融合步骤，将被修剪的令牌信息压缩为部分保留令牌。
精简视觉：YOLO模型剪枝技术提升效率
最新发布
07-19
4. **易于集成**：YOLO 模型结构简单，易于与其他视觉任务（如图像分割、关键点检测等）结合使用。 5. **多尺度预测**：YOLO 可以通过多尺度预测来检测不同大小的对象，提高了检测的准确性。 YOLO 已经发展出多个...
人工智能：α β剪枝代码
04-15
在人工智能领域，α β剪枝是一种优化搜索树的策略，常用于博弈树的搜索，以减少不必要的计算。这种算法在棋类游戏如国际象棋、围棋或一字棋（也称五子棋）中尤为关键，因为它们有大量可能的走法。本主题将深入探讨...
基于pytorch的模型稀疏训练与模型剪枝示例
03-05
在PyTorch中，可以使用第三方库如`torchprune`或者`nnunet`来实现模型剪枝。这些库提供了方便的API，可以对预训练模型进行不同策略的剪枝。 为了实现模型剪枝，我们首先需要定义一个剪枝策略，如基于权重绝对值的L1...
ACNet:交流网
05-10
交流网 这是官方的工具 , , Lei Fei, Accepted by IEEE ICIP 2019 实验结果 我们在SUN-RGBD和NYUDv2中评估ACNet的mIoU 太阳RGBD 纽约市第二版 密欧 48.1％ 48.3％ 如何使用 这段代码是NYUDv2工具。 要求 Python 3 Pytorch 0.4.1 TensorboardX Tensorboard 训练模式 python ACNet_train_V1_nyuv2.py --cuda -b 4 评估模式 NYUDv2的预训练模型可从。 带有.npy格式的预处理NYUDv2数据集可在，密码：k6rv python ACNet_eval_nyuv2.py --cuda --last-ckpt '.\model\ckpt_epoch_1195.00.pth' 注意：该代码部分基于RedNet（
重参数 (Reparameterization)
连理o的博客
07-09 4720
重参数、Gumbel softmax、REINFORCE
【网络结构复现】之ACNet
qq_44785998的博客
04-12 1943
网络出处请看这篇博客：基于注意力机制的深度学习路面裂缝检测 直接上代码了，不会的地方可以留言 AFM.py from torch import nn class ConvG1(nn.Module): #ConvG1采用 7×7 和 3×3 步长均为 2 的 2 种卷积核 def __init__(self): super(ConvG1, self).__init__() self.conv1 = nn.Conv2d(512,128,7,2,3)
细粒度分类：ACNet（Attention Convolutional Binary Neural Tree）
DaZheng121的博客
05-06 2342
文章目录前言摘要一、简介二、相关工作三、Attention Convolutional Binary Neural Tree3.1 ArchitectureBackbone network moduleBranch routing moduleAttention transformerLabel prediction3.2 TrainingData augmentationLoss functionOptimization四、实验五、结论其他 前言 本文主要介绍 Attention Convolution
ACNet：用于图像超分的非对称卷积（附实现code）
Maple__Boy
07-13 764
不一样的卷积方式
ACNet(无痛涨点)
justsolow的博客
05-26 4278
ACNet(无痛涨点) 论文链接 1. 前言 不知道你是否发现了，CNN的结构创新在这两年已经变得相对很少了，同时要做出有影响力并且Solid的工作也变得越来越难，最近CNN结构方面的创新主要包含两个方面： 1、网络结构搜索，以Google Brain的EfficientNet为代表作。 2、获取更好的特征表达，主要是将特征复用，特征细化做得更加极致，以HRNet，Res2Net等为代表作。 本文要介绍的是ICCV 2019的一个新CNN架构ACNet（全称为Asymmetric Convolution N
【ICCV 2019】ACNet: 使用非对称卷积块增强CNN的卷积核骨架
weixin_44378835的博客
07-20 2055
这篇文章提出了ACNet，使用了一种可以替代原始CNN模型中普通方形$d\times d$卷积核的非对称卷积块（ Asymmetric Convolution Block，ACB）。非对称卷积块由卷积核为方形($d×d$)、水平($1×d$)和垂直($d×1$)的三个平行层组成，水平和垂直卷积核与方形卷积核相加可以对方形卷积核的骨架进行增强。利用得到的卷积核参数对原始模型进行部署还可以在不需要额外的计算成本的前提下提升原始模型的准确率：.....................
深度模型剪枝：重思价值与训练策略
对于他们研究的所有最先进的结构化修剪算法，他们发现对修剪后的模型进行微调实际上只会得到与随机初始化权重训练的模型相当或更差的性能。这意味着，即使进行了修剪，模型仍然需要从头开始训练以恢复其性能。 此外...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱听歌的周童鞋

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

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

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

打赏作者

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

抵扣说明：

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

余额充值