/**
* Assigns crowding distances to all solutions in a <code>SolutionSet</code>.
*
* @param solutionSet The <code>SolutionSet</code>.
* @param nObjs Number of objectives.
*/
public void crowdingDistanceAssignment(SolutionSet solutionSet, int nObjs) {
int size = solutionSet.size();
if (size == 0) return;
if (size == 1) {
solutionSet.get(0).setCrowdingDistance(Double.POSITIVE_INFINITY);
return;
} // if
if (size == 2) {
solutionSet.get(0).setCrowdingDistance(Double.POSITIVE_INFINITY);
solutionSet.get(1).setCrowdingDistance(Double.POSITIVE_INFINITY);
return;
} // if
// Use a new SolutionSet to evite alter original solutionSet
SolutionSet front = new SolutionSet(size);
for (int i = 0; i < size; i++) {
front.add(solutionSet.get(i));
}
for (int i = 0; i < size; i++) front.get(i).setCrowdingDistance(0.0);
double objetiveMaxn;
double objetiveMinn;
double distance;
for (int i = 0; i < nObjs; i++) {
// Sort the population by Obj n
front.sort(new ObjectiveComparator(i));
objetiveMinn = front.get(0).getObjective(i);
objetiveMaxn = front.get(front.size() - 1).getObjective(i);
// Set de crowding distance
front.get(0).setCrowdingDistance(Double.POSITIVE_INFINITY);
front.get(size - 1).setCrowdingDistance(Double.POSITIVE_INFINITY);
for (int j = 1; j < size - 1; j++) {
distance = front.get(j + 1).getObjective(i) - front.get(j - 1).getObjective(i);
distance = distance / (objetiveMaxn - objetiveMinn);
distance += front.get(j).getCrowdingDistance();
front.get(j).setCrowdingDistance(distance);
} // for
} // for
} // crowdingDistanceAssing
/**
* Execute the ElitistES algorithm
* @throws JMException
*/
public SolutionSet execute() throws JMException, ClassNotFoundException {
int maxEvaluations ;
int evaluations ;
SolutionSet population ;
SolutionSet offspringPopulation ;
Operator mutationOperator ;
Comparator comparator ;
comparator = new ObjectiveComparator(0) ; // Single objective comparator
// Read the params
maxEvaluations = ((Integer)this.getInputParameter("maxEvaluations")).intValue();
// Initialize the variables
population = new SolutionSet(mu_) ;
offspringPopulation = new SolutionSet(mu_ + lambda_) ;
evaluations = 0;
// Read the operators
mutationOperator = this.operators_.get("mutation");
System.out.println("(" + mu_ + " + " + lambda_+")ES") ;
// Create the parent population of mu solutions
Solution newIndividual;
for (int i = 0; i < mu_; i++) {
newIndividual = new Solution(problem_);
evaluations++;
population.add(newIndividual);
} //for
finish {
//
async {
for (int i = 0; i < mu_; i++) {
evaluate_internal(population, i, null);
}
}
}
// Main loop
int offsprings ;
offsprings = lambda_ / mu_ ;
while (evaluations < maxEvaluations) {
// STEP 1. Generate the mu+lambda population
for (int i = 0; i < mu_; i++) {
for (int j = 0; j < offsprings; j++) {
Solution offspring = new Solution(population.get(i)) ;
offspringPopulation.add(offspring) ;
evaluations ++ ;
} // for
} // for
finish {
//
async {
for (int i = 0; i < mu_*offsprings; i++) {
evaluate_internal(offspringPopulation, i, mutationOperator);
}
}
}
// STEP 2. Add the mu individuals to the offspring population
for (int i = 0 ; i < mu_; i++) {
offspringPopulation.add(population.get(i)) ;
} // for
population.clear() ;
// STEP 3. Sort the mu+lambda population
offspringPopulation.sort(comparator) ;
// STEP 4. Create the new mu population
for (int i = 0; i < mu_; i++)
population.add(offspringPopulation.get(i)) ;
System.out.println("Evaluation: " + evaluations + " Fitness: " +
population.get(0).getObjective(0)) ;
// STEP 6. Delete the mu+lambda population
offspringPopulation.clear() ;
} // while
// Return a population with the best individual
SolutionSet resultPopulation = new SolutionSet(1) ;
resultPopulation.add(population.get(0)) ;
/**
* Runs the NSGA-II algorithm.
*
* @return a <code>SolutionSet</code> that is a set of non dominated solutions as a result of the
* algorithm execution
* @throws JMException
*/
public SolutionSet execute() throws JMException, ClassNotFoundException {
int populationSize;
int maxEvaluations;
int evaluations;
QualityIndicator indicators; // QualityIndicator object
int requiredEvaluations; // Use in the example of use of the
// indicators object (see below)
SolutionSet population;
SolutionSet offspringPopulation;
SolutionSet union;
Distance distance = new Distance();
// Read the parameters
populationSize = ((Integer) getInputParameter("populationSize")).intValue();
maxEvaluations = ((Integer) getInputParameter("maxEvaluations")).intValue();
indicators = (QualityIndicator) getInputParameter("indicators");
// Initialize the variables
population = new SolutionSet(populationSize);
evaluations = 0;
requiredEvaluations = 0;
// Read the operators
List<Operator> mutationOperators = new ArrayList<Operator>();
mutationOperators.add(operators_.get("oneNoteMutation"));
mutationOperators.add(operators_.get("harmonyNoteToPitch"));
mutationOperators.add(operators_.get("swapHarmonyNotes"));
mutationOperators.add(operators_.get("melodyNoteToHarmonyNote"));
mutationOperators.add(operators_.get("pitchSpaceMutation"));
Operator crossoverOperator = operators_.get("crossover");
Operator selectionOperator = operators_.get("selection");
// Create the initial solutionSet
Solution newSolution;
for (int i = 0; i < populationSize; i++) {
newSolution = new MusicSolution(problem_);
problem_.evaluate(newSolution);
problem_.evaluateConstraints(newSolution);
evaluations++;
population.add(newSolution);
}
int changeCount = 0;
// Generations ...
// while ((evaluations < maxEvaluations) && changeCount < 10 *
// populationSize) {
while ((evaluations < maxEvaluations)) {
List<Solution> copySolutions = copyList(population);
// Create the offSpring solutionSet
offspringPopulation = new SolutionSet(populationSize);
Solution[] parents = new Solution[2];
for (int i = 0; i < (populationSize / 2); i++) {
if (evaluations < maxEvaluations) {
// obtain parents
parents[0] = (Solution) selectionOperator.execute(population);
parents[1] = (Solution) selectionOperator.execute(population);
Solution[] offSpring = (Solution[]) crossoverOperator.execute(parents);
for (Operator operator : mutationOperators) {
operator.execute(offSpring[0]);
operator.execute(offSpring[1]);
}
if (decorated) {
decorator.decorate(offSpring[0]);
decorator.decorate(offSpring[1]);
}
problem_.evaluate(offSpring[0]);
problem_.evaluateConstraints(offSpring[0]);
problem_.evaluate(offSpring[1]);
problem_.evaluateConstraints(offSpring[1]);
offspringPopulation.add(offSpring[0]);
offspringPopulation.add(offSpring[1]);
evaluations += 2;
}
}
// Create the solutionSet union of solutionSet and offSpring
union = ((SolutionSet) population).union(offspringPopulation);
// Ranking the union
Ranking ranking = new Ranking(union);
int remain = populationSize;
int index = 0;
SolutionSet front = null;
population.clear();
// Obtain the next front
front = ranking.getSubfront(index);
while ((remain > 0) && (remain >= front.size())) {
// Assign crowding distance to individuals
distance.crowdingDistanceAssignment(front, problem_.getNumberOfObjectives());
// Add the individuals of this front
for (int k = 0; k < front.size(); k++) {
population.add(front.get(k));
}
// Decrement remain
remain = remain - front.size();
// Obtain the next front
index++;
if (remain > 0) {
front = ranking.getSubfront(index);
}
}
// Remain is less than front(index).size, insert only the best one
if (remain > 0) { // front contains individuals to insert
distance.crowdingDistanceAssignment(front, problem_.getNumberOfObjectives());
front.sort(new jmetal.util.comparators.CrowdingComparator());
for (int k = 0; k < remain; k++) {
population.add(front.get(k));
}
remain = 0;
}
// This piece of code shows how to use the indicator object into the
// code
// of NSGA-II. In particular, it finds the number of evaluations
// required
// by the algorithm to obtain a Pareto front with a hypervolume
// higher
// than the hypervolume of the true Pareto front.
if ((indicators != null) && (requiredEvaluations == 0)) {
double HV = indicators.getHypervolume(population);
double p = indicators.getTrueParetoFrontHypervolume();
if (HV >= (0.98 * indicators.getTrueParetoFrontHypervolume())) {
requiredEvaluations = evaluations;
}
}
// check changes pareto front
// SolutionSet paretoFront = ranking.getSubfront(0);
List<Solution> frontSolutions = copyList(population);
boolean changed = hasPopulationChanged(copySolutions, frontSolutions);
LOGGER.fine(
"Population changed: "
+ changed
+ ", evaluations: "
+ evaluations
+ ", change count:"
+ changeCount);
if (changed) {
changeCount = 0;
} else {
changeCount++;
}
}
// Return as output parameter the required evaluations
setOutputParameter("evaluations", requiredEvaluations);
// Return the first non-dominated front
Ranking ranking = new Ranking(population);
return ranking.getSubfront(0);
}