5324 IEEE TRANSACTIONS ON NEURAL NETWORKS AND LEARNING SYSTEMS, VOL. 31, NO.
12, DECEMBER 2020
Hybrid Deep Learning-Gaussian Process
Network for Pedestrian Lane Detection
in Unstructured Scenes
Thi Nhat Anh Nguyen , Son Lam Phung , Senior Member, IEEE,
and Abdesselam Bouzerdoum , Senior Member, IEEE
Abstract— Pedestrian lane detection is an important task in
many assistive and autonomous navigation systems. This arti-
cle presents a new approach for pedestrian lane detection in
unstructured environments, where the pedestrian lanes can have
arbitrary surfaces with no painted markers. In this approach,
a hybrid deep learning-Gaussian process (DL-GP) network is pro-
posed to segment a scene image into lane and background regions.
The network combines a compact convolutional encoder–decoder
net and a powerful nonparametric hierarchical GP classifier. The
resulting network with a smaller number of trainable parameters
helps mitigate the overfitting problem while maintaining the
modeling power. In addition to the segmentation output for each
test image, the network also generates a map of uncertainty—a
measure that is negatively correlated with the confidence level
with which we can trust the segmentation. This measure is
important for pedestrian lane-detection applications, since its
prediction affects the safety of its users. We also introduce a new
data set of 5000 images for training and evaluating the pedestrian
lane-detection algorithms. This data set is expected to facilitate
research in pedestrian lane detection, especially the application
of DL in this area. Evaluated on this data set, the proposed
network shows significant performance improvements compared
with several existing methods.
Index Terms— Assistive and autonomous navigation, bench-
mark data set, deep learning (DL), Gaussian process (GP)
classifier, pedestrian lane detection.
I. I NTRODUCTION
A UTOMATIC detection of the pedestrian lane in a
scene is an important component in many assistive and
autonomous navigation systems. It assists vision-impaired peo-
ple in finding the walkable path and maintaining their balance
while walking—a difficult task that is currently performed
mostly using a white cane or a guided dog [1]. It also allows
Manuscript received April 7, 2019; revised September 26, 2019 and Decem-
ber 21, 2019; accepted January 1, 2020. Date of publication February 13,
2020; date of current version December 1, 2020. This work was supported by
a grant from the Australian Research Council (ARC). (Corresponding author:
Thi Nhat Anh Nguyen.)
Thi Nhat Anh Nguyen and Son Lam Phung are with the School of Electri-
cal, Computer and Telecommunications Engineering, University of Wollon-
gong, Wollongong, NSW 2522, Australia (e-mail: ngt.nhatanh@gmail.com;
phung@uow.edu.au).
Abdesselam Bouzerdoum is with the School of Electrical, Computer
and Telecommunications Engineering, University of Wollongong, Wollon-
gong, NSW 2522, Australia, and also with the College of Science and
Engineering, Hamad Bin Khalifa University, Doha 7675, Qatar (e-mail:
a.bouzerdoum@uow.edu.au).
This article has supplementary downloadable material available at
https://ieeexplore.ieee.org, provided by the authors.
Color versions of one or more of the figures in this article are available
online at https://ieeexplore.ieee.org.
Digital Object Identifier 10.1109/TNNLS.2020.2966246
2162-237X © 2020 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission.
See https://www.ieee.org/publications/rights/index.html for more information.
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
a smart wheelchair, with little guidance from its disabled user,
to traverse a pedestrian lane [2]. Pedestrian lane detection is
useful also for autonomous vehicles to avoid pedestrians or
off-limit regions in a scene [3]. In addition, it complements
other features of electronic navigation devices such as obstacle
detection [4], [5] and GPS-based guidance [6].
The existing methods proposed for pedestrian lane detection
are mostly designed for detecting pedestrian lanes painted with
white markers [7]–[10]. This article addresses this gap by
focusing on the camera-based detection of pedestrian lanes
in unstructured environments, where the pedestrian lanes can
have arbitrary surfaces with no painted markers. The scenes
containing the pedestrian lane are under varying lighting
conditions and could be indoor or outdoor.
Existing algorithms for unmarked lane detection mostly rely
on hand-engineered features. These methods either use the
color- and texture-based features of the lane surfaces to differ-
entiate the lane pixels from the background [11]–[13], or use
the edge features to locate the lane boundaries [14]–[16].
In general, these methods are sensitive to scene variations,
which cannot be easily captured by such model-based systems.
Recently, lane-detection methods that use deep neural
networks (DNNs) for automatic feature-learning have been
proposed [17]–[19]. These methods yielded promising perfor-
mances in terms of accuracy and processing time. However,
they were mostly designed for vehicle road lane detection.
To the best of our knowledge, there are few publicly available
methods based on the DNNs for unmarked pedestrian lane
detection, which is generally a more challenging problem than
road lane detection, because the appearances, surfaces, and
shapes of the pedestrian lanes often vary more significantly
than the vehicle lanes.
There are two major challenges in adopting the DNN
methods for pedestrian lane detection. First, training a typical
DNN often requires a large volume of data, especially for
complex problems. However, the data sets of labeled images
for training a pedestrian lane-detection system are generally
small compared with the training sets in other computer vision
tasks. The largest publicly available data set for pedestrian lane
detection was introduced in [16] with only 2000 images. Since
typical DNNs usually have a huge amount of parameters to
model complex problems, they are highly prone to overfitting
if the amount of available data is small. Second, for the
safety of the users (vision-impaired persons, for example),
the pedestrian lane-detection system must generate not only
an accurate segmentation of the lane but also a confidence
measure with which we can trust its predictive output. Ideally,
the system should give a full-resolution confidence map,
so that the user can decide which parts of the scene to avoid
NGUYEN et al.: HYBRID DL-GP NETWORK FOR PEDESTRIAN LANE DETECTION IN UNSTRUCTURED SCENES 5325

Fig. 1. Conceptual comparison of a softmax layer of a deep network versus a GP classifier, using an example in binary classification. A softmax layer gives
only a point prediction for each test input. In comparison, a GP classifier gives a probabilistic prediction with a predictive mean and an uncertainty level
for each test input: the test inputs far from the training data have higher uncertainty. In Fig. 1(c), the uncertainty interval (the gray area) is plotted with the
predictive 95% confidence bounds. (a) Input to a softmax layer as a function of the network input x. (b) Output of the softmax layer as a function of the
network input x. (c) Predictive output of GP classifier as a function of its input x.

(the parts with low confidence levels). A typical DNN does
not naturally produce such a confidence measurement for its
prediction.
To address the above two challenges, this article presents
a new approach for pedestrian lane detection using a hybrid
deep learning-Gaussian process (DL-GP) architecture. In this
approach, we cast the pedestrian lane detection in unstructured
environments as a segmentation problem where a scene image
is segmented into pedestrian lane and background regions. The
contributions of the article can be highlighted as follows.
1) We propose a hybrid architecture for pedestrian
lane detection that combines a compact convolutional
encoder–decoder (E-D) network and a hierarchical
GP (HGP) classifier. Unlike the existing lane-detection
approaches that use very deep convolutional networks,
the proposed architecture combines a compact network
having a smaller number of parameters with a powerful
nonparametric GP classifier. This strategy helps mitigate
the overfitting problem while maintaining the modeling
power. The proposed architecture can be trained in an
end-to-end manner. An additional benefit of using a GP
classifier in our architecture is that besides the seg-
mentation output for each test image, the classifier also
generates a map of well-calibrated uncertainty—a para-
meter that is negatively correlated with the confidence
with which we can trust the segmentation. In a typical
DNN classifier, predictive probabilities obtained by a
softmax layer are often erroneously interpreted as model
confidence. In fact, since softmax uses point estimation
without considering model uncertainty, a model can be
uncertain in its predictions even with a high softmax
output. As illustrated in Fig. 1, passing a point estimate
of a function [see Fig. 1(a)] through a softmax layer
results in extrapolations [see Fig. 1(b)] with unjustified
high confidence for points far from the training data.
For example, an input x = 6 is classified as class 1
with a probability of 1. In contrast, a GP classifier [see
Fig. 1(c)] gives a full probabilistic prediction with a pre-
dictive mean and an uncertainty level for each test input.
2) The main limitation of the GP is the high computational
cost. Existing methods to reduce its cost can
be categorized into global or local approximation
approaches. Global approximations use only sparse
information from the training data and normally cannot
account for nonstationarity and locality in complex data
sets. Local approximations fit a separate GP for each
subregion of the input space and are prone to overfitting.
In [20], we proposed a GP approximation method that
uses a hierarchical structure to combine global and local
information from the data set. This method has been
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
shown to improve the predictive performance over the
methods that only use either global or local information.
However, the above article mainly focuses on the multi
class classification cases. A model specifically designed
for binary classification will lead to a further reduction
in the computational cost. This article will discuss the
HGP model for binary classification in detail. We will
then formulate a single loss function and present an
algorithm for end-to-end training of the hybrid DL-GP
architecture for pedestrian lane detection.
3) We create a new data set with manually annotated
ground truth for the objective evaluation of algorithms
for pedestrian lane detection. This data set consists
of 5000 images collected from the realistic indoor
and outdoor scenes, with various shapes, textures, and
surface colors. This data set is the largest data set
for pedestrian lane detection in the literature; it is
extended from the data set that has been previously
introduced in [16]. It is expected to facilitate research
in pedestrian lane detection, especially the application
of DL in this area. The data set is available at
slp-lab.com/phung/plvp2.html.
The rest of the article is organized as follows. Section II
reviews the related work. Section III presents the proposed
hybrid DL-GP architecture for pedestrian lane detection.
Section IV presents the experiments and analysis. Finally,
Section V concludes the article.
II. R ELATED W ORK
In this section, we review the related work for unmarked lane
detection including the traditional and DL-based methods.
A. Traditional Methods for Unmarked Lane Detection
Representative traditional methods based on hand-
engineered features for detecting pedestrian lanes in
unstructured scenes are listed in Table I. They can be divided
into two categories: 1) lane segmentation and 2) lane-
border detection. In the lane-segmentation approach, color
models, which are built through offline training, are used to
differentiate the lane pixels from the background [11], [12],
[21], [22]. These methods use different color spaces and
classifiers. Crisman and Thorpe [11] represent the on-road
and off-road classes with Gaussian color models in the
red–green–blue (RGB) color space. Tan et al. [12] uses color
histograms in the RGB space. Ramstrom and Christensen [22]
construct Gaussian mixture models from the UV, normalized
red and green, and luminance components. Sotelo et al. [21]
employ the hue–saturation–intensity (HSI) color space, and
classify pixels by thresholding their chromatic distance to the
5326 IEEE TRANSACTIONS ON NEURAL NETWORKS AND LEARNING SYSTEMS, VOL. 31, NO. 12, DECEMBER 2020
TABLE I
R EPRESENTATIVE T RADITIONAL M ETHODS FOR U NMARKED L ANE D ETECTION . T HE M ARK “-” M EANS T HAT THE T ECHNIQUE I S N OT U SED
color models. In general, the above methods using offline
trained models do not cope well with the variations in lane
appearance, lane surfaces, and illumination conditions.
To address this problem, several methods choose to build
the lane model directly from the sample regions in the input
image [23]–[26]. There have been different ways to obtain
sample lane regions. In [26] and [27], small random areas are
selected at the bottom and in the middle of the input image.
In [25], the sample lane region is initialized as a trapezoid at
the bottom and center of the image, and then refined using
the vanishing point. In [23], the sample lane region is formed
from the candidate lane boundaries that are detected using
the vanishing point and the assumption about the lane width.
The performance of the above methods highly depends on the
quality of the sample lane regions, which in turn relies on
prior knowledge about the lane.
In the lane-border-detection approach, the lane borders are
detected using the vanishing point [14], [15] or the templates
of lane boundaries [28]. In [14], the two lane borders are found
among the edges pointing to the vanishing point using an
objective function that measures the color and texture differ-
ences between the lane and background regions. This method
requires that the color and texture of the lane region are homo-
geneous and differ significantly from those of the background
regions. In [15], the lane borders are also found from the
edges directed toward the vanishing point; the edges are ranked
using texture orientation and color features. In another method,
the lane boundaries are found from the edges of the homoge-
neous color regions by matching with the lane templates [28].
The above methods for lane-border detection are sensitive to
background edges. To overcome this problem, Chang et al.
[29] propose combining lane-border detection and lane seg-
mentation. In this method, lane borders are detected using
the vanishing point, and the lane region is segmented using
the color model learned from a homogeneous region at the
middle bottom of the input image. In [16], the sample lane
region is first identified using the vanishing point method. The
lane region is then segmented using both the matching scores
between the edges of the homogeneous color regions and lane
templates, and between the colors of these regions and the
color model learned from the sample lane region.
B. DL-Based Methods for Unmarked Lane Detection
Convolutional neural networks (CNNs) are originally
proposed for entire-image classification, but they are making
progress in structured prediction problems such as object
detection and semantic segmentation. Inspired by such a
progress in the CNNs in semantic segmentation, a few
road lane-detection methods using CNNs for automatic
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
feature-learning have been proposed recently [18], [19],
[30]. Mendes et al. [19] design and train a CNN for image
patch classification and then convert it into a network for
road lane segmentation. During training, each image is
divided into 4 × 4 regions, and a patch centered at each
region is extracted. The CNN is trained to classify the
patches into road or nonroad classes that are attributed to
the corresponding 4 × 4 regions. For inference, the CNN is
converted into a fully convolutional network by turning the
fully connected (FC) layers into convolutional layers. In this
way, the network can receive an entire image (instead of a
patch) as input, and output a class for every image region.
However, the classification net uses subsampling to reduce
the number of features and the computational complexity.
This will also coarsen the segmentation output in the final
network and reduce its size compared with the input image.
To address this problem, newer DL methods for semantic
segmentation learn to decode low-resolution image represen-
tations to pixelwise predictions [30]–[32]. These methods
typically employ the E-D architecture that comprises two
parts: encoder and decoder networks. The encoder network
acts as a feature extractor that transforms an input image into
a low-resolution feature representation. The encoder network
typically resembles the VGG16 classification network [33],
which has 13 convolutional layers and three FC layers. The
decoder network is responsible for decoding or mapping the
low-resolution feature representation to a probability map of
the same size as the input image.
A decoder network is typically comprised of several
decoders, each of which increases the size of its input feature
map by a factor of 2. In the fully convolutional network [31],
each decoder learns to upsample its input feature map through
deconvolution with a 2 × 2 stride. The upsampled feature map
is combined with the corresponding encoder feature map to
produce the input to the next decoder. In the deconvolutional
network [31], each decoder performs two main operations:
unpooling and deconvolution. Unpooling performs nonlinear
upsampling—a reverse operation of pooling in the encoder
network. It uses the locations of the maximum activations
selected during pooling to place each activation back to its
original locations. Deconvolution with a 1 × 1 stride is then
used to densify the sparse feature map obtained by unpooling.
In SegNet [30], a convolution layer is used in the place of
deconvolution in a similar decoder network. In Bayesian Seg-
Net, Kendall et al. [34] extend SegNet to a Bayesian network,
which can produce a probabilistic segmentation output. This is
done by adding dropout layers to the network at both training
and testing phases. Dropout is used at test time to sample the
network with randomly dropped out units and, thereby, obtain
the samples of the posterior distribution of softmax class
NGUYEN et al.: HYBRID DL-GP NETWORK FOR PEDESTRIAN LANE DETECTION IN UNSTRUCTURED SCENES
TABLE II
R EPRESENTATIVE DL-BASED M ETHODS FOR ITS
probabilities for each test image. The mean of these samples is
used for segmentation prediction, and the variance is used as
model uncertainty. This method requires that each test image
is fed to the network many times, which can be very slow.
There have been attempts to apply the above deep
E-D architectures to road lane segmentation and a related
problem—road scene segmentation. For example, Nugroho
and Riasetiawan [18] adapt the deconvolutional network for
road lane segmentation without using the FC layers. In [30]
and [34], SegNet and Bayesian SegNet are used for road scene
segmentation on the CamVID road scenes data set [35]. These
methods yield promising results for the road lane-segmentation
and road scene-segmentation problems; however, we are not
aware of any publicly available methods based on DNNs for
unmarked pedestrian lane detection.
C. DL for Intelligent Transportation Systems (ITS)
DL has been widely used to solve many ITS problems
in the recent years. Table II gives a summary on the
representative DL-based methods for ITS. While some of
the works purely use DNNs as an instrument for solving
the ITS problems, many of them propose the state of the art
in DL before applying the approaches to the ITS problems.
While developing a CNN for traffic sign recognition, Jin
et al. [36] also propose a hinge loss stochastic gradient
descent method, whose cost function is similar to that of
the support vector machine (SVM), to train the CNNs
more quickly. Bejani and Ghatee [37] propose a system for
classifying driving styles using the CNN on acceleration data
collected by smartphone sensors. To tackle overfitting, they
propose two adaptive regularization schemes called adaptive
dropout and adaptive weight decay. In our proposed method,
we take another approach to avoid overfitting by using a
compact DNN combined with a nonparametric GP classifier.
However, as shown in our experiments in Appendix B
(Supplementary Material), it is also beneficial to apply the
adaptive weight decay regularization scheme proposed in [37]
to our network.
Pashaei et al. [38] propose a system for the classification of
accident images, which uses a CNN for feature extraction and
a mixture of extreme learning machines (ELM) for classifica-
tion. This system and our proposed architecture are similar in
that they both try to combine a CNN with a new classifier.
However, unlike our method that uses a single-stage end-to-
end training process, the method in [38] requires two separate
training stages. In the first training stage, the traditional CNN
using a multilayer perceptron (MLP) classifier in the last layer
is trained. In the second stage, the features extracted from
the last pooling layer of the CNN are used as the input to
train the mixture of ELM classifiers. The main purpose of
replacing MLP in the original CNN with the mixture of ELM
classifier is for better prediction speed; however, the predictive
performance of the new system is inferior to that of the
original CNN, as reported in [38]. This is because the mixture
of ELM classifier is trained separately from the CNN, and
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
5327
Fig. 2. Structure of the hybrid DL-GP architecture.
ELMs themselves are not strong classifiers. In contrast, since
our proposed hybrid network employs a one-stage end-to-end
training process and since the GP classifier is a powerful
classifier, it leads to improved predictive performances over
the original CNN.
Zadeh et al. [39] propose a warning system for vulnerable
road users, which classifies the collision risk into low, medium,
or high. It uses a fuzzy neural network for risk estimation
based on various types of data from their smartphone sen-
sors such as vehicle acceleration, GPS location, and weather
condition. The problem addressed in [39] is related and com-
plementary to the pedestrian lane-detection problem addressed
by our proposed method. The fuzzy inference method used in
[39] is a promising direction for computing the risk for blind
people or robots on pedestrian lanes, which could be used in
conjunction with the uncertainty produced by our network to
provide extra safety assurance for the users.
III. P ROPOSED H YBRID DL-GP A RCHITECTURE
We propose a hybrid DL-GP architecture that consists of a
convolutional E-D network for generating multi dimensional
features for each pixel in the input image and an HGP module
for pixelwise classification. The block diagram of the proposed
architecture is shown in Fig. 2.
A. Convolutional E-D Network
The convolutional E-D network comprises two parts:
encoder and decoder networks. The encoder network trans-
forms an input image into a low-resolution feature represen-
tation. The decoder network maps the low-resolution feature
representation to a stack of feature maps, each of which has
the same resolution to the input image.
1) Encoder Architecture: The encoder network extracts 2-D
image features at increasing dyadic scales by alternating con-
volutional layers and max-pooling layers. Here, we organize
these layers into a series of encoder units. Each encoder unit
comprises of two convolutional layers, followed by a max-
pooling layer. The structure of an example encoder network
with four encoder units is shown in the top part of Fig. 3.
The two convolutional layers within an encoder unit have
the same number of output channels, which is 64 channels
for the first encoder unit. The spatial size of the feature maps
is halved after each encoder unit. The number of channels is
5328 IEEE TRANSACTIONS ON NEURAL NETWORKS AND LEARNING SYSTEMS, VOL. 31, NO. 12, DECEMBER 2020
Fig. 3. Example E-D network with four encoder/decoder units. The convolutional layers are denoted as “Conv kernel size-number of channels.” Max-
pooling layers are denoted as “Pool kernel size.” Upsampling layers are denoted as “Up kernel size.” Each Conv layer is immediately followed by a batch
normalization layer and an ReLU layer.
doubled at the second and third encoder units compared with
their immediately previous unit. However, we experimentally
found that increasing the number of channels beyond 256 does
not improve the performance for the pedestrian lane-detection
problem. Therefore, for the later encoder units, the number
of channels remains unchanged, i.e., the number of channels
at each layer stops increasing after it reaches 256. This
strategy also aligns with our original plan of keeping the
network compact to avoid overfitting. Each convolutional layer
is immediately followed by a batch normalization layer and
a nonlinear activation layer (ReLU layer); these layers have
been omitted in Fig. 3 for conciseness.
A max-pooling layer applies a 2 × 2 filter to each of its
input feature maps using the stride of 2 pixels, and outputs
the maximum value in every subregion that the filter captures.
A pooling layer effectively reduces the size of its input feature
maps by half while still retaining the important information.
This layer has two main purposes. First, it increases invariance
against small spatial shifts. Second, it reduces the number
of parameters and computation in the network and, thereby,
controls overfitting. However, spatial information within a
pooling window is lost during pooling. This is not beneficial
to semantic segmentation where precise boundary delineation
is required. Therefore, it is necessary to store boundary infor-
mation from the feature maps before subsampling. Storing all
the encoder feature maps is a possible solution, but it requires
a huge amount of memory. Here, employing the solution
proposed in [30], we store only the max-pooling indices,
i.e., the locations of the maximum value in each pooling
window. These stored indices will be used by the decoder
network to upsample the feature maps.
Note that, in the proposed network, each encoder unit
consists of two convolutional layers before a pooling layer.
Our design choice is explained as follows. Since pooling
leads to information loss, we could only have a few pooling
layers before losing too much information. For example, for
a 256 × 256 input image, typically, the maximum number of
pooling layers (and hence the maximum number of encoder
units) is 5. As a result, having multiple convolutional layers
before a pooling layer allows us to build up better representa-
tions of the data without quickly losing spatial information.
However, since our goal is to build a compact network,
the number of convolutional layers should be kept small. From
experimentation, we find that using two convolutional layers
per encoder unit gives comparable performance with other
designs that use more convolutional layers per encoder unit,
while it keeps the number of trained parameters small.
2) Decoder Architecture: The decoder network maps the
low-resolution feature maps generated by the encoder network
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
Fig. 4. Illustration of the operation of an upsampling layer.
to higher resolution feature maps at increasing dyadic scales
until the output feature maps have the same spatial size as
the input image. This is done by using the upsampling layers
and the convolutional layers. An example decoder network is
shown in the bottom part of Fig. 3. We organize the layers
of the decoder network into a series of decoder units, each
of which comprises an upsampling layer followed by two
convolutional layers. The structure of the decoder network is
a reflection of that of the encoder network. The number of
decoder units is equal to the number of encoder units in the
network. The first decoder unit corresponds to the last encoder
unit, and so on.
The number and the spatial size of the output feature maps
of each decoder unit are equal to those of the input feature
maps of the corresponding encoder unit. An exception is for
the last decoder unit, in which the number of its output feature
maps is not equal to the number of channels of the input image
(which is 3) but is kept unchanged from that of its input feature
maps (which is 64). This is because the output of the final
decoder unit will be fed to the GP classifier for segmentation,
and a large number of features at each spatial location are
required for good classification performance.
a) Upsampling layer: The upsampling layer performs
the reverse operation of pooling: upsampling its input feature
maps and, thereby, doubling their spatial size. During pooling,
the max-pooling indices, i.e., the locations of the maximum
value in each pooling window, are stored. An upsampling layer
uses the memorized max-pooling indices from the correspond-
ing max-pooling layer to place each element of the input
feature maps back to its original location in the upsampled
output feature maps. The upsampling technique is illustrated
in Fig. 4. Note that the number of feature maps does not
change after each upsampling layer.
b) Convolutional layer: An upsampling layer produces
enlarged but sparse feature maps. These maps will be fed to
the two subsequent convolutional layers to get densified.
B. HGP Classifier
We develop an HGP classifier for binary classification that
can be placed on the top of the E-D network to classify each
pixel in the image into lane or background. For each input
NGUYEN et al.: HYBRID DL-GP NETWORK FOR PEDESTRIAN LANE DETECTION IN UNSTRUCTURED SCENES
image, the E-D network extracts 64 full-resolution feature
maps, which are then rearranged into an array of feature
vectors; each vector consists of 64 features corresponding to
a pixel. HGP takes a feature vector as input and classifies the
corresponding pixel into lane or background.
Let x denote an extracted feature vector (row vector of
D features; D = 64 in this application), and y denote the
corresponding class label: y = 1 for lane pixel and y = 0
for background. Let N denote the total number of pixels from
all the training images, and X = [(x1 )T , . . . , (x N )T ]T and y =
[y1 , . . . , y N ]T denote the collection of all the feature vectors
and the corresponding labels of all the N training pixels. X
is a matrix with the dimension of N × D and y is a column
vector of size N × 1. We adopt the convention that lowercase
italic letters denote scalar variables or functions, uppercase
italic letters denote scalar constants, lowercase bold letters
denote vectors, and uppercase bold letters denote matrices.
The operators row(A) and col(A) return the number of rows
and columns of a matrix A, respectively.
1) Background on GP Classifiers: GP models are powerful
tools for Bayesian classification [42]–[46]. They have two
most desirable properties. First, since a GP is a nonparametric
model, it has only a few hyperparameters that need to be
learned, and thus, overfitting can be avoided. Second, GPs give
probabilistic predictions with well-calibrated uncertainties.
Let X denote the feature space. In GP classification,
we assume that there is an underlying latent function f (x):
X −→ R that is distributed according to a GP: f (x) ∼
GP(m(x), κ(x, x )). Here, m(x) and κ(x, x ) denote the mean
function and the covariance function that characterize the GP.
For each input x, the value of f (x) is a latent variable.
For any given set of input points, the GP places a prior
multivariate normal distribution on the corresponding latent
variables. The observed output y, given the latent variable
f (x), is then distributed according to a non-Gaussian like-
lihood: p(y| f (x)) = h( f (x)). The objects of interest are the
posterior of the latent variables placed at the training inputs
and the predictive distribution p(y ∗ |y) for the class label y ∗
at a test point x∗ ; they can be estimated using approximate
inference methods such as the variational inference.
2) Rationale Behind HGP: A limitation of GP is its high
computational cost, mainly due to the inversion of the kernel
matrix, which is O(N 3 ) in the training time, where N is
the number of training samples. Many approximation methods
for GP have been proposed to overcome this limitation. They
can be classified into global and local approaches. Global GP
approximation methods (also known as sparse GP methods)
try to summarize all the training data using a set of M N
inducing points to reduce the computational cost [47]–[50].
The sparse GPs work well for simple data sets, but they
cannot deal with locality and nonstationarity in complex
data sets.
Local approaches attempt to overcome the limitation of
global methods by employing a mixture of GP experts
(MoGPE). In MoGPE, a gating network divides the input space
into regions within which a specific GP expert is responsible
for making predictions [51]–[54]. In this way, the locality and
nonstationarity in the data are addressed. The computational
cost is also reduced as the inversion of a large kernel matrix
is replaced by that of several smaller matrices. However, since
each GP expert is trained independently using only the local
data assigned to it, without considering the global information
(the correlations between the clusters), the experts are likely
to overfit the local training data.
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
5329
An HGP classifier is proposed to combine the advantages
of sparse approximation and MoGPE by exploiting both the
global information and local information from the training data
through a two-layer hierarchical structure. In the upper layer,
a sparse GP, hereafter called the global GP, is used to coarsely
model the entire data set. In the lower layer, a gating network
divides the input space into T regions; and within each region,
a specific local GP expert is used for finer modeling. All the
local GP have a common mean function m(x), which encodes
information from the global GP. In this way, information is
shared between the two layers as well as among the local
experts to avoid overfitting.
Herein, we use subscript 0 for the global unit and subscript
k for the kth local expert (k = 1, . . . , T ).
3) Details of the GPs: The global GP is associated with a
latent function f 0 (x), a zero mean function, and a covariance
function κ0 (x, x ): f 0 (x) ∼ GP(0, κ0 (x, x )). The kth local
GP is associated with a latent function f k (x), the mean
function m(x), and a covariance function κk (x, x ): f k (x) ∼
GP(m(x), κk (x, x )), for k = 1, . . . , T . Each GP in the model
is a sparse GP in which the training latent variables (i.e.,
the latent variables placed at the training inputs) are summa-
rized by a set of M inducing points. Each inducing point is
comprised of an inducing input, which is a point from the
input space X , and its corresponding latent variable.
We introduce the following notations for the kth GP
(k = 0, . . . , T ): f kn denotes f k (xn ), fk is the vector
(size N × 1) of all training latent variables, gk is the
vector (size M × 1) of the inducing variables, Uk is the
matrix (size M × D) formed by the M inducing inputs, θk is
the set of hyperparameters of the covariance function κk (x, x ),
(k)
and KAB is the covariance matrix [size row(A) × row(B)]
formed by evaluating κk (x, x ) at all pairs of points (x, x ),
where x is in A and x is in B.
a) Global GP prior: The global GP places a joint prior
distribution on its latent variables g0 and f0 , which results in
the following distributions:
 
p(g0 ) = N 0, K(0)U0 U0 (1)
 (0)  (0) −1 (0)
p(f0 |g0 ) = N KXU0 KU0 U0 g0 , KXX
 (0) −1 (0) 
− K(0)
XU0 KU0 U0 KU0 X. . (2)
b) Local GP prior: To encode information from the
global unit, we set the prior mean of the local GPs to be
(0) (0)
the mean of p( f 0 (x)|g0 ), which is m(x) = KxU0 [KU0 U0 ]−1 g0 ,
according to (2). This imposes a complex dependence between
gk and g0 , making it difficult for model inference. To remove
this dependence, we introduce new latent variables hk =
gk −m(Uk ). This results in the following distributions:
 (k) 
p(hk ) = N 0, KUk Uk (3)
 (k)  (k) −1 (k)
p(fk |hk , g0 ) = N KXUk KUk Uk hk + KXU0 K−1
U0 U0 g0 KXX
  
(k) (k) −1 (k)
− KXUk KUk Uk KUk X . (4)
4) Likelihood Function: In the upper layer, the observed
pixel labels are related to latent variables according to the
following likelihood:
p(yn | f 0n ) = B(yn |φ( f 0n )) = φ( f0n ) yn (1 − φ( f0n ))1−yn .
Here, φ(z) is the probit function that maps the latent variables
into the unit interval [0, 1], and B denotes a Bernoulli distrib-
ution. The above equation implies that the class membership
5330 IEEE TRANSACTIONS ON NEURAL NETWORKS AND LEARNING SYSTEMS, VOL. 31, NO. 12, DECEMBER 2020
Fig. 5. Probabilistic graphical model for HGP.
probability p(yn = 1| f 0n ) and p(yn = 0| f 0n ) can be
calculated as φ( f 0n ) and 1 − φ( f0n ), respectively.
In the lower layer, for each observation (xn , yn ), a latent
variable z n indicates the expert to which the observation
belongs. The likelihood in the lower layer (i.e., the conditional
distribution of the label given all the corresponding latent
variables from all the local experts) is
p(yn | f 1(xn ), . . . , f T(xn )) = p(yn | f zn (xn )) = B(yn |φ( f zn (xn ))).
5) Gating Network Prior: Expert indicators z n are specified
by a gating network based on the inputs. In our model,
the prior over z n is defined as
N(xn |mk , V)
p(z n = k) = T (5)
j =1 N(xn |m j , V)
M (k)
where mk = 1/M m=1 u and V = diag(v 1 , . . . , v D ) with
T m M (k) (k)
v d = 1/(T (M − 1)) k=1 m=1 (u md − m kd )2 ; um denotes
an inducing inputs in the kth expert. Here, mk is a vector of
size 1 × D and V is a diagonal matrix of size D × D. The
rationale behind this prior is that when xn is closer to mk (the
centroid of Uk ), its output can be better predicted by expert
k, and thus, it is more probable to be assigned to that expert.
The probabilistic graphical model that summarizes the
dependences among the variables for HGP is given in Fig. 5
6) Learning for HGP: HGP is learned using a variational
inference algorithm, in which the variational distributions of
the inducing latent variables are explicitly represented as
q(g0 )  N (m0 , S0 ) and q(hk )  N (mk , Sk )
where mk is a column vector of size M and Sk is a square
matrix of size M × M. Following the similar steps in [20],
the following lower bound of the marginal likelihood is
derived:

N 
T of O(N M 2 ) in training time is still prohibitive for this
ln p(y) ≥ q(z n = k)Eq( f kn ) [ln p(yn | f kn )]
n=1 k=1
 N
+ Eq( f0n ) [ln p(yn | f 0n )] − KL(q(h)|| p(h))
n=1
− KL(q(g0 )|| p(g0 )) − KL(q(z)|| p(z))
where KL denotes the Kullback Leibler divergence, z denotes
the set of all z n ; q( f kn ) is defined as
 B
q( f 0n )  p( f 0n |g0 )q(g0 )dg0 and (8)

q( f kn )  p( f kn |hk , g0 )q(hk )q(g0 )dhk g0 (9)
for k = 1, . . . , T . Using (2) and (4), q( f kn ) can be easily
computed in terms of m0 , S0 , mk , and Sk (see [55, Eqs. (38) λn =
and (39)]). The expectation terms Eq( fkn ) [ln p(yn | f kn )] in (7)
can then be evaluated using the Gauss–Hermite quadrature
method [56]. The remaining KL-divergence terms in (7) are
analytically tractable
Authorized (see
licensed use[55, Appendix
limited to: UniversityB]). The
of Hull. bound on
Downloaded
(7) can be considered as containing two separate components.
First, the generative loss component involving the first two
terms measures how accurately the model reconstructed the
observed labels. Second, the latent loss component involving
the last three KL-divergences measures how closely the pos-
teriors of the latent variables match their priors.
Learning is performed by maximizing the bound (7) with
respect to q(z), mk , Sk θk , and Uk . Let γ be the vector formed
by all the parameters to be optimized, except those of q(z).
Due to the complex dependence between z and Uk , we are
not able to optimize z and Uk . Instead, we employ a varia-
tional expectation-maximization (EM) algorithm to optimize
the bound (7) by alternating between the following two steps.
1) E-Step: Fix γ , and maximize the bound with respect to
q(z).
2) M-Step: Fix q(z), and maximize the bound with respect
to γ using gradient-based optimization.
The first step estimates the output of the gating network q(z).
As shown in [20], it can be approximated as follows:
1, if argmaxi N (xn |mi , V) = k
q(z n = k) = (10)
0, otherwise.
a) Convergence: It has been shown in [20] that both the
E and M steps of the above EM algorithm only increase or at
least maintain the value of the objective function (7), which
is upper-bounded by the maximum value of the log marginal
likelihood ln p(y), and the algorithm will eventually converge
to a (local or global) maximum.
b) Complexity: Suppose that all the GPs have the same
number of inducing points M. Most of the computational
cost for the above EM algorithm arises from computing the
expected likelihood terms Eq( fkn ) [ln p(yn | f kn )] in (7), which
in turn requires the computation of q( f kn ) for k = 1, . . . , T
and n = 1, . . . , N. Computing each q( f kn ) according to [55,
Eqs. (38) and (39)] has the complexity of O(M 2 ). Hence,
the overall time complexity of the algorithm appears to be
O(N M 2 T ). However, with the variational posterior of z n
(6) given by (10), we can see that, for each given point xn , there is
only one expert k such that q(z n = k) is nonzero. Therefore,
for each n ∈ {1, . . . , N}, only one term q( f kn ) is needed for
the computation of the objective function (7). For this, the time
complexity of the algorithm is actually reduced to O(N M 2 ).
7) Stochastic Optimization: The computational complexity
application, considering that N is the total number of image
pixels in the training set. The beauty of this method is that due
to the special form of the bound derived in (7), we can further
reduce the training cost using mini-batch training, i.e., using
only a mini-batch of data in each iteration. In particular, since
(7) the bound (7) includes the sum over data points, at each
training iteration t, it can be approximated with
N 
L(S (t ) ) = λi − KL(q(h)|| p(h))
x i ∈S (t)
− KL(q(g0 )|| p(g0 )) − KL(q(z)|| p(z)) (11)
where S (t ) denotes the set of feature vectors corresponding to
the mini-batch of B pixels used in iteration t, and
T
q(z n = k)Eq( f kn ) [ln p(yn | f kn )]
k=1
+ Eq( f 0n ) [ln yn | f 0n ].
This12,2023
in August effectively reduces
at 17:52:35 theIEEE
UTC from training
Xplore. time to O(B
Restrictions M 2 ).
apply.
NGUYEN et al.: HYBRID DL-GP NETWORK FOR PEDESTRIAN LANE DETECTION IN UNSTRUCTURED SCENES 5331

Fig. 6. HGP classification model for pixelwise lane segmentation. Arrows indicate the dataflow at test time.

We note that the computational complexity is independent
of the number of experts T . Therefore, we can freely select the
value of T to fit the data. For that, an autoselection mechanism
for T is implemented as follows. We first initialize T = T0 ,
where T0 is larger than the expected number of experts and
is typically smaller than 10. After each optimization iteration,
if an expert k does not have any training pixel assigned to it
(q(z n = k) = 1), this expert will be removed.
8) Predicting With HGP: Consider a test pixel with the
feature vector x∗ . Let f k∗ denote fk (x∗ ). The predictive distri-
bution for fk∗ can be approximated as
 
p( f k∗ |y) ≈ p f k∗ |hk , g0 q(hk )q(g0 )dhk dg0 = N (μ∗k , σk∗2 )
where
 T  T
μ∗k = a∗k mk + a∗0 m0
 T   ∗  ∗ T
σk∗2 = κk (xn , xn )+ a∗k Sk −K(k) ∗ vector xn in S (t ) .
Uk Uk ak + a0 S0 a0
(k) (k)
with a∗k = [KUk Uk ]−1 KUk x∗ . It can be observed that the
last terms of μ∗k and σk∗2 in (12) are actually the posterior
mean and variance of m(x∗ ), which represent the information
passed
 from the upperlayer T to the ∗lower
T layer:
 q(m(x∗ )) =
∗ ∗ ∗
N m̄(x ), v̄(x ) = N a0 m0 , a0 S0 a0 . ∗ 10: until convergence.
The prediction at x∗ by expert k is then given by

    GP, the local GP experts, and the gating network for a single
p(y ∗ |x∗ , y, z ∗ = k) = p y ∗ | f k∗ p f k∗ |y d f k∗ (13)
which can be computed by the Gauss–Hermite quadrature
method giving two outputs: the predictive mean (or the lane
probability) and the predictive variance (or the uncertainty).
The final prediction by HGP at x∗ can be computed as the
weighted average of the predictions from T GP experts

T 1) Training: The end-to-end training procedure for the
p(y ∗ |x∗ , y) = p(z ∗ = k|x∗ , y) p(y ∗ |x∗ , yz ∗ = k)
k=1

T
≈ q(z ∗ = k) p(y ∗ |x∗ , y, z ∗ = k)
k=1
where q(z ∗ = k) is the output of the gating network, which
is calculated according to (10).
The computational cost of the predicting label for a single
test pixel by HGP is dominated by the computation of σk∗2 in
(12), which has the time complexity of O(M 2 ).
Fig. 6 illustrates the input and output of the HGP, and the
dataflow among its main components including the global
Algorithm 1 End-to-End Training Algorithm for the Hybrid
DL-HGP Network
1: Initialize all the parameters (denoted as δ) of the E-D
network.
2: Initialize all the parameters of HGP, i.e., γ and q(z).
3: repeat
4: Sample a mini-batch of B I images randomly from the
training set.
5: Pass the mini-batch through the E-D network to
generate a set of 64 full-resolution feature maps for
each image in the mini-batch.
6: Rearrange the feature maps to form a set of feature
vectors denoted as S (t ). Each vector in S (t ) has 64
features corresponding to a pixel in the mini-batch.
7: Update q(z n ) according to Eq. (10) for each feature
(12)
8: Calculate the partial derivatives of L(S (t ) ) (Eq. (11))
w.r.t. all the GP variables in γ and all the parameters
δ of the E-D network using back- propagation.
9: Update the current estimate of γ and δ using the
calculated partial derivatives.
test image.
C. Training and Testing for the Hybrid DL-GP Architecture
When HGP is used as the classifier in the proposed hybrid
DL-GP architecture, we referred to the resulting network as
the DL-HGP network.
DL-HGP network is presented in Algorithm 1.
As discussed in Section III-B6, the HGP classifier alone
will converge to a local or global maximum. However, this
(14) does not guarantee the convergence of the training algorithm
for the hybrid DL-HGP network. In fact, it is also well known
that even the traditional neural networks are not guaranteed
to converge to a global optimum. Nevertheless, throughout
our experiments, the training algorithm for DL-HGP always
converges to a meaningful state, in which the network gives
good predictions on a validation set. This convergence state
can be detected when both the network parameters and the
objective function do not change significantly anymore (i.e.,
their changes are below a certain threshold).

Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
5332 IEEE TRANSACTIONS ON NEURAL NETWORKS AND LEARNING SYSTEMS, VOL. 31, NO. 12, DECEMBER 2020
Algorithm 2 Lane-Segmentation Algorithm for a Test Image I
1: Pass the image through the E-D network to generate
64 full-resolution feature maps.
2: Rearrange the feature maps to form a set of feature vectors
S ∗ . Each vector in S ∗ consists of 64 features corresponding
to a pixel in the image.
3: for each x∗ ∈ S ∗ do
4: Find the GP expert k that is responsible for the
prediction at x∗ : k = argmaxi N (x∗ |mi , V).
5: Compute μ∗k and σk∗2 using the formulas in (12).
6: Estimate the prediction at x∗ by the expert k
according to (13) using the Gauss-Hermite quadrature,
which gives the lane probability and the classification
uncertainty for the corresponding pixel.
7: The lane probability p(y ∗ = 1|x∗ , y) produced in the
previous step is compared to 0.5 to give the pixel label:
1, iff p(y ∗ = 1|x∗ , y) > 0.5
label =
0, otherwise.
8: end for
9: The set of labels for all the pixels in the test image is
rearranged into a 2-D segmentation mask, which has the
same size as input image, as shown in Fig. 6. Similarly, the
set of classification uncertainties for all the image pixels is
rearranged into a 2-D uncertainty map.
The time complexity for training the DL-HGP network
is the sum of the time complexity for learning the HGP
and for learning the parameters of the E-D network. As
previously mentioned, the training time complexity of the
HGP alone is O(B M 2 ), where B is the number of pixels
in each mini-batch. The time complexity of the E-D network
is dominated
 L by that of all the convolutional layers, which is
O B I ( l=1 nl−1 sl2 nl m l2 ) , for each mini-batch of B I images.
Here, l is the index of a convolutional layer and L is the
number of convolutional layers. nl is the number of output
channels (number of filters) of the lth layer and nl−1 is the
number of input channels of the lth layer. sl is the spatial size
of the filters and m l is the spatial size of the output feature
maps. The overall complexity of the training L algorithm for 
DL-HGP is O(B I W H M 2 ) + O B I ( l=1 nl−1 sl2 nl m l2 ) ,
where W × H is the spatial size of the training images.
2) Testing: The steps for producing the lane-segmentation
result for a new test image using the hybrid DL-HGP network
are summarized in Algorithm 2.
We note that the predictive lane probability p(y ∗ = 1|x∗ , y)
and the background probability p(y ∗ = 0|x∗ , y) are summed
to 1. Hence, it is reasonable to assign the pixel label to 1 (i.e.,
lane) if the probability p(y ∗ = 1|x∗ , y) is larger than 0.5,
as shown in Step 7 of Algorithm 2.
Since the testing time complexity of the HGP is
O(M 2 ) for a single pixel, the testing time complex-
ity for the DL-HGP
 network for a single test image is randomized image numbers. The data set is then divided into
O(W H M 2 ) + O L five partitions of equal sizes. For each fold, four partitions are
l=1 n l−1 sl n l m l .
2 2
IV. E XPERIMENTS AND A NALYSIS
In this section, we first describe the image data set, perfor-
mance measures, and experimental setup (see Section IV-A).
We then present the configuration search for the proposed
network (see Section IV-B) and the comparative experimental
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
TABLE III
S TATISTICS OF THE PLVP2 D ATA S ET
results of different methods for pedestrian lane detection (see
Section IV-C).
A. Image Data Set and Experimental Methods
1) Image Data Set: We created an image data set for pedes-
trian lane detection. This data set, named PLVP2, consists
of 5000 images with their corresponding ground-truth lane-
segmentation masks. Each ground-truth mask is a manually
segmented binary image, where each pixel is labeled as lane
or background. Annotated vanishing points are also included
for each image; this information can be used to evaluate the
lane-detection methods based on vanishing point detection.
The images were taken from the realistic indoor and outdoor
scenes, at different times of a day, and in different weather
conditions. The images contain unmarked pedestrian lanes
with various shapes, colors, textures, and surface structures
(pavement, brick, concrete, or soil). In many images, lane
regions are exposed to extreme lighting conditions (e.g., very
low or high illumination, or strong shadow). Fig. 7 shows some
example images and the corresponding ground truth from the
data set. Statistics regarding the lane surfaces and the lighting
conditions are given in Table III.
2) Performance Measures: To evaluate pedestrian lane
detection for each test image, the predicted pedestrian lane-
segmentation mask and the ground-truth mask are compared
pixelwise to compute four evaluation measures: accuracy,
recall, precision, and F-measure. Each of these four measures
for individual images is then averaged over the whole test set
to get the overall evaluation measures. Accuracy is the per-
centage of the image pixels that are correctly classified. Recall,
Precision, and F-measure were proposed in [57] for evaluating
the lane-detection algorithms, and they have been widely used
since then. Recall is the percentage of the ground-truth lane
pixels that are detected correctly. Precision is the percentage
of the machine-detected lane pixels that are considered to
be correct. F-measure is the harmonic mean of precision
and recall: F-measure = 2 × Recall × Precision/(Recall +
Precision).
3) Experimental Setup: To compare the performance
measures among different lane-detection methods on the
PLVP2 data set, we use the fivefold cross-validation. In this
data set, images collected from multiple sources are given
used for training and validation (called the training–validation
set), and the remaining partition is used for testing. Different
folds use different test partitions: the first fold uses the first
1000 images, the second fold uses the next 1000 images, and
so on. For the experiments comparing the performances of
different lane-detection methods, the performance measures
evaluated on the test sets are averaged over the fivefolds.
NGUYEN et al.: HYBRID DL-GP NETWORK FOR PEDESTRIAN LANE DETECTION IN UNSTRUCTURED SCENES 5333

Fig. 7. Examples from the PLVP2 data set. First rows: pedestrian lane images. Second rows: ground-truth-segmentation masks.

TABLE IV
P ERFORMANCE OF D IFFERENT E-D N ETWORK C ONFIGURATIONS FOR L ANE D ETECTION ON THE F OLD -1 PLVP2 VALIDATION S ET. T HE L ISTED
N UMBER OF PARAMETERS C OUNTS A LL THE PARAMETERS OF THE E-D N ETWORK AND THE GP C LASSIFIER

For the hyperparameter tuning (model selection) in each TABLE V

individual method, a validation set separated from the test P ERFORMANCE OF THE DL-HGP N ETWORK U SING D IFFERENT VALUES
set must be used to avoid the biases. Therefore, we further FOR T0 ON THE F OLD -1 PLVP2 VALIDATION S ET

randomly divide each training-validation set into a training

set and a validation set using the ratio of 4 : 1.
Images in the data set are captured in both land-
scape (2113 images) and portrait orientations (the remaining
images). The image width and height range from 1224 to
1632 pixels. To reduce the computational cost, the images are
resized to 306 × 306 pixels. We experimentally found that
image data augmentation does not improve the performance of
the tested methods in this pedestrian lane-detection problem.
Therefore, it is not used in all the experiments subsequently
reported in this section.
For training of the tested methods, the Adam optimizer is
used with the learning rate of 0.001, and the exponential decay
rates β1 and β2 of 0.9 and 0.999. Mini-batch training is used
with a batch size of B I = 3 images. The maximum number
of training iterations is 30 000.
Each experiment is performed on a system that has Intel
Core i7-7700 CPU at 3.60 GHz, 64 GB of RAM, and a
GTX1080TI GPU with 11-GB memory.
4) System Implementation: The proposed hybrid network
is implemented entirely in Python using Tensorflow and the
GPFlow library for the HGP modules. The GPFlow library
[58] is able to back-propagate through all the GP components,
allowing us to train the network in an end-to-end manner.
We note that our HGP classifier treats the inducing inputs
as variational parameters, which are tuned to minimize the
divergence between the variational distribution and the exact
GP posterior distribution of the latent variables. The more
inducing points are used by the model, and the better it is at
approximating the exact nonparametric GP model, as pointed
out in [59]. Therefore, we can safely increase the number
of inducing inputs M and optimize them without concerning
about overfitting. However, since the training time for the GP
classifier is directly proportional to the square of M, we prefer
to use a small M. In all our experiments, M is fixed to 50.
B. Configuration Search
In this section, we evaluate different variations of the
proposed network to find the best configuration in terms
of the number of encoder/decoder units, the filter size, and
the number of GP experts. These are collectively called the
hyperparameter set.
For each of the fivefolds described in Section IV-A3,
we train different network variations using the training set,
analyze their performance on the validation set, and select the
network variation with the best performance on the validation
set. We emphasize that this entire model selection process must
be repeated for each of the fivefolds. However, since we found
the results of the model selection for the different folds are
very similar, in this section, we will only present the model
selection result of the first fold.
1) E-D Network Configuration Search: We first fix the
number of GP experts to 9 and search for the number of
encoder/decoder units and the filter size. The number of
encoder/decoder units is selected from 2 to 6, and the filter size
varies among 3 × 3, 5 × 5, and 7 × 7. The performance of the
different E-D network configurations on the validation set is

Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
5334 IEEE TRANSACTIONS ON NEURAL NETWORKS AND LEARNING SYSTEMS, VOL. 31, NO. 12, DECEMBER 2020
TABLE VI
P ERFORMANCE OF D IFFERENT L ANE -D ETECTION M ETHODS ON THE PLVP2 D ATA S ET U SING F IVEFOLD C ROSS -VALIDATION ; THE B EST
P ERFORMANCE M EASURES A RE G IVEN IN B OLD
listed in Table IV. We observe that the network achieves higher
accuracy and F-measure by using more encoder/decoder units,
up to four to five units. The performance drops when the sixth
encoder/decoder unit is added. This dropping in performance
can be explained by the fact that too much spatial information
has been lost after six pooling layers of the encoder network
that it cannot be effectively recovered by the decoder network.
The configurations C4K5 and C5K5, which have the filter
size of 5 × 5 and use four and five encoder/decoder units,
respectively, achieve the best performances in terms of both
accuracy and F-measure. The configuration C4K5 is chosen
for our network, because it has fewer trainable parameters
(and, hence, it is less prone to overfitting).
2) Initial Number of Expert Search: Next, we fix the config-
uration C4K5 for the E-D network and vary the initial number
of GP experts T0 among 3, 6, 9, and 12. The performance of
the network using different values for T0 on the PLVP2 vali-
dation set is presented in Table V. The network achieves the
best performance at T0 = 9, where the number of experts T at
convergence is 9. When T0 increases to 12 or 15, the network
also converges at T = 9 and achieves the performance that is
very close to when T0 = 9. This result shows that the proposed
autoselection mechanism for T is effective as long as the initial
number of experts T0 is larger than or equal to the expected
T . For the remaining experiments, we fix T0 = 9.
C. Comparison With Other Lane-Detection Methods
1) Quantitative Comparison: In this experiment, we use
fivefold cross-validation to compare the performances of dif-
ferent lane-detection methods on the PLVP2 data set. The
proposed DL-HGP network is compared with the traditional
methods that use hand-engineered features and the DL-based
methods for unmarked lane detection. Two representative and
relevant traditional methods are included in this experiment.
1) Edge-Based Method [15]: This method detects the lane
boundaries from the edges pointing to the vanishing
points. We use the MATLAB code provided by Kong
et al. [15].
2) Border-Detection + Segmentation [16]: This method
combines lane-border detection and lane segmen-
tation. We use the MATLAB code provided by
Phung et al. [16].
Four state-of-the-art DL-based methods for road scene seg-
mentation are evaluated in this experiment.
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
1) DeepLabv3 + [60]: This method also uses an E-D
structure. The encoder network can extract features at
an arbitrary resolution by applying atrous convolution.
It also uses atrous Spatial Pyramid Pooling with multiple
atrous rates to capture multi scale context. Normally,
the encoder will generate feature maps with an output
stride of 8 or 16 (i.e., the size of the feature maps is
1/8 or 1/16 of that of the input image). A simple decoder
module recovers the object boundaries. We find that the
encoder output stride of 8 performs the best for this data
set. Therefore, the result of DeepLabv3+ with an output
stride of 8 is reported.
2) Fully Convolutional DenseNets [61]: This method
extends DenseNets [62] to deal with the problem
of semantic segmentation. It uses a downsampling–
upsampling style E-D network. Each stage (between
the pooling layers) uses a dense block, in which each
layer takes a concatenation of feature maps from all
the preceding layers as input. It also concatenates skip
connections from the encoder to the decoder. We report
the results for the Fully Convolutional DenseNets
with 56 layers (FC-DenseNet56) and with 103 layers
(FC-DenseNet103).
3) SegNet [30]: An E-D network is followed by a linear
classifier (an FC layer and a Softmax layer), which
generates a class label for each image pixel. The encoder
network of SegNet resembles the first part of the
VGG16 classification network [33] with 13 convolu-
tional layers.
4) Bayesian SegNet [34]: It has dropout layers added to the
SegNet architecture at both training and testing phases
to produce a probabilistic segmentation output.
We also experiment with the variants of SegNet, Bayesian
SegNet, and the proposed network (C4K5 + HGP).
1) SegNet-Basic [30]: This is a smaller version of SegNet,
where each of the encoder and decoder networks has
four convolutional layers with filter size 7 × 7. Each
convolutional layer is followed by a pooling or upsam-
pling layer.
2) Bayesian SegNet-Basic [34]: Dropout layers are added
to SegNet-Basic to produce probabilistic segmentation.
3) SegNet + HGP, Bayesian SegNet + HGP, SegNet-
Basic + HGP, and Bayesian SegNet-Basic + HGP:
These are, respectively, the variants of SegNet, Bayesian
NGUYEN et al.: HYBRID DL-GP NETWORK FOR PEDESTRIAN LANE DETECTION IN UNSTRUCTURED SCENES 5335

Fig. 8. Pedestrian lane segmentation using different algorithms. Column 1: input images. Column 2: output of the Border-detection + segmentation method
[16]. Column 3: output of SegNet [30]. Column 4: output of Bayesian SegNet [34]. Column 5: output of the proposed DL-HGP network. See the electronic
color image.

SegNet, SegNet-Basic, and Bayesian SegNet-Basic,
where the linear classifier is replaced by the HGP
classifier.
4) C4K5 + Linear-Classifier: This is a variant of the
proposed network, where HGP is replaced by a linear
classifier.
All the DL-based methods in our experiments are imple-
mented in Python using Tensorflow. For Bayesian SegNet and
its variants, each test image is passed through the network
30 times to obtain 30 samples of the posterior distribution of
the segmentation output.
The performance of different methods on the PLVP2 data set
using fivefold cross-validation is presented in Table VI. Here,
the methods are arranged into four groups. The first group con-
sists of traditional methods that use hand-engineered features.
The second group includes the variants of DeepLabv3+ and
Fully Convolutional DenseNets. The third group comprises
the variants of SegNet, Bayesian SegNet, and the proposed
network that use the linear classifier. The last group involves
the variants of SegNet, Bayesian SegNet, and the proposed
network that use the HGP classifier. The following can be
observed from the results in Table VI.
1) The DL methods outperform the traditional methods
that use the hand-engineered features for unmarked
lane detection, and in general, they take a much shorter
time for inference. SegNet-Basic, which has the second
lowest accuracy among the DL methods, outperforms
Border-detection + segmentation, which is the one
with the higher accuracy between the two evaluated
traditional methods, by 2.12% in accuracy and 1.67% in
F-measure, while being approximately 173 times faster
than Border-detection + segmentation for inference.
2) For each of the DL networks in the third group, replacing
its linear classifier by the HGP classifier in the fourth
group improves the performance. Especially, we find
that combining the HGP classifier with a compact E-D
network like SegNet-Basic and C4K5 provides more
significant increases in accuracy (2.29% and 1.21%
improvement) and F-measure (1.50% and 1.67%
improvement). This result shows that using a powerful
GP classifier can help mitigate the need for a complex
E-D network in pedestrian lane detection.
3) The compact E-D network C4K5 has fewer than half
the number of trained parameters of the E-D network
of SegNet: 13 017 472 versus 29 480 064 parameters.
However, the proposed network combining C4K5 with
HGP is more accurate than SegNet + HGP. It also gives
the best performance among the tested methods in terms
of accuracy, F-measure, and recall. It outperforms the
state-of-the-art methods SegNet and Bayesian SegNet by
1.21% and 0.82% in terms of accuracy, and 1.56% and
1.19% in terms of F-measure. This is because pairing
the compact E-D network C4K5 with the powerful HGP
classifier gives a similar modeling power to the larger
networks while mitigating the overfitting problem,
especially for small data sets. We can also expect that

Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
5336 IEEE TRANSACTIONS ON NEURAL NETWORKS AND LEARNING SYSTEMS, VOL. 31, NO. 12, DECEMBER 2020

Fig. 9. Pedestrian lane-detection results of Bayesian SegNet and DL-HGP. Column 1: input images. Column 2 and 3: detected lanes and the uncertainty
maps by Bayesian SegNet. Column 4 and 5: detected lanes and the uncertainty maps by DL-HGP. A brighter intensity in the uncertainty maps presents a
higher uncertain level. See the electronic color image.

the proposed network can perform better than the above
larger networks for new test samples that are quite
different from those seen in the PLVP2 data set.
4) In Bayesian SegNet-Basic and Bayesian SegNet, adding
the dropout layers for probabilistic segmentation has a
positive side effect: It results in a slightly improved
accuracy of these two networks over SegNet-Basic and
SegNet. This improvement comes at the cost of much
slower inference: Inference in Bayesian SegNet-Basic
and Bayesian SegNet requires 0.484 and 0.995 s/test
image, respectively. On the other hand, combining the
dropout layers into the networks that use the HGP clas-
sifier does not seem to improve the performance of these
networks: Bayesian SegNet-Basic + HGP classifier ver-
sus SegNet-Basic + HGP classifier, and Bayesian Seg-
Net + HGP classifier versus SegNet + HGP classifier.
5) The Fully Convolutional DenseNets (FC-DenseNet103)
gives a good performance, which is close to
the performance of the proposed network. Hence,
we believe that it would be beneficial to combine an
E-D architecture based on dense blocks with an HGP
classifier for the pedestrian lane-detectionproblem.
We leave it for future exploration.
2) Visual Comparison on Lane-Detection Results: Fig. 8
shows the visual comparative results of different methods for
pedestrian lane detection. The compared methods include the
Border-detection + segmentation method [16], SegNet [30],
Bayesian SegNet [34], and DL-HGP. The Border-detection +
segmentation method [16] is susceptible to background edges
(as seen in images 1, 4, 5, and 7). As a result, its performance
is poor for indoor scenes in which there exist many strong
structured edges (image 7). It also does not perform well in a
scene with extreme lighting conditions such as strong shadow
(image 2) or when the colors of the lane and background
region are similar (images 3 and 6). The three remaining
(DL-based) methods are less susceptible to the above prob-
lems. Especially, they give much better results for indoor
scenes (image 7). Among these methods, DL-HGP seems to
be the one that is most robust to the background edges (as seen
in images 1 and 5), and to the extreme lighting conditions (as
seen in images 2, 3, and 5). There are three possible reasons
for DL-HGP to be able to address these conditions better than
the two other DL methods.
1) While the linear classifier at the end of a traditional
DNN requires the network to extract linearly separable
features, the HGP classifier does not. The HGP can
classify well using nonlinearly separable features.
2) Since HGP does not require linearly separable features,
we can afford to use fewer network layers in DL-HGP
(16 convolutional and four pooling layers) than that in
SegNet and Bayesian SegNet (26 convolutional and five
pooling layers). Using fewer pooling layers means that
the resolution of the final encoder feature maps is not
reduced as much. Therefore, more edge and boundary
information still remains on the final encoder feature
maps. This helps DL-HGP to detect the lane boundary
better.

Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
NGUYEN et al.: HYBRID DL-GP NETWORK FOR PEDESTRIAN LANE DETECTION IN UNSTRUCTURED SCENES
3) HGP is a generative model, which is well known for
generalizing better and for being more robust to noise
than a discriminative model (e.g., the linear classifier
and the SVM), especially for small data sets [63].
The compact E-D network with a smaller number of
parameters in the proposed DL-HGP architecture is also
less likely to overfit training data and is more robust to
noise.
3) Visual Comparison on Uncertainty Maps: Fig. 9 shows
the visual comparative results for the uncertainty maps gen-
erated by Bayesian SegNet and by the proposed DL-HGP. It
can be seen that DL-HGP is generally more certain about its
prediction than Bayesian SegNet. The areas of high uncer-
tainty generated by DL-HGP are mostly located near the lane
boundaries. On the other hand, the areas of high uncertainty
produced by Bayesian SegNet appear more at random loca-
tions, which can be seen clearly in images 1, 2, 3, 4, and 7.
The uncertainty maps by DL-HGP can be more useful for the
pedestrian lane-detection application, since they can be used
to locate the lane boundaries and to warn the blind users about
the areas of high uncertainty near the lane boundary to keep
them within the safe pedestrian lane areas.
V. C ONCLUSION
This article presents a method for pedestrian lane detection
in unstructured environments using a hybrid DL-GP architec-
ture to segment scene images into the pedestrian lane and
background regions. The proposed hybrid network, which can
be trained in an end-to-end manner, combines a compact con-
volutional E-D network with a powerful nonparametric HGP
classifier to mitigate the overfitting problem while maintaining
its modeling power. In addition to the segmentation output
for each test image, the network also generates a map of
well-calibrated uncertainty. Last but not least, a new data set
of 5000 images for training and evaluating pedestrian lane-
detection algorithms is introduced. It is expected to facilitate
research in pedestrian lane detection, especially the application
of DL in this area.
R EFERENCES
[1] A. J. Jackson and J. S. Wolffsohn, Low Vision Manual. Amsterdam,
The Netherlands: Elsevier, 2007.
[2] R. C. Simpson, “How many people would benefit from a smart wheel-
chair?” J. Rehabil. Res. Develop., vol. 45, no. 1, pp. 53–72, Dec. 2008.
[3] J. Kim and H. Shin, Algorithm and SoC Design for Automotive Vision
Systems. Amsterdam, The Netherlands: Springer, 2014.
[4] I. Ulrich and J. Borenstein, “The GuideCane-applying mobile robot
technologies to assist the visually impaired,” IEEE Trans. Syst., Man,
Cybern. A, Syst. Humans, vol. 31, no. 2, pp. 131–136, Mar. 2001.
[5] S. Shoval, J. Borenstein, and Y. Koren, “Auditory guidance with the
Navbelt—A computerized travel aid for the blind,” IEEE Trans. Syst.,
Man, Cybern. C, Appl. Rev., vol. 28, no. 3, pp. 459–467, Mar. 1998.
[6] HumanWare. (2015). BrailleNote GPS. [Online]. Available:
https://store.humanware.com/hus/braillenote-gps-software-and-receiver-
package.html
[7] S. Se and M. Brady, “Road feature detection and estimation,” Mach.
Vis. Appl., vol. 14, no. 3, pp. 157–165, Jul. 2003.
[8] M. S. Uddin and T. Shioyama, “Bipolarity and projective invariant-based
zebra-crossing detection for the visually impaired,” in Proc. CVPRW,
2005, pp. 22–30.
[9] V. Ivanchenko, J. Coughlan, and S. Huiying, “Detecting and locating
crosswalks using a camera phone,” in Proc. CVPRW, 2008, pp. 1–8.
[10] M. C. Le, S. L. Phung, and A. Bouzerdoum, “Pedestrian lane detec-
tion for assistive navigation of blind people,” in Proc. ICPR, 2012,
pp. 2594–2597.
[11] J. Crisman and C. Thorpe, “SCARF: A color vision system that tracks
roads and intersections,” IEEE Trans. Robot. Automat., vol. 9, no. 1,
pp. 49–58, Feb. 1993.
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
5337
[12] C. Tan, H. Tsai, T. Chang, and M. Shneier, “Color model-based real-
time learning for road following,” in Proc. IEEE Conf. Intell. Transp.
Syst., Sep. 2006, pp. 939–944.
[13] J. M. Alvarez, T. Gevers, and A. M. Lopez, “Vision-based road detection
using road models,” in Proc. ICIP, 2009, pp. 2073–2076.
[14] C. Rasmussen, “Texture-based vanishing point voting for road shape
estimation,” in Proc. BMVC, 2004, pp. 470–477.
[15] H. Kong, J.-Y. Audibert, and J. Ponce, “General road detection
from a single image,” IEEE Trans. Image Process., vol. 19, no. 8,
pp. 2211–2220, Aug. 2010.
[16] S. L. Phung, M. C. Le, and A. Bouzerdoum, “Pedestrian lane detection
in unstructured scenes for assistive navigation,” Comput. Vis. Image
Understand., vol. 149, pp. 186–196, Aug. 2016.
[17] J. Kim and M. Lee, “Robust lane detection based on convolutional
neural network and random sample consensus,” in Proc. ICONIP, 2014,
pp. 454–461.
[18] D. P. A. Nugroho and M. Riasetiawan, “Road lane segmentation using
deconvolutional neural network,” in Proc. Int. Conf. Soft Comput. Data
Sci., 2017, pp. 13–22.
[19] C. C. T. Mendes, V. Fremont, and D. F. Wolf, “Exploiting fully
convolutional neural networks for fast road detection,” in Proc. IEEE
Int. Conf. Robot. Autom. (ICRA), May 2016, pp. 3174–3179.
[20] T. N. A. Nguyen, A. Bouzerdoum, and S. L. Phung, “A scalable
hierarchical Gaussian process classifier,” IEEE Trans. Signal Process.,
vol. 67, no. 11, pp. 3042–3057, Jun. 2019.
[21] M. A. Sotelo, F. J. Rodriguez, L. Magdalena, L. M. Bergasa, and
L. Boquete, “A color vision-based lane tracking system for autonomous
driving on unmarked roads,” Auto. Robots, vol. 16, no. 1, pp. 95–116,
Jan. 2004.
[22] O. Ramstrom and H. Christensen, “A method for following unmarked
roads,” in Proc. IEEE Intell. Vehicles Symp., 2005., 2005, pp. 650–655.
[23] Y. He, H. Wang, and B. Zhang, “Color-based road detection in
urban traffic scenes,” IEEE Trans. Intell. Transp. Syst., vol. 5, no. 4,
pp. 309–318, Dec. 2004.
[24] C. Oh, J. Son, and K. Sohn, “Illumination robust road detection using
geometric information,” in Proc. 15th Int. IEEE Conf. Intell. Transp.
Syst., Sep. 2012, pp. 1566–1571.
[25] O. Miksik, P. Petyovsky, L. Zalud, and P. Jura, “Robust detection of
shady and highlighted roads for monocular camera based navigation of
UGV,” in Proc. ICRA, 2011, pp. 64–71.
[26] J. M. Á. Alvarez and A. M. Lopez, “Road detection based on illu-
minant invariance,” IEEE Trans. Intell. Transp. Syst., vol. 12, no. 1,
pp. 184–193, Mar. 2011.
[27] J. M. Alvarez, T. Gevers, Y. LeCun, and A. M. Lopez, “Road scene
segmentation from a single image,” in Proc. ECCV, 2012, pp. 376–389.
[28] J. D. Crisman and C. E. Thorpe, “UNSCARF—A color vision sys-
tem for the detection of unstructured roads,” in Proc. ICRA, 1991,
pp. 2496–2501.
[29] C.-K. Chang, C. Siagian, and L. Itti, “Mobile robot monocular vision
navigation based on road region and boundary estimation,” in Proc.
IEEE/RSJ Int. Conf. Intell. Robots Syst., Oct. 2012, pp. 1043–1050.
[30] V. Badrinarayanan, A. Kendall, and R. Cipolla, “SegNet: A deep
convolutional encoder-decoder architecture for image segmentation,”
IEEE Trans. Pattern Anal. Mach. Intell., vol. 39, no. 12, pp. 2481–2495,
Dec. 2017.
[31] J. Long, E. Shelhamer, and T. Darrell, “Fully convolutional networks
for semantic segmentation,” in Proc. CVPR, Jun. 2015, pp. 3431–3440.
[32] H. Noh, S. Hong, and B. Han, “Learning deconvolution network for
semantic segmentation,” in Proc. ICCV, Dec. 2015, pp. 1520–1528.
[33] K. Simonyan and A. Zisserman, “Very deep convolutional networks
for large-scale image recognition,” 2014, arXiv:1409.1556. [Online].
Available: https://arxiv.org/abs/1409.1556
[34] A. Kendall, V. Badrinarayanan, and R. Cipolla, “Bayesian SegNet:
Model uncertainty in deep convolutional encoder-decoder architectures
for scene understanding,” in Proc. BMVC, 2017.
[35] G. J. Brostow, J. Fauqueur, and R. Cipolla, “Semantic object classes in
video: A high-definition ground truth database,” Pattern Recognit. Lett.,
vol. 30, no. 2, pp. 88–97, Jan. 2009.
[36] J. Jin, K. Fu, and C. Zhang, “Traffic sign recognition with hinge loss
trained convolutional neural networks,” IEEE Trans. Intell. Transp. Syst.,
vol. 15, no. 5, pp. 1991–2000, Oct. 2014.
[37] M. M. Bejani and M. Ghatee, “Convolutional neural network
with adaptive regularization to classify driving styles on smart-
phones,” IEEE Trans. Intell. Transp. Syst., early access, doi:
10.1109/TITS.2019.2896672.
5338 IEEE TRANSACTIONS ON NEURAL NETWORKS AND LEARNING SYSTEMS, VOL. 31, NO. 12, DECEMBER 2020
[38] A. Pashaei, M. Ghatee, and H. Sajedi, “Convolution neural network joint
with mixture of extreme learning machines for feature extraction and
classification of accident images,” J. Real-Time Image Process., vol. 16,
pp. 1–16, Feb. 2019.
[39] R. Bastani Zadeh, M. Ghatee, and H. R. Eftekhari, “Three-phases
smartphone-based warning system to protect vulnerable road users under
fuzzy conditions,” IEEE Trans. Intell. Transp. Syst., vol. 19, no. 7,
pp. 2086–2098, Jul. 2018.
[40] Y. Lv, Y. Duan, W. Kang, Z. Li, and F. Wang, “Traffic flow prediction
with big data: A deep learning approach,” IEEE Trans. Intell. Transp.
Syst., vol. 16, no. 2, pp. 865–873, Apr. 2014.
[41] L. Zhang, F. Yang, Y. Daniel Zhang, and Y. J. Zhu, “Road crack detection
using deep convolutional neural network,” in Proc. IEEE Int. Conf.
Image Process. (ICIP), Sep. 2016, pp. 3708–3712.
[42] M. Kuss and C. E. Rasmussen, “Assessing approximate inference for
binary Gaussian process classification,” J. Mach. Learn. Res., vol. 6,
pp. 1679–1704, Oct. 2005.
[43] Y. Altun, T. Hofmann, and A. J. Smola, “Gaussian process classifica-
tion for segmenting and annotating sequences,” in Proc. ICML, 2004,
pp. 4–11.
[44] A. Kapoor, K. Grauman, R. Urtasun, and T. Darrell, “Active learning
with Gaussian processes for object categorization,” in Proc. ICCV, 2007,
pp. 1–8.
[45] H. Nickisch and C. E. Rasmussen, “Approximations for binary
Gaussian process classification,” J. Mach. Learn. Res., vol. 9, no. 10,
pp. 2035–2078, 2008.
[46] T. P. N. A. Centeno and N. D. Lawrence, “Optimising kernel parameters
and regularisation coefficients for non-linear discriminant analysis,”
J. Mach. Learn. Res., vol. 7, pp. 455–491, Feb. 2006.
[47] N. Lawrence, M. Seeger, and R. Herbrich, “Fast sparse Gaussian
process methods: The informative vector machine,” in Proc. NIPS, 2003,
pp. 625–632.
[48] A. Naish-Guzman and S. Holden, “The generalized FITC approxima-
tion,” in Proc. NIPS, 2007, pp. 1057–1064.
[49] J. Hensman, A. Matthews, and Z. Ghahramani, “Scalable variational
Gaussian process classification,” in Proc. AISTATS, 2015, pp. 351–360.
[50] J. Hensman, A. G. Matthews, M. Filippone, and Z. Ghahramani,
“MCMC for variationally sparse Gaussian processes,” in Proc. NIPS,
2015, pp. 1648–1656.
[51] C. E. Rasmussen and Z. Ghahramani, “Infinite mixtures of Gaussian
process experts,” in Proc. NIPS, 2002, pp. 881–888.
[52] V. Tresp, “Mixtures of Gaussian processes,” in Proc. NIPS, 2000,
pp. 654–660.
[53] T. N. A. Nguyen, A. Bouzerdoum, and S. L. Phung, “Variational
inference for infinite mixtures of sparse Gaussian processes through KL-
correction,” in Proc. IEEE Int. Conf. Acoust., Speech Signal Process.
(ICASSP), Mar. 2016, pp. 2579–2583.
[54] J. Shi, R. Murray-Smith, and D. Titterington, “Bayesian regression
and classification using mixtures of Gaussian processes,” Int. J. Adapt.
Control Signal Process., vol. 17, no. 2, pp. 149–161, Mar. 2003.
[55] T. N. A. Nguyen, A. Bouzerdoum, and S. L. Phung, “Stochastic varia-
tional hierarchical mixture of sparse Gaussian processes for regression,”
Mach. Learn., vol. 107, no. 12, pp. 1947–1986, Dec. 2018.
[56] M. Girolami and S. Rogers, “Variational Bayesian multinomial probit
regression with Gaussian process priors,” Neural Comput., vol. 18, no. 8,
pp. 1790–1817, Aug. 2006.
[57] J. Fritsch, T. Kuhnl, and A. Geiger, “A new performance measure and
evaluation benchmark for road detection algorithms,” in Proc. 16th Int.
IEEE Conf. Intell. Transp. Syst. (ITSC), Oct. 2013, pp. 1693–1700.
[58] A. G. D. G. Matthews et al., “GPflow: A Gaussian process library using
TensorFlow,” J. Mach. Learn. Res., vol. 18, no. 40, pp. 1–6, 2017.
[59] M. K. Titsias, “Variational learning of inducing variables in sparse
Gaussian processes,” in Proc. AISTATS, 2009, pp. 567–574.
[60] L. Chen, Y. Zhu, G. Papandreou, F. Schroff, and H. Adam, “Encoder-
decoder with atrous separable convolution for semantic image segmen-
tation,” in Proc. ECCV, 2018, pp. 801–818.
[61] S. Jegou, M. Drozdzal, D. Vazquez, A. Romero, and Y. Bengio, “The one
hundred layers Tiramisu: Fully convolutional DenseNets for semantic
segmentation,” in Proc. IEEE Conf. Comput. Vis. Pattern Recognit.
Workshops (CVPRW), Jul. 2017, pp. 11–19.
[62] G. Huang, Z. Liu, K. Q. Weinberger, and L. van der Maaten, “Densely
connected convolutional networks,” in Proc. CVPR, 2017, vol. 1, no. 2,
p. 3.
[63] A. Y. Ng and M. I. Jordan, “On discriminative vs. generative classifiers:
A comparison of logistic regression and naive Bayes,” in Proc. NIPS,
2002, pp. 841–848.
Authorized licensed use limited to: University of Hull. Downloaded on August 12,2023 at 17:52:35 UTC from IEEE Xplore. Restrictions apply.
Thi Nhat Anh Nguyen received the B.Eng. degree
(Hons.) and the M.Eng. degree from Nanyang Tech-
nological University, Singapore, in 2007 and 2012,
respectively, and the Ph.D. degree from the Univer-
sity of Wollongong, Wollongong, NSW, Australia,
in 2019, all in computer engineering.
Her research interests include machine learning,
pattern recognition, computer vision, and image
processing.
Son Lam Phung (Senior Member, IEEE) received
the B.Eng. degree (Hons.) and the Ph.D. degree
from Edith Cowan University, Perth, WA, Australia,
in 1999 and 2003, respectively, all in computer
engineering.
He is currently an Associate Professor with the
School of Electrical, Computer and Telecommu-
nications Engineering, University of Wollongong,
Wollongong, NSW, Australia. His general research
interests are in the areas of image and signal
processing, neural networks, pattern recognition, and
machine learning.
Dr. Phung received the University and Faculty Medals in 2000.
Abdesselam Bouzerdoum (Senior Member, IEEE)
received the M.S.E.E. and Ph.D. degrees in electri-
cal engineering from the University of Washington,
Seattle, WA, USA, in 1986 and 1991, respectively.
In 1991, he joined The University of Adelaide,
Adelaide, SA, Australia, where he was a Research
Associate and then a Senior Assistant Professor.
In 1998, he joined Edith Cowan University, Perth,
WA, Australia, as an Associate Professor. In 2004,
he was appointed as a Professor of computer engi-
neering and the Head of the School of Electri-
cal, Computer and Telecommunications Engineering, University of Wollon-
gong, Wollongong, NSW, Australia, where he served as an Associate Dean
Researcher for the Faculty of Informatics from 2007 to 2013. He is currently
serving as the Head of the Information and Computing Technology Division,
College of Science and Engineering, Hamad Bin Khalifa University, Doha,
Qatar, and a Senior Professor of computer engineering with the University of
Wollongong. He held several visiting professor appointments at the Institut
Galilée, Université Paris-13, Villetaneuse, France; LAAS/CNRS, Toulouse,
France; Institut Femto-st, Besancon, France; Villanova University, Villanova,
PA, USA; and The Hong Kong University of Science and Technology,
Hong Kong. He has published over 360 technical articles and graduated
50 Ph.D. and research master’s students, and supervised over 60 honors theses.
His research interests include radar imaging and signal processing, image
processing, vision, machine learning, and pattern recognition.
Dr. Bouzerdoum was a member of the Australian Research Council (ARC)
College of Experts from 2009 to 2011. He received the Eureka Prize for
Outstanding Science in Support of Defense or National Security in 2011,
the Chester Sall Award of the IEEE T RANSACTIONS ON C ONSUMER
E LECTRONICS in 2005, and the Distinguished Researcher Award, Chercheur
de Haut Niveau, from the French Ministry in 2001. He is the Deputy
Chair of the Engineering, Mathematics and Informatics Panel from 2010 to
2011. He has served as an Associate Editor for five international journals,
including the IEEE T RANSACTIONS ON I MAGE P ROCESSING and the IEEE
T RANSACTIONS S YSTEMS , M AN , AND C YBERNETICS from 1999 to 2006.