Paradiseo

Fast & full featured optimization heuristics framework

# Paradiseo: a Heuristic Optimization Framework

Paradiseo is an open-source full-featured evolutionary computation framework which main purpose is to help you write your own stochastic optimization algorithms, insanely fast.

It focus on the efficiency of the implementation of solvers, by providing:

- a modular design for several types of paradigms,
- the largest codebase of existing components,
- tools for automated design and selection of algorithms,
- a focus on speed and several parallelization options.

# Quick start ⤒

## Download

Download the latest stable release.

Or clone the latest version: `git clone git://scm.gforge.inria.fr/paradiseo/paradiseo.git`

## Build

As Paradiseo is a development framework, you do not really need to install it on all your systems. Just put it somewhere on your development computer, compile it from here and indicate where to find it to your favorite build system.

Paradiseo is mainly developed for Linux, on which it is straightforward to install a C++ build chain. For example, on Ubuntu 18.04: `sudo apt install g++-8 cmake make libeigen3-dev libopenmpi-dev doxygen graphviz libgnuplot-iostream-dev`

Paradiseo use the CMake build system, so building it should be as simple as: `mkdir build ; cd build ; cmake -DEDO=ON .. && make -j`

For more details, see the building Paradiseo section.

## Develop

Download the quick start project template, edit the `CMakeLists.txt` file to indicate where to find Paradiseo and start developing your own solver.

To show you how does a Paradiseo code look, you will find here a minimal implementation of the popular CMA-ES algorithm.

The code is presented without comments, to keep it short, but it is yet full-featured, as you will see if you compile it within the `build` directory, with `c++ cmaes.cpp -I../eo/src -I../edo/src -DWITH_EIGEN=1 -I/usr/include/eigen3 -std=c++17 -L./lib/ -leo -leoutils -les -o cmaes` and run `./cmaes --help`

`1 #include <eo> 2 #include <edo> 3 #include <es.h> 4 #include <do/make_pop.h> 5 #include <do/make_run.h> 6 #include <do/make_continue.h> 7 #include <do/make_checkpoint.h> 8 9 using R = eoReal<eoMinimizingFitness>; 10 using CMA = edoNormalAdaptive<R>; 11 12 R::FitnessType sphere(const R& sol) { 13 double sum = 0; 14 for(auto x : sol) { sum += x * x; } 15 return sum; 16 } 17 18 int main(int argc, char** argv) { 19 eoParser parser(argc, argv); 20 eoState state; 21 22 size_t dim = parser.createParam<size_t>(10, 23 "dimension", "Dimension", 'd', 24 "Problem").value(); 25 26 size_t max_eval = parser.getORcreateParam<size_t>(100 * dim, 27 "maxEval", "Maximum number of evaluations", 'E', 28 "Stopping criterion").value(); 29 30 edoNormalAdaptive<R> gaussian(dim); 31 32 auto& obj_func = state.pack< eoEvalFuncPtr<R> >(sphere); 33 auto& eval = state.pack< eoEvalCounterThrowException<R> >(obj_func, max_eval); 34 auto& pop_eval = state.pack< eoPopLoopEval<R> >(eval); 35 36 auto& gen = state.pack< eoUniformGenerator<R::AtomType> >(-5, 5); 37 auto& init = state.pack< eoInitFixedLength<R> >(dim, gen); 38 auto& pop = do_make_pop(parser, state, init); 39 pop_eval(pop,pop); 40 41 auto& eo_continue = do_make_continue( parser, state, eval); 42 auto& pop_continue = do_make_checkpoint(parser, state, eval, eo_continue); 43 auto& best = state.pack< eoBestIndividualStat<R> >(); 44 pop_continue.add( best ); 45 auto& distrib_continue = state.pack< edoContAdaptiveFinite<CMA> >(); 46 47 auto& selector = state.pack< eoRankMuSelect<R> >(dim/2); 48 auto& estimator = state.pack< edoEstimatorNormalAdaptive<R> >(gaussian); 49 auto& bounder = state.pack< edoBounderRng<R> >(R(dim, -5), R(dim, 5), gen); 50 auto& sampler = state.pack< edoSamplerNormalAdaptive<R> >(bounder); 51 auto& replacor = state.pack< eoCommaReplacement<R> >(); 52 53 make_verbose(parser); 54 make_help(parser); 55 56 auto& algo = state.pack< edoAlgoAdaptive<CMA> >( 57 gaussian , pop_eval, selector, 58 estimator, sampler , replacor, 59 pop_continue, distrib_continue); 60 61 try { 62 algo(pop); 63 } catch (eoMaxEvalException& e) { 64 eo::log << eo::progress << "STOP" << std::endl; 65 } 66 67 std::cout << best.value() << std::endl; 68 return 0; 69 }`

## Get help

If you need immediate support or have any question, the best way to get answers is to send an email to paradiseo-help@lists.gforge.inria.fr. You can also consult the help archives, subscribe to our (low traffic) mailing-list or consult its archives.

Alternatively, you can join us on the official chatroom. You can try our webchat interface, or if you already use IRC, you can directly connect to the irc.freenode.org/#paradiseo multi-user chatroom with your favorite client.

# Rationale ⤒

## Black-box and Gray-box Optimization Problems

Paradiseo targets the development of solvers for mathematical optimization problems for which you cannot compute gradients. The classical use case is the automated design or configuration of some system which is simulated.

It supports mono-objective and multi-objective functions, partial evaluation, several generic way to represent solutions and have all the tools for using your own representation.

Paradiseo does not provides tools for modelling your problem, but makes it easy to find the best algorithm to solve it.

## Metaheuristics / Evolutionary Algorithms

Paradiseo targets the design of metaheuristics solvers using computational intelligence methods, a subdomain of artificial intelligence.

It was originally designed for Evolutionary Algorithms, but rapidly evolved to provide abstractions for several "grammars" for other metaheuristics (or search heuristics, or whatever you call them). As of today, it provides: evolutionary algorithms (evolution strategies, genetic algorithms, etc.), particle swarm optimization, local searches (greedy search, simulated annealing, etc.), estimation of distribution algorithms (covariance-matrix adaptation, etc.).

## Why choosing Paradiseo?

Learning a full-featured framework like Paradiseo very often seems overkill. However, we would like to stress out that you may forget some points while jumping to this conclusion.

### Full-featured

Paradiseo provides the largest mature codebase of state-of-the-art algorithms, and focuses on (automatically) find the most efficient solvers.

The most classical impediment to the use of Paradiseo is that you just want to check if your problem can actually be solved with heuristics. You feel that it would be a loss of time to learn complex stuff if it ends being useless.

However, you should keep in mind that:

- Metaheuristics do seem very easy to implement in textbooks, but the state-of-the art versions of efficient algorithms can be a lot more complex.
- It is usually easy to get something to actually run, but it is far more difficult to get an efficient solver.
- Metaheuristics performances on a given problem are very sensitive to small variations in the parameter setting or the choice of some operators. Which render large experimental plans and algorithm selection compulsory to attain peak efficiency.

Fortunately, Paradiseo have the largest codebase of the market, hardened along 20 years of development of tens of solvers. Additionally, it provides the tools to rapidly search for the best combination of algorithms to solve your problem, even searching for this combination automatically.

### Efficient

Paradiseo is the fastest framework on the market, which is a crucial feature for modern and robust approach to solver design and validation.

Another classical criticism against Paradiseo is that C++ is hard and that a fast language is useless because speed is not a concern when your objective function is dominating all the runtime.

However, we argue that:

- During the design phase of your solver, you will need to estimate its performance against synthetic benchmarks that are fast to compute. In that case, fast computation means fast design iterations. And it's even more true if you plan to use automated design to find the best solver for your problem.
- Modern C++ makes use of the very same high-level abstractions you would find in more accepted languages like Python. Sure, the syntax is cumbersome, but you will not see it after a while, given that you will work at the algorithm level.
- C++ provides full type checking and the largest set of tooling for any modern language, which are your first line of defense against long-term bugs. Sure, it sometimes gives you the impression that you fight against the compiler, but chasing subtle interface bugs across a complex Python code is even harder.

## How fast is Paradiseo?

As indicated in the previous section, this speed is crucially useful for algorithm design and algorithm selection.

You can expect that validating an algorithm implemented with Paradiseo will be up to 10 times faster than its (heavily optimized) Python counterpart.

To give an order of magnitude:

- If you use the "official" vanilla implementation of CMA-ES in Python/Numpy solving the BBOB problem suite through the COCO plateform, running the whole benchmark will take approximately 10 minutes on a single Intel Core i5 @ 2.50GHz with a solid state disk.
- The same experiment, running the Paradiseo implementation using the seamless binding to the IOHprofiler BBOB implementation, will take 1 minute.

Those measures are for a sequential execution, both implementation are able to run in parallel mode.

CMA-ES solves numeric problems with quadratic complexity regarding the number of dimensions. If you target simpler algorithms, they will be faster but one can expect a similar behaviour.

The pycma used for the comparison rely on numpy for the heavy parts of the computations. If you use a pure Python implementation, the difference will be far greater.

# Features ⤒

## Component-based Design

Designing an algorithm with Paradiseo consists in choosing what components (called operators) you want to use for your specific needs, just as building a structure with Lego blocks.

If you have a classical problem for which available code exists (for example if you have a black-box problem with real-valued variables), you will just choose operators to form an algorithm and connect it to your evaluation function (which computes the quality of a given solution).

Example of the operators "slots" for designing an Evolutionary Algorithm. The red "Evaluation" is where you plug your objective function, the yellow slots are the ones that depends on your choice of encoding (if you do not use generic ones). The green slots can be used by any algorithm. Tens of alternative operators may exists for each slot.

If your problem is a bit more exotic, you will have to code a class that encodes how solutions to your problem are represented, and perhaps a few more. For instance, you may want ad-hoc variations operators, but most of the other operators (selection, replacement, stopping criteria, command-line interface, etc.) are already available in Paradiseo.

One of the very powerful feature of Paradiseo is that its design targets easy combination of operators. Is is, for instance, straightforward to plug several different continuation operators in the stopping criterion slot of algorithms.

Popular combination of operators are provided as code-defined functions, with automatic command line argument control.

Additionally, this design allows for all kind of hybridizations between algorithms. For instance, it's easy to plug a local search algorithm as a variation operator of an evolutionary algorithm.

Another advantage is that you can very easily try alternative algorithms. With tens of operators available for popular slots, the number of different algorithms increase very rapidly. For instance, just using basic genetic algorithm operators with set parameters, Paradiseo can provide up to 5 millions different bitstrings algorithms. Given that metaheuristics are very sensitive to the interactions between operators, this approach allows for vital degrees of freedom.

Of course, it's also possible to add new algorithms "grammar". For instance, the grammar for estimation of distribution algorithms is an extension of the one for evolutionary algorithms. That way, you can re-use the operators already implemented for other algorithms.

The grammar of EDAs is extending the grammar of EAs, by adding an intermediate "distribution" data structure and operators manipulating it.

## Large Choice of Components

Paradiseo is organized in several modules, either providing different "grammars" for different algorithms, either providing high-level features. All modules follows the same architecture design and are interoperable with the others, so that you can easily choose the subset of features you need.

The modules of Paradiseo.

It is, for instance, easy to start with a simple local search, then add multi-objective capabilities, then shared-memory parallelization, then hybridization with an evolutionary algorithm and finally plug everything in an objective function so as to optimize the parameters with a particle swarm optimizer.

Below is an abridged list of components available in the EO module (only):

- Flexible design that permits to easily create virtually any algorithm
- Solution representation for continuous and combinatorial problems:
  - binary-strings,
  - permutations,
  - vectors,
  - easily write your own,
  - …
- Several algorithm paradigms:
  - evolution strategies,
  - genetic algorithms,
  - estimation of distribution,
  - particle swarm optimization
  - …
- Many selection and replacement operators:
  - rank-based,
  - deterministic or stochastic tournaments,
  - roulette,
  - elitism,
  - …
- Ready-to-use variations operators:
  - uniform initializer,
  - gaussian mutation,
  - subtree crossover,
  - …
- Easy combination of several operators:
  - proportional combination,
  - sequential call,
  - …
- Parallelization tools:
  - Shared memory loops unrolling (with OpenMP)
  - Message passing parallelization (with openMPI):
    - map/reduce-like design, with operators choice, as in Paradiseo
    - useful existing operators (parallel dynamic multi-start, static evaluations, …)
- Portable and human-readable parameter files
- Suspend and load population from files
- Versatile checkpointing and logging:
  - graphical display,
  - file dump,
  - various statistics,
  - signal catching,
  - …
- Mersenne Twister random number generator (and various distributions)
- No useless computation (sparing fitness call, functor-based calls)
- And more!

## Algorithm Selection and Configuration

Paradiseo provides meta-algorithmics features, like on-the-fly algorithm instanciation. This is useful to dynamically assemble and run an algorithm from a simple numerical encoding. This "algorithm forge" can handle a set of operators and parameter configurations, to be assembled in different "slots" to form an algorithm.

A simplified example of binding between Paradiseo, IOHexperimenter and irace. ParadisEO provides a on-the-fly algorithm instanciation, which is ran on an IOH problem, with performances estimated with a generic and fast module. All components figured with lego bricks forms a single, integrated, binary.

As the Paradiseo codebase provides generic algorithm and a large set of operators, it's easy to have access to a huge number of algorithms alternatives: there's easily millions of unique combinations.

To evaluate those algorithms, you can use bindings toward fast benchmarking tools (like IOHexperimenter), which allow for the fastests runs of the market.

You can then wrap this evaluation within an optimizer, to automatically search for the best algorithm instance. For instance, you can either use an optimizer made with Paradiseo, either plug the binary with irace (Paradiseo provides an automatic interface generation) and reach budgets of 10 000 runs in just one hour (!).

And voilà! You started by just designing a high-level view of a solver, and you now know which algorithm instance allow for the best performance.

Note that the binding with IOHexperimenter also allow to easily import and explore experimental results in the IOHanalyzer HMI. Ohlala.

## Portability

Paradiseo is mainly developed under Linux operating systems, where its dependencies and the C++ toolchain are easy to install. Recent versions have been tested with gcc and clang compilers.

Stable versions should however work on Windows and any Unix-like operating system with a standard-conforming C++ development system.

Previous versions of Paradiseo have been tested on the following platforms:

- Linux x86 with GCC 3.x and 4.x
- Linux x86_64 with GCC 3.x and GCC 4.x
- MacOS X/Darwin PowerPC with GCC 3.x
- MacOS X/Darwin x86 with GCC 4.x
- Microsoft Windows using Cygwin's GCC 3.x (cygming special).
- Microsoft Windows using Visual Studio 2003/2005; projects files are provided.
- Solaris SPARC with GCC 3.x
- Solaris x86 with GCC 3.x

Recent versions of Paradiseo uses the CMake portable build system, that permits to easily generate a build script for your environment.

If you have tested Paradiseo on a system not listed here, please let us know.

## VS other Frameworks

The following tables show how Paradiseo compares to other active open-source frameworks, to the best of our knowledge (updated on 2019-10-18).

Projects

Framework | Colored by speed level Language | License | If ‘Yes’, you have to disclose the sources of your solver when using this framework Copyleft | Number of contributors Contrib. | Number of lines of code ×1000 kloc
Paradiseo | C++ | LGPLv2/CeCill | No | 50 | 82
jMetal | Java | MIT | No | 29 | 60
ECJ | Java | AFLv3 | Yes | 33 | 54
OpenBeagle | C++ | LGPLv3 | No | 4 | 48
Jenetics | Java | Apachev2 | No | 10 | 47
ECF | C++ | MIT | No | 19 | 15
DEAP | Python | LGPLv3 | No | 45 | 9
Cllib | Scala | Apachev2 | No | 17 | 4

Features

Framework | Evolutionary Algorithms EA | Genetic Programming GP | Estimation of Distribution Algorithms EDA | Particle Swarm Opimization PSO | Local Search LS | Multi-Objective Optimization MO | Parallelization for Clusters MPI | Paralellization for Multicores MC | Parallelization on GPU GPU | Fitness Landscapes FL | Algorithm Selection AS | Score
Paradiseo | Y | Y | Y | Y | Y | Y | Y | Y | N | Y | Y | 10
ECJ | Y | Y | Y | N | N | Y | Y | Y | Y | N | N | 7
jMetal | Y | N | N | Y | N | Y | Y | N | N | N | N | 4
ECF | Y | Y | N | Y | N | N | Y | N | N | N | N | 4
DEAP | Y | N | N | N | N | Y | Y | Y | N | N | N | 4
OpenBeagle | Y | N | N | N | N | Y | Y | N | N | N | N | 3
Jenetics | Y | ? | N | N | N | Y | N | N | N | N | N | 2

Gathering and maintaining this information is not easy, so take them with a grain of salt, and if you see errors in those tables, please contact us.

# Documentation ⤒

## Academic Articles about Paradiseo

- The core EO module is described in the following scientific article:

  > M. Keijzer, J.J. Merelo, G. Romero, G., M. Schoenauer, Evolving objects: A general purpose evolutionary computation library, Artificial Evolution, 2310, 829--888 (2002).

  If you used EO in a study, please cite it. As of today, it has been cited more than 250 times.

  @Article{Keijzer2001,
  title = "Evolving Objects: A General Purpose Evolutionary Computation Library ",
  author = "Maarten Keijzer and J. J. Merelo and G. Romero and M. Schoenauer",
  journal = "Artificial Evolution",
  year = "2002",
  volume = "2310",
  pages = "829--888",
  keywords = "genetic algorithms, genetic programming, evolutionary computation, metaheuristic, computational intelligence, optimization",
  URL = "http://www.lri.fr/~marc/EO/EO-EA01.ps.gz",
  size = "12 pages",
  }

- The multi-objective module (MOEO) is described in:

  > A. Liefooghe, M. Basseur, L. Jourdan, E.-G. Talbi, Paradiseo-MOEO: A Framework for Evolutionary Multi-objective Optimization, EMO 2007, LNCS Vol. 4403, pp. 386-400, Matsushima, Japan.

- The local search module (MO) is explained in:

  > J. Humeau, A. Liefooghe, E-G. Talbi, S. Verel, Paradiseo-MO: From Fitness Landscape Analysis to Efficient Local Search Algorithms, Research Report RR-7871, INRIA, 2012.

- A book about metaheuristics use Paradiseo as its framework of choice and explains in details several of its concepts, along with algorithmics content:

  > El-Ghazali Talbi, Metaheuristics: from design to implementation, Wiley, 2009. (624pp), ISBN: 978-0-470-27858-1

Research Reports

- J. Humeau, A. Liefooghe, E-G. Talbi, S. Verel Paradiseo-MO: From Fitness Landscape Analysis to Efficient Local Search Algorithms, Research Report RR-7871, INRIA, 2012.
- A. Liefooghe, L. Jourdan, E.-G. Talbi, A Unified Model for Evolutionary Multiobjective Optimization and its Implementation in a General Purpose Software Framework: Paradiseo-MOEO, Research Report RR-6906, INRIA, 2009.

Journal papers

- S. Cahon, N. Melab and E-G. Talbi, "Paradiseo: A Framework for the Reusable Design of Parallel and Distributed Metaheuristics", Journal of Heuristics, vol. 10(3), pp.357-380, May 2004.
- N. Melab, S. Cahon, E-G. Talbi, Grid computing for parallel bioinspired algorithms. Journal of Parallel and Distributed Computing (JPDC), Elsevier Science, Vol. 66(8), Pages 1052-1061, Aug. 2006.
- E-G. Talbi, S. Cahon and N. Melab. Designing cellular networks using a parallel hybrid metaheuristic. Journal of Computer Communications, Elsevier Science, Vol. 30(4), Pages 698-713, 2007
- S. Cahon, N. Melab and E-G. Talbi, "Building with Paradiseo reusible parallel and distributed evolutionary algorithms", Parallel Computing, vol.30(5-6), pp.677-697, June 2004.

Conference papers

- A. Liefooghe, M. Basseur, L. Jourdan, E.-G. Talbi, "Paradiseo-MOEO: A Framework for Evolutionary Multi-objective Optimization", EMO 2007, LNCS Vol. 4403, pp. 386-400, Matsushima, Japan.
- S. Cahon, N. Melab and E-G. Talbi, "Paradiseo: a framework for metaheuristics", International Workshop on Optimization Frameworks for Industrial Applications (ICOPI 2005), Paris, France, October 19-21, 2005.
- S. Cahon, N. Melab and E-G. Talbi, "An Enabling Framework for Parallel Optimization on the Computational Grid", In Proceedings of the fifth IEEE/ACM International Symposium on Cluster Computing and the Grid (CCGRID'2005), Cardiff, UK, May, 2005.
- S. Cahon, N. Melab, E-G. Talbi and M. Schoenauer, "PARADISEO based design of parallel and distributed evolutionary algorithms", Evolutionary Algorithms EA'2003, Marseille, France, LNCS, October 2003.

Paradiseo has been experimented on different academic and industrial problems. In this section, we present different applications that show the wide range of potential of this framework as it has been applied to scheduling problems, continuous optimization, data-mining applications, bioinformatic applications, telecommunication problem, etc.

Here is a list of some known publications that used Paradiseo:

### Automated Planning

- Jacques Bibaï, Pierre Savéant, Marc Schoenauer, Vincent Vidal, An Evolutionary Metaheuristic Based on State Decomposition for Domain-Independent Satisficing Planning, Twentieth International Conference on Automated Planning and Scheduling (2010). Winner of the International Planning Competition
- Jacques Bibaï, Pierre Savéant, Marc Schoenauer, Vincent Vidal, An Evolutionary Metaheuristic for Domain-Independent Satisficing Planning, Genetic and Evolutionary Computation Conference (2010). Silver Medal at the Human-Competitive Competition

### Telecommunications

Cellular network design is a major issue in mobile telecommunication systems. A model of the problem in its full practical complexity, based on multiobjective constrained combinatorial optimization, has been investigated. We adopted the Pareto approach at resolution in order to compute a set of diversified non-dominated networks, thus removing the need for the designer to rank or weight objectives a priori.

Ref:

- E-G. Talbi, S. Cahon and N. Melab. "Designing cellular networks using a parallel hybrid metaheuristic". Journal of Computer Communications, Elsevier Science, To appear in 2006.

### Bi-objective flow-shop scheduling problem.

The flow-shop is one of the most widely investigated scheduling problem of the literature. But, the majority of studies considers it on a single-criterion form. However, other objectives than minimizing the makespan can be taken into account, like, e.g., minimizing the total tardiness.

Ref:

- Arnaud Liefooghe, Matthieu Basseur, Laetitia Jourdan, El-Ghazali Talbi. "Combinatorial Optimization of Stochastic Multi-objective Problems: an Application to the Flow-shop Scheduling Problem". In S. Obayashi et al. (Eds.): Evolutionary Multi-Criterion Optimization (EMO 2007), LNCS vol. 4403, pp. 457-471, Matsushima, Japan (2007)

### Electromagnetic properties of conducting polymer composites in the microwave band.

Due to the proliferation of electromagnetic interferences, designing protecting material for high frequencies equipments has become an important problem. A new multi-objective model is proposed to design the different layers of a conducting polymer. To solve this model, a multi-objective continuous genetic algorithm is used. This algorithm offers several solutions with different physical properties and different costs.

Ref:

- Oliver Schuetze, Laetitia Jourdan, Thomas Legrand, El-Ghazali Talbi, Jean Luc Wojkiewicz, "A Multi-Objective Approach to the Design of Conducting Polymer Composites for Electromagnetic Shielding", EMO 2007, LNCS Vol. XX, pp. XX-XX, Matsushima, Japan.

### Knowledge discovery in biological data from microarray experiments.

The problem of analyzing microarray data is actually a major issue in genomics. Often used techniques are clustering and classification. The authors propose to analyze those data through association rules. The problem is modeled as a multi-objective rule mining problem and a genetic algorithm is used to explore the large search space associated. Thence, MOGA permitted to present previously undiscovered knowledge.

Ref:

- M. Khabzaoui, C. Dhaenens and E-G. Talbi, "A Cooperative Genetic Algorithm for Knowledge Discovery in MicroArray Experiments", In Parallel Computing for Bioinformatics and Computational Biology, Edited by Albert Y. Zomaya, ISBN: 0-471-71848-3, Chapter 13, pp 305-326, April 2006.
- L. Jourdan, M. Khabzaoui, C. Dhaenens and E-G. Talbi, "A hybrid metaheuristic for knowledge discovery in microarray experiments", In Handbook of Bioinspired Algorithms and Applications, Edited by S. Olariu and A.Y. Zomaya, CRC Press, USA, ISBN: 1-58488-475-4, October 2005.

### Molecular Docking and Protein Structure Prediction

Ref:

- Alexandru-Adrian Tantar, Nouredine Melab, El-Ghazali Talbi, "A Comparative Study of Parallel Metaheuristics for Protein Structure Prediction on the Computational Grid", IEEE International Parallel & Distributed Processing Symposium(IPDPS 2007), pp. 1-10, 26-30 March 2007, Long Beach, California, USA.
- A-A. Tantar, N. Melab, E-G. Talbi, O. Dragos and B. Parent, "A Parallel Hybrid Genetic Algorithm for Protein Structure Prediction on the Computational Grid", In Future Generation Computer Systems, Elsevier Science, vol. 23(3), pp. 398-409, 2007.
- Alexandru-Adrian Tantar, Nouredine Melab, El-Ghazali Talbi and Bernard Toursel,"Solving the Protein Folding Problem with a Bicriterion Genetic Algorithm on the Grid", Fourth International Workshop on Biomedical Computations on the Grid(BioGrid'06), May 16-19, 2006, Singapore.

### Protein identification.

Ref:

- J-C Boisson, L. Jourdan, E-G. Talbi and C. Rolando "Protein Sequencing with an Adaptive Genetic Algorithm from Tandem Mass Spectrometry", CEC 2006, 0-7803-9489-5, July 16-21 2006, pp 1412-1419, Vancouver, Canada.
- J-C. Boisson, L. Jourdan, E-G. Talbi and C. Rolando, "A Preliminary Work on Evolutionary Identification of Protein Variants and New Proteins on Grids", Second IEEE Workshop on High Performance Computing in Medicine and Biology (HiPComb 2006). Proccedings of the 20th International Conference on Advance Information Networking and Application, vol. 2, pp. 583-587. Vienne, Austria, April 18-20, 2006.

### Engineering

- J.J. Gilijamse, J. Küpper, S. Hoekstra, S.Y.T. van de Meerakker, G. Meijer, Optimizing the Stark-decelerator beamline for the trapping of cold molecules using evolutionary strategies, Physical Review, A 73, 063410 (2006).
  Also available at arXiv physics/0603108 (2006).

### Metaheuristics Design

- Johann Dreo, Using Performance Fronts for Parameter Setting of Stochastic Metaheuristics, Genetic and Evolutionary Computation Conference, (2009).

## Presentations Slides

The following documents aim to provide general overviews of the different Paradiseo's modules. They are based on different pdf files which offer complementary view on both theoritical aspects and pratical use.

### Paradiseo-EO

- A functional and "philosophical" overview of the EO module was presented at EA'01 conference. You can download the paper or the slides.
- Metaheuristics for Combinatorial Optimization [pdf] by E-G. Talbi and S.Cahon: provides general concept on metaheuristics for combinatorial optimization.
- Reusable Design of Metaheuristics [pdf] by S.Cahon, E-G. Talbi and N. Melab: explains how to use Paradiseo-EO with a simple example.

### Paradiseo-MO

- Reusable Design of Local Searches and Tools for Landscape Analysis [pdf] by S.Verel, A.Liefooghe and J.Humeau: explains the new design of Paradiseo-MO.
- Paradiseo-MO: From fitness landscape analysis to efficient local search algorithms [pdf] by J.Humeau, A.Liefooghe, E-G. Talbi, and S.Verel (presented at ROADEF 2012).

### Paradiseo-MOEO

- Metaheuristics for Multi-objective Optimization [pdf] by E.-G. Talbi and the Paradiseo group: presents multi-objective optimization concepts, a taxonomy of resolution methods and gives performance evaluation examples.
- Reusable Design of Metaheuristics for Multi-objective Optimization [pdf] by E.-G. Talbi and the Paradiseo group: explains how to implement metaheuristics for multi-objective optimization using Paradiseo-MOEO through a simple example.

## Tutorials

Examples on the differents metaheuristics are available in "tutorials" directory of each module of Paradiseo. Here you can find the corresponding explications.

### Tutorials on EO (evolutionary algorithms module)

- EO Lesson1-5 Implement a GA
- EO Lesson6 first part Implement a real PSO algorithm
- EO Lesson6 second part Implement a binary PSO algorithm

### Tutorials on MO (local search module)

- MO Lesson1 Hill Climber
- MO Lesson2 Neighborhoods (classical and indexed)
- MO Lesson3 Simulated Annealing and Checkpointing
- MO Lesson4 Tabu Search
- MO Lesson5 Iterated Local Search
- MO Lesson6 Fitness Landscapes Analysis
- MO Lesson7 Hybrid Lesson

### Tutorials on MOEO (multi-objective module)

- MOEO Lesson1 Implement NSGA, NSGA-II and IBEA for the SCH1 problem
- MOEO Lesson2 Evolutionary Algorithms for the flow-shop scheduling problem
- MOEO Lesson3 Evolutionary Algorithms with a user-friendly parameter file
- MOEO Lesson4 Dominance-based Local Search for the flow-shop scheduling problem

Tutorials SMP: new

- SMP Lesson1 Algorithm wrapping with Master / Workers model

### Tutorials on parallelization

- Series on Island Model with Paradiseo, by Alexandre Quemy: 1. heterogeneous island model, 2. components and basics, 3. advanced island model manipulations.
- PEO Intro Technical introduction
- PEO Lesson2 Multistart over an evolutionary algorithm
- PEO Lesson3 Parallel evaluation
- PEO Lesson5 Island model

### Utilities

- Utils Lesson1 Using configuration files
- Utils Lesson2 Using statistics

## API documentation

The heart of Paradiseo is a set of classes implementing operators. Each module has a separate API documentation. If you want to browse the features and find which class to use, this is the right entry point

For your convenience, you can browse an online API doc for Paradiseo version 2.0:

- doc-eo (includes doc on EO, PSO and EDO)
- doc-mo
- doc-moeo
- doc-smp

Note that if you want to find the API documentation for the version you have at hand, just build the `make doc` target and open `paradiseo/<build>/<module>/doc/html/index.html` in your web browser.

## Examples of real solvers

If you want to see examples of real solvers:

- The examples page on INRIA Paradiseo pages (with explanations).
- The contributed code on the project page.
- The Descarwin project hold the "DaE" planning solver, which is implemented with Paradiseo and won the International Planning Competition.

# Code ⤒

## Downloads

The current stable release is version 2.0.1: ParadisEO 2.0.1. Some other releases (older or newer) can be found on GitHub/paradiseo/releases.

You can obtain the latest stable and beta version directly via the official Git repository: `git clone git://scm.gforge.inria.fr/paradiseo/paradiseo.git`. The release are on the "master" branch.

Or you can use (at your own risks) the development repositories of the developers:

- Johann Dreo's: on GitHub.

## Dependencies

In order to build the latest version of Paradiseo, you will need a C++ compiler supporting C++17. So far, GCC and CLANG gave good results under Linux. You will also need the CMake and make build tools.

A free working build chain under Windows seems always difficult to find. Paradiseo 2.0.1 was successfully tested with MinGW (minus the PEO module), but it's unsure if it still work for recent versions. If you managed to build under Windows, your feedback would be appreciated.

Some features are only available if some dependencies are installed:

- Most of the EDO module depends on either uBlas or Eigen3. The recommended package is Eigen3, which enables the adaptive algorithms.
- Doxygen is needed to build the API documentation, and you should also install graphviz if you want the class relationship diagrams.
- GNUplot is needed to have the… GNUplot graphs at checkpoints.

To install all those dependencies at once under Ubuntu (18.04), just type: sudo apt install g++-8 cmake make libeigen3-dev libopenmpi-dev doxygen graphviz libgnuplot-iostream-dev.

## Compilation

The build chain uses the classical workflow of CMake. The recommended method is to build in a specific, separated directory and call `cmake ..` from here. CMake will prepare the compilation script for your system of choice which you can change with the `-G <generator-name>` option (see the CMake doc for the list of available generators).

Under Linux, the default is make, and a build command is straitghtforward: `mkdir build ; cd build ; cmake .. && make -j`

There is, however, several build options which you may want to switch. To see them, we recommend the use of a CMake gui, like `ccmake` or `cmake-gui`. On the command line, you can see the available options with: `cmake -LH ..`. Those options can be set with the `-D<option>=<value>` argument to cmake.

The first option to consider is CMAKE_BUILD_TYPE, which you most probably want to set to "Debug" (during development/tests) or "Release" (for production/validation).

Other important options are: `EDO` (which is false by default) and parallelization options: `ENABLE_OPENMP, MPI, SMP`.

By default, the build script will build the Paradiseo libraries only.

If you ENABLE_CMAKE_TESTING and BUILD_TESTING, it will be the tests, which you can run with the "ctest" command.

If you ENABLE_CMAKE_EXAMPLE, it will also build the examples.

## Licenses

Paradiseo is distributed under the GNU Lesser General Public License and the CeCILL license (depending on the modules).

Note that those licenses places copyleft restrictions on a program created with Paradiseo, but does not apply these restrictions to other software that would links with the program.

## Contribute

Paradiseo development is open and contributions are welcomed.

The official bug tracker is available on the project page. But you may be more confortable using the issue tracker of Johann Dreo's project page on GitHub.

If you have any question about contributing: subscribe to our (low traffic) mailing-list.

# History ⤒

## Institutional support

Paradiseo have been developed with the support of the following institutions:

- INRIA (current maintainer)
- University of the Littoral Opal Coast (current maintainer)
- Thales (current maintainer)
- École Polytechnique
- University of Granada
- Vrije Universiteit Amsterdam
- Leiden University
- French National Centre for Scientific Research (CNRS)
- French National Agency for Research (ANR)
- Fritz Haber Institute of the Max Planck Society
- Center for Free-Electron Laser Science
- University of Angers
- French National Institute of Applied Sciences
- Free University of Brussels

## Authors

The EO module was started in 1999 by the Geneura Team at the University of Granada, headed by Juan Julián Merelo. The original Web site is also the only place where you will find old releases of Paradiseo (up to 0.8.7), but beware that it is not compatible at all with the current version.

You can read this PowerPoint presentation, that shows the EO philosophy back then. It includes a Visual Basic (!) macro for evolving objects in Visual Basic for Applications.

The developement team has then been reinforced by Maarten Keijzer, the C++ wizard who designed the current neat architecture), and Marc Schoenauer (who became a prominent researcher in the evolutionary algorithm community). Later came Jeroen Eggermont, who, among other things, did a lot of work on GP, INRIA Dolphin Team, Olivier König, who did a lot of useful additions and cleaning of the code and Jochen Küpper, working on infrastructure maintenance.

El-Ghazali Talbi's INRIA team did a lot of contributions starting from around 2003, on their own module collection called Paradiseo. Thomas Legrand, Sébastien Cahon and Nouredine Melab worked on parallelization modules. Arnaud Liefooghe worked a lot on the multi-objective module and on the local-search one along with Sébastien Verel and Jeremy Humeau. In the same team, C. C. and J. Boisson made significant contributions. Karima Boufaras specifically worked on (now deprecated) GPU tools.

The (then) EO project was then taken over by Johann Dreo, who worked with the help of Caner Candan on adding the EDO module. Johann and Benjamin Bouvier have also designed a MPI parallelization module. Alexandre Quemy also worked on parallelization codes.

In 2012, the two project (EO and Paradiseo) were merged in a single one by Johann Dreo, Sébastien Verel and Arnaud Liefooghe, who act as maintainers ever since.

In 2020, automated algorithm selection tools and binding toward the IOH profiler validation tool were added.

Around 50 people contributed to Paradiseo so far and we cannot list them all, so thanks also to those not listed here.

Some softwares listed here are using Paradiseo, but they are not maintained by the Paradiseo team. They may not be free softwares.

- DegaX is an ActiveX control which embeds Paradiseo 0.8.4.
- EASEA was a GUI that permits to build evolutionary algorithm with Paradiseo or the GAlib. It is now a platform that allows program evolutionary algorithms on massively parallel many-core architectures.
- GUIDE is a GUI that allows the generation of evolutionary algorithms. It can use Paradiseo or ECJ.