Joone Documentation

• Jan 19, 2007 - Joone 2.0 RC1 is out! Try this major version release and discover the big enhancements we've made to the core engine. read more...
• May 08, 2006 - JoonePad 0.5.0 is out (thanks to H.Fiorletta). Try now the new GUI Editor that will substitute the old one. read more...
• Sep 08, 2005 - Joone 1.2.1 is out! This is mainly a bug fix release. read more...
• Feb 03, 2005 - Joone 1.2.0 is out. In this version: new components, plugins and a lot of bug fixes. read more...
• Jan 19, 2005 - The Joone's Wiki is open! You can find FAQs, Books Reviews, Discussion Forums, and more... Join the Joone Community!

Joone is a FREE Neural Network framework to create, train and test artificial neural networks. The aim is to create a powerful environment both for enthusiastic and professional users, based on the newest Java technologies.

Joone is composed by a central engine that is the fulcrum of all applications that are developed with Joone. Joone's neural networks 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 AI applications that revolve around the core framework.

Download it, and enjoy!

• Supervised learning:
• Feed Forward neural networks (FFNN)
• Recursive neural networks (Elman, Jordan, ...)
• Time Delay neural networks (TDNN)
• Standard Back-prop (Gradient Descent, on-line and batch)
• Resilient Back-prop (RPROP)
• Unsupervised learning:
• Kohonen SOMs (with WTA or Gaussian output maps)
• Principal Component Analysis (PCA)
• Modular Neural Networks (i.e. possibility to mix all the above architectures)
• Powerful built-in data pre-processing mechanism
• Scripting capability (JavaScript) in order to add custom behaviour to the NNs
• more...

Joone is a Java framework to build and run AI applications based on neural networks.

Joone consists of a modular architecture based on linkable components that can be extended to build new learning algorithms and neural networks architectures. All the components have specific features, like persistence, multithreading, serialization and parameterisation 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 an own GUI Editor to visually create and test any neural network, and a Distributed Training Environment to train in parallel mode many neural networks to find the fittest one for a given problem.

If you want learn more on Joone, you can read the available documentation

• The Joone Complete Guide (pdf)
• The Core Engine
• The Java API cookbook
• The JOONE GUI Editor
• A sample GUI, that learns the XOR problem
• A selection of the best Neural Networks books

After a lot of months of hard work, the new Joone 2.0 is ready. This is a release candidate, so anyone is invited to try it and help us to discover any problem. Some of the new features:

• The core engine has been refactored by adding the single-thread mode. The resulting performances are improved by 50%, with an enhanced reliability and scalability.
• A set of tools were added, in order to hide the complexity of the API, and make it very simple to work with the core engine. Now you can build, train and interrogate a neural network by writing only 3 rows of code! Read more...
• A new Image I/O component has been added, in order read and write directly from/to image files (jpeg and gif format supported)
• Added a new SoftMax Layer to build neural networks for resolving 1 of C classification problems
• Improved the usability of the property panels, by adopting a new file chooser panel, and a visual calendar panel in order to make it very simple to insert date fields
• Several bugs were fixed and the documentation has been updated with the new features

Read all the changes...

Posted: Jan 18, 2007

The new neural network GUI editor - JoonePad - is out! Try it now by launching it directly from the web (You need JRE 1.5 and WebStart installed). Some of the new features:

• Added a wizard to easily build several kinds of neural networks
• Added a java code generator in order to reproduce in a custom java program the same network currently displayed in the editor
• Now it's possible to import a neural network exported by the old GUI editor
• The TODO-list now is an active list: click an item in order to highlight the corresponding component containing the error
• Improved the user interface with docking panels and enhanced property sheets, in order to make it simpler to use the editor

This is a pre-view beta release, so please be patient if you discover some bug...

I want to thank Huascar Fiorletta for the great support and contribution he gave to make all that possible

Posted: May 08, 2006

This is mainly bug fix release. Some of the new features:

• Added the support for the Groovy scripting language
• Added the LogarithmicPlugin to apply a logarithmic transformation (base e) to input data
• Added the save as XML in the GUI Editor

Several bugs were fixed:

• Fixed a problem that prevented the SangerSynapse from learning when in training mode
• Now the inspection panel doesn't show the biases for Layers for which this doesn't make sense
• Fixed the lacking of the first column when copied in the clipboard the inspected values

Read all the changes...

Posted: September 08, 2005

A new version of Joone is out! Among the new features:

• Added many new components (SineLayer, JDBCOutputSynapse, InputConnector,...) and plug-ins (ShufflerPlugin, DeltaNormPlugin, ...)
• Revisited many internal mechanisms in order to make joone more expandible (a new Weights Initializer, a new Learner mechanism,...)
• Fixed a lot of bugs
• Improved the documentation

Read all the changes...

Posted: February 03, 2005

The main features of this powerful framework for distributed processing of neural networks:

• The training process scale almost linearly adding more machines
• Possibility to add or remove machines dynamically during the training process
• The overall process controlled by XML parameters
• Latest SUN's Jini 2.0 compliant
• Easily expandible with new features/algorithms/control modules, etc.

Read more...

Posted: September 19, 2004

This is a minor bug fix release. Several bugs were fixed: resolved the 'No matching patterns' problem, added the momentum in the BatchLearner, etc.

Changes

Posted: September 13, 2004

A new version of Joone is out! Great new features in this release:

• Added the Resilient Backprop algorithm (RPROP), a really performant new training algorithm (thanks to Boris Jansen)
• Improved the core engine's speed of about 35-40%, thanks to a deep review of the threads synchronization mechanism.

  On an Athlon 2200Mhz the XORMemory example took 4.4 sec to execute 10,000 epochs with the old 1.0.1 version; now it executes the same elaboration in only 2.4 seconds!

  Now the Joone's performances are nearly comparable to a C/C++ framework!
• Added the setting of a http proxy to access to Internet also in presence of a firewall proxy
• ...plus several bug fixes and a lot of small enhancements

Changes

Posted: August 18, 2004

Thanks to the Forrest project, we have changed the look&feel of our web site. Now all the content is written in XML, and the HTML pages are obtained by applying a XSL transformation. By separating the content from the layout, we can easily and quickly add and modify the content, without affecting the graphical layout. Moreover, now all the pages are easily reachable from the menu on the left, and for each page is also available the content in PDF format.

Posted: July 16, 2004

The final release 1.0.1 is out! This is a minor bug fix release. Several bugs in the NestedNeuralLayer were fixed and more examples were added to the Joone Complete Guide PDF paper

Changes

Posted: June 13, 2004

The final release 1.0.0 is out! In the past months many bugs have been fixed, and now the version 1.0 can be declared stable. Download the auto-installer program and enjoy!

Changes

Posted: April 13, 2004

Thanks to Casey Marshall, Joone now runs also on the .NET platform.

Download

Posted: January 13, 2004

• The Joone's framework is built with a modular architecture: the 'core engine' is separated from the visual interface and permits easily to implement any new application based on it.
• Joone is portable, being written in 100% pure Java. It can run in any environment, from big multiprocessor machines to small palmtop devices.

• The neural networks based on Joone are usable stand-alone (separated from the framework that has created or trained them).
• The Joone's based neural networks can be transported using common protocols (like http or ftp) to run on remote machines

• The framework is expandable with more components to implement new learning algorithms or new architectures.
• With Joone it's possible to implement any kind of optimization; there are two main methods to find the best solution to a given problem (i.e. to find the best neural network): local optimization and global optimization techniques. The local optimization is obtained applying some 'internal' mechanism (the most famous is the momentum), the global optimization, instead, try to find the best solution applying some external technique to select the best performing NN among a predefined group of NNs (like genetic algorithms). Both are implemented with Joone, and many new optimization techniques can be experimented thanks to its expansibility.

• Joone's core engine is based on a multithreaded engine, capable to scale using all the computing resources available.
• Joone provides the professional users with a distributed environment to train many neural networks in parallel on several machines.

• Joone is freely usable. Its license is the Lesser General Public License (LGPL).
• You're encouraged to try it and use it for whatever (both commercial and academic) application!

• The Joone Complete Guide (pdf)
• The Core Engine
• The Java API cookbook
• The JOONE GUI Editor
• A sample GUI, that learns the XOR problem
• A selection of the best Neural Networks books

To run the joone's visual editor, all you need to do is to download and launch one of the following installers. Choose it according your platform and the presence of a JVM on your machine:

Note:

• Due to a problem reported for the MacOSX installer, the Mac users must choose now the platform independent version
• Note:The packages without JVM require a JRE 1.4.2 or above installed

Installation Instructions

You can download the compiled classes or the source code of the core engine. To compile and runnit you need to download the External Libraries, too.

Download the compiled classes or the source code of the DTE. Download the DTE Complete Guide to read how to install and use it.

A subset of the core engine can be also used on the .NET platform. Download here the excellent work made by Casey Marshall (contains a porting of the version 1.0.0).

• The Joone Complete Guide (pdf)
• The Core Engine
• The Java API cookbook
• The JOONE GUI Editor
• A sample GUI, that learns the XOR problem
• A selection of the best Neural Networks books

The support is mainly provided trough two public forums available on SourceForge:

• Help: Use this forum if you need help about Joone, its core engine or the GUI Editor. It's the best way to obtain support directly by the developers of Joone.
• Open Discussion: This forum is to post suggestions, proposals, or to ask for the opinion of other users about whatever aspect of Joone.

The following are some general "common-sense" guidelines for using the forums: Most people are already following these guidelines. To those people, I thank you. For those of you who are not...please read carefully.

1. Please be patient. We dedicate to Joone our free time, hence we cannot use it only to respond to the questions. Anyway we monitor the forum each day, hence sooner or later we'll give a response to any post.
2. Please refrain from using words and phrases like URGENT, IMPORTANT, MY WIFE WILL LEAVE ME IF YOU DO NOT RESPOND, etc, in the subject line of your postings. Or even in the body of the message for that matter. You may think that things which are URGENT, or IMPORTANT to you, are just as urgent and important to everyone else reading this forums. You'd be surprised at just how wrong an assumption like that can be. As a matter of fact, I personally tend to read all such postings last and give them a low priority.
3. Please use meaningful subject lines. "Newbie Question", is not meaningful what-so-ever.
4. Please provide necessary information, where applicable. Statements like, "I recieve a NullPointerException when using Joone, what's up with that?", are not very helpful, add unnecessary traffic on the forum, and will probably never get an answer.
5. As a follow on to #3, when submitting examples, please try to submit the smallest possible example which demonstrates the problem. Short examples are easier to follow and will get quicker responses from developers or other users than long examples with lots of extraneous code/data.
6. Please read the documentation before posting. One of the biggest problems is that there is not a lot of documentation to Joone. At the same time, because it doesn't take long, everyone should read what is written before posting.
7. Please check the forum archives before posting. Many questions on this forums have already been answered before.
8. Please refrain from posting confidential information. Once a message is sent to the forum, it goes out to all subscribers, including archive engines. If you are unsure about what is confidential or not, check with your manager, supervisor, or the person in charge at your company.
9. Please be kind and respectful to your fellow Joone users. Remember, except for the author, you were all newbies at one point.

• The Joone Complete Guide (pdf)
• The Java API cookbook
• The JOONE GUI Editor
• A sample GUI, that learns the XOR problem
• A selection of the best Neural Networks books

• The core engine has been refactored by adding the single-thread mode. The resulting performances are improved by 50%, with an enhanced reliability and scalability.()
• A set of tools were added, in order to hide the complexity of the API, and make it very simple to work with the core engine. Now you can build, train and interrogate a neural network by writing only 3 rows of code! Read more...()
• A new Image I/O component has been added, in order read and write directly from/to image files (jpeg and gif format supported)()
• Added a new SoftMax Layer to build neural networks for resolving 1 of C classification problems()
• Improved the usability of the property panels, by adopting a new file chooser panel, and a visual calendar panel in order to make it very simple to insert date fields()
• Several bugs were fixed and the documentation has been updated with the new features()

• Added the FahlmanTeacherSynapse to implement the Fahlman criterion (by Boris Jansen)()
• Added the support for the Groovy scripting language (by Yan Cheng Cheok)()
• Added the LogarithmicPlugin to apply a logarithmic transformation (base e) to input data (by Yan Cheng Cheok)()
• Added the save as XML in the GUI Editor (needs xstream.jar in the classpath) (by Paolo Marrone)()
• Added the AbstractTeacherSynapse in order to permit to add the calculus of whatever new cost function (by Boris Jansen)()
• Fixed the ChartOutputSynapse: small bug in values Y axis labels (bug #1143858) (by Jan Boonen)()
• Fixed the lacking of the first column when copied the inspected values (bug #1158597) (by Paolo Marrone)()
• Fixed a problem about the data not reloaded after calling StreamInputSynapse.resetInput (#1164061) (by Paolo Marrone)()
• Fixed resetInput not propagated through the InputConnector (bug #1164064) (by Paolo Marrone)()
• Resolved an ArrayIndexOutOfBoundsException into the ToBinaryPlugin (by Yan Cheng Cheok)()
• Fixed a ArrayIndexOutOfBoundsException within the Monitor.fireNetStopped method (by Jonathan Love)()
• Fixed a problem that prevented the SangerSynapse from learning when in training mode (by Paolo Marrone)()
• Now the inspection panel doesn't show the biases for Layers for which this doesn't make sense (by Paolo Marrone)()

• Engine: Added a basic implementation of the RBF networks (by Boris Jansen)()
• Engine: Added the BiasedLinearLayer, useful to implement the RBF networks (by Boris Jansen)()
• Engine: Added the DeltaNormPlugin in order to pre-elaborate time series()
• Engine: Added the JDBCOutputSynapse to write output patterns to RDBMs via JDBC (by Julien Norman)()
• Engine: Added the SineLayer component, a layer that applies the sin(x) function to its input (by Boris Jansen)()
• Engine: Added the ShufflePlugin, an input plugin to shuffle the input patterns at each cycle()
• Engine: Added the BynaryPlugin, an input plugin to convert to binary the input values (by Boris Jansen)()
• Engine: Added the SimulatedAnnealing learning algorithm (by Boris Jansen)()
• Engine: Added the 'useRMSE' property to the Monitor object in order to choose how to calculate the error of the network: MSE or RMSE (by Boris Jansen)()
• Engine: Added the InputConnector class in order to permit to use a unique input synapse for the entire network()
• Engine: Added the 6th column to the YahooFinanceInputSynapse in order to extract also the 'Adjusted Close' value()
• Engine: Added the WeightInitializer interface in order to implement a plugable mechanism to initialize the Matrix's weights according to a customizable algorithms (by Boris Jansen)()
• Engine: Refactored the Input plugins mechanism in order to eliminate the duplicated code in both the ConverterPlugin and OutputConverterPlugin classes()
• Engine: Added a new mechanism to manage the chosen learning algorithm()
• GUI Editor: Added a new toolbar in order to reduce the size of the main window()
• Engine: Fixed the 'Batch size never passed to BatchLearner' problem (bug #1027660)()
• Engine: Fixed the unwanted change of the Layer's rows value (bug #1038530)()
• Engine: Fixed a problem in the YahooFinanceInputSynapse correlated with non-US stocks (bug #1047194)()
• Engine: Added code to prevent a clear() call when patternListeners are null (by Firestrand)()
• GUI Editor: Added code in the GUI Control Panel to refresh the display on the last epoch (by Firestrand)()
• Engine: Fixed netStopped wont be invoked in recall mode (bug #1047774)()
• Engine: Fixed a NullPointerException when ispected a DirectSynapse (bug #1038525)()
• Engine: Fixed Joone cannot run within an applet (bug #1110154)()
• Engine: Resolved a problem about unbuffered StreamInputSynapses when a big input file is read()

• Engine: Fixed the 'No matching patterns' problem (bug #1024973)()
• Engine: Fixed the globalError set to 0.0 for a cloned neural network (bug #1013956)()
• Engine: Fixed the missing use of the momentum parameter in the BatchLearner (bug #1024960)()
• Engine: Now the KohonenSynapse registers itself correctly as NeuralNetListener when deserialized (bug #1025177)()
• Engine: Fixed a NullPointerException in the YahooFinanceInputSynapse when no data present (bug #1026110)()

• Engine: Added the Resilient Backprop (RPROP) algorithm (by Boris Jansen)()
• Engine: Added the method join to the NeuralNet object in order to implement a mechanism to wait for all the running threads to finish()
• Engine: Added the 'param' property to the Monitor object in order to permit to store whatever new parameter without the need to change the java code()
• GUI Editor: Added the learningMode property in the Control Panel to choose the learning algorithm()
• GUI Editor: Added the 'http_proxy...' tag to the xml property file in order to permit to access to Internet also when in presence of a firewall proxy()
• Engine: Revisited the threads synchronization to improve the training speed: improved more than 35%!()
• Engine: Revisited the learners handling mechanism in order to be able to add/choose dynamically the Learner components()
• Engine: Fixed a bug in batchmode (bug #991335) (by Boris Jansen)()
• Engine: Fixed a wrong calculus of the output neighbourhood radius of the GaussianLayer component when in recall mode()
• Engine: Fixed a bug in Layer.isRunning method (bug #1007838) (by Jerry R. Vos)()
• GUI Editor: Fixed the file chooser, that didn't appeare when the .cfg file was corrupted()

• GUI Editor: Resolved the rmse not displayed when the net runs for few epochs (> 50)()
• Engine: Fixed a wrong initialization of the parent Monitor within the NestedNeuralLayer class()
• Engine: Added the netStoppedError notification to the internal NN of the NestedNeuralLayer class()
• Engine: The NestedNeuralLayer's randomize/addNoise method calls now have effect only when in learning mode()
• Engine: Resolved a wrong calculus of the validation error after consecutive runs (bug #957664)()
• Engine: Fixed the wrong validation error calculus when preLearning > 0 (bug #949353)()
• Engine: Eliminated an useless warning raised by the TeacherSynapse when stopped()

• GUI Editor: Added the 'Page Setup' menu item to setup the printer's options()
• GUI Editor: Added the 'Paste' button in the inspection frame()
• GUI Editor: Added the maxBufSize property to the input synapses based on the StreamInputTokenizer()
• GUI Editor: Now the main window remembers its last position and size()
• GUI Editor: Added the initial splash screen()
• GUI Editor: Inverted the In/Out dataMin/Max properties' description on the NormalizerPlugin()
• Engine: Added the setComponent method to the Inspection interface and its inherited classes()
• Engine: Added the maxBufSize property to the input synapses based on the StreamInputTokenizer()
• Engine: Decoupled the engine from the logging libraries to be independent from the Log4j library()
• Engine: The StreamInputSynapse checks now if its input patterns number is lesser than the Monitor's input patterns setting()
• Engine: The FileInputSynapse opens the input stream only when requested()
• Engine: Resolved the IOException 'too many open files' on FileOutputSynapse object()
• Engine: Changed the tokenizer handling into all the classes inheriting StreamInputSynapse()
• Engine: The NestedNeuralLayer now handles correctly the attached I/O components()
• Engine: The XLSInputSynapse now handles correctly sheets containing empty columns/rows()
• Engine: The XLSInputSynapse now handles correctly the sheet name property()
• Engine: The Monitor object now handles correctly the nested Monitor, if present()

• [DTE] Complete the rewriting of the DTE to be compliant to the Jini 2.0 specifications. → PM
• [engine] Add the XML serialization of a neural network → PM
• [GUI Editor] Rewriting the new GUI Editor by using the JGraph library and also by completing and adopting the SwiXAT XUL MVC framework in order to be able to write the new editor's interface by using XML and JavaScript. → PM

• [engine] Adding of a new output synapse in order to write the results of a neural network in a form suitable to be visualized with GNUPLOT. → PM
• [engine] Add the possibility to calculate the quantization error (distance between the input vector and the best-matching unit BMU) of a SOM network. → PM

If you want to learn more on Neural Networks, reading a good book is the first and most useful thing to do. Look at the titles (over 15000 books!) available at Amazon.com:

• About Joone
• The Core Engine
• The Joone Complete Guide (pdf) - All you need to know about Joone (technical details, code examples, etc.)
• A description of the Core Engine
• How to build a neural network using java code
• The GUI Editor
• A description of the GUI Editor
• A sample GUI that learns the XOR problem
• The Distributed Training Environment
• A description of the DTE
• The DTE Complete Guide (pdf)

• Using Joone for Artificial Intelligence Programming by Jeff Heaton
• Programming Neural Networks in Java by Jeff Heaton

This is a list of projects that use the Joone's libraries. Feel free to contact us to add here a link to your own project/application

• Software Development Effort Estimations Through Neural Networks (by Sebastian Donatti) A very interesting work about the development of a neural network model to solve the software development effort estimation problem with a more complex feed-forward architecture and using a large software development metrics historical database
• A complete character recognition program (by Yan Cheng)
• JOONEGAP (by Richard Kennard) A Neural Network evolutionary environment

• 3D Freeform Surfaces from Planar Sketches using Neural Networks (by Usman Khan, Abdelaziz Terchi, Sungwoo Lim, David Wright, Sheng-Feng Qin)
• Using Java™ Technology-Based Neural Networks to Predict Trauma Mortality (pdf slides presented at JavaOne 2006)
• A Neural Networked-based Approach to a Dead Reckoning Predictor for Haptic Interfaces (pdf)
• Post-processing Analysis of Grid Monitoring data (pdf)
• Real-time Adaptive Control of Modal Synthesis (pdf)
• Layered Learning in RoboCup Rescue Simulation (pdf)
• Ontology Mapping - An Integrated Approach (pdf)
• XPOD - A human activity and emotion aware mobile music player (pdf)
• Modeling and verification of digital logic circuit using neural networks (pdf)
• Hierarchical Confidence Based Clustering (pdf)
• Hardware Implementation of Distributed Artificial Neural Network (DANN) Models of Neural Functioning (pdf)
• Implementation of self-organizing map (SOM) on distributed artificial neural network (DANN) (pdf)
• Developing a Data Communication Model for Distributed Artificial Neural Network (DANN) Remote Training Environments (pdf)
• Using Distributed Network Systems To Model Perception With an Artificial Neural Network (pdf)

Features

Packages

Resources

How to build a NN using java code

      SigmoidLayer layer1 = new SigmoidLayer();
      SigmoidLayer layer2 = new SigmoidLayer();
      SigmoidLayer layer3 = new SygmoidLayer();
      FullSynapse synapse1 = new FullSynapse();
      FullSynapse synapse2 = new FullSynapse();

      layer1.addOutputSynapse(synapse1);
      layer2.addInputSynapse(synapse1);
      layer2.addOutputSynapse(synapse2);
      layer3.addInputSynapse(synapse2);

A real implementation: The XOR Problem

	0.0;0.0;0.0
	0.0;1.0;1.0
	1.0;0.0;1.0
	1.0;1.0;0.0

	LinearLayer input = new LinearLayer();
	SigmoidLayer hidden = new SigmoidLayer();
	SigmoidLayer output = new SygmoidLayer();

	input.setRows(2);
	hidden.setRows(3);
	output.setRows(1);

	FullSynapse synapse_IH = new FullSynapse(); /* Input  -> Hidden conn. */
	FullSynapse synapse_HO = new FullSynapse(); /* Hidden -> Output conn. */

	input.addOutputSynapse(synapse_IH);
	hidden.addInputSynapse(synapse_IH);

	hidden.addOutputSynapse(synapse_HO);
	output.addInputSynapse(synapse_HO);

	NeuralNet nnet = new NeuralNet();
	nnet.addLayer(input, NeuralNet.INPUT_LAYER);
	nnet.addLayer(hidden, NeuralNet.HIDDEN_LAYER);
	nnet.addLayer(output, NeuralNet.OUTPUT_LAYER);
	

	Monitor monitor = nnet.getMonitor();
	monitor.setLearningRate(0.7);
	monitor.setMomentum(0.5);

    	monitor.addNeuralNetListener(this);

	FileInputSynapse inputStream = new FileInputSynapse();
	/* The first two columns contain the input values */
	inputStream.setAdvancedColumnSelector("1,2");
	/* This is the file that contains the input data */
	inputStream.setInputFile(new File("c:\\joone\\XOR.txt"));

	input.addInputSynapse(inputStream);

	TeachingSynapse trainer = new TeachingSynapse();
	/* Setting of the file containing the desired responses, provided by a FileInputSynapse */
	FileInputSynapse samples = new FileInputSynapse();
	samples.setInputFile(new File("c:\\joone\\XOR.txt"));
	trainer.setDesired(samples);
	/* The output values are on the third column of the file */
	samples.setAdvancedColumnSelector("3");
	/* We add it to the neural network */
	nnet.setTeacher(trainer);

	output.addOutputSynapse(trainer);

	monitor.setTrainingPatterns(4); /* # of rows contained in the input file */
	monitor.setTotCicles(2000); /* How many times the net must be trained on the input patterns */
	monitor.setLearning(true); /* The net must be trained */
	nnet.go(); /* The network starts the training job */

Resources

Features

Screenshots

Click the images for full size

The charting capability	The Macro Editor	The drawing capability	The Help on Line

Resources

The XOR example

    0.0;0.0;0.0
    0.0;1.0;1.0
    1.0;0.0;1.0
    1.0;1.0;0.0

Testing the XOR example

          0.02592995527027603
          0.9664584492704527
          0.9648193164739925
          0.03994103766843536

Resources

Introduction

Why a distributed environment?

Possible Applications

Features

How does it work?

Credits

A robust alternative to Jini: GreenTea

Resources