Exemple #1
0
  /**
   * 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
Exemple #2
0
 /**
  * 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)) ;
    
Exemple #3
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);
  }