Exploiting Tournament Selection for Efficient Parallel Genetic Programming

Genetic Programming (GP) is a computationally intensive technique which is naturally parallel in nature. Consequently, many attempts have been made to improve its run-time from exploiting highly parallel hardware such as GPUs. However, a second methodology of improving the speed of GP is through efficiency techniques such as subtree caching. However achieving parallel performance and efficiency is a difficult task. This paper will demonstrate an efficiency saving for GP compatible with the harnessing of parallel CPU hardware by exploiting tournament selection. Significant efficiency savings are demonstrated whilst retaining the capability of a high performance parallel implementation of GP. Indeed, a 74% improvement in the speed of GP is achieved with a peak rate of 96 billion GPop/s for classification type problems

Global distributed evolution of L-systems fractals

Internet based parallel genetic programming (GP) creates fractal patterns like Koch’s snow flake. Pfeiffer, http://www.cs.ucl.ac.uk/staff/W.Langdon/pfeiffer.html, by analogy with seed/embryo development, uses Lindenmayer grammars and LOGO style turtle graphics written in Javascript and Perl. 298 novel pictures were produced. Images are placed in animated snow globes (computerised snowstorms) by www web browsers anywhere on the planet. We discuss artificial life (Alife) evolving autonomous agents and virtual creatures in higher dimensions from a free format representation in the context of neutral networks, gene duplication and the evolution of higher order genetic operators

TensorFlow Enabled Genetic Programming

Genetic Programming, a kind of evolutionary computation and machine learning algorithm, is shown to benefit significantly from the application of vectorized data and the TensorFlow numerical computation library on both CPU and GPU architectures. The open source, Python Karoo GP is employed for a series of 190 tests across 6 platforms, with real-world datasets ranging from 18 to 5.5M data points. This body of tests demonstrates that datasets measured in tens and hundreds of data points see 2-15x improvement when moving from the scalar/SymPy configuration to the vector/TensorFlow configuration, with a single core performing on par or better than multiple CPU cores and GPUs. A dataset composed of 90,000 data points demonstrates a single vector/TensorFlow CPU core performing 875x better than 40 scalar/Sympy CPU cores. And a dataset containing 5.5M data points sees GPU configurations out-performing CPU configurations on average by 1.3x.Comment: 8 pages, 5 figures; presented at GECCO 2017, Berlin, German

Studying Parallel Evolutionary Algorithms: The cellular Programming Case

Parallel evolutionary algorithms, studied to some extent over the past few years, have proven empirically worthwhile—though there seems to be lacking a better understanding of their workings. In this paper we concentrate on cellular (fine-grained) models, presenting a number of statistical measures, both at the genotypic and phenotypic levels. We demonstrate the application and utility of these measures on a specific example, that of the cellular programming evolutionary algorithm, when used to evolve solutions to a hard problem in the cellular-automata domain, known as synchronization

XML-based genetic rules for scene boundary detection in a parallel processing environment

Genetic programming is based on Darwinian evolutionary theory that suggests that the best solution for a problem can be evolved by methods of natural selection of the fittest organisms in a population. These principles are translated into genetic programming by populating the solution space with an initial number of computer programs that can possibly solve the problem and then evolving the programs by means of mutation, reproduction and crossover until a candidate solution can be found that is close to or is the optimal solution for the problem. The computer programs are not fully formed source code but rather a derivative that is represented as a parse tree. The initial solutions are randomly generated and set to a certain population size that the system can compute efficiently. Research has shown that better solutions can be obtained if 1) the population size is increased and 2) if multiple runs are performed of each experiment. If multiple runs are initiated on many machines the probability of finding an optimal solution are increased exponentially and computed more efficiently. With the proliferation of the web and high speed bandwidth connections genetic programming can take advantage of grid computing to both increase population size and increasing the number of runs by utilising machines connected to the web. Using XML-Schema as a global referencing mechanism for defining the parameters and syntax of the evolvable computer programs all machines can synchronise ad-hoc to the ever changing environment of the solution space. Another advantage of using XML is that rules are constructed that can be transformed by XSLT or DOM tree viewers so they can be understood by the GP programmer. This allows the programmer to experiment by manipulating rules to increase the fitness of a rule and evaluate the selection of parameters used to define a solution

Scalability of genetic programming model

Tématem práce je praktická realizace jednoho ze způsobů paralelního zpracování genetického programování, tzv. ostrovního modelu. První část je teoretická. Popisuje pojmy genetického programování, Age-layered population structure a ostrovní model. Ve druhé části je popsána realizace ostrovního modelu v jazyce Java.Theme of this thesis is practical realization of so-called Island model which is one of way of parallel genetic programming. First part is theoretical. This part is describing terms of genetic programming, age-layered population structure and island model. In second part of thesis is described realization of island model in Java language.