public static void main(String[] args) throws JMException, ClassNotFoundException {
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator crossover; // Crossover operator
Operator mutation; // Mutation operator
Operator selection; // Selection operator
// int bits ; // Length of bit string in the OneMax problem
HashMap parameters; // Operator parameters
int threads = 4; // 0 - use all the available cores
IParallelEvaluator parallelEvaluator = new MultithreadedEvaluator(threads);
// problem = new Sphere("Real", 10) ;
problem = new Griewank("Real", 10);
algorithm = new pgGA(problem, parallelEvaluator); // Generational GA
/* Algorithm parameters*/
algorithm.setInputParameter("populationSize", 100);
algorithm.setInputParameter("maxEvaluations", 2500000);
// Mutation and Crossover for Real codification
parameters = new HashMap();
parameters.put("probability", 0.9);
parameters.put("distributionIndex", 20.0);
crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover", parameters);
parameters = new HashMap();
parameters.put("probability", 1.0 / problem.getNumberOfVariables());
parameters.put("distributionIndex", 20.0);
mutation = MutationFactory.getMutationOperator("PolynomialMutation", parameters);
/* Selection Operator */
parameters = null;
selection = SelectionFactory.getSelectionOperator("BinaryTournament", parameters);
/* Add the operators to the algorithm*/
algorithm.addOperator("crossover", crossover);
algorithm.addOperator("mutation", mutation);
algorithm.addOperator("selection", selection);
/* Execute the Algorithm */
long initTime = System.currentTimeMillis();
SolutionSet population = algorithm.execute();
long estimatedTime = System.currentTimeMillis() - initTime;
System.out.println("Total execution time: " + estimatedTime);
/* Log messages */
System.out.println("Objectives values have been writen to file FUN");
population.printObjectivesToFile("FUN");
System.out.println("Variables values have been writen to file VAR");
population.printVariablesToFile("VAR");
} // main
/**
* Configure the MOCell algorithm with default parameter settings
*
* @return an algorithm object
* @throws jmetal.util.JMException
*/
public Algorithm configure() throws JMException {
Algorithm algorithm;
Operator crossover;
Operator mutation;
Operator improvement; // Operator for improvement
HashMap parameters; // Operator parameters
QualityIndicator indicators;
// Creating the problem
algorithm = new AbYSS(problem_);
// Algorithm parameters
algorithm.setInputParameter("populationSize", populationSize_);
algorithm.setInputParameter("refSet1Size", refSet1Size_);
algorithm.setInputParameter("refSet2Size", refSet2Size_);
algorithm.setInputParameter("archiveSize", archiveSize_);
algorithm.setInputParameter("maxEvaluations", maxEvaluations_);
parameters = new HashMap();
parameters.put("probability", crossoverProbability_);
parameters.put("distributionIndex", crossoverDistributionIndex_);
crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover", parameters);
parameters = new HashMap();
parameters.put("probability", mutationProbability_);
parameters.put("distributionIndex", mutationDistributionIndex_);
mutation = MutationFactory.getMutationOperator("PolynomialMutation", parameters);
parameters = new HashMap();
parameters.put("improvementRounds", 1);
parameters.put("problem", problem_);
parameters.put("mutation", mutation);
improvement = new MutationLocalSearch(parameters);
// Adding the operators to the algorithm
algorithm.addOperator("crossover", crossover);
algorithm.addOperator("improvement", improvement);
/* Deleted since jMetal 4.2
// Creating the indicator object
if ((paretoFrontFile_!=null) && (!paretoFrontFile_.equals(""))) {
indicators = new QualityIndicator(problem_, paretoFrontFile_);
algorithm.setInputParameter("indicators", indicators) ;
} // if
*/
return algorithm;
} // Constructor
/**
* Configure SPEA2 with default parameter settings
*
* @return an algorithm object
* @throws jmetal.util.JMException
*/
public Algorithm configure() throws JMException {
Algorithm algorithm;
Operator crossover; // Crossover operator
Operator mutation; // Mutation operator
Operator selection; // Selection operator
QualityIndicator indicators;
HashMap parameters; // Operator parameters
// Creating the problem
algorithm = new SPEA2(problem_);
// Algorithm parameters
algorithm.setInputParameter("populationSize", populationSize_);
algorithm.setInputParameter("archiveSize", archiveSize_);
algorithm.setInputParameter("maxEvaluations", maxEvaluations_);
// Mutation and Crossover for Real codification
parameters = new HashMap();
parameters.put("probability", crossoverProbability_);
parameters.put("distributionIndex", crossoverDistributionIndex_);
crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover", parameters);
parameters = new HashMap();
parameters.put("probability", mutationProbability_);
parameters.put("distributionIndex", mutationDistributionIndex_);
mutation = MutationFactory.getMutationOperator("PolynomialMutation", parameters);
// Selection operator
parameters = null;
selection = SelectionFactory.getSelectionOperator("BinaryTournament", parameters);
// Add the operators to the algorithm
algorithm.addOperator("crossover", crossover);
algorithm.addOperator("mutation", mutation);
algorithm.addOperator("selection", selection);
/* Deleted since jMetal 4.2
// Creating the indicator object
if ((paretoFrontFile_!=null) && (!paretoFrontFile_.equals(""))) {
indicators = new QualityIndicator(problem_, paretoFrontFile_);
algorithm.setInputParameter("indicators", indicators) ;
} // if
*/
return algorithm;
} // configure
/**
* Configure the MOCell algorithm with default parameter experiments.settings
*
* @return an algorithm object
* @throws jmetal.util.JMException
*/
public Algorithm configure() throws JMException {
Algorithm algorithm;
Crossover crossover;
Mutation mutation;
Operator selection;
HashMap parameters; // Operator parameters
// Selecting the algorithm: there are six MOCell variants
Object[] problemParams = {"Real"};
problem_ = (new ProblemFactory()).getProblem(problemName_, problemParams);
// algorithm = new sMOCell1(problem_) ;
// algorithm = new sMOCell2(problem_) ;
// algorithm = new aMOCell1(problem_) ;
// algorithm = new aMOCell2(problem_) ;
// algorithm = new aMOCell3(problem_) ;
algorithm = new MOCell(problem_);
// Algorithm parameters
algorithm.setInputParameter("populationSize", populationSize_);
algorithm.setInputParameter("maxEvaluations", maxEvaluations_);
algorithm.setInputParameter("archiveSize", archiveSize_);
algorithm.setInputParameter("feedBack", feedback_);
// Mutation and Crossover for Real codification
parameters = new HashMap();
parameters.put("probability", crossoverProbability_);
parameters.put("distributionIndex", crossoverDistributionIndex_);
crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover", parameters);
parameters = new HashMap();
parameters.put("probability", mutationProbability_);
parameters.put("distributionIndex", mutationDistributionIndex_);
mutation = MutationFactory.getMutationOperator("PolynomialMutation", parameters);
// Selection Operator
parameters = null;
selection = SelectionFactory.getSelectionOperator("BinaryTournament", parameters);
// Add the operators to the algorithm
algorithm.addOperator("crossover", crossover);
algorithm.addOperator("mutation", mutation);
algorithm.addOperator("selection", selection);
return algorithm;
} // configure
/**
* @param args Command line arguments. The first (optional) argument specifies the problem to
* solve.
* @throws JMException
*/
public static void main(String[] args) throws JMException, IOException, ClassNotFoundException {
Problem problem; // The problem to solve
Algorithm algorithm; // The algorithm to use
Operator crossover; // Crossover operator
Operator mutation; // Mutation operator
Operator selection; // Selection operator
QualityIndicator indicators; // Object to get quality indicators
HashMap parameters; // Operator parameters
// Logger object and file to store log messages
logger_ = Configuration.logger_;
fileHandler_ = new FileHandler("FastPGA_main.log");
logger_.addHandler(fileHandler_);
indicators = null;
if (args.length == 1) {
Object[] params = {"Real"};
problem = (new ProblemFactory()).getProblem(args[0], params);
} // if
else if (args.length == 2) {
Object[] params = {"Real"};
problem = (new ProblemFactory()).getProblem(args[0], params);
indicators = new QualityIndicator(problem, args[1]);
} // if
else { // Default problem
problem = new Kursawe("Real", 3);
// problem = new Kursawe("BinaryReal", 3);
// problem = new Water("Real");
// problem = new ZDT1("ArrayReal", 100);
// problem = new ConstrEx("Real");
// problem = new DTLZ1("Real");
// problem = new OKA2("Real") ;
} // else
algorithm = new FastPGA(problem);
algorithm.setInputParameter("maxPopSize", 100);
algorithm.setInputParameter("initialPopulationSize", 100);
algorithm.setInputParameter("maxEvaluations", 25000);
algorithm.setInputParameter("a", 20.0);
algorithm.setInputParameter("b", 1.0);
algorithm.setInputParameter("c", 20.0);
algorithm.setInputParameter("d", 0.0);
// Parameter "termination"
// If the preferred stopping criterium is PPR based, termination must
// be set to 0; otherwise, if the algorithm is intended to iterate until
// a give number of evaluations is carried out, termination must be set to
// that number
algorithm.setInputParameter("termination", 1);
// Mutation and Crossover for Real codification
parameters = new HashMap();
parameters.put("probability", 0.9);
parameters.put("distributionIndex", 20.0);
crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover", parameters);
// crossover.setParameter("probability",0.9);
// crossover.setParameter("distributionIndex",20.0);
parameters = new HashMap();
parameters.put("probability", 1.0 / problem.getNumberOfVariables());
parameters.put("distributionIndex", 20.0);
mutation = MutationFactory.getMutationOperator("PolynomialMutation", parameters);
// Mutation and Crossover for Binary codification
parameters = new HashMap();
parameters.put("comparator", new FPGAFitnessComparator());
selection = new BinaryTournament(parameters);
algorithm.addOperator("crossover", crossover);
algorithm.addOperator("mutation", mutation);
algorithm.addOperator("selection", selection);
long initTime = System.currentTimeMillis();
SolutionSet population = algorithm.execute();
long estimatedTime = System.currentTimeMillis() - initTime;
// Result messages
logger_.info("Total execution time: " + estimatedTime + "ms");
logger_.info("Variables values have been writen to file VAR");
population.printVariablesToFile("VAR");
logger_.info("Objectives values have been writen to file FUN");
population.printObjectivesToFile("FUN");
if (indicators != null) {
logger_.info("Quality indicators");
logger_.info("Hypervolume: " + indicators.getHypervolume(population));
logger_.info("GD : " + indicators.getGD(population));
logger_.info("IGD : " + indicators.getIGD(population));
logger_.info("Spread : " + indicators.getSpread(population));
logger_.info("Epsilon : " + indicators.getEpsilon(population));
int evaluations = ((Integer) algorithm.getOutputParameter("evaluations")).intValue();
logger_.info("Speed : " + evaluations + " evaluations");
} // if
} // main
public SPEA2Search(Builder builder) throws JMException {
super(builder);
this.populationSize = builder.populationSize;
this.maxEvaluations = builder.maxEvaluations;
this.archiveSize = builder.archiveSize;
this.crossoverOperatorName = builder.crossoverOperatorName;
this.crossoverProbability = builder.crossoverProbability;
this.mutationOperatorName = builder.mutationOperatorName;
if (builder.mutationProbability != 0) this.mutationProbability = builder.mutationProbability;
this.selectionOperatorName = builder.selectionOperatorName;
this.problem = new SeaCloudsProblem(this.appMap, this.suitableCloudOfferMap, this.topology);
this.algorithm = new SPEA2(this.problem);
this.metaHeuristicName = this.getAlgorithm().getClass().getSimpleName();
// Algorithm parameters
this.algorithm.setInputParameter("populationSize", this.populationSize);
this.algorithm.setInputParameter("maxEvaluations", this.maxEvaluations);
this.algorithm.setInputParameter("archiveSize", this.archiveSize);
// Crossover Operator
this.parameters = new HashMap();
this.parameters.put("probability", this.crossoverProbability);
// this.crossover = CrossoverFactory.getCrossoverOperator(
// "MultiPointCrossover", this.parameters);
this.crossover =
CrossoverFactory.getCrossoverOperator(
this.crossoverOperatorName.getCrossoverOperatorValue(), this.parameters);
this.parameters.clear();
// Mutation Operator
this.parameters.put("probability", this.mutationProbability);
// this.mutation = MutationFactory.getMutationOperator(
// "PACandNumOfInstancesMutation", this.parameters);
this.mutation =
MutationFactory.getMutationOperator(
this.mutationOperatorName.getMutationOperatorValue(), this.parameters);
this.parameters.clear();
// Selection Operator
// this.selection =
// SelectionFactory.getSelectionOperator("BinaryTournament",
// this.parameters);
if ((builder
.selectionOperatorName
.getSelectionOperatorValue()
.equals(SelectionOperatorName.BEST_SOLUTION.getSelectionOperatorValue()))
|| (builder
.selectionOperatorName
.getSelectionOperatorValue()
.equals(SelectionOperatorName.WORST_SOLUTION.getSelectionOperatorValue()))) {
// Comparator comparator = new DominanceComparator();
Comparator comparator = new EqualSolutions();
this.parameters.put("comparator", comparator);
}
this.selection =
SelectionFactory.getSelectionOperator(
this.selectionOperatorName.getSelectionOperatorValue(), this.parameters);
// Add the operators to the algorithm
this.algorithm.addOperator("crossover", this.crossover);
this.algorithm.addOperator("mutation", this.mutation);
this.algorithm.addOperator("selection", this.selection);
}
