コード例 #1
0
  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);
    }
  }
コード例 #2
0
  /**
   * 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
コード例 #3
0
ファイル: Distance.java プロジェクト: vpillac/vroom
  /**
   * 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
コード例 #4
0
ファイル: SMPSO.java プロジェクト: dukeboard/kevoree-genetic
 /**
  * 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
コード例 #5
0
  /**
   * 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
コード例 #6
0
ファイル: Distance.java プロジェクト: vpillac/vroom
  /**
   * 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
コード例 #7
0
ファイル: SMPSO.java プロジェクト: dukeboard/kevoree-genetic
  /**
   * 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
コード例 #8
0
ファイル: PSO.java プロジェクト: vivkumar/ajws
  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_; //   
		  }
	  }
  }
コード例 #9
0
ファイル: PESA2.java プロジェクト: santiagofm/proyectoAE2015
  /**
   * 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
コード例 #10
0
  /**
   * 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
コード例 #11
0
ファイル: Distance.java プロジェクト: vpillac/vroom
  /**
   * 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
コード例 #12
0
ファイル: ElitistES.java プロジェクト: vivkumar/ajws
 /**
  * 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)) ;
    
コード例 #13
0
ファイル: ElitistES.java プロジェクト: vivkumar/ajws
  } // 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);
コード例 #14
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
コード例 #15
0
ファイル: PSO.java プロジェクト: vivkumar/ajws
  /**
   * 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
コード例 #16
0
ファイル: PSO.java プロジェクト: vivkumar/ajws
  private void evaluate_parallel_internal(int i) throws JMException, ClassNotFoundException {
	  Solution particle = particles_.get(i);
      problem_.evaluate(particle);
  }
コード例 #17
0
ファイル: PSO.java プロジェクト: vivkumar/ajws
  /**   
   * 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
コード例 #18
0
ファイル: Main.java プロジェクト: ai-se/SPL
  /** @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();
    }
  }
コード例 #19
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);
  }