Vol. 25 · No. 1

Radial Basis Neural Networks have been successfully used in many applications due, mainly, to their fast convergence properties. However, the level of generalization is heavily dependent on the quality of the training data. It has been shown that with careful dynamic selection of training patterns, better generalization performance may be obtained. In this paper, a learning method is presented, that automatically selects the training patterns more appropriate to the new test sample. The method follows a selective learning strategy, in the sense that it builds approximations centered around the novel sample. This training method uses a Gaussian kernel function in order to decide the relevance of each training pattern depending on its similarity to the novel sample. The proposed method has been applied to three different domains: an artificial approximation problem and two time series prediction problems. Results have been compared to standard training method using the complete training data set and the new method shows better generalization abilities.

This article presents a comparison between agent and non-agent based approaches to building network-load-balancing systems. In particular, two large software systems are compared, one traditional and the other agent-based, both performing the same load balancing functions. Due to the two different architectures, several differences emerge. The differences are analyzed theoretically and practically in terms of design, scalability and fault-tolerance. The advantages and disadvantages of both approaches are presented by combining an analysis of the system and gathering the experience of designers, developers and users. Traditionally, designers specify rigid software structure, while for multi-agent systems the emphasis is on specifying the different tasks and roles, as well as the interconnections between the agents that cooperate autonomously and simultaneously. The major advantages of the multi-agent approach are the introduced abstract design layers and, as a consequence, the more comprehendible top-level design, the increased redundancy, and the improved fault tolerance. The major improvement in performance due to the agent architecture is observed in the case of one or more failed computers. Although the agent-oriented design might not be a silver bullet for building large distributed systems, our analysis and application confirm that it does have a number of advantages over non-agent approaches.

Since humans are the best readers, one of the most promising trends in automatic handwriting recognition is to get inspiration from psychological reading models. The underlying idea is to derive benefits from studies of human reading, in order to build efficient automatic reading systems. In this context, we propose a human reading inspired system for the recognition of Arabic handwritten literal amounts. Our approach is based on the McClelland and Rumelhart's neural model called IAM, which is one of the most referenced psychological reading models. In this article, we have adapted IAM to suit the Arabic writing characteristics, such as the natural existence of sub-words, and the particularities of the considered literal amounts vocabulary. The core of the proposed system is a neural network classifier with local knowledge representation, structured hierarchically into three levels: perceptual structural features, sub-words and words. In contrast to the classical neural networks, localist approach is more appropriate to our problem. Indeed, it introduces a priori knowledge which leads to a precise structure of the network and avoids the black box aspect as well as the learning phase. Our experimental recognition results are interesting and confirm our expectation that adapting human reading models is a promising issue in automatic handwritten word recognition.

The state of a system is expressed using PFL, a process functional language, in an easily understandable manner. The paper presents PFL environment variable – our basic concept for the state manipulation in the process functional language. Then we introduce the style in which stateful systems are described using monads and state transformers in pure lazy functional language Haskell. Finally, we describe our approach to lazy state manipulation in PFL and correspondence between state manipulation in PFL and the one in a pure lazy functional language Haskell. The proposed translation from eager PFL to a lazy Haskell provides an opportunity to exploit laziness for process functional programs and furthermore for imperative programs. The approach described in this paper was used in implemented PFL to Haskell code generator.

The paper is devoted to the problem of extending the temporal logic CTL so that it is more expressive and complicated properties can be expressed in a more readable form. The specification language RegCTL, an extension of CTL, is proposed. In RegCTL every CTL temporal operator is augmented with a regular expression, thus restricting moments when the validity is required. We propose a local distributed model checking algorithm for RegCTL and exactly state the complexity of model checking RegCTL formulas.