Git Product home page Git Product logo

evolver's Introduction

jMetal project Web site

Build Status Test Status Integration Test Status Documentation Status

jMetal is a Java-based framework for multi-objective optimization with metaheuristics. The last stable version is 6.1. The most recent documentation is hosted in https://jmetal.readthedocs.io.

The current development version (6.2-SNAPSHOT) is a Maven project structured in the following sub-projects:

Sub-project Contents
jmetal-core Core classes
jmetal-solution Solution encodings
jmetal-algorithm Algorithm implementations
jmetal-problem Benchmark problems
jmetal-lab Experimentation and visualization
jmetal-parallel Parallel extensions
jmetal-auto Auto-design and configuration
jmetal-component Component-based algorithms

Comments and suggestions are welcome.

Changelog

  • [06/27/2024] The jMetal project adopts Java 19.
  • [11/30/2023] The Zapotecas-Coello-Aguirre-benchmark (ZCAT) (https://doi.org/10.1016/j.swevo.2023.101350) is included in jMetal.
  • [09/25/2023] The jMetal project adopts Java 17.
  • [09/25/2023] Added a variant of NSGA-II using differential evolution.
  • [07/19/2023] jMetal 6.1 is released.
  • [07/04/2023]. Added the RWA benchmark, described in "Engineering applications of multi-objective evolutionary algorithms: A test suite of box-constrained real-world problems". DOI: https://doi.org/10.1016/j.engappai.2023.106192
  • [12/13/2022] jMetal 6.0 is released.
  • [9/12/2022] The master branch has been renamed main.
  • [7/5/2022] The jMetal project adopts Java 14.
  • [5/23/2022] Algorithm AGE-MOEA-II. Contribution of Annibale Panichella (@apanichella).
  • [5/9/2022] Algorithm AGE-MOEA. Contribution of Annibale Panichella (@apanichella).
  • [3/28/2022] The CF benchmark of constrained multi-objective problems, defined in Constrained Multiobjective Optimization: Test Problem Construction and Performance Evaluations, has been included.
  • [3/28/2022] The constraint handling code has been refactorized and the documentation has been updated.
  • [9/6/2021] Release 5.11
  • [9/6/2021] The jMetal project adopts Java 13.
  • [7/6/2021] The LSMOP benchmark is available.
  • [2/19/2021] The Solution interface has been refactorized.
  • [2/19/2021] New implementation of quality indicators to remove the dependence of jMetal classes. Now, all of them accept as a parameter a matrix containing objective values.
  • [1/21/2021] Added the MicroFAME multi-objective genetic algorith, described in: Alejandro Santiago, Bernabé Dorronsoro, Héctor Fraire, Patricia Ruíz: Micro-Genetic algorithm with fuzzy selection of operators for multi-Objective optimization: microFAME. Swarm and Evolutionary Computation, V.61, March 2021. DOI. Contributed by Alejandro Santiago.

evolver's People

Contributors

ajnebro avatar jfaldanam avatar juanjdurillo avatar

Stargazers

avatar

Watchers

avatar avatar

Forkers

elseviersoftwarex

evolver's Issues

Configurable stop conditions

The stopping condition can be a list of increased maximum evaluation number thresholds so that a single run can allow to optimize the problem until, for example, 10000, 25000, 50000, and 100000 evaluations.

In each of this thresholds, the quality indicators will be logged (#2).

Implement logging

The running of the algorithm can be configured with different levels of logging data. The log information will be semantically annotated and stored in files.

For data to be semantically annotated we can use Jena or export the data in csv or json to use previously developed RDF mappings.

Define how to represent the parameter space and develop an encoder/decoder

The parameter space of an auto-configurable algorithm is composed of parameters and parameter relationships. The parameter has a type, which can be:

  • Real: a real value within a range [upper bound, lower bound]
  • Integer: an integer value within a range [upper bound, lower bound]
  • Cardinal: a list of strings

Our starting point is the parameter space of AutoNSGAII and the configuration file defined to use irace as auto-configuration tool:

populationSize                           "--populationSize "                      o       (100)                                              
#
algorithmResult                          "--algorithmResult "                     c       (externalArchive, population)                      
populationSizeWithArchive                "--populationSizeWithArchive "           i       (10, 200)                      | algorithmResult %in% c("externalArchive")
externalArchive                          "--externalArchive "                     c       (crowdingDistanceArchive, unboundedArchive) | algorithmResult %in% c("externalArchive")
#
createInitialSolutions                   "--createInitialSolutions "              c       (random, latinHypercubeSampling, scatterSearch)                     
#
variation                                "--variation "                           c       (crossoverAndMutationVariation)                     
offspringPopulationSize                  "--offspringPopulationSize "             i       (1, 400)                       | variation %in% c("crossoverAndMutationVariation")
crossover                                "--crossover "                           c       (SBX, BLX_ALPHA, wholeArithmetic) | variation %in% c("crossoverAndMutationVariation")
crossoverProbability                     "--crossoverProbability "                r       (0.0, 1.0)                     
crossoverRepairStrategy                  "--crossoverRepairStrategy "             c       (random, round, bounds)        
sbxDistributionIndex                     "--sbxDistributionIndex "                r       (5.0, 400.0)                   | crossover %in% c("SBX")
blxAlphaCrossoverAlphaValue              "--blxAlphaCrossoverAlphaValue "         r       (0.0, 1.0)                     | crossover %in% c("BLX_ALPHA")
mutation                                 "--mutation "                            c       (uniform, polynomial, linkedPolynomial, nonUniform) | variation %in% c("crossoverAndMutationVariation")
mutationProbabilityFactor                "--mutationProbabilityFactor "           r       (0.0, 2.0)                     
mutationRepairStrategy                   "--mutationRepairStrategy "              c       (random, round, bounds)        
polynomialMutationDistributionIndex      "--polynomialMutationDistributionIndex " r       (5.0, 400.0)                   | mutation %in% c("polynomial")
linkedPolynomialMutationDistributionIndex "--linkedPolynomialMutationDistributionIndex " r       (5.0, 400.0)                   | mutation %in% c("linkedPolynomial")
uniformMutationPerturbation              "--uniformMutationPerturbation "         r       (0.0, 1.0)                     | mutation %in% c("uniform")
nonUniformMutationPerturbation           "--nonUniformMutationPerturbation "      r       (0.0, 1.0)                     | mutation %in% c("nonUniform")
#
selection                                "--selection "                           c       (tournament, random)                               
selectionTournamentSize                  "--selectionTournamentSize "             i       (2, 10)                        | selection %in% c("tournament")

The third column of the list is a character indicating the parameter type: c (cardinal), i (integer), and r (real). The last column indicates explicit parameter relationships (e.g., sbxDistributionIndex depends of whether the SBX crossover is selected). There are implicit relationships that are not annotated in the configuration file; for example, crossoverProbability is associated to any crossover. There is no need to include a relationship in this case because the crossover is always used, but it could be necessary to specify it if the crossover is used as an optional parameter.

From this parameter space, the AutoNSGAII algorithm can be configured and executed in this way:

    String[] parameters =
        ("--problemName org.uma.jmetal.problem.multiobjective.zdt.ZDT1 "
            + "--randomGeneratorSeed 12 "
            + "--referenceFrontFileName "+ referenceFrontFileName + " "
                + "--maximumNumberOfEvaluations 25000 "
                + "--algorithmResult population "
                + "--populationSize 100 "
                + "--offspringPopulationSize 100 "
                + "--createInitialSolutions random "
                + "--variation crossoverAndMutationVariation "
                + "--selection tournament "
                + "--selectionTournamentSize 2 "
                + "--rankingForSelection dominanceRanking "
                + "--densityEstimatorForSelection crowdingDistance "
                + "--crossover SBX "
                + "--crossoverProbability 0.9 "
                + "--crossoverRepairStrategy bounds "
                + "--sbxDistributionIndex 20.0 "
                + "--mutation polynomial "
                + "--mutationProbabilityFactor 1.0 "
                + "--mutationRepairStrategy bounds "
                + "--polynomialMutationDistributionIndex 20.0 ")
            .split("\\s+");

    AutoNSGAII autoNSGAII = new AutoNSGAII();
    autoNSGAII.parseAndCheckParameters(parameters);

    EvolutionaryAlgorithm<DoubleSolution> nsgaII = autoNSGAII.create();

    nsgaII.run();

With this context in mind, we need to:

  • Define a way to represent the space parameter. A choice would be to parse the irace configuration file, but using for example a JSON file seems more easy to deal with.
  • Any valid configuration (that is, a list of parameters and their values) must be encoded into a list of double values to include them into a DoubleSolution in jMetal. Conversely, given a DoubleSolution'', it must be decoded into a parameter string to configure and run AutoNSGAII``.

Implement a `ConfigurableAlgorithmProblem`

Define a ConfigurableAlgorithmProblem class that will implement the problem of configurate an algorithm.
It will receive as parameters the algorithm to be optimized, the search space dimensions (parameters of the algorithm), and the objectives (quality indicators) to be optimized.

The solution space is composed by valid configurations (i.e, a parameter list with values) and the objective spaces is defined the selected quality indicators.

The ConfigurableAlgorithmProblem will be a continuous problem to allow to use most of the algorithms included in jMetal. We must cope with parameter that will not be continuous; some of them can be integer and others can be categorical. The approach to be adopted to convert them as continuous parameters can be the same applied in ML algorithms.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.