About jjmerelo

Servidor de ustedes

Asynchronous, heterogeneous, pool based evolutionary algorithms in GECCO 2017

Fresh back from GECCO 2017, which is probably the main event for evolutionary algorithms and other metaheuristics. Together with the conference proper, there are workshops and tutorials. Last year we achieved full score, with papers, posters and tutorials. Unfortunately, not this year.
We’re happy though with the two papers that were accepted in the EvoSoft workshop, which we usually attend, and the BBOB benchmarking workshop. Both used the same thing, EvospaceJS, Mario’s framework for working with tuple-space pool-based evolutionary algorithms. The idea of this pool is decoupling algorithms from population. And as soon as you do that, a world of posibility opens, like using different clients on the same pool. In the EvoSoft paper, evospace-js: asynchronous pool-based execution of heterogeneous metaheuristics, we presented the general framework and a pool of concept which combined PSO and evolutionary algorithms, with very interesting results. Here’s the rather laconic presentation, which is a reason more to check out the paper.
In the second paperBenchmarking a pool-based execution with GA and PSO workers on the BBOB noiseless testbed.
All in all, EvospaceJS and NodIO, the two frameworks we work with, offer a nice platform for experimentation with different kind of algorithms that can be easily transported to the cloud and adapted to volunteer computing environments. Whatever the case, it also has an interesting dynamics that has an influence on the working of the evolutionary algorithms. Sure, we will continue tapping this source of interesting insights on evolutionary models.

Entropy is the best predictor of volunteer computing system performance

In volunteer computing systems the users get to decide when, and how much, their own computers are going to be working in a particular problem. We have been working for some time in using volunteer computing for evolutionary algorithms, and all our efforts have focused in having a scalable back end and also finding how the user behaves in order to understand the behavior. A priori, one would think that the more users, the better. However, the fact that these systems are asynchronous and have heterogeneous capabilities means that it might happen that new users do not really have any contribution to the overall effort.
In this paper presented at the EvoStar conference this week, we took a different approach to analyzing performance by using compression entropy, computed over the number of contributions per minute. The bigger compression, the more uniform contributions are; the lower the compression, that means that the contributions change all the time. After some preliminary reports published in FigShare we found that there is a clear trend in an increasing entropy making the algorithm end much faster. This contradicts our initial guess, and also opens new avenues for the design of volunteer evolutionary computing systems, and probably other systems whose performande depends on diversity such as evolutionary algorithms.
Check out the poster and also the presentation done at the conference. You will miss, however, the tulip origami we gave out to the visitors of the poster.
In our research group we support open science, that is why you can find everything, from data to processing scripts to the sources of this paper, in the GitHub repository

Benchmarking evolutionary algorithms

People tend to think that there is a simple way of implementing evolutionary algorithms: whatever language they’re the most familiar with, or, by default, Java or C++. So after receiving several carps from reviewers who didn’t like our use of non-conventional languages like JavaScript of Perl, we decided to test a pile of languages performing simple evolutionary operations: mutation and crossover, and also a very common benchmark, OneMax.
Our poster was accepted in the ECTA conference and we recently presented it in Porto. Have a look at the paper and poster source https://github.com/geneura-papers/2016-ea-languages-PPSN/releases/tag/v1.0ECTA that uses Knitr, and check out the poster.

Evolutionary (and other) algorithms in the cloud

The cloud is where you run your applications, but it’s also how you will design your algorithms from now on. Evolutionary algorithms are specially suited for this, and that is why I have given tutorials on how to adapt evolutionary algorithms to the cloud in PPSN and lately, when one of the keynotes dropped, an updated and abridged version at ECTA 16.
In these tutorials I make an introduction to what is the cloud and what it means: basically, create applications as loosely connected, polyglot, multi-vendor sets of different programs. Which will spawn a slew of new algorithms, starting with the pool-based evolutionary algorithm we have working on for so long.

Pool-based evolutionary algorithms at GECCO 2016

As we usually do, we attended GECCO 2016 this year, a genetic and evolutionary algorithm confernce which took place in Denver, in America.

The paper accepted in the Parallel Evolutionary Systems session and two papers presented in workshops dealt with pool-based evolutionary algorithms and their implementation in volunteer computer systems in browsers. Unlike mainstream evolutionary algorithms, which put the algorithm and the population in the same process or thread, pool based evolutionary algorithms decouple population from algorithms, allowing these to work ephemerally, spontaneously and in a completely asynchronous way.

In these presentations, we focused on browser-based implementations evolutionary algorithms, where by the simple act of visiting a web page, you could help an experiment by running an evolutionary algorithm in your browser. In the first paper, presented in the EvoSoft workshop and dealing with the basic framework, which we call NodIO and entitled NodIO: a framework and architecture for pool-based evolutionary computation, we explained the working principles of this pool-based evolutionary algorithm and made comparisons with other languages and platforms, mainly to prove that, even if there is a difference in performance between the JavaScript used here, it can be more than outset by the fact that spontaneous collaboration can make potentially thousands of users participate in an experiment. This paper was presented by Mario García Valdez, because almost at the same time, I was presenting Visualizing for Success
How Can we Make the User more Efficient in Interactive Evolutionary Algorithms?
, which was an exposition of how what the web page shows has a clear influence on the time the user spends in it and thus on the performance of the system, and also a call for help from this visualization workshop on how to make this time as long as possible. We received many helpful comments, including using badges for users (how this could be done without authentication, which would be a barrier, is not so easy to work out) or creating leaderboards so users can compete with each other.
The paper presented in GECCO proper entitled Performance for the masses
Experiments with A Web Based Architecture to Harness Volunteer Resources for Low Cost Distributed Evolutionary Computation
, dealt with a series of experiments using the platform NodIO published in OpenShift. It has actually been running continuously for a year, although the number of volunteers is close to 0. I will have to check it out, anyway, this long term behavior would be interesting. The paper presented how the behavior of the user presents some patterns, including the fact that their contributions follow a Weibull distribution, very close to what happens in games. Which, in fact is what lead us to submit the first paper to the visualization workshop.
As usual, all our papers are open source and reside in GitHub. If you want copies, just leave a comment and we’ll email them to you.

How good are different languages at runnig evolutionary algorithms?

As part of the EvoStar conference, which took place last week, we presented the poster Benchmarking Languages for Evolutionary Algorithms, where, with help from many friends in Open Science fashion, we tested several a bunch of compiled and scripting languages on several common evolutionary operations: crossover, mutation and OneMax.

It was presented in poster form, and you had to be there to actually understand it. Since you are not, it’s better if you use this comments (or those at the poster) to inquire about it. Or you can check out the interactive presentation we also did, which in fact includes data and everything in the source.
This work is ongoing, and you are very welcome to participate. Just take a peek at the repo, and do a pull request.

There can be only one: Evolving RTS Bots via joust selection

During EvoStar, our group presented several papers on games, multiobjective optimization and implementation of evolutoinary algorithms. This paper was presented as a full talk at EvoGAMES 2016 in Porto (Portugal). BY: Antonio Fernández Ares, Pablo García-Sánchez, Antonio M. Mora García, Pedro A. Castillo, Juan J. Merelo

Source: There can be only one: Evolving RTS Bots via joust selection