コード例 #1
0
  public Individual[] run(
      StopCondition cond,
      FitnessFunction fitness,
      SelectionAlgorithm[] selector,
      GenerationAlgorithm generator,
      ReplaceAlgorithm replacer,
      int lambda) {

    int t = 0;

    double prob[] = new double[selector.length];

    for (int i = 0; i < prob.length; i++) {
      prob[i] = 1 / prob.length;
    }

    Individual parents[] = fitness.initialize(lambda);

    double mini = minimize ? Double.MAX_VALUE : Double.MIN_VALUE;

    double better = minimize ? Double.MAX_VALUE : Double.MIN_VALUE;

    for (int i = 0; i < parents.length; i++) {
      double fit = fitness.fitness(parents[i]);
      if (minimize) {
        if (better > fit) {
          better = fit;
        }
      } else {
        if (better < fit) {
          better = fit;
        }
      }
    }

    double previous = better;

    boolean first = true;
    boolean second = true;
    ArrayList<Double> values = new ArrayList<Double>();

    ArrayList<Double> minis = new ArrayList<Double>();
    ArrayList<Double> maxis = new ArrayList<Double>();
    ArrayList<Double> promis = new ArrayList<Double>();
    ArrayList<Double> desvis = new ArrayList<Double>();

    while (!cond.stop(parents, fitness, t)) {
      for (int l = 0; l < lambda; l += 2) {
        Individual[] marriage = new Individual[2];
        marriage[0] = parents[StdRandom.uniform(lambda)];
        marriage[1] = parents[StdRandom.uniform(lambda)];
        marriage = generator.generate(marriage, fitness, minimize);
        parents[l] = marriage[0];
        if (l + 1 < lambda) {
          parents[l + 1] = marriage[1];
        }
      }
      double rnd = StdRandom.uniform(0.0, 1.0);
      double sum = 0.0;
      SelectionAlgorithm sel = selector[selector.length - 1];
      int index = selector.length - 1;
      for (int i = 0; i < prob.length; i++) {
        if ((sum += prob[i]) >= rnd) {
          sel = selector[i];
          index = i;
          break;
        }
      }
      parents = sel.selection(parents, fitness, minimize);

      double prom = 0.0;
      better = minimize ? Double.MAX_VALUE : Double.MIN_VALUE;

      for (int i = 0; i < parents.length; i++) {
        double fit = fitness.fitness(parents[i]);
        values.add(fit);
        prom += fit;
        if (minimize) {
          if (better > fit) {
            better = fit;
          }
        } else {
          if (better < fit) {
            better = fit;
          }
        }
      }
      prom /= parents.length;
      if (prom != mini) {

        prob[index] +=
            minimize && prom < mini
                ? (1 - prob[index]) / prob.length
                : (-1 * prob[index]) / prob.length;

        for (int i = 0; i < prob.length; i++) {
          if (i != index) {
            prob[i] +=
                minimize && prom < mini
                    ? -1 * (1 - prob[index]) / (prob.length * (prob.length - 1))
                    : (prob[index]) / (prob.length * (prob.length - 1));
          }
        }

        mini = minimize && prom < mini ? prom : mini;
        mini = !minimize && prom > mini ? prom : mini;
      }

      if (Math.abs(previous - better) < StdRandom.uniform(0.0, 1)) {

        for (int i = 0; i < parents.length; i++) {
          double par[] = parents[i].getParameters();
          par[Individual.DELTA] += StdRandom.uniform(0.5, fitness.getConstraintMax() * 2);
          parents[i].setParameters(par);
        }
      } else if (Math.abs(previous - better) > StdRandom.uniform(100, 10000)) {
        for (int i = 0; i < parents.length; i++) {
          double par[] = parents[i].getParameters();
          if (par[Individual.DELTA] > 0) {
            par[Individual.DELTA] -= StdRandom.uniform(0, par[Individual.DELTA] / 2);
          }

          parents[i].setParameters(par);
        }
      }

      previous = better;

      t++;

      if (fitness.callsNumber() >= 120000 && first) {
        first = false;
        Statistics.run(values, fitness, minimize);
      }
      if (fitness.callsNumber() >= 600000 && second) {
        second = false;
        Statistics.run(values, fitness, minimize);
      }

      double min = Double.MAX_VALUE;
      double max = Double.MIN_VALUE;
      double desEst = 0;
      double prome = 0;

      for (int i = 0; i < parents.length; i++) {
        double fit = fitness.fitness(parents[i]);
        values.add(fit);
        if (fit < min) {
          min = fit;
        }
        if (fit > max) {
          max = fit;
        }
        prome += fit;
      }
      prome /= parents.length;

      for (int i = 0; i < parents.length; i++) {
        double fit = fitness.fitness(parents[i]);
        desEst = (fit - prome) * (fit - prome);
      }
      desEst /= parents.length - 1;

      minis.add(min);
      maxis.add(max);
      promis.add(prome);
      desvis.add(desEst);
      System.out.println(min);
    }
    Statistics.run(values, fitness, minimize);

    System.out.println("ITER;MIN;MAX;PROM;D.EST");
    for (int i = 0; i < minis.size(); i++) {
      System.out.print((i + 1) + ";");
      System.out.print(minis.get(i) + ";");
      System.out.print(maxis.get(i) + ";");
      System.out.print(promis.get(i) + ";");
      System.out.println(desvis.get(i));
    }

    return parents;
  }
コード例 #2
0
  @Override
  public Individual[] run(
      StopCondition T,
      FitnessFunction f,
      SelectionAlgorithm selector,
      GenerationAlgorithm generator,
      ReplaceAlgorithm replacer,
      int lambda) {

    int t = 0;
    Individual[] P = f.initialize(lambda);

    boolean first = true;
    boolean second = true;
    ArrayList<Double> values = new ArrayList<Double>();

    ArrayList<Double> minis = new ArrayList<Double>();
    ArrayList<Double> maxis = new ArrayList<Double>();
    ArrayList<Double> promis = new ArrayList<Double>();
    ArrayList<Double> desvis = new ArrayList<Double>();

    while (!T.stop(P, f, t)) {
      Individual Q[] =
          selector.selection(
              P, f,
              minimize); // lambda-individuos, seleccion por ruleta, torneo, ranqueo o USS ->
                         // repetir lambda veces
      Individual H[] = generator.generate(Q, f, minimize); // generar lambda-individuos:
      // 1. se hacen parejas
      // se hace cruce si cumple probabilidad P=0.6 para cada hijo
      // se hace una mutacion si cumple probabilidad por cada bit P = 1/len(cromosoma) para cada
      // hijo
      // se ponen en H
      P = replacer.replace(P, H);

      double min = Double.MAX_VALUE;
      double max = Double.MIN_VALUE;
      double desEst = 0;
      double prom = 0;

      for (int i = 0; i < P.length; i++) {
        double fit = f.fitness(P[i]);
        values.add(fit);
        if (fit < min) {
          min = fit;
        }
        if (fit > max) {
          max = fit;
        }
        prom += fit;
      }
      prom /= P.length;

      for (int i = 0; i < P.length; i++) {
        double fit = f.fitness(P[i]);
        desEst = (fit - prom) * (fit - prom);
      }
      desEst /= P.length - 1;

      minis.add(min);
      maxis.add(max);
      promis.add(prom);
      desvis.add(desEst);

      System.out.println(min);

      if (f.callsNumber() >= 120000 && first) {
        first = false;
        Statistics.run(values, f, minimize);
      }
      if (f.callsNumber() >= 600000 && second) {
        second = false;
        Statistics.run(values, f, minimize);
      }

      t++;
    }
    Statistics.run(values, f, minimize);
    System.out.println("ITER;MIN;MAX;PROM;D.EST");
    for (int i = 0; i < minis.size(); i++) {
      System.out.print((i + 1) + ";");
      System.out.print(minis.get(i) + ";");
      System.out.print(maxis.get(i) + ";");
      System.out.print(promis.get(i) + ";");
      System.out.println(desvis.get(i));
    }

    return P;
  }