Sašo Greiner

Self-Adapting Control Parameters in Differential Evolution: A Comparative Study on Numerical Benchmark Problems

We describe an efficient technique for adapting control parameter settings associated with differential evolution (DE). The DE algorithm has been used in many practical cases and has demonstrated good convergence properties. It has only a few control parameters, which are kept fixed throughout the entire evolutionary process. However, it is not an easy task to properly set control parameters in DE. We present an algorithm-a new version of the DE algorithm-for obtaining self-adaptive control parameter settings that show good performance on numerical benchmark problems. The results show that our algorithm with self-adaptive control parameter settings is better than, or at least comparable to, the standard DE algorithm and evolutionary algorithms from literature when considering the quality of the solutions obtained

Performance comparison of self-adaptive and adaptive differential evolution algorithms

Differential evolution (DE) has been shown to be a simple, yet powerful, evolutionary algorithm for global optimization for many real problems. Adaptation, especially self-adaptation, has been found to be highly beneficial for adjusting control parameters, especially when done without any user interaction. This paper presents differential evolution algorithms, which use different adaptive or self-adaptive mechanisms applied to the control parameters. Detailed performance comparisons of these algorithms on the benchmark functions are outlined.

An Analysis of the Control Parameters’ Adaptation in DE

The main goal of this chapter is to present an analysis of how self-adaptive control parameters are being changed during the current evolutionary process. We present a comparison of two distinct self-adaptive control parameters’ mechanisms, both using Differential Evolution (DE). The first mechanism has recently been proposed in the jDE algorithm, which uses self-adaptation for F and CR control parameters. In the second one, we integrated the well known self-adaptive mechanism from Evolution Strategies (ES) into the original DE algorithm, also for the F and CR control parameters. Both mechanisms keep the third DE control parameter NP fixed during the optimization process. They both use the same DE strategy, same mutation, crossover, and selection operations, even the same initial population, and they both use self-adaptation at individual level.

History mechanism supported differential evolution for chess evaluation function tuning

This paper presents a differential evolution (DE) based approach to chess evaluation function tuning. DE with opposition-based optimization is employed and upgraded with a history mechanism to improve the evaluation of individuals and the tuning process. The general idea is based on individual evaluations according to played games through several generations and different environments. We introduce a new history mechanism which uses an auxiliary population containing good individuals. This new mechanism ensures that good individuals remain within the evolutionary process, even though they died several generations back and later can be brought back into the evolutionary process. In such a manner the evaluation of individuals is improved and consequently the whole tuning process.

An Adaptive Differential Evolution Algorithm with Opposition-Based Mechanisms, Applied to the Tuning of a Chess Program

This chapter describes an algorithm for the tuning of a chess program which is based on Differential Evolution using adaptation and opposition based optimization mechanisms. The mutation control parameter F is adapted according to the deviation of search parameters in each generation. Opposition-based optimization is included in the initialization, and in the evolutionary process itself. In order to demonstrate the behaviour of our algorithm we tuned our BBChess chess program with a combination of adaptive and opposition-based optimization. Tuning results show that adaptive optimization with an opposition-based mechanism increases the robustness of the algorithm and has a comparable convergence to the algorithm which uses only adaptation optimization.

A Differential Evolution for the Tuning of a Chess Evaluation Function

We describe an approach for tuning a chess program evaluation function. The general idea is based on the differential evolution algorithm. The tuning of the evaluation function has been implemented using only final outcomes of games. Each individual of the population represents a chess program with specific (different) parameters of its evaluation function. The principal objective is to ascertain fitness values of individuals in order to promote them into successive generations. This is achieved by competition between individuals of two populations which also changes the individuals of both populations. The preliminary results show that less generations are necessary to obtain good (tuned) parameters. Acquired results have exhibited the fact that population individuals (vectors) are not as diverse as they would be if no changes were made during the competition.

The representation of chess game

Implementation of a fast chess program is a formidable task from many perspectives. The architecture of a programming model is vital to get the best performance. Instead of building a chess program based on knowledge we opted for speed instead. We implemented the majority of all key concepts which turned out to be very efficient in our chess program design. Tests have shown relatively high rating of our implementation despite the simple evaluation function.

Web information system based on open source technologies

Systems based on open-source technologies are proving to be an interesting and very common phenomenon in the area of modern software design. In this context we introduce our Web information system from an unorthodox viewpoint - open-source. We try to give a lucid overview how open-source paradigm can be effectively incorporated and utilised in software design. In addition, we also speak of the benefits of this principle, especially in the context of distributed knowledge sharing and rapid software development. As an outstanding and extremely successful products of open-source paradigm we expose the Linux and FreeBSD operating systems as well as some other renowned projects which have now gained much popularity, particularly because of the ability to contribute to them.

Zero-a blend of static typing and dynamic metaprogramming

Zero is an experimental statically typed, fully object-oriented reflective programming language. Reflective features cover introspection as well as structural and behavioural reflection. The reflective facilities include safe method and class replacements and detailed modification of methods. These enable Zero programs to quickly accommodate to run-time requirements. Behavioural reflection is realised using handlers (hooks), which may be attached to all language constructs based on closures. Zero provides an efficient static typing system with run-time extensions. Methods are first class values and are represented as objects when such representation is required. By using such representation, Zero provides elegant use of statically typed higher-order methods.

Advantages of dynamic method-oriented mechanism in a statically typed object-oriented programming language Z0

Z0 is a simple class-based pure object-oriented programming language. It was basically designed as an experimental language that would provide a static yet expressive type system, method dynamics and pure object abstraction philosophy. Classes define their state explicitly and exclusively through method abstractions. There are no instance variables because Z0 aims to achieve a clean and strict method-based modification mechanism for objects. Dynamic features that enable method-based calculation between objects have been incorporated in a way that conforms to the languages strong static type system. This has been done with a method update mechanism that is fully checkable at compile-time and requires no runtime overhead in invocation