车道线检测

前言

现在，车道线检测技术已经相称成熟，重要应用在自动驾驶、智能交通等范畴。下面列举一些当下最流行的车道线检测方法：

• 基于图像处理的车道线检测方法。该方法是通过图像处理技术从摄像头传回的图像中提取车道线信息的一种方法，重要是使用图像处理算法进行车道线的检测和辨认，并输出车道线的位置信息。
  
• 基于激光雷达的车道线检测方法。该方法通过激光雷达扫描地面，获取车道线位置信息。这种方法对于在光照较弱、天气恶劣的情况下车道线能更加准确地被检测出来。
  
• 基于雷达与摄像头的融合车道线检测方法。此方法是将雷达和摄像头两个传感器的数据进行融合，从而得到更加准确的车道线位置信息，检测的鲁棒性也得到了进步。
  
• 基于GPS和舆图的车道线检测方法。该方法重要是使用车辆上的GPS以及舆图数据来检测车道线的位置信息。这种方法可以降服图像处理技术在某些特定情况下（好比光照不敷大概情况光线无法反射）的不敷。
  

以上这些方法均存在优缺点，差异方法的选择重要取决于详细的技术需求和场景应用。在该章节以基于图像处理的车道线检测方法进行介绍。分别从底子的入门级方法到深度学习的方法进行介绍。
传统图像方法
传统图像方法通过边沿检测滤波等方式分割出车道线地区，然后连合霍夫变换、RANSAC等算法进行车道线检测。这类算法需要人工手动去调滤波算子，根据算法所针对的街道场景特点手动调节参数曲线，工作量大且鲁棒性较差，当行车情况出现明显变革时，车道线的检测效果不佳。基于蹊径特性检测根据提取特性差异，分为：基于颜色特性、纹理特性、多特性融合；
比方：在车道图像中，路面与车道线交汇处的灰度值变换剧烈，使用边沿增强算子突出图像的局部边沿，界说像素的边沿强度，设置阈值方法提取边沿点；
常用的算子：Sobel算子、Prewitt算子、Log算子、Canny算子；
基于灰度特性检测布局简朴，对于路面平整、车道线清楚的布局化蹊径尤为实用；但当光照强烈、有大量异物遮挡、蹊径布局复杂、车道线较为模糊时，检测效果受到很大的影响；
使用openCV的传统算法

• Canny边沿检测
  
• 高斯滤波
  
• ROI和mask
  
• 霍夫变换
  

openCV在图片和视频干系常用的代码

1. # 读取图片 cv2.imread第一个参数是窗口的名字，第二个参数是读取格式（彩色或灰度）
2. cv2.imread(const String & filename, int flags = IMREAD_COLOR)
4. #显示图片 cv2.imshow第一个参数是窗口的名字  第二个参数是显示格式，
5. cv2.imshow(name, img)       
7. #保持图片
8. cv2.imwrite(newfile_name, img)
10. #关闭所有openCV打开的窗口。
11. cv2.destroyAllWindows()
13. #-----------------------------#
14. #打开视频
15. capture = cv2.VideoCapture('video.mp4')
17. #按帧读取视频
18. #capture.read()有两个返回值。其中ret是布尔值，如果读取帧是正确的则返回True，如果文件读取到结尾，它的返回值就为False。frame就是每一帧的图像，是个三维矩阵。
19. ret, frame = capture.read()
21. #视频编码格式设置
22. fourcc = cv2.VideoWriter_fourcc('X', 'V', 'I', 'D')
24. """
25. 补充：cv2.VideoWriter_fourcc(‘I’, ‘4’, ‘2’, ‘0’),该参数是YUV编码类型，文件名后缀为.avi
26. cv2.VideoWriter_fourcc(‘P’, ‘I’, ‘M’, ‘I’),该参数是MPEG-1编码类型，文件名后缀为.avi
27. cv2.VideoWriter_fourcc(‘X’, ‘V’, ‘I’, ‘D’),该参数是MPEG-4编码类型，文件名后缀为.avi
28. cv2.VideoWriter_fourcc(‘T’, ‘H’, ‘E’, ‘O’),该参数是Ogg Vorbis,文件名后缀为.ogv
29. cv2.VideoWriter_fourcc(‘F’, ‘L’, ‘V’, ‘1’),该参数是Flash视频，文件名后缀为.flv
31. """

复制代码

高斯滤波

Canny边沿检测

有关边沿检测也是计算机视觉。起首使用梯度变革来检测图像中的边，怎样辨认图像的梯度变革呢，答案是卷积核。卷积核是就是不连续的像素上找到梯度变革较大位置。我们知道 sobal 核可以很好检测边沿，那么 canny 就是 sobal 核检测上进行优化。
CV2提供了提取图像边沿的函数canny。其算法头脑如下：

• 使用高斯模糊，去除噪音点（cv2.GaussianBlur）
  
• 灰度转换（cv2.cvtColor）
  
• 使用sobel算子，计算出每个点的梯度巨细和梯度方向
  
• 使用非极大值抑制(只有最大的保留)，消除边沿检测带来的杂散效应
  
• 应用双阈值，来确定真实和潜伏的边沿
  
• 通过抑制弱边沿来完成终极的边沿检测
  

1. #color_img 输入图片
2. #gaussian_ksize 高斯核大小，可以为方形矩阵，也可以为矩形
3. #gaussian_sigmax X方向上的高斯核标准偏差
4. gaussian = cv2.GaussianBlur(color_img, (gaussian_ksize,gaussian_ksize), gaussian_sigmax)
6. #用于颜色空间转换。input_image为需要转换的图片，flag为转换的类型，返回值为颜色空间转换后的图片矩阵。
7. #flag对应：
8. #cv2.COLOR_BGR2GRAY BGR -> Gray
9. #cv2.COLOR_BGR2RGB BGR -> RGB
10. #cv2.COLOR_BGR2HSV BGR -> HSV
12. gray_img = cv2.cvtColor(input_image, flag)

复制代码

输出结果：

1. #imag为所操作的图片，threshold1为下阈值，threshold2为上阈值，返回值为边缘图。
2. edge_img = cv2.Canny(gray_img,canny_threshold1,canny_threshold2)
4. #整成canny_edge_detect的方法
5. def canny_edge_detect(img):
6.     gray = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)
7.     kernel_size = 5
8.     blur_gray = cv2.GaussianBlur(gray,(kernel_size, kernel_size),0)
10.     low_threshold = 180
11.     high_threshold = 240
12.     edges = cv2.Canny(blur_gray, low_threshold, high_threshold)
14.     return edges

复制代码

ROI and mask

在机器视觉或图像处理中，通过图像获取到的信息通常是一个二维数组或矩阵，这些信息中大概包罗需要进一步处理的地区以及不需要处理的地区。为了进步图像处理的服从和准确性，通常会在需要处理的地区内界说一个感爱好的地区（ROI），并对该地区进行下一步的处理。ROI可以通过方框、圆、椭圆、不规则多边形等方式勾勒出需要处理的地区。在机器视觉软件中，常常通过图像处理算子和函数来计算ROI。好比，在OpenCV中可以使用cv::Rect、cv::RotatedRect、cv:oint等进行ROI的范例界说和计算；在Matlab中可以使用imrect、imellipse、impoly等函数实现ROI的界说和计算。
处理ROI的目的是为了便于在图像的地区中进行目的检测、物体跟踪、边沿检测、图像分割等操作。通过使用ROI，可以将不需要处理的地区从原始图像中清撤除，从而减少图像处理的复杂度和耗时，进步计算服从和准确性。

1. #设置ROI和掩码
2. poly_pts = numpy.array([[[0,368],[300,210],[340,210],[640,368]]])
4. mask = np.zeros_like(gray_img)
6. cv2.fillPoly(mask, pts, color)
8. img_mask = cv2.bitwise_and(gray_img, mask)

复制代码

霍夫变换

霍夫变换是一种常用的图像处理算法，用于在图像中检测几何形状（如直线、圆、椭圆等）。该算法最初是由保罗·霍夫于 1962 年提出的。简朴来说，霍夫变换可以将在直角坐标系中表示的图形转换为极坐标系中的线或曲线，从而方便地进行形状的检测和辨认。所以霍夫变换实际上一种由繁到简(类似降维)的操作。在应用中，霍夫变换的过程可以分为以下几个步调：

• 针对待检测的形状，选择相应的霍夫曼变换方法。好比，如果要检测直线，可以使用尺度霍夫变换；如果要检测圆形，可以使用圆霍夫变换。
  
• 将图像转换为灰度图像，并进行边沿检测，以得到待检测的形状目的的轮廓。
  
• 以肯定的步长和角度范围在霍夫空间中进行投票，将所有大概的直线或曲线与它们大概在的极坐标空间中的位置相对应。
  
• 找到霍夫空间中的峰值，这些峰值表示形状的参数空间中存在原始图像中形状的大概性。
  
• 通过峰值位置在原始图像中绘制直线、圆等形状。
  

当使用 canny 进行边沿检测后图像可以交给霍夫变换进行简朴图形(线、圆)等的辨认。这里用霍夫变换在 canny 边沿检测结果中寻找直线。

1. # 示例代码，作者丹成学长：Q746876041
2. mask = np.zeros_like(edges)
4.     ignore_mask_color = 255
5.     # 获取图片尺寸
6.     imshape = img.shape
7.     # 定义 mask 顶点
8.     vertices = np.array([[(0,imshape[0]),(450, 290), (490, 290), (imshape[1],imshape[0])]], dtype=np.int32)
9.     # 使用 fillpoly 来绘制 mask
10.     cv2.fillPoly(mask, vertices, ignore_mask_color)
11.     masked_edges = cv2.bitwise_and(edges, mask)
12.     # 定义Hough 变换的参数
13.     rho = 1
14.     theta = np.pi/180
15.     threshold = 2
17.     min_line_length = 4 # 组成一条线的最小像素数
18.     max_line_gap = 5    # 可连接线段之间的最大像素间距
19.     # 创建一个用于绘制车道线的图片
20.     line_image = np.copy(img)*0
22.     # 对于 canny 边缘检测结果应用 Hough 变换
23.     # 输出“线”是一个数组，其中包含检测到的线段的端点
24.     lines = cv2.HoughLinesP(masked_edges, rho, theta, threshold, np.array([]),
25.                                 min_line_length, max_line_gap)
27.     # 遍历“线”的数组来在 line_image 上绘制
28.     for line in lines:
29.         for x1,y1,x2,y2 in line:
30.             cv2.line(line_image,(x1,y1),(x2,y2),(255,0,0),10)
32.     color_edges = np.dstack((edges, edges, edges))
34. import math
35. import cv2
36. import numpy as np
38. """
39. Gray Scale
40. Gaussian Smoothing
41. Canny Edge Detection
42. Region Masking
43. Hough Transform
44. Draw Lines [Mark Lane Lines with different Color]
45. """
47. class SimpleLaneLineDetector(object):
48.     def __init__(self):
49.         pass
51.     def detect(self,img):
52.         # 图像灰度处理
53.         gray_img = self.grayscale(img)
54.         print(gray_img)
55.         #图像高斯平滑处理
56.         smoothed_img = self.gaussian_blur(img = gray_img, kernel_size = 5)
57.         #canny 边缘检测
58.         canny_img = self.canny(img = smoothed_img, low_threshold = 180, high_threshold = 240)
59.         #区域 Mask
60.         masked_img = self.region_of_interest(img = canny_img, vertices = self.get_vertices(img))
61.         #霍夫变换
62.         houghed_lines = self.hough_lines(img = masked_img, rho = 1, theta = np.pi/180, threshold = 20, min_line_len = 20, max_line_gap = 180)
63.         # 绘制车道线
64.         output = self.weighted_img(img = houghed_lines, initial_img = img, alpha=0.8, beta=1., gamma=0.)
65.         
66.         return output
67.     def grayscale(self,img):
68.         return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
70.     def canny(self,img, low_threshold, high_threshold):
71.         return cv2.Canny(img, low_threshold, high_threshold)
73.     def gaussian_blur(self,img, kernel_size):
74.         return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)
76.     def region_of_interest(self,img, vertices):
77.         mask = np.zeros_like(img)   
78.    
79.         if len(img.shape) > 2:
80.             channel_count = img.shape[2]  
81.             ignore_mask_color = (255,) * channel_count
82.         else:
83.             ignore_mask_color = 255
84.             
85.         cv2.fillPoly(mask, vertices, ignore_mask_color)
86.         
87.         masked_image = cv2.bitwise_and(img, mask)
88.         return masked_image
89.     def draw_lines(self,img, lines, color=[255, 0, 0], thickness=10):
90.         for line in lines:
91.             for x1,y1,x2,y2 in line:
92.                 cv2.line(img, (x1, y1), (x2, y2), color, thickness)
94.     def slope_lines(self,image,lines):
95.         img = image.copy()
96.         poly_vertices = []
97.         order = [0,1,3,2]
99.         left_lines = []
100.         right_lines = []
101.         for line in lines:
102.             for x1,y1,x2,y2 in line:
104.                 if x1 == x2:
105.                     pass
106.                 else:
107.                     m = (y2 - y1) / (x2 - x1)
108.                     c = y1 - m * x1
110.                     if m < 0:
111.                         left_lines.append((m,c))
112.                     elif m >= 0:
113.                         right_lines.append((m,c))
115.         left_line = np.mean(left_lines, axis=0)
116.         right_line = np.mean(right_lines, axis=0)
119.         for slope, intercept in [left_line, right_line]:
121.             rows, cols = image.shape[:2]
122.             y1= int(rows)
124.             y2= int(rows*0.6)
126.             x1=int((y1-intercept)/slope)
127.             x2=int((y2-intercept)/slope)
128.             poly_vertices.append((x1, y1))
129.             poly_vertices.append((x2, y2))
130.             self.draw_lines(img, np.array([[[x1,y1,x2,y2]]]))
131.         
132.         poly_vertices = [poly_vertices[i] for i in order]
133.         cv2.fillPoly(img, pts = np.array([poly_vertices],'int32'), color = (0,255,0))
134.         return cv2.addWeighted(image,0.7,img,0.4,0.)
135.    
136.     def hough_lines(self,img, rho, theta, threshold, min_line_len, max_line_gap):
137.         """
138.         edge_img: 要检测的图片矩阵
139.                 参数2: 距离r的精度,值越大,考虑越多的线
140.                 参数3: 距离theta的精度,值越大,考虑越多的线
141.                 参数4: 累加数阈值,值越小,考虑越多的线
142.                 minLineLength: 最短长度阈值,短于这个长度的线会被排除
143.                 maxLineGap:同一直线两点之间的最大距离
144.         """
145.         lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap)
146.         line_img = np.zeros((img.shape[0], img.shape[1], 3), dtype=np.uint8)
147.         line_img = self.slope_lines(line_img,lines)
148.         return line_img
150.     def weighted_img(self,img, initial_img, alpha=0.1, beta=1., gamma=0.):
152.         lines_edges = cv2.addWeighted(initial_img, alpha, img, beta, gamma)
153.         return lines_edges
154.         
155.     def get_vertices(self,image):
156.         rows, cols = image.shape[:2]
157.         bottom_left  = [cols*0.15, rows]
158.         top_left     = [cols*0.45, rows*0.6]
159.         bottom_right = [cols*0.95, rows]
160.         top_right    = [cols*0.55, rows*0.6]
161.         
162.         ver = np.array([[bottom_left, top_left, top_right, bottom_right]], dtype=np.int32)
163.         return ver

复制代码

深度学习方法

• 基于基于分割的方法
  
• 基于检测的方法
  
• 基于关键点的方法
  
• 基于参数曲线的方法
  

LaneNet+H-Net车道线检测

论文链接：Towards End-to-End Lane Detection: an Instance Segmentation Approach
代码链接
LaneNet+H-Net的车道线检测方法，通过深度学习方法实现端到端的车道线检测，该方法包括两个重要组件，一个是实例分割网络，另一个是车道线检测网络。
该方法的重要贡献在于使用实例分割技术来区分差异车道线之间的重叠和交织，而且应用多任务学习方法同时实现车道线检测和实例分割。详细来说，该方法将车道线检测标题转化为实例分割标题，使用 Mask R-CNN 实现车道线的分割和检测。通过融合两个任务的 loss 函数，同时对车道线检测和实例分割网络进行练习，实现端到端的车道线检测。
论文中的模子布局重要包括两部分：实例分割网络和车道线检测网络。实例分割网络接纳 Mask R-CNN，由主干网络和 Mask R-CNN 网络两部分组成。车道线检测网络接纳了 U-Net 布局，用于对掩码图像进行后处理，得到车道线检测结果。

• LaneNet将车道线检测标题转为实例分割标题，即：每个车道线形成独立的实例，但都属于车道线这一种别；H-Net由卷积层和全毗连层组成，使用转换矩阵H对同一车道线的像素点进行回归；
  
• 对于一张输入图片，LaneNet负责输出实例分割结果，每条车道线一个标识ID，H-Net输出一个转换矩阵，对车道线像素点进行修正，并对修正后的结果拟合出一个三阶多项式作为猜测的车道线；
  
  
  测试效果
  

Ultra-Fast-Lane-Detection-V2

论文链接：Ultra Fast Deep Lane Detection with Hybrid Anchor Driven Ordinal Classification
代码：Ultra-Fast-Lane-Detection-V2

解说模子部分的代码

• backbone
  
• layer
  
• model_culane
  
• model_tusimple
  
• seg_model
  

backbone

backbone有两类主干方法，VGG和ResNet

• class vgg16bn
  
• class resnet
  

1. import torch,pdb
2. import torchvision
3. import torch.nn.modules
5. class vgg16bn(torch.nn.Module):
6.     def __init__(self,pretrained = False):
7.         super(vgg16bn,self).__init__()
8.         model = list(torchvision.models.vgg16_bn(pretrained=pretrained).features.children())
9.         model = model[:33]+model[34:43]
10.         self.model = torch.nn.Sequential(*model)
11.         
12.     def forward(self,x):
13.         return self.model(x)
14. class resnet(torch.nn.Module):
15.     def __init__(self,layers,pretrained = False):
16.         super(resnet,self).__init__()
17.         #resnet有以下几种选择方式
18.         if layers == '18':
19.             model = torchvision.models.resnet18(pretrained=pretrained)
20.         elif layers == '34':
21.             model = torchvision.models.resnet34(pretrained=pretrained)
22.         elif layers == '50':
23.             model = torchvision.models.resnet50(pretrained=pretrained)
24.         elif layers == '101':
25.             model = torchvision.models.resnet101(pretrained=pretrained)
26.         elif layers == '152':
27.             model = torchvision.models.resnet152(pretrained=pretrained)
28.         elif layers == '50next':
29.             model = torchvision.models.resnext50_32x4d(pretrained=pretrained)
30.         elif layers == '101next':
31.             model = torchvision.models.resnext101_32x8d(pretrained=pretrained)
32.         elif layers == '50wide':
33.             model = torchvision.models.wide_resnet50_2(pretrained=pretrained)
34.         elif layers == '101wide':
35.             model = torchvision.models.wide_resnet101_2(pretrained=pretrained)
36.         elif layers == '34fca':
37.             model = torch.hub.load('cfzd/FcaNet', 'fca34' ,pretrained=True)
38.         else:
39.             raise NotImplementedError
40.         
41.         self.conv1 = model.conv1
42.         self.bn1 = model.bn1
43.         self.relu = model.relu
44.         self.maxpool = model.maxpool
45.         self.layer1 = model.layer1
46.         self.layer2 = model.layer2
47.         self.layer3 = model.layer3
48.         self.layer4 = model.layer4
50.     def forward(self,x):
51.         x = self.conv1(x)
52.         x = self.bn1(x)
53.         x = self.relu(x)
54.         x = self.maxpool(x)
55.         x = self.layer1(x)
56.         x2 = self.layer2(x)
57.         x3 = self.layer3(x2)
58.         x4 = self.layer4(x3)
59.         return x2,x3,x4

复制代码

layer

在这部分代码，是设置网络层的功能模块。其中有两个模块 ： AddCoordinates和CoordConv，它们都是用于卷积操作的。这些模块是用于办理卷积神经网络中的"hole problem"（洞穴标题）的。

• AddCoordinates用于叠加在输入上的坐标信息。详细来说，它将坐标x、y和r(若设置了with_r参数为True)与输入张量相毗连。其中，x和y坐标在[-1, 1]范围内进行缩放，坐标原点在中央。r是间隔中央的欧几里得间隔，并缩放为[0,1]范围内。如许做的目的是为了给卷积层提供额外的位置信息，以便进步其对位置信息的感知。
  
• CoordConv模块则使用AddCoordinates模块中到场的坐标信息进行卷积操作。在当前张量和坐标信息合并后，将结果输入到卷积层中进行卷积操作。别的参数与torch.nn.Conv2d类似。
  

需要注意的是，这些模块需要连合使用，AddCoordinates模块在CoordConv模块之前使用，以确保卷积层可以大概获取到足够的位置信息。

1. import torch
2. from torch import nn
5. class AddCoordinates(object):
7.     r"""Coordinate Adder Module as defined in 'An Intriguing Failing of
8.     Convolutional Neural Networks and the CoordConv Solution'
9.     (https://arxiv.org/pdf/1807.03247.pdf).
10.     This module concatenates coordinate information (`x`, `y`, and `r`) with
11.     given input tensor.
12.     `x` and `y` coordinates are scaled to `[-1, 1]` range where origin is the
13.     center. `r` is the Euclidean distance from the center and is scaled to
14.     `[0, 1]`.
15.     Args:
16.         with_r (bool, optional): If `True`, adds radius (`r`) coordinate
17.             information to input image. Default: `False`
18.     Shape:
19.         - Input: `(N, C_{in}, H_{in}, W_{in})`
20.         - Output: `(N, (C_{in} + 2) or (C_{in} + 3), H_{in}, W_{in})`
21.     Examples:
22.         >>> coord_adder = AddCoordinates(True)
23.         >>> input = torch.randn(8, 3, 64, 64)
24.         >>> output = coord_adder(input)
25.         >>> coord_adder = AddCoordinates(True)
26.         >>> input = torch.randn(8, 3, 64, 64).cuda()
27.         >>> output = coord_adder(input)
28.         >>> device = torch.device("cuda:0")
29.         >>> coord_adder = AddCoordinates(True)
30.         >>> input = torch.randn(8, 3, 64, 64).to(device)
31.         >>> output = coord_adder(input)
32.     """
34.     def __init__(self, with_r=False):
35.         self.with_r = with_r
37.     def __call__(self, image):
38.         batch_size, _, image_height, image_width = image.size()
40.         y_coords = 2.0 * torch.arange(image_height).unsqueeze(
41.             1).expand(image_height, image_width) / (image_height - 1.0) - 1.0
42.         x_coords = 2.0 * torch.arange(image_width).unsqueeze(
43.             0).expand(image_height, image_width) / (image_width - 1.0) - 1.0
45.         coords = torch.stack((y_coords, x_coords), dim=0)
47.         if self.with_r:
48.             rs = ((y_coords ** 2) + (x_coords ** 2)) ** 0.5
49.             rs = rs / torch.max(rs)
50.             rs = torch.unsqueeze(rs, dim=0)
51.             coords = torch.cat((coords, rs), dim=0)
53.         coords = torch.unsqueeze(coords, dim=0).repeat(batch_size, 1, 1, 1)
55.         image = torch.cat((coords.to(image.device), image), dim=1)
57.         return image
60. class CoordConv(nn.Module):
62.     r"""2D Convolution Module Using Extra Coordinate Information as defined
63.     in 'An Intriguing Failing of Convolutional Neural Networks and the
64.     CoordConv Solution' (https://arxiv.org/pdf/1807.03247.pdf).
65.     Args:
66.         Same as `torch.nn.Conv2d` with two additional arguments
67.         with_r (bool, optional): If `True`, adds radius (`r`) coordinate
68.             information to input image. Default: `False`
69.     Shape:
70.         - Input: `(N, C_{in}, H_{in}, W_{in})`
71.         - Output: `(N, C_{out}, H_{out}, W_{out})`
72.     Examples:
73.         >>> coord_conv = CoordConv(3, 16, 3, with_r=True)
74.         >>> input = torch.randn(8, 3, 64, 64)
75.         >>> output = coord_conv(input)
76.         >>> coord_conv = CoordConv(3, 16, 3, with_r=True).cuda()
77.         >>> input = torch.randn(8, 3, 64, 64).cuda()
78.         >>> output = coord_conv(input)
79.         >>> device = torch.device("cuda:0")
80.         >>> coord_conv = CoordConv(3, 16, 3, with_r=True).to(device)
81.         >>> input = torch.randn(8, 3, 64, 64).to(device)
82.         >>> output = coord_conv(input)
83.     """
85.     def __init__(self, in_channels, out_channels, kernel_size,
86.                  stride=1, padding=0, dilation=1, groups=1, bias=True,
87.                  with_r=False):
88.         super(CoordConv, self).__init__()
90.         in_channels += 2
91.         if with_r:
92.             in_channels += 1
94.         self.conv_layer = nn.Conv2d(in_channels, out_channels,
95.                                     kernel_size, stride=stride,
96.                                     padding=padding, dilation=dilation,
97.                                     groups=groups, bias=bias)
99.         self.coord_adder = AddCoordinates(with_r)
101.     def forward(self, x):
102.         x = self.coord_adder(x)
103.         x = self.conv_layer(x)
105.         return x

复制代码

seg_model

• 重要包罗conv_bn_relu和SegHead
  
• conv_bn_relu模块包罗一个卷积层、一个BatchNorm层和ReLU激活函数。这些层的目的是将输入张量x进行卷积、BN和ReLU激活操作，并将结果返回。
  
• SegHead模块实现了一个带有分支的分割头。它包括三个分支，它们分别对应于主干网络的差异层级。每个分支都由卷积、BN和ReLU激活函数组成，并使用双线性插值对它们的输出进行上采样。然后它们的输出会被拼接在一起，输入到一个包罗一系列卷积层的组合中。最后，它输出一个张量，其中包罗num_lanes + 1个通道，表示每个车道的掩码以及背景。
  

1. import torch
2. from utils.common import initialize_weights
4. class conv_bn_relu(torch.nn.Module):
5.     def __init__(self,in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1,bias=False):
6.         super(conv_bn_relu,self).__init__()
7.         self.conv = torch.nn.Conv2d(in_channels,out_channels, kernel_size,
8.             stride = stride, padding = padding, dilation = dilation,bias = bias)
9.         self.bn = torch.nn.BatchNorm2d(out_channels)
10.         self.relu = torch.nn.ReLU()
12.     def forward(self,x):
13.         x = self.conv(x)
14.         x = self.bn(x)
15.         x = self.relu(x)
16.         return x
17.         
18. class SegHead(torch.nn.Module):
19.     def __init__(self,backbone, num_lanes):
20.         super(SegHead, self).__init__()
22.         self.aux_header2 = torch.nn.Sequential(
23.             conv_bn_relu(128, 128, kernel_size=3, stride=1, padding=1) if backbone in ['34','18'] else conv_bn_relu(512, 128, kernel_size=3, stride=1, padding=1),
24.             conv_bn_relu(128,128,3,padding=1),
25.             conv_bn_relu(128,128,3,padding=1),
26.             conv_bn_relu(128,128,3,padding=1),
27.         )
28.         self.aux_header3 = torch.nn.Sequential(
29.             conv_bn_relu(256, 128, kernel_size=3, stride=1, padding=1) if backbone in ['34','18'] else conv_bn_relu(1024, 128, kernel_size=3, stride=1, padding=1),
30.             conv_bn_relu(128,128,3,padding=1),
31.             conv_bn_relu(128,128,3,padding=1),
32.         )
33.         self.aux_header4 = torch.nn.Sequential(
34.             conv_bn_relu(512, 128, kernel_size=3, stride=1, padding=1) if backbone in ['34','18'] else conv_bn_relu(2048, 128, kernel_size=3, stride=1, padding=1),
35.             conv_bn_relu(128,128,3,padding=1),
36.         )
37.         self.aux_combine = torch.nn.Sequential(
38.             conv_bn_relu(384, 256, 3,padding=2,dilation=2),
39.             conv_bn_relu(256, 128, 3,padding=2,dilation=2),
40.             conv_bn_relu(128, 128, 3,padding=2,dilation=2),
41.             conv_bn_relu(128, 128, 3,padding=4,dilation=4),
42.             torch.nn.Conv2d(128, num_lanes+1, 1)
43.             # output : n, num_of_lanes+1, h, w
44.         )
46.         initialize_weights(self.aux_header2,self.aux_header3,self.aux_header4,self.aux_combine)
48.         # self.droput = torch.nn.Dropout(0.1)
49.     def forward(self,x2,x3,fea):
50.         x2 = self.aux_header2(x2)
51.         x3 = self.aux_header3(x3)
52.         x3 = torch.nn.functional.interpolate(x3,scale_factor = 2,mode='bilinear')
53.         x4 = self.aux_header4(fea)
54.         x4 = torch.nn.functional.interpolate(x4,scale_factor = 4,mode='bilinear')
55.         aux_seg = torch.cat([x2,x3,x4],dim=1)
56.         aux_seg = self.aux_combine(aux_seg)
57.         return aux_seg

复制代码

未完待续！

来源：https://blog.csdn.net/qq_38915354/article/details/130340073
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！