Paloma de las Cuevas

Performance for the Masses: Experiments with A Web Based Architecture to Harness Volunteer Resources for Low Cost Distributed Evolutionary Computation

Using volunteers browsers as a computing resource presents several advantages, but it remains a challenge to fully harness the browsers capabilities and to model the users behavior so that those capabilities can be leveraged optimally. These are the objectives of this paper, where we present the results of several evolutionary computation experiments with different implementations of a volunteer computing framework called NodIO, designed to be easily deployable on freely available cloud resources. We use different implementations to find out which one is able to get the user to lend more computing cycles and test different problems to check the influence it has on said performance, as measured by the time needed to find a solution, but also by the number of users engaged. From these experiments we can already draw some conclusions, besides the fact that volunteer computing can be a valuable computing resource and that it is essential to be as open as possible with software and data: the user has to be kept engaged to obtain as many computing cycles as possible, the client has to be built to use the computer capabilities fully, and, finally, that the user contributions follow a common statistical distribution.

Implementing Parallel Genetic Algorithm Using Concurrent-functional Languages

The spread of multiprocessor and multi-core architectures have a pervasive effect on the way software is developed. In order to take full advantage of them, a parallel implementation of every single program would be needed, but also a radical reformulation of the algorithms that are more appropriate to that kind of implementation. In this work we design and implement an evolutionary computation model using programming languages with built-in concurrent concepts. This article shows the advantages of these paradigms in order to implement a parallel genetic algorithm (pGA) with an island pools based topology in the concurrent-functional oriented programming languages: Erlang, Scala, and Clojure. Some implementation decisions are analyzed and the results of the solution of a study case are shown.

Enforcing corporate security policies via computational intelligence techniques

This paper presents an approach, based in a project in development, which combines Data Mining, Machine Learning and Computational Intelligence techniques, in order to create a user-centric and adaptable corporate security system. Thus, the system, named MUSES, will be able to analyse the users behaviour (modelled as events) when interacting with the companys server, accessing to corporate assets, for instance. As a result of this analysis, and after the application of the aforementioned techniques, the Corporate Security Policies, and specifically, the Corporate Security Rules will be adapted to deal with new anomalous situations, or to better manage users behaviour. The work reviews the current state of the art in security issues resolution by means of these kind of methods. Then it describes the MUSES features in this respect and compares them with the existing approaches.

Adapting evolutionary algorithms to the concurrent functional language Erlang

In this paper we describe how the usual sequential and procedural Evolutionary Algorithm is mapped to a concurrent and functional framework using the Erlang language. The design decisions, as well as some early results, are shown.

A Performance Assessment of Evolutionary Algorithms in Volunteer Computing Environments: The Importance of Entropy

In a volunteer distributed computing system, users run a program on their own machine to contribute to a common effort. If the program is embedded in a web page, collaboration is straightforward, but also ephemeral. In this paper, we analyze a volunteer evolutionary computing system called NodIO, by running several experiments, some of them massive. Our objective is to discover rules that encourage volunteer participation and also the interplay of these contributions with the dynamics of the algorithm itself, making it more or less efficient. We will show different measures of participation and contribution to the algorithm, as well as how different volunteer usage patterns and tweaks in the algorithm, such as restarting clients when a solution has been found, contribute to improvements and leveraging of these contributions. We will also try to find out what is the key factor in the early termination of the experiments, measuring entropy in the contributions and other large scale indicators.

NodIO: A Framework and Architecture for Pool-based Evolutionary Computation

JavaScript is an interpreted language mainly known for its inclusion in web browsers, making them a container for rich Internet based applications. This has inspired its use, for a long time, as a tool for evolutionary algorithms, mainly so in browser-based volunteer computing environments. Several libraries have also been published so far and are in use. However, the last years have seen a resurgence of interest in the language, becoming one of the most popular and thus spawning the improvement of its implementations, which are now the foundation of many new client-server applications. We present such an application for running distributed volunteer-based evolutionary algorithm experiments, and we make a series of measurements to establish the speed of JavaScript in evolutionary algorithms that can serve as a baseline for comparison with other distributed computing experiments. These experiments use different integer and floating point problems, and prove that the speed of JavaScript is actually competitive with other languages commonly used by the evolutionary algorithm practitioner.

Developing services in a service oriented architecture for evolutionary algorithms

This paper shows the design and implementation of services for Evolutionary Computation following the Service Oriented Architecture paradigm. This paradigm allows independence over language and distribution mechanism. This development is challenging because some technological and design issues, such as abstract design or unordered execution. To solve them, OSGiLiath, an implementation of an abstract Service Oriented Architecture for Evolutionary Algorithms, is used to develop new interoperable services taking into account these restrictions.

The Uncertainty Quandary: A Study in the Context of the Evolutionary Optimization in Games and Other Uncertain Environments

In many optimization processes, the fitness or the considered measure of goodness for the candidate solutions presents uncertainty, that is, it yields different values when repeatedly measured, due to the nature of the evaluation process or the solution itself. This happens quite often in the context of computational intelligence in games, when either bots behave stochastically, or the target game possesses intrinsic random elements, but it shows up also in other problems as long as there is some random component. Thus, it is important to examine the statistical behavior of repeated measurements of performance and, more specifically, the statistical distribution that better fits them. This work analyzes four different problems related to computational intelligence in videogames, where Evolutionary Computation methods have been applied, and the evaluation of each individual is performed by playing the game, and compare them to other problem, neural network optimization, where performance is also a statistical variable. In order to find possible patterns in the statistical behavior of the variables, we track the main features of its distributions, skewness and kurtosis. Contrary to the usual assumption in this kind of problems, we prove that, in general, the values of two features imply that fitness values do not follow a normal distribution; they do present a certain common behavior that changes as evolution proceeds, getting in some cases closer to the standard distribution and in others drifting apart from it. A clear behavior in this case cannot be concluded, other than the fact that the statistical distribution that fitness variables follow is affected by selection in different directions, that parameters vary in a single generation across them, and that, in general, this kind of behavior will have to be taken into account to adequately address uncertainty in fitness in evolutionary algorithms.