Juan J. Merelo-Guervós

Parallel Problem Solving from Nature - PPSN VIII

Two ideas taken from Bayesian optimization and classifier systems are presented for personnel scheduling based on choosing a suitable scheduling rule from a set for each person’s assignment. Unlike our previous work of using genetic algorithms whose learning is implicit, the learning in both approaches is explicit, i.e. we are able to identify building blocks directly. To achieve this target, the Bayesian optimization algorithm builds a Bayesian network of the joint probability distribution of the rules used to construct solutions, while the adapted classifier system assigns each rule a strength value that is constantly updated according to its usefulness in the current situation. Computational results from 52 real data instances of nurse scheduling demonstrate the success of both approaches. It is also suggested that the learning mechanism in the proposed approaches might be suitable for other scheduling problems.

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.

Conference Paper Assignment Using a Combined Greedy/Evolutionary Algorithm

This paper presents a method that combines a greedy and an evolutionary algorithm to assign papers submitted to a conference to reviewers. The evolutionary algorithm tries to maximize match between the referee expertise and the paper topics, with the constraints that no referee should get more papers than a preset maximum and no paper should get less reviewers than an established minimum, taking into account also incompatibilities and conflicts of interest. A previous version of the method presented on this paper was tested in another conference obtaining not only a good match, but also a high satisfaction of referees with the papers they have been assigned; the current version has been also applied on that conference data, and to the conference where this paper has been submitted; results were obtained in a short time, and yielded a good match between reviewers and papers assigned to them, better than a greedy algorithm. The paper finishes with some conclusions and reflections on how the whole submission and refereeing process should be conducted.

Adapting Heuristic Mastermind Strategies to Evolutionary Algorithms

The art of solving the Mastermind puzzle was initiated by Donald Knuth and is already more than thirty years old; despite that, it still receives much attention in operational research and computer games journals, not to mention the natureinspired stochastic algorithm literature. In this paper we try to suggest a strategy that will allow nature-inspired algorithms to obtain results as good as those based on exhaustive search strategies; in order to do that, we first review, compare and improve current approaches to solving the puzzle; then we test one of these strategies with an estimation of distribution algorithm. Finally, we try to find a strategy that falls short of being exhaustive, and is then amenable for inclusion in nature inspired algorithms (such as evolutionary of particle swarm algorithms). This paper proves that by the incorporation of what we call local entropy into the fitness function of the evolutionary algorithm it becomes a better player than a random one, and gives a rule of thumb on how to incorporate the best heuristic strategies to evolutionary algorithms without incurring in an excessive computational cost.

Randomized Parameter Settings for Heterogeneous Workers in a Pool-Based Evolutionary Algorithm

Recently, several Pool-based Evolutionary Algorithms (PEAs) have been proposed, that asynchronously distribute an evolutionary search among heterogeneous devices, using controlled nodes and nodes outside the local network, through web browsers or cloud services. In PEAs, the population is stored in a shared pool, while distributed processes called workers execute the actual evolutionary search. This approach allows researchers to use low cost computational power that might not be available otherwise. On the other hand, it introduces the challenge of leveraging the computing power of heterogeneous and unreliable resources. The heterogeneity of the system suggests that using a heterogeneous parametrization might be a better option, so the goal of this work is to test such a scheme. In particular, this paper evaluates the strategy proposed by Gong and Fukunaga for the Island-Model, which assigns random control parameter values to each worker. Experiments were conducted to assess the viability of this strategy on pool-based EAs using benchmark problems and the EvoSpace framework. The results suggest that the approach can yield results which are competitive with other parametrization approaches, without requiring any form of experimental tuning.

Finding better solutions to the mastermind puzzle using evolutionary algorithms

The art of solving the Mastermind puzzle was initiated by Donald Knuth and is already more than thirty years old; despite that, it still receives much attention in operational research and computer games journals, not to mention the nature-inspired stochastic algorithm literature. In this paper we revisit the application of evolutionary algorithms to solving it and trying some recently-found results to an evolutionary algorithm. The most parts heuristic is used to select guesses found by the evolutionary algorithms in an attempt to find solutions that are closer to those found by exhaustive search algorithms, but at the same time, possibly have better scaling properties when the size of the puzzle increases.

Scaling in distributed evolutionary algorithms with persistent population

This work presents the experimental results obtained with a distributed computing system created by mapping an evolutionary algorithm to the CouchDB object store. The framework decouples the population from the evolutionary algorithm and -through the API that CouchDB provides- allows the distributed and asynchronous operation of clients written in different programming languages. In this paper we present tests which prove that the novel algorithm design still performs as good as a canonical evolutionary algorithm and discover what are the main issues concerning it, what kind of speedups should we expect, and how all this affects the fundamental evolutionary algorithms concepts.

Designing and Modeling a Browser-Based DistributedEvolutionary Computation System

Web browsers have scaled from simple page-rendering engines to operating systems that include most services the lower OS layer has, with the added facility that applications can be run by just visiting a web page. In this paper we will describe the front and back end of a distributed evolutionary computation system that uses the browsers capabilities of running programs written in JavaScript. We will focus on two different aspects of volunteer computing: first, the pragmatic: where to find those resources, which ones can be used, what kind of support you have to give them; and then, the theoretical: how evolutionary algorithms can be adapted to an environment in which nodes come and go, have different computing capabilities and operate in complete asynchrony of each other. We will examine the setup needed to create a simple distributed evolutionary algorithm using JavaScript, with the intention of eventually finding a model of how users react to it by collecting data from several experiments featuring a classical benchmark function.

Randomized parameter settings for a pool-based particle swarm optimization algorithm: a comparison between dynamic adaptation of parameters and randomized parameterization

This work makes a comparison between different parameter tuning strategies and a strategy based on randomized parameterization in a pool-based model for the particle swarm optimization algorithm. The proposed method is compared against strategies that implement dynamic adaptation of parameters through the use of fuzzy inference systems. The experiments show results that support a hypothesis stating that the use of randomized parameterization can make a pool-based particle swarm optimization algorithm perform as well as its dynamically adapted counterpart.

Ranking the Performance of Compiled and Interpreted Languages in Genetic Algorithms.

Despite the existence and popularity of many new and classical computer languages, the evolutionary algorithm community has mostly exploited a few popular ones, avoiding them, especially if they are not compiled, under the asumption that compiled languages are always faster than interpreted languages. Wide-ranging performance analyses of implementation of evolutionary algorithms are usually focused on algorithmic implementation details and data structures, but these are usually limited to specific languages. In this paper we measure the execution speed of three common operations in genetic algorithms in many popular and emerging computer languages using different data structures and implementation alternatives, with several objectives: create a ranking for these operations, compare relative speeds taking into account different chromosome sizes and data structures, and dispel or show evidence for several hypotheses that underlie most popular evolutionary algorithm libraries and applications. We find that there is indeed basis to consider compiled languages, such as Java, faster in a general sense, but there are other languages, including interpreted ones, that can hold its ground against them.