297 lines
11 KiB
Java
297 lines
11 KiB
Java
package javaeva.server.go.strategies;
|
|
|
|
import javaeva.server.go.InterfacePopulationChangedEventListener;
|
|
import javaeva.server.go.individuals.AbstractEAIndividual;
|
|
import javaeva.server.go.operators.selection.InterfaceSelection;
|
|
import javaeva.server.go.operators.selection.SelectBestIndividuals;
|
|
import javaeva.server.go.populations.PBILPopulation;
|
|
import javaeva.server.go.populations.Population;
|
|
import javaeva.server.go.problems.B1Problem;
|
|
import javaeva.server.go.problems.InterfaceOptimizationProblem;
|
|
|
|
/** Population based increamental learning in the PSM by Mommarche
|
|
* version with also allows to simulate ant systems due to the flexible
|
|
* update rule of V. But both are limited to binary gentypes.
|
|
* This is a simple implementation of Population Based Incremental Learning.
|
|
* Copyright: Copyright (c) 2003
|
|
* Company: University of Tuebingen, Computer Architecture
|
|
* @author Felix Streichert
|
|
* @version: $Revision: 307 $
|
|
* $Date: 2007-12-04 14:31:47 +0100 (Tue, 04 Dec 2007) $
|
|
* $Author: mkron $
|
|
*/
|
|
|
|
public class PopulationBasedIncrementalLearning implements InterfaceOptimizer, java.io.Serializable {
|
|
|
|
// These variables are necessary for the simple testcase
|
|
private InterfaceOptimizationProblem m_Problem = new B1Problem();
|
|
private boolean m_UseElitism = true;
|
|
private InterfaceSelection m_SelectionOperator = new SelectBestIndividuals();
|
|
transient private String m_Identifier = "";
|
|
transient private InterfacePopulationChangedEventListener m_Listener;
|
|
private Population m_Population = new PBILPopulation();
|
|
private double m_LearningRate = 0.04;
|
|
private double m_MutationRate = 0.5;
|
|
private double m_MutateSigma = 0.01;
|
|
private int m_NumberOfPositiveSamples = 1;
|
|
|
|
public PopulationBasedIncrementalLearning() {
|
|
}
|
|
|
|
public PopulationBasedIncrementalLearning(PopulationBasedIncrementalLearning a) {
|
|
this.m_Population = (Population)a.m_Population.clone();
|
|
this.m_Problem = (InterfaceOptimizationProblem)a.m_Problem.clone();
|
|
this.m_LearningRate = a.m_LearningRate;
|
|
this.m_MutationRate = a.m_MutationRate;
|
|
this.m_MutateSigma = a.m_MutateSigma;
|
|
this.m_NumberOfPositiveSamples = a.m_NumberOfPositiveSamples;
|
|
this.m_UseElitism = a.m_UseElitism;
|
|
this.m_SelectionOperator = (InterfaceSelection)a.m_SelectionOperator.clone();
|
|
}
|
|
|
|
public Object clone() {
|
|
return (Object) new PopulationBasedIncrementalLearning(this);
|
|
}
|
|
|
|
public void init() {
|
|
this.m_Problem.initPopulation(this.m_Population);
|
|
this.evaluatePopulation(this.m_Population);
|
|
this.firePropertyChangedEvent("NextGenerationPerformed");
|
|
}
|
|
|
|
/** This method will init the optimizer with a given population
|
|
* @param pop The initial population
|
|
* @param reset If true the population is reset.
|
|
*/
|
|
public void initByPopulation(Population pop, boolean reset) {
|
|
this.m_Population = new PBILPopulation();
|
|
if (reset) this.m_Population.init();
|
|
this.m_Population.addPopulation((Population)pop.clone());
|
|
((PBILPopulation)this.m_Population).buildProbabilityVector();
|
|
this.evaluatePopulation(this.m_Population);
|
|
this.firePropertyChangedEvent("NextGenerationPerformed");
|
|
}
|
|
|
|
/** This method will evaluate the current population using the
|
|
* given problem.
|
|
* @param population The population that is to be evaluated
|
|
*/
|
|
private void evaluatePopulation(Population population) {
|
|
this.m_Problem.evaluate(population);
|
|
population.incrGeneration();
|
|
}
|
|
|
|
/** This method will generate the offspring population from the
|
|
* given population of evaluated individuals.
|
|
*/
|
|
private Population generateChildren() {
|
|
PBILPopulation result = (PBILPopulation)this.m_Population.clone();
|
|
Population examples;
|
|
|
|
// this.m_NormationOperator.computeSelectionProbability(this.m_Population, "Fitness");
|
|
//System.out.println("Population:"+this.m_Population.getSolutionRepresentationFor());
|
|
this.m_SelectionOperator.prepareSelection(this.m_Population);
|
|
examples = this.m_SelectionOperator.selectFrom(this.m_Population, this.m_NumberOfPositiveSamples);
|
|
//System.out.println("Parents:"+parents.getSolutionRepresentationFor());
|
|
result.learnFrom(examples, this.m_LearningRate);
|
|
result.mutateProbabilityVector(this.m_MutationRate, this.m_MutateSigma);
|
|
result.initPBIL();
|
|
return result;
|
|
}
|
|
|
|
public void optimize() {
|
|
Population nextGeneration;
|
|
AbstractEAIndividual elite;
|
|
|
|
nextGeneration = this.generateChildren();
|
|
this.evaluatePopulation(nextGeneration);
|
|
if (this.m_UseElitism) {
|
|
elite = this.m_Population.getBestEAIndividual();
|
|
this.m_Population = nextGeneration;
|
|
this.m_Population.add(0, elite);
|
|
} else {
|
|
this.m_Population = nextGeneration;
|
|
}
|
|
this.firePropertyChangedEvent("NextGenerationPerformed");
|
|
}
|
|
|
|
/** This method will set the problem that is to be optimized
|
|
* @param problem
|
|
*/
|
|
public void SetProblem (InterfaceOptimizationProblem problem) {
|
|
this.m_Problem = problem;
|
|
}
|
|
public InterfaceOptimizationProblem getProblem () {
|
|
return this.m_Problem;
|
|
}
|
|
|
|
/** This method allows you to add the LectureGUI as listener to the Optimizer
|
|
* @param ea
|
|
*/
|
|
public void addPopulationChangedEventListener(InterfacePopulationChangedEventListener ea) {
|
|
this.m_Listener = ea;
|
|
}
|
|
/** Something has changed
|
|
*/
|
|
protected void firePropertyChangedEvent (String name) {
|
|
if (this.m_Listener != null) this.m_Listener.registerPopulationStateChanged(this, name);
|
|
}
|
|
|
|
/** This method will return a string describing all properties of the optimizer
|
|
* and the applied methods.
|
|
* @return A descriptive string
|
|
*/
|
|
public String getStringRepresentation() {
|
|
String result = "";
|
|
result += "Population Based Incremental Learning:\n";
|
|
result += "Optimization Problem: ";
|
|
result += this.m_Problem.getStringRepresentationForProblem(this) +"\n";
|
|
result += this.m_Population.getStringRepresentation();
|
|
return result;
|
|
}
|
|
/** This method allows you to set an identifier for the algorithm
|
|
* @param name The indenifier
|
|
*/
|
|
public void SetIdentifier(String name) {
|
|
this.m_Identifier = name;
|
|
}
|
|
public String getIdentifier() {
|
|
return this.m_Identifier;
|
|
}
|
|
|
|
/** This method is required to free the memory on a RMIServer,
|
|
* but there is nothing to implement.
|
|
*/
|
|
public void freeWilly() {
|
|
|
|
}
|
|
/**********************************************************************************************************************
|
|
* These are for GUI
|
|
*/
|
|
/** This method returns a global info string
|
|
* @return description
|
|
*/
|
|
public String globalInfo() {
|
|
return "The Population based incremental learning is based on a statistical distribution of bit positions. Please note: This optimizer requires a binary genotype!";
|
|
}
|
|
/** This method will return a naming String
|
|
* @return The name of the algorithm
|
|
*/
|
|
public String getName() {
|
|
return "PBIL";
|
|
}
|
|
|
|
/** Assuming that all optimizer will store thier data in a population
|
|
* we will allow acess to this population to query to current state
|
|
* of the optimizer.
|
|
* @return The population of current solutions to a given problem.
|
|
*/
|
|
public Population getPopulation() {
|
|
return this.m_Population;
|
|
}
|
|
public void setPopulation(Population pop){
|
|
this.m_Population = pop;
|
|
}
|
|
public String populationTipText() {
|
|
return "Edit the properties of the PBIL population used.";
|
|
}
|
|
|
|
public Population getAllSolutions() {
|
|
return getPopulation();
|
|
}
|
|
// /** This method will set the normation method that is to be used.
|
|
// * @param normation
|
|
// */
|
|
// public void setNormationMethod (InterfaceNormation normation) {
|
|
// this.m_NormationOperator = normation;
|
|
// }
|
|
// public InterfaceNormation getNormationMethod () {
|
|
// return this.m_NormationOperator;
|
|
// }
|
|
// public String normationMethodTipText() {
|
|
// return "Select the normation method.";
|
|
// }
|
|
|
|
/** This method will set the selection method that is to be used
|
|
* @param selection
|
|
*/
|
|
public void setSelectionMethod(InterfaceSelection selection) {
|
|
this.m_SelectionOperator = selection;
|
|
}
|
|
public InterfaceSelection getSelectionMethod() {
|
|
return this.m_SelectionOperator;
|
|
}
|
|
public String selectionMethodTipText() {
|
|
return "Choose a selection method.";
|
|
}
|
|
|
|
/** This method will set the problem that is to be optimized
|
|
* @param elitism
|
|
*/
|
|
public void setElitism (boolean elitism) {
|
|
this.m_UseElitism = elitism;
|
|
}
|
|
public boolean getElitism() {
|
|
return this.m_UseElitism;
|
|
}
|
|
public String elitismTipText() {
|
|
return "Enable/disable elitism.";
|
|
}
|
|
|
|
/** This method will set the learning rate for PBIL
|
|
* @param LearningRate
|
|
*/
|
|
public void setLearningRate (double LearningRate) {
|
|
this.m_LearningRate = LearningRate;
|
|
if (this.m_LearningRate < 0) this.m_LearningRate = 0;
|
|
}
|
|
public double getLearningRate() {
|
|
return this.m_LearningRate;
|
|
}
|
|
public String learningRateTipText() {
|
|
return "The learing rate of PBIL.";
|
|
}
|
|
|
|
/** This method will set the mutation rate for PBIL
|
|
* @param m
|
|
*/
|
|
public void setMutationRate (double m) {
|
|
this.m_MutationRate = m;
|
|
if (this.m_MutationRate < 0) this.m_MutationRate = 0;
|
|
if (this.m_MutationRate > 1) this.m_MutationRate = 1;
|
|
}
|
|
public double getMutationRate() {
|
|
return this.m_MutationRate;
|
|
}
|
|
public String mutationRateTipText() {
|
|
return "The mutation rate of PBIL.";
|
|
}
|
|
|
|
/** This method will set the mutation sigma for PBIL
|
|
* @param m
|
|
*/
|
|
public void setMutateSigma (double m) {
|
|
this.m_MutateSigma = m;
|
|
if (this.m_MutateSigma < 0) this.m_MutateSigma = 0;
|
|
}
|
|
public double getMutateSigma() {
|
|
return this.m_MutateSigma;
|
|
}
|
|
public String mutateSigmaTipText() {
|
|
return "Set the sigma for the mutation of the probability vector.";
|
|
}
|
|
|
|
/** This method will set the number of positive samples for PBIL
|
|
* @param PositiveSamples
|
|
*/
|
|
public void setPositiveSamples (int PositiveSamples) {
|
|
this.m_NumberOfPositiveSamples = PositiveSamples;
|
|
if (this.m_NumberOfPositiveSamples < 1) this.m_NumberOfPositiveSamples = 1;
|
|
}
|
|
public int getPositiveSamples() {
|
|
return this.m_NumberOfPositiveSamples;
|
|
}
|
|
public String positiveSamplesTipText() {
|
|
return "The number of positive samples that update the PBIL vector.";
|
|
}
|
|
} |