In the experiments running the whole Kohonen application on different machines, it is verified that it runs in an acceptable time and velocity. Although the results achieved in this research cannot be generalized for every distributed application using the Java language and the Voyager environment, they can be useful as guidelines regarding the distributed implementations of neural network models under Voyager. The results encourage a more detailed implementation of distribution facilities under the CANN framework.
Adding mobility to the ANN implementations in CANN is a straightforward task basically because of the use of the Java language and the object architecture of the CANN framework. The Java language has several characteristics that are useful in this implementation:
• It offers the capability of executing the generated code on any platform, which together with the use of Voyager makes the distribution of code possible.
Furthermore, the facilities the language offers such as dynamic binding and polymorphism permitted the implementation of important requirements such as adding new ANN models at runtime. For instance, the user is able to develop and add ANN models at runtime to create several ANN instances, and to try different solutions of the problem at hand. The user is able to execute these ANN tasks in a distributed way making use of the computer network infrastructure. Those aspects are considered as very important and, in many cases, compensate possible performance losses of using the Java language.
• Java implement concurrent programming. Skillicorn and Talia (1998) evaluate languages for concurrent computation. They argue that it shall be easy to program, it should have a software development methodology, it should be architecture-independent, it should be easy to understand, it should guarantee performance and it should provide accurate information about the cost of programs. Java covers quite well at least the first four items. Regarding performance, Java is clearly not reaching the point. It is necessary to consider the performance losses of the language when running the CANN framework.
The experience is that the possibility of using multiple machines to test different ANN implementations and CPU’s supported by the parallel CNM implementation may also compensate this drawback.
• Java has explicit programming for concurrent implementation (Skillicorn and Talia (1998)). That means the software developers shall take care with all details of the concurrent implementation. It can be difficult to achieve the best possible correctness and performance when programming with such a language. To compensate this, the Voyager library offers a brokering system in Java. It allows the implementation of mobile objects in a clear and simple way without much coding effort and without influencing the application objects implementations.
The software architecture of the CANN facilitates the implementation of mobile components. This architecture is carefully designed to allow flexible ANN implementations.
The clear definition and separation of the objects that form the architecture, help to choose
where and how to implement the distribution without changing the implementation done so far.
The presented solution for distribution of ANN objects opens several application possibilities. It is possible to develop applications where it is necessary to migrate the ANN code to perform artificial intelligent tasks on remote machines such as classification, forecasting and clustering. Imagine having an ANN in each computer where customer classification shall be accomplished in real-time. A previously trained ANN could be sent to each machine whenever necessary and be autonomously evaluating the input data. Other tasks in different application areas such as computer networks management could also be implemented like: making intelligent routing of messages or intelligent control of the network resources.
However, the performance results of the CANN distribution solution do not encourage its usage in a production environment. The time for performing the ANN learning and testing on the remote machines were significantly worse than the time spent when running on the local machine, which makes the distribution environment inefficient and inapplicable at this stage.
Additional tests should be conducted to verify the behavior of distributed applications when using some other technology. An evaluation of the achieved results in this experiment also depends on the application in question, which could be considered appropriate for one application but unreliable for another application. Furthermore, this experiment is concerned with providing an idea about the time, memory and computer resources someone could expect to use when building a system in a similar environment, and not to make a judgment about the appropriateness of time, memory or processing capacity. Such a judgment is beyond the scope of this experiment and is relative to each particular application.
Some parallel systems permit the load balancing among the participating CPUs (for example Cray systems). This is certainly an important feature to be implemented by the ORB when being used to implement CPU critical applications such as distributed ANN learning.
With such a feature the CPU usage could be better tuned for each hardware involved in the processing and better results could be reached.
Another point to discuss is the number of agents running simultaneously on the same machine. Tests with more than two agents running simultaneously on the same machine were not performed because the scope of this work is to investigate the performance of the
distributed application among several computers, and not to investigate the performance of the computers when running several applications simultaneously.
Additional topics that could be considered in future work include:
• Implementation of different distribution solutions for each of the considered ANN models.
• Adding knowledge representation and communication features to the object agents using for example knowledge communication languages, such as DAML (The DARPA Agent Markup Language - www.daml.org). Agent implementation and communication is not explored here, even though the mobile ANN components are implemented as mobile agents.
• Experiment with other distributed Java development environments such as Aglets (Aglets SDK, IBM 2000) or Sumatra (The Sumatra Project, Arizona University).
6 O p t i m i z a t i o n s o f t h e C o m b i n a t o r i a l N e u r a l M o d e l
The CNM model is explained in detail in Chapter 2. Along this work, complementary information about its implementation on the CANN framework is provided. The implementation of the CANN CNM component core construction principles is explained in Chapter 3 and a parallel solution is presented in Chapter 4. Besides implementing parallelism specific to the CNM model, this work dedicated to introduce and implement significant optimizations for its algorithm. This chapter presents the optimizations and empiric results of its application. The most important optimization aims at taming combinatorial explosion, which is the main problem inherent to this model.