Joone (Java Object Oriented Neural Engine)

Category Intelligent Software>Neural Network Systems/Tools

Abstract Joone (Java Object Oriented Neural Engine) is a free Neural Network (NN) framework to create, train and test artificial neural networks.

The aim is to create an advanced environment both for enthusiastic and professional users, based on the newest Java technologies.

Joone is composed of a ‘central engine’ that is the fulcrum of all applications that are developed with Joone.

Joone's NNs can be built on a local machine, be trained on a distributed environment and run on whatever device.

Everyone can write new modules to implement new algorithms or new architectures starting from the simple components distributed with the core engine.

The main idea is to create the basis to promote a zillion of Artificial Intelligent (AI) applications that revolve around the core framework.

The Framework -- Joone is a 'Java framework' to build and run AI applications based on NNs.

Joone consists of a modular architecture based on 'linkable components' that can be extended to build new 'learning algorithms' and NN architectures.

All the components have specific features, like persistence, multithreading, serialization and parameterization that guarantee scalability, reliability and expansibility, all mandatory features to make Joone suitable for commercial applications and to reach the final goal to represent the future standard of the AI world.

Joone applications are built out of components. Components are pluggable, reusable, and persistent code modules.

Components are written by developers. AI experts and designers can build applications by gluing together components with a graphical editor, and controlling the logic with scripts.

All the modules and applications written with Joone will be based on the above reusable components. Joone can be used to build Custom Systems, adopted in an embedded manner to enhance an existing application, or employed to build applications on Mobile Systems.

Joone has its own GUI editor to visually create and test any NN, and a Distributed Training Environment to train in parallel mode many NNs to find the fittest one for a given problem.

The GUI editor -- is a graphical user interface to visually create, modify and train a NN.

It's based on a graphical framework called JHotDraw (JHotDraw is a two-dimensional ‘graphics framework’ for structured drawing editors that is written in Java.)

The GUI editor main features are:

1) Creation of any architecture, according to the nature of the core engine;

2) NN save and restore from a file system;

3) Setting of all parameters for each component of the NN;

4) Checking for the correctness of the NN;

5) Use of pre-processing and control plug-ins;

6) A complete macro editor to define and control the scripting code;

7) A control centre to train the NN;

8) A charting component to visualize the output values of the NN;

9) A flexible environment based on XML files to add new layers, synapses, etc. to the editor's palette;

10) Exporting of the embedded NN to distribute and run it on external applications.

The Distributed Training Environment (DTE) -- The idea that underlies Joone is to build a professional environment to create, train, distribute and use NNs in a simple but advanced way.

To accomplish this final goal, the manufacturer has built a distributed training environment to train in parallel many NNs.

The manufacturer's dream is to provide a professional framework to permit everyone to build NNs that could be trained on a lot of common problems of the real life suitable to be resolved by the NNs (spoken and handwriting recognition, stock quotes forecasting, credit loan assessment, life science applications, etc.), and then distribute these trained NNs to interested users (final users, sales force, scientists, researchers, etc.) that can use the trained NNs on their devices (desktops, palmtops, PDA, etc.).

Thanks to this framework it would be possible to originate a 'NN Farm' that could fabricate NNs by training them in parallel on several machines, and finally distribute them to the final users (e.g. for free, or as a prepaid service), to 'train once, run anywhere' a NN without being worried about the Hardware (HW) or Software (SW) platform owned by the end-user.

Joone has its own complete and professional framework where it's possible to create a NN (with the GUI editor), and then teach several copies of it on many machines where some agents are running (they are also based on Joone's engine).

Those agents (or Workers) receive a copy of the NN and train it, sending back the outcome (i.e. the trained NN) to the starting machine where the user, or an automatic script, can control all the results of the distributed training process, being so able to choose, at the end of the process, the best NN, by applying some discriminating mechanism: e.g. choosing the NN with the lowest error, applying a 'genetic algorithm', etc.

Parameter Selection - You could also use the DTE to train different NN architectures, in order to verify the influence of a different number of hidden neurons, a different weights initialization, a different initial learning rate, a different input temporal window' size, or... whatever combination of them.

The Distributed Training Environment (DTE) features are:

1) Console based interface;

2) Centralized control;

3) The Final results are logged into a XML file to permit you to analyze the results from a custom program/script;

4) The training process can scale almost linearly adding more machines;

5) No manual configuration needed to add or remove machines;

6) Possibility to add or remove machines dynamically during the training process;

7) The overall process is controlled by XML parameters;

8) Latest SUN's Jini 2.0 compliant;

9) Easily expandable with new features/algorithms/control modules, etc.

The Core Engine -- The 'core engine' is the fulcrum around which all the other modules and applications based on Joone are built.

It contains a Java API providing the developer with the following features:

1) Components to create any NN architecture (feed forward or recurrent);

2) Several supervised training algorithms:

3) Components to build unsupervised NNs (Kohonen SOMs and Principal Component Analysis);

4) Components to build modular NNs;

5) A serialization mechanism to save and restore a NN to/from a file system or to send/receive a NN on remote locations (via HTTP, RMI, etc.);

6) I/O components to read patterns from:

7) Components to implement both the supervised and unsupervised learning control;

8) Components to control the behavior of the NN (start/stop, recall/learn) and its parameters (learning rate, momentum, etc.);

9) Plug-ins to preprocess the input data (Normalization, Moving Average, etc.) and to control dynamically the training parameters (Annealing);

10) A complete event notification mechanism, along with a scripting capability to control the behavior of a NN at the happening of some events.

System Requirements

Contact manufacturer.


Manufacturer Web Site Joone (Java Object Oriented Neural Engine)

Price Free

G6G Abstract Number 20342

G6G Manufacturer Number 104002