FCN前向传播代码实现（百度飞浆图像分割）

定义：训练过程分为5个部分：输入（本文内容），前向，计算损失，反向，更新权重。

代码大概两个部分：定义FCN8s类，主函数。

FCN8S:

下采样：FCN8s基于VGG提取特征，然后使用1*1卷积改变通道数，dropout()得到一个（1，,4069，,16，,16）的tensor。

上采样：

1将16*16通道数改为类别数，再次对它进行上采样两倍得到map1（32*32），将下采样中pool4后的feature map相加得到map2（64*64）。

2对map2上采样两倍得到map3（128*128），将下采样中pool3后的feature相加的到map4(256*256)。

3将map4上采样得到map5（512*512），即原图大小。

主函数：

定义一个随机的四维数组模拟图像

然后放入模型

最后输出结果类型

import numpy as np
import paddle.fluid as fluid
from paddle.fluid.dygraph import to_variable
from paddle.fluid.dygraph import Conv2D
from paddle.fluid.dygraph import Conv2DTranspose
from paddle.fluid.dygraph import Dropout
from paddle.fluid.dygraph import BatchNorm
from paddle.fluid.dygraph import Pool2D
from paddle.fluid.dygraph import Linear
from vgg import VGG16BN

# create fcn8s model
class FCN8s(fluid.dygraph.Layer):
    def __init__( self, num_classes=59):
        super(FCN8s, self).__init__()
        backbone = VGG16BN(pretrained=False)

        self.layer1 = backbone.layer1
        self.layer1[0].conv._padding = [100, 100]
        self.pool1 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)
        self.layer2 = backbone.layer2
        self.pool2 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)
        self.layer3 = backbone.layer3
        self.pool3 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)
        self.layer4 = backbone.layer4
        self.pool4 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)
        self.layer5 = backbone.layer5
        self.pool5 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True)

        self.fc6 = Conv2D(512, 4096, 7, act='relu')
        self.fc7 = Conv2D(4096, 4096, 1, act='relu')
        self.drop6 = Dropout()
        self.drop7 = Dropout()

        self.score = Conv2D(4096, num_classes, 1)
        self.score_pool3 = Conv2D(256, num_classes, 1)
        self.score_pool4 = Conv2D(512, num_classes, 1)

        self.up_output = Conv2DTranspose(num_channels=num_classes,
                                         num_filters=num_classes,
                                         filter_size=4,
                                         stride=2,
                                         bias_attr=False)
        
        self.up_pool4 = Conv2DTranspose(num_channels=num_classes,
                                         num_filters=num_classes,
                                         filter_size=4,
                                         stride=2,
                                         bias_attr=False)
        
        self.up_final = Conv2DTranspose(num_channels=num_classes,
                                         num_filters=num_classes,
                                         filter_size=16,
                                         stride=8,
                                         bias_attr=False)
    
    def forward(self, inputs):
        x = self.layer1(inputs)#(2,3,512,512)
        x = self.pool1(x) # 1/2
        print(x)
        x = self.layer2(x)
        x = self.pool2(x) # 1/4
        x = self.layer3(x)
        x = self.pool3(x) # 1/8
        pool3 = x
        x = self.layer4(x)
        x = self.pool4(x) # 1/16
        pool4 = x
        x = self.layer5(x)
        x = self.pool5(x) # 1/32
        print(x.shape)

        x = self.fc6(x)
        x = self.drop6(x)
        x = self.fc7(x)
        x = self.drop7(x)
        print(x.shape)

        x = self.score(x)
        x = self.up_output(x)
        print(x.shape)

        up_output = x # 1/16
        x = self.score_pool4(pool4)

        x = x[:, :, 5:5+up_output.shape[2], 5:5+up_output.shape[3]]

        up_pool4 = x
        x = up_pool4 + up_output
        x = self.up_pool4(x)
        up_pool4 = x
        x = self.score_pool3(pool3)
        x = x[:, :, 9:9+up_pool4.shape[2], 9:9+up_pool4.shape[3]]
        up_pool3 = x # 1/8

        x = up_pool3 + up_pool4
        x = self.up_final(x)
        x = x[:, :, 31:31+inputs.shape[2], 31:31+inputs.shape[3]]

        return x


def main():
    with fluid.dygraph.guard():
        x_data = np.random.rand(2, 3, 512, 512).astype(np.float32)
        x = to_variable(x_data)
        model = FCN8s(num_classes=59)
        model.eval()
        pred = model(x)
        print(pred.shape)


if __name__ == '__main__':
    main()