예제 #1
0
  /**
   * Configure the MOCell algorithm with default parameter settings
   *
   * @return an algorithm object
   * @throws jmetal.util.JMException
   */
  public Algorithm configure() throws JMException {
    Algorithm algorithm;
    Operator selection = null; // Selection operator
    Operator crossover = null; // Crossover operator
    Operator mutation = null; // Mutation operator
    Operator localsearch = null; // LocalSearch operator

    QualityIndicator indicators;

    // Creating the problem: there are six MOCell variants
    // algorithm = new sMOCell1(problem_) ;
    // algorithm = new sMOCell2(problem_) ;
    // algorithm = new aMOCell1(problem_) ;
    // algorithm = new aMOCell2(problem_) ;
    // algorithm = new aMOCell3(problem_) ;
    // algorithm = new aMOCell4CTBT(problem_) ;
    algorithm = new aMOCell4(problem_);
    //    algorithm = new aMOCell2CTBT(problem_) ;

    // Algorithm parameters
    algorithm.setInputParameter("populationSize", populationSize_);
    algorithm.setInputParameter("maxEvaluations", maxEvaluations_);
    algorithm.setInputParameter("archiveSize", archiveSize_);
    algorithm.setInputParameter("feedBack", feedback_);

    //	algorithm.setInputParameter( "specialSolution"  , P_SPECIAL_SOLUTION );

    // Mutation and Crossover for Real codification
    crossover = CrossoverFactory.getCrossoverOperator(CROSSOVER);
    // crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover");
    crossover.setParameter("probability", crossoverProbability_);
    crossover.setParameter("distributionIndex", distributionIndexForCrossover_);

    mutation = MutationFactory.getMutationOperator(MUTATION);
    // mutation = MutationFactory.getMutationOperator("PolynomialMutation");
    mutation.setParameter("probability", mutationProbability_);
    //    mutation.setParameter( "rounds"             , (Integer) M_ROUNDS );
    mutation.setParameter("Problem", problem_);
    //	mutation.setParameter( "overloadPercentage" , M_OVERLOAD_PER     );
    //	mutation.setParameter( "Policy"             , M_POLICY           );
    //	mutation.setParameter( "Mode"               , M_MODE             );

    selection = SelectionFactory.getSelectionOperator(SELECTION);

    localsearch = LocalSearchFactory.getLocalSearchOperator(LOCAL_SEARCH);
    localsearch.setParameter("Problem", problem_);

    // Add the operators to the algorithm
    algorithm.addOperator("localsearch", localsearch);
    algorithm.addOperator("crossover", crossover);
    algorithm.addOperator("mutation", mutation);
    algorithm.addOperator("selection", selection);

    //   // Creating the indicator object
    //   if (! paretoFrontFile_.equals("")) {
    //      indicators = new QualityIndicator(problem_, paretoFrontFile_);
    //      algorithm.setInputParameter("indicators", indicators) ;
    //   } // if
    return algorithm;
  }
예제 #2
0
  /**
   * Configure the MOCell algorithm with default parameter settings
   *
   * @return an algorithm object
   * @throws jmetal.util.JMException
   */
  public Algorithm configure() throws JMException {
    Algorithm algorithm;
    Operator selection;
    Operator crossover;
    Operator mutation;

    QualityIndicator indicators;

    // Creating the problem: there are six MOCell variants
    // algorithm = new sMOCell1(problem_) ;
    // algorithm = new sMOCell2(problem_) ;
    // algorithm = new aMOCell1(problem_) ;
    // algorithm = new aMOCell2(problem_) ;
    // algorithm = new aMOCell3(problem_) ;
    algorithm = new sMOCell4CTBT(problem_);

    // Algorithm parameters
    algorithm.setInputParameter("populationSize", populationSize_);
    algorithm.setInputParameter("maxEvaluations", maxEvaluations_);
    algorithm.setInputParameter("archiveSize", archiveSize_);
    algorithm.setInputParameter("feedBack", feedback_);

    // Mutation and Crossover for Real codification
    crossover = CrossoverFactory.getCrossoverOperator("DPX");
    // crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover");
    crossover.setParameter("probability", crossoverProbability_);
    crossover.setParameter("distributionIndex", distributionIndexForCrossover_);

    mutation = MutationFactory.getMutationOperator("BinaryMutation");
    // mutation = MutationFactory.getMutationOperator("PolynomialMutation");
    mutation.setParameter("probability", mutationProbability_);
    mutation.setParameter("distributionIndex", distributionIndexForMutation_);

    // Selection Operator
    selection = SelectionFactory.getSelectionOperator("BinaryTournament");

    // Add the operators to the algorithm
    algorithm.addOperator("crossover", crossover);
    algorithm.addOperator("mutation", mutation);
    algorithm.addOperator("selection", selection);

    //   // Creating the indicator object
    //   if (! paretoFrontFile_.equals("")) {
    //      indicators = new QualityIndicator(problem_, paretoFrontFile_);
    //      algorithm.setInputParameter("indicators", indicators) ;
    //   } // if
    return algorithm;
  }
예제 #3
0
  public static void main(String[] args) throws JMException, ClassNotFoundException {
    Problem problem; // The problem to solve
    Algorithm algorithm; // The algorithm to use
    Operator crossover; // Crossover operator
    Operator mutation; // Mutation operator
    Operator selection; // Selection operator

    // int bits ; // Length of bit string in the OneMax problem

    // bits = 512 ;
    // problem = new OneMax(bits);

    problem = new Sphere("Real", 20);
    // problem = new Easom("Real") ;
    // problem = new Griewank("Real", 10) ;

    algorithm = new DE(problem); // Asynchronous cGA

    /* Algorithm parameters*/
    algorithm.setInputParameter("populationSize", 100);
    algorithm.setInputParameter("maxEvaluations", 1000000);

    // Crossover operator
    crossover = CrossoverFactory.getCrossoverOperator("DifferentialEvolutionCrossover");
    crossover.setParameter("CR", 0.1);
    crossover.setParameter("F", 0.5);
    crossover.setParameter("DE_VARIANT", "rand/1/bin");

    // Add the operators to the algorithm
    selection = SelectionFactory.getSelectionOperator("DifferentialEvolutionSelection");

    algorithm.addOperator("crossover", crossover);
    algorithm.addOperator("selection", selection);

    /* Execute the Algorithm */
    long initTime = System.currentTimeMillis();
    SolutionSet population = algorithm.execute();
    long estimatedTime = System.currentTimeMillis() - initTime;
    System.out.println("Total execution time: " + estimatedTime);

    /* Log messages */
    System.out.println("Objectives values have been writen to file FUN");
    population.printObjectivesToFile("FUN");
    System.out.println("Variables values have been writen to file VAR");
    population.printVariablesToFile("VAR");
  } // main
예제 #4
0
  /**
   * Configure method. Change the default configuration
   *
   * @param settings
   * @return A problem with the settings indicated as argument
   * @throws jmetal.util.JMException
   * @throws ClassNotFoundException
   */
  public final Algorithm configure(Properties settings)
      throws JMException, IllegalArgumentException, IllegalAccessException, ClassNotFoundException {

    if (settings != null) {

      Field[] fields = this.getClass().getFields();

      for (int i = 0; i < fields.length; i++) {
        if (fields[i].getName().endsWith("_")) { // it is a configuration field
          // The configuration field is an integer
          if (fields[i].getType().equals(int.class) || fields[i].getType().equals(Integer.class)) {

            int value =
                Integer.parseInt(
                    settings.getProperty(fields[i].getName(), "" + fields[i].getInt(this)));

            fields[i].setInt(this, value);
          } else if (fields[i].getType().equals(double.class)
              || fields[i].getType().equals(Double.class)) {
            // The configuration field is a double
            double value =
                Double.parseDouble(
                    settings.getProperty(fields[i].getName(), "" + fields[i].getDouble(this)));

            if (fields[i].getName().equals("mutationProbability_") && value == 0) {
              if ((problem_.getSolutionType().getClass()
                      == Class.forName("jmetal.base.solutionType.RealSolutionType"))
                  || (problem_.getSolutionType().getClass()
                      == Class.forName("jmetal.base.solutionType.ArrayRealSolutionType"))) {
                value = 1.0 / problem_.getNumberOfVariables();
              } else if (problem_.getSolutionType().getClass()
                      == Class.forName("jmetal.base.solutionType.BinarySolutionType")
                  || problem_.getSolutionType().getClass()
                      == Class.forName("jmetal.base.solutionType.BinaryRealSolutionType")) {
                int length = problem_.getNumberOfBits();

                value = 1.0 / length;
                System.out.println("La probabilidad es : " + value);
              } else {
                int length = 0;
                for (int j = 0; j < problem_.getNumberOfVariables(); j++) {
                  length += problem_.getLength(j);
                }
                value = 1.0 / length;
              }
              fields[i].setDouble(this, value);
            } // if
            else {
              fields[i].setDouble(this, value);
            }
          } else {
            Object value = settings.getProperty(fields[i].getName(), null);

            if (value != null) {
              if (fields[i].getType().equals(jmetal.base.operator.crossover.Crossover.class)) {
                Object value2 = CrossoverFactory.getCrossoverOperator((String) value, settings);
                value = value2;
              }

              if (fields[i].getType().equals(jmetal.base.operator.mutation.Mutation.class)) {
                Object value2 = MutationFactory.getMutationOperator((String) value, settings);
                value = value2;
              }

              fields[i].set(this, value);
            }
          }
        }
      } // for

      // At this point all the fields have been read from the properties
      // parameter. Those fields representing crossover and mutations should also
      // be initialized. However, there is still mandatory to configure them
      for (int i = 0; i < fields.length; i++) {
        if (fields[i].getType().equals(jmetal.base.operator.crossover.Crossover.class)
            || fields[i].getType().equals(jmetal.base.operator.mutation.Mutation.class)) {
          Operator operator = (Operator) fields[i].get(this);
          // This field stores a crossover operator
          String tmp = fields[i].getName();
          String aux = fields[i].getName().substring(0, tmp.length() - 1);

          for (int j = 0; j < fields.length; j++) {
            if (i != j) {
              if (fields[j].getName().startsWith(aux)) {
                // The field is a configuration parameter of the crossover
                tmp = fields[j].getName().substring(aux.length(), fields[j].getName().length() - 1);

                if ((fields[j].get(this) != null)) {
                  System.out.println(fields[j].getName());
                  if (fields[j].getType().equals(int.class)
                      || fields[j].getType().equals(Integer.class)) {
                    operator.setParameter(tmp, fields[j].getInt(this));
                  } else if (fields[j].getType().equals(double.class)
                      || fields[j].getType().equals(Double.class)) {
                    operator.setParameter(tmp, fields[j].getDouble(this));
                  }
                }
              }
            }
          }
        }
      }
      // At this point, we should compare if the pareto front have been added
      paretoFrontFile_ = settings.getProperty("paretoFrontFile_", "");
    }

    return configure();
  } // configure
예제 #5
0
  /**
   * @param args Command line arguments.
   * @throws JMException
   * @throws IOException
   * @throws SecurityException Usage: three choices - jmetal.metaheuristics.nsgaII.NSGAII_main -
   *     jmetal.metaheuristics.nsgaII.NSGAII_main problemName -
   *     jmetal.metaheuristics.nsgaII.NSGAII_main problemName paretoFrontFile
   */
  public static void main(String[] args) throws JMException, IOException, ClassNotFoundException {
    Problem problem; // The problem to solve
    Algorithm algorithm; // The algorithm to use
    Operator crossover; // Crossover operator
    Operator mutation; // Mutation operator
    Operator selection; // Selection operator

    QualityIndicator indicators; // Object to get quality indicators

    // Logger object and file to store log messages
    logger_ = Configuration.logger_;
    fileHandler_ = new FileHandler("IBEA.log");
    logger_.addHandler(fileHandler_);

    indicators = null;
    if (args.length == 1) {
      Object[] params = {"Real"};
      problem = (new ProblemFactory()).getProblem(args[0], params);
    } // if
    else if (args.length == 2) {
      Object[] params = {"Real"};
      problem = (new ProblemFactory()).getProblem(args[0], params);
      indicators = new QualityIndicator(problem, args[1]);
    } // if
    else { // Default problem
      problem = new Kursawe("Real", 3);
      // problem = new Kursawe("BinaryReal", 3);
      // problem = new Water("Real");
      // problem = new ZDT1("ArrayReal", 100);
      // problem = new ConstrEx("Real");
      // problem = new DTLZ1("Real");
      // problem = new OKA2("Real") ;
    } // else

    algorithm = new IBEA(problem);

    // Algorithm parameters
    algorithm.setInputParameter("populationSize", 100);
    algorithm.setInputParameter("archiveSize", 100);
    algorithm.setInputParameter("maxEvaluations", 25000);

    // Mutation and Crossover for Real codification
    crossover = CrossoverFactory.getCrossoverOperator("SBXCrossover");
    crossover.setParameter("probability", 1.0);
    crossover.setParameter("distribuitionIndex", 20.0);
    mutation = MutationFactory.getMutationOperator("PolynomialMutation");
    mutation.setParameter("probability", 1.0 / problem.getNumberOfVariables());
    mutation.setParameter("distributionIndex", 20.0);

    /* Mutation and Crossover Binary codification */
    /*
    crossover = CrossoverFactory.getCrossoverOperator("SinglePointCrossover");
    crossover.setParameter("probability",0.9);
    mutation = MutationFactory.getMutationOperator("BitFlipMutation");
    mutation.setParameter("probability",1.0/80);
    */

    /* Selection Operator */
    selection = new BinaryTournament(new FitnessComparator());
    // Add the operators to the algorithm
    algorithm.addOperator("crossover", crossover);
    algorithm.addOperator("mutation", mutation);
    algorithm.addOperator("selection", selection);

    // Execute the Algorithm
    long initTime = System.currentTimeMillis();
    SolutionSet population = algorithm.execute();
    long estimatedTime = System.currentTimeMillis() - initTime;

    // Print the results
    logger_.info("Total execution time: " + estimatedTime + "ms");
    logger_.info("Variables values have been writen to file VAR");
    population.printVariablesToFile("VAR");
    logger_.info("Objectives values have been writen to file FUN");
    population.printObjectivesToFile("FUN");

    if (indicators != null) {
      logger_.info("Quality indicators");
      logger_.info("Hypervolume: " + indicators.getHypervolume(population));
      logger_.info("GD         : " + indicators.getGD(population));
      logger_.info("IGD        : " + indicators.getIGD(population));
      logger_.info("Spread     : " + indicators.getSpread(population));
      logger_.info("Epsilon    : " + indicators.getEpsilon(population));
    } // if
  } // main