CenterNet网络模型代码_2-resnet_dcn.py

Bertha 。 2022-12-23 03:26 225阅读 0赞

#### 本文件其实和msra\_resnet.py类似，[进入博文][Link 1]，这里只把两者的不同说下，不同的部分有以下几处，总体感觉作者在这里添加DCN模块很牵强（仅个人吐槽），其实就是把ResNet的输出先经过可变形卷积，然后再经过反卷积，这样迭代了三次，最终得到分类和回归的特征图，通道个数为64，没有用到类似于FPN的特征图融合。加入可变形卷积，可能对反卷积有帮助吧： ####

# 反卷积操作的通道不同
    # used for deconv layers
            self.deconv_layers = self._make_deconv_layer(
                3,
                [256, 128, 64],
                [4, 4, 4],
            )
            # 网络的头部设置不同
            for head in self.heads:
                classes = self.heads[head]# 获取头部操作
                if head_conv > 0:# head_conv=64
                # 经过一个 3*3卷积 然后经过 1*1卷积进行调整维度
                    fc = nn.Sequential(
                      nn.Conv2d(64, head_conv,
                        kernel_size=3, padding=1, bias=True),
                      nn.ReLU(inplace=True),
                      nn.Conv2d(head_conv, classes, 
                        kernel_size=1, stride=1, 
                        padding=0, bias=True))
                    if 'hm' in head:# 热图部分偏置置为-2.19
                        fc[-1].bias.data.fill_(-2.19)
                    else:
                        fill_fc_weights(fc)
                else:
                    fc = nn.Conv2d(64, classes, 
                      kernel_size=1, stride=1, 
                      padding=0, bias=True)
                    if 'hm' in head:
                        fc.bias.data.fill_(-2.19)
                    else:
                        fill_fc_weights(fc)
                self.__setattr__(head, fc)

# 反卷积层的设置的时候，在该函数中相当于在反卷积操作前，设置了 一层可变形卷积
    def _make_deconv_layer(self, num_layers, num_filters, num_kernels):
            assert num_layers == len(num_filters), \
                'ERROR: num_deconv_layers is different len(num_deconv_filters)'
            assert num_layers == len(num_kernels), \
                'ERROR: num_deconv_layers is different len(num_deconv_filters)'
            layers = []
            for i in range(num_layers):
                kernel, padding, output_padding = \
                    self._get_deconv_cfg(num_kernels[i], i)
    
                planes = num_filters[i]# 256，128，64
                # 使用可变形卷积 V2 
                #256 2048*3*3 ,128 256*3*3, 64 128*3*3
                # 可变形模块初始化 权重 和 偏置 均置为 0 
                # 其实可以直接用 fill_fc_weights 初始化。
                fc = DCN(self.inplanes, planes, 
                        kernel_size=(3,3), stride=1,
                        padding=1, dilation=1, deformable_groups=1)
                # fc = nn.Conv2d(self.inplanes, planes,
                # kernel_size=3, stride=1, 
                # padding=1, dilation=1, bias=False)
                # fill_fc_weights(fc)
                # 反卷积
                up = nn.ConvTranspose2d(
                        in_channels=planes,
                        out_channels=planes,
                        kernel_size=kernel,
                        stride=2,
                        padding=padding,
                        output_padding=output_padding,
                        bias=self.deconv_with_bias)
                fill_up_weights(up)
    
                layers.append(fc)
                layers.append(nn.BatchNorm2d(planes, momentum=BN_MOMENTUM))
                layers.append(nn.ReLU(inplace=True))
                layers.append(up)
                layers.append(nn.BatchNorm2d(planes, momentum=BN_MOMENTUM))
                layers.append(nn.ReLU(inplace=True))
                self.inplanes = planes
    
            return nn.Sequential(*layers)

另外 添加了两个初始化函数

# 初始化 上采样层
    def fill_up_weights(up):
        w = up.weight.data
        f = math.ceil(w.size(2) / 2)
        c = (2 * f - 1 - f % 2) / (2. * f)
        for i in range(w.size(2)):
            for j in range(w.size(3)):
                w[0, 0, i, j] = \
                    (1 - math.fabs(i / f - c)) * (1 - math.fabs(j / f - c))
        for c in range(1, w.size(0)):
            w[c, 0, :, :] = w[0, 0, :, :] 
    # 初始化卷积参数 其实用 kaiming xavier 两种初始化 应该是更好的
    def fill_fc_weights(layers):
        for m in layers.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.normal_(m.weight, std=0.001)
                # torch.nn.init.kaiming_normal_(m.weight.data, nonlinearity='relu')
                # torch.nn.init.xavier_normal_(m.weight.data)
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)

其实，原生的 msra\_resnet 换为 resnet\_dcn 并没有好的提升，更像是作者强行添加的， 当然也可能是我的数据集的原因。

[Link 1]: https://blog.csdn.net/qq_29750461/article/details/109889904