DAMO-YOLO的Neck（ Efficient RepGFPN）详解

 这个图是有点题目的，在GiraffeNeckV2代码中只有了5个Fusion Block（图中有6个）
https://github.com/tinyvision/DAMO-YOLO/blob/master/damo/base_models/necks/giraffe_fpn_btn.py
代码中只有5个CSPStage
所以我自己画了一个总体图，在github上提了个issue，得到了原作者的肯定
I think the pictures in your paper are not rigorous in several places · Issue #91 · tinyvision/DAMO-YOLO · GitHub

 
想要看懂Neck部分，只必要看懂Fusion Block在做什么就行了，其他部分和PAN差不太多

1. class CSPStage(nn.Module):   
2.     def __init__(self,
3.                  block_fn,
4.                  ch_in,
5.                  ch_hidden_ratio,
6.                  ch_out,
7.                  n,
8.                  act='swish',
9.                  spp=False):
10.         super(CSPStage, self).__init__()
12.         split_ratio = 2
13.         ch_first = int(ch_out // split_ratio)
14.         ch_mid = int(ch_out - ch_first)
15.         self.conv1 = ConvBNAct(ch_in, ch_first, 1, act=act)
16.         self.conv2 = ConvBNAct(ch_in, ch_mid, 1, act=act)
17.         self.convs = nn.Sequential()
19.         next_ch_in = ch_mid
20.         for i in range(n):
21.             if block_fn == 'BasicBlock_3x3_Reverse':
22.                 self.convs.add_module(
23.                     str(i),
24.                     BasicBlock_3x3_Reverse(next_ch_in,
25.                                            ch_hidden_ratio,
26.                                            ch_mid,
27.                                            act=act,
28.                                            shortcut=True))
29.             else:
30.                 raise NotImplementedError
31.             if i == (n - 1) // 2 and spp:
32.                 self.convs.add_module(
33.                     'spp', SPP(ch_mid * 4, ch_mid, 1, [5, 9, 13], act=act))
34.             next_ch_in = ch_mid
35.         self.conv3 = ConvBNAct(ch_mid * n + ch_first, ch_out, 1, act=act)
37.     def forward(self, x):
38.         y1 = self.conv1(x)
39.         y2 = self.conv2(x)
41.         mid_out = [y1]
42.         for conv in self.convs:
43.             y2 = conv(y2)
44.             mid_out.append(y2)
45.         y = torch.cat(mid_out, axis=1)
46.         y = self.conv3(y)
47.         return y

复制代码

以上是CSPStage的代码，要想看懂，我们得先看懂ConvBNAct、BasicBlock_3x3_Reverse这两个类

1. class ConvBNAct(nn.Module):
2.     """A Conv2d -> Batchnorm -> silu/leaky relu block"""
3.     def __init__(
4.         self,
5.         in_channels,
6.         out_channels,
7.         ksize,
8.         stride=1,
9.         groups=1,
10.         bias=False,
11.         act='silu',
12.         norm='bn',
13.         reparam=False,
14.     ):
15.         super().__init__()
16.         # same padding
17.         pad = (ksize - 1) // 2
18.         self.conv = nn.Conv2d(
19.             in_channels,
20.             out_channels,
21.             kernel_size=ksize,
22.             stride=stride,
23.             padding=pad,
24.             groups=groups,
25.             bias=bias,
26.         )
27.         if norm is not None:
28.             self.bn = get_norm(norm, out_channels, inplace=True)
29.         if act is not None:
30.             self.act = get_activation(act, inplace=True)
31.         self.with_norm = norm is not None
32.         self.with_act = act is not None
34.     def forward(self, x):
35.         x = self.conv(x)
36.         if self.with_norm:
37.             x = self.bn(x)
38.         if self.with_act:
39.             x = self.act(x)
40.         return x
42.     def fuseforward(self, x):
43.         return self.act(self.conv(x))

复制代码

ConvBNAct照旧很悦目懂的，Conv +BN + SiLU就完事了（也可用别的激活函数，文章用SiLU）

 假如设置了groups参数就酿成了组卷积了

1. class BasicBlock_3x3_Reverse(nn.Module):
2.     def __init__(self,
3.                  ch_in,
4.                  ch_hidden_ratio,
5.                  ch_out,
6.                  act='relu',
7.                  shortcut=True):
8.         super(BasicBlock_3x3_Reverse, self).__init__()
9.         assert ch_in == ch_out
10.         ch_hidden = int(ch_in * ch_hidden_ratio)
11.         self.conv1 = ConvBNAct(ch_hidden, ch_out, 3, stride=1, act=act)
12.         self.conv2 = RepConv(ch_in, ch_hidden, 3, stride=1, act=act)
13.         self.shortcut = shortcut
15.     def forward(self, x):
16.         y = self.conv2(x)
17.         y = self.conv1(y)
18.         if self.shortcut:
19.             return x + y
20.         else:
21.             return y

复制代码

要看懂BasicBlock_3x3_Reverse这个类，就得了解RepConv类，这个类就是根据RepVGG网络的RepVGGBlock改的

1. class RepConv(nn.Module):
2.     '''RepConv is a basic rep-style block, including training and deploy status
3.     Code is based on https://github.com/DingXiaoH/RepVGG/blob/main/repvgg.py
4.     '''
5.     def __init__(self,
6.                  in_channels,
7.                  out_channels,
8.                  kernel_size=3,
9.                  stride=1,
10.                  padding=1,
11.                  dilation=1,
12.                  groups=1,
13.                  padding_mode='zeros',
14.                  deploy=False,
15.                  act='relu',
16.                  norm=None):
17.         super(RepConv, self).__init__()
18.         self.deploy = deploy
19.         self.groups = groups
20.         self.in_channels = in_channels
21.         self.out_channels = out_channels
23.         assert kernel_size == 3
24.         assert padding == 1
26.         padding_11 = padding - kernel_size // 2
28.         if isinstance(act, str):
29.             self.nonlinearity = get_activation(act)
30.         else:
31.             self.nonlinearity = act
33.         if deploy:
34.             self.rbr_reparam = nn.Conv2d(in_channels=in_channels,
35.                                          out_channels=out_channels,
36.                                          kernel_size=kernel_size,
37.                                          stride=stride,
38.                                          padding=padding,
39.                                          dilation=dilation,
40.                                          groups=groups,
41.                                          bias=True,
42.                                          padding_mode=padding_mode)
44.         else:
45.             self.rbr_identity = None
46.             self.rbr_dense = conv_bn(in_channels=in_channels,
47.                                      out_channels=out_channels,
48.                                      kernel_size=kernel_size,
49.                                      stride=stride,
50.                                      padding=padding,
51.                                      groups=groups)
52.             self.rbr_1x1 = conv_bn(in_channels=in_channels,
53.                                    out_channels=out_channels,
54.                                    kernel_size=1,
55.                                    stride=stride,
56.                                    padding=padding_11,
57.                                    groups=groups)
59.     def forward(self, inputs):
60.         '''Forward process'''
61.         if hasattr(self, 'rbr_reparam'):
62.             return self.nonlinearity(self.rbr_reparam(inputs))
64.         if self.rbr_identity is None:
65.             id_out = 0
66.         else:
67.             id_out = self.rbr_identity(inputs)
69.         return self.nonlinearity(
70.             self.rbr_dense(inputs) + self.rbr_1x1(inputs) + id_out)
72.     def get_equivalent_kernel_bias(self):
73.         kernel3x3, bias3x3 = self._fuse_bn_tensor(self.rbr_dense)
74.         kernel1x1, bias1x1 = self._fuse_bn_tensor(self.rbr_1x1)
75.         kernelid, biasid = self._fuse_bn_tensor(self.rbr_identity)
76.         return kernel3x3 + self._pad_1x1_to_3x3_tensor(
77.             kernel1x1) + kernelid, bias3x3 + bias1x1 + biasid
79.     def _pad_1x1_to_3x3_tensor(self, kernel1x1):
80.         if kernel1x1 is None:
81.             return 0
82.         else:
83.             return torch.nn.functional.pad(kernel1x1, [1, 1, 1, 1])
85.     def _fuse_bn_tensor(self, branch):
86.         if branch is None:
87.             return 0, 0
88.         if isinstance(branch, nn.Sequential):
89.             kernel = branch.conv.weight
90.             running_mean = branch.bn.running_mean
91.             running_var = branch.bn.running_var
92.             gamma = branch.bn.weight
93.             beta = branch.bn.bias
94.             eps = branch.bn.eps
95.         else:
96.             assert isinstance(branch, nn.BatchNorm2d)
97.             if not hasattr(self, 'id_tensor'):
98.                 input_dim = self.in_channels // self.groups
99.                 kernel_value = np.zeros((self.in_channels, input_dim, 3, 3),
100.                                         dtype=np.float32)
101.                 for i in range(self.in_channels):
102.                     kernel_value[i, i % input_dim, 1, 1] = 1
103.                 self.id_tensor = torch.from_numpy(kernel_value).to(
104.                     branch.weight.device)
105.             kernel = self.id_tensor
106.             running_mean = branch.running_mean
107.             running_var = branch.running_var
108.             gamma = branch.weight
109.             beta = branch.bias
110.             eps = branch.eps
111.         std = (running_var + eps).sqrt()
112.         t = (gamma / std).reshape(-1, 1, 1, 1)
113.         return kernel * t, beta - running_mean * gamma / std
115.     def switch_to_deploy(self):
116.         if hasattr(self, 'rbr_reparam'):
117.             return
118.         kernel, bias = self.get_equivalent_kernel_bias()
119.         self.rbr_reparam = nn.Conv2d(
120.             in_channels=self.rbr_dense.conv.in_channels,
121.             out_channels=self.rbr_dense.conv.out_channels,
122.             kernel_size=self.rbr_dense.conv.kernel_size,
123.             stride=self.rbr_dense.conv.stride,
124.             padding=self.rbr_dense.conv.padding,
125.             dilation=self.rbr_dense.conv.dilation,
126.             groups=self.rbr_dense.conv.groups,
127.             bias=True)
128.         self.rbr_reparam.weight.data = kernel
129.         self.rbr_reparam.bias.data = bias
130.         for para in self.parameters():
131.             para.detach_()
132.         self.__delattr__('rbr_dense')
133.         self.__delattr__('rbr_1x1')
134.         if hasattr(self, 'rbr_identity'):
135.             self.__delattr__('rbr_identity')
136.         if hasattr(self, 'id_tensor'):
137.             self.__delattr__('id_tensor')
138.         self.deploy = True

复制代码

 RepConv的特点是布局重参数化，训练时采用三条分支，推理时将三个分支融合在一起，大大淘汰了推理时间（发起看看RepVGG的讲授视频），我图画得太丑了

  RepConv采用的两分支的布局（a）

 其他细节有缘再更，代码不难，渐渐看完万能懂。有写的不对的地方请包涵


来源：https://blog.csdn.net/weixin_43227262/article/details/129368505
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！