diff --git a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticMain.java b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticMain.java index 464ea2ec32f2fded6df13324efcbd864ed406d2e..705bc1077792ea7d65b859fe88b8c5b2dd936d70 100644 --- a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticMain.java +++ b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticMain.java @@ -7,6 +7,8 @@ import de.tudresden.inf.st.mquat.jastadd.model.Root; import de.tudresden.inf.st.mquat.solving.BenchmarkableSolver; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; +import org.apache.logging.log4j.core.net.ssl.SslConfiguration; + import de.tudresden.inf.st.mquat.jastadd.model.Solution; import de.tudresden.inf.st.mquat.solving.SolvingException; @@ -58,32 +60,72 @@ public class GeneticMain { long timeoutValue = 20; //from scenarios.json String timeoutUnit = "SECONDS"; //from scenarios.json, possible values - "SECONDS", "MINUTES" - + // + double treeCrossoverOperatorMin = 0.0d; + double treeCrossoverOperatorMax = 1.0d; + double treeCrossoverOperatorProbability = 0.5; + double treeMutateOperatorMin = 0.0d; + double treeMutateOperatorMax = 1.0d; + double treeMutateOperatorP = 0.9; + double treeMutateOperatorP1 = 3.0; + double treeMutateOperatorP2 = 0.7; + double treeMutateOperatorP3 = 0.4; + double opt4jEvaluatorK1 = 0.5; + double opt4jEvaluatorK2 = 0.5; + // + /// + int lambda = 25; + double crossoverRate= 0.95; + int mu = 25; + int tournament = 0; + /// int generations = 200000; int populationSize = 1000; + if (args.length == 2) { logger.debug("============ Args: " + args[0] + " and " + args[1]); generations = Integer.parseInt(args[0]); populationSize = Integer.parseInt(args[1]); logger.debug("============ generations = " + generations + ", populationSize = " + populationSize); - } else if (args.length == 15){ + } else if (args.length == 30){ logger.debug("============ Args: " + String.join("and",args)); - generations = Integer.parseInt(args[0]); - populationSize = Integer.parseInt(args[1]); - numTopLevelComponents = Integer.parseInt(args[2]); - avgNumImplSubComponents = Integer.parseInt(args[3]); - implSubComponentStdDerivation = Integer.parseInt(args[4]); - avgNumCompSubComponents = Integer.parseInt(args[5]); - compSubComponentStdDerivation = Integer.parseInt(args[6]); - componentDepth = Integer.parseInt(args[7]); - numImplementations = Integer.parseInt(args[8]); - excessComputeResourceRatio = Double.parseDouble(args[9]); - numRequests = Integer.parseInt(args[10]); - numCpus = Integer.parseInt(args[11]); - seed = Integer.parseInt(args[12]); - timeoutValue = Integer.parseInt(args[13]); - timeoutUnit = args[14]; + numTopLevelComponents = Integer.parseInt(args[0]); + avgNumImplSubComponents = Integer.parseInt(args[1]); + implSubComponentStdDerivation = Integer.parseInt(args[2]); + avgNumCompSubComponents = Integer.parseInt(args[3]); + compSubComponentStdDerivation = Integer.parseInt(args[4]); + componentDepth = Integer.parseInt(args[5]); + numImplementations = Integer.parseInt(args[6]); + excessComputeResourceRatio = Double.parseDouble(args[7]); + numRequests = Integer.parseInt(args[8]); + numCpus = Integer.parseInt(args[9]); + seed = Integer.parseInt(args[10]); + timeoutValue = Integer.parseInt(args[11]); + timeoutUnit = args[12]; + + generations = Integer.parseInt(args[13]); + populationSize = Integer.parseInt(args[14]); + // + treeCrossoverOperatorMin = Double.parseDouble(args[15]); + treeCrossoverOperatorMax = Double.parseDouble(args[16]); + treeCrossoverOperatorProbability = Double.parseDouble(args[17]); + treeMutateOperatorMin = Double.parseDouble(args[18]); + treeMutateOperatorMax = Double.parseDouble(args[19]); + treeMutateOperatorP = Double.parseDouble(args[20]); + treeMutateOperatorP1 = Double.parseDouble(args[21]); + treeMutateOperatorP2 = Double.parseDouble(args[22]); + treeMutateOperatorP3 = Double.parseDouble(args[23]); + opt4jEvaluatorK1 = Double.parseDouble(args[24]); + opt4jEvaluatorK2 = Double.parseDouble(args[25]); + // + /// + lambda = Integer.parseInt(args[26]); + crossoverRate = Double.parseDouble(args[27]); + mu = Integer.parseInt(args[28]); + tournament = Integer.parseInt(args[29]); + /// + logger.debug( String.format("============ generations = %d populationSize = %d numTopLevelComponents = %d" + " avgNumImplSubComponents = %d implSubComponentStdDerivation = %d avgNumCompSubComponents = %d compSubComponentStdDerivation = %d componentDepth = %d" + " numImplementations = %d excessComputeResourceRatio = %f numRequests = %d numCpus = %d seed = %d timeoutValue = %d timeoutUnit = %s", @@ -104,6 +146,25 @@ public class GeneticMain { BenchmarkableSolver solver = new GeneticSolver(GeneticSolver.SelectorType.NSGA2, generations, populationSize); solver.setTimeout(timeoutValue, TimeUnit.valueOf(timeoutUnit)); + // + ((GeneticSolver) solver).setTreeCrossoverOperatorMin(treeCrossoverOperatorMin); + ((GeneticSolver) solver).setTreeCrossoverOperatorMax(treeCrossoverOperatorMax); + ((GeneticSolver) solver).setTreeCrossoverOperatorProbability(treeCrossoverOperatorProbability); + ((GeneticSolver) solver).setTreeMutateOperatorMin(treeMutateOperatorMin); + ((GeneticSolver) solver).setTreeMutateOperatorMax(treeMutateOperatorMax); + ((GeneticSolver) solver).setTreeMutateOperatorP(treeMutateOperatorP); + ((GeneticSolver) solver).setTreeMutateOperatorP1(treeMutateOperatorP1); + ((GeneticSolver) solver).setTreeMutateOperatorP2(treeMutateOperatorP2); + ((GeneticSolver) solver).setTreeMutateOperatorP3(treeMutateOperatorP3); + ((GeneticSolver) solver).setOpt4jEvaluatorK1(opt4jEvaluatorK1); + ((GeneticSolver) solver).setOpt4jEvaluatorK2(opt4jEvaluatorK2); + // + /// + ((GeneticSolver) solver).setLambda(lambda); + ((GeneticSolver) solver).setCrossoverRate(crossoverRate); + ((GeneticSolver) solver).setMu(mu); + ((GeneticSolver) solver).setTournament(tournament); + /// Path path_for_results = Paths.get("results/scenarios"); createDirIfNecessary(path_for_results); Path results_file = Paths.get(path_for_results.toString() + "/" + scenario_name + ".csv"); diff --git a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticSolver.java b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticSolver.java index 8ecb48e0556a17968956cc04ee8c738984927b3d..91164165e25bed8457612c02485e8f07d01bc293 100644 --- a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticSolver.java +++ b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/GeneticSolver.java @@ -46,18 +46,22 @@ public class GeneticSolver implements BenchmarkableSolver { private double treeCrossoverOperatorMin; private double treeCrossoverOperatorMax; private double treeCrossoverOperatorProbability; - private double treeMutateOperatorMin; private double treeMutateOperatorMax; private double treeMutateOperatorP; private double treeMutateOperatorP1; private double treeMutateOperatorP2; private double treeMutateOperatorP3; - private double opt4jEvaluatorK1; private double opt4jEvaluatorK2; // + /// + private int lambda; + private double crossoverRate; + private int mu; + private int tournament; + /// public GeneticSolver() { this(SelectorType.NSGA2, 100, 100); } @@ -87,12 +91,12 @@ public class GeneticSolver implements BenchmarkableSolver { EvolutionaryAlgorithmModule ea = new EvolutionaryAlgorithmModule(); ea.setGenerations(this.generations); //The number of generations. ea.setAlpha(this.populationSize); //The size of the population.4 - // + ea.setLambda(lambda); //The number of offspring per generation. //Dep inj no ea.setCrossoverRate(crossoverRate); //Performs a crossover operation with this given rate. //Dep inj no ea.setCrossoverRateType(CrossoverRateType.CONSTANT); // no more variants //Dep inj no ea.setMu(mu); //The number of parents per generation. //Dep inj no - // + Opt4jModule mquatModule = new Opt4jModule(); @@ -198,4 +202,54 @@ public class GeneticSolver implements BenchmarkableSolver { NSGA2, SPEA2 } + + // + public void setTreeCrossoverOperatorMin(double treeCrossoverOperatorMin) { + this.treeCrossoverOperatorMin = treeCrossoverOperatorMin; + } + public void setTreeCrossoverOperatorMax(double treeCrossoverOperatorMax) { + this.treeCrossoverOperatorMax = treeCrossoverOperatorMax; + } + public void setTreeCrossoverOperatorProbability(double treeCrossoverOperatorProbability) { + this.treeCrossoverOperatorProbability = treeCrossoverOperatorProbability; + } + public void setTreeMutateOperatorMin(double treeMutateOperatorMin) { + this.treeMutateOperatorMin = treeMutateOperatorMin; + } + public void setTreeMutateOperatorMax(double treeMutateOperatorMax) { + this.treeMutateOperatorMax = treeMutateOperatorMax; + } + public void setTreeMutateOperatorP(double treeMutateOperatorP) { + this.treeMutateOperatorP = treeMutateOperatorP; + } + public void setTreeMutateOperatorP1(double treeMutateOperatorP1) { + this.treeMutateOperatorP1 = treeMutateOperatorP1; + } + public void setTreeMutateOperatorP2(double treeMutateOperatorP2) { + this.treeMutateOperatorP2 = treeMutateOperatorP2; + } + public void setTreeMutateOperatorP3(double treeMutateOperatorP3) { + this.treeMutateOperatorP3 = treeMutateOperatorP3; + } + public void setOpt4jEvaluatorK1(double opt4jEvaluatorK1) { + this.opt4jEvaluatorK1 = opt4jEvaluatorK1; + } + public void setOpt4jEvaluatorK2(double opt4jEvaluatorK2) { + this.opt4jEvaluatorK2 = opt4jEvaluatorK2; + } + // + /// + public void setLambda(int lambda) { + this.lambda = lambda; + } + public void setCrossoverRate(double crossoverRate) { + this.crossoverRate = crossoverRate; + } + public void setMu(int mu) { + this.mu = mu; + } + public void setTournament(int tournament) { + this.tournament = tournament; + } + /// } diff --git a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/Opt4jEvaluator.java b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/Opt4jEvaluator.java index 062c7dc3e49190bc1826b091f13ee58ccd0294d6..f767e99cc1fe27e2b2e9f8cb2d32c8a639ca897b 100644 --- a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/Opt4jEvaluator.java +++ b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/Opt4jEvaluator.java @@ -8,6 +8,8 @@ import org.opt4j.core.Objective.Sign; import org.opt4j.core.Objectives; import org.opt4j.core.problem.Evaluator; +import com.google.inject.Inject; + public class Opt4jEvaluator implements Evaluator<Solution> { // diff --git a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/crossover/TreeCrossoverOperator.java b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/crossover/TreeCrossoverOperator.java index 3f028bf537f82bb3f7cb86366e10ed98b84e2bb4..54603107fec456ae2951d2240288992851cb83e8 100644 --- a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/crossover/TreeCrossoverOperator.java +++ b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/crossover/TreeCrossoverOperator.java @@ -22,9 +22,9 @@ import java.util.Random; public class TreeCrossoverOperator implements Crossover<TreeGenotype<Request, Instance, Resource, Implementation>> { private final Random random; - private final double Min = 0.0d; //Dep inj TreeCrossoverOperatorMin - private final double Max = 1.0d; //Dep inj TreeCrossoverOperatorMax - private final double probability = 0.5; //Dep inj TreeCrossoverOperatorProbability + private double Min = 0.0d; //Dep inj TreeCrossoverOperatorMin + private double Max = 1.0d; //Dep inj TreeCrossoverOperatorMax + private double probability = 0.5; //Dep inj TreeCrossoverOperatorProbability @Inject public TreeCrossoverOperator(Rand random, @TreeCrossoverOperatorMin double treeCrossoverOperatorMin, @TreeCrossoverOperatorMax double treeCrossoverOperatorMax, @TreeCrossoverOperatorProbability double treeCrossoverOperatorProbability) { diff --git a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/mutate/TreeMutateOperator.java b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/mutate/TreeMutateOperator.java index 9da0c2446faff2b75dc91e8a44ff1d38c89c2687..15a052d17e7fffd24f853da50a5d127903674698 100644 --- a/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/mutate/TreeMutateOperator.java +++ b/jastadd-mquat-solver-genetic/src/main/java/de/tudresden/inf/st/mquat/solving/genetic/opt4j/custom/operator/mutate/TreeMutateOperator.java @@ -23,8 +23,8 @@ import java.util.Random; public class TreeMutateOperator implements Mutate<TreeGenotype<Request, Instance, Resource, Implementation>> { private final Random random; - private final double Min = 0.0d; //Dep inj TreeMutateOperatorMin - private final double Max = 1.0d; //Dep inj TreeMutateOperatorMax + private double Min = 0.0d; //Dep inj TreeMutateOperatorMin + private double Max = 1.0d; //Dep inj TreeMutateOperatorMax // private double treeMutateOperatorP;