From ca30e6c705a6d37ee4094b81e41b2b4dc6a08fdf Mon Sep 17 00:00:00 2001 From: Fabian Becker Date: Thu, 23 Oct 2014 17:51:13 +0200 Subject: [PATCH] Start of implementation for AdaptiveDE --- .../AdaptiveDifferentialEvolution.java | 190 ++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 src/eva2/optimization/strategies/AdaptiveDifferentialEvolution.java diff --git a/src/eva2/optimization/strategies/AdaptiveDifferentialEvolution.java b/src/eva2/optimization/strategies/AdaptiveDifferentialEvolution.java new file mode 100644 index 00000000..77b3e5ce --- /dev/null +++ b/src/eva2/optimization/strategies/AdaptiveDifferentialEvolution.java @@ -0,0 +1,190 @@ +package eva2.optimization.strategies; + +import eva2.optimization.go.InterfacePopulationChangedEventListener; +import eva2.optimization.individuals.AbstractEAIndividual; +import eva2.optimization.operator.selection.replacement.ReplacementNondominatedSortingDistanceCrowding; +import eva2.optimization.population.InterfaceSolutionSet; +import eva2.optimization.population.Population; +import eva2.problems.AbstractMultiObjectiveOptimizationProblem; +import eva2.problems.AbstractOptimizationProblem; +import eva2.problems.F1Problem; +import eva2.problems.InterfaceOptimizationProblem; +import eva2.tools.math.RNG; +import eva2.util.annotation.Description; +import eva2.util.annotation.Parameter; + +import java.util.ArrayList; + +/** + * This is an implementation of Differential Evolution with two-level parameter adaption published by + * Yu, Shen, Chen, et.al. in 2014 (IEEE Transaction on Cybernetics, DOI: 10.1109/TCYB.2013.2279211). + */ +@Description("Differential Evolution with Two-Level Parameter Adaption (Yu, Shen, Chen, et.al., 2014") +public class AdaptiveDifferentialEvolution implements InterfaceOptimizer { + protected Population population; + + @Parameter(name = "groups", description = "Number of sub-groups to use during optimization.") + protected int nonOverlappingGroups = 5; + + @Parameter(name = "F", description = "Differential Weight") + protected double differentialWeight = 0.8; + + @Parameter(name = "CR", description = "Crossover Rate") + protected double crossoverRate = 0.6; + + + protected transient Population children = null; + protected AbstractOptimizationProblem optimizationProblem = new F1Problem(); + + private ArrayList populationChangedEventListeners; + + public Object clone() { + return this; + } + + @Override + public String getName() { + return "Adaptive Differential Evolution"; + } + + @Override + public void addPopulationChangedEventListener(InterfacePopulationChangedEventListener ea) { + if (populationChangedEventListeners == null) { + populationChangedEventListeners = new ArrayList<>(); + } + populationChangedEventListeners.add(ea); + } + + @Override + public boolean removePopulationChangedEventListener(InterfacePopulationChangedEventListener ea) { + return populationChangedEventListeners != null && populationChangedEventListeners.remove(ea); + } + + @Override + public void initialize() { + + } + + /** + * This method will initialize the optimizer with a given population + * + * @param pop The initial population + * @param reset If true the population is reset. + */ + @Override + public void initializeByPopulation(Population pop, boolean reset) { + this.population = (Population) pop.clone(); + if (reset) { + this.population.init(); + this.evaluatePopulation(this.population); + this.firePropertyChangedEvent(Population.NEXT_GENERATION_PERFORMED); + } + } + + /** + * This method will evaluate the current population using the given problem. + * + * @param population The population that is to be evaluated + */ + private void evaluatePopulation(Population population) { + this.optimizationProblem.evaluate(population); + population.incrGeneration(); + } + + public AbstractEAIndividual generateNewIndividual(Population population, int index) { + return null; + } + + @Override + public void optimize() { + AbstractEAIndividual indy, orig; + + /** + * Initialize the child Population or clear it + */ + if (children == null) { + children = new Population(population.size()); + } else { + children.clear(); + } + + /** + * Cycle through the whole population and generate a new individual + */ + for (int i = 0; i < this.population.size(); i++) { + indy = generateNewIndividual(population, i); + children.add(indy); + } + + children.setGeneration(population.getGeneration()); + optimizationProblem.evaluate(children); + + + for (int i = 0; i < this.population.size(); i++) { + /** + * Compare each individual in the child population with the corresponding + * one from the parent population. + */ + indy = (AbstractEAIndividual) this.children.get(i); + orig = (AbstractEAIndividual) this.population.get(i); + if (indy.isDominatingDebConstraints(orig)) { + this.population.replaceIndividualAt(i, indy); + } + } + + // Estimate the optimization state + + // + + this.population.incrGeneration(); + this.firePropertyChangedEvent(Population.NEXT_GENERATION_PERFORMED); + } + + /** + * Something has changed + * + * @param name Event name + */ + protected void firePropertyChangedEvent(String name) { + if (this.populationChangedEventListeners != null) { + for (InterfacePopulationChangedEventListener listener : this.populationChangedEventListeners) { + listener.registerPopulationStateChanged(this, name); + } + } + } + + @Override + public Population getPopulation() { + return population; + } + + @Override + public void setPopulation(Population pop) { + this.population = pop; + } + + @Override + public InterfaceSolutionSet getAllSolutions() { + return null; + } + + /** + * Sets the optimization problem. Will cast to AbstractOptimizationProblem. + * + * @param problem The optimization problem. + */ + @Override + public void setProblem(InterfaceOptimizationProblem problem) { + this.optimizationProblem = (AbstractOptimizationProblem) problem; + } + + @Override + public InterfaceOptimizationProblem getProblem() { + return this.optimizationProblem; + } + + @Override + public String getStringRepresentation() { + return null; + } +}