项目步骤如下：¶
- 使用模拟器产生驾驶记录
- 使用keras建立卷积网络模型预测图像的转向角
- 训练校验模型
- 在模拟器中测试模型
1）使用模拟器产生驾驶记录¶
本试验是Udacity的自动驾驶纳米学位第一学期的P3,使用self-driving-car-sim模拟器产生驾驶记录，产生的记录如下，模拟器的使用教程参考Introduction to Udacity Self-Driving Car Simulator
In [1]:
import csv
with open('/home/zzx/imagedata/driving_log.csv') as csvFile:
reader = csv.reader(csvFile)
print(next(reader))
In [2]:
import matplotlib.pyplot as plt
image=plt.imread('/home/zzx/imagedata/IMG/center_2017_11_09_14_28_39_576.jpg')
plt.imshow(image)
plt.show()
1.1）数据预处理¶
In [3]:
import cv2
import csv
import numpy as np
import os
#解析模拟驾驶的日志
def getLinesFromDrivingLogs(dataPath, skipHeader=False):
"""
Returns the lines from a driving log with base directory `dataPath`.
If the file include headers, pass `skipHeader=True`.
"""
lines = []
with open(dataPath + '/driving_log.csv') as csvFile:
reader = csv.reader(csvFile)
if skipHeader:
next(reader, None)
for line in reader:
lines.append(line)
return lines
def findImages(dataPath):
"""
Finds all the images needed for training on the path `dataPath`.
Returns `([centerPaths], [leftPath], [rightPath], [measurement])`
"""
#walk(top, topdown=True, onerror=None, followlinks=False)
#每次遍历的对象都是返回的是一个三元组(root,dirs,files)
#root 所指的是当前正在遍历的这个文件夹的本身的地址
#dirs 是一个 list，内容是该文件夹中所有的目录的名字(不包括子目录)
#files 同样是 list,内容是该文件夹中所有的文件(不包括子目录)
#找到dataPath下的所有目录
directories = [x[0] for x in os.walk(dataPath)]
#filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，
#返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list
dataDirectories = list(filter(lambda directory: os.path.isfile(directory + '/driving_log.csv'), directories))
centerTotal = []
leftTotal = []
rightTotal = []
measurementTotal = []
for directory in dataDirectories:
lines = getLinesFromDrivingLogs(directory)
center = []
left = []
right = []
measurements = []
for line in lines:
measurements.append(float(line[3]))
#这里做了修改，驾驶记录文件里面已经包含来绝对路径
#center.append(directory + '/' + line[0].strip())
center.append(line[0].strip())
#left.append(directory + '/' + line[1].strip())
left.append(line[1].strip())
#right.append(directory + '/' + line[2].strip())
right.append(line[2].strip())
centerTotal.extend(center)
leftTotal.extend(left)
rightTotal.extend(right)
measurementTotal.extend(measurements)
return (centerTotal, leftTotal, rightTotal, measurementTotal)
def combineImages(center, left, right, measurement, correction):
"""
Combine the image paths from `center`, `left` and `right` using the correction factor `correction`
Returns ([imagePaths], [measurements])
"""
imagePaths = []
imagePaths.extend(center)
imagePaths.extend(left)
imagePaths.extend(right)
measurements = []
measurements.extend(measurement)
measurements.extend([x + correction for x in measurement])
measurements.extend([x - correction for x in measurement])
return (imagePaths, measurements)
import sklearn
def generator(samples, batch_size=32):
"""
Generate the required images and measurments for training/
`samples` is a list of pairs (`imagePath`, `measurement`).
"""
num_samples = len(samples)
while 1: # Loop forever so the generator never terminates
samples = sklearn.utils.shuffle(samples)
for offset in range(0, num_samples, batch_size):
batch_samples = samples[offset:offset+batch_size]
images = []
angles = []
for imagePath, measurement in batch_samples:
originalImage = cv2.imread(imagePath,cv2.IMREAD_COLOR)
image = cv2.cvtColor(originalImage, cv2.COLOR_BGR2RGB)
images.append(image)
angles.append(measurement)
# Flipping
#cv2.flip(img,flipcode)翻转图像
#flipcode = 0：沿x轴翻转
#flipcode > 0：沿y轴翻转
#flipcode < 0：x,y轴同时翻转
images.append(cv2.flip(image,1))
angles.append(measurement*-1.0)
# trim image to only see section with road
inputs = np.array(images)
outputs = np.array(angles)
yield sklearn.utils.shuffle(inputs, outputs)
2）使用keras建立卷积网络模型预测图像的转向角¶
In [4]:
from keras.models import Sequential, Model
from keras.layers import Flatten, Dense, Lambda, Convolution2D, Cropping2D
from keras.layers.pooling import MaxPooling2D
import matplotlib.pyplot as plt
def createPreProcessingLayers():
"""
Creates a model with the initial pre-processing layers.
"""
model = Sequential()
model.add(Lambda(lambda x: (x / 255.0) - 0.5, input_shape=(160,320,3)))
#keras.layers.convolutional.Cropping2D(cropping=((0, 0), (0, 0)), data_format=None)
#cropping：长为2的整数tuple，分别为宽和高方向上头部与尾部需要裁剪掉的元素数
model.add(Cropping2D(cropping=((50,20), (0,0))))
return model
def leNetModel():
"""
Creates a LeNet model.
"""
model = createPreProcessingLayers()
model.add(Convolution2D(6,5,5,activation='relu'))
model.add(MaxPooling2D())
model.add(Convolution2D(6,5,5,activation='relu'))
model.add(MaxPooling2D())
model.add(Flatten())
model.add(Dense(120))
model.add(Dense(84))
model.add(Dense(1))
return model
2.2） Nvidia Autonomous Car Group模型¶
In [5]:
def nVidiaModel():
"""
Creates nVidea Autonomous Car Group model
"""
model = createPreProcessingLayers()
model.add(Convolution2D(24,5,5, subsample=(2,2), activation='relu'))
model.add(Convolution2D(36,5,5, subsample=(2,2), activation='relu'))
model.add(Convolution2D(48,5,5, subsample=(2,2), activation='relu'))
model.add(Convolution2D(64,3,3, activation='relu'))
model.add(Convolution2D(64,3,3, activation='relu'))
model.add(Flatten())
model.add(Dense(100))
model.add(Dense(50))
model.add(Dense(10))
model.add(Dense(1))
return model
3）训练模型¶
3.1）训练LeNet模型¶
In [8]:
logdata='/home/zzx/imagedata3'
centerPaths, leftPaths, rightPaths, measurements = findImages(logdata)
imagePaths, measurements = combineImages(centerPaths, leftPaths, rightPaths, measurements, 0.5)
print('Total Images: {}'.format( len(imagePaths)))
# Splitting samples and creating generators.
from sklearn.model_selection import train_test_split
samples = list(zip(imagePaths, measurements))
train_samples, validation_samples = train_test_split(samples, test_size=0.2)
print('Train samples: {}'.format(len(train_samples)))
print('Validation samples: {}'.format(len(validation_samples)))
train_generator = generator(train_samples, batch_size=512)
validation_generator = generator(validation_samples, batch_size=512)
model = leNetModel()
# Compiling and training the model
model.compile(loss='mse', optimizer='adam')
history_object = model.fit_generator(train_generator, samples_per_epoch= \
len(train_samples), validation_data=validation_generator, \
nb_val_samples=len(validation_samples), nb_epoch=20, verbose=1)
model.save('lenet_model.h5')
print(history_object.history.keys())
print('Loss')
print(history_object.history['loss'])
print('Validation Loss')
print(history_object.history['val_loss'])
plt.plot(history_object.history['loss'])
plt.plot(history_object.history['val_loss'])
plt.title('model mean squared error loss')
plt.ylabel('mean squared error loss')
plt.xlabel('epoch')
plt.legend(['training set', 'validation set'], loc='upper right')
plt.show()
3.2）训练 Nvidia Autonomous Car Group模型¶
In [6]:
logdata='/home/zzx/imagedata3'
centerPaths, leftPaths, rightPaths, measurements = findImages(logdata)
imagePaths, measurements = combineImages(centerPaths, leftPaths, rightPaths, measurements, 0.5)
print('Total Images: {}'.format( len(imagePaths)))
# Splitting samples and creating generators.
from sklearn.model_selection import train_test_split
samples = list(zip(imagePaths, measurements))
train_samples, validation_samples = train_test_split(samples, test_size=0.2)
print('Train samples: {}'.format(len(train_samples)))
print('Validation samples: {}'.format(len(validation_samples)))
train_generator = generator(train_samples, batch_size=1028)
validation_generator = generator(validation_samples, batch_size=1028)
model = nVidiaModel()
# Compiling and training the model
model.compile(loss='mse', optimizer='adam')
history_object = model.fit_generator(train_generator, samples_per_epoch= \
len(train_samples), validation_data=validation_generator, \
nb_val_samples=len(validation_samples), nb_epoch=20, verbose=1)
model.save('nVidia_model.h5')
print(history_object.history.keys())
print('Loss')
print(history_object.history['loss'])
print('Validation Loss')
print(history_object.history['val_loss'])
plt.plot(history_object.history['loss'])
plt.plot(history_object.history['val_loss'])
plt.title('model mean squared error loss')
plt.ylabel('mean squared error loss')
plt.xlabel('epoch')
plt.legend(['training set', 'validation set'], loc='upper right')
plt.show()
5）结论¶
LeNet的效果不好，大部分的时候都掉进沟里去了，Nvidia Autonomous Car Group模型两个场景都跑的挺好，但是由于第一个场景的数据相对少，所以稍微不稳定。
In [ ]: