SCNN:对交通场景的语义分割--源码及原文阅读

摘要

常规的CNN网络就是由一层一层的卷积层堆叠的.但是,普通的卷积并不能很好地利用像素探索图像的行列信息(空间信息).充分捕捉像素的空间信息对于拥有很强形状先验\很弱外观连接性的语义目标(例如车道线)来说很重要.在交通场景中,车道线经常被遮挡甚至没有画在图像中(也就是完全遮挡了),如下图所示: 本文提出了SCNN,不同于传统的CNN一层一层卷积的连接,本文采用了一片一片的卷积,这使得每层的像素信息可以在行列间流动.SCNN有利于有强空间相关但无纹理信息的大目标,例如车道线\杆\强,我们应用SCNN在车道线检测数据集上,对比基于ReNet的RNN和MRF+CNN,分别比它们提升了8.7%和4.6%,同时在车道线检测挑战赛赢得了第一名,准确率为96.53%.

介绍

作者的贡献还在于提供了车道线数据集.现有的车道线数据量很小,场景单一,图片中都是清晰的车道线.作者提供的图片不仅有磨损的车道线,还有遮挡以及遮挡到看不见的车道线,这更加接近于真实情况.为了收集数据,作者将相机放在六辆不同的车上,由不同的司机驾驶,在不同的时间,在北京采集数据,关于数据集的标注,每一帧都是手动标注的,对于有些遮挡和看不见,也是根据周围信息手工标注的,依据大多数场景,每张图片标注四条车道线,多了的也不再标注.

Spatial CNN

传统的对空间关系建模的方法是马尔科夫链或者条件随机链. 由下图可以看出,两种方法都是先通过CNN获得输出HW＊C（其中ＨW跟原图一样大小,C是语义分割的分割个数),但是,它们获得最终预测图的后处理却是不相同的. 马尔可夫后处理的过程如下:1.归一化,通过softmax对每层特征图归一化;2.信息传输,用大的卷积核进行通道卷积(对于CRF而言,用跟原图一样大的卷积核,卷积核参数取决于输入图片);3.兼容性变换,通过1X1的卷积实现;4.增加一元的potentials,这个过程迭代N次再给出最终的结果.可以看出,在信息传输的过程中采用了传统算法,每一个像素要接受其他像素的信息,计算量很大,很难应用在实时的自动驾驶技术中,而且如此大的卷积核也很难去学习和初始化,但是这是用在top hidden layer,一个包含丰富信息的层,在这里运用空间卷积是很好的.为了解决这个问题,为了更有效地学习空间关系和平滑连续的车道线,或者其他交通标志,我们提出了SCNN,这里的空间指的不是空间卷积,而是通过特殊的方式在CNN结构中传输空间信息. 如上图所示,HWC的tensor要被分成H片,第一片用C个大小为C*w的卷积核进行卷积(其中w为卷积核宽度,在传统CNN当前特征图是要送到下一层进行卷积,但在这里,输出要添加到下一个片以此产生一个新的片,新的片送到下一个卷积层,这个过程一直持续知道最后一个片也被更新. 特别地,假设我们有一个3D的核K,其中i,j,k代表最后一片i通道的元素\当前片j通道的元素\两个元素K列之间的差别,对于输入的3Dtensor X ,其中i,j,k代表通道\行\列,然后SCNN的计算公式如下: 其中f是Relu(非线性的激活函数),带有上标’代表是已经更新的.卷积核的参数被所有片共享,SCNN是一种回归神经网络,同时SCNN是有方向的,四个SCNN的模块下表为D、U、R、L分别代表向下的、向上的、向右的、向左的。

分析

相比于传统的网络，SCNN主要由以下三个优势： 1.计算量更有效,在dense MRF/CRF中,每一个像素要接受其他所有像素的信息,会有大量冗余.但在SCNN中是序列传输的方式.具体如下图所示: 假设tensor有H行W列，在dense MRF/CRF中，信息在两个WH像素中传递，在n次迭代中，信息传递的数量是n_iterWWHH.在SCNN中，每一个像素仅仅从w个像素中接受信息，信息传递的数量n_dirWH*w,n_dir代表传输方向，w代表kernel大小，n_iter从10到100，在本文中n_dir设置为4，因为有四个方向，w通常小于10（本例中为3），对比可以看出，SCNN可以大大节约计算量，同时每个像素可以通过四个方向的传播接受其他所有像素的信息。 ２.ＳＣＮＮ使用了残差，在深度网络里面可有利于训练； ３.灵活性，可以灵活更换骨干网络。

训练

我们使用LargeFov作为前置网络（前面13层是已经在ImagNet数据集上训练好的VGG），使用SGD，batch_size=12,lr=0.01,momentuom=0.9等等。我们的输出是要得到四张预测图，然后在测试阶段，我们需要从预测图获得曲线，当lane marking的存在可能超过0.5，我们在对应的置信图每20行取一个最高的响应值，然后所有的这些位置通过3次样条插值连接起来，作为最终的预测结果。 我们的baseline模型跟largeFov有一些细节上的区别，如下图所示：（1）全连接层fc7的输出被设置为128，（2）每一个relu后面都加上了batchNorm,(3）添加了一个小网络看车道线是否存在。在训练过程中，目标的线宽被设置为16个像素，输入和输出图都被resize成800X288,考虑到在label中目标和背景并不平衡，背景的loss要乘上0.4。

评估

我们把车道线假设成像素宽度为30的曲线，使用IOU重合度来作为衡量，将0.3和0.5作为松的和严格的标准。 (1)关于多方向SCNN的有效性 为了对比多方向的SCNN的好处,我们添加了一个额外的5X5的卷积核的卷积网路作为对比: 其中F1代表F1-measure (2)关于kernel 宽度w的有效性 w代表一个像素能接受多少个周围像素的信息,w=9最好,对比baseline,两种不同的IOU阈值分别能提升8.4%和3.2%. (3)SCNN接在不同的位置 前面说过SCNN可以接在不同的位置，接在output和top hidden layer之后有区别，如下图所示： （3）验证连续传播的有效性 一个片收集完前面所有片的信息后，才传递给下一个片，我们对比一个同步方案，每一个片同步传输给下一个片，对比结果如下：，其结果很好地说明了一个像素不仅受周围像素的影响，也受远距离位置的像素的影响。 （4）为了证明我们的方案的优越性，我们对比了其他一些主流受欢迎的方案，结果如下。

接下来给出了时间上的对比，证明SCNN比ＣＲＦ计算更有效： 为了验证SCNN的有效性，我们在Cityscapes数据集上也进行了测试，结果如下： 之所以SCNN能取得比较好的效果，是因为对于长形状的物体，SCNN能够很好地捕捉其连续的结构并将不连接的地方连接起来，对于墙面、卡车等大物体，SCNN可以根据上下文的信息纠正错误分类的地方，这说明SCNN不仅适用于细长的结构，同样适用于大目标，因为SCNN很好地利用了全局的信息，但是有另外一个有趣的现象，就是车辆位于图片的顶端，在训练的时候漏了ｌａｂｅｌ，然后分类出来的结果是道路，这也是因为SCNN的扩散影响将车辆的头部区域也分类为道路。 为了验证我们方法的有效性，我们还进行了如下实验：

总结

本文提出了SCNN,充分利用了传播过程中的空间信息,可以很容易地接在深度网络后面,且可以进行端到端的训练,结果证明SCNN不仅对于长条状的物体有效,对于大目标也很有效,我们20层的网络比101层的Resnet的效果还要好.

代码阅读

前置网络不重要,我们主要看看SCNN的建立过程，以下代码来自github,注释自己加上去的(lua语言)

require 'nn' require 'cudnn' #载入VGG为前置网络 model = torch.load('vgg/vgg.t7') last = model:get(43) #Seq:add(buildPass(1,1,dim,s,9)) #Seq:add(buildPass(2,1,dim,s,9)) #dim=(128,1) #scale=7 function buildPass(d,width,dim,scale,kw) --d=1:down-up d=2:right-left local pass = nn.Sequential() local length = 0 if d==1 then Num = 36/scale length = 100/scale else Num = 100/scale length = 36/scale end local num = Num/width local function buildParal() local seq = nn.Sequential() #Tensor=batch+channel+H+W #nn.SplitTable按维度将Tensor划分成tables #在这里是按照第三个维度进行划分,具体原因参照https://github.com/torch/nn/blob/master/SplitTable.lua#L13 #所以是按照H划分得 seq:add(nn.SplitTable(d+1, 3)) --128 36 -- view fom 100 to 1,1,100 local paralView = nn.ParallelTable() for i=1,Num do local view = nn.Sequential() view:add(nn.Contiguous()) if d==1 then view:add(nn.View(dim, 1, length):setNumInputDims(2)) else view:add(nn.View(dim, length, 1):setNumInputDims(2)) end paralView:add(view) end seq:add(paralView) if width > 1 then local concatM = nn.ConcatTable() for i=1,num do local merge = nn.Sequential() merge:add(nn.NarrowTable((i-1)*width+1,width)) merge:add(nn.JoinTable(d+1,3)) concatM:add(merge) -- 128,36,2 * 50 end seq:add(concatM) end local concat = nn.ConcatTable() local part1 = nn.Sequential() part1:add(nn.SelectTable(1)) local conv, conv2 if d==2 then conv = cudnn.SpatialConvolution(dim,dim,1,kw,1,1,0,(kw-1)/2) conv2 = cudnn.SpatialConvolution(dim,dim,1,kw,1,1,0,(kw-1)/2) else conv = cudnn.SpatialConvolution(dim,dim,kw,1,1,1,(kw-1)/2,0) conv2 = cudnn.SpatialConvolution(dim,dim,kw,1,1,1,(kw-1)/2,0) end conv.bias = nil conv.gradBias = nil conv.weight:normal(0,math.sqrt(2/(kw*dim*dim*5))) conv2.bias = nil conv2.gradBias = nil conv2.weight:normal(0,math.sqrt(2/(kw*dim*dim*5))) local function buildConcat(d) local conc = nn.ConcatTable() if d == true then conc:add(nn.Identity()) local seq = nn.Sequential() seq:add(conv:clone('weight','bias','gradWeight','gradBias')) seq:add(nn.ReLU(true)) conc:add(seq) else local seq = nn.Sequential() seq:add(conv2:clone('weight','bias','gradWeight','gradBias')) seq:add(nn.ReLU(true)) conc:add(seq) conc:add(nn.Identity()) end return conc end part1:add(buildConcat(true)) concat:add(part1) concat:add(nn.NarrowTable(2,num-1)) seq:add(concat) -- {1, 1s}, {2, 3, ..., 18} seq:add(nn.FlattenTable()) -- pass the rest 34+1 times for i = 1,num-1 do local concat = nn.ConcatTable() local part2 = nn.Sequential() part2:add(nn.NarrowTable(i+1, 2)) part2:add(nn.CAddTable()) if i~=num-1 then part2:add(buildConcat(true)) else part2:add(buildConcat(false)) end if i==1 then concat:add(nn.SelectTable(1)) else concat:add(nn.NarrowTable(1, i)) end concat:add(part2) if i==num-2 then concat:add(nn.SelectTable(num+1)) elseif i~=num-1 then concat:add(nn.NarrowTable(i+3, num-1-i)) end seq:add(concat) seq:add(nn.FlattenTable()) end -- {1, 2', 3', ..., 17'}, {18's, 18'} for i = 1,num-1 do local concat = nn.ConcatTable() local part2 = nn.Sequential() part2:add(nn.NarrowTable(num-i, 2)) part2:add(nn.CAddTable()) if i~=num-1 then part2:add(buildConcat(false)) end if i==num-2 then concat:add(nn.SelectTable(1)) elseif i~=num-1 then concat:add(nn.NarrowTable(1, num-1-i)) end concat:add(part2) if i==1 then concat:add(nn.SelectTable(num+1)) else concat:add(nn.NarrowTable(num+2-i, i)) end seq:add(concat) seq:add(nn.FlattenTable()) end -- {1', 2'', 3'', ..., 17'', 18'} seq:add(nn.JoinTable(d+1,3)) --128,36,100 return seq end pass:add(buildParal()) return pass end function buildSCNN(dim, s) local Seq = nn.Sequential() #显示对H进行拆分 Seq:add(buildPass(1,1,dim,s,9)) #然后对W进行拆分 Seq:add(buildPass(2,1,dim,s,9)) return Seq end #建立SCNN网络 last:insert(buildSCNN(128, 1),7) print(model) #VGG+SCNN(w=9) torch.save('vgg_SCNN_DULR_w9/vgg_SCNN_DULR_w9.t7', model)

lua语言的大致能看懂,细节太难看懂了,下面来看看一目了然的python版的SCNN

import torch import torch.nn as nn import torch.nn.functional as F import torchvision.models as models class SCNN(nn.Module): def __init__( self, input_size, ms_ks=9, pretrained=True ): """ Argument ms_ks: kernel size in message passing conv """ super(SCNN, self).__init__() self.pretrained = pretrained self.net_init(input_size, ms_ks) if not pretrained: self.weight_init() self.scale_background = 0.4 self.scale_seg = 1.0 self.scale_exist = 0.1 self.ce_loss = nn.CrossEntropyLoss(weight=torch.tensor([self.scale_background, 1, 1, 1, 1])) self.bce_loss = nn.BCELoss() def forward(self, img, seg_gt=None, exist_gt=None): #首先,前面有一个backbone网络 x = self.backbone(img) #然后第一个layer1执行了空洞卷积,BN,1*1的降维卷积 x = self.layer1(x) #这里将特征图切片,从上往下切,每一片与之前更新的前面所有片的信息融合 #然后是从下往上 #然后是从左往右 #然后是从右往左 x = self.message_passing_forward(x) #layer2进行dropout和1*1的降维卷积 x = self.layer2(x) #双线性插值恢复指定倍数 seg_pred = F.interpolate(x, scale_factor=8, mode='bilinear', align_corners=True) #后面是另外一个分支判断lane是否存在 #layer3 是softmax和2*2的pooling x = self.layer3(x) x = x.view(-1, self.fc_input_feature) #linear和sigmoid,输出是四个值,代表四个lane是否存在的置信度 exist_pred = self.fc(x) if seg_gt is not None and exist_gt is not None: #语义分割的loss是多分类loss,所以使用CEloss loss_seg = self.ce_loss(seg_pred, seg_gt) #是否存在是二分类loss,所以使用bceloss loss_exist = self.bce_loss(exist_pred, exist_gt) #两个以一定系数相乘 loss = loss_seg * self.scale_seg + loss_exist * self.scale_exist else: #如果gt中不含有lane,那么loss=0 loss_seg = torch.tensor(0, dtype=img.dtype, device=img.device) loss_exist = torch.tensor(0, dtype=img.dtype, device=img.device) loss = torch.tensor(0, dtype=img.dtype, device=img.device) return seg_pred, exist_pred, loss_seg, loss_exist, loss #在这里进行上下\下上\左右\右左的信息传递 def message_passing_forward(self, x): Vertical = [True, True, False, False] Reverse = [False, True, False, True] for ms_conv, v, r in zip(self.message_passing, Vertical, Reverse): x = self.message_passing_once(x, ms_conv, v, r) return x #这里进行单次单方向的message passing def message_passing_once(self, x, conv, vertical=True, reverse=False): """ Argument: ---------- x: input tensor vertical: vertical message passing or horizontal reverse: False for up-down or left-right, True for down-up or right-left """ nB, C, H, W = x.shape #按照是垂直还是水平进行切片 if vertical: slices = [x[:, :, i:(i + 1), :] for i in range(H)] dim = 2 else: slices = [x[:, :, :, i:(i + 1)] for i in range(W)] dim = 3 #这里的reverse决定了要不要反向传输,譬如本来信息从上到下融合,要不要变成从下到上 if reverse: slices = slices[::-1] out = [slices[0]] #当前层要更新,要加上之前累加的卷积结果 for i in range(1, len(slices)): out.append(slices[i] + F.relu(conv(out[i - 1]))) if reverse: out = out[::-1] #将out的slices拼接成跟原始一样大的图 return torch.cat(out, dim=dim) def net_init(self, input_size, ms_ks): #先进行参数初始化 input_w, input_h = input_size self.fc_input_feature = 5 * int(input_w/16) * int(input_h/16) self.backbone = models.vgg16_bn(pretrained=self.pretrained).features # ----------------- process backbone ----------------- for i in [34, 37, 40]: conv = self.backbone._modules[str(i)] dilated_conv = nn.Conv2d( conv.in_channels, conv.out_channels, conv.kernel_size, stride=conv.stride, padding=tuple(p * 2 for p in conv.padding), dilation=2, bias=(conv.bias is not None) ) dilated_conv.load_state_dict(conv.state_dict()) self.backbone._modules[str(i)] = dilated_conv #将backbone中的VGG中的全连接层去掉 self.backbone._modules.pop('33') self.backbone._modules.pop('43') # ----------------- SCNN part ----------------- #什么是空洞卷积https://www.zhihu.com/question/54149221 #空洞卷积+BN+RELU+1*1降维卷积+RELU self.layer1 = nn.Sequential( nn.Conv2d(512, 1024, 3, padding=4, dilation=4, bias=False), nn.BatchNorm2d(1024), nn.ReLU(), nn.Conv2d(1024, 128, 1, bias=False), nn.BatchNorm2d(128), nn.ReLU() # (nB, 128, 36, 100) ) # ----------------- add message passing ----------------- #这是信息融合模块,包含了从上到下\从下到上\从左到右\从右到左 self.message_passing = nn.ModuleList() self.message_passing.add_module('up_down', nn.Conv2d(128, 128, (1, ms_ks), padding=(0, ms_ks // 2), bias=False)) self.message_passing.add_module('down_up', nn.Conv2d(128, 128, (1, ms_ks), padding=(0, ms_ks // 2), bias=False)) self.message_passing.add_module('left_right', nn.Conv2d(128, 128, (ms_ks, 1), padding=(ms_ks // 2, 0), bias=False)) self.message_passing.add_module('right_left', nn.Conv2d(128, 128, (ms_ks, 1), padding=(ms_ks // 2, 0), bias=False)) # (nB, 128, 36, 100) # ----------------- SCNN part ----------------- #dropout和1*1降维卷积 self.layer2 = nn.Sequential( nn.Dropout2d(0.1), nn.Conv2d(128, 5, 1) # get (nB, 5, 36, 100) ) self.layer3 = nn.Sequential( nn.Softmax(dim=1), # (nB, 5, 36, 100) nn.AvgPool2d(2, 2), # (nB, 5, 18, 50) ) #为了获得分类结果的fc self.fc = nn.Sequential( nn.Linear(self.fc_input_feature, 128), nn.ReLU(), nn.Linear(128, 4), nn.Sigmoid() ) def weight_init(self): for m in self.modules(): if isinstance(m, nn.Conv2d): m.reset_parameters() elif isinstance(m, nn.BatchNorm2d): m.weight.data[:] = 1. m.bias.data.zero_()

接下来看看评估过程中IOU计算的代码：

#这里是判断两条车道线的相似度 double LaneCompare::get_lane_similarity(const vector<Point2f> &lane1, const vector<Point2f> &lane2) { #每条车道线里面至少有两个点，因为单个点根本不能成为一条线 if(lane1.size()<2 || lane2.size()<2) { cerr<<"lane size must be greater or equal to 2"<<endl; return 0; } #造两张值为全0的图 Mat im1 = Mat::zeros(im_height, im_width, CV_8UC1); Mat im2 = Mat::zeros(im_height, im_width, CV_8UC1); // draw lines on im1 and im2 vector<Point2f> p_interp1; vector<Point2f> p_interp2; if(lane1.size() == 2) { p_interp1 = lane1; } else { p_interp1 = splineSolver.splineInterpTimes(lane1, 50); } if(lane2.size() == 2) { p_interp2 = lane2; } else { p_interp2 = splineSolver.splineInterpTimes(lane2, 50); } #以一定线宽把点在图像上画出来 Scalar color_white = Scalar(1); for(int n=0; n<p_interp1.size()-1; n++) { line(im1, p_interp1[n], p_interp1[n+1], color_white, lane_width); } for(int n=0; n<p_interp2.size()-1; n++) { line(im2, p_interp2[n], p_interp2[n+1], color_white, lane_width); } double sum_1 = cv::sum(im1).val[0]; double sum_2 = cv::sum(im2).val[0]; #计算重合的像素个数 double inter_sum = cv::sum(im1.mul(im2)).val[0]; #计算总的像素的个数 double union_sum = sum_1 + sum_2 - inter_sum; #计算IOU double iou = inter_sum / union_sum; return iou; } // resize the lane from Size(curr_width, curr_height) to Size(im_width, im_height) void LaneCompare::resize_lane(vector<Point2f> &curr_lane, int curr_width, int curr_height) { if(curr_width == im_width && curr_height == im_height) { return; } double x_scale = im_width/(double)curr_width; double y_scale = im_height/(double)curr_height; for(int n=0; n<curr_lane.size(); n++) { curr_lane[n] = Point2f(curr_lane[n].x*x_scale, curr_lane[n].y*y_scale); } }