protected void generate(String folder, List<String> files, int totalOfFiles, int level) throws Exception { logger.info( "Generating Quality Indicators for " + folder + ". Finding a True Pareto-front file in the path"); File parent = new File(folder); for (int i = 0; i < level; i++) { parent = parent.getParentFile(); } String approxTrueParetoFrontPath = parent.getAbsolutePath() + File.separator + "PFAPPROX"; if (!new File(approxTrueParetoFrontPath).exists()) { throw new Exception("You must to define a true Pareto-front before"); } SolutionSet paretoFront = SolutionSetUtils.getFromFile(approxTrueParetoFrontPath); if (paretoFront.size() == 0) { throw new IllegalArgumentException("The Approximate Pareto-front cannot be empty"); } int numberOfObjectives = paretoFront.get(0).getNumberOfObjectives(); Problem p = new FakeProblem(numberOfObjectives); QualityIndicator qi = new QualityIndicator(p, approxTrueParetoFrontPath); for (String file : files) { generateQualityIndicators(qi, folder, file, paretoFront, totalOfFiles); } }
/** * Performs the operation * * @param object Object representing a SolutionSet. * @return the best solution found */ public Object execute(Object object) { SolutionSet solutionSet = (SolutionSet) object; if (solutionSet.size() == 0) { return null; } int worstSolution; worstSolution = 0; for (int i = 1; i < solutionSet.size(); i++) { if (comparator_.compare(solutionSet.get(i), solutionSet.get(worstSolution)) > 0) worstSolution = i; } // for return worstSolution; } // Execute
/** * Returns a matrix with distances between solutions in a <code>SolutionSet</code>. * * @param solutionSet The <code>SolutionSet</code>. * @return a matrix with distances. */ public double[][] distanceMatrix(SolutionSet solutionSet) { Solution solutionI, solutionJ; // The matrix of distances double[][] distance = new double[solutionSet.size()][solutionSet.size()]; // -> Calculate the distances for (int i = 0; i < solutionSet.size(); i++) { distance[i][i] = 0.0; solutionI = solutionSet.get(i); for (int j = i + 1; j < solutionSet.size(); j++) { solutionJ = solutionSet.get(j); distance[i][j] = this.distanceBetweenObjectives(solutionI, solutionJ); distance[j][i] = distance[i][j]; } // for } // for // ->Return the matrix of distances return distance; } // distanceMatrix
/** * Apply a mutation operator to some particles in the swarm * * @throws jmetal.util.JMException */ private void mopsoMutation(int actualIteration, int totalIterations) throws JMException { for (int i = 0; i < particles_.size(); i++) { if ((i % 6) == 0) polynomialMutation_.execute(particles_.get(i)); // if (i % 3 == 0) { //particles_ mutated with a non-uniform mutation %3 // nonUniformMutation_.execute(particles_.get(i)); // } else if (i % 3 == 1) { //particles_ mutated with a uniform mutation operator // uniformMutation_.execute(particles_.get(i)); // } else //particles_ without mutation // ; } } // mopsoMutation
/** * Update the speed of each particle * * @throws JMException */ private void computeSpeed(int iter, int miter) throws JMException, IOException { double r1, r2, W, C1, C2; double wmax, wmin, deltaMax, deltaMin; XReal bestGlobal; for (int i = 0; i < swarmSize_; i++) { XReal particle = new XReal(particles_.get(i)); XReal bestParticle = new XReal(best_[i]); // Select a global best_ for calculate the speed of particle i, bestGlobal Solution one, two; int pos1 = PseudoRandom.randInt(0, leaders_.size() - 1); int pos2 = PseudoRandom.randInt(0, leaders_.size() - 1); one = leaders_.get(pos1); two = leaders_.get(pos2); if (crowdingDistanceComparator_.compare(one, two) < 1) { bestGlobal = new XReal(one); } else { bestGlobal = new XReal(two); // Params for velocity equation } // Juanjo, si usamos esto en lugar de lo de antes va de pena // bestGlobal = new XReal(leaders_.get(0)) ; r1 = PseudoRandom.randDouble(r1Min_, r1Max_); r2 = PseudoRandom.randDouble(r2Min_, r2Max_); C1 = PseudoRandom.randDouble(C1Min_, C1Max_); C2 = PseudoRandom.randDouble(C2Min_, C2Max_); W = PseudoRandom.randDouble(WMin_, WMax_); // wmax = WMax_; wmin = WMin_; for (int var = 0; var < particle.getNumberOfDecisionVariables(); var++) { // Computing the velocity of this particle speed_[i][var] = velocityConstriction( constrictionCoefficient(C1, C2) * (inertiaWeight(iter, miter, wmax, wmin) * speed_[i][var] + C1 * r1 * (bestParticle.getValue(var) - particle.getValue(var)) + C2 * r2 * (bestGlobal.getValue(var) - particle.getValue(var))), deltaMax_, // [var], deltaMin_, // [var], var, i); } } } // computeSpeed
/** * Returns the minimum distance from a <code>Solution</code> to a <code> * SolutionSet according to the variable values</code>. * * @param solution The <code>Solution</code>. * @param solutionSet The <code>SolutionSet</code>. * @return The minimum distance between solution and the set. * @throws JMException */ public double distanceToSolutionSetInSolutionSpace(Solution solution, SolutionSet solutionSet) throws JMException { // At start point the distance is the max double distance = Double.MAX_VALUE; // found the min distance respect to population for (int i = 0; i < solutionSet.size(); i++) { double aux = this.distanceBetweenSolutions(solution, solutionSet.get(i)); if (aux < distance) distance = aux; } // for // ->Return the best distance return distance; } // distanceToSolutionSetInSolutionSpace
/** * Update the position of each particle * * @throws jmetal.util.JMException */ private void computeNewPositions() throws JMException { for (int i = 0; i < swarmSize_; i++) { XReal particle = new XReal(particles_.get(i)); for (int var = 0; var < particle.getNumberOfDecisionVariables(); var++) { particle.setValue(var, particle.getValue(var) + speed_[i][var]); if (particle.getValue(var) < problem_.getLowerLimit(var)) { particle.setValue(var, problem_.getLowerLimit(var)); speed_[i][var] = speed_[i][var] * ChVel1_; // } if (particle.getValue(var) > problem_.getUpperLimit(var)) { particle.setValue(var, problem_.getUpperLimit(var)); speed_[i][var] = speed_[i][var] * ChVel2_; // } } } } // computeNewPositions
private void computeNewPositions_parallel(int i) throws JMException { //Variable[] particle = particles_.get(i).getDecisionVariables(); XReal particle = new XReal(particles_.get(i)) ; //particle.move(speed_[i]); for (int var = 0; var < particle.size(); var++) { particle.setValue(var, particle.getValue(var) + speed_[i][var]) ; if (particle.getValue(var) < problem_.getLowerLimit(var)) { particle.setValue(var, problem_.getLowerLimit(var)); speed_[i][var] = speed_[i][var] * ChVel1_; // } if (particle.getValue(var) > problem_.getUpperLimit(var)) { particle.setValue(var, problem_.getUpperLimit(var)); speed_[i][var] = speed_[i][var] * ChVel2_; // } } }
/** * Runs of the PESA2 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 archiveSize, bisections, maxEvaluations, evaluations, populationSize; AdaptiveGridArchive archive; SolutionSet solutionSet; Operator crossover, mutation, selection; // Read parameters populationSize = ((Integer) (inputParameters_.get("populationSize"))).intValue(); archiveSize = ((Integer) (inputParameters_.get("archiveSize"))).intValue(); bisections = ((Integer) (inputParameters_.get("bisections"))).intValue(); maxEvaluations = ((Integer) (inputParameters_.get("maxEvaluations"))).intValue(); // Get the operators crossover = operators_.get("crossover"); mutation = operators_.get("mutation"); // Initialize the variables evaluations = 0; archive = new AdaptiveGridArchive(archiveSize, bisections, problem_.getNumberOfObjectives()); solutionSet = new SolutionSet(populationSize); HashMap parameters = null; selection = new PESA2Selection(parameters); // -> Create the initial individual and evaluate it and his constraints for (int i = 0; i < populationSize; i++) { Solution solution = new Solution(problem_); problem_.evaluate(solution); problem_.evaluateConstraints(solution); solutionSet.add(solution); } // Incorporate non-dominated solution to the archive for (int i = 0; i < solutionSet.size(); i++) { archive.add(solutionSet.get(i)); // Only non dominated are accepted by // the archive } // Clear the init solutionSet solutionSet.clear(); // Iterations.... Solution[] parents = new Solution[2]; do { // -> Create the offSpring solutionSet while (solutionSet.size() < populationSize) { parents[0] = (Solution) selection.execute(archive); parents[1] = (Solution) selection.execute(archive); Solution[] offSpring = (Solution[]) crossover.execute(parents); mutation.execute(offSpring[0]); problem_.evaluate(offSpring[0]); problem_.evaluateConstraints(offSpring[0]); evaluations++; solutionSet.add(offSpring[0]); } for (int i = 0; i < solutionSet.size(); i++) archive.add(solutionSet.get(i)); // Clear the solutionSet solutionSet.clear(); } while (evaluations < maxEvaluations); // Return the solutionSet of non-dominated individual return archive; } // execute
/** * Runs of the SMPSO algorithm. * * @return a <code>SolutionSet</code> that is a set of non dominated solutions as a result of the * algorithm execution * @throws JMException */ @Override public SolutionSet execute() throws JMException, ClassNotFoundException { initParams(); success_ = false; // ->Step 1 (and 3) Create the initial population and evaluate for (int i = 0; i < swarmSize_; i++) { Solution particle = new Solution(problem_); problem_.evaluate(particle); problem_.evaluateConstraints(particle); particles_.add(particle); } // -> Step2. Initialize the speed_ of each particle to 0 for (int i = 0; i < swarmSize_; i++) { for (int j = 0; j < problem_.getNumberOfVariables(); j++) { speed_[i][j] = 0.0; } } // Step4 and 5 for (int i = 0; i < particles_.size(); i++) { Solution particle = new Solution(particles_.get(i)); leaders_.add(particle); } // -> Step 6. Initialize the memory of each particle for (int i = 0; i < particles_.size(); i++) { Solution particle = new Solution(particles_.get(i)); best_[i] = particle; } // Crowding the leaders_ // distance_.crowdingDistanceAssignment(leaders_, problem_.getNumberOfObjectives()); leaders_.computeHVContribution(); // -> Step 7. Iterations .. while (iteration_ < maxIterations_) { System.out.println("Iteration: " + iteration_ + " times"); try { // Compute the speed_ computeSpeed(iteration_, maxIterations_); } catch (IOException ex) { Logger.getLogger(SMPSOhv.class.getName()).log(Level.SEVERE, null, ex); } // Compute the new positions for the particles_ computeNewPositions(); // Mutate the particles_ mopsoMutation(iteration_, maxIterations_); // Evaluate the new particles_ in new positions for (int i = 0; i < particles_.size(); i++) { Solution particle = particles_.get(i); problem_.evaluate(particle); problem_.evaluateConstraints(particle); } // Actualize the archive for (int i = 0; i < particles_.size(); i++) { Solution particle = new Solution(particles_.get(i)); leaders_.add(particle); } if (leaders_.size() < archiveSize_) leaders_.computeHVContribution(); // Actualize the memory of this particle for (int i = 0; i < particles_.size(); i++) { int flag = dominance_.compare(particles_.get(i), best_[i]); if (flag != 1) { // the new particle is best_ than the older remeber Solution particle = new Solution(particles_.get(i)); best_[i] = particle; } } iteration_++; } return this.leaders_; } // execute
/** * 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)) ;
} // execute private void evaluate_internal(SolutionSet s, int i, Operator mutationOperator) throws JMException, ClassNotFoundException { Solution sol = s.get(i); if(mutationOperator != null) mutationOperator.execute(sol);
/** * Runs of the SMPSO algorithm. * * @return a <code>SolutionSet</code> that is a set of non dominated solutions as a result of the * algorithm execution * @throws jmetal.util.JMException */ public SolutionSet execute() throws JMException, ClassNotFoundException { initParams(); success_ = false; // ->Step 1 (and 3) Create the initial population and evaluate for (int i = 0; i < swarmSize_; i++) { Solution particle = new Solution(problem_); problem_.evaluate(particle); problem_.evaluateConstraints(particle); particles_.add(particle); } // -> Step2. Initialize the speed_ of each particle to 0 for (int i = 0; i < swarmSize_; i++) { for (int j = 0; j < problem_.getNumberOfVariables(); j++) { speed_[i][j] = 0.0; } } // Step4 and 5 for (int i = 0; i < particles_.size(); i++) { Solution particle = new Solution(particles_.get(i)); leaders_.add(particle); } // -> Step 6. Initialize the memory of each particle for (int i = 0; i < particles_.size(); i++) { Solution particle = new Solution(particles_.get(i)); best_[i] = particle; } // Crowding the leaders_ distance_.crowdingDistanceAssignment(leaders_, problem_.getNumberOfObjectives()); // -> Step 7. Iterations .. while (iteration_ < maxIterations_) { try { // Compute the speed_ computeSpeed(iteration_, maxIterations_); } catch (IOException ex) { Logger.getLogger(SMPSO.class.getName()).log(Level.SEVERE, null, ex); } // Compute the new positions for the particles_ computeNewPositions(); // Mutate the particles_ mopsoMutation(iteration_, maxIterations_); // Evaluate the new particles_ in new positions for (int i = 0; i < particles_.size(); i++) { Solution particle = particles_.get(i); problem_.evaluate(particle); problem_.evaluateConstraints(particle); } // Actualize the archive for (int i = 0; i < particles_.size(); i++) { Solution particle = new Solution(particles_.get(i)); leaders_.add(particle); } // Actualize the memory of this particle for (int i = 0; i < particles_.size(); i++) { int flag = dominance_.compare(particles_.get(i), best_[i]); if (flag != 1) { // the new particle is best_ than the older remeber Solution particle = new Solution(particles_.get(i)); best_[i] = particle; } } // Assign crowding distance to the leaders_ distance_.crowdingDistanceAssignment(leaders_, problem_.getNumberOfObjectives()); iteration_++; /* if ((iteration_ % 1) == 0) { leaders_.printObjectivesOfValidSolutionsToFile("FUNV"+iteration_) ; leaders_.printObjectivesToFile("FUN"+iteration_) ; leaders_.printVariablesToFile("VAR"+iteration_) ; } */ } // leaders_.printObjectivesOfValidSolutionsToFile("FUNV.SMPSO") ; leaders_.printFeasibleFUN("FUN_SMPSO"); return this.leaders_; } // execute
/** * Update the speed of each particle * @throws JMException */ private void computeSpeed(int iter, int miter) throws JMException, IOException { double r1, r2 ; //double W ; double C1, C2; double wmax, wmin, deltaMax, deltaMin; XReal bestGlobal; bestGlobal = new XReal(globalBest_) ; for (int i = 0; i < particlesSize_; i++) { XReal particle = new XReal(particles_.get(i)) ; XReal bestParticle = new XReal(localBest_[i]) ; //int bestIndividual = (Integer)findBestSolution_.execute(particles_) ; C1Max_ = 2.5; C1Min_ = 1.5; C2Max_ = 2.5; C2Min_ = 1.5; r1 = PseudoRandom.randDouble(r1Min_, r1Max_); r2 = PseudoRandom.randDouble(r2Min_, r2Max_); C1 = PseudoRandom.randDouble(C1Min_, C1Max_); C2 = PseudoRandom.randDouble(C2Min_, C2Max_); //W = PseudoRandom.randDouble(WMin_, WMax_); // WMax_ = 0.9; WMin_ = 0.9; ChVel1_ = 1.0; ChVel2_ = 1.0; C1 = 2.5 ; C2 = 1.5 ; wmax = WMax_; wmin = WMin_; /* for (int var = 0; var < particle.size(); var++) { //Computing the velocity of this particle speed_[i][var] = velocityConstriction(constrictionCoefficient(C1, C2) * (inertiaWeight(iter, miter, wmax, wmin) * speed_[i][var] + C1 * r1 * (bestParticle.getValue(var) - particle.getValue(var)) + C2 * r2 * (bestGlobal.getValue(var) - particle.getValue(var))), deltaMax_, deltaMin_, //[var], var, i); } */ C1 = 1.5 ; C2 = 1.5 ; double W = 0.9 ; for (int var = 0; var < particle.size(); var++) { //Computing the velocity of this particle speed_[i][var] = inertiaWeight(iter, miter, wmax, wmin) * speed_[i][var] + C1 * r1 * (bestParticle.getValue(var) - particle.getValue(var)) + C2 * r2 * (bestGlobal.getValue(var) - particle.getValue(var)) ; } } } // computeSpeed
private void evaluate_parallel_internal(int i) throws JMException, ClassNotFoundException { Solution particle = particles_.get(i); problem_.evaluate(particle); }
/** * Runs of the SMPSO 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 { initParams(); success_ = false; globalBest_ = null ; //->Step 1 (and 3) Create the initial population and evaluate for (int i = 0; i < particlesSize_; i++) { Solution particle = new Solution(problem_); problem_.evaluate(particle); evaluations_ ++ ; particles_.add(particle); if ((globalBest_ == null) || (particle.getObjective(0) < globalBest_.getObjective(0))) globalBest_ = new Solution(particle) ; } //-> Step2. Initialize the speed_ of each particle to 0 for (int i = 0; i < particlesSize_; i++) { for (int j = 0; j < problem_.getNumberOfVariables(); j++) { speed_[i][j] = 0.0; } } //-> Step 6. Initialize the memory of each particle for (int i = 0; i < particles_.size(); i++) { Solution particle = new Solution(particles_.get(i)); localBest_[i] = particle; } //-> Step 7. Iterations .. while (iteration_ < maxIterations_) { int bestIndividual = (Integer)findBestSolution_.execute(particles_) ; try { //Compute the speed_ computeSpeed(iteration_, maxIterations_); } catch (IOException ex) { Logger.getLogger(PSO.class.getName()).log(Level.SEVERE, null, ex); } //Compute the new positions for the particles_ computeNewPositions(); //Mutate the particles_ //mopsoMutation(iteration_, maxIterations_); //Evaluate the new particles_ in new positions evaluations_ += particles_.size(); finish { // async { for (int i = 0; i < particles_.size(); i++) { evaluate_parallel_internal(i); } } } //Actualize the memory of this particle for (int i = 0; i < particles_.size(); i++) { //int flag = comparator_.compare(particles_.get(i), localBest_[i]); //if (flag < 0) { // the new particle is best_ than the older remember if ((particles_.get(i).getObjective(0) < localBest_[i].getObjective(0))) { Solution particle = new Solution(particles_.get(i)); localBest_[i] = particle; } // if if ((particles_.get(i).getObjective(0) < globalBest_.getObjective(0))) { Solution particle = new Solution(particles_.get(i)); globalBest_ = particle; } // if } iteration_++; } // Return a population with the best individual SolutionSet resultPopulation = new SolutionSet(1) ; resultPopulation.add(particles_.get((Integer)findBestSolution_.execute(particles_))) ; return resultPopulation ; } // execute
/** @param args the command line arguments -- modelname, alg_name, evaluation_times, [runid] */ public static void main(String[] args) throws Exception { try { String name = args[0]; URL location = Main.class.getProtectionDomain().getCodeSource().getLocation(); String loc = location.toString(); String project_path = loc.substring(5, loc.lastIndexOf("SPL/")) + "SPL/"; // with '/' at the end String fm = project_path + "dimacs_data/" + name + ".dimacs"; String augment = fm + ".augment"; String dead = fm + ".dead"; String mandatory = fm + ".mandatory"; String seed = fm + ".richseed"; String opfile = fm + ".sipop"; Problem p = new ProductLineProblem(fm, augment, mandatory, dead, seed); // Problem p = new ProductLineProblemNovelPrep(fm, augment, mandatory, dead, seed, // opfile); // GroupedProblem.grouping((ProductLineProblem) p, 100); System.exit(0); Algorithm a; int evaluation_times = Integer.parseInt(args[2]); String alg_name = args[1]; String runid = ""; if (args.length >= 4) { runid = args[3]; } switch (alg_name) { case "IBEA": a = new SPL_SettingsIBEA(p).configureICSE2013(evaluation_times); break; case "SIPIBEA": a = new SPL_SettingsIBEA(p).configureSIPIBEA(evaluation_times); break; case "SPEA2": a = new SPL_SettingsEMOs(p).configureSPEA2(evaluation_times); break; case "NSGA2": a = new SPL_SettingsEMOs(p).configureNSGA2(evaluation_times); break; case "IBEASEED": a = new SPL_SettingsIBEA(p).configureIBEASEED(evaluation_times); break; case "SATIBEA": // a = new SPL_SettingsIBEA(p).configureICSE15(1000, fm, ((ProductLineProblem) // p).getNumFeatures(), // ((ProductLineProblem) p).getConstraints()); a = new SPL_SettingsIBEA(p) .configureSATIBEA( evaluation_times, fm, ((ProductLineProblem) p).getNumFeatures(), ((ProductLineProblem) p).getConstraints()); break; default: a = new SPL_SettingsIBEA(p).configureICSE2013(evaluation_times); } long start = System.currentTimeMillis(); SolutionSet pop = a.execute(); float total_time = (System.currentTimeMillis() - start) / 1000.0f; String file_tag = name + "_" + alg_name + '_' + evaluation_times / 1000 + "k_" + runid + ".txt"; String file_path = project_path + "j_res/" + file_tag; File file = new File(file_path); if (!file.exists()) { file.createNewFile(); } FileWriter fw = new FileWriter(file.getAbsoluteFile()); BufferedWriter bw = new BufferedWriter(fw); for (int i = 0; i < pop.size(); i++) { Variable v = pop.get(i).getDecisionVariables()[0]; bw.write((Binary) v + "\n"); System.out.println("Conf" + (i + 1) + ": " + (Binary) v + " "); } bw.write("~~~\n"); for (int i = 0; i < pop.size(); i++) { Variable v = pop.get(i).getDecisionVariables()[0]; for (int j = 0; j < pop.get(i).getNumberOfObjectives(); j++) { bw.write(pop.get(i).getObjective(j) + " "); System.out.print(pop.get(i).getObjective(j) + " "); } bw.write("\n"); System.out.println(""); } System.out.println(total_time); bw.write("~~~\n" + total_time + "\n"); bw.close(); fw.close(); } catch (Exception e) { e.printStackTrace(); } }
/** * 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); }