コード例 #1
5
ファイル: NSGAII_G10.java プロジェクト: deserver/qopmo_p234
  /**
   * 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
   */
  @Test
  public Poblacion execute() throws JMException, ClassNotFoundException {
    int populationSize;
    int maxEvaluations;
    int evaluations;
    int probMutacion;
    int nrocaso;
    int corridas;

    int requiredEvaluations; // Use in the example of use of the
    // indicators object (see below)

    // Poblacion population;
    // SolutionSet population;
    Poblacion offspringPopulation;
    Poblacion union;
    Poblacion copyPopulation;

    Operator mutationOperator;
    Operator crossoverOperator;
    Operator selectionOperator;

    Distance distance = new Distance();

    // Read the parameters
    populationSize = ((Integer) getInputParameter("populationSize")).intValue();
    maxEvaluations = ((Integer) getInputParameter("maxEvaluations")).intValue();
    probMutacion = ((Integer) getInputParameter("probMutacion")).intValue();
    nrocaso = ((Integer) getInputParameter("nrocaso")).intValue();
    corridas = ((Integer) getInputParameter("corridas")).intValue();

    // Initialize the variables
    // population = new SolutionSet(populationSize);
    evaluations = 0;
    caso = casosDePrueba[nrocaso];

    // Initialize Nsfnet
    NSFNET = em.find(Red.class, 1); // NSFnet
    NSFNET.inicializar();

    long time_start, time_end = 0;
    // captura tiempo Inicial
    time_start = System.currentTimeMillis();
    // 0. Obtener Poblacion Inicial
    this.obtenerPoblacion(populationSize);

    requiredEvaluations = 0;

    // Read the operators
    // mutationOperator = operators_.get("mutation");
    // crossoverOperator = operators_.get("crossover");
    // selectionOperator = operators_.get("selection");
    OperadorSeleccion seleccionOp = new TorneoBinario();

    // Create the initial solutionSet
    Solution newSolution;
    // population = new Poblacion(populationSize);
    for (int i = 0; i < populationSize; i++) {
      newSolution = new Solution(problem_);
      problem_.evaluate(newSolution);
      problem_.evaluateConstraints(newSolution);
      evaluations++;
      population.add(newSolution);
    } // for

    Ranking ranking = new Ranking(population);
    evaluations = 0;
    int cantIt = 0;
    int size, tamanho = 0;
    // Generations

    System.out.println(caso + "-" + corridas + " Test Genetico.");

    while (evaluations < tiempoTotal[nrocaso]) {

      size = population.getIndividuos().size();
      tamanho = (size * size) + size;
      offspringPopulation = new Poblacion(populationSize * populationSize + populationSize);
      copyPopulation = new Poblacion(populationSize * populationSize + populationSize);
      // offspringPopulation.copiarPoblacion(population);;

      // for (int i = 0; i < (populationSize); i++) {
      if (evaluations < tiempoTotal[nrocaso]) {

        for (Individuo ind : population.getIndividuos()) {
          Solution s = (Solution) ind;
          s.setNumberOfObjectives(problem_.getNumberOfObjectives());
          problem_.evaluate(s);
          // if (s.getCosto()<2.8)
          // System.out.println(s.getCosto());
          if (s.getCosto() > 0) offspringPopulation.add(s);
        }

        Collection<Individuo> selectos = seleccionOp.seleccionar(population);

        population.cruzar(selectos, probMutacion);
        /*copyPopulation.copiarPoblacion(offspringPopulation);
        Poblacion mejores = getFront(copyPopulation);
        population.siguienteGeneracion(mejores);*/
        population.siguienteGeneracion();

        evaluations++;
      } // if

      // } // for

      for (Individuo ind : population.getIndividuos()) {
        Solution s = (Solution) ind;
        s.setNumberOfObjectives(problem_.getNumberOfObjectives());
        problem_.evaluate(s);
        if (s.getCosto() > 0) offspringPopulation.add(s);
      }
      // Create the solutionSet union of solutionSet and offSpring
      // union = ((SolutionSet) population).union(offspringPopulation);

      union = offspringPopulation.union(population);
      // Ranking the union
      ranking = new Ranking(union);

      int remain = populationSize;
      int index = 0;
      Poblacion front = null;
      population.clear();

      // Obtain the next front
      front = ranking.getSubfront(index);

      while (front != null && (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));
        } // for

        // Decrement remain
        remain = remain - front.size();

        // Obtain the next front
        index++;
        if (remain > 0) {
          front = ranking.getSubfront(index);
        } // if
      } // while

      if (front != null) {
        // 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 CrowdingComparator());
          for (int k = 0; k < remain; k++) {
            population.add(front.get(k));
          } // for
        }
        remain = 0;
      } // if

      // 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);
        if (HV >= (0.98 * indicators.getTrueParetoFrontHypervolume())) {
          requiredEvaluations = evaluations;
        } // if
      } // if*/

      if (evaluations % maxEvaluations == 0) {
        System.out.println();
        System.out.print("Población Nro: " + evaluations + " ");
        // System.out.println("MEJOR--> " + p.getMejor().toString());
        System.out.print("Costo-MEJOR==> ");
        ranking = new Ranking(population);
        if (ranking.getSubfront(0) != null) {
          ranking.getSubfront(0).printParcialResults();
          ranking.getSubfront(0).printVariablesToFile("VAR_p3" + "_" + caso);
        }
        // ((Solution) p.getMejor()).imprimirCosto();
      }
    } // while
    cantIt++;

    // captura tiempo final
    // time_end = System.currentTimeMillis();
    // Calculo del Tiempo
    /*long tiempo = time_end - time_start;
    long hora = tiempo / 3600000;
    long restohora = tiempo % 3600000;
    long minuto = restohora / 60000;
    long restominuto = restohora % 60000;
    long segundo = restominuto / 1000;
    long restosegundo = restominuto % 1000;
    String time = hora + ":" + minuto + ":" + segundo + "." + restosegundo;
    time = " Tiempo: " + time;
    String fin = caso + " FIN - Test Genetico. Tiempo:" + time;
    fin += " - Nº Generaciones: " + evaluations;
    System.out.println(fin);
    */
    System.out.println("Evaluaciones: " + evaluations);

    // Return as output parameter the required evaluations
    setOutputParameter("evaluations", requiredEvaluations);

    // Return the first non-dominated front
    ranking = new Ranking(population);
    if (ranking.getSubfront(0) != null) ranking.getSubfront(0).printFeasibleFUN("FUN_NSGAII");

    return ranking.getSubfront(0);
  } // execute
コード例 #2
0
ファイル: Spea2Fitness.java プロジェクト: fritsche/MECBA-Hyp
 /**
  * Constructor. Creates a new instance of Spea2Fitness for a given <code>SolutionSet</code>.
  *
  * @param solutionSet The <code>SolutionSet</code>
  */
 public Spea2Fitness(SolutionSet solutionSet) {
   distance = distance_.distanceMatrix(solutionSet);
   solutionSet_ = solutionSet;
   for (int i = 0; i < solutionSet_.size(); i++) {
     solutionSet_.get(i).setLocation(i);
   } // for
 } // Spea2Fitness
コード例 #3
0
ファイル: NSGAII_G10.java プロジェクト: deserver/qopmo_p234
  public Poblacion getFront(Poblacion population) {
    Ranking ranking = new Ranking(population);
    Distance distance = new Distance();

    int remain = population.size();
    int index = 0;
    Poblacion front = null;
    Poblacion poblacion = new Poblacion(population.size());

    front = ranking.getSubfront(index);

    while (front != null && (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++) {
        poblacion.add(front.get(k));
      } // for

      // Decrement remain
      remain = remain - front.size();

      // Obtain the next front
      index++;
      if (remain > 0) {
        front = ranking.getSubfront(index);
      } // if
    } // while

    if (front != null) {
      // 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 CrowdingComparator());
        for (int k = 0; k < remain; k++) {
          poblacion.add(front.get(k));
        } // for
      }
      remain = 0;
    } // if

    return ranking.getSubfront(0);
  }
コード例 #4
0
ファイル: SMPSO.java プロジェクト: dukeboard/kevoree-genetic
  /**
   * 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
コード例 #5
0
ファイル: Spea2Fitness.java プロジェクト: fritsche/MECBA-Hyp
  /**
   * Gets 'size' elements from a population of more than 'size' elements using for this de
   * enviromentalSelection truncation
   *
   * @param size The number of elements to get.
   */
  public SolutionSet environmentalSelection(int size) {

    if (solutionSet_.size() < size) {
      size = solutionSet_.size();
    }

    // Create a new auxiliar population for no alter the original population
    SolutionSet aux = new SolutionSet(solutionSet_.size());

    int i = 0;
    while (i < solutionSet_.size()) {
      if (solutionSet_.get(i).getFitness() < 1.0) {
        aux.add(solutionSet_.get(i));
        solutionSet_.remove(i);
      } else {
        i++;
      } // if
    } // while

    if (aux.size() < size) {
      Comparator comparator = new FitnessComparator();
      solutionSet_.sort(comparator);
      int remain = size - aux.size();
      for (i = 0; i < remain; i++) {
        aux.add(solutionSet_.get(i));
      }
      return aux;
    } else if (aux.size() == size) {
      return aux;
    }

    double[][] distance = distance_.distanceMatrix(aux);
    List<List<DistanceNode>> distanceList = new LinkedList<List<DistanceNode>>();
    for (int pos = 0; pos < aux.size(); pos++) {
      aux.get(pos).setLocation(pos);
      List<DistanceNode> distanceNodeList = new ArrayList<DistanceNode>();
      for (int ref = 0; ref < aux.size(); ref++) {
        if (pos != ref) {
          distanceNodeList.add(new DistanceNode(distance[pos][ref], ref));
        } // if
      } // for
      distanceList.add(distanceNodeList);
    } // for

    for (int q = 0; q < distanceList.size(); q++) {
      Collections.sort(distanceList.get(q), distanceNodeComparator);
    } // for

    while (aux.size() > size) {
      double minDistance = Double.MAX_VALUE;
      int toRemove = 0;
      i = 0;
      Iterator<List<DistanceNode>> iterator = distanceList.iterator();
      while (iterator.hasNext()) {
        List<DistanceNode> dn = iterator.next();
        if (dn.get(0).getDistance() < minDistance) {
          toRemove = i;
          minDistance = dn.get(0).getDistance();
          // i y toRemove have the same distance to the first solution
        } else if (dn.get(0).getDistance() == minDistance) {
          int k = 0;
          while ((dn.get(k).getDistance() == distanceList.get(toRemove).get(k).getDistance())
              && k < (distanceList.get(i).size() - 1)) {
            k++;
          }

          if (dn.get(k).getDistance() < distanceList.get(toRemove).get(k).getDistance()) {
            toRemove = i;
          } // if
        } // if
        i++;
      } // while

      int tmp = aux.get(toRemove).getLocation();
      aux.remove(toRemove);
      distanceList.remove(toRemove);

      Iterator<List<DistanceNode>> externIterator = distanceList.iterator();
      while (externIterator.hasNext()) {
        Iterator<DistanceNode> interIterator = externIterator.next().iterator();
        while (interIterator.hasNext()) {
          if (interIterator.next().getReference() == tmp) {
            interIterator.remove();
            continue;
          } // if
        } // while
      } // while
    } // while
    return aux;
  } // environmentalSelection
コード例 #6
0
  /**
   * @author Juanjo This method selects N solutions from a set M, where N <= M using the same method
   *     proposed by Qingfu Zhang, W. Liu, and Hui Li in the paper describing MOEA/D-DRA (CEC 09
   *     COMPTETITION) An example is giving in that paper for two objectives. If N = 100, then the
   *     best solutions attenting to the weights (0,1), (1/99,98/99), ...,(98/99,1/99), (1,0) are
   *     selected.
   *     <p>Using this method result in 101 solutions instead of 100. We will just compute 100 even
   *     distributed weights and used them. The result is the same
   *     <p>In case of more than two objectives the procedure is: 1- Select a solution at random 2-
   *     Select the solution from the population which have maximum distance to it (whithout
   *     considering the already included)
   * @param n: The number of solutions to return
   * @return A solution set containing those elements
   */
  SolutionSet finalSelection(int n) throws JMException {
    SolutionSet res = new SolutionSet(n);
    if (problem_.getNumberOfObjectives() == 2) { // subcase 1
      double[][] intern_lambda = new double[n][2];
      for (int i = 0; i < n; i++) {
        double a = 1.0 * i / (n - 1);
        intern_lambda[i][0] = a;
        intern_lambda[i][1] = 1 - a;
      } // for

      // we have now the weights, now select the best solution for each of them
      for (int i = 0; i < n; i++) {
        Solution current_best = population.get(0);
        int index = 0;
        double value = fitnessFunction(current_best, intern_lambda[i]);
        for (int j = 1; j < n; j++) {
          double aux =
              fitnessFunction(
                  population.get(j), intern_lambda[i]); // we are looking the best for the weight i
          if (aux < value) { // solution in position j is better!
            value = aux;
            current_best = population.get(j);
          }
        }
        res.add(new Solution(current_best));
      }

    } else { // general case (more than two objectives)

      Distance distance_utility = new Distance();
      int random_index = PseudoRandom.randInt(0, population.size() - 1);

      // create a list containing all the solutions but the selected one (only references to them)
      List<Solution> candidate = new LinkedList<Solution>();
      candidate.add(population.get(random_index));

      for (int i = 0; i < population.size(); i++) {
        if (i != random_index) {
          candidate.add(population.get(i));
        }
      } // for

      while (res.size() < n) {
        int index = 0;
        Solution selected = candidate.get(0); // it should be a next! (n <= population size!)
        double distance_value =
            distance_utility.distanceToSolutionSetInObjectiveSpace(selected, res);
        int i = 1;
        while (i < candidate.size()) {
          Solution next_candidate = candidate.get(i);
          double aux =
              distance_value =
                  distance_utility.distanceToSolutionSetInObjectiveSpace(next_candidate, res);
          if (aux > distance_value) {
            distance_value = aux;
            index = i;
          }
          i++;
        }

        // add the selected to res and remove from candidate list
        res.add(new Solution(candidate.remove(index)));
      } //
    }
    return res;
  }
コード例 #7
0
ファイル: NSGAII.java プロジェクト: patrom/neo
  /**
   * 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);
  }