车辆行为克隆

说是行为克隆，听着高大上，其实原理很简单。挂载在车盖上的摄像头拍摄一张图片，网络对其进行回归预测，输出车轮转向角。最终目标就是使模拟器中的小车可以自己开，不能超出车道线。

训练数据就是好多好多张车辆运行中摄像头拍摄的图片，而label就是各个图片对应的车轮转向角，为[-25,25]中的值。

原理都很简单，主要是我第一次是用的keras搭建的网络，并且使用generator来生成训练数据，主要记录这些内容。

网络结构

使用的是NVIDIA发表的一篇端到端自动驾驶论文中的网络结构，网络功能很强大，对于这个小项目绰绰有余了。网络为五层卷积后接四层全连接，因为只预测转向角，所以输出只有一个神经元。另外，在第一层卷积之前有两个预处理步骤：1.因为摄像头拍摄的范围还是挺大的，对于图像中天空这一部分是不需要的，所以给它裁掉。还有摄像头还会拍到一点车盖，这个给它裁掉。输入图像是(160,320,3)，我看了下，上面裁60行，下面裁20行就可以。2.之后对输入normalize一下，这里只是简单的除以255后减去0.5而已。

from keras.models import Sequential
from keras.layers import Flatten, Dense, Lambda, Dropout
from keras.layers.convolutional import Conv2D, Cropping2D
from keras.layers.pooling import MaxPooling2D

conv_trainable = True

model = Sequential()
model.add(Cropping2D(cropping=((60,20),(0,0)), input_shape=(160,320,3)))
model.add(Lambda(lambda x: x / 255.0 - 0.5))

model.add(Conv2D(24,(5,5),strides=(2,2),activation='relu', trainable=conv_trainable))
model.add(Conv2D(36,(5,5),strides=(2,2),activation='relu', trainable=conv_trainable))
model.add(Conv2D(48,(5,5),strides=(2,2),activation='relu', trainable=conv_trainable))
model.add(Conv2D(64,(3,3),activation='relu', trainable=conv_trainable))
model.add(Conv2D(64,(3,3),activation='relu', trainable=conv_trainable))

model.add(Flatten())
# 我训练的epoch不多，还没过拟合，所以没用dropout
# model.add(Dropout(0.5))
model.add(Dense(100,activation='relu'))
# model.add(Dropout(0.6))
model.add(Dense(50,activation='relu'))
model.add(Dense(10,activation='relu'))
model.add(Dense(1))

model.compile(loss='mse', optimizer='adam')
model.summary()

对于结构这么简单的网络，使用keras可是太方便了！

训练数据

训练数据是好多好多图片，shape为(160,320,3)。所有图片的信息都存在一个csv文件中，csv文件的每一行包括车上三个摄像头拍摄图片的地址(中，左，右)，和此时车轮的转向角。

在训练之前先要做个data augment。我只是对每张图片都翻转一下。翻转后要记录新的图片地址和取了负值的转向角，然后更新原来的csv文件。下面代码完成这个操作：

import csv
import cv2
import numpy as np

# 本代码由于augment data，对于所有图片左右翻转下
# 方法是通过csv文件中的地址分别读取图片，翻转图片，存储新图片，如此循环
# 在该过程中记录新图片地址，最后更新csv文件。
new_csv = []
with open('./driving_log.csv', 'r') as csvfile:
    reader = csv.reader(csvfile)
    # 注意line中所有数据都是字符串形式
    for line in reader:
        for i in range(3):
            # 防止地址前后有空格，没有什么特殊的含义
            path = line[i].strip()
            img = cv2.imread(path)
            img = cv2.flip(img, 1)
            # 翻转后图片的新名字
            new_path = path.split('.jpg')[0] + '_r.jpg'
            cv2.imwrite(new_path, img)
            line[i] = new_path
        # 因为翻转了，所以左图右图互换
        line[1],line[2] = line[2], line[1]
        line[3] = str(-1.0 * float(line[3]))
        # 把新的信息存到列表里，后面更新csv文件
        new_csv.append(line)

# 用open以写方式打开csv文件需要指定newline=''
# 不然，写的行与行之间会多一个空行
with open('./driving_log.csv', 'a', newline='') as csvfile:
    writer = csv.writer(csvfile)
    writer.writerows(new_csv)

下面代码读入csv文件，提取出每一行，shuffle后，分类训练、验证集。

lines = []
with open('./driving_log.csv') as csvfile:
    # reader为一生成器
    reader = csv.reader(csvfile)
    for line in reader:
        lines.append(line)

# sklearn的工具还是很好用的
from sklearn.utils import shuffle
lines = shuffle(lines)

from sklearn.model_selection import train_test_split
# 注意这种分法没有完全分开同一时刻左中右三个摄像头拍摄的图片
train_samples, validation_samples = train_test_split(lines, test_size=0.2)

这时训练数据我记得是好五六万张吧。一次都读进内存电脑课吃不消。所以每训练一个batch再从硬盘中读一个batch的图片。所以这里shuffle的只是图片的地址，到时候根据地址读图片就好了。

使用生成器训练网络

需要构造一个生成器，在训练时传入到model.fit_generator中，生成器每次返回一个batch的数据。

# samples接收的就是保存了地址的列表
# 返回的batch全部在samples中。
def generator(samples, batch_size=32):
    num_samples = len(samples)
    # 要不断生成数据，所以无限循环
    while 1:
        # 每次大循环完该samples，也就是一个epoch，都shuffle下整个数据集
        shuffle(samples)
        # 在该for中每次yeild一个batch数据
        for offset in range(0, num_samples, batch_size):
            batch_samples = samples[offset:offset+batch_size]
            images = []
            labels = []

            for batch_sample in batch_samples:
                # 这里使用了左中右三个摄像头的图片
                # 所以yeild的真正的数据量为batch*3
                for i in range(3):
                    # stip就是防止地址前后的空格
                    # 读不到图片imread可不会报错
                    image = cv2.imread(batch_sample[i].strip())
                    images.append(image)
                label = float(batch_sample[3])
                label_left = label + correction
                label_right = label - correction
                labels.extend([label, label_left, label_right])

            X_train = np.array(images)
            y_train = np.array(labels)
            # 这个shuffle我感觉没太大用
            yield shuffle(X_train, y_train)

上面只是生成器的定义，下面，要建立训练集和验证集的生成器对象，分别传入之前分割好的列表即可：

batch_size = 16
train_generator = generator(train_samples, batch_size=batch_size)
validation_generator = generator(validation_samples, batch_size=batch_size)

这两个生成器就是用于model.fit_generator()中的了。

训练！

直接调用model.fit_generator就好：

# 每一个epoch都保存一个模型
# 所以设置model.fit_generator中的epochs参数为1
# 并在循环中调用
# 每次fit结束后就保持模型。
for i in range(5):
    history_object = model.fit_generator(generator = train_generator,
                                     steps_per_epoch = int(len(train_samples)/batch_size),
                                     epochs = 1,
                                     validation_data = validation_generator,
                                     validation_steps = int(len(validation_samples)/batch_size))

    model.save('./model_%d.h5'%i)

用keras可太方便了，这要是用tensorflow可费劲了。

上面说这个网络结构强大是有原因的，一开始我搭建网络的时候忘记指定全连接层的转移函数了！！！所以这四层全连接就相当于一层线性层，但是，就算是这样，使用第4个epoch之后得到的模型，小车也能非常稳定的开。。。