Site hosted by Build your free website today!





Design and Implementation of a Flexible Simulation Tool for Hybrid Problem Solving

H. Geiger 1, J. Pfalzgraf 2, A. Bücherl 3, K. Frank 2, T. Neuböck 2, J. Weichenberger 2


This contribution presents a new simulation tool which incorporates several modules, for simulation of artificial neural networks (ANN), fuzzy reasoning (FR), genetic algorithms (GA), robotics and computer algebra (CA) - or more general symbolic computation - for hybrid problem solving tasks.

Keywords: ANN, GA, fuzzy reasoning, robotics, hybrid simulation tool

1  Introduction and Motivation

This contribution presents a new simulation tool which should be capable to allow flexible applications in the context of hybrid problem solving. The title might suggest ``yet another simulator'', but we try to explain why we decided to work on a simulation tool as described below. The starting point has been the long lasting cooperation contact between H.Geiger and J.Pfalzgraf (formerly at RISC-Linz, University of Linz) and their working groups, respectively. This cooperation is now being continued with the new group of the second author at the Salzburg computer science department. The artificial neural network group at RISC-Linz (established by the second author) used the connectionist network simulator ``NEUROtools'', an extended and modified version of ``NETUSE'' which goes back to original work of H. Geiger and his group at the company KRATZER Automatisierung. In the course of many discussions a diploma student at RISC-Linz, J.Sixt, who used the NEUROtools extensively, made a list of drawbacks of that simulator and he proposed possible improvements of the tool - all this has been approved and partially inspired by H.Geiger. The result was a diploma thesis in which a new command language has been developed which forms the basis of the flexible simulation tool as discussed in this article. We think that it is a real improvement of the existing NEUROtools (nevertheless, we are aware of the fact that NEUROtools showed and still shows its power in industrial problem solving). Besides the new language features of our new tool the idea is to have an ``open system'' that means for real hybrid approaches we need interfaces to other systems which have proven to be useful for problem solving. Thus, we want to integrate simulation of Artificial Neural Networks (ANN) (the core of the tool) in a very flexible way (``arbitrary'' networks should be possible to simulate).

In addition to that we design interfaces to Fuzzy Reasoning (FR), Genetic Algorithms (GA), Computer Algebra (CA) - or more general symbolic computation - and last but not least to robotics simulation. Actually, ``historically'' the combination of an ANN simulator and a robotics simulator was our original goal, as mentioned and discussed in the diploma thesis of J.Sixt. With this working area the RISC-Linz group became a former associated member of the ANN section of the European project JESSI.

A general principle in our work will be to incorporate as many existing software packages (from NEUROtools) as possible in the sense of a ``library''. Of course, the new tool will have the option to simulate time coded neurons (single spike models), based on work of H.Geiger and his group. We also refer to [Ede95], KRATZER Automatisierung.

Another new aspect is given by cooperation work of the first and second author [GP95], [GP]. It turned out after many fruitful discussions that certain mathematical modeling methods lead to a simplified mathematical description of Geiger's ANN paradigm. This can be exploited in the simulation of the networks and results in a considerable ``economy'' in concrete applications. That is to say, by the mathematical model it is possible to reduce storage capacity, to enhance speed-up, and even to save costs in hardware application - for more details we refer to the cited references.

We would like to underline that a major goal of our project should be the capability to perform hybrid problem solving approaches with a felxible simulation tool.

Until now the command language (i.e. kernel) is completely implemented. Currently we are implementing the ANN module.

2  Existing Work

In this section a short schedule of existing work will be presented:

  • Th. Waschulzik implemented the first release of an ANN simulator called NETUSE, which goes back to the ideas of H. Geiger and his ANN paradigm [Was87].
  • K. Eder implemented a new neuron model, called Single Spike Model (SSM), for NETUSE in his doctoral thesis [Ede95].
  • A. Bücherl implemented an extension of NETUSE, which combines fuzzy systems and ANNs [Büc94].
  • J. Sixt designed a new version of NETUSE, which provides more flexibility (object-oriented modelling principle, simple programming language) and the possibility to integrate a set of external modules (integration of ANN, fuzzy reasoning, genetic algorithms, symbolic computation, robotics) [Six94].
  • Th. Hainzl implemented a fuzzy reasoning tool especially for fuzzy control with an interface to ANN [Hai95].
  • M. Meisinger used genetic algorithms for generating ``optimal'' ANN topologies [Mei95].

3  Specification of the New Tool

In practice ANN's often consist of many neurons (especially Geiger's paradigm of locally regularly structured networks). Furthermore, the integration of different problem solving methods (both subsymbolic and symbolic approaches) are of great interest. Therefore two requirements for a new simulation tool can be stated:

  • Flexibility: The work with ANNs is characterized by three main steps which are usually repeated many times until one receives an appropriate solution: network definition, training, recall (applying a trained network). Especially for big networks it is useful to carry out these steps in a flexible way. Both a graphical user interface and a simple (line oriented) command interpreter, which only supports built-in commands, restrict the work. A command language, which provides all important elements of a ``usual'' programming language (loops, if-conditions, function definitions etc.) seems most suitable.
  • Integrational aspect: To combine different solution methods and application areas (ANN, fuzzy reasoning, genetic algorithms, symbolic computation, robotics etc.) problem specific modules and the problem independent command language (kernel) must be linked in an appropriate way. For this reason some interface conventions are necessary when implementing these problem specific modules.

J. Sixt, in his diploma thesis, specified the structure of a new simulation tool which satisfies these requirements: Neural Command Interpreter (NCI6t). Originally, the objective of his work was to integrate ANN (especially Geiger's paradigm) and robotics simulation [Six94].

3.1  The System Architecture

The new simulation tool is based on an open system structure. The core is made up by NCI6t. This module represents the problem/method independent part of the simulation environment. The problem specific functionalities and the various problem solving methods are kept in different modules (Fig. 1): ANN, fuzzy reasoning, genetic algorithms, computer algebra, robotics.

Figure 1: System Structure

The whole simulation tool is/will be implemented in C++. The application program combines the modules:

int main(int, char *[])
   NciRegisterClass( &rcmLayerClassSE );
   NciRegisterClass( &rcmNeuronTypeClassSE );
   NciRegisterFunction( ... );
   NciRegisterVariable( ... );
   return 0;

First, the problem specific parts (classes, functions, global variables) are made known to the symbol table of the kernel NCI6t. This is done by the functions NciRegisterClass, NciRegisterFunction and NciRegisterVariable. Then the control is transfered to the interpreter NCI6t (NciInterpret) which waits for the user's input (keyboard or input file).

3.2  The Kernel Language

The kernel language (which is already completely implemented) is a simple C-like programming language, which supports

  • control structures (if-, for-, while-statements etc.),
  • definition of functions, variables and constants (strictly typed language),
  • some built-in commands like exit, ?? (printing command), include (including another command file) etc. and
  • the use of instances of classes which are implemented in C++ (the definition of new classes is not possible).

Although no classes can be defined by the command language one can use instances of classes at the interpreter level, e.g. [Six94]:

NeuronType nt_input = new BPNeuronType(0.0, 0.0);
NeuronType nt_output = new BPNeuronType(0.2, 0.3);
Layer input = new BPLayer(nt_input, 20, 20, 1);
Layer output = new BPLayer(nt_output, 15, 15, 15);

These classes are defined in the problem dependent modules (in C++) and are made known to the interpreter (NciRegisterClass). Functions can also be implemented in C++ and registered in the symbol table of the interpreter, but they can also be defined at the interpreter level.

3.3  The ANN Module

One main objective for the design of the ANN module is to facilitate the definition of networks in the sense of Geiger's paradigm where the following constituents are of importance (for description see e.g. [Was87] or [Six94]):

  • View
  • Distribution
  • Projection

According to these components an appropriate class structure was designed (Fig. 2). This structure also allows to create simulations of ``traditional'' networks like multi-layer perceptrons easily.

Figure 2: ANN module

The base classes (NeuronType, Layer) provide common funcitonality of all neuron models. Specific models are concretized by derived classes (RCMNeuronType, RCMLayer etc.). The data classes (Data, ByteData, FloatData) handle the input and output of network data. The classes View, Distribution and Projection are used for all neuron models. They allow to build up connections at an ``abstract'' level (e.g. take each neuron n of the postsynaptic layer within a ``cube'', transform it to a neuron o of the presynaptic layer, take all presynaptic neurons within a ``square'' with origin o into a set pre and connect n with all neurons in pre). The class Network contains some supervisor functionality (e.g. load/save the network state from/to a file, register a new layer etc.). NciObject is only used for technical purpose. All classes which should be used at the interpreter level must be direct or indirect subclasses of NciObject.

The model independent classes of the ANN module are already implemented. Now we are going to realize the model specific parts (e.g. Single Spike Model).

4  The Single Spike Model (SSM)

Most neural network models use model neurons that describe the neurons' state by one single number usually designated äctivity" (either binary, i.e. 0,1, -1,+1 or continuous, i.e. [0...1.0], [0,255]). This number represents the number of action potentials (APs per time unit) for a given neuron. All information about the exact time of single action potentials is thus lost. Since triggering of postsynaptic APs critically depends on the superpositon in time of incoming APs, an additional dimension is added for the information flow between neurons by using this time dependency. "Real" neurons therefore should be represented by: their average activity and the exact time for each AP. As has been pointed out by von der Malsburg, (cf. [vdM85]) using this additional channel yields virtually ``natural'' solutions for difficult problems such as figure-ground-problems in pattern recognition, but also time sequence storage, improved associative memories etc.. Of course, the SSM will be a substantial part of our new simulation tool.

5  A Simplifying Mathematical Model

In order to save space we are keeping this section very short (as we did in the previous section) and we refer to the references [GP95], [GP]. A few words about a mathematical modeling approach of H. Geiger's ANN paradigm (cooperation work of the first and second author). It turned out that we were able to apply geometric and categorical methods to develop a mathematical description of the ANN model which resulted in a considerable ``economy'' of the formal model representation. It has been an unusual experience that it has been even possible to measure this simplification economically, that means in terms of saved production costs in an industrial project performed by H. Geiger. Shortly spoken, by applying the mathematical model the whole simulation could be really simplified which led to a considerable performance improvement. This fact will be an important aspect for ANN simulation in our new tool.

A remark about the role of categories. In category theory ``objects'' and ``morphisms'' are basic notions. Actually, in our joint work it turned out that the objects can be interpreted as ``geometric nets'' and a morphism is a ``learning step'' and all this can be done in a natural way. It would not be necessary at all to resort to categorical notions, but it helped a lot to obtain a transparent ``linguistic modeling framework''.

6  Aims of the Project

The intention of this project is to implement a flexible simulation environment having the goal to integrate

  • a module for ANN-Simulation in an ``unlimited way'',
  • a fuzzy reasoning module,
  • a genetic algorithm module,
  • a robotic simulation module and
  • symbolic computation (computer algebra system).

An ultimate goal will be to work with these combined modules in an interactive way. Original motivations come from ANN-applications to robotic kinematic problems (``learning the kinematic model of a robot arm''). To reduce limitations of a pure symbolic approach for simulating a robot kinematic chain we plan to establish a hybrid symbolic-connectionist network modelling approach. That means one part of a robot arm will be modelled purely symbolically (e.g. exploiting the Denavit-Hartenberg transformations to implement a closed symbolic solution of the inverse kinematics) the other part will be represented by a suitably trained connectionist network. We expect an overall reduction of complexity by using such hybrid approaches in robotics simulation. Furthermore we keep in mind that in concrete (industrial) robotics applications sensors are used to manage the ``fine path tracking control problem''.

Fuzzy reasoning will be represented by a separate module for pure fuzzy control and fuzzy logic applications [Hai95] and in combination with ANN. For the latter aspect we resort to ``Neuro-Fuzzy System'' [Büc94]. Such a combined neuro-fuzzy system has been developed and implemented separately by A. Bücherl. In this implementation fuzzy rules are translated into neural networks which are trained to modify the membership functions of the fuzzy system. By the last step the trained network will be transformed back to the improved fuzzy rules by means of a modified center of gravity method.

M. Meisinger designed a simulation tool which combines Neural Networks and Genetic Algorithms [Mei95]. In his approach ``optimal'' network topologies can be generated by application of genetic algorithms.

The new tool is constructed in such a way that it allows to integrate as good as possible already existing modules (as previously mentioned). Moreover we intend to integrate existing software components as already available in NEUROtools, robotics simulation, computer algebra, etc.. We are aware of the fact that this cannot be done in a smooth straight forward way and we know about the limitations of this intention.

7  Concluding Remarks

The design and implementation of a flexible simulation tool based on a newly developed specification language has been presented in this contribution. Besides the technical facts we tried to motivate the origins and the development of our project. It is hoped that in the end all our intentions and wishes will be practicable in that simulation environment. It is in the spirit of our joint work to be flexible enough to integrate further tools for hybrid problem solving.


Angela Bücherl. Reversible Übertragung von regelbasierten Systemen in adaptive Form durch Implementierung als neuronale Netze. Master's thesis, Technische Universität München, 1994.

Klaus Eder. Repräsentation temporaler Information in künstlichen neuronalen Netzen (Doctoral Thesis). VDI Verlag, Reihe 10, Nr.402, 1995.

Hans Geiger and Jochen Pfalzgraf. Modeling a connectionist network paradigm: Geometric and categorical perspectives. In preparation.

Hans Geiger and Jochen Pfalzgraf. Quality control connectionst networks supported by a mathematical model. In A.B.Bulsari and S.Kallio, editors, Proceedings Engineering Applications of Artificial Neural Networks (EANN'95), Ontaniemi, Finland, 21-23 August, 1995, pages 57-60. Finnish AI Society, 1995.

Thomas Hainzl. A Simulation System for Applied Fuzzy Control with an Interface to Connectionism. Master's thesis, RISC-Institut, Johannes-Kepler-Universität Linz, Austria, 1995.

Markus Meisinger. Evolving Artificial Neural Networks by Genetic Algorithms. Master's thesis, RISC-Institut, Johannes-Kepler-Universität Linz, Austria, 1995.

Johannes Sixt. Design of an Artificial Neural Network Simulator and its Integration with a Robot Simulation Environment. Master's thesis, RISC-Institut, Johannes-Kepler-Universität Linz, Austria, 1994.

C. von der Malsburg. Am I thinking assemblies ? Proceedings of the Trieste Meeting on Brain Theory, 1985.

Thomas Waschulzik. Optische Mustererkennung in neuronalen Architekturen. Master's thesis, Technische Universität München, 1987.

File translated from TEX by TTH, version 2.79.
On 25 Nov 2000, 12:39.