Difference between revisions of "Evoptool: Evolutionary Optimization Tool"

Revision as of 15:48, 29 May 2009

Project profile

Short Description

The project focus on the study, implementation, comparison and analysis of different algorithms for combinatorial optimization using techniques and algorithms proposed in Evolutionary Computation. In particular we are interested in the study of Estimation of Distribution Algorithms, a recent meta-heuristic, often presented as an evolution of Genetic Algorithms, where classical crossover and mutation operators, used in genetic algorithms, are replaced with operators that come from statistics, such as sampling and estimation. The focus will be on the implementation of new hybrid algorithms able to combine estimation of distribution algorithms with different approaches available in the evolutionary computation literature, such as genetic algorithms and evolutionary strategies, together with other local search techniques.

User Manual

Algorthms

This section have the purpose to show the set of algorithms implemented inside evoptool. These algorithms belong to different classes, and they perfom different operations. In the following lines are presented the theoretical bases for better undestand the use of evoptool.

• Genetic Algorithm (GA). Is a search technique used in computing to find exact or approximate solutions to optimization and search problems. They grow a population of abstract representations (chromosomes or genotype) of candidate solutions (individuals or phenotypes) to an optimization problem evolves toward better solutions. In this tool, solutions are represented as binary strings of 0s and 1s, but other encodings are also possible. The evolution usually starts from a population of randomly generated individuals and happens in several generations (selection, crossover, mutation). The new population is then used in the next iteration of the algorithm. Commonly, the algorithm terminates when either a maximum number of generations has been produced, or a satisfactory fitness level has been reached for the population. Nowaday, there are the following GA implemented inside evoptool:
  • SGA (Simple Genetic Algorithm). A selection operator is applied to the population and two random recombinator operators called crossover and mutation are applied to the selected population in order to improve the population. SGA uses a truncation selection with a fixed percentage. The variation operators used are Uniform crossover and Bit-Flip mutation.
    • SGA with Binary Tournment.
    • SGA with Population Wise Uniform Crossover.

• Estimation Distribution Algorithm (EDA). Is powerful population-based searcher where the variation operations traditionally implemented via crossover and mutation in EAs are replaced by the process of random sampling from a probability distribution. The distribution is modified generation after generation, using information obtained from the fitter individuals in the population (estimation). The objective of these changes in the distribution is to increase the probability of generating individuals with high fitness. In our tool there are several EDA implemented such:
  • cGA (Compact Genetic Algorithm). It initialize a vector of probabilities where each component follows a Bernoulli distribution with parameter 0.5. Next, two individuals are generated randomly from this vector of probabilities. After the individuals are evaluated, a competion between then is carried out. The competion is held at level of each of the unidimensional variables, in such a way that if for the ith position the conquiring individual take a value different from the loser, the ith component of the vector of probabilities increases its value.
  • PBIL (Population Based Incremental Learning). It maintains unconditional probabilities and no interparameter dependencies are modeled. A vector, P, specifies the probability of generating a 1 in each bit position. Initially, all values in P are set to 0.5. A number of solution vectors are generated by stochastically sampling P; each bitis sampled independently of all the others. The probability vector is then moved towards the generated solution vector with the highest evaluation.
  • UMDA (Univariate Marginal Distribution Algorithm). At each generation, it estimate the joint probability distribution model of the selected individual by factorize it as product of indipendent univariate marginal distributions. Each univariate marginal distribution is estimated from marginal frequency.
  • MIMIC (Mutual Information Maximizing Input Clustering). It attempts to communicate information about the cost function obtained from one iteration of the search to later iterations of the search directly. There are two main components of MIMIC: first, a randomized optimization algorithm that samples from those regions of the input space most likely to contain the maximum; second, an effective density estimator that can be used to capture a wide variety of structure on the input space, and that build a Markov Chain in order to represents the bivariate structure.
  • COMIT (Combining Optimizers with Mutual Information Trees). It gains most of the benefits of modeling the dependencies in the search space at a significantly reduced computational cost. COMIT starts by estimating a probabilistic model of the population, than uses the model to stochastically generate new solutions, it selects the fittest solutions and perfom a local fast-search initialized with these solutions.
    • COMIT with HillClimbing as fast-search.
    • COMIT with PBIL as fast-search.
  • DEUM (Distribution Estimation Using Markov Random Field). DEUM uses MRF approach to estimate and sample the probability distribution using a fitness modelling approach to estimate the MRF parameters. This version of DEUM is an univariate model of probability distribution. This allows to completely eliminate the structure learning task.
    • DEUM with probability vector. It uses the estimated parameters of MRF for update the probability vector, generation by generation.
    • DEUM with direct sampling from Gibbs distribution. It uses the estimated parameters of MFR for directly calcutate the probability of each bit to be 1 or 0.
  • Is-DEUM (Ising model DEUM). It is an evolution from the univariate DEUM to a bivariate version. This algorithm has been defined for solve the Ising Sping Glass problem, and therefore it use a grid structure to model the interactions between each variables of a solution.
    • Is-DEUM with a Metropolis sampler.
    • Is-DEUM with a Gibbs sampler.
  • sBOA (Simple Bayesian Optimization Algorithm). It is a multivariate EDA that uses the Bayesian Dirichlet equivalence metric to measure the goodness of each structure. The search used is a greedy search and it starts in each generation from scratch. In order to reduce the cardinality of the search space the constraint that each node in the Bayesian network as at most k parents is assumed.

• Genetic Estimation Distribution Algorithm (GEDA). This class of Evolute Algorithms is a new proposal class, where genetic variation operations such mutation and crossover are applied to a probabilistic model of the population, rather than directly to an individual of the population. Each generation of a GEDA is composed by estimation of population distribution, variation of the probabilistic model, and sampling from the variated model.
  • gcGA.

• Operative Reaserch classical algorithms (OR). It is distinguished by its frequent use to examine an entire management information system, rather than concentrating only on specific elements. An operations researcher faced with a new problem is expected to determine which techniques are most appropriate given the nature of the system, the goals for improvement, and constraints on time and computing power. For this and other reasons, the human element of OR is vital. Like any other tools, OR techniques cannot solve problems by themselves.
  • Pseudo Boolean Linear Programming.

Optimization Problems

An optimization problem is defined by a specified problem space X, an objective functions F , a search space G, a set of search operations A. Specifying the elements of this tuple is the most important prerequisite for any experiment. The problem space X is the space of all possible solutions canditates, in our case is defined by every combinations of a fixed lengh bit string. The objective functions F (fitness) measure the utility of a solution. As convention, we decide that every objective function return a real number between in the [0,100] set, and if nothing else is stated, maximization is assumed. The search space G is the space of elements where the search operations are applied. For evoptool is defined by the individual lenght (size). The search operations A are all the operations used for perform the search, and such we compare several algorthms a time, they are defined by the particular algorthm used.

Inside evoptool, is possible to choose between several different Objective Functions and customize a proper Optimization Problem setting the individual size and choosing a set of Algorithms to compare. The following list contains the Objective Functions implemented for the moment.

• AltBits.
• One Max and One Zero Max. The task in the OneMax problem is to find a binary string of length n consisting of all ones. The search and problem space are both the fixed-length bit strings G = X = Bn. Each gene (bit) has two alleles 0 and 1 which also contribute exactly this value to the total fitness.
• BinVal. It is something like a perverted version of the OneMax problem, with the objective function defined as the real value of the binary string. Since the bit at index i has a higher contribution to the fitness than all other bit at higher indices together, the comparison between two solution candidates x1 and x2 is won by the

lexicographically bigger one. We can expect that the bits with high contribution (high salience) will converge quickly whereas the other genes with lower salience are only pressured by selection when all others have already been fully converged.

• F3d Deceptive.
  • F3d Deceptive Bipolar.
  • F3d Deceptive Ovelapping.
• Four and Six Peaks. This Objective Function have some global optima wich are isolated, and therefore are difficult to find. It also have some local optima which are easy to get and therefore the search algorithms tend to converge on local optima.
• Trap5. Subjected to maximization based on the Hamming distance to a pre-defined global optimum X' . They build a second, local optimum in form of a hill with a gradient pointing away from the global optimum. This trap is specified with two values, b and r, where b corresponds to the width of the attractive basins (in our case b = 5)and r to their relative importance.
• Quadratic.
• Sat Lib.
• SumVal.
• Royal Road.
• Liepins Vose Fully Deceptive.

Graphic User Interface

The graphic user interface of evoptool is quite intuitive. The user can easily customize his own experiment, and visualize the results graph. In the next rows there are shortly described the GUI componets and their use.

Evoptool running on Ubuntu 9.04.

1. Control Buttons. There are three control buttons which can be used to start or stop the execution of an experitment, and to force the update of the graphs.
2. Objective Function Settings. This part of the toolbar allows the customization of the Objective Problem. It is possible to select an objective function type and fix the individual size as number of bits.
3. Average Mode Setting. Pushing this toggled button it is possible to enable Average Test Mode. In this mode, evoptool will run a difined number of algortihms for each selected one in the Algorithm Panel, and it will perform the average of the different executions of the same algorithm. This option is usefull to show the average behavior of searchers.
4. Algorithms Panel. This panel allows to select a set of algorithms to compare in a particular execution. It is subdivided in four parts, in order to classify algorithms for belonging kind. Next, is possible to customize the parameters of each selected algorithm.
5. Result Tabs. This tabs show the result graphics of the a test execution in real time mode. At this time, only the average fitness graph is implemented in evoptool, but new graphs can be easily added in future.
6. Log Monitor. This monitor keep the user informed about the execution status and several others information such warnings or errors.

Video Example of Use

In this short video is briefly presented an example of use of evoptool. It starts by configuring the Optimization Problem to solve, next select a set of algortihms to compare and finally is showed the execution of a test.

Command Line

Evoptool is also powered by a command line interface, so when the GUI is not needed and can be an unusefull weight, it is possible to escape it and run the software just typing a command inside a terminal such bash or dash.

Commands

• --help (-h). This command print at video usefull information about evoptool commands and their use.
• --version (-v). This command print at video information about currently version of the software and others informations such Copyright or link to the evoptool web page.
• --nogui [CONF_FILE] (-n). This is the more usefull command, such it allows to run evoptool from command line and to achieve the results as an image graph or, for more complex purposes, as data files. This command need only of one parameter that specify the CONFIGURATION FILE for the execution. The configuration file parameter need to be specified with a proper PATH if, and only if, its position differs from the program executable folder. In the next image is possible to view the output generated from an execution of a test from command line.

Evoptool running from command line

Configuration File

In order to run evoptool from command line, is needed a proper configuration file that define all the contraints and settings for that particulat test execution. A default configuration file can be found in the folder ../evoptool/trunk/gui/bin/confi.evoptool, and the user is free to customize it or to create a different file in a different position and specify the entire PATH before run evoptool. The configuration file is quite intuitive, and the default file presents several usuful information about the contents and how to modify it. It is subdivided in three main section, each of them define the behavior of a particular component.

• General Settings. Allows to specify if the execution of a test have to be a normal one (Single Run Mode), or an average execution (Multi Run Mode). In the last case, the parameter N_ALGO define the number of execution of an algorithm on that perform the average.
• Objective Function.Allows to specify which is the Objective Function for this test execution and to define the needed parameters as the individual size or others.
• Algorithms. Allows to define a set of algorithms to run, and to specify their parameters individually.

Some usefull information on how to customize the configuration file are listed in the next rows:

• Comment or uncomment lines with a simbol '#' for customize the configuration.
• Mandatory sections are signaled with a simbol '*', other sections can be deleted.
• Uneeded parameters must be commented!
• Values must be between square braces.
• Order of parameters inside sections is mandatory!
• There must be the end of file delimiter at last line.

Documentation

Evoptool is a software with the purpose to compare the performance of several different algorithms from the Evolutive family and, for obvious reasons, with some algorithms from the classical Operation Research family. Evoptool is written in C++ for the GNU/Linux platform and it exploit the Gtk libraries (in this case gtkmm libraries) and GNUplot utility. Inside this tool there are several implemented algorithms and some wrapped ones from already existing applications.

Evoptool running on Ubuntu 9.04.

Software Modules

Evoptool is made up of several different modules (or libraries). This architecture make easy to organize files and better understanding how the application work.

• common - It contains commons classes and ancestors for the algorithm modules and for the optimization function module.
• ga - It contains the implementation of several Genetic Algorithms.
• eda - It contains the implementation of several Estimation Distribution Algorithms.
• geda - It contains the implementation of several gEDAs.
• or - It contains the implementation of some algorithms from the classical Operation Research.
• opt-pbl - It contains the implementation of several objective functions (fitness), that represents different problem instances.
• gui - This module is the main one, it contains all the classes for manage GUI (algorithm decorators). From the other side it implements the multithread mechanism under the GUI, and last but not list it contains the wrapped applications and take care about wrapping.
• misc - It contains general utility classes such rondom seed geerator.

Hierarchies

This section have the purpose to show some structures internal to evoptool implementation. In particular there are presented the main hierarchies of this software, so, future developers will be facilitated during the development of new componets.

Algorithms Hierarchy

Algorithms Hierarchy

Every algorithm implemented inside evoptool inherits from the abstract class Algorithm. This defines every common attributes and functions, and it is an hight level of abstraction for an algorithm. Next, the others abstract classes GA, EDA, gEDA defines and some times implements common attributes and functions for each category of algorithm, in order to generalize more possible their own concepts. Finally every concrete algorithm will be inherits from one of those last abstract class, and will be a complete implementation of a particular kind of searcher.

Decorators Hierarchy

Algorithm Decorators Hierarchy

Decorators are a very useufull and versatile objects. They allow to easily integrate a new algorithm in the graphic user interface. The abstract class AlgorithmDecorator define some functons that every concrete decorator have to implement. In addiction, it provides the function addParameter that allows a fast customization of each concrete decorator. Finally, a decorator can be viewed as a Wrapper for that algorithms that aren't directly implemented inside evoptool such sBOA.

Objective Functions Hierarchy

Objective Functions Hierarchy

This hierarchy define the structure of Objective Functions. As we can see, it is a quite simple architecture. Every objective functionions inherits from the abstract class ObjectiveFunction, that defines an abstract function f that represents the fitness function. Finally every concrete objective function have to implements this function as specified from the Optimization Problem.

Usefull Links

• Evoptool Repository (Need authentication!)
• GNU Scientific Library
• GUI Library Gtkmm
• Boost Library
• Gnuplot Utility
• C++ Library reference

How To Add New Features

Along the next sections will be presented some procedures to follow in order to add new features and components to evoptool. Those instructions are usefull to avoid common errors or to forget some parts of the implementation.

Add an Algorithm

Add a Decorator

In the following lines there are showed the steps to follow in order to add a new algorithm decorator to the grafic user interface. Here, we suppose to add a decorator called SomeAlgoDecorator for convenience, but obviously these instructions are valid for every decorator.

1. Create files. Create the files SomeAlgoDecorator.h and SomeAlgoDecorator.cpp inside the ../evoptool/trunk/gui/src/ folder.
2. Fill files. Every decorator must inherits from the abstract class AlgorithmDecorator, and must provides a concrete implementation of the abstract function:
   • Solver* newInstance(...)
   • MultiSolver* newInstance(...)
   • string plotProperties(...)
   • void initContent(...)
3. Configure headers. Add the SomeAlgoDecorator.h to AlgorithmDecorators.h (note the 's'!) that is placed in the ../evoptool/trunk/gui/src/ folder. This will avoid to include a long list of decorator headers to the main GUI class.
4. Add decorator to GUI. In order to concretly add the decorator to the GUI, is needed to modify the GUI.cpp class, adding proper code lines to the initAlgorithmDecorators function.

Add an Objective Function

Update Configuration Parser