Faster-RCNN网络实现目标检测----pytorch

pytorch框架实现faster-RCNN网络

Faster RCNN网络pytorch框架和Keras框架代码对比

https://blog.csdn.net/weixin_44791964/article/details/105739918
代码来自：
https://github.com/bubbliiiing/faster-rcnn-pytorch

Keras是高度封装起来的框架，用起来就是调用各部分的模块。因此Keras适合于学习，需习模型的整体结构。
本文记一篇学习笔记，把Keras框架和Pytorch框架的代码对比吗，完成Faster-RCNN网络

1 faster-RCNN网络概述

Faster-RCNN是一种two-stage的目标检测方法，（与one-stage方法相比two-stage的目标检测方法检测精度高，但是速度较慢）

Faster-RCNN网络对输入的图片大小没有限制，首相将输入的图片resize 成短边为600，按照原图像的比例进行缩放。缩放后的图片经过backbone进行特征提取得到共享特征层。例如特征层大小为38×38，可以看做将原图像划分成38×38的网格。然后利用RPN（区域建议网络）对先验框进行调整，得到建议框。
其中先验框是指事先在大型数据集上标注好的框。
得到建议框的过程可以看做是对框的粗略筛选。然后利用建议框在共享特征层上进行截取，得到局部特征层。
将局部特征层输入到ROI_Pooling中，首先将特征层resize成相同的大小，然后进行分类预测(cls_pred)和回归预测(bbox_pred)，得到目标检测的结果。

---

2 主干特征提取网络（backbone ResNet_50）

pytorch 中的torch.nn.Conv2d()函数
https://blog.csdn.net/qq_34243930/article/details/107231539?%3E

pytorch官网

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1,groups=1, bias=True)

参数：
in_channels:输入图像的通道数
out_channels:输出图像的通道数
kernel_size:卷积核的大小，参数的类型可以使一个整数(int),或者一个元组（tuple），卷积核可以宽 高不相等
stride=1:卷积的步长，默认为1
padding=0:填充方式
dilation=1:空洞卷积，扩张操作
groups=1:分组卷积，默认不分组
bias=True:在输出中添加一个可学习的偏差，默认为True

空洞卷积https://blog.csdn.net/qq_34243930/article/details/107231539?%3E

主干特征提取网络使用的是ResNet_50
该网络可以看做是Conv_block和Identity_block的堆叠。
特征提取网络的代码如下：

class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, inplanes, planes, stride=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, stride=stride, bias=False) # change
        self.bn1 = nn.BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, # change
                    padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * 4)
        self.relu = nn.ReLU(inplace=True)
        # downsample表示残差边
        self.downsample = downsample
        self.stride = stride

首先第一部分class Bottleneck定义了瓶颈结构，包括三个卷积部分：1×1卷积减少通道数，3×3卷积进行特征提取，1×1卷积再将通道数增加。
downsample表示残差边，由于Identity_block和Conv_block的区别在于残差边上是否有卷积核归一化的操作。

然后forward函数调用各个网络层

    def forward(self, x):
        residual = x
        # 1×1卷积
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        # 3×3卷积
        out = self.conv2(out)
        out = self.bn2(out)
        out = self.relu(out)
        # 1×1卷积
        out = self.conv3(out)
        out = self.bn3(out)
		# 判断是有有残差边，Conv_block有残差边，identity_block没有残差边
        if self.downsample is not None:
            residual = self.downsample(x)

        out += residual
        out = self.relu(out)

        return out

函数make_layer是将卷积层堆叠起来。

    def _make_layer(self, block, planes, blocks, stride=1):
        # 残差边
        downsample = None
        if stride != 1 or self.inplanes != planes * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.inplanes, planes * block.expansion,
                    kernel_size=1, stride=stride, bias=False),
            nn.BatchNorm2d(planes * block.expansion),
        )

        layers = []
        layers.append(block(self.inplanes, planes, stride, downsample))
        self.inplanes = planes * block.expansion
        for i in range(1, blocks):
            layers.append(block(self.inplanes, planes))

        return nn.Sequential(*layers)

这里，利用循环将conv_block和identity_block堆叠起来。blocks堆叠的数量
在最外层的函数resnet50里面定义，blocks=[3, 4, 6, 3]，在resnet网络中分别有3层、4层、6层、3层卷积堆叠

def resnet50():
    # 第二个参数为block存放的是堆叠的conv_block和identity_block的个数
    model = ResNet(Bottleneck, [3, 4, 6, 3])
    # 获取特征提取部分
    # 将主干特征提取网络结果分割开
    features = list([model.conv1, model.bn1, model.relu, model.maxpool, model.layer1, model.layer2, model.layer3])
    # 获取分类部分
    classifier = list([model.layer4, model.avgpool])
    features = nn.Sequential(*features)
    classifier = nn.Sequential(*classifier)
    return features,classifier

每一层堆叠的卷积输入通道数和输出通道数是不同的：

class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes=1000):
        self.inplanes = 64
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
                    bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, ceil_mode=True) # change
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
        
        self.avgpool = nn.AvgPool2d(7)
        self.fc = nn.Linear(512 * block.expansion, num_classes)

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()

Keras框架搭建ResNet_50:

def identity_block(input_tensor, kernel_size, filters, stage, block):

    filters1, filters2, filters3 = filters

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'

    x = Conv2D(filters1, (1, 1), name=conv_name_base + '2a')(input_tensor)
    x = BatchNormalization(name=bn_name_base + '2a')(x)
    x = Activation('relu')(x)

    x = Conv2D(filters2