Yolov6、Yolov7重参数化 RepConv 详解（代码可直接使用）

最新推荐文章于 2025-05-04 09:15:00 发布

兔子Code

最新推荐文章于 2025-05-04 09:15:00 发布

阅读量1.1w

点赞数 12

分类专栏： Yolo涨点文章标签： YOLO pytorch 算法

本文链接：https://blog.csdn.net/YXD0514/article/details/132466512

版权

Yolo涨点专栏收录该内容

4 篇文章

订阅专栏

本文介绍了RepConv模型重参数化技术，以及3种融合卷积层（3x3+BN,1x1+3x3,1x1+1x3+3x1）的方法，展示了如何通过这些技术简化计算，提高模型性能。同时提到了AvgPooling转换为卷积的等效实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. RepConv简介

RepConv是一种模型重参化技术，它可以在推理阶段将多个计算模块合并为一个，提高模型的效率和性能。它最初是用于VGG网络的，但后来也被应用到其他网络结构，如ResNet和DenseNet。RepConv的主要思想是在训练时使用多分支的卷积层，然后在推理时将分支的参数重参数化到主分支上，从而减少计算量和内存消耗。RepConv在目标检测等任务上取得了很好的效果。

2. 3x3卷积+BN 融合

卷积层的计算公式为：

$C o n v (x) = W (x) + b$

卷积层的参数为：

import torch.nn as nn
for parameter in nn.Conv2d(3,3,3).named_parameters():
     print(parameter[0])

weight
bias

BN层的计算公式为：

$BN(x)=\gamma*\frac{x-mean}{\sqrt{var}}+\beta$

for parameter in nn.BatchNorm2d(3).named_parameters():
     print(parameter[0])

weight
bias

这里的 weight 和 bias 是 BN 公式里面的 ${\gamma}$ 和 ${\beta}$ ，训练过程中需要学习的参数。

下面将卷积的结果带入BN公式并进行化简：

$\begin{align} BN(Conv(x)) &= \gamma*\frac{Conv(x)-mean}{\sqrt{var}}+\beta \\ &= \gamma*\frac{W(x)+b-mean}{\sqrt{var}}+\beta \\ &= \frac{\gamma*W(x)}{\sqrt{var}}+(\frac{\gamma*(b-mean)}{\sqrt{var}}+\beta) \end{align}$

化简后 ${\frac{\gamma*W(x)}{\sqrt{var}}}$ 为融合后卷积的 weight， ${\frac{\gamma*(b-mean)}{\sqrt{var}}+\beta}$ 为融合后卷积的 bias。

import torch
import torch.nn as nn

class repconv3x3(nn.Module):
     def __init__(self, c1, c2):
          super().__init__()
          self.conv1 = nn.Conv2d(c1,c2,3,1,1,bias=False)
          self.bn1 = nn.BatchNorm2d(c2)
          self.conv_fuse=nn.Conv2d(c1,c2,3,1,1)

     def fuse_conv_bn(self, conv, bn):
          bn_mean, bn_var, bn_gamma, bn_beta = ( 
          bn.running_mean, 
          bn.running_var, 
          bn.weight, 
          bn.bias, 
          ) 
          bn_std = (bn_var + bn.eps).sqrt()  
          conv_weight = nn.Parameter((bn_gamma / bn_std).reshape(-1, 1, 1, 1) * conv.weight) 
          conv_bias = nn.Parameter(bn_beta - bn_mean * bn_gamma / bn_std) 
          return conv_weight,conv_bias
    
     def forward(self, x):
          x = self.bn1(self.conv1(x))
          return x
     def forward_fuse(self, x):
          self.conv_fuse.weight.data,self.conv_fuse.bias.data=self.fuse_conv_bn(self.conv1,self.bn1)
          return self.conv_fuse(x)
    
inputs = torch.rand((1,1,3,3))
# 重点 模型调到 eval 模式，停止参数更新
model = repconv3x3(1,2).eval()

out1 = model.forward(inputs)
out2 = model.forward_fuse(inputs)

print("difference:",((out2-out1)**2).sum().item())

difference: 2.930988785010413e-14

3. 3x3卷积 + 1x1卷积

这个非常简单，只是将1x1卷积的权重padding成3x3卷积的形状，再与3x3卷积的权重相加。

import torch
import torch.nn as nn

class repconv3x3(nn.Module):
     def __init__(self, c1, c2):
          super().__init__()
          self.conv1 = nn.Conv2d(c1,c2,3,1,1)
          self.conv2 = nn.Conv2d(c1,c2,1,1,0)
          self.conv_fuse=nn.Conv2d(c1,c2,3,1,1)

     def fuse_1x1conv_3x3conv(self, conv1, conv2):
          conv1x1_weight = nn.functional.pad(conv2.weight, [1,1,1,1])
          conv_weight = conv1x1_weight + conv1.weight
          conv_bias = conv2.bias + conv1.bias

          return conv_weight,conv_bias
    
     def forward(self, x):
          x = self.conv1(x) + self.conv2(x)
          return x
     def forward_fuse(self, x):
          self.conv_fuse.weight.data,self.conv_fuse.bias.data=self.fuse_1x1conv_3x3conv(self.conv1,self.conv2)
          return self.conv_fuse(x)
    
inputs = torch.rand((1,1,3,3))
# 重点 模型调到 eval 模式
model = repconv3x3(1,2).eval()

out1 = model.forward(inputs)
out2 = model.forward_fuse(inputs)

print("difference:",((out2-out1)**2).sum().item())

difference: 2.4980018054066022e-15

4. 1x1卷积和 3x3卷积串联

$output=Conv_{3x3}(Conv_{1x1}(x))$

首先将1x1卷积核的第0维和第1维互相调换位置，然后3x3卷积核权重与转置后的1x1卷积核进行卷积操作

import torch
import torch.nn as nn

class repconv3x3(nn.Module):
     def __init__(self, c1, c2):
          super().__init__()
          self.conv3x3 = nn.Conv2d(c2,c1,3,1,1,bias=False)
          self.conv1x1 = nn.Conv2d(c1,c2,1,1,0,bias=False)
          self.conv_fuse=nn.Conv2d(c1,c1,3,1,1,bias=False)

     def fuse_1x1conv_3x3conv(self, conv3x3, conv1x1):
          weight=nn.functional.conv2d(conv3x3.weight.data,conv1x1.weight.data.permute(1,0,2,3))
          return weight
    
     def forward(self, x):
          x = self.conv3x3(self.conv1x1(x))
          return x
     def forward_fuse(self, x):
          self.conv_fuse.weight.data =self.fuse_1x1conv_3x3conv(self.conv3x3,self.conv1x1)
          return self.conv_fuse(x)

inputs = torch.rand((1,1,3,3))
# 重点 模型调到 eval 模式
model = repconv3x3(1,2).eval()

out1 = model.forward(inputs)
out2 = model.forward_fuse(inputs)

print("difference:",((out2-out1)**2).sum().item())

difference: 4.90059381963448e-16

5. 1x1Conv、1x3Conv和3x1Conv 并联

将卷积的weight全部padding成3x3卷积的weight，然后将其相加。

import torch
import torch.nn as nn

class repconv3x3(nn.Module):
     def __init__(self, c1, c2):
          super().__init__()
          self.conv1x1 = nn.Conv2d(c1,c2,1,1,0)
          self.conv1x3 = nn.Conv2d(c2,c2,(1,3),1,(0,1))
          self.conv3x1 = nn.Conv2d(c2,c2,(3,1),1,(1,0))
          self.conv_fuse=nn.Conv2d(c1,c2,3,1,1)

     def fuse_1x1conv_1x3conv_3x1conv(self, conv1, conv2, conv3):
          weight=nn.functional.pad(conv1.weight.data,(1,1,1,1))+nn.functional.pad(conv2.weight.data,(0,0,1,1))+nn.functional.pad(conv3.weight.data,(1,1,0,0))
          bias=conv1.bias.data+conv2.bias.data+conv3.bias.data
          return weight,bias
    
     def forward(self, x):
          x = self.conv3x1(x)+self.conv1x3(x)+self.conv1x1(x)
          return x
     def forward_fuse(self, x):
          self.conv_fuse.weight.data, self.conv_fuse.bias.data=self.fuse_1x1conv_1x3conv_3x1conv(self.conv1x1,self.conv1x3,self.conv3x1)
          return self.conv_fuse(x)

inputs = torch.rand((1,2,3,3))
# 重点 模型调到 eval 模式
model = repconv3x3(2,2).eval()

out1 = model.forward(inputs)
out2 = model.forward_fuse(inputs)

print("difference:",((out2-out1)**2).sum().item())

difference: 7.327471962526033e-15

6. AvgPooling 转换 Conv

池化层是针对各个输入通道的(对单层特征图进行池化操作)，而卷积层会将所有输入通道的结果相加。平均池化层可以等价一个固定权重的卷积层，假设池化核的大小为 K，那么可以设置卷积层权重为 1/K。池化权重另外要注意的是卷积层会将所有输入通道结果相加，所以我们需要对当前输入通道设置固定的权重，对其他通道权重设置为0。

import torch
import torch.nn as nn

class repconv3x3(nn.Module):
     def __init__(self, c1):
          super().__init__()
          self.avg = nn.AvgPool2d(3,1,1)
          self.conv_fuse=nn.Conv2d(c1,c1,3,1,1,bias=False)

     def fuse_avg(self):
          self.conv_fuse.weight.data[:]=0
          for i in range(self.conv_fuse.in_channels):
               self.conv_fuse.weight.data[i,i,:,:]=1/(torch.prod(torch.tensor(self.conv_fuse.kernel_size)))
    
     def forward(self, x):
          x = self.avg(x)
          return x
     def forward_fuse(self, x):
          self.fuse_avg()
          return self.conv_fuse(x)


inputs = torch.rand((1,2,3,3))
# 重点 模型调到 eval 模式
model = repconv3x3(2).eval()

out1 = model.forward(inputs)
out2 = model.forward_fuse(inputs)

print("difference:",((out2-out1)**2).sum().item())