System requirements

• Windows 7 / 8 / 10
• 1,0 GHz CPU
• 256 MB RAM
• 30 MB HD

Mathematical Model used by MemBrain

The neuron and link model of MemBrain is highly flexible: Everything from simple time invariant Feed-Forward Networks to Nets with spiking neurons, arbitrary loopback connections and signal runtime delays on the links can be simulated. It is even possible to directly connect the output of a neuron to its own input. 

In principle every net in MemBrain is a valid net. Through the consequently object oriented approach every neuron and also every link in MemBrain can have different properties. Links can have user-defined logical lengths, so that real runtime behaviour can be simulated and visualized. 

Feed Forward  Net	Net with loopback links	Snapshot of a chaotic net with  many loop backs. In the center  of the net  there is a neuron that  spikes randomly.

                                                Click pictures to enlarge.

The exact mathematical model for neurons and links used by MemBrain is detailed in MemBrain's HTML help.

Available learning algorithms

Currently the following learning algorithms are implemented in MemBrain.

Supervised learning (also for Autoencoder sub-networks and for Convolutional neural nets):

• Backpropagation (only forward links are trained)
• Backpropagation with momentum (only forward links are trained)
• Backpropagation with support for loopback links
• Backpropagation with support for loopback links and with momentum
• RPROP (Resilient Backpropagation) with support for loopback links
• Levenberg-Marquardt (only forward links are trained)
• Cascade Correlation with support for loopback links (using Backpropagation with momentum)
• Cascade Correlation with support for loopback links (using RPROP)
• Trial and Error with support for loopback links

Unsupervised learning:

• 'Winner Takes it All' for SOMs ('Self Organizing Maps').

The MemBrain DLL

Many functionalities of MemBrain are also available as a DLL (Dynamic Link Library). Two DLL versions are provided: 32 Bit and 64 Bit.

With the MemBrain DLL you can incorporate neural nets that have been designed with MemBrain 
into your own applications no matter which programming language you use. 
The DLL features:

• Loading an arbitrary number of neural nets from MemBrain files
• Assigning values to the input neurons of the nets
• Performing simulation steps of the nets
• Reading back the results from the output neurons of the nets
• Saving the nets back to file
• All functionalities to train the nets, to create, load, import and export data sets and much more
• All functionalities to create and edit neural nets

By this means it is easily possible to incorporate neural nets from MemBrain into a production system without the need of having MemBrain running in parallel and without having to deal with the TCP/IP interface or the scripting language of MemBrain.
Additionally, applications can be designed that create and/or edit neural nets during run time and thus can dynamically adapt to new problems.

The MemBrain DLL is included in the installation packet of MemBrain, the corresponding files will be 
copied to a separate sub folder automatically during the installation. In the download area you will find 
an example on how to use the DLL from within Microsoft Excel VBA (Visual Basic for Applications).

Java users are provided with a JNI wrapper DLL and a corresponding Java class to directly access the 
DLL from Java programs. The Java class file contains comments on how to use the files. Both, the 
wrapper DLL and the Java class file are copied to the DLL folder during intallation automatically.

An object oriented set of C# wrapper classes is available for free, too (see  download area).

Certainly the MemBrain DLL also is accessible from the C/C++ programming language.

Detailed information on the DLL is included in the corresponding header file "MemBrain_inc.h".

Automatic Code Generation

MemBrain features a code generator which can translate a currently loaded neural net into C or C++ code that can be compiled using any standard C or C++ compiler so that the nets can be run within user software (e.g. on an embedded platform). 

The generated code can model every aspect of MemBrain neural nets starting from the simple Feed-Forward net up to nets that feature time variant components, delays on links, loopback links, random firing  ect. 

The code consists of a fix library portion which is generated during the installation of MemBrain and two files that are dynamically created by MemBrain for every single net: A header and an implementation file. The MemBrain-generated implementation file provides net specific definitions of constants.
The header file publishes some important definitions for the net and incorporates the preprocessor directives which optimize the library code according to the generated net.

For this purpose the net is subjected to a detailed analysis procedure in order to only invoke the library portions that are absolutely necessary to implement the net. This approach ensures that MemBrain always generates code that is highly optimized according to the user's needs and provides maximum prformance with minimum memory requirements.  

C Code generation follows a 'relaxed ANSI-C' standard. I.e. all relevant ANSI-C rules are obeyed, however, the code makes use of some common extensions like single line comments in C++ style. The C++ library uses some elements of the the C++ standard library like containers (array) for instance.
With respect to the possible use on embedded targets no dynamic memory allocation is used. 

The code provides the following means to operate the generated net.

• Reset and initialize the net
• Assign input activations to the input neurons
• Execute simulation steps of the net
• Read back results from the output neurons
• The C++ variant allows to use an arbitrary number of the same or different exeported neural nets in your application in parallel

The mentioned code libraries are included in the installation packet of MemBrain. The corresponding files are automatically copied into corresponding sub folders during the installation. The MemBrain help (press F1 in MemBrain) contains details about using the code in your own applications.

object oriented scripting language

MemBrain features a powerful, fully featured object oriented scripting language. Almost all operations in MemBrain are available through scripting, too.

Scripts also provide a means for remote controlling MemBrain from other software or for preparing 
small presentations that show live operation of neural nets.

MemBrain scripts can interact with the user in many ways including message boxes, file open or 
save dialogs, numerical and string value input fields, trace window text output etc. Due to the 
powerful maths and file operations available in MemBrain scripts can also be used to optimize 
neural net training and validation strategies according to user's needs. E.g. scripting can be 
used to select optimum learning parameters and neural net candidates automatically based on 
user defined algorithms.

Furthermore, MemBrain's scripting language contains powerful functions to create and modify 
neural nets. Thus, even your own evolutionary algorithms for net design can be realized through scripting. 

The MemBrain scripting language is based on the scripting engine AngelScript which provides a strongly typed C++/Java like scripting language. The scripts are compiled into byte code by MemBrain before execution which guarantees optimum runtime performance.

MemBrain Scripts can be executed in several ways:

• Manually, via the menu <Scripting> in MemBrain
• From the command line, as parameter to MemBrain.exe
• Through a special file interface while MemBrain is running
• From within the external graphical script debugger

Details on executing scripts via one of the named ways are contained in MemBrain's help file.

Examples of MemBrain scripts are available in the download area.

Source Level Debugger for scripts

MemBrain features a powerful graphical debugger for scripts including the following features:

• Syntax highlighting
• Fully featured text editor, including block indentation, copy/paste, search function, bookmarks...
• Compile, build run and pause script remotely from within debugger
• Build output window: See compiler messages directly in the debugger window, jump to code location via mouse click
• Debug output window
• Variable watch window
• Graphical breakpoints
• Step Into, Step Over, Step Out
• Attach debugger to running script
• Run debugger on the same machine as MemBrain or on an other machine within the LAN
• Start debugger from within MemBrain
• Start MemBrain from within the debugger

The following screenshot shows the debugger in action:

Click picture to enlarge

automatic Network analysis

You don't have to tell MemBrain what net architecture you're currently building up. Just place as many neurons as you like and where you like and connect them in the way you like. Besides the possibility of interconnecting neurons by drawing single links there are also mighty editing features available in MemBrain that allow insertion of thousands of links with a few mouse clicks.

The integrated neural network analysis feature detects the logical structure of the net, like layers and loopback links, whenever needed automatically in background. This information can be visualized, too.

	Example result of the network analysis Click picture to enlarge.

Encryption

MemBrain provides an optional, integrated password controlled 256 bit AES encryption for neural nets and data set files (lessons). Files which use this procetion can only be opened by MemBrain or the MemBrain DLL with the correct password.

Die used AES encryption represents one of the strongest encryption techgnologies available today.

Multi Core support

MemBrain automatically determines the optimum usage of the available computing cores of the operating system. Through this MemBrain always only takes as much of the available computing power as reasonable with respect to the currently operated neural net. The rules for determining the number of used cores can even be adjusted by the user if desired.

Moreover, the process priority of MemBrain is freely adjustable via the MemBrain menu so that the actual burden of MemBrain on the computer becomes adjustable in a wide range.

Reading data from image/picture files

MemBrain supports direct reading of gray scale pixel data from a huge variety of picture file formats. Before reading the image files and converting them to gray scale pixel values the images can optionally be re-samples to a lower resolution and image format.

This massively simplifies generation of neural net input data from picture files.

Open TCP/IP interface

MemBrain incorporates the possibility to connect to other MemBrain instances or MemBrain compatible device drivers over a TCP/IP link. It doesn't make any difference if the other applications are running on different computers or on the same machine.

MemBrain's TCP/IP Weblink protocol is provided as part of the context sensitive HTML help that comes with the application.

	Click picture to enlarge.

The screen shot shows a picture matrix of 160 x 120 input neurons, invoked into a neural net over TCP/IP from the 'MemBrain Picture Driver' which is also available for download in the download area.

Neurons can be displayed as grey scale pixels in MemBrain depending on their current activation value.
This gives the impression of a monochrome bitmap.

  Other screenshots

Click pictures to enlarge.

Detection of handwritten digits using a multi stage Convolutional Neural Network with Pooling layers	Importing neurons over TCP/IP (Here: From a second MemBrain instance)
Configuration of  'winner takes it all' Learning algorithm	Training of a SOM (Here: Map of Belief)
Training a time variant network to predict future values of the chaotic Mackey-Glass time series.	Comprehensive HTML-Help