深度学习：全卷积网络（FCN）

全卷积网络（fully convolutional network，FCN）采用卷积神经网络实现了从图像像素到像素类别的变换[36]。与之前介绍的卷积神经网络有所不同，全卷积网络通过转置卷积（transposed convolution）层将中间层特征图的高和宽变换回输入图像的尺寸，从而令预测结果与输入图像在空间维（高和宽）上一一对应：给定空间维上的位置，通道维的输出即该位置对应像素的类别预测。

我们先导入实验所需的包或模块，然后解释什么是转置卷积层。

In [1]: %matplotlib inline
        import d2lzh as d2l
        from mxnet import gluon, image, init, nd
        from mxnet.gluon import data as gdata, loss as gloss, model_zoo, nn
        import numpy as np
        import sys

9.10.1　转置卷积层

顾名思义，转置卷积层得名于矩阵的转置操作。事实上，卷积运算还可以通过矩阵乘法来实现。在下面的例子中，我们定义高和宽分别为 4 的输入X，以及高和宽分别为3的卷积核K。打印二维卷积运算的输出以及卷积核。可以看到，输出的高和宽分别为 2。

In [2]: X = nd.arange(1, 17).reshape((1, 1, 4, 4))
        K = nd.arange(1, 10).reshape((1, 1, 3, 3)) 
        conv = nn.Conv2D(channels=1, kernel_size=3) 
        conv.initialize(init.Constant(K))
        conv(X), K

Out[2]: (
         [[[[348. 393.]
            [528. 573.]]]]
         , 
         [[[[1. 2. 3.]
            [4. 5. 6.]
            [7. 8. 9.]]]]
         )

下面我们将卷积核K改写成含有大量零元素的稀疏矩阵W，即权重矩阵。权重矩阵的形状为(4, 16)，其中的非零元素来自卷积核K中的元素。将输入X逐行连结，得到长度为 16 的向量。然后将W与向量化的X做矩阵乘法，得到长度为 4 的向量。对其变形后，我们可以得到和上面卷积运算相同的结果。可见，我们在这个例子中使用矩阵乘法实现了卷积运算。

In [3]: W, k = nd.zeros((4, 16)), nd.zeros(11)
        k[:3], k[4:7], k[8:] = K[0, 0, 0, :], K[0, 0, 1, :], K[0, 0, 2, :]
        W[0, 0:11], W[1, 1:12], W[2, 4:15], W[3, 5:16] = k, k, k, k
        nd.dot(W, X.reshape(16)).reshape((1, 1, 2, 2)), W

Out[3]: (
         [[[[348. 393.]
            [528. 573.]]]]
         ,
         [[1. 2. 3. 0. 4. 5. 6. 0. 7. 8. 9. 0. 0. 0. 0. 0.]
          [0. 1. 2. 3. 0. 4. 5. 6. 0. 7. 8. 9. 0. 0. 0. 0.]
          [0. 0. 0. 0. 1. 2. 3. 0. 4. 5. 6. 0. 7. 8. 9. 0.]
          [0. 0. 0. 0. 0. 1. 2. 3. 0. 4. 5. 6. 0. 7. 8. 9.]]
         )

现在我们从矩阵乘法的角度来描述卷积运算。设输入向量为x，权重矩阵为W，卷积的前向计算函数的实现可以看作将函数输入乘以权重矩阵，并输出向量

。我们知道，反向传播需要依据链式法则。由于 

，卷积的反向传播函数的实现可以看作将函数输入乘以转置后的权重矩阵 

。而转置卷积层正好交换了卷积层的前向计算函数与反向传播函数：这两个函数可以看作将函数输入向量分别乘以 

和W。

不难想象，转置卷积层可以用来交换卷积层输入和输出的形状。让我们继续用矩阵乘法描述卷积。设权重矩阵是形状为 

 的矩阵，对于长度为16的输入向量，卷积前向计算输出长度为4的向量。假如输入向量的长度为4，转置权重矩阵的形状为 

，那么转置卷积层将输出长度为16的向量。在模型设计中，转置卷积层常用于将较小的特征图变换为更大的特征图。在全卷积网络中，当输入是高和宽较小的特征图时，转置卷积层可以用来将高和宽放大到输入图像的尺寸。

我们来看一个例子。构造一个卷积层conv，并设输入X的形状为 （1，3，64，64）。卷积输出Y的通道数增加到10，但高和宽分别缩小了一半。

In [4]: conv = nn.Conv2D(10, kernel_size=4, padding=1, strides=2) 
        conv.initialize()

        X = nd.random.uniform(shape=(1, 3, 64, 64)) 
        Y = conv(X)
        Y.shape

Out[4]: (1, 10, 32, 32)

下面我们通过创建Conv2DTranspose实例来构造转置卷积层conv_trans。这里我们设conv_trans的卷积核形状、填充以及步幅与conv中的相同，并设输出通道数为3。当输入为卷积层conv的输出Y时，转置卷积层输出与卷积层输入的高和宽相同：转置卷积层将特征图的高和宽分别放大了2倍。

In [5]: conv_trans = nn.Conv2DTranspose(3, kernel_size=4, padding=1, strides=2) 
        conv_trans.initialize()
        conv_trans(Y).shape

Out[5]: (1, 3, 64, 64)

在有些文献中，转置卷积也被称为分数步长卷积（fractionally-strided convolution）[12]。

9.10.2　构造模型

我们在这里给出全卷积网络模型最基本的设计。如图9-11所示，全卷积网络先使用卷积神经网络抽取图像特征，然后通过 

 卷积层将通道数变换为类别个数，最后通过转置卷积层将特征图的高和宽变换为输入图像的尺寸。模型输出与输入图像的高和宽相同，并在空间位置上一一对应：最终输出的通道包含了该空间位置像素的类别预测。

图9-11　全卷积网络

下面我们使用一个基于ImageNet数据集预训练的ResNet-18模型来抽取图像特征，并将该网络实例记为pretrained_net。可以看到，该模型成员变量features的最后两层分别是全局最大池化层GlobalAvgPool2D和样本变平层Flatten，而output模块包含了输出用的全连接层。全卷积网络不需要使用这些层。

In [6]: pretrained_net = model_zoo.vision.resnet18_v2(pretrained=True) 
        pretrained_net.features[-4:], pretrained_net.output

Out[6]: (HybridSequential(
           (0): BatchNorm(axis=1, eps=1e-05, momentum=0.9, f ix_gamma=False,
➥  use_global_stats=False, in_channels=512) 
           (1): Activation(relu)
           (2): GlobalAvgPool2D(size=(1, 1), stride=(1, 1), padding=(0, 0),
➥  ceil_mode=True)
           (3): Flatten
         ), Dense(512 -> 1000, linear))

下面我们创建全卷积网络实例net。它复制了pretrained_net实例的成员变量features里除去最后两层的所有层以及预训练得到的模型参数。

In [7]: net = nn.HybridSequential()
        for layer in pretrained_net.features[:-2]: 
            net.add(layer)

给定高和宽分别为320和480的输入，net的前向计算将输入的高和宽减小至原来的1/32，即10和15。

In [8]: X = nd.random.uniform(shape=(1, 3, 320, 480)) 
        net(X).shape

Out[8]: (1, 512, 10, 15)

接下来，我们通过 

 卷积层将输出通道数变换为Pascal VOC2012数据集的类别个数21。最后，我们需要将特征图的高和宽放大32倍，从而变回输入图像的高和宽。回忆一下5.2节中描述的卷积层输出形状的计算方法。由于 

 且 

，我们构造一个步幅为 32 的转置卷积层，并将卷积核的高和宽设为 64、填充设为 16。不难发现，如果步幅为s、填充为s/2（假设s/2为整数）、卷积核的高和宽为2s，转置卷积核将输入的高和宽分别放大s倍。

In [9]: num_classes = 21
        net.add(nn.Conv2D(num_classes, kernel_size=1), 
                nn.Conv2DTranspose(num_classes, kernel_size=64, padding=16,
                                   strides=32))

9.10.3　初始化转置卷积层

我们已经知道，转置卷积层可以放大特征图。在图像处理中，我们有时需要将图像放大，即上采样（upsample）。上采样的方法有很多，常用的有双线性插值。简单来说，为了得到输出图像在坐标 

 上的像素，先将该坐标映射到输入图像的坐标 

，例如，根据输入与输出的尺寸之比来映射。映射后的

和

通常是实数。然后，在输入图像上找到与坐标 

最近的4像素。最后，输出图像在坐标 

 上的像素依据输入图像上这4像素及其与 

的相对距离来计算。双线性插值的上采样可以通过由以下bilinear_kernel函数构造的卷积核的转置卷积层来实现。限于篇幅，我们只给出bilinear_kernel函数的实现，不再讨论算法的原理。

In [10]: def bilinear_kernel(in_channels, out_channels, kernel_size): 
             factor = (kernel_size + 1) // 2
             if kernel_size % 2 == 1: 
                 center = factor - 1
             else:
                 center = factor - 0.5
             og = np.ogrid[:kernel_size, :kernel_size]
             f ilt = (1 - abs(og[0] - center) / factor) * \ 
                    (1 - abs(og[1] - center) / factor)
             weight = np.zeros((in_channels, out_channels, kernel_size, kernel_size), 
                              dtype='f loat32')
             weight[range(in_channels), range(out_channels), :, :] = f ilt
             return nd.array(weight)

我们来实验一下用转置卷积层实现的双线性插值的上采样。构造一个将输入的高和宽放大 2 倍的转置卷积层，并将其卷积核用bilinear_kernel函数初始化。

In [11]: conv_trans = nn.Conv2DTranspose(3, kernel_size=4, padding=1, strides=2) 
         conv_trans.initialize(init.Constant(bilinear_kernel(3, 3, 4)))

读取图像X，将上采样的结果记作Y。为了打印图像，我们需要调整通道维的位置。

In [12]: img = image.imread('../img/catdog.jpg')
         X = img.astype('f loat32').transpose((2, 0, 1)).expand_dims(axis=0) / 255
         Y = conv_trans(X)
         out_img = Y[0].transpose((1, 2, 0))

可以看到，转置卷积层将图像的高和宽分别放大2倍。值得一提的是，除了坐标刻度不同，双线性插值放大的图像和9.3节中打印出的原图看上去没什么两样。

In [13]: d2l.set_f igsize()
         print('input image shape:', img.shape) 
         d2l.plt.imshow(img.asnumpy()); 
         print('output image shape:', out_img.shape) 
         d2l.plt.imshow(out_img.asnumpy());

input image shape: (561, 728, 3)
output image shape: (1122, 1456, 3)

在全卷积网络中，我们将转置卷积层初始化为双线性插值的上采样。对于1 × 1卷积层，我们采用Xavier随机初始化。

In [14]: net[-1].initialize(init.Constant(bilinear_kernel(num_classes, num_classes,
                                                        64)))
         net[-2].initialize(init=init.Xavier())

9.10.4　读取数据集

我们用9.9节介绍的方法读取数据集。这里指定随机裁剪的输出图像的形状为320 × 480：高和宽都可以被 32 整除。

In [15]: crop_size, batch_size, colormap2label = (320, 480), 32, nd.zeros(256**3)
         for i, cm in enumerate(d2l.VOC_COLORMAP): 
             colormap2label[(cm[0] * 256 + cm[1]) * 256 + cm[2]] = i
         voc_dir = d2l.download_voc_pascal(data_dir='../data')

         num_workers = 0 if sys.platform.startswith('win32') else 4
         train_iter = gdata.DataLoader(
             d2l.VOCSegDataset(True, crop_size, voc_dir, colormap2label), batch_size, 
             shuff le=True, last_batch='discard', num_workers=num_workers)
         test_iter = gdata.DataLoader(
             d2l.VOCSegDataset(False, crop_size, voc_dir, colormap2label), batch_size, 
             last_batch='discard', num_workers=num_workers)

read 1114 examples
read 1078 examples

9.10.5　训练模型

现在可以开始训练模型了。这里的损失函数和准确率计算与图像分类中的并没有本质上的不同。因为我们使用转置卷积层的通道来预测像素的类别，所以在SoftmaxCrossEntropyLoss里指定了axis=1（通道维）选项。此外，模型基于每个像素的预测类别是否正确来计算准确率。

In [16]: ctx = d2l.try_all_gpus()
         loss = gloss.SoftmaxCrossEntropyLoss(axis=1) 
         net.collect_params().reset_ctx(ctx)
         trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.1,
                                                            'wd': 1e-3})
         d2l.train(train_iter, test_iter, net, loss, trainer, ctx, num_epochs=5)

training on [gpu(0), gpu(1), gpu(2), gpu(3)]
epoch 1, loss 1.3306, train acc 0.726, test acc 0.811, time 17.5 sec
epoch 2, loss 0.6524, train acc 0.811, test acc 0.820, time 16.6 sec
epoch 3, loss 0.5364, train acc 0.838, test acc 0.812, time 16.3 sec
epoch 4, loss 0.4650, train acc 0.856, test acc 0.842, time 16.5 sec
epoch 5, loss 0.4017, train acc 0.872, test acc 0.851, time 16.3 sec

9.10.6　预测像素类别

在预测时，我们需要将输入图像在各个通道做标准化，并转成卷积神经网络所需要的四维输入格式。

In [17]: def predict(img):
             X = test_iter._dataset.normalize_image(img)
             X = X.transpose((2, 0, 1)).expand_dims(axis=0)
             pred = nd.argmax(net(X.as_in_context(ctx[0])), axis=1)
             return pred.reshape((pred.shape[1], pred.shape[2])) 

为了可视化每个像素的预测类别，我们将预测类别映射回它们在数据集中的标注颜色。

In [18]: def label2image(pred):
             colormap = nd.array(d2l.VOC_COLORMAP, ctx=ctx[0], dtype='uint8')
             X = pred.astype('int32')
             return colormap[X, :]

测试数据集中的图像大小和形状各异。由于模型使用了步幅为32的转置卷积层，当输入图像的高或宽无法被32整除时，转置卷积层输出的高或宽会与输入图像的尺寸有偏差。为了解决这个问题，我们可以在图像中截取多块高和宽为32的整数倍的矩形区域，并分别对这些区域中的像素做前向计算。这些区域的并集需要完整覆盖输入图像。当一个像素被多个区域所覆盖时，它在不同区域前向计算中转置卷积层输出的平均值可以作为 softmax 运算的输入，从而预测类别。

简单起见，我们只读取几张较大的测试图像，并从图像的左上角开始截取形状为 320 × 480的区域：只有该区域用于预测。对于输入图像，我们先打印截取的区域，再打印预测结果，最后打印标注的类别（另见彩插图20）。

In [19]: test_images, test_labels = d2l.read_voc_images(is_train=False) 
         n, imgs = 4, []
         for i in range(n):
             crop_rect = (0, 0, 480, 320)
             X = image.f ixed_crop(test_images[i], *crop_rect) 
             pred = label2image(predict(X))
             imgs += [X, pred, image.f ixed_crop(test_labels[i], *crop_rect)] 
         d2l.show_images(imgs[::3] + imgs[1::3] + imgs[2::3], 3, n);

小结

可以通过矩阵乘法来实现卷积运算。

全卷积网络先使用卷积神经网络抽取图像特征，然后通过1 × 1卷积层将通道数变换为类别个数，最后通过转置卷积层将特征图的高和宽变换为输入图像的尺寸，从而输出每个像素的类别。

在全卷积网络中，可以将转置卷积层初始化为双线性插值的上采样。

本文摘自《动手学深度学习》

本书旨在向读者交付有关深度学习的交互式学习体验。书中不仅阐述深度学习的算法原理，还演示它们的实现和运行。与传统图书不同，本书的每一节都是一个可以下载并运行的 Jupyter记事本，它将文字、公式、图像、代码和运行结果结合在了一起。此外，读者还可以访问并参与书中内容的讨论。 

全书的内容分为3个部分：第一部分介绍深度学习的背景，提供预备知识，并包括深度学习基础的概念和技术；第二部分描述深度学习计算的重要组成部分，还解释近年来令深度学习在多个领域大获成功的卷积神经网络和循环神经网络；第三部分评价优化算法，检验影响深度学习计算性能的重要因素，并分别列举深度学习在计算机视觉和自然语言处理中的重要应用。 

本书同时覆盖深度学习的方法和实践，主要面向在校大学生、技术人员和研究人员。阅读本书需要读者了解基本的Python编程或附录中描述的线性代数、微分和概率基础。