The Neurodynamics and Evolutionary Robotics Development Kit (NERD) is developed as part of the ALEAR
project.
NERD aims to become a versatile evolutionary robotics environment that is easy to use for different types of robots and neuro-controllers.
Including this goal, an easily usable mechanism of defining own motors and sensors is planned. The built-in robot simulator is based on a
physical abstraction layer that allows the exchange of the underlying physics engine with little effort (e.g. ODE, IBDS). This offers the possibility
of trying new physics engines.
Concepts
Modularity
To achieve a high degree of modularity and extendability, NERD uses several mechanisms in addition to common
object oriented programming techniques, that proved their usability and their potential to reduce the
implementation effort for applications with rapidly changing requirements. These mechanisms facilitate not only the usage of the library in a wide variety of applications,
but also provide a simple way to extend existing applications with user specific plug-ins. In the next release
users will for instance be able to extend the simulators with own motor models, agents and embedded controllers.
There are two main mechanisms used to enhance modularity and to decouple functional modules from each other:
an event processor and a variable repository.
Event Processor
NERD uses an event system for the interaction of functional modules. This system provides a run-time interface
for modules, using the classical observer pattern. Modules can create events at a globally available manager
instance and trigger these events to signal the occurrence of relevant events, e.g. the start or finalization
of a simulation phase or the detection of a collision in the simulator. Other modules interested in such an
event can register at the global instance to be notified at its occurrence. In difference to the signal-slot
mechanism provided by Qt, NERD events do not require a module to know the owner of an event at compile time.
Instead NERD events are identified by simple strings and resolved at run-time. Therefore it is easy to exchange
both, owners and event subscribers, with minimal changes at the application. Furthermore highly portable plug-ins
and modules can be implemented that allow users to select the required events manually at run-time and therefore
can be used in many different contexts.
Blackboard Architecture with a Global Variable Repository (GVR)
Modules in the library can exchange information using a global variable repository. This repository provides
access to variables identified by path names, similar to directory names in an operating system. Any module
can publish variables in this value repository, and read variables published by other modules. To access a
variable a module requires to know the name of the variable, not the owner of the parameter. Therefore modules
can easily be exchanged - as previously described for event processing - as long as the replacement of a module
provides the same set of variables at the variable repository.
(1) Three components add variables to the global variable repository. (2) Components connect to local variables of other components using the global names of these variables via the global variable repository. (3) Even if components are exchanged with very different other components (A,B replaced by D,E), all dependent components (C) can still work properly, as long as the required variables are available in the global variable repository.
Variables in the repository support a notification mechanism. In case a variable is changed, all modules
registered for notification are informed about the change.
All variables encapsulate a specific data type (e.g. bool, int, double, string, color, vector3d) and provide
corresponding methods to read and write the variable. Variables in the repository additionally provide a set of
methods to read and write the variable by using simple strings. Thus each variable comes with a build-in string
parser and string composer, to handle the strings to match the specific encapsulated type. So all variables in
the repository can easily be stored to files, displayed in user interfaces, modified with simple text fields or
loaded from files, independently of their encapsulated type.
The string interface of variables enables the implementation of general user interfaces allowing the observation and
modification of all repository variables in a uniform way. New modules therefore automatically get a simple
configuration tool to adjust all of their parameters, if these parameters are published in the repository. The
implementation of such a configuration panel then becomes optional.
Simulator
The NERD simulator is an extensible simulation framework used to simulate arbitrary rigid-body experiments with any number of robots.
The underlying physics engine can be replaced so that, in principle, also uncommon experiment become possible, such as with airodynamics or under-water engines (not implemented yet).
Simulation environments in an NERD simulator can be defined with simple XML, so that experiments can be set up without programming knowledge. New motor and sensor models can be added via C++ plug-in to adapt a simulation to a physical robot, so that the transfer of evolved neuro-controllers becomes more successful.
Physical Abstraction Layer
NERD currently uses the Open Dynamics Engine (ODE) as primary physics
library to simulate the rigid body dynamics. However it was designed to work with a large number of physics
engines, such es the promising Impulse-based dynamic simulation engine (IBDS). NERD uses an
abstraction layer to describe, configure and manipulate physical objects. Because the physics library is hidden
behind this abstraction layer, it can be exchanged with little effort. Other modules, depending only on the
physical abstraction layer, remain unaffected by such a change. This enables the NERD library to make use of new
upcoming physics simulation technologies and to pursue very different strategies to accurately model motors and
sensors of the robots.
Object collisions in the simulation are resolved within the native physics or collision detection library, thus
behind the physics abstraction layer. After each simulation step collision information is projected to a physics
independent format and can be used by any module without dependencies to a specific physics or collision library.
Neural Network Library
NERD features an extensible neural network library to simulate artificial recurrent neural networks to control agents
in the simulations. The default network model is a time-discrete neuron model, that allows the selection of different transfer functions, activation functions and synapse functions for each neuron and synapse. Synapse functions can be used to implement local learning rules or higher order synapses as a simple extension of the model. The network model can be extended or replaced with custom network models, such as
radial basis function networks or time-continuous neurons.
In addition the NERD library provides a rich neural network editor to construct neural networks with graphical interaction, to analyze neurons while controlling an agent, or to prepare networks as initial seed for evolutions. Analysis of networks is supported by different kinds of plotters, tools to perform pruning experiments in active networks, visualization of activations of the network, and more.
Evolution Library
NERD provides a set of libraries to use evolutionary algorithms to design suitable controller networks for simulated agents. The graphical user interface is designed to work with any evolutionary algorithm, as long as the implementation of the algorithm follows some simple conventions. This allows users to extend the applications by custom algorithms without the need to implement a user interface for them. Also independent of the algorithms, a set of statistics and logger components simplifiy the observation, intervention and analysis of evolution experiments.
Currently the NERD library supports the following evolution algorithms for neural structure evolution:
ENS3 (Evolution of Neural Systems by Stochastic Synthesis)
Fitness functions can be implemented either as C++ plug-in or scripted in a language similar to JavaScript. With both methods the fitness function has access to all variables of the global variable repository and to all event. Therefore it can use all available information about any object, agent or neural network to define the fitness criteria of an experiment.
