Beispiel #1
0
  /** This method will optimize */
  @Override
  public void optimize() {
    AbstractEAIndividual indy;
    Population original = (Population) this.population.clone();
    double[] fitness;

    for (int i = 0; i < this.population.size(); i++) {
      indy = this.population.get(i);
      double tmpD = indy.getMutationProbability();
      indy.setMutationProbability(1.0);
      indy.mutate();
      indy.setMutationProbability(tmpD);
    }
    this.optimizationProblem.evaluate(this.population);
    for (int i = 0; i < this.population.size(); i++) {
      fitness = this.population.get(i).getFitness();
      if (fitness[0] > this.currentFloodPeak) {
        this.population.remove(i);
        this.population.add(i, original.get(i));
      }
    }
    this.currentFloodPeak -= this.drainRate;
    this.population.incrGeneration();
    this.firePropertyChangedEvent(Population.NEXT_GENERATION_PERFORMED);
  }
Beispiel #2
0
 /**
  * This method return the currently selected populations
  *
  * @return the selected populations
  */
 public Population getSelectedPopulations() {
   Population result = new Population();
   for (int i = 0; i < this.populationHistory.length; i++) {
     if (this.use[i]) {
       result.addPopulation(this.populationHistory[i]);
     }
   }
   this.currentProblem.evaluate(result);
   return result;
 }
Beispiel #3
0
 /**
  * Initializes the CMA parameter set for given mu, lambda and a population. The initialSigma
  * parameter is used as initial sigma directly unless it is <0, in that case the average range is
  * used as initial sigma. The parameter instance is also added as listener to the population.
  *
  * @param params the CMA parameter set to be used - its data are overwritten
  * @param mu ES mu parameter
  * @param lambda ES lambda parameter
  * @param pop associated Population
  * @param initialSigma initial sigma or -1 to indicate the usage of average range
  * @return
  */
 public static CMAParamSet initCMAParams(
     CMAParamSet params, int mu, int lambda, Population pop, double initialSigma) {
   initCMAParams(
       params,
       mu,
       lambda,
       pop.getBestEAIndividual().getDoublePosition(),
       ((InterfaceDataTypeDouble) pop.getEAIndividual(0)).getDoubleRange(),
       initialSigma);
   pop.addPopulationChangedEventListener(params);
   return params;
 }
Beispiel #4
0
 @Override
 public void stopOptimizationPerformed(boolean normal, String stopMessage) {
   this.currentRun.put("stopMessage", stopMessage);
   this.currentRun.put(
       "totalFunctionCalls",
       this.currentParameters.getOptimizer().getPopulation().getFunctionCalls());
   // ToDo: Figure out a sane way to do this. Having multirun > 1 increases SnakeYAML memory
   // consumption to beyond infinity
   // this.currentRun.put("generations", currentGenerations);
   Population pop = this.currentParameters.getOptimizer().getAllSolutions().getSolutions();
   this.currentRun.put("solution", pop.getBestEAIndividual().getDoublePosition().clone());
   this.currentRun.put("bestFitness", pop.getBestFitness().clone());
   this.currentRun.put("meanFitness", pop.getMeanFitness().clone());
   this.runs.add(currentRun);
 }
  /**
   * This method allows an optimizer to register a change in the optimizer.
   *
   * @param source The source of the event.
   * @param name Could be used to indicate the nature of the event.
   */
  @Override
  public void registerPopulationStateChanged(Object source, String name) {
    if (name.equals(Population.NEXT_GENERATION_PERFORMED)) {
      Population population = ((InterfaceOptimizer) source).getPopulation();
      double x = 100 / this.multiRuns;
      if (this.optimizationParameters.getTerminator() instanceof EvaluationTerminator) {
        double y =
            x
                / (double)
                    ((EvaluationTerminator) this.optimizationParameters.getTerminator())
                        .getFitnessCalls();
        currentProgress = (int) (this.currentRun * x + population.getFunctionCalls() * y);
      } else {
        currentProgress = (int) (this.currentRun * x);
      }
      updateStatus(currentProgress);

      // data to be stored in file
      double tmpd = 0;
      StringBuilder tmpLine = new StringBuilder("");
      tmpLine.append(population.getFunctionCalls());
      tmpLine.append("\t");
      tmpLine.append(population.getBestEAIndividual().getFitness(0));
      tmpLine.append("\t");
      for (int i = 0; i < population.size(); i++) {
        tmpd += population.get(i).getFitness(0) / (double) population.size();
      }
      tmpLine.append("\t");
      tmpLine.append(tmpd);
      tmpLine.append("\t");
      tmpLine.append(population.getWorstEAIndividual().getFitness(0));
      // tmpLine.append("\t");
      // tmpLine.append(this.optimizationParameters.getProblem().getAdditionalDataValue(population));
      this.writeToFile(tmpLine.toString());

      Double[] tmpData = new Double[2];
      tmpData[0] = (double) population.getFunctionCalls();
      // instead of adding simply the best fitness value i'll ask the problem what to show
      tmpData[1] = this.optimizationParameters.getProblem().getDoublePlotValue(population);
      if (this.plot != null) {
        if (this.continueFlag) {
          this.plot.setConnectedPoint(
              tmpData[0] + this.recentFunctionCalls, tmpData[1], 1000 + this.currentRun);
        } else {
          this.plot.setConnectedPoint(tmpData[0], tmpData[1], 1000 + this.currentRun);
        }
      }
      this.tmpData.add(tmpData);
    }
  }
 @Override
 public void actionPerformed(ActionEvent event) {
   JFrame frame = new JFrame();
   frame.setTitle(
       "The current best solution for " + optimizationParameters.getProblem().getName());
   frame.setSize(400, 300);
   frame.setLocation(450, 250);
   Population pop = optimizationParameters.getOptimizer().getPopulation();
   frame
       .getContentPane()
       .add(
           optimizationParameters
               .getProblem()
               .drawIndividual(
                   pop.getGeneration(), pop.getFunctionCalls(), pop.getBestEAIndividual()));
   frame.validate();
   frame.setVisible(true);
 }
 @Override
 public void initializeByPopulation(Population pop, boolean reset) {
   this.setPopulation((Population) pop.clone());
   if (reset) {
     this.getPopulation().initialize();
     this.optimizationProblem.evaluate(this.getPopulation());
     this.firePropertyChangedEvent(Population.NEXT_GENERATION_PERFORMED);
   }
 }
Beispiel #8
0
  public void addPopulation2History(Population pop) {
    InterfaceOptimizationObjective[] tmpObj = null;

    if (this.show == null) {
      this.use = new boolean[1];
      this.use[0] = true;
      this.show = new boolean[1];
      this.show[0] = true;
      this.colors = new Color[1];
      this.colors[0] = this.getColor4Index(0);
    } else {
      boolean[] newUse = new boolean[this.show.length + 1];
      boolean[] newShow = new boolean[this.show.length + 1];
      Color[] newColor = new Color[this.show.length + 1];
      for (int i = 0; i < this.show.length; i++) {
        newUse[i] = this.use[i];
        newShow[i] = this.show[i];
        newColor[i] = this.colors[i];
      }
      newUse[show.length] = true;
      newShow[show.length] = true;
      newColor[show.length] = this.getColor4Index(this.populationHistory.length);
      this.use = newUse;
      this.show = newShow;
      this.colors = newColor;
    }

    Population[] newPop = new Population[this.populationHistory.length + 1];
    System.arraycopy(this.populationHistory, 0, newPop, 0, this.populationHistory.length);
    newPop[newPop.length - 1] = (Population) pop.clone();
    newPop[newPop.length - 1].addPopulation(newPop[newPop.length - 1].getArchive());
    newPop[newPop.length - 1].SetArchive(null);
    this.populationHistory = newPop;
    ArrayList fitness = new ArrayList();
    ArrayList objectives = new ArrayList();
    ArrayList constraint = new ArrayList();
    if (this.currentProblem instanceof InterfaceMultiObjectiveDeNovoProblem) {
      tmpObj = ((InterfaceMultiObjectiveDeNovoProblem) this.currentProblem).getProblemObjectives();
    }
    for (int j = 0; j < newPop[newPop.length - 1].size(); j++) {
      if (tmpObj != null) {
        double[] tmoF = new double[tmpObj.length];
        for (int k = 0; k < tmpObj.length; k++) {
          tmoF[k] = (Double) newPop[newPop.length - 1].get(j).getData(tmpObj[k].getIdentName());
        }
        objectives.add(tmoF);
      }
      fitness.add(newPop[newPop.length - 1].get(j).getFitness());
      constraint.add(newPop[newPop.length - 1].get(j).getConstraintViolation());
    }
    if (this.objectiveCache != null) {
      this.objectiveCache.add(objectives);
    }
    this.fitnessCache.add(fitness);
    this.constraintCache.add(constraint);
  }
Beispiel #9
0
 /**
  * This method will initialize the optimizer with a given population
  *
  * @param reset If true the population is reset.
  */
 @Override
 public void initializeByPopulation(Population pop, boolean reset) {
   this.population = (Population) pop.clone();
   if (reset) {
     this.population.initialize();
     this.optimizationProblem.evaluate(this.population);
     this.firePropertyChangedEvent(Population.NEXT_GENERATION_PERFORMED);
   }
   this.currentFloodPeak = this.initialFloodPeak;
 }
Beispiel #10
0
 /**
  * This method allows an optimizer to register a change in the optimizer.
  *
  * @param source The source of the event.
  * @param name Could be used to indicate the nature of the event.
  */
 @Override
 public void registerPopulationStateChanged(Object source, String name) {
   int currentProgress;
   if (name.equals(Population.NEXT_GENERATION_PERFORMED)) {
     if (this.state.isVisible) {
       Population population = ((InterfaceOptimizer) source).getPopulation();
       double x = 100;
       if (this.state.terminator instanceof EvaluationTerminator) {
         double y = x / (double) ((EvaluationTerminator) this.state.terminator).getFitnessCalls();
         currentProgress = (int) (population.getFunctionCalls() * y);
       } else {
         currentProgress = 0;
       }
       updateStatus("Optimizing...", currentProgress);
     } else {
       // perhaps i could write it to file!?
     }
   }
 }
  /**
   * The subswarm is deactivated and the particles indices are returned. They are to be
   * reinitialized into the mainswarm.
   */
  @Override
  public int[] deactivateSubswarm(
      ParticleSubSwarmOptimization subswarm, ParticleSubSwarmOptimization mainswarm) {
    if (!subswarm.isActive()) {
      System.out.println("deactivateSubSwarm: try to deactivate inactive subswarm");
      return null;
    }

    // use the indizes of the deactivated particles for the reinitialized particles (important for
    // ANPSO)
    Population pop = subswarm.getPopulation();
    int[] particleIndices = new int[pop.size()];
    for (int i = 0; i < pop.size(); ++i) {
      AbstractEAIndividual indy = pop.getEAIndividual(i);
      // Integer index = (Integer)indy.getData("particleIndex");
      particleIndices[i] = indy.getIndividualIndex(); // index.intValue();
    }
    subswarm.SetActive(false);
    return particleIndices;
  }
 public boolean isConverged(Population pop) {
   Vector<Double> bests = (Vector<Double>) pop.getEAIndividual(0).getData(NichePSO.fitArchiveKey);
   if (bests.size() < haltingWindow) {
     return false;
   } else {
     List<Double> lst = bests.subList(bests.size() - haltingWindow, bests.size());
     bests = new Vector<>(haltingWindow);
     bests.addAll(lst);
     for (int i = 1; i < pop.size(); i++) {
       for (int k = 0; k < haltingWindow; k++) {
         Vector<Double> fitArch =
             (Vector<Double>) pop.getEAIndividual(i).getData(NichePSO.fitArchiveKey);
         int archIndex =
             fitArch.size()
                 - haltingWindow
                 + k; // index within the fitness archive of the current particle, which may be
                      // larger than the bests list - the tail is important
         if (archIndex >= 0 && (fitArch.get(archIndex) < bests.get(k))) {
           bests.set(k, fitArch.get(archIndex));
         }
       }
     }
   }
   // bests contains now the sequence of best fitness values across the last generations
   Double historicHWAgo = bests.get(0);
   boolean res = true;
   for (int i = 1; i < haltingWindow; i++) {
     // if historic[-hW] is worse than historic[-hW+i] return false
     Double historicIter = bests.get(i);
     // if the iterated value (the later one in history) has improved, there is no convergence.
     boolean improvementHappened =
         (historicIter < historicHWAgo); // testSecondForImprovement(historicHWAgo, historicIter));
     if (improvementHappened) {
       res = false;
       break;
     }
   }
   return res;
 }
Beispiel #13
0
  /**
   * Make sure that the parameter sets of each population are updated (reinitialized) if a
   * population is reinitialized.
   *
   * @see InterfacePopulationChangedEventListener
   */
  @Override
  public void registerPopulationStateChanged(Object source, String name) {
    if (name.equals(Population.POPULATION_INITIALIZED)) {
      Population pop = (Population) source;

      CMAParamSet params = (CMAParamSet) (pop.getData(MutateESRankMuCMA.cmaParamsKey));
      int mu;
      if (pop.hasData(EvolutionStrategies.esMuParam)) {
        mu = (Integer) pop.getData(EvolutionStrategies.esMuParam);
      } else {
        System.err.println("Unknown mu in reinit! using lambda/2...");
        mu = pop.size() / 2;
      }
      pop.putData(
          MutateESRankMuCMA.cmaParamsKey,
          CMAParamSet.initCMAParams(params, mu, pop.size(), pop, params.firstSigma));
    }
  }
Beispiel #14
0
 /**
  * This method takes a population of individuals with an array of fitness values and calculates a
  * single fitness value to replace the former fitness array. Please note: The orignal fitness
  * values are lost this way, so please use the individual.setData() method if you still want to
  * access the original fitness values.
  *
  * @param pop The population to process.
  */
 @Override
 public void convertMultiObjective2SingleObjective(Population pop) {
   for (int i = 0; i < pop.size(); i++) {
     this.convertSingleIndividual(pop.get(i));
   }
 }
Beispiel #15
0
 /**
  * This method establishes a fitness cache to give the plot methods easier and faster access to
  * the data
  *
  * @param reevaluate
  */
 public void makeFitnessCache(boolean reevaluate) {
   InterfaceOptimizationObjective[] tmpObj = null;
   if (reevaluate) {
     // clear all archives, since problem dimension may have changed
     for (int i = 0; i < this.populationHistory.length; i++) {
       if (this.populationHistory[i].getArchive() != null) {
         this.populationHistory[i].addPopulation(this.populationHistory[i].getArchive());
         this.populationHistory[i].SetArchive(null);
       }
     }
     Population pop = this.optimizer.getPopulation();
     if (pop.getArchive() != null) {
       pop.addPopulation(pop.getArchive());
       pop.SetArchive(null);
     }
     this.currentProblem.evaluate(pop);
   }
   this.fitnessCache = new ArrayList();
   this.objectiveCache = null;
   this.constraintCache = new ArrayList();
   if (this.currentProblem instanceof InterfaceMultiObjectiveDeNovoProblem) {
     this.objectiveCache = new ArrayList();
     tmpObj = ((InterfaceMultiObjectiveDeNovoProblem) this.currentProblem).getProblemObjectives();
   }
   this.paretoFront = new Population();
   for (int i = 0; i < this.populationHistory.length; i++) {
     if (reevaluate) {
       ((AbstractMultiObjectiveOptimizationProblem) this.currentProblem).resetParetoFront();
       this.currentProblem.evaluate(this.populationHistory[i]);
     }
     this.paretoFront.addPopulation(this.populationHistory[i]);
     ArrayList fitness = new ArrayList();
     ArrayList objectives = new ArrayList();
     ArrayList constraint = new ArrayList();
     for (int j = 0; j < this.populationHistory[i].size(); j++) {
       if (tmpObj != null) {
         double[] tmoF = new double[tmpObj.length];
         for (int k = 0; k < tmpObj.length; k++) {
           if (this.populationHistory[i].get(j) == null) {
             System.out.println("Individual " + i + " == null!");
           }
           if (tmpObj[k] == null) {
             System.out.println("Objective " + k + " == null!");
           }
           if (this.populationHistory[i].get(j).getData(tmpObj[k].getIdentName()) == null) {
             System.out.println("User Data " + k + " " + tmpObj[k].getIdentName() + " == null!");
           }
           tmoF[k] = (Double) this.populationHistory[i].get(j).getData(tmpObj[k].getIdentName());
         }
         objectives.add(tmoF);
       }
       fitness.add(this.populationHistory[i].get(j).getFitness());
       constraint.add(this.populationHistory[i].get(j).getConstraintViolation());
     }
     if (this.objectiveCache != null) {
       this.objectiveCache.add(objectives);
     }
     this.fitnessCache.add(fitness);
     this.constraintCache.add(constraint);
   }
   ArchivingAllDominating arch = new ArchivingAllDominating();
   arch.addElementsToArchive(this.paretoFront);
   this.paretoFront = this.paretoFront.getArchive();
   this.paretoFront.SetArchive(null);
 }
Beispiel #16
0
 public void MOCCOOptimization() {
   boolean cont = true;
   InterfaceProcessElement tmpP;
   while (cont) {
     this.iteration++;
     while (stillWorking) {
       try {
         Thread.sleep(1000);
       } catch (java.lang.InterruptedException e) {
       }
     }
     if (this.state.originalProblem == null) {
       this.state.originalProblem = new TF1Problem();
       tmpP = new MOCCOProblemInitialization(this);
       tmpP.initProcessElementParametrization();
       while (!tmpP.isFinished()) {
         try {
           Thread.sleep(1000);
         } catch (java.lang.InterruptedException e) {
         }
       }
       this.state.currentProblem =
           (InterfaceOptimizationProblem) this.state.originalProblem.clone();
       this.view.problemChanged(true);
       this.parameterPanel.removeAll();
       tmpP = new MOCCOInitialPopulationSize(this);
       tmpP.initProcessElementParametrization();
       while (!tmpP.isFinished()) {
         try {
           Thread.sleep(1000);
         } catch (java.lang.InterruptedException e) {
         }
       }
       this.state.initialPopulationSize = Math.max(1, this.state.initialPopulationSize);
       Population pop = new Population();
       pop.setTargetSize(this.state.initialPopulationSize);
       this.state.currentProblem =
           (InterfaceOptimizationProblem) this.state.originalProblem.clone();
       this.state.currentProblem.initializePopulation(pop);
       this.state.currentProblem.evaluate(pop);
       this.state.addPopulation2History(pop);
       this.view.problemChanged(true);
     }
     ((InterfaceMultiObjectiveDeNovoProblem) this.state.currentProblem)
         .deactivateRepresentationEdit();
     this.updateStatus("Analysis/Redefinition", 33);
     tmpP = new MOCCOProblemRedefinition(this);
     tmpP.initProcessElementParametrization();
     while (!tmpP.isFinished()) {
       try {
         Thread.sleep(1000);
       } catch (java.lang.InterruptedException e) {
       }
     }
     this.state.makeFitnessCache(true);
     this.state.currentProblem.initializeProblem();
     this.state.makeBackup();
     this.view.problemChanged(true);
     if (this.state.currentProblem.isMultiObjective()) {
       this.updateStatus("MO Strategy Selection", 50);
       tmpP = new MOCCOChooseMOStrategy(this);
       tmpP.initProcessElementParametrization();
       while (!tmpP.isFinished()) {
         try {
           Thread.sleep(1000);
         } catch (java.lang.InterruptedException e) {
         }
       }
       switch (((MOCCOChooseMOStrategy) tmpP).getMOStrategy()) {
         case MOCCOChooseMOStrategy.STRATEGY_MOEA:
           {
             this.updateStatus("MOEA Parameterization", 75);
             tmpP = new MOCCOParameterizeMO(this);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             break;
           }
         case MOCCOChooseMOStrategy.STRATEGY_STEP:
           {
             this.updateStatus("Reference Solution...", 75);
             tmpP = new MOCCOChooseReferenceSolution(this);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             AbstractEAIndividual reference =
                 ((MOCCOChooseReferenceSolution) tmpP).getReferenceSolution();
             this.updateStatus("STEP Parameterization...", 90);
             tmpP = new MOCCOParameterizeSTEP(this);
             ((MOCCOParameterizeSTEP) tmpP).setReferenceSolution(reference);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             break;
           }
         case MOCCOChooseMOStrategy.STRATEGY_REFP:
           {
             this.updateStatus("Reference Point...", 75);
             tmpP = new MOCCOChooseReferencePoint(this);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             double[] reference = ((MOCCOChooseReferencePoint) tmpP).getReferencePoint();
             this.updateStatus("Reference Point Parameterization...", 90);
             tmpP = new MOCCOParameterizeRefPoint(this);
             ((MOCCOParameterizeRefPoint) tmpP).setReferencePoint(reference);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             break;
           }
         case MOCCOChooseMOStrategy.STRATEGY_TBCH:
           {
             this.updateStatus("Reference Point...", 75);
             tmpP = new MOCCOChooseReferencePoint(this);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             double[] reference = ((MOCCOChooseReferencePoint) tmpP).getReferencePoint();
             this.updateStatus("Tchebycheff Method Parameterization...", 90);
             tmpP = new MOCCOParameterizeTchebycheff(this);
             ((MOCCOParameterizeTchebycheff) tmpP).setReferencePoint(reference);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             break;
           }
         case MOCCOChooseMOStrategy.STRATEGY_GDF:
           {
             this.updateStatus("Reference Solution...", 75);
             tmpP = new MOCCOChooseReferenceSolution(this);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             AbstractEAIndividual reference =
                 ((MOCCOChooseReferenceSolution) tmpP).getReferenceSolution();
             this.updateStatus("Geoffrion-Dyer-Feinberg Method Parameterization...", 90);
             tmpP = new MOCCOParameterizeGDF(this);
             ((MOCCOParameterizeGDF) tmpP).setReferenceSolution(reference);
             tmpP.initProcessElementParametrization();
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             break;
           }
         default:
           {
             tmpP = new MOCCOParameterizeMO(this);
             while (!tmpP.isFinished()) {
               try {
                 Thread.sleep(1000);
               } catch (java.lang.InterruptedException e) {
               }
             }
             break;
           }
       }
     } else {
       this.updateStatus("SO-Optimizer Parameterization", 66);
       tmpP = new MOCCOParameterizeSO(this);
       tmpP.initProcessElementParametrization();
       while (!tmpP.isFinished()) {
         try {
           Thread.sleep(1000);
         } catch (java.lang.InterruptedException e) {
         }
       }
     }
     // now optimize
     this.updateStatus("Optimizing...", 0);
     this.startExperiment();
   }
 }