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

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

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

参考资料：

一、数据集简介

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

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

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

二、模型组网

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

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

1.残差分解块

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

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

import paddleclass 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 1 -b 8 --lr 0.01

W0305 21:12:08.735818   621 device_context.cc:447] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 10.1, Runtime API Version: 10.1W0305 21:12:08.741001   621 device_context.cc:465] device: 0, cuDNN Version: 7.6.=> pretrained model loaded successfullyEpoch: [0][199/1600], lr: 0.00000 Time 1.044 (1.223) Data 0.0003 (0.4569) Loss 1.0267 (1.1224)Epoch: [0][399/1600], lr: 0.01000 Time 1.557 (1.268) Data 1.0433 (0.5760) Loss 1.1810 (1.0765)Epoch: [0][599/1600], lr: 0.00000 Time 1.319 (1.322) Data 0.8051 (0.6646) Loss 0.7047 (0.9411)Epoch: [0][799/1600], lr: 0.01000 Time 1.508 (1.268) Data 0.9931 (0.5015) Loss 0.8654 (0.8181)Epoch: [0][999/1600], lr: 0.00000 Time 1.539 (1.262) Data 1.0248 (0.4835) Loss 0.6578 (0.6222)Epoch: [0][1199/1600], lr: 0.01000 Time 1.397 (1.261) Data 0.8822 (0.4821) Loss 0.4555 (0.5395)Epoch: [0][1399/1600], lr: 0.00000 Time 1.411 (1.256) Data 0.8975 (0.4768) Loss 0.3137 (0.4068)Epoch: [0][1599/1600], lr: 0.01000 Time 1.394 (1.254) Data 0.8796 (0.4755) Loss 0.4796 (0.4184)Test: [199/1000] Time 0.121 (0.142) Pixels Acc 0.839 mIoU 0.500Test: [399/1000] Time 0.122 (0.140) Pixels Acc 0.835 mIoU 0.499Test: [599/1000] Time 0.123 (0.140) Pixels Acc 0.841 mIoU 0.507Test: [799/1000] Time 0.124 (0.140) Pixels Acc 0.843 mIoU 0.512Test: [999/1000] Time 0.118 (0.140) Pixels Acc 0.839 mIoU 0.513Testing Results: Pixels Acc 0.839mIoU 0.513 (0.5128)

训练1轮后，平均交并比为51.3%.

四、效果测试

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

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

W0305 21:49:27.301187  3291 device_context.cc:447] Please NOTE: device: 0, GPU Compute Capability: 7.0, Driver API Version: 10.1, Runtime API Version: 10.1W0305 21:49:27.306970  3291 device_context.cc:465] device: 0, cuDNN Version: 7.6.=> loading checkpoint 'Lane-Detection-with-ERFNet/trained/erfnet_best.pdparams'=> checkpoint loaded successfullyTest: [400/3200]Time 0.122 (0.103)Test: [800/3200]Time 0.135 (0.102)Test: [1200/3200]Time 0.085 (0.102)Test: [1600/3200]Time 0.093 (0.102)Test: [2000/3200]Time 0.085 (0.103)Test: [2400/3200]Time 0.130 (0.103)Test: [2800/3200]Time 0.084 (0.104)Test: [3200/3200]Time 0.083 (0.104)finished, #test:3200

可视化输出

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

%matplotlib inlineimport cv2import numpy as npimport matplotlib.pyplot as pltindex = 10001image = cv2.imread("data/data125507/car_data_2024/JPEGImages/0{}.webp".format(index))image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)result = cv2.imread("results/result/{}.webp".format(index))result = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)plt.imshow(image)plt.show()plt.imshow(result)plt.show()

%cd /home/aistudio/submission/!python predict.py data.txt result.json

你是一名 AI 行业编辑，请围绕下面这条热点输出一份资讯解读：
热点：ERFNet：用于实时语义分割的高效残差分解卷积神经网络要求：
1. 先用一句话解释这条热点在讲什么
2. 再总结它为什么重要
3. 说明会影响哪些 AI 产品或内容方向
4. 最后给出 3 个适合资讯站使用的标题