• RetinaNet pytorch implement from scratch 01--Backbone


    懒,就直接用Resnet50了
    先写个残差块

    class Bottleneck(nn.Module):
    
        expansion = 4
    
        def __init__(self, inplanes, planes, stride=1, downsample=None):
            super(Bottleneck, self).__init__()
            #1*1
            self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
            self.bn1 = nn.BatchNorm2d(planes)
            #3*3
            self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
            self.bn2 = nn.BatchNorm2d(planes)
    
            # channels*4
            self.conv3 = nn.Conv2d(planes, planes*4, kernel_size=1, bias=False)
            self.bn3 = nn.BatchNorm2d(planes*4)
            self.relu = nn.ReLU(inplace=True)
    
            self.downsample = downsample
            self.stride = stride
    
        # 前向
        def forward(self, x):
            residual = x
    
            out = self.conv1(x)
            out = self.bn1(out)
            out = self.relu(out)
            out = self.conv2(out)
            out = self.bn2(out)
            out = self.conv3(out)
            out = self.bn3(out)
    
            if self.downsample is not None:
                residual = self.downsample(x)
            
            out += residual
            out = self.relu(out)
    
            return out
    

    整个网络,输出C2~C5特征层

    class ResNet(nn.Module):
        def __init__(self, num_classes, block, layers):
            self.inplanes = 64
            super(ResNet, self).__init__()
            # 7*7
            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)
            # 3*3
            self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
            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)
    
            # 初始化权重
            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_()
        
        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 = [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)
    
        def freeze_bn(self):
            '''Freeze BatchNorm layers.'''
            for layer in self.modules():
                if isinstance(layer, nn.BatchNorm2d):
                    layer.eval()
                    
        def forward(self, x):
            x = self.conv1(x)
            x = self.bn1(x)
            x = self.relu(x)
            x = self.maxpool(x)
    
            # 特征提取C2~C5
            x1 = self.layer1(x)
            x2 = self.layer2(x1)
            x3 = self.layer3(x2)
            x4 = self.layer4(x3)
    
            return x2, x3, x4
    

    实例化

    def resnet50(num_classes, pretrained=False, **kwargs):
        model = ResNet(num_classes, Bottleneck, [3, 4, 6, 3], **kwargs)
        if pretrained:
            model.load_state_dict(torch.load(path), strict=False)
        return model
    
  • 相关阅读:
    时空上下文视觉跟踪(STC)算法的解读与代码复现(转)
    神经网络:卷积神经网络(转)
    图像卷积与滤波的一些知识点(转)
    Deep Learning论文笔记之(四)CNN卷积神经网络推导和实现(转)
    深度学习(卷积神经网络)一些问题总结(转)
    卷积神经网络的初步理解LeNet-5(转)
    中期总结
    转载:通俗理解遗传算法
    转载:协方差与协方差矩阵
    装载:关于拉格朗日乘子法与KKT条件
  • 原文地址:https://www.cnblogs.com/Valeyw/p/15019655.html
Copyright © 2020-2023  润新知