DeepLabV3+ 基本原理及Pytorch版注解

1.原理图

在原理图中，整个执行过程如下：
（1）一张图片A，送进改造过后的主流深度卷积网络B（DCNN,加入了一个空洞卷积Atrous Conv）提取特征，得到高级语义特征C和低级语义特征G。

（2）高级语义特征C进入到空洞金字塔池化模块ASPP，分别与四个空洞卷积层和一个池化层进行卷积和池化，得到五个特征图，然后连接成五层D。D再通地一个1*1的卷积进行运算后得到E; E再经过上采样得到F。

（3）通过在深度卷积网络层找到一个与F分辨率相同的低级语义特征图G；经过1*1卷积进行降通道数使之与F所占通道比重一样，更有利于模型学习

（4）合并成H，然后再通过一个3*3细化卷积进行细化；后通过双线性上采样4倍，得到预测结果。

具体细节，请参考下面pytorch版本的源码。

2.pytorch版本的源码

注意的地方：

A.用到的sync_batchnorm.batchnorm比归一化包，pytorch版本的可以在https://github.com/acgtyrant/Synchronized-BatchNorm-PyTorch下载

B.在python2.7中，引用的队列是大写import Queue

import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.model_zoo as model_zoo
from sync_batchnorm.batchnorm import SynchronizedBatchNorm2d

BatchNorm2d = SynchronizedBatchNorm2d
import cv2
import matplotlib.pyplot as plt

class Bottleneck(nn.Module):#'resnet网络的基本框架’
    expansion = 4
    def __init__(self, inplanes, planes, stride=1, dilation=1, downsample=None):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
        self.bn1 = BatchNorm2d(planes)
        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,dilation=dilation, padding=dilation, bias=False)
        self.bn2 = BatchNorm2d(planes)
        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
        self.bn3 = BatchNorm2d(planes * 4)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample
        self.stride = stride
        self.dilation = dilation

    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.relu(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


class ResNet(nn.Module):#renet网络的构成部分
    def __init__(self, nInputChannels, block, layers, os=16, pretrained=False):
        self.inplanes = 64
        super(ResNet, self).__init__()
        if os == 16:
            strides