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;