In [1]:
# Configure matlab to show graphics in the notebook
%matplotlib inline
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
In [2]:
# Change to 'data' when training on a GPU
PATH_TO_UDACITY_DATA = 'data'
PATH_TO_TRAIN_DATA = 'train'
PATH_TO_VALID_DATA = 'valid'
PATH_TO_TEST_DATA = 'test'
In [3]:
# Shape of the image
input_shape = (66, 200, 3)
In [4]:
def img_folder(data_folder):
return '{}/IMG'.format(data_folder)
def path_driving_log(data_folder):
return '{}/driving_log.csv'.format(data_folder)
In [5]:
datasets = ['train', 'test', 'valid']
In [6]:
def get_driving_log_dataframe(data_folder):
driving_log_df = pd.read_csv(path_driving_log(data_folder))
return driving_log_df
In [7]:
!pip install imutils
In [8]:
import cv2
import imutils
In [9]:
get_driving_log_dataframe(PATH_TO_TRAIN_DATA)['steering'].min()
Out[9]:
In [10]:
from scipy.ndimage import imread
from os import listdir
from sklearn.utils import shuffle
from PIL import Image
import math
def get_weight(label):
return math.exp(abs(label))
def left_center_right_generator(data_folder, batch_size=64):
driving_log_df = get_driving_log_dataframe(data_folder)
number_of_examples = len(driving_log_df)
image_columns = ['center', 'left', 'right']
X_train = []
y_train = []
weights = []
index_in_batch = 0
batch_number = 0
angle_offset = 0.2
while True:
for image_column in image_columns:
image_series = driving_log_df[image_column]
steering_series = driving_log_df['steering']
for offset in range(0, number_of_examples, batch_size):
X_train = []
y_train = []
weights = []
end_of_batch = min(number_of_examples, offset + batch_size)
for j in range(offset, end_of_batch):
image_filename = image_series[j].lstrip().rstrip()
image = Image.open('{0}/{1}'.format(data_folder, image_filename))
image = image.convert('YCbCr')
image_np = np.asarray(image.resize((200, 66)))
label = steering_series[j]
if image_column == 'left':
delta_steering = -angle_offset
elif image_column == 'right':
delta_steering = angle_offset
else:
delta_steering = 0
label = label + delta_steering
X_train.append(image_np)
y_train.append(label)
weights.append(get_weight(label))
flipped_image = cv2.flip(image_np, 1)
flipped_label = -label
X_train.append(flipped_image)
y_train.append(flipped_label)
weights.append(get_weight(flipped_label))
X_train, y_train, weights = shuffle(X_train, y_train, weights)
yield np.array(X_train), np.array(y_train), np.array(weights)
In [11]:
def center_only_generator(data_folder, batch_size=64):
driving_log_df = get_driving_log_dataframe(data_folder)
number_of_examples = len(driving_log_df)
X_train = []
y_train = []
weights = []
index_in_batch = 0
batch_number = 0
angle_offset = 0.2
while True:
image_series = driving_log_df['center']
steering_series = driving_log_df['steering']
for offset in range(0, number_of_examples, batch_size):
X_train = []
y_train = []
weights = []
end_of_batch = min(number_of_examples, offset + batch_size)
for j in range(offset, end_of_batch):
image_filename = image_series[j].lstrip().rstrip()
image = Image.open('{0}/{1}'.format(data_folder, image_filename))
image = image.convert('YCbCr')
image_np = np.asarray(image.resize((200, 66)))
label = steering_series[j]
X_train.append(image_np)
y_train.append(label)
weights.append(get_weight(label))
flipped_image = cv2.flip(image_np, 1)
flipped_label = -label
X_train.append(flipped_image)
y_train.append(flipped_label)
weights.append(get_weight(flipped_label))
X_train, y_train, weights = shuffle(X_train, y_train, weights)
yield np.array(X_train), np.array(y_train), np.array(weights)
In [12]:
X, y, w = next(left_center_right_generator(PATH_TO_UDACITY_DATA))
In [13]:
plt.imshow(X[0])
Out[13]:
In [14]:
X, y, w = next(center_only_generator(PATH_TO_UDACITY_DATA))
In [15]:
plt.imshow(X[0])
print(w[0])
In [16]:
from keras.models import Sequential
from keras.layers import BatchNormalization
from keras.layers import Dense
from keras.layers import Convolution2D
from keras.layers import Flatten
from keras.layers import Dropout
from keras.layers import Lambda
In [25]:
from keras.regularizers import l2, activity_l2
model = Sequential()
regularization_coef = 10e-7
model.add(Lambda(lambda x: x/255.0,
input_shape=input_shape))
model.add(Convolution2D(24,
5, 5,
subsample=(2, 2),
init='he_normal',
W_regularizer=l2(regularization_coef), activity_regularizer=activity_l2(regularization_coef)))
model.add(BatchNormalization())
model.add(Convolution2D(36,
5, 5,
subsample=(2, 2),
init='he_normal',
W_regularizer=l2(regularization_coef), activity_regularizer=activity_l2(regularization_coef)))
model.add(BatchNormalization())
model.add(Convolution2D(48,
5, 5,
subsample=(2, 2),
init='he_normal',
W_regularizer=l2(regularization_coef), activity_regularizer=activity_l2(regularization_coef)))
model.add(BatchNormalization())
model.add(Dropout(0.2))
model.add(Convolution2D(64,
3, 3,
init='he_normal',
W_regularizer=l2(regularization_coef), activity_regularizer=activity_l2(regularization_coef)))
model.add(BatchNormalization())
model.add(Dropout(0.3))
model.add(Convolution2D(64,
3, 3,
init='he_normal',
W_regularizer=l2(regularization_coef), activity_regularizer=activity_l2(regularization_coef)))
model.add(BatchNormalization())
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(100, activation='relu', init='he_normal'))
model.add(Dense(50, activation='relu', init='he_normal'))
model.add(Dense(10, activation='relu', init='he_normal'))
model.add(Dense(1, init='he_normal'))
In [26]:
model.summary()
In [27]:
from keras.callbacks import ModelCheckpoint
filepath="weights-improvement-{epoch:02d}.hdf5"
checkpoint = ModelCheckpoint(filepath)
callbacks_list = [checkpoint]
In [28]:
from keras.optimizers import Adam
adam = Adam(lr=10e-4)
In [29]:
model.compile(optimizer=adam,
loss='mse',
metrics=['mean_squared_error'])
In [24]:
image_generator = left_center_right_generator(PATH_TO_UDACITY_DATA)
validation_generator = center_only_generator(PATH_TO_VALID_DATA)
samples = len(get_driving_log_dataframe(PATH_TO_UDACITY_DATA)) * 3 * 2
nb_val_samples = len(get_driving_log_dataframe(PATH_TO_VALID_DATA))
model.fit_generator(image_generator,
samples_per_epoch=samples,
nb_epoch=20,
callbacks=callbacks_list,
validation_data=validation_generator,
nb_val_samples=nb_val_samples)
Out[24]:
In [37]:
test_generator = center_only_generator(PATH_TO_TEST_DATA)
samples = len(get_driving_log_dataframe(PATH_TO_TEST_DATA))
model.evaluate_generator(test_generator, samples)
Out[37]:
In [30]:
image_generator = center_only_generator(PATH_TO_TRAIN_DATA)
validation_generator = center_only_generator(PATH_TO_VALID_DATA)
samples = len(get_driving_log_dataframe(PATH_TO_TRAIN_DATA)) * 2
nb_val_samples = len(get_driving_log_dataframe(PATH_TO_VALID_DATA))
model.fit_generator(image_generator,
samples_per_epoch=samples,
nb_epoch=20,
callbacks=callbacks_list,
validation_data=validation_generator,
nb_val_samples=nb_val_samples)
Out[30]:
In [31]:
model_json = model.to_json()
with open("model.json", "w") as json_file:
json_file.write(model_json)
# serialize weights to HDF5
model.save_weights("model.h5")
model.save("trained_model.h5")
In [45]:
y_val
Out[45]:
In [1]:
from keras.models import load_model
loaded_model = load_model("trained_model.h5")
In [26]:
image_generator = left_ce(PATH_TO_DATA)
samples = len(get_driving_log_dataframe(PATH_TO_DATA))
loaded_model.fit_generator(image_generator,
samples_per_epoch=samples,
nb_epoch=10,
callbacks=callbacks_list)
Out[26]:
In [ ]: