ERFNet：用于实时语义分割的高效残差分解卷积神经网络

基于ERFNet实现第17届全国大学生智能汽车竞赛完全模型组线上资格赛

AI Studio

4005人浏览 · 2022-01-31 13:09:35

AI Studio · 2022-01-31 13:09:35 发布

用于实时语义分割的高效残差分解卷积神经网络

语义分割是一项具有挑战性的任务，它以统一的方式解决智能车辆的大部分感知需求。深度神经网络擅长这项任务，因为它们可以进行端到端训练，以在像素级别准确分类图像中的多个对象类别。然而，在最先进的语义分割方法中还没有在高质量和计算资源之间进行良好的权衡，这限制了它们在实际车辆中的应用。而ERFNet是一种深度架构，该架构能够实时运行的同时提供准确的语义分割。

参考资料：

一、数据集简介

本项目使用的是第17届全国大学生智能汽车竞赛完全模型组线上资格赛的数据集。本次大赛提供3类共计16000张图像数据。

该数据集采用单通道标注图片，每一种像素值代表一种类别，像素标注类别从0开始递增，即0，1，2，3这4种类别，分别为背景、实车道线、虚车道线、斑马线。

# 解压数据集
!unzip -q data/data125507/CM_data_2022.zip -d data/data125507/

二、模型组网

ERFNet旨在解决通常采用的残差层版本中固有的效率限制，该残差层用于最近几个在分类和分割任务中达到最高精度的ConvNet。与现有体系结构相比，该体系结构更有效地利用了参数，使网络在保持最高效率的同时获得了非常高的分割精度。

ERFNet的网络架构是编码-解码器架构。与像FCN架构相反，在这种架构中，不同层的特征映射需要被融合，以获得一个细腻的输出。

1.残差分解块

ResNet提出了两种残差模块，其结构如下图里的a、b所示。两者有着相似的参数和接近的精度。但是，bottleneck需要更少的计算资源，随着深度增加这个特点更加划算，因此更加通用。但是，non-bottleneck模块能够获得更好的精度，并且bottleneck仍存在退化问题。

于是ERFNet的作者提出了一个新的版本，如上图c所示。其代码如下所示：

import paddle

class non_bottleneck_1d(paddle.nn.Layer):
    def __init__(self, chann, dropprob, dilated):
        super().__init__()
        self.conv3x1_1 = paddle.nn.Conv2D(in_channels=chann, out_channels=chann, kernel_size=(3, 1), stride=1, padding=(1, 0), bias_attr=True)
        self.conv1x3_1 = paddle.nn.Conv2D(in_channels=chann, out_channels=chann, kernel_size=(1, 3), stride=1, padding=(0, 1), bias_attr=True)
        self.bn1 = paddle.nn.BatchNorm(chann, epsilon=1e-03)
        self.conv3x1_2 = paddle.nn.Conv2D(in_channels=chann, out_channels=chann, kernel_size=(3, 1), stride=1, padding=(1 * dilated, 0), bias_attr=True,
                                              dilation=(dilated, 1))
        self.conv1x3_2 = paddle.nn.Conv2D(in_channels=chann, out_channels=chann, kernel_size=(1, 3), stride=1, padding=(0, 1 * dilated), bias_attr=True,
                                              dilation=(1, dilated))
        self.bn2 = paddle.nn.BatchNorm(chann, epsilon=1e-03)
        self.dropout = paddle.nn.Dropout(dropprob)
        self.p = dropprob

    def forward(self, input):
        output = self.conv3x1_1(input)
        output = paddle.nn.functional.relu(output)
        output = self.conv1x3_1(output)
        output = self.bn1(output)
        output = paddle.nn.functional.relu(output)
        output = self.conv3x1_2(output)
        output = paddle.nn.functional.relu(output)
        output = self.conv1x3_2(output)
        output = self.bn2(output)
        if self.p != 0:
            output = self.dropout(output)
        return paddle.nn.functional.relu(output + input)

2.编码器

下采样虽然获得了粗糙的输出，但降低了计算量，网络进行了三次下采样，并借鉴了ENet的早期下采样模式：即将2x2的最大池化和3x3卷积（步长为2）concat在一起。并且在提出的resnet block上交错使用空洞卷积，以获得更多的信息。

其代码如下所示：

class DownsamplerBlock(paddle.nn.Layer):
    def __init__(self, ninput, noutput):
        super().__init__()
        self.conv = paddle.nn.Conv2D(in_channels=ninput, out_channels=noutput-ninput, kernel_size=3,
                                     stride=2, padding=1, bias_attr=True)
        self.pool = paddle.nn.MaxPool2D(kernel_size=2, stride=2)
        self.bn = paddle.nn.BatchNorm(noutput, epsilon=1e-3)

    def forward(self, input):
        output = paddle.concat(x=[self.conv(input), self.pool(input)], axis=1)
        output = self.bn(output)
        return paddle.nn.functional.relu(output)

class Encoder(paddle.nn.Layer):
    def __init__(self, num_classes):
        super().__init__()
        self.initial_block = DownsamplerBlock(3, 16)
        self.layers = paddle.nn.LayerList()
        self.layers.append(DownsamplerBlock(16, 64))
        for x in range(0, 5):  # 5 times
            self.layers.append(non_bottleneck_1d(64, 0.1, 1))
        self.layers.append(DownsamplerBlock(64, 128))
        for x in range(0, 2):  # 2 times
            self.layers.append(non_bottleneck_1d(128, 0.1, 2))
            self.layers.append(non_bottleneck_1d(128, 0.1, 4))
            self.layers.append(non_bottleneck_1d(128, 0.1, 8))
            self.layers.append(non_bottleneck_1d(128, 0.1, 16))
        # only for encoder mode:
        self.output_conv = paddle.nn.Conv2D(in_channels=128, out_channels=num_classes, kernel_size=1, stride=1, padding=0, bias_attr=True)

    def forward(self, input, predict=False):
        output = self.initial_block(input)
        for layer in self.layers:
            output = layer(output)
        if predict:
            output = self.output_conv(output)
        return output

3.解码器

上采样部分仅有调节细腻度并与输入匹配的作用，采用了和ENet类似的架构。不同的是，没有采用ENet的最大反池化，而是采用了简单的步长为2的反卷积。

class UpsamplerBlock(paddle.nn.Layer):
    def __init__(self, ninput, noutput, output_size=[16, 16]):
        super().__init__()
        self.conv = paddle.nn.Conv2DTranspose(ninput, noutput, kernel_size=3, stride=2, padding=1, bias_attr=True)
        self.bn = paddle.nn.BatchNorm(noutput, epsilon=1e-3)
        self.output_size = output_size

    def forward(self, input):
        output = self.conv(input, output_size=self.output_size)
        output = self.bn(output)
        return paddle.nn.functional.relu(output)

class Decoder(paddle.nn.Layer):
    def __init__(self, num_classes, raw_size=[576, 1640]):
        super().__init__()
        self.layers = paddle.nn.LayerList()
        self.raw_size = raw_size
        self.layers.append(UpsamplerBlock(128, 64, output_size=[raw_size[0] // 4, raw_size[1] // 4]))
        self.layers.append(non_bottleneck_1d(64, 0, 1))
        self.layers.append(non_bottleneck_1d(64, 0, 1))
        self.layers.append(UpsamplerBlock(64, 16, output_size=[raw_size[0] // 2, raw_size[1] // 2]))
        self.layers.append(non_bottleneck_1d(16, 0, 1))
        self.layers.append(non_bottleneck_1d(16, 0, 1))
        self.output_conv = paddle.nn.Conv2DTranspose(16, num_classes, kernel_size=2, stride=2, padding=0, bias_attr=True)

    def forward(self, input):
        output = input
        for layer in self.layers:
            output = layer(output)
        output = self.output_conv(output, output_size=[self.raw_size[0], self.raw_size[1]])

        return output

4.完整ERFNet

完整的ERFNet的代码如下所示：

class ERFNet(paddle.nn.Layer):
    def __init__(self, num_classes, raw_size=[576, 1640]):
        super().__init__()
        self.encoder = Encoder(num_classes)
        self.decoder = Decoder(num_classes, raw_size=raw_size)

    def forward(self, input):
        output = self.encoder(input)
        return self.decoder.forward(output)

三、模型训练

为了方便各位开发者运行，这里加载了在Cityscape数据集上预训练的权重，大家可以基于该权重做预训练。

!python Lane-Detection-with-ERFNet/train_erfnet_paddle.py --epochs 10 -b 8 --lr 0.01

部分输出如下所示，训练10轮后，平均交并比为65%：

Epoch: [9][1509/1600], lr: 0.01000 Time 1.587 (1.298) Data 1.2379 (0.6051) Loss 0.1736 (0.1973)
Epoch: [9][1519/1600], lr: 0.01000 Time 1.627 (1.350) Data 1.2774 (0.6488) Loss 0.1508 (0.1782)
Epoch: [9][1529/1600], lr: 0.01000 Time 1.774 (1.376) Data 1.4225 (0.6706) Loss 0.0615 (0.0909)
Epoch: [9][1539/1600], lr: 0.01000 Time 1.416 (1.283) Data 1.0669 (0.5862) Loss 0.3365 (0.1828)
Epoch: [9][1549/1600], lr: 0.01000 Time 1.560 (1.215) Data 1.2121 (0.5201) Loss 0.0489 (0.2059)
Epoch: [9][1559/1600], lr: 0.01000 Time 1.434 (1.257) Data 1.0853 (0.5631) Loss 0.2443 (0.1724)
Epoch: [9][1569/1600], lr: 0.01000 Time 1.037 (1.340) Data 0.0002 (0.7339) Loss 0.2959 (0.1444)
Epoch: [9][1579/1600], lr: 0.01000 Time 1.039 (1.251) Data 0.0002 (0.5559) Loss 0.2098 (0.2389)
Epoch: [9][1589/1600], lr: 0.01000 Time 1.040 (1.326) Data 0.0002 (0.6283) Loss 0.0776 (0.2452)
Epoch: [9][1599/1600], lr: 0.01000 Time 1.038 (1.783) Data 0.0001 (1.0942) Loss 0.0606 (0.1670)
Test: [99/1000] Time 0.191 (0.160) Pixels Acc 0.951 mIoU 0.651
Test: [199/1000] Time 0.192 (0.152) Pixels Acc 0.949 mIoU 0.654
Test: [299/1000] Time 0.189 (0.151) Pixels Acc 0.947 mIoU 0.656
Test: [399/1000] Time 0.193 (0.150) Pixels Acc 0.946 mIoU 0.656
Test: [499/1000] Time 0.187 (0.151) Pixels Acc 0.944 mIoU 0.654
Test: [599/1000] Time 0.192 (0.151) Pixels Acc 0.940 mIoU 0.650
Test: [699/1000] Time 0.185 (0.152) Pixels Acc 0.943 mIoU 0.654
Test: [799/1000] Time 0.275 (0.152) Pixels Acc 0.945 mIoU 0.654
Test: [899/1000] Time 0.184 (0.152) Pixels Acc 0.944 mIoU 0.650
Test: [999/1000] Time 0.308 (0.158) Pixels Acc 0.946 mIoU 0.652
Testing Results: Pixels Acc 0.946	mIoU 0.652 (0.6567)

四、效果测试

下面我们来测试下训练了10轮的模型效果。

!python Lane-Detection-with-ERFNet/test_erfnet_paddle.py --resume Lane-Detection-with-ERFNet/trained/erfnet_ep10.pdparams

部分输出如下图所示：

=> loading checkpoint 'Lane-Detection-with-ERFNet/trained/erfnet_ep10.pdparams'
=> checkpoint loaded successfully
Test: [10/3200]	Time 0.088 (0.208)	
Test: [20/3200]	Time 0.088 (0.172)	
Test: [30/3200]	Time 0.087 (0.162)	
Test: [40/3200]	Time 0.094 (0.152)	
Test: [50/3200]	Time 0.089 (0.146)	
Test: [60/3200]	Time 0.087 (0.140)	
Test: [70/3200]	Time 0.094 (0.135)	
Test: [80/3200]	Time 0.088 (0.131)	
Test: [90/3200]	Time 0.146 (0.131)

可视化输出

模型的输出结果跟数据集的标签都是单通道的图像，因此直接打开的话就是一张黑黑的图像，如果想要看清输出结果，可以将输出结果转换成灰度图：

%matplotlib inline
import cv2
import numpy as np
import matplotlib.pyplot as plt

index = 10001
image = cv2.imread("data/data125507/data_2022_baseline/JPEGImages/0{}.jpg".format(index))
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
result = cv2.imread("results/result/{}.png".format(index))
result = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
plt.imshow(image)
plt.show()
plt.imshow(result)
plt.show()