Pedro A. Castillo

G-Prop: Global optimization of multilayer perceptrons using GAs

Abstract A general problem in model selection is to obtain the right parameters that make a model fit observed data. For a multilayer perceptron (MLP) trained with back-propagation (BP), this means finding appropiate layer size and initial weights. This paper proposes a method (G-Prop, genetic backpropagation) that attempts to solve that problem by combining a genetic algorithm (GA) and BP to train MLPs with a single hidden layer. The GA selects the initial weights and changes the number of neurons in the hidden layer through the application of specific genetic operators. G-Prop combines the advantages of the global search performed by the GA over the MLP parameter space and the local search of the BP algorithm. The application of the G-Prop algorithm to several real-world and benchmark problems shows that MLPs evolved using G-Prop are smaller and achieve a higher level of generalization than other perceptron training algorithms, such as Quick-Propagation or RPROP, and other evolutive algorithms, such as G-LVQ.

Statistical analysis of the main parameters involved in the design of a genetic algorithm

Most genetic algorithm (GA) users adjust the main parameters of the design of a GA (crossover and mutation probability, population size, number of generations, crossover, mutation, and selection operators) manually. Nevertheless, when GA applications are being developed it is very important to know which parameters have the greatest influence on the behavior and performance of a GA. The purpose of this study was to analyze the dynamics of GAs when confronted with modifications to the principal parameters that define them, taking into account the two main characteristics of GAs; their capacity for exploration and exploitation. Therefore, the dynamics of GAs have been analyzed from two viewpoints. The first is to study the best solution found by the system, i.e., to observe its capacity to obtain a local or global optimum. The second viewpoint is the diversity within the population of GAs; to examine this, the average fitness was calculated. The relevancy and relative importance of the parameters involved in GA design are investigated by using a powerful statistical tool, the analysis of the variance (ANOVA).

Evolving Multilayer Perceptrons

This paper proposes a new version of a method (G-Prop, genetic backpropagation) that attempts to solve the problem of finding appropriate initial weights and learning parameters for a single hidden layer Multilayer Perceptron (MLP) by combining an evolutionary algorithm (EA) and backpropagation (BP). The EA selects the MLP initial weights, the learning rate and changes the number of neurons in the hidden layer through the application of specific genetic operators, one of which is BP training. The EA works on the initial weights and structure of the MLP, which is then trained using QuickProp; thus G-Prop combines the advantages of the global search performed by the EA over the MLP parameter space and the local search of the BP algorithm. The application of the G-Prop algorithm to several real-world and benchmark problems shows that MLPs evolved using G-Prop are smaller and achieve a higher level of generalization than other perceptron training algorithms, such as QuickPropagation or RPROP, and other evolutive algorithms. It also shows some improvement over previous versions of the algorithm.

Asynchronous distributed genetic algorithms with Javascript and JSON

In a connected world, spare CPU cycles are up for grabs, if you only make its obtention easy enough. In this paper we present a distributed evolutionary computation system that uses the computational capabilities of the ubiquituous Web browser. Asynchronous Javascript and JSON (Javascript object notation, a serialization protocol) allows anybody with a Web browser (that is, mostly everybody connected to the Internet) to participate in a genetic algorithm experiment with little effort, or none at all. Since, in this case, computing becomes a social activity and is inherently impredictable, in this paper we will explore the performance of this kind of virtual computer by solving simple problems such as the royal road function and analyzing how many machines and evaluations it yields. We will also examine possible performance bottlenecks and how to solve them, and, finally, issue some advice on how to set up this kind of experiments to maximize turnout and, thus, performance. The experiments show that we we can obtain high, and to a certain point, reliable performance from volunteer computing based on AJAJ, with speedups of up to several (averaged) machines.

Resilience to churn of a peer-to-peer evolutionary algorithm

In this paper we analyse the resilience of a peer-to-peer (P2P) evolutionary algorithm (EA) subject to the following dynamics: computing nodes acting as peers leave the system independently from each other causing a collective effect known as churn. Since the P2P EA has been designed to tackle large instances of computationally expensive problems, we will assess its behaviour under these conditions, by performing a scalability analysis in five different scenarios using the massively multimodal deceptive problem as a benchmark. In all cases, the P2P EA reaches the success criterion without a penalty on the runtime. We show that the key to the algorithm resilience is to ensure enough peers at the beginning of the experiment; even if some of them leave, those that remain contain enough information to guarantee a reliable convergence.

Algorithm::Evolutionary, a flexible Perl module for evolutionary computation

This paper describes Algorithm::Evolutionary (A::E), a Perl module released under an open source license and designed for the exploration and exploitation of evolutionary algorithms. We describe the design decisions taken to enhance flexibility, how performance was improved by using several implementation tweaks, and what kind of design patterns were applied for its development. This work also tries to dispel the myth of low performance of scripting languages by comparing it with a state-of-the-art library (ECJ) written in Java. Besides, we are interested in assessing its efficiency in several possible evolutionary settings, finding out what kind of behavior we can expect, and what can be done to improve it. Applications already written using A::E are also described, along with how it can be used to create new operators. Finally, some conclusions are drawn from the design experience.

Implementation matters: programming best practices for evolutionary algorithms

While a lot of attention is usually devoted to the study of different components of evolutionary algorithms or the creation of heuristic operators, little effort is being directed at how these algorithms are actually implemented. However, the efficient implementation of any application is essential to obtain a good performance, to the point that performance improvements obtained by changes in implementation are usually much bigger than those obtained by algorithmic changes, and they also scale much better. In this paper we will present and apply usual methodologies for performance improvement to evolutionary algorithms, and show which implementation options yield the best results for a certain problem configuration and which ones scale better when features such as population or chromosome size increase.

Finding a needle in a haystack using hints and evolutionary computation: the case of evolutionary MasterMind

In this paper we present a new version of an evolutionary algorithm that finds the hidden combination in the game of MasterMind by using hints on how close is a combination played to it. The evolutionary algorithm finds the hidden combination in an optimal number of guesses, is efficient in terms of memory and CPU, and examines only a minimal part of the search space. The algorithm is fast, and indeed previous versions can be played in real time on the world wide web. This new version of the algorithm is presented and compared with theoretical bounds and other algorithms. We also examine how the algorithm scales with search space size, and its performance for different values of the EA parameters. # 2005 Published by Elsevier B.V.

Service oriented evolutionary algorithms

This work presents a service oriented architecture for evolutionary algorithms, and an implementation of this architecture using a specific technology (called OSGiLiath). Service oriented architecture is a computational paradigm where users interact using services to increase the integration between systems. The presented abstract architecture is formed by loosely coupled, highly configurable and language-independent services. As an example of an implementation of this architecture, a complete process development using a specific service oriented technology is explained. With this implementation, less effort than classical development in integration, distribution mechanisms and execution time management has been attained. In addition, steps, ideas, advantages and disadvantages, and guidelines to create service oriented evolutionary algorithms are presented. Using existing software, or from scratch, researchers can create services to increase the interoperability in this area.

Evolving bot AI in Unreal

This paper describes the design, implementation and results of an evolutionary bot inside the PC game UnrealTM, that is, an autonomous enemy which tries to beat the human player and/or some other bots. The default artificial intelligence (AI) of this bot has been improved using two different evolutionary methods: genetic algorithms (GAs) and genetic programming (GP). The first one has been applied for tuning the parameters of the hard-coded values inside the bot AI code. The second method has been used to change the default set of rules (or states) that defines its behaviour. Both techniques yield very good results, evolving bots which are capable to beat the default ones. The best results are yielded for the GA approach, since it just does a refinement following the default behaviour rules, while the GP method has to redefine the whole set of rules, so it is harder to get good results.