navigating mobile robots with a modular neural architecture Neural Comput & Applic (2003) pdf

Neural Comput & Applic (2003) 12: 200–211
DOI 10.1007/s00521-003-0383-y

O R I GI N A L A R T IC L E

Catarina Silva Ỉ Bernardete Ribeiro

Navigating mobile robots with a modular neural architecture

Received: 28 March 2002 / Accepted: 3 July 2003 / Published online: 14 November 2003
Ó Springer-Verlag London Limited 2003

Abstract Neural architectures have been proposed to
navigate mobile robots within several environment definitions. In this paper a new neural modular constructive
approach to navigate mobile robots in unknown environments is presented. The problem, in its basic form,
consists of defining and executing a trajectory to a predefined goal while avoiding all obstacles, in an unknown
environment. Some crucial issues arise when trying to
solve this problem, such as an overflow of sensorial
information and conflicting objectives. Most neural
network (NN) approaches to this problem focus on a
monolithic system, i.e., a system with only one neural
network that receives and analyses all available information, resulting in conflicting training patterns,
long training times and poor generalisation. The work
presented in this article circumvents these problems by
the use of a constructive modular NN. Navigation
capabilities were proven with the NOMAD 200 mobile
robot.
Keywords Constructive algorithms Ỉ Mobile robot
navigation Ỉ Modular neural networks Ỉ Sensor fusion

1 Introduction

There has been an increasing interest in the development
of intelligent mobile robots, i.e., robots that are able to
learn to navigate and act in complex, possibly unknown,
environments. This interest grew with the realisation
that a mobile robotÕs application environments are
usually dynamic, leading to the search for new solutions
for mobile robot navigation.
When attempting to satisfy the requirements of such
a control system, it is often difficult to find a unique
C. Silva (&) Ỉ B. Ribeiro
´
Centro de Informatica e Sistemas,
Universidade de Coimbra, 3030 Coimbra, Portugal
E-mail:

control law that applies in all relevant regions of the
parameter space [1] and that can evaluate all the information available. The overflow of information is indeed
a major problem in mobile robot control.
Neural networksÕ (NNsÕ) adaptive, noise filtering and
generalisation capabilities have made them an obvious
instrument for controlling mobile robots. Traditional
approaches use monolithic neural networks. Monolithic
systems are composed of just one NN that receives all
data, learning the solution mapping. Monolithic NNs
present some problems, due to the usually conflicting
tasks that exist in mobile robot navigation. These can be
handled by following a modular strategy, applying the
divide and conquer principle and using functional task
division. This approach leads to NNs that are known as
Modular Neural Networks (MNNs) [2]. An MNN

consists of a multiplicity of NNs organised in a way that
improves both the systemÕs overall performance, and the
effectiveness of the training and architecture determination [3].
Monolithic NN training is normally a tedious procedure and it is usually difficult to justify the obtained
parameters. One of the most serious criticisms of NN is
the fact that one does not know what is happening inside
it. In other words, an NN behaves like a black box. A
considerable benefit that can emerge from MNNs is an
interpretable and relevant neural representation of the
systemÕs behaviour [4].
Another step towards clarifying NNs is the use of
constructive algorithms as an approach for the incremental construction of potentially near-optimal NN
architectures. Such algorithms help overcome the need
for the ad hoc and often inappropriate network topology choices that result from the use of algorithms that
search for a suitable weight setting in an otherwise a
priori fixed network topology [5].
This article presents a constructive MNN architecture
that performs the navigation control of a real mobile
robot. Sect. 3 states the questions underlying the problem of mobile robot navigation. Sect. 5 justifies the need
for MNN architectures. Sect. 6 presents the constructive


201

NN algorithms, highlighting the potential improvements
obtained by their use. Sect. 7 describes the modular
architecture developed, and Sect. 10 presents the constructive method applied. Sect 15 reports experimental
results for this system, in both a simulated environment
and a real mobile robot. Sect. 16 draws final conclusions
and suggests possible extensions.

2 Mobile robot navigation
As mentioned above, mobile robot navigation consists
of the definition and execution of a trajectory to a predefined goal, while avoiding all obstacles, in an unknown environment. There are a number of questions
that arise when trying to navigate a mobile robot:
–
–
–
–

how to get information on the environment
how to deal with the various types of data
what restrictions should be put on trajectory planning
how to detect and avoid unknown obstacles.

Environmental information is usually gathered
through sensors in the mobile platform. As there are
several types of sensors, care has to be taken when
receiving online data. Once an acceptable data interpretation has been found, the next step is to determine
the trajectory. There are several approaches to this task,
and they can be broadly divided into two groups:

The NOMAD 200 is a wheeled cylindrical robot,
whose diameter is about 46 centimetres, illustrated in
Fig. 1. The robot can move forwards or backwards with
varying speed and turn right or left a variable number of
degrees. The robot has also a dead-reckoning system for
keeping track of its orientation and position. The deadreckoning system determines the robotÕs present position
from a previous one with information regarding the path
and velocity taken between the two positions. This

information is gathered by monitoring the platform
traction wheels. This data can have great relevance, since
it is easy to obtain and can be gathered with negligible
delay. Moreover, it is always available and its update
frequency is higher than other sensors.
The robot has 16 ultrasonic sensors and 16 infrared
sensors for observing the surrounding environment.
Ultrasonic and infrared sensors are evenly distributed
around the robot, yielding a 22.5 degree angle between
any two adjacent sensors.
There are two sensors installed in each direction: an
ultrasonic and an infrared sensor, distributed according
to Fig. 2. The redundancy is only apparent, since the
sensorsÕ ranges are very different. While infrared sensors

– global planning-based navigation, where, without
having dynamic knowledge of the environment, a
trajectory planner determines the best path from the
start position to the goal position;
– reactive navigation, using sensorial information to
determine the robotÕs path online.
Global planning-based navigation relies on the
hypothesis that the robotÕs action environment is sufficiently static to trust an a priori planning. However, this
hypothesis is rarely true, as the environment is usually
much too changeable. Examples of these environments
are factories or public spaces, like airports.
Reactive based navigation takes a different approach.
Assuming that the mobile platform navigates in a truly
dynamic environment, as it usually does, this strategy
discards global planning, supporting the robotÕs navigation in sensorial information and behaviour patterns

that are already known, or that are developed or
learned. This approach can lead to adaptive systems,
with a certain level of learning [6]. In this work we focus
on the problem of navigating a NOMAD 200 mobile
robot in an unknown environment, thus assuming a
reactive approach.

Fig. 1 The NOMAD 200 mobile robot

2.1 The NOMAD 200 mobile robot
This section describes the mobile robot that was used as
a test bed for our experiments. We shall first describe the
robot, then the simulator.

Fig. 2 The Location of NOMAD 200 sensors


202

detect obstacles up to 60 cm, the ultrasonic sensorsÕ
range is from 50 cm to 650 cm. Therefore, in every
evaluation, for each one of the 16 possible sensorial
directions, only one type of sensor will be used, as will be
explained in Sect. 7.
The NOMAD 200 simulator has been used during
initial experiments in order to set up the required NN
system architecture. It accurately models each of the
NOMADÕs motion and sensing capabilities. It also
provides tools to test user-developed programs and
recreate specific interactions within a user-defined environment.

An illustration of the user interface screen is shown in
Fig. 3. This interface makes it possible to show both the
pure simulation environment, and the representation of
the robotÕs real trajectory, as will be shown in the results
section.

3 MNNs
The building block of any NN is the neuron. The
organisation of neurons in layers and the interconnection of these layers are the next steps to be taken in the
neural architecture. For this concept to be applied, the
NN must be provided with sufficient resources (i.e., the
correct architecture considering the input space) and,
obviously, an algorithm capable of learning the inputoutput mapping by updating the NN weights. Unfortunately these requirements are far from being accessible
[4].
The basic organisation just described can go one step
further. Specifically, an NN can consist of a multiplicity
of networks organised in a modular structure [2]. As
already mentioned, modularity can be viewed as a
manifestation of the principle of divide and conquer,
which allows us to solve complex problems, by diving
them into smaller sub-problems (modules), easier to
solve and combining their individual solutions to
achieve the final solution.
The use of global NNs (as the back propagation NN)
and clustering NNs (as the radial basis function NN) can
Fig. 3 The simulation
environment

lead to various advantages and drawbacks [4]. Combining the two approaches to retain the best of each one
is possible using an MNN.

Nevertheless, the application of the modular concept
to an NN has to be systematised, thus:
1. Task decomposition into sub-tasks;
2. Module organisation;
3. Module integration (communication).
A global NN, as the multi-layer perceptron (MLP), is
characterised by the fact that all its nodes are involved in
each pattern processing. This is the main difference when
comparing with clustering NNs, where only a part of
their structure is involved in each pattern processing.
The use of clustering NNs requires relatively few
learning trials and tends to yield interpretable representations, whereas the global NN converges very slowly
(or does not converge at all) and still has the black-box
problem. However, the clustering NN tends to be
memory intensive, while global NNs have the advantage
of smaller storage requirements and better generalisation performance.
It therefore seems very interesting to combine the
desirable features of each approach, as a way of computing the information to obtain a better neural learning
system.
A modular approach can also be justified on a biological basis. In the human brain specific areas have been
identified, responsible for specific tasks that do not per
se solve any particular problem. However, in combination, those specific areas accomplish greater tasks, not
foreseeable if the particular areas are examined separately. An example of this situation is seen in the visual
cortex, where the operations it performs are achieved by
its division into different regions, each responsible for a
smaller sub-task.
One of the important improvements achieved by
MNNs is better generalisation. A common approach in
neural networks is to use architectures as small as possible to obtain better generalisation, because the ability
of feed-forward NNs to generalise is inversely proportional to the number of weights involved [7].

203

Some other advantages are gained by using MNNs.
Firstly, dividing a task into sub-tasks will avoid the
problems of temporal and spatial crosstalk [1]. Temporal crosstalk occurs when a single NN is trained with
different training sets in two different moments in time
to perform two different tasks. Usually the net forgets
how to execute the first task, altering the previously
trained weights. Spatial crosstalk occurs when an NN is
trained simultaneously for the two tasks, resulting in
incoherent training patterns and long training times. In
either case the outcome is poor generalisation capability.
Finally, modularity can result in learning economy,
since some modules can be reused or modified without
altering the other modules, as will be demonstrated in
this work in Sect. 10. This economy can become crucial
when hardware implementations are intended, since
MNNs can facilitate the hardware realisation of neural
networks [8].
There are several types of modular networks: cooperative, competitive, sequential and supervisory [3]. In
all of them there is an implicit division of tasks. They
differ in the way the modules interact. Whereas in
cooperative modular networks all modules cooperate in
the final decision, in competitive NNs the modules
compete to win the chance to provide the solution. In
sequential MNNs the modulesÕ solutions are used
sequentially to achieve the final solution, the computation of one module depending on the preceding one.
Supervisory networks have the task of supervising one

or more modules [3].
Having reflected on the many advantages of using a
modular approach to mobile robot navigating problem,
emphasising the reasons that led to our choice, we
should now look at other successful approaches, whose
merit should not be ignored. These are: unsupervised
learning methods [9], and reinforcement learning procedures [10]. Unlike supervised learning, these methods
do not rely on a training set to learn. Instead they learn
more autonomously.
In reinforcement learning the only output that is
available is the measure of the performance the NN is
achieving: whether it is rewarded or punished. This
reinforcement signal is much less informative than a set
of examples and it can be delayed, i.e., the success or
failure obtained can result from past control signals. A
greater disadvantage of reinforcement learning is the
fact that it is a slow process, largely owing to its stochastic nature.
Unsupervised learning depends on the input distribution to cluster the examples. These procedures rely on
the possibility that these more autonomous learning
methods (non-supervised) can achieve behaviours not
foreseeable with a human supervisor.
Sharkey et al. [10] classify the self-learning of
autonomous robots as a worthwhile scientific adventure,
presenting real-life situations where intelligence emerges
both from the interplay with the environment and the
gradual development of actionsÕ representations in the
world.

4 Constructive NNs
Recently several NN learning models have been proposed for a wide range of applications. Of them, the

MLP, trained with the standard back-propagation (BP)
algorithm, is the most common.
The BP algorithm searches for the solution using an
a priori determined topology. Usually, this procedure is
only useful when the topology is correctly determined
for the specific problem [11]. If the chosen topology is
too small, the network will not be able to learn the
problem solution; however, if the topology is too large
a memorisation process can occur, generating overfitting.
Research has therefore been conducted with the aim
of optimising the NN dimension for each [12, 13]
problem. Generally, there are two approaches to this
optimisation problem. One starts with a bigger than
necessary network, that is trained until an acceptable
solution is found. Then, useless hidden units are removed or pruned, using a pruning algorithm [14]. The
other approach is constructive algorithms, which start
with a minimum configuration network and then add
hidden units until an acceptable solution is reached.
Pruning algorithms have several disadvantages [11]:
– it is often difficult to determine the appropriate initial
network size;
– most of the training time is spent with larger than
necessary networks;
– consequently it is not computationally efficient;
– the solution found may not be the smallest possible
for the defined performance.
Constructive approaches avoid most of these problems. Thus, a constructive approach was followed to
define the modular architecture that best handles the
mobile robot navigation problem, which can be classified as a regression problem, whether a constructive
modular architecture is used or not. Before explaining

the constructive approach followed, a formalisation of
the regression problem is presented.
In regression problems, a d-dimensional input
space, X, is defined, composed of independent variables, and there is a scalar variable, Y, denominated
answer (this is a simplification, because the answer can
have one or several dimensions). A regression surface,
h, describes the desired relation between the variables
X and Y. The constructive process tries to find the
NN architecture that best represents the h function [2].
Determining the NN architecture that is able to
approximate the objective function can be seen as a
problem of searching in a function space [11], where
the search space, the start state, goal state and
the control strategy are defined by the constructive
process.
The search space is a sub-space of a function space,
which is usually a space where a norm, | |, is defined and
satisfies certain conditions:


204

1. ktk=0, if and only if t=0;
2. kktk=|k|ktk, for any scalar k;
3. kt+xk £ ktk+kxk.

The generation and test methodology is used in all
NN constructive processes to:

The norm gives a notion of the distance in the

space: if x, t are vectors in the normed space, then
the distance from x to t (and vice-versa) will be
kt)xk. Different norms, and consequently different
spaces, are used to represent and solve different kinds
of problems.
As an exhaustive search is computationally prohibitive, the search space is only a sub-space of the function
space and is determined by the way new units are generated.
Notice that, unlike conventional methods with fixedsized networks, constructive algorithms have two search
levels. The first one searches the best NN architecture
and the second searches, within the defined architecture,
for the best set of weights.
The initial state deals with the network before the
constructive algorithm takes place. Usually this initial
network does not have hidden units or connections. The
training is carried out in this initial structure and hidden
units are added and connected as long as the performance is not satisfactory.
The final states are acceptable problem solutions,
good approximations for function h. This evaluation
depends on the problem on hand. The distance measure
depends on the defined space norm. For two functions h,
g, defined in an input space X, a uniform distance can be
used, according to Eq. 1:
kh gk ẳ maxjh xị g xÞj :
x2X

ð1Þ

If h is the objective function and g is the constructive
network implemented function, the uniform distance
emphasises the x values for which the approximation is

worst (with a larger absolute error), using these
approximations as a distance measure, assuring the
absolute correction for error boundaries.
Another error measure often used is the Lp distance,
in Eq. 2:
!1=p
Z
p
;
2ị
jh xị g xịj dl
kh gkp ẳ
X

where l is the input space distance and p is a real
number, p‡1. If p=2, Euclidean distance is obtained. In
Eqs. 1 and 2, the distance measure is used in all the
space, not only in the training patterns, because the
greatest interest in the NN test lies not in the training
examples, but in its generalisation capabilities.
There can be several final states, i.e., it is possible
that several networks approximate the objective function with the same precision or error. The advantage
of this fact is that it is only necessary to find one of
these networks. The main obvious disadvantage is that
different network configurations represent different
functions, leading to the representation of different
realities.

1. generate the network according to a control strategy
that defines the solution search;

2. test the generated network;
3. if it is acceptable, end the process; if not, return to
point 1.
The search for the best set of weights can be
accomplished through several optimisation algorithms.
In topology matters, constructive methods always search
for the smaller networks first, increasing their size only if
necessary. Besides having better generalisation capabilities, smaller networks also present other benefits:
– computational costs, measured by the number of
arithmetic operations, are of O(W), where W represents the number of network weights. Therefore,
smaller networks are more efficient, not only in
training, but also online;
– a smaller network is more easily described by a rule set
and is easier to interpret.
In this work we explore a class of constructive algorithms that systematically determine the NN architecture. Constructive algorithms aim to improve
generalisation and simplify learning through the dynamic creation of problem-specific NN architecture. A
review of constructive NN algorithms can be found in
[11].

5 Modular architecture
Mobile robot navigation has a considerable number of
issues that can be analysed and studied, as was pointed
out in Sect 3. In this work we focus on the problem of
navigating a mobile robot to a defined goal in an unknown environment, minimising navigation time and
positioning error [15, 16]. Navigation systems can be
broadly divided into two types of situations: where there
is an environment map or where there is not. This map
can exist prior to the planning, or can be built while the
robot navigates in the environment. There are several
real situations where the existence of a map is not an

objective and has little relevance to solving the problem.
These situations occur when the robotÕs environment is
too dynamic, which makes a mapÕs construction too
costly to compute. In these conditions, the robot may
not maintain a map, using its sensorial information to
reach the desired objective.
This is the situation we propose to examine, using an
NN. The first approach is usually a monolithic network,
but a deeper evaluation clouds the effectiveness of this
approach [17, 18]. In fact, the large amount of available
sensorial information can make distinguishing the relevant information a problem. Therefore, a monolithic
NN that receives all available information can have very
long training times and poor generalisation capabilities,
as we have corroborated empirically [19].


205

All these factors, and all the MNNÕs features suggested in Sect. 5, emphasise the usefulness of MNNs in
mobile robot navigation. The first step is to functionally
divide our proposed task into sub-tasks. Mobile robot
navigation was divided in two main tasks that proceed
directly from the problem definition, presented earlier in
this section:
– obstacle detection and avoidance;
– objective direction.
This division is easily justifiable, since to fulfil mobile
robot navigation one has, firstly, to detect and avoid all
obstacles in the way, and secondly, to reach an objective.
The evidence that these two tasks can be contradictory,

i.e., that one can lead the robot in a different direction
from the other, strengthens the modular concept application to the problem, because, as was mentioned in
Sect. 5, temporal and spatial crosstalk can occur when a
problem has contradictory objectives.
These two tasks and the moduleÕs interconnection
structure will now be described. Figure 4 presents the
defined architecture.
5.1 The obstacle detection and avoidance module
This task has the objective of detecting and avoiding
unknown obstacles in the robotÕs environment. This
module will play a central role in the resolution of the
problem, since it will receive and fuse all the sensorial
information available.
5.1.1 Handling sensorial Information
The NOMAD 200 mobile robot has two types of sensors
aligned in each of the 16 sensorial directions: an infrared
sensor and an ultrasonic sensor. The difference in their
ranges can be used to optimise the information in each
Fig. 4 The modular
architecture

of the 16 possible sensorial directions. Ultrasonic sensors are used to give global information about the area,
but when the robot is close to obstacles, it uses infrared
sensors. The reason for this is that an ultrasonic sensor
cannot give the distance to an obstacle when it is less
than 50 centimetres. Thus, when the output of the
ultrasonic sensor is 50 centimetres or less, the infrared
sensor, in that specific direction, will be used. Moreover,
an ultrasonic sensor output that exceeds 100 centimetres
is always set to 100 centimetres. This truncation occurs

because objects whose distance is greater are not considered for obstacle avoidance, since they carry little
information and are very often the result of multiple
reflections of the ultrasonic wave. Eq. 3 displays these
renements.
8
ultrasonic sensor650;
< infrared;
3ị
Sensor ẳ 100;
ultrasonic sensor>100;
:
ultrasonic; otherwise:

5.1.2 Internal structure
The obstacle detection and avoidance module has 16
possible inputs, corresponding to the 16 possible sensorial directions presented in Fig. 2. As can be inferred,
a system of cardinal points has been assigned to the
sensorial directions available, dividing the inputs into
four quadrants (North, East, South and West). Considering that the robot always faces North, it could be
said that it is not a real cardinal system, but a pseudosystem, because our cardinal points are not static.
Although all the sensors are evenly distributed, the four
quadrants do not have the same level of imporance.
In fact, as the robot always faces North, this will be the
quadrant with a higher probability of collision, and
consequently the most important as far as the obstacle
detection and avoidance module is concerned. Because


206
Table 1 Codification of the North output

Table 2 Obstacle detection and avoidance module codification

N1

N2

Direction

OD1

OD2

OD3

Direction

0
0
1
1

0
1
1
0

N
NW
NE

Other

0
0
0
0
1
1

0
0
1
1
1
0

0
1
1
0
0
0

N
NW
NE
E
S
W

of its relevance, therefore, the North quadrant will have
a specialised module that will monitor and manage the
available sensors within its action range.
The North module uses all available sensors, i.e., the
five sensors shaded in Fig. 2 (NW, NNW, N, NNE and
NE). The training set for the North module was derived
from actual trajectories driven by the supervisor in
simulated environments. It consists of 120 sets of sensorial information and the desired direction associated
with it, codified according to Table 1. The test set was
derived in the same way and has 38 samples. The codification was carried out using two outputs for the North
module. There are three available output directions,
since it is also possible not to consider the North
quadrant as an option. The output codification was
constructed using Gray code1, reducing the error when
there is a failure in one output.
The other three modules (East, South and West) are
smaller and identical, making it possible to construct
just one module and replicate the other two, taking
advantage of the learning economy that underlies the
modular structure.
Each one of these three modules watches one of the
other quadrants and has three sensorial inputs that
correspond to three sensorial readings of the respective
quadrant, as illustrated in Fig. 4. There is only one
output neuron, which indicates the confidence that there
is an obstacle in that quadrant. The supervisor used the
robotÕs simulator to define the training set by defining
trajectories in different scenarios. The training set was
composed of 30 patterns.
An integrating module was defined to integrate the

four modules (North, East, South and West), (see
Fig. 4). The integrating module is a neural network with
5 inputs: two from the North module and one from each
of the other three modules. It has three output neurons,
which codify the direction to be followed according to
Table 2. The training set for the integrating module was
generated by the supervisor and consisted of 32 training
examples that constitute all possible combinations of the
5 binary inputs. Notice that, although the training set is
binary, when the module is online, the inputs will be
continuous since they will result from other NNs.
This integrating module was first tested separately. In
the test, a goal was not defined and the robotÕs objective
was to wander indiscriminately, detecting and avoiding
unknown obstacles. The results were very satisfactory,

1
Binary code in which only one bit changes from one state to the
other.

Fig. 5 Tests with the obstacle detection and avoidance module

because, as can be seen in Fig. 5, the robot was able to
wander without colliding with obstacles.
5.2 The objective direction module
The objective direction module computes the direction
heading to the goal, considering the goal position, the
robotÕs actual position (xi,yi) and the robotÕs orientation,
hi.
The desired orientation is computed according to

Eq. 4:
yo yi
ho ẳ at an
;
4ị
xo xi
where (x0,y0) is the objectiveÕs position and h0represents
the angle to the objective. The rotation the robot must
perform, h, is obtained by Eq. 5.
h ¼ ho À hi :

ð5Þ

The direction is also codified according to Table 2.
5.3 The navigation module
At this stage, the structures of the obstacle detection and
avoidance module and the objective navigation module
have been completely defined. It remains to be determined how the resulting outputs will be combined. To
solve this issue, a navigation module was built, as shown
in Fig. 4. This module receives nine inputs: three outputs
derived from each of the two previous modules and three
extra sensor values. These sensorial inputs are obtained


207

in the objective direction, as a way to introduce more
information regarding that specific and important
direction. For instance if the direction heading to the
goal is West, S1 will be the sensorial value in WNW

direction, S2 the sensorial value in W direction and S3
the sensorial value in WSW direction (see Fig. 2).
All these sensorial values are subjected to the handling procedure described in Sect. 9 and are further
scaled to [0,1], so that all inputs to the navigation
module are in this interval. This module thus has nine
inputs and three outputs that codify the direction to
follow according to Table 2.

because it is essentially driven by the outputs of the
navigation module (see Fig. 4). The supervisory module
training set was composed of 80 examples, and the test
set had 25 examples. These examples had two inputs:
– one that reflects the degree of convergence between
the output of the navigation module and the output of
the obstacle detection and avoidance module;
– the other presents a probability of the robot having a
cyclic behaviour.
The output of the supervisory module was binary,
indicating which functioning mode should be pursued:
navigation or obstacle contour mode.

5.4 The supervisory and angular memory modules
At this stage the systemÕs architecture is defined. Most
navigation situations presented to the architecture defined in Fig. 4 were successfully solved, as will be shown
in Sect. 15. There are, however, a few situations where
the robot exhibited a cyclic behaviour in simulation
environments. To circumvent these situations, two
changes were introduced to deal with the specific situations that were detected when the obstacles were much
larger than the robotÕs dimensions or when they presented peculiar configurations. Figure 6 presents three
examples of these situations, in which the robot is unable

to reach the desired objective, exhibiting cyclic behaviour. Figure 7 shows a simulator image, where the robot
is unable to surmount the obstacle to reach the goal
(placed behind it).
Thus, two additional modules were defined to cope
with situations where the proposed architecture failed:
the supervisory module and the angular memory module. The addition of these modules further serves to
demonstrate the modular approach advantages.
The supervisory module was developed to detect
obstacles whose dimension was much larger than the
robotÕs dimension, because a somewhat erroneous
behaviour was detected when such obstacles were present. The moduleÕs algorithm is represented in Fig. 8.
Analysing the algorithm, we can conclude that when this
neural module detects that the robot is in the presence of
a large obstacle, an obstacle contour mode is activated.
When this is not the case, the normal functioning mode
is used. This normal mode was called navigation mode,

Fig. 6 Examples of non-circumventable obstacles

Fig. 7 A simulation example of the robotÕs cyclic behaviour

Fig. 8 The supervisory moduleÕs algorithm


208

The obstacle contour mode favours the outputs of the
obstacle detection and avoidance module to establish the
direction to follow, as a strategy to contour the large
obstacle that the robot is faced with.

With the introduction of the obstacle contour mode
the systemÕs architecture abandons its co-operative nature and becomes competitive (see Sect. 5), in the sense
that there can be two functioning modes that compete to
navigate the robot.
When the functioning mode changes from navigation to obstacle contour and vice versa, there is a
possibility of repeatedly making mistakes. The angular
memory moduleÕs objective is to detect such situations.
To do this, the module keeps track of the angular
directions followed when there is a change in the
functioning mode, to detect cycles in the trajectory.
Using a circular memory, the transition points are
memorised and when a repetition is found an alternative direction is followed, as a way to break the cycle.
This module is not an NN, because its main feature is a
memorisation one.

6 Module construction
The topology and parameters of all the NN modules
defined so far were constructed and not determined ad
hoc. This section explains how the NN modules were
constructed.
A dynamic node creation [11] method, initially proposed by Ash [20], was used with a variant of the BP
algorithm. In this algorithm, sigmoid units are added,
one at a time, in the same hidden layer. Every time a new
unit is added, the training procedure takes place.
These algorithms are simple, since they are based on
the iterative learning algorithm application, maintaining
all the advantages of the constructive methods described
in Sect. 6. The learning algorithm used was a variant of
the BP algorithm, with a momentum coefficient, c and a
variable learning coefficient, a. The learning coefficient,

a, was updated according to the expression in Eq. 6,
where k represents the iteration.
8
k ẳ 0;
< 0:2;
ak ị ẳ
ak 1ị=2
k 2 f3; 7; 10; 31g  103 ; ð6Þ
:
aðk À 1Þ
otherwise:

As already mentioned, NN constructive algorithms
start with an initial configuration and add neurons until
some criterion is satisfied. Each neural module presented
in the architecture had its initial configuration determined by the number of inputs, the number of outputs
and the number of initial hidden units.
Table 3 summarises the results obtained, giving the
number of training patterns, the final configuration
achieved and the mean square error (MSE) obtained, for
each NN module.

7 Results
This section presents the results for several simulated
and real environments. In each figure, the robot is represented by a darker circle at the end of the defined
trajectory as in [21]. The other end is its initial position.
Figures 9 and 10 show simulated environments,
similar to real ones with several small obstacles that
interfere with the robotÕs navigation. In these examples
the objective is reached by the base modular architecture. As can be observed, the objective is reached while

avoiding all the small obstacles in these cluttered environments.
Figures 11, 12, 13 and 14 are further examples of
simulated navigation that show how the defined architecture deals with some situations through the supervisory module, since the robot was faced with large
obstacles. In these three examples the supervisory
module determines that there is a large obstacle, and the
obstacle contour mode is switched on. Once the obstacle
is overcome, the supervisory module switches back to
navigation mode and the objective can be easily reached.
Figures 15 and 16 show complex environments that
are solved by the changes made to the base architecture
(Sect. 13). It can be seen that the robot does not reach
the objective in a straightforward manner. In these two
examples, the peculiarity of the obstacles misleads the
robot in its first attempt, but the angular memory
module keeps track of the decisions made and prevents
repetition of the mistake when the robot reaches the

For the momentum term, c, the test was carried out
with values in [0,1], with a 0.05 step.
Table 3 Results obtained with the dynamic node creation method
Module

Test set

Configuration

North
East
South
West

Integrating
Navigation
Supervisory

120
30
30
30
32
396
25

5
3
3
3
5
9
2

fi
fi
fi
fi
fi
fi
fi

5
1

1
1
4
4
2

fi
fi
fi
fi
fi
fi
fi

2
1
1
1
3
3
1

MSE
0.028
0.001
0.001
0.001
0.001
0.002
0.002

Fig. 9 The trajectory defined with the base architecture


209

Fig. 10 The trajectory defined with the base architecture
Fig. 13 Entering an alley (the supervisory module)

Fig. 11 The trajectory defined by the architecture with the
supervisory module (from right to left)
Fig. 14 The trajectory defined by the architecture with the
supervisory module

Fig. 12 Leaving an alley (the supervisory module)

decision point the second time (in both cases it is the
point where it turns inside the obstacle).
Figures 17, 18 and 19 show simulator images of real
trajectories, taken by the NOMAD 200 mobile robot.
All three snapshots demonstrate that the robot is agile,
even in narrow confines. Figure 20 presents a real trajectory being performed in a cluttered environment by
the NOMAD 200 mobile robot.

Fig. 15 The path defined with the supervisory module and the
angular memory module

All the situations presented to the robot, in simulation and real environments were successfully dealt with,
i.e., the final goal was reached. When the supervisory or
angular modules had to step in, there was, as mentioned,

a cyclic behaviour that was broken.


210

Fig. 19 The real trajectory taken by the NOMAD 200 mobile
robot in a cluttered environment
Fig. 16 The path defined with the supervisory module and the
angular memory module, in an environment like the one illustrated
in Fig. 6c

Fig. 17 The real trajectory taken by the NOMAD 200 mobile
robot
Fig. 20 The NOMAD robot performing a real trajectory

Fig. 18 The real trajectory taken by the NOMAD 200 mobile
robot in an environment with front obstacles

8 Conclusions
NNs, because of their adaptive and learning abilities, are
often used in mobile robot navigation. But the use of a
monolithic NN has disadvantages that can be circumvented by the application of a modular strategy.
MNNs are major candidates for mobile robot
navigation in unknown dynamic environments. The

overload of sensorial information available for analysis
can be dealt with by using the divide and conquer
principle underlying MNNs.
This work has proposed a new modular architecture
to navigate mobile robots in unknown environments.

This architecture presented a performance improvement when compared with a monolithic NN, because
crosstalk problems were prevented and smaller architectures were achieved, yielding better final generalisation ability.
Taking advantage of the modular structure defined,
new modules were added to the base architecture, as a
way to improve its performance in specific situations.
Moreover, each moduleÕs internal structure has been
constructively determined, using a dynamic node creation Method. This algorithm allows an appropriatelysized topology to be designed for each neural module
and permits weight definition using a modified BP
algorithm.
The results obtained for the NOMAD 200 mobile
robot with this modular constructive architecture show
its effectiveness and robustness, showing that MNNs can
be used to navigate a mobile robot around obstacles,
without knowledge of the environment.


211

Future work will include the study of online learning
as a way to improve the system performance. If it is
found that the robot has made a mistake, it could be
possible to identify the module responsible and eventually re-train or re-construct it.
Another line of future work is the research into
potential improvements introduced by adding static
environmental information, such as artificial landmarks.
Acknowledgements This work was partially supported by the Por´
tuguese Ministerio da Ciencia e Tecnologia and the European
ˆ
Union through the R&D Unit 326/94 (CISUC).

References
1. Jacobs R, Jordan M (1993) Learning piecewise control strategies in a modular neural network architecture. IEEE Trans Sys
Man Cybern 23(2):337–345
2. Haykin S (1999) Neural networks—a comprehensive foundation. Prentice Hall, New York
3. Sharkey A (ed) (1999) Combining artificial neural networks.
Springer, Berlin Heidelberg New York
4. Ronco E, Gawthrop P (1995) Modular neural networks: a state
of the art. Technical report: CSC-95026, Centre for System and
Control, University of Glasgow, Glasgow, UK
5. Parekh R, Yang J and Honavar V (1995) Constructive neural
network learning algorithms for multi-category pattern classification. Technical Report TR95–15, Artificial Intelligence
Research Group, Department of Computer Science, Iowa State
University, Ames, IA
6. Krose B and van Dam J (1997) Neural vehicles. In: van der
Smagt P, Omidvar O (eds) Neural systems for robotics, Academic Press, New York
7. Baum E, Haussler D (1989) What size net gives valid generalisation? Neur Comput 1:151–160
8. Auda G, Kamel M (1999) Modular neural networks: a survey.
Int J Neur Sys 9(2):129–151

9. Nehmzow U (1992) Experiments in competence acquisition for
autonomous mobile robots. Dissertation, University of Edinburgh
10. Sarkey N, Heemskerk J (1996), The neural mind and the robot.
In: Browne A (ed) Current perspectives in neural computing,
IOS Press, Amsterdam, The Netherlands
11. Kwok T, Yeung D (1997) Constructive algorithms for structure
learning in feed forward neural networks for regression problems. IEEE Trans Neur Ntwks 8(3):630–645
12. Mataric M (1992) Integhration of Representation Into GoalDriven Behavior-Based Robots. Proceedings of the IEEE
Transactions on Robotics and Automation 8(3)
13. Mayoraz E, Aviolat F (1996) Constructive Training Methods
for Feed Forward Neurol Networks with Binary Weights. Int J

Neur Sys 7(2)
14. Mozer M, Smolensky P (1988) Skeletonization: a technique for
trimming the fat from a network via relevance assessment. Adv
Neur Info Proc Sys 1:107–115
15. Pomerleau D (1991) Rapidly adapting artificial neural networks for autonomous navigation. Neu Inf Proc 3:429–435
16. Dracopoulos D (1998) Robot Path Planning for Maze Navigation. Proceedings of the 1988 IEEE World Conference on
Computational Intelligence, pp 2081–2085
17. Schmidt A, Bandar Z (1997) A Modular Neural Network
Architecture with Additional Generalisation Abilities for Large
Input Vectors. Proceedings of the 3rd International Conference
on Artificial Neural Networks and Genetic Algorithms
(ICANNGA 97), Springer, Berlin Heidelberg New York,
pp 40–43
18. Jacobs R, Jordan M (1991) A competitive modular connectionist architecture. In: Lippmann et al. (eds) Neural Information Processing Systems 3, vol. 3
´
19. Silva C, Cristomo M, Ribeiro B (2000) Monoda: A Neural
Modular Architecture for Obstacle Avoidance Without
Knowledge of the Environment. Proceedings of the 2000
International Joint Conference on Neural Networks
20. Ash T (1989) Dynamic node creation in backpropagation networks. Connect Sci 1(4):365–375
´
21. Silva C, Cristomo M, Ribeiro B (2000) A Modular Learning
Architecture for Navigating NOMAD Mobile Robot. 8th
International Conference on Information Processing and
Management of Uncertainty in Knowledge Based Systems