EvoloPy: An Open-Source Nature-Inspired Optimization Framework in Python

As an initiative to keep an implementation of the recent nature-inspired metaheuristics as well as the classical ones in a single open source framework, we introduce EvoloPy. EvoloPy is an open source and cross-platform Python  framework that implements a wide range of metaheuristic algorithms. The goal is to take the advantage of the rapidly growing scientific community of Python and provide a set of robust optimizers as free and open source software. We believe that implementing such algorithms in Python will increase their popularity and portability among researchers and non-specialists coming from different domains. The powerful libraries and packages available in Python (such as NumPy) will make it more feasible to apply metaheuristics for solving complex problems on a much higher scale.

Our poster of EvoloPy was accepted in the ECTA conference and we recently presented it in Porto. Have a look at the paper and poster source:

Paper source: https://github.com/7ossam81/EvoloPy
Poster source: https://github.com/7ossam81/EvoloPy-poster
List of available optimizers: https://github.com/7ossam81/EvoloPy/wiki/List-of-optimizers

Thank you Python and NumPy :)

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.

Master of Evolution! Using Genetic Algorithms to generate decks for the game HearthStone

This September we attended to the IEEE CIG 2017 Conference in Santorini, Greece, to present the paper “Evolutionary Deckbuilding in HearthStone”. This paper was written in collaboration with our colleagues Alberto Tonda and Giovanni Squillero.

The story of this paper started a (not so) long time ago while me and Alberto were discussing about how awesome HearthStone is. Suddenly, we thought about how easy it would be to create the constraints for the uGP framework, and that there were some open source simulators of the game. In a while, we already had the constraints, the simulator adapted to accept individuals from uGP, and some experiments running.

And we finished the paper after, of course.

You can download the paper draft from here (the electronic original version is not available yet).

And here is the presentation:

The abstract:

—One of the most notable features of collectible card games is deckbuilding, that is, defining a personalized deck before the real game. Deckbuilding is a challenge that involves a big and rugged search space, with different and unpredictable behaviour
after simple card changes and even hidden information. In this paper, we explore the possibility of automated deckbuilding: a genetic algorithm is applied to the task, with the evaluation delegated to a game simulator that tests every potential deck against a varied and representative range of human-made decks.
In these preliminary experiments, the approach has proven able to create quite effective decks, a promising result that proves that, even in this challenging environment, evolutionary algorithms can find good solutions.

Starcraft GP nominated to the HUMIES award

This year we participated in the HUMIES awards with our paper “Towards Automatic StarCraft Strategy Generation Using Genetic Programming“, accepted at CIG2015, wrote in collaboration with Politecnico di Torino and INRA. Our paper was elected from 28 candidates to be part of the 8 finalists, so we can consider it a great achievement. Although we didn’t won, because the astounding quality of the other works, we are thrilled about our nomination :)

Here is the presentation. It even includes a reference to Starship Troopers!

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.