图像语义分割 -- FCN

一：图像语义分割
最简答理解图像语义分割呢就是看下面的图片例子：
像素级别的分类：

假如像素有五个类别，那么最后输出的结果在长度和宽度上是一样的，只不过通道数就是类别个数了。拆解开各个通道就是如下所示：

合并后就是各个像素的类别信息了，一般情况下会不同的颜色来表示各个类别，这样我们就能更加清晰看出来哪些像素是什么类别了，这也是一个监督学习的例子。

二：FCN
由于自己太懒了，关于FCN的概念和介绍请自己自行百度哈。推荐下面链接
https://zhuanlan.zhihu.com/p/31428783
https://www.pianshen.com/article/1189524224/
太多重复的我就不写了，请直接看上面的链接咯，会的就直接跳过忽略，总体来说，
CNN是用来做图像分类的，是图像级别的，较浅的卷积层感知域较小，学习到一些局部区域的特征，较深的卷积层具有较大的感知域，能够学习到更加抽象一些的特征。
但是由于CNN在进行convolution和pooling过程中丢失了图像细节，即feature map size逐渐变小，所以不能很好地指出物体的具体轮廓、指出每个像素具体属于哪个物体，无法做到精确的分割。
FCN是把CNN最后的FC层全部改成了卷积层，这样就会得到2维的输出，能对应到原始图像每一个像素的类别，后接softmax获得每个像素点的分类信息，从而解决了分割问题。

三：FCN的结构
如下所示：

简单描述下其结构：
1：image经过多个conv和加一个max pooling变为pool1 feature，宽高变为1/2。
2：pool1 feature再经过多个conv家加一个max pooling变为pool2 feature，宽高变为1/4。
3：pool2 feature再经过多个conv加一个max pooling变为pool3 feature，宽高变为1/8。
4：pool3 feature再经过多个conv加一个max pooling变为pool4 feature，宽高变为1/16。
5：pool4 feature再经过多个conv加一个max pooling变为pool5 feature，宽高变为1/32。

这里是得到了五个特征feature，这个是不是很熟悉啊？
我们才学过的那个VGG不就是这么个结构么？除了我们上篇文章学习的VGG16，还有其他VGG结构，我们等下都会涉及到。

但是这里只是特征提取阶段，我们下一步得进行特征融合等操作，这个才是FCN的重头啊。
1：对于FCN-32，直接将最后的输出通过反卷积扩大32倍。
2：对于FCN-16，先把pool5反卷积扩大2倍，再和pool相加，最后通过反卷积扩大16倍。
3：对于FCN-8，先把pool5反卷积扩大2倍，再和pool相加，得到的值扩大2倍，再和pool3相加，最后通过反卷积扩大8倍。

四：代码实现

复用了VGG的结构。
VGG有VGG11，VGG13，VGG16和VGG19，后两者是最常用的结构，他们的特点就是
前面特征提取层都是五层结构，最后公用两个FC层，在FCN中会把这里卷积改成卷积。
输入时数据是[batch, 3, W, H]。五层分别会得到[batch, 64, W, H]，[batch, 128, W, H]，[batch, 256, W, H]，[batch, 512, W, H]，[batch, 512, W, H]。
至于VGG11，VGG13，VGG16和VGG19的结构呢，可以代码查看下

import torch
import torchvision

# Press the green button in the gutter to run the script.
if __name__ == '__main__':
    net = torchvision.models.vgg11(pretrained=True)   # 从预训练模型加载VGG11网络参数
    print(net)

    net = torchvision.models.vgg13(pretrained=True)   # 从预训练模型加载VGG13网络参数
    print(net)

    net = torchvision.models.vgg16(pretrained=True)   # 从预训练模型加载VGG16网络参数
    print(net)

    net = torchvision.models.vgg19(pretrained=True)   # 从预训练模型加载VGG19网络参数
    print(net)

为了减少数据量的计算，在反卷积的之前会先进行降维的操作，详细见代码。

完整代码如下：

from torch import nn
import torch
import torchvision

# ranges 是用于方便获取和记录每个池化层得到的特征图
# 各个vgg原始定义的特征输出的层数
ranges = {
    'vgg11': ((0, 3), (3, 6), (6, 11), (11, 16), (16, 21)),
    'vgg13': ((0, 5), (5, 10), (10, 15), (15, 20), (20, 25)),
    'vgg16': ((0, 5), (5, 10), (10, 17), (17, 24), (24, 31)),
    'vgg19': ((0, 5), (5, 10), (10, 19), (19, 28), (28, 37))
}


class VGGTest(nn.Module):
    def __init__(self, vgg='vgg16'):  # num_classes，此处为 二分类值为2
        super(VGGTest, self).__init__()
        net = {}
        if vgg == 'vgg11':
            net = torchvision.models.vgg11(pretrained=True)  # 从预训练模型加载VGG11网络参数
        elif vgg == 'vgg13':
            net = torchvision.models.vgg13(pretrained=True)  # 从预训练模型加载VGG13网络参数
        elif vgg == 'vgg16':
            net = torchvision.models.vgg16(pretrained=True)  # 从预训练模型加载VGG16网络参数
        elif vgg == 'vgg19':
            net = torchvision.models.vgg19(pretrained=True)  # 从预训练模型加载VGG19网络参数

        self.pool1 = net.features[ranges[vgg][0][0]: ranges[vgg][0][1]]  # [batch, 64, W, H]
        self.pool2 = net.features[ranges[vgg][1][0]: ranges[vgg][1][1]]  # [batch, 128,W, H]
        self.pool3 = net.features[ranges[vgg][2][0]: ranges[vgg][2][1]]  # [batch, 256,W, H]
        self.pool4 = net.features[ranges[vgg][3][0]: ranges[vgg][3][1]]  # [batch, 512,W, H]
        self.pool5 = net.features[ranges[vgg][4][0]: ranges[vgg][4][1]]  # [batch, 512,W, H]

    def forward(self, x):
        pool1_features = self.pool1(x)  # 1/2
        pool2_features = self.pool2(pool1_features)  # 1/4
        pool3_features = self.pool3(pool2_features)  # 1/8
        pool4_features = self.pool4(pool3_features)  # 1/16
        pool5_features = self.pool5(pool4_features)  # 1/32

        return pool1_features, pool2_features, pool3_features, pool4_features, pool5_features


class FCN32s(nn.Module):
    def __init__(self, vgg='vgg16', num_classes=21):  # num_classes，最后的通道数。也是像素分类的个数。
        super(FCN32s, self).__init__()

        # 掐年5个提取特征层
        self.net_features = VGGTest(vgg)

        # 最后俩个那个FC层，被改造成两个Conv层
        self.FC_Layers = nn.Sequential(
            # fc6
            nn.Conv2d(512, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d(),

            # fc7
            nn.Conv2d(4096, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d()
        )

        # 输出层之前，先降维一下。
        self.score_pool5 = nn.Conv2d(4096, num_classes, 1)
        # 最后把降维后的数据进行反卷积（上采样）
        self.final_x32 = nn.ConvTranspose2d(num_classes, num_classes, 32, stride=32, bias=False)

    def forward(self, x):
        # 得到5个特征
        features = self.net_features(x)

        # 最后一个特征图还要进行FC操作
        last_features = self.FC_Layers(features[-1])

        # 先降行通道降维，减少运算量，再上采样（反卷积法）
        pool5 = self.score_pool5(last_features)

        out = self.final_x32(pool5)
        return out


class FCN16s(nn.Module):
    def __init__(self, vgg='vgg16', num_classes=21):  # num_classes，此处为 二分类值为2
        super(FCN16s, self).__init__()

        # 掐年5个提取特征层
        self.net_features = VGGTest(vgg)

        # 最后俩个那个FC层，被改造成两个Conv层
        self.FC_Layers = nn.Sequential(
            # fc6
            nn.Conv2d(512, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d(),

            # fc7
            nn.Conv2d(4096, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d()
        )

        # 输出层之前，先降维一下。
        self.score_pool5 = nn.Conv2d(4096, num_classes, 1)
        self.score_pool4 = nn.Conv2d(512, num_classes, 1)
        # 最后把降维后的数据进行反卷积（上采样）
        self.upscore_pool5_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.final_x16 = nn.ConvTranspose2d(num_classes, num_classes, 16, stride=16, bias=False)

    def forward(self, x):
        # 得到5个特征
        features = self.net_features(x)

        # 最后一个特征图还要进行FC操作
        last_features = self.FC_Layers(features[-1])

        # 先降行通道降维，减少运算量，再上采样（反卷积法）
        pool5 = self.score_pool5(last_features)
        pool4 = self.score_pool4(features[-2])

        out = pool4 + self.upscore_pool5_x2(pool5)

        out = self.final_x16(out)
        return out


class FCN8s(nn.Module):
    def __init__(self, vgg='vgg16', num_classes=21):  # num_classes，此处为 二分类值为2
        super(FCN8s, self).__init__()

        # 掐年5个提取特征层
        self.net_features = VGGTest(vgg)

        # 最后俩个那个FC层，被改造成两个Conv层
        self.FC_Layers = nn.Sequential(
            # fc6
            nn.Conv2d(512, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d(),

            # fc7
            nn.Conv2d(4096, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d()
        )

        # 输出层之前，先降维一下。
        self.score_pool5 = nn.Conv2d(4096, num_classes, 1)
        self.score_pool4 = nn.Conv2d(512, num_classes, 1)
        self.score_pool3 = nn.Conv2d(256, num_classes, 1)
        # 最后把降维后的数据进行反卷积（上采样）
        self.upscore_pool5_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.upscore_pool4_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.final_x8 = nn.ConvTranspose2d(num_classes, num_classes, 8, stride=8, bias=False)

    def forward(self, x):
        # 得到5个特征
        features = self.net_features(x)

        # 最后一个特征图还要进行FC操作
        last_features = self.FC_Layers(features[-1])

        # 先行通道降维，减少运算量，再上采样（反卷积法）
        pool5 = self.score_pool5(last_features)
        pool4 = self.score_pool4(features[-2])
        pool3 = self.score_pool3(features[-3])

        out = pool4 + self.upscore_pool5_x2(pool5)
        out = pool3 + self.upscore_pool4_x2(out)

        out = self.final_x8(out)
        return out


class FCN4s(nn.Module):
    def __init__(self, vgg='vgg16', num_classes=21):  # num_classes，此处为 二分类值为2
        super(FCN4s, self).__init__()

        # 掐年5个提取特征层
        self.net_features = VGGTest(vgg)

        # 最后俩个那个FC层，被改造成两个Conv层
        self.FC_Layers = nn.Sequential(
            # fc6
            nn.Conv2d(512, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d(),

            # fc7
            nn.Conv2d(4096, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d()
        )

        # 输出层之前，先降维一下。
        self.score_pool5 = nn.Conv2d(4096, num_classes, 1)
        self.score_pool4 = nn.Conv2d(512, num_classes, 1)
        self.score_pool3 = nn.Conv2d(256, num_classes, 1)
        self.score_pool2 = nn.Conv2d(128, num_classes, 1)
        # 最后把降维后的数据进行反卷积（上采样）
        self.upscore_pool5_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.upscore_pool4_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.upscore_pool3_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.final_x4 = nn.ConvTranspose2d(num_classes, num_classes, 4, stride=4, bias=False)

    def forward(self, x):
        # 得到5个特征
        features = self.net_features(x)

        # 最后一个特征图还要进行FC操作
        last_features = self.FC_Layers(features[-1])

        # 先行通道降维，减少运算量，再上采样（反卷积法）
        pool5 = self.score_pool5(last_features)
        pool4 = self.score_pool4(features[-2])
        pool3 = self.score_pool3(features[-3])
        pool2 = self.score_pool2(features[-4])

        out = pool4 + self.upscore_pool5_x2(pool5)
        out = pool3 + self.upscore_pool4_x2(out)
        out = pool2 + self.upscore_pool3_x2(out)

        out = self.final_x4(out)
        return out


class FCN2s(nn.Module):
    def __init__(self, vgg='vgg16', num_classes=21):  # num_classes，此处为 二分类值为2
        super(FCN2s, self).__init__()

        # 掐年5个提取特征层
        self.net_features = VGGTest(vgg)

        # 最后俩个那个FC层，被改造成两个Conv层
        self.FC_Layers = nn.Sequential(
            # fc6
            nn.Conv2d(512, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d(),

            # fc7
            nn.Conv2d(4096, 4096, 1),
            nn.ReLU(inplace=True),
            nn.Dropout2d()
        )

        # 输出层之前，先降维一下。
        self.score_pool5 = nn.Conv2d(4096, num_classes, 1)
        self.score_pool4 = nn.Conv2d(512, num_classes, 1)
        self.score_pool3 = nn.Conv2d(256, num_classes, 1)
        self.score_pool2 = nn.Conv2d(128, num_classes, 1)
        self.score_pool1 = nn.Conv2d(64, num_classes, 1)
        # 最后把降维后的数据进行反卷积（上采样）
        self.upscore_pool5_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.upscore_pool4_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.upscore_pool3_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.upscore_pool2_x2 = nn.Sequential(
            nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False),
            nn.ReLU(inplace=True)
        )
        self.final_x2 = nn.ConvTranspose2d(num_classes, num_classes, 2, stride=2, bias=False)

    def forward(self, x):
        # 得到5个特征
        features = self.net_features(x)

        # 最后一个特征图还要进行FC操作
        last_features = self.FC_Layers(features[-1])

        # 先进行通道降维，减少运算量，再上采样（反卷积法）
        pool5 = self.score_pool5(last_features)
        pool4 = self.score_pool4(features[-2])
        pool3 = self.score_pool3(features[-3])
        pool2 = self.score_pool2(features[-4])
        pool1 = self.score_pool1(features[-5])

        out = pool4 + self.upscore_pool5_x2(pool5)
        out = pool3 + self.upscore_pool4_x2(out)
        out = pool2 + self.upscore_pool3_x2(out)
        out = pool1 + self.upscore_pool2_x2(out)

        out = self.final_x2(out)
        return out


if __name__ == '__main__':
    # model = VGGTest()
    x = torch.rand(64, 3, 224, 224)
    print(x.shape)
    num_classes = 21  # 假设最后像素的类别是num_classes，那么通道数就是num_classes

    # model = FCN32s()
    # model = FCN16s()
    # model = FCN8s()
    # model = FCN4s()
    model = FCN2s(num_classes=num_classes)
    y = model(x)
    print(y.shape)