百度Apollo无人车车道线检测挑战赛（一）

百度Apollo车道线分割比赛一（数据处理）

百度Apollo车道线分割比赛二（模型搭建）
百度Apollo车道线分割比赛三（模型训练）
完整代码：Github

百度Apollo车道线检测比赛用的数据集是百度自己制作的数据集，数据集是像素级的标注，比tusimple的数据集要更加精准，下图为原图和标签，数据集下载地址

百度比赛要求采用百度自己的深度学习框架飞浆（paddlepadle）实现，比赛前35名方案
本方案采用pytorch实现，且采用复赛的数据集，标签为灰度值图像。
本实现数据集处理为实时预处理的形式，这样可以节省内存空间，特别使用服务器去训练时会场方便，首先下载复赛的数据集，包含样本和灰度值的标签。
实时预处理的思路很简单，将数据集的样本和标签映射到csv文件中，训练时按照csv的顺序去读取样本，并且处理好送到训练的模型。

***第一步***将下载的数据集映射到csv文件。处理文件utils.make_list.py，代码如下：

#coding=utf-8
#@author : Jiangnan He
#@date : 2019.12.25 15:47

"""
img_process 生成的文件结构如下：
--train_set :D:\Dataset\Apollolaneline\train_set   - gt_image
                                                   - src_image

-- test_set :D:\Dataset\Apollolaneline\test_set     - src_image
"""
import pandas as pd
import os
from sklearn.utils import shuffle
import glob
# train_set 共有21914 个样本 我们按照 train：val：test=3:1：1 的比例划分 训练集和 验证集 测试集
datasetpath1=datasetpath='D:/Dataset/Apollolaneline/'
#================================================
# make train & validation & test lists
#================================================
def get_train_val_test():
    img_list=[]
    lab_list=[]
    for file in glob.glob(str(datasetpath1)+"/Road*/"):
        if file.find("zip")!=-1:
            continue
        for i in glob.glob(str(file)+"/ColorImage_road*"):
                file1=os.path.join(datasetpath1,i,"ColorImage")
                for j in os.listdir(file1):
                    path=os.path.join(file1,j)
                    for k in os.listdir(path):
                        path1=os.path.join(path,k)
                        print(path1,len(os.listdir(path1)))
                        for z in os.listdir(path1):
                            image_path=os.path.join(path1,z)
                            #样本D:\Dataset\Apollolaneline\Road02\ColorImage_road02\ColorImage\Record001\Camera 5\170927_063811892_Camera_5.jpg
                            #标签D:\Dataset\Apollolaneline\Gray_Label\Gray_Label\Label_road02\Label\Record001\Camera 5\170927_063811892_Camera_5_bin.png
                            print(image_path,"image_path")
                            image_name=str(image_path.split()[1]).split('\\')[1].split(".")[0]+'_bin.png'
                            print("image_name",image_name)
                            #获取src_img 文件地址
                            src_path=os.path.join(path1,z)
                            # 获取gt_img 文件地址
                            gt_path=os.path.join("D:/Dataset/Apollolaneline/Gray_Label/Gray_Label/","Label_"+str(image_path.split("\\")[2]).split("_")[1],"Label","/".join(image_path.split("\\")[4:6]),image_name)
                            img_list.append(src_path)
                            lab_list.append(gt_path)
    assert len(img_list)==len(lab_list)
    total_len=len(img_list)
    six_part=int(total_len*0.6)
    eight_part=int(total_len*0.8)
    all=pd.DataFrame({'image': img_list, 'label': lab_list})
    all_shuffle = shuffle(all)  # 顺序打乱存储
    train_list=all_shuffle[:six_part]
    val_list=all_shuffle[six_part:eight_part]
    test_list=all_shuffle[eight_part:]
    #生成val.csv
    train_list.to_csv('../data_list/train.csv', index=False)#生成val的数据集csv文件
    # 生成train.csv
    val_list.to_csv('../data_list/val.csv', index=False)#生成train的数据集csv文件
    #生成test.csv
    test_list.to_csv('../data_list/test.csv', index=False)  # 生成test的数据集csv文件

if __name__=="__main__":
    get_train_val_test()

运行make_list.py将生成3个list文件，分别为train.csv, val.csv,test.csv
csv文件为一个字典 键“image”，“label”，一一对应样本标签的存储地址，如下图

***第二步***样本标签处理：

1.样本处理：尺寸，颜色随机变换，添加高斯噪声，随机剪裁cutout（类似dropout），pytorch有很多样本增强工具，例如apex，torchvision.transform,opencv,PIL(轻量级)，albumentations，imgaug，numpy,这里用的opencv 增强方式较为简单，因为数据集较大，没有对数据量扩充。

2.标签处理：尺寸，旋转变化时要求和样本处理同步。处理文件utils.img_process.py，处理代码如下：

#coding: utf-8
#@author jiangnan He
#@date: 15:00 2019.11.13
'''
APollo laneline dataset
'''
###############################  config ##########################
#原图尺寸3384x1710 wh
#这里采用三种尺寸进行训练 768x256,1024x384,1536x512（wh）
imgH=384
imgW=1024
offset=690
###############################################################
import numpy as np
import cv2
import torch
def gamma_transform(img, gamma):#gamma变换
    gamma_table = [np.power(x / 255.0, gamma) * 255.0 for x in range(256)]
    gamma_table = np.round(np.array(gamma_table)).astype(np.uint8)
    return cv2.LUT(img, gamma_table)

def random_gamma_transform(img, gamma_vari):
    log_gamma_vari = np.log(gamma_vari)
    alpha = np.random.uniform(-log_gamma_vari, log_gamma_vari)
    gamma = np.exp(alpha)
    return gamma_transform(img, gamma)

def rotate(xb,yb, angle):#旋转变换
    M_rotate = cv2.getRotationMatrix2D((imgH/2, imgW/2), angle, 1)
    xb = cv2.warpAffine(xb, M_rotate, (imgH , imgW ))
    yb = cv2.warpAffine(yb, M_rotate, (imgH , imgW ))
    return xb, yb

def blur(img):
    img = cv2.blur(img, (3, 3))
    return img

def add_noise(img):
    for i in range(200):  # 添加点噪声
        temp_x = np.random.randint(0, img.shape[0])
        temp_y = np.random.randint(0, img.shape[1])
        img[temp_x][temp_y] = 255
    return img

def data_augment(xb, yb):#样本增强函数
    if np.random.random() < 0.25:#只对原图操作
        xb = random_gamma_transform(xb, 1.0)
    if np.random.random() < 0.25:#只对原图操作
        xb = blur(xb)
    if np.random.random() < 0.2:#只对原图操作
        xb = add_noise(xb)
    return xb, yb
class Process_dataset(object):
    def __call__(self,sample):
        image, mask=sample
        src_img=image[offset:,:]#hw
        gt_img =mask[offset:,:]  #先将 原图上部分的填空部分 3384x690 剪裁掉
        #1 图像尺度处理 将图像缩放到训练尺寸  这里采用三种尺寸进行训练 768x256,1024x384,1536x512（wh）
        src_img = cv2.resize(src_img,
                               dsize=(imgW, imgH),
                               interpolation=cv2.INTER_LINEAR)
        gt_img = cv2.resize(gt_img,
                                      dsize=(imgW, imgH),
                                    interpolation=cv2.INTER_NEAREST)#  样本图片缩放用双线性插值，标签尺寸缩放时用最近邻处理，双线性插值将产生浮点型标注
        #样本增强
        src_img,gt_img=data_augment(src_img,gt_img)
        return src_img,gt_img

class ToTensor(object):#将样本numpy格式转为pytorch的tensor
    def __call__(self,sample ):
        image, mask=sample
        image = np.transpose(image,(2,0,1))
        image = image.astype(np.float32)
        mask = mask.astype(np.uint8)
        return torch.from_numpy(image.copy()),  torch.from_numpy(mask.copy())



# crop the image to discard useless parts 测试时用到这个函数
def crop_resize_data(image, label=None, image_size=(1024, 384), offset=690):
    """
    Attention:
    h,w, c = image.shape
    cv2.resize(image,(w,h))
    """
    roi_image = image[offset:, :]
    if label is not None:
        roi_label = label[offset:, :]
        train_image = cv2.resize(roi_image, image_size, interpolation=cv2.INTER_LINEAR)
        train_label = cv2.resize(roi_label, image_size, interpolation=cv2.INTER_NEAREST)
        return train_image, train_label
    else:
        train_image = cv2.resize(roi_image, image_size, interpolation=cv2.INTER_LINEAR)
        return train_image

***第三步***标签编码，将label中不同灰度值（代表不同类别的车道线），用0-7去标注，这里没有直接处理成one-hot形式，后面模型计算loss时会根据需要去看是否需要处理成one-hot形式
处理文件utils.lab_process.py，处理代码如下

#coding=utf-8
#@author : Jiangnan He
#@data ：  2019.12.25 20：00
import numpy as np
def encode_labels(color_mask):#编码  灰度值转为类别  0-7
    encode_mask = np.zeros((color_mask.shape[0], color_mask.shape[1]))
    # 0
    encode_mask[color_mask == 0] = 0
    encode_mask[color_mask == 249] = 0
    encode_mask[color_mask == 255] = 0
    # 1
    encode_mask[color_mask == 200] = 1
    encode_mask[color_mask == 204] = 1
    encode_mask[color_mask == 213] = 0
    encode_mask[color_mask == 209] = 1
    encode_mask[color_mask == 206] = 0
    encode_mask[color_mask == 207] = 0
    # 2
    encode_mask[color_mask == 201] = 2
    encode_mask[color_mask == 203] = 2
    encode_mask[color_mask == 211] = 0
    encode_mask[color_mask == 208] = 0
    # 3
    encode_mask[color_mask == 216] = 0
    encode_mask[color_mask == 217] = 3
    encode_mask[color_mask == 215] = 0
    # 4 In the test, it will be ignored
    encode_mask[color_mask == 218] = 0
    encode_mask[color_mask == 219] = 0
    # 4
    encode_mask[color_mask == 210] = 4
    encode_mask[color_mask == 232] = 0
    # 5
    encode_mask[color_mask == 214] = 5
    # 6
    encode_mask[color_mask == 202] = 0
    encode_mask[color_mask == 220] = 6
    encode_mask[color_mask == 221] = 6
    encode_mask[color_mask == 222] = 6
    encode_mask[color_mask == 231] = 0
    encode_mask[color_mask == 224] = 6
    encode_mask[color_mask == 225] = 6
    encode_mask[color_mask == 226] = 6
    encode_mask[color_mask == 230] = 0
    encode_mask[color_mask == 228] = 0
    encode_mask[color_mask == 229] = 0
    encode_mask[color_mask == 233] = 0
    # 7
    encode_mask[color_mask == 205] = 7
    encode_mask[color_mask == 212] = 0
    encode_mask[color_mask == 227] = 7
    encode_mask[color_mask == 223] = 0
    encode_mask[color_mask == 250] = 7
    return encode_mask

***第四步***生成数据集，运行文件create_data.py，代码如下：

# coding=utf-8
# @author：Jiangnan He
# @date： 2019.12.25 18:54
# 本实现用于生成 pytorch 的数据集

import torch
import pandas as pd
from torchvision import transforms
from torch.utils.data.dataset import Dataset
from utils.lab_process import encode_labels
from utils.img_process import Process_dataset
from utils.img_process import ToTensor
import cv2


class DatasetFromCSV(Dataset):
    def __init__(self, csv_path, transforms=None):
        self.data = pd.read_csv(csv_path,header=None, names=["image","label"])
        self.images = self.data["image"].values[1:]
        self.labels = self.data["label"].values[1:]
        self.transforms = transforms

    def __len__(self):
        return self.labels.shape[0]

    def __getitem__(self, index):
        image=self.images[index]
        label=self.labels[index]
        image=cv2.imread(image,cv2.IMREAD_COLOR)
        lab_as_np=cv2.imread(label, cv2.IMREAD_GRAYSCALE)
        label=encode_labels(lab_as_np)#将不同灰度值标记为不同类 # 后续需要将其转为one-hot编码
        sample=[image,label]
        img_as_tensor ,lab_as_tensor= self.transforms(sample)
        return img_as_tensor, lab_as_tensor
    
#测试代码
if __name__=="__main__":
    batch_size =2
    transform = transforms.Compose([Process_dataset(),ToTensor()] )
    train_data = DatasetFromCSV('../data_list/train.csv',transform)
    val_data = DatasetFromCSV('../data_list/val.csv', transform)
    test_data = DatasetFromCSV("../data_list/test.csv",transform)
    train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size)
    val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size)
    test_loader = torch.utils.data.DataLoader(test_data, batch_size=batch_size)
    for batch in train_loader:
         img, lab = batch
         lab=torch.unsqueeze(lab,1)
         print(img.shape,lab.shape)

其中DatasetFromCSV，继承了pytorch的Dataset的类制作自己的数据集只需要重写这个类的__len__(),和__getitem__()两个函数即可，transform就是我们预处理样本的函数组合加上ToTensro函数，这样才能完整将样本处理成pytorch能够接受的Tensor
运行测试代码效果如下：