Send Orders for Reprints to reprints@benthamscience.

ae
Recent Patents on Computer Science 2019, 12, 1-8 1

RESEARCH ARTICLE

Cloning Safe Driving Behavior for Self-Driving Cars using Convolutional

Neural Networks

Wael Farag*

Electrical Engineering Department, American University of the Middle East, Kuwait, Cairo University, Egypt

ARTICLE HISTORY
Received: August 25, 2018
Revised: October 30, 2018
Accepted: October 30, 2018
DOI:
10.2174/2213275911666181106160002
Keywords: Behavioral cloning, convolutional neural network, autonomous driving, machine learning, stochastic gradient de-
scent.
Abstract: In this paper, a Convolutional Neural Network (CNN) to learn safe driving behavior and
smooth steering manoeuvring, is proposed as an empowerment of autonomous driving technologies.
The training data is collected from a front-facing camera and the steering commands issued by an
experienced driver driving in traffic as well as urban roads. This data is then used to train the pro-
posed CNN to facilitate what it is called “Behavioral Cloning”. The proposed Behavior Cloning
CNN is named as “BCNet”, and its deep seventeen-layer architecture has been selected after exten-
sive trials. The BCNet got trained using Adam’s optimization algorithm as a variant of the Stochas-
tic Gradient Descent (SGD) technique. The paper goes through the development and training pro-
cess in details and shows the image processing pipeline harnessed in the development. The proposed
approach proved successful in cloning the driving behavior embedded in the training data set after
extensive simulations.

1. INTRODUCTION
In the past decade, the automobile industry has made a
shift towards intelligent vehicles equipped with driving as-
sistance systems [1, 2], and recently has introduced vision
systems in their high end cars. The vision system (the
mounted cameras in the car including the front-facing ones)
is being utilized by autonomous driving engineers to develop
many of the future self-driving cars features like: a) road-
lane finding; b) free driving-space finding; c) traffic signs
detection and recognition [3, 4]; d) traffic lights detection
and recognition; e) road-objects detection and tracking. In
this paper, it is proposed to use the mounted car vision sys-
tem (more specifically, the front-facing camera) to improve
the safety and the driving behavior of future self-driving
cars.
The main idea is to construct a Convolutional Neural
Network (CNN) that is able to learn the safe driving
manoeuvers from data collected through the driving of an
expert driver in urban roads. The main focus in this paper to
let the proposed CNN to map raw pixels from a single front-
facing camera directly to steering commands of the car. This
an end-to-end approach that lets the car drives without lane
markings on highways and on the roads with unclear visual
guidance such as in parking lots and on unpaved roads [5].
The CNN automatically learns internal representations of the
necessary processing pipeline steps such as detecting useful
*Address correspondence to this author at the Electrical Engineering De-
partment, American University of the Middle East, Kuwait, Cairo Universi-
ty, Egypt; E-mails: wael.farag@aum.edu.kw, wael.farag@cu.edu.eg
2213-2759/19 $58.00+.00
road features with only the human steering angle as the train-
ing signal. In comparison with the explicit decomposition of
the autonomous driving problem into lane-marking detec-
tion, path planning, and control, the proposed end-to-end
CNN optimizes all processing steps simultaneously.
2. THE CNN ARCHITECTURE
The proposed CNN architecture is a seventeen-layer Be-
havior Cloning CNN model is given the name “BCNet”. The
model is coded using Keras [6] on top of Tensorflow [7] in
Python [8]. Fig. (1) illustrates the BCNet architecture as well
as Table I below describes the architecture in details:
Four Drop-out layers are added so as to prevent over-
fitting during training, and the fully connected layers are
widened. Also, No Pooling layers are used here, as it is a
regression problem and not a classification. Additionally, all
the convolutional layers are sized according to the input im-
age sizes after normalization and cropping.
3. THE TRAINING DATA SET
The following are the two main sources of data which are
utilized to construct the training data set that is used to train
the BCNet:
1) Source 1 - Udacity Supplied Data [9]: These collections
with an unzipped size of 365MB consists of 24,108 im-
ages equally divided between center, left and right front
cameras shots. Each image is 160x320 pixels size with 3
channels for RGB colors. The index of the data is stored
in a CSV file which contains 8,036 line of records.
© 2019 Bentham Science Publishers
2 Recent Patents on Computer Science, 2019, Vol. 12, No. 1 Wael Farag

Table I. BCNet Architecture.

#   Layer Size/Output Parameters Comment

1 Input 160x320x3 ------------ Color – 3 Channels RGB

Scaling the inputs => -1 & 1, using Keras

2 Normalization 160x320x3 lambda x: x/127.5 - 1
Lambda function

Cropping the images, cut 70 pixels from the

3 Cropping 65x320x3 = 62,400 The new height will be (160-70) - 25 = 65
top and 25 pixels from the bottom.

No. Filters =24,

Kernel =5x5, No Pooling
4 Convolutional #1 31x159x24
Strides = 2x2, Padding: Valid, Activation = [(W−F+2P)/S]+1
RELU

No. Filters =36,

Kernel =5x5, No Pooling
5 Convolutional #2 14x78x36
Strides = 2x2, Padding: Valid, Activation = [(W−F+2P)/S]+1
RELU

No. Filters =48,

Kernel =5x5, No Pooling
6 Convolutional #3 5x38x48
Strides = 2x2, Padding: Valid, Activation = [(W−F+2P)/S]+1
RELU

No. Filters =64,

Kernel =3x3, No Pooling
7 Convolutional #4 3x36x64
Strides = 1x1, Padding: Valid, Activation = [(W−F+2P)/S]+1
RELU

No. Filters =64,

Kernel =3x3, No Pooling
8 Convolutional #5 1x34x64
Strides = 1x1, Padding: Valid, Activation = [(W−F+2P)/S]+1
RELU

9 Flatten 1x34x64 = 2,176 Keras Flatten Function

Keep Probability:
10 Drop-out 2,176
0.5 => 0.7

11 Fully Connected #1 200 Keras Dense Layer With biases

Keep Probability:
12 Drop-out 200
0.5 => 0.7

13 Fully Connected #2 100 Keras Dense Layer With biases

Keep Probability:
14 Drop-out 100
0.5 => 0.7

15 Fully Connected #3 20 Keras Dense Layer With biases

Keep Probability:
16 Drop-out 20
0.5 => 0.7

17 Fully Connected #4 1 Keras Dense Layer Output layer

2) Source 2 - Simulator Generated Data: collected using the
open source Udacity driving simulator in [10]. The rec-
orded data set has an unzipped size of 808MB and con-
sists of 49,851 images equally divided between center,
left and right front cameras shots. Each image is 160x320
pixels size with 3 channels for RGB colors. The index of
the data is stored in a CSV file which contains 16,617
line of records. The data has been generated by driving
the car manually around Track 1 in the mentioned simu-
lator several times (~ 10 times) with as good as possible
safe driving behavior. Particularly, it is encouraged to in-
clude "recovery" data while training. This means that da-
ta should be captured starting from the point of approach-
ing the edge of the track (perhaps nearly missing a turn
and almost driving off the track) and recording the pro-
cess of steering the car back toward the center of the
track to give the model a chance to learn recovery
behavior.
Cloning Safe Driving Behavior for Self-Driving Cars Recent Patents on Computer Science, 2019, Vol. 12, No. 1 3

C onvolution  # 1   C onvolution  # 2  
31x159x24 C onvolution  # 3  
14x78x36 5x38x48
160x320x3 C ro pp ing  
65x320x3

K ern el:  5x5

K ern el:  5x5 S trid es:  2x2
C onvolution  # 4   C onvolution  # 5   Flatten   K ern el:  5x5 S trid es:  2x2
3x36x64 1x34x64 2176 S trid es:  2x2

O u tp u t
N euro n

D ro p-­‐ o ut  
Dro p-­‐ o ut   Dro p-­‐ o ut   0.7
Dro p-­‐ o ut   0.7 0.5 F ull y  
0.5 C o n nected  20
K ern el:  3x3 F ull y   F ull y  
K ern el:  3x3 S trid es:  1x1 C o n nected  200 C o n nected  100
S trid es:  1x1

Fig. (1). The BCNet Architecture.

Several subroutines have been written for data visualiza-
tion and analysis. This acts as a sort of sanity check to verify
that the preprocessing is not fundamentally flawed. Flawed
data will almost certainly act to confuse the model and result
in unacceptable performance. An Example of the output of
these subroutines is presented in Fig. (2) which displays a
sample of the generated training data (source 2), and Fig. (3)
which presents the histogram of the steering angle values
collected during driving (source 2).
The data (both sources 1 and 2) is divided into 2 separate
parts: training data which represents 80% of the chunk and
validation data which represents 20% of the chunk.
4. DRIVING DATA PRE-PROCESSING
Before using the front cameras images in train-
ing/validation data sets, these images need to be pre-
processed to make more useful and convenient throughout
the learning process. The pre-processing steps meant to im-
prove the training results and reduce the computation as
much as possible, or to find the delicate balance between the
two requirements. The following steps describe the imple-
mented pre-processing steps in order of execution:
1) Normalization (color): this is done for color images using
the “Lambda function” in Keras [6] by simply imple-
menting a min-max scaling. The values of the RGB pix-
els are scaled to the -1 → 1 range and centered on zero
instead of the 0→255 range.
2) Cropping images: The images have been cropped from
the top by 70 pixels and from the bottom by 25 pixels, in
order to focus on the region of interest (ROI) and to re-
duce the number of inputs (faster learning process). The
cropped images have the size of 65x320x3.
3) Flipping images: The data has been doubled (augmented)
by flipping all the images (around the y axis) and revers-
ing the sign of the corresponding steering angle. Accord-
ingly, the source-1 data becomes 48,216 samples, and
source-2 data becomes 99,702 samples. In other words,
each CSV line record can generate 6 training samples
(center, left, right, flipped-center, flipped-left, and
flipped-right). This technique actually serves to balance
the data at both the left and right steering, which removes
the bias or the tendency of the car to steer right or left
due to the exposure to a biased training data (more left
turns than right or vice versa).
4) Jittering images: To minimize the model's tendency to
overfit to the conditions of the test track, images are "jit-
tered" before being fed to the BCNet. The jittering con-
sists of a randomized brightness adjustment, a random-
ized shadow, and a randomized horizon shift. The shad-
ow effect is simply a darkening of a random rectangular
portion of the image, starting at either the left or right
edge and spanning the height of the image. The horizon
shift applies a perspective transform beginning at the
horizon line (at roughly 2/5 of the height) and shifting it
up or down randomly by up to 1/8th of the image height.
The horizon shift is meant to mimic the topology condi-
tions of the test track.
5) Data Distribution Flattening: Because the test track in-
cludes long sections with very slight or no curvature, the
data captured from it tends to be heavily skewed toward
low and zero turning angles. This creates a problem for
the neural network, which then becomes biased toward
driving in a straight line and can become easily confused
by sharp turns. The distribution of the input data can be
observed in Fig. (3). To reduce the occurrence of low and
zero angle data points, a histogram of the turning angles
is produced and the average number of samples per bin is
computed. Next, a "keep probability" for the samples be-
longing to each bin is determined. That keep probability
is 1.0 for bins that contain less than the computed aver-
age samples per bin, and for other bins the “keep proba-
bility” is calculated to be the number of samples for that
bin divided by average samples per bin. Finally, random
data points from the data set are removed with a rate
of (1 – “keep probability”). The resulting data distribu-
tion can be seen in Fig. (4). The distribution is not uni-
form overall, but it is much closer to uniform for lower
and zero turning angles. This method helped speed up the
training process as lower size data is used but with higher
quality.
6) Cleaning the dataset: it is discovered that the model per-
formed poorly especially on certain data points, and then
found those data points to be mislabeled in several cases.
4 Recent Patents on Computer Science, 2019, Vol. 12, No. 1 Wael Farag

A subroutine is created to display frames from the dataset

on which the model performs the worst. The intent was to
manually adjust the steering angles for the mislabeled
frames. Even though this approach is tedious, it helped to
improve the results of the training to some extent.
7) Shuffling the training data: this is done once each train-
ing epoch to avoid pattern memorization and consequent-
ly trapping in local minima.
8) Using generator function to load data in memory [11]:
this step helps a lot to smooth out the training process by
saving the computing resources [12], as it is actually
mandatory. Loading the whole data in the computer
memory was actually not possible (or at least not practi-
cal for huge datasets). Each patch (size = 128 images and
angles) is generated and loaded in memory individually. Fig. (3). The histogram of the steering angles collected during driv-
The fit_generator() function by Keras [11] is used to
ing.
manage the whole process.

Fig. (2). Sample of the collected images: center, left and right re-
spectively.

Finally, the actually used pre-processing pipeline is Col-

or-Image → Normalization → Cropping→ Flipping→ Jitter-
ing → Shuffling → Batch Memory Loading.
It is found out that the above pipeline is fair enough and
produced the required results. For example, some techniques
target speed like “cropping” which substantially reduces the
required time for training by almost 55% (the training dura-
tion is directly proportional with the number of pixels in the
image). Some other techniques target training result im-
provement, but on the expense of the speed, such as “flip-
ping the images” which doubles the training data and the
time as well. The most valuable technique which improves
the results and also reducing the training time is the “data
distribution flattening”. The rest of the techniques add quali-
ty to the result without much overhead like normalization,
jittering, and shuffling the training data. The “cleaning of the
dataset” technique can be avoided especially for huge da-
tasets as it will be impractical, or may be automated.
The implementation of the “generator function to load
data in memory” will help to extend the current training pro-
cess into using giant data sets (100’s of GB) which is a ne-
cessity for putting “behavior cloning” into practice.
However, the following other techniques may be put into
consideration, as it may be needed or for future endeavors:
1) Converting color images to grey: reduces complexity a
lot by reducing the size of training data and the associat-
ed computation to 1/3rd.
2) Incorporating Edge detection and lane finding using
Canny algorithm and Hough transform.
3) Blur-Filtering the input images using Gaussian filtering
to remove noise.
Fig. (4). The histogram of the steering angles after flattening.
5. THE LEARNING ALGORITHM
In this work, Adam learning algorithm [13] is used to
train the proposed BCNet and update its weights iteratively
based on the prepared training driving data. Adam is an op-
timization algorithm that is used instead of the classical sto-
chastic gradient descent (SGD) learning algorithm [14]. The
method computes individual adaptive learning rates for dif-
ferent parameters from estimates of first and second mo-
ments of the gradients.
Adaptive Moment Estimation (ADAM) [13] is a method
that computes adaptive learning rates for each parameter. In
addition to storing an exponentially decaying average of past
squared gradients  !! , Adam also keeps an exponentially de-
caying average of past gradients  !! , similar to momentum:
!! = !! !!!! + (1 − !! )!!
!! = !! !!!! + (1 − !! )!!! (1)
!! and !!  are estimates of the first moment (the mean)
and the second moment (the uncentered variance) of the gra-
dients (!! ) respectively, hence the name of the method. As
!! and !! are initialized as vectors of 0’s, the authors of
Adam observe that they are biased towards zero, especially
Cloning Safe Driving Behavior for Self-Driving Cars Recent Patents on Computer Science, 2019, Vol. 12, No. 1 5

during the initial time steps, and especially when the decay by Fig. (8). For this reason, the learning rate is further re-
rates are small (i.e. β1 and β2 are close to 1). duced and the keep probability increased.
They counteract these biases by computing bias-
corrected first and second moment estimates:
!!
!! =
1 − !!!
!!
!! = (2)
!!!!!

They then use these to update the parameters which yield

the Adam update rule:
!
!!!! = !! − !! (3)
!! !!

for all neural network model's parameters θ ∈ ℝd

Fig. (5). Overview of the CNN in training mode.
(weights and biases) where ! is the learning rate, and ! is a
very small constant prevents divide by zero.
The authors propose default values of 0.9 for β1, 0.999
for β2, and 10-8 for !. They show empirically that Adam
works well in practice and compares favorably to other adap-
tive learning-method algorithms [15].
Fig. (6). Overview of the trainned CNN in running mode.
The output layer of the proposed BCNet is a linear re-
gression function [16]. The network models the system as a
linear combination of features to produce the final estimated Table II. BCNet training parameters (Learning Rate).
output !. The function is given by
!!!!! Algorithm Parameter Value Comment
! = ℎ !, ! = !!! !! !! +! (4)
For epochs: 0 – 5 for data
where xj is the jth input to the output unit and wj is the jth
source 1
weight of the jth input, b is the bias term, N is the number of 0.001
For epochs: 0 – 5 for data
inputs to the output unit (or in other words, the size of the
source 2
previous hidden layer), w is the vector of weights w = [w0, ADAM Learning
w1, … wj, … wN-1], x is the vector of inputs x = [x0, x1, … xj, Optimization Rate For epochs: 6 – 8 for data
0.0005
… xN-1]. source 2
The main task of the training process is to find the For epochs: 8 – 9 for data
weights that provide the most feasible fit for the training 0.0002
source 2
data. One way to measure this fit is to calculate the least
squares error (or the data loss) over the training dataset:
!!!!! !!!!!
Table III. BCNet training parameters (Learning Rate).
! ! =   !!! (ℎ !, !! − !! )! =   !!! (!! − !! )! (5)
Where L is the data loss function that needs to be mini- Parameter Value Comment
mized using Adam’s algorithm, yi is the ith ground truth sam-
ple output, !! is the ith output estimate of the neural net, and Left Angle Correction 0.25 Radians
M is the number of training samples. Then the gradient de-
Right Angle Correction -0.25 Radians
scent will be used on the loss's gradient ∇w L(w) in order to
minimize the overall error on the training data. Using this,
the weights can be updated using the standard gradient de- Table IV. BCNet training parameters (others).
scent:
! = ! − !∇! !(!) (6) Parameter Value Comment
where η is the learning rate. Batch Size 120 For epochs: 0 - 9

6. THE BCNET TRAINING RESULTS Epochs 15 The whole training

The BCNet model is trained using the parameters listed Keep Probability 0.5 → 0.7 For Drop-out Layers
in Tables II, III and IV using ADAM’s optimization algo-
rithm. Fig. (5) shows the setup of the BCNet used during the
training phase, while Fig. (6) shows the setup during the The training of the BCNet has been carried-out through
running and simulation modes. Furthermore, the training several trials to achieve the presented results in Table V. The
results are presented in Table V, Figs. (7 and 8). The state of following observations have been collected during the train-
the model is a bit over-fitting after the training represented ing process:
6 Recent Patents on Computer Science, 2019, Vol. 12, No. 1 Wael Farag

Table V. BCNet training results.

Phase Data Type Loss Value Parameters Comment

5 Epochs
Phase 1 Training : 0.0235 Learning Rate = 0.001 Coarse Tuning with Udacity Data. Not
Source-1 Data
Coarse Tuning Validation: 0.0205 Keep Prob. = 0.5 enough for full learning.
Fig. (7)

5 Epochs
Fine Tuning with self-collected data. Proved
Phase 2 Training : 0.0455 Learning Rate = 0.001
Source-2 Data enough for full learning with acceptable
Fine Tuning Validation: 0.0411 Keep Prob. = 0.5
Performance.
Fig. (8)

3 Epochs
More fine tuning with self-collected data.
Phase 3 Training : 0.0417 Learning Rate = 0.0005
Source-2 Data Caused over-fitting with a kind of inferior
Fine Tuning Validation: 0.0377 Keep Prob. = 0.6
performance.
Fig. (9)

2 Epochs
Phase 4 Training : 0.0348 Learning Rate = 0.0002 More fine tuning with self-collected data. Full
Source-2 Data
Fine Tuning Validation: 0.0295 Keep Prob. = 0.7 learning with very good performance.
Fig. (10)

Fig. (7). Learning progress for data source 1 (Udacity Data).

Fig. (8).Learning progress for data source 2 (Self-Collected).

Cloning Safe Driving Behavior for Self-Driving Cars
Fig. (9). Learning progress for data source 2 (Self-Collected).
Fig. (10). Learning progress for data source 2 (Self-Collected).
1) Training the network using only the “source-1” Udacity
supplied data have been tried several times incorporating
several ways of data augmentation, however, acceptable
results have not been achieved, and the car always hit the
borders.
2) Using the Udacity driving simulator [10], training data
has been collected by manoeuvring the car using a key-
board or a joystick. Accordingly, useful data has been
successfully collected for training by looping the car
around; as an example; “Track 1” several times (~ 10).
3) After coarse tuning the model using the “source-1” data,
the resultant model weights are then reused for further
training and fine-tuning based on the “source-2” data us-
ing ADAM optimizer learning rate of 0.001 as in Table V
and Fig. (8). This matter of coarse and then fine-tuning
resembles the transfer learning approach. Note that the
two types of data are never used together. After this fine
tuning phase, the resultant model is then tested on “Track
1” in the simulator and produces acceptable results (no
unsafe or sudden manoeuvring).
4) In order to improve the performance further, the learning
rate of the ADAM optimizer has been halved to 0.0005
and the model got trained for further 3 epochs. However,
Recent Patents on Computer Science, 2019, Vol. 12, No. 1 7
this results in an over-fitting model as shown in Fig. (9).
Furthermore, the testing confirmed that after producing
inferior performance even with both training and valida-
tion loss are lower than the previous case. Consequently,
this model is set to get further fine-tuning.
5) The learning rate of the ADAM optimizer has been re-
duced further to 0.0002 and keep probability increased to
0.7 and the model got trained for an extra 2 epochs (Fig.
10). The resultant model is then tested on “Track 1” and
produced very good performance.
7. SHORTCOMING OF THE IMPLEMENTED AP-
PROACH
The following list summaries the identified shortcom-
ings:
1) The presented neural network model doesn’t have a
memory, it takes momentarily decision and doesn’t build
on previous states to make the current decision. Howev-
er, It is believed that driving is a sequential process and
the current approach doesn’t mimic that.
2) After training the network on one track and testing it on
another one (considerably different than the first one), it
may produce unacceptable results in some scenarios in
8 Recent Patents on Computer Science, 2019, Vol. 12, No. 1
terms of driving behavior, as it has never gone through
these scenarios before. Accordingly, this approach may
require the network to be exposed to a massive number
of tracks in order to generalize well for actual street de-
ployment (commercial application).
8. SUGGESTED IMPROVEMENTS
The following points summarize the suggested improve-
ments:
1) Other network topologies with a memory like Long
Short-Term Memory (LSTM) models need to be tried for
behavior cloning end-to-end learning.
2) The network needs to be trained on much more tracks,
manoeuvring scenarios and road conditions in order to
make it generalize as much as possible.
3) More useful data can be generated from the current col-
lected data by random distortion addition, brightness ma-
nipulation, jitter and rotation … etc.
4) Applying the concept of a finite impulse response (FIR)
filtering or the moving average concept for the steering
angle estimation before the final steering command, in-
stead of using the raw estimated value directly. In such a
case, the new estimated value will depend on previous
history as well.
CONCLUSION
In this paper, a CNN-based safe steering controller
“BCNet” has been proposed. The architecture of the CNN is
presented in details. The structure of the comprehensive
training, validation and testing data is described. The in-
volved image processing algorithms have been described as
well and their contributions are analyzed. The BCNet has
shown that it is able to learn the entire task of lane and road
following without manual decomposition into road or lane
marking detection, semantic abstraction, path planning, and
control. A small amount of training data from one or two
tracks was sufficient to train the car to drive safely in multi-
ple tracks. The CNN is able to learn meaningful road fea-
tures from a very sparse training signal (steering alone). It
has been shown throughout the training process that the
quality of data (much more than quantity) is specifically cru-
cial for this application. Therefore, a comprehensive pipeline
of training data pre-processing has been carefully imple-
mented.
Moreover, the shortcomings of the proposed approach
have been discussed with proposed improvement actions for
future work being elaborated. The presented solution pre-
Wael Farag
sents a corner stone in facilitating the existence of fully au-
tonomous cars in the near future.
CONSENT FOR PUBLICATION
Not applicable.
CONFLICT OF INTEREST
The authors declare no conflict of interest, financial or
otherwise.
ACKNOWLEDGEMENTS
This work used the HPC facilities of the American Uni-
versity of the Middle East, Kuwait.
REFERENCES
[1] Karim Mansour, Wael Farag, “AiroDiag: A Sophisticated Tool that
Diagnoses and Updates Vehicles Software Over Air”, 2012 IEEE
Intern. Electric Vehicle Conference (IEVC), TD Convention Center
Greenville, SC, USA, March 4, 2012, ISBN: 978-1-4673-1562-3.
[2] Wael Farag, “CANTrack: Enhancing automotive CAN bus security
using intuitive encryption algorithms”, 7th Inter. Conf. on Model-
ing, Simulation, and Applied Optimization (ICMSAO), UAE,
March 2017.
[3] Á. Arcos-García, J.A. Álvarez-García, L.M. Soria-Morillo, “Deep
neural network for traffic sign recognition systems: An analysis of
spatial transformers and stochastic optimisation methods”, Neural
Networks 99 (2018) 158–165, Elsevier.
[4] Wael Farag, Zakaria Saleh, "Traffic Signs Identification by Deep
Learning for Autonomous Driving", IET Smart Cities Symposium
(SCS'18), Bahrain, 22-23 April, 2018.
[5] M Bojarski, D Del Testa, D Dworakowski, B Firner, B Flepp, P
Goyal, ... et al., “End to End Learning for Self-Driving Cars”,
arXiv:1604.07316, 25 Apr 2016.
[6] Keras Documentation, “https://keras.io/”.
[7] TensorFlow, “https://www.tensorflow.org/”.
[8] Python, “https://www.python.org/”
[9] Udacity Sample Training Data, https://d17h27t6h515a5. cloud-
front.net/topher/2016/December/584f6edd_data/data.zip
[10] Udacity Simulator, https://github.com/udacity/self-driving-car-sim
[11] Shervine Amidi, “https://stanford.edu/~shervine/blog/keras-how-
to-generate-data-on-the-fly.html”.
[12] Mina Nagiub, Wael Farag, “Automatic selection of compiler op-
tions using genetic techniques for embedded software design”,
IEEE 14th Inter. Symposium on Comp. Intelligence and Informatics
(CINTI), Budapest, Hungary, 19 Nov., 2013, ISBN: 978-1-4799-
0194-4.
[13] D.P. Kingma, J. Ba, “Adam: A Method for Stochastic Optimiza-
tion”, 3rd Inter. Conf. for Learning Representations, San Diego,
USA, 2015.
[14] Léon Bottou, "Online Algorithms and Stochastic Approximations",
Online Learning and Neural Nets, Cambridge Univ. Press, ISBN
978-0-521-65263-6, (1998).
[15] Sebastian Ruder, “An overview of gradient descent optimization
algorithms”, arXiv:1609.04747v2, 15 Jun 2017.
[16] Wael Farag, “Synthesis of intelligent hybrid systems for modeling
and control”, University of Waterloo, Canada, 1998.