234 lines
9.1 KiB
Java
234 lines
9.1 KiB
Java
package javaeva.server.go.operators.mutation;
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import javaeva.gui.GenericObjectEditor;
|
|
import javaeva.server.go.individuals.AbstractEAIndividual;
|
|
import javaeva.server.go.populations.Population;
|
|
import javaeva.server.go.problems.InterfaceOptimizationProblem;
|
|
import javaeva.server.go.tools.RandomNumberGenerator;
|
|
|
|
/**
|
|
* Created by IntelliJ IDEA.
|
|
* User: streiche
|
|
* Date: 20.05.2005
|
|
* Time: 13:53:46
|
|
* To change this template use File | Settings | File Templates.
|
|
*/
|
|
public class MutateEAMixer implements InterfaceMutation, java.io.Serializable {
|
|
|
|
private PropertyMutationMixer m_Mutators;
|
|
private boolean m_UseSelfAdaption = false;
|
|
protected double m_Tau1 = 0.15;
|
|
protected double m_LowerLimitChance = 0.05;
|
|
|
|
public MutateEAMixer() {
|
|
InterfaceMutation[] tmpList;
|
|
ArrayList<String> mutators = GenericObjectEditor.getClassesFromProperties("javaeva.server.go.operators.mutation.InterfaceMutation");
|
|
tmpList = new InterfaceMutation[mutators.size()];
|
|
for (int i = 0; i < mutators.size(); i++) {
|
|
if (((String)mutators.get(i)).equals(this.getClass().getName())) continue;
|
|
try {
|
|
tmpList[i] = (InterfaceMutation)Class.forName((String)mutators.get(i)).newInstance();
|
|
} catch (java.lang.ClassNotFoundException e) {
|
|
System.out.println("Could not find class for " +(String)mutators.get(i) );
|
|
} catch (java.lang.InstantiationException k) {
|
|
System.out.println("Instantiation exception for " +(String)mutators.get(i) );
|
|
} catch (java.lang.IllegalAccessException a) {
|
|
System.out.println("Illegal access exception for " +(String)mutators.get(i) );
|
|
}
|
|
}
|
|
this.m_Mutators = new PropertyMutationMixer(tmpList);
|
|
tmpList = new InterfaceMutation[2];
|
|
tmpList[0] = new MutateGINominal();
|
|
tmpList[1] = new MutateGIOrdinal();
|
|
this.m_Mutators.setSelectedMutators(tmpList);
|
|
this.m_Mutators.normalizeWeights();
|
|
this.m_Mutators.setDescriptiveString("Combining alternative mutation operators, please norm the weights!");
|
|
this.m_Mutators.setWeightsLabel("Weigths");
|
|
|
|
}
|
|
public MutateEAMixer(MutateEAMixer mutator) {
|
|
this.m_Mutators = (PropertyMutationMixer)mutator.m_Mutators.clone();
|
|
this.m_UseSelfAdaption = mutator.m_UseSelfAdaption;
|
|
this.m_Tau1 = mutator.m_Tau1;
|
|
this.m_LowerLimitChance = mutator.m_LowerLimitChance;
|
|
}
|
|
//
|
|
// private Vector getClassesFromProperties(String mySelf, String myInterface) {
|
|
// Vector classes = new Vector();
|
|
// String typeOptions = EvAClient.getProperty(myInterface);
|
|
// if (typeOptions == null) {
|
|
// System.out.println("Warning: No configuration property found in: " +EvAClient.EVA_PROPERTY_FILE + " "+"for javaeva.server.oa.go.Operators.Mutation.InterfaceMutation");
|
|
// } else {
|
|
// StringTokenizer st = new StringTokenizer(typeOptions, ", ");
|
|
// while (st.hasMoreTokens()) {
|
|
// String current = st.nextToken().trim();
|
|
// if (!current.equalsIgnoreCase(mySelf)) {
|
|
// try {
|
|
// Class c = Class.forName(current);
|
|
// classes.addElement(current);
|
|
// } catch (Exception ex) {
|
|
// System.out.println("Couldn't load class with name: " + current);
|
|
// System.out.println("ex:"+ex.getMessage());
|
|
// ex.printStackTrace();
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// return classes;
|
|
// }
|
|
|
|
|
|
/** This method will enable you to clone a given mutation operator
|
|
* @return The clone
|
|
*/
|
|
public Object clone() {
|
|
return new MutateEAMixer(this);
|
|
}
|
|
|
|
/** This method allows you to evaluate wether two mutation operators
|
|
* are actually the same.
|
|
* @param mutator The other mutation operator
|
|
*/
|
|
public boolean equals(Object mutator) {
|
|
if (mutator instanceof MutateEAMixer) {
|
|
MutateEAMixer mut = (MutateEAMixer)mutator;
|
|
|
|
return true;
|
|
} else return false;
|
|
}
|
|
|
|
/** This method allows you to init the mutation operator
|
|
* @param individual The individual that will be mutated.
|
|
* @param opt The optimization problem.
|
|
*/
|
|
public void init(AbstractEAIndividual individual, InterfaceOptimizationProblem opt){
|
|
InterfaceMutation[] mutators = this.m_Mutators.getSelectedMutators();
|
|
for (int i = 0; i < mutators.length; i++) mutators[i].init(individual, opt);
|
|
}
|
|
|
|
/** This method will mutate a given AbstractEAIndividual. If the individual
|
|
* doesn't implement InterfaceGAIndividual nothing happens.
|
|
* @param individual The individual that is to be mutated
|
|
*/
|
|
public void mutate(AbstractEAIndividual individual) {
|
|
this.m_Mutators.normalizeWeights();
|
|
double[] probs = this.m_Mutators.getWeights();
|
|
if (this.m_UseSelfAdaption) {
|
|
for (int i = 0; i < probs.length; i++) {
|
|
probs[i] = probs[i] * Math.exp(this.m_Tau1 * RandomNumberGenerator.gaussianDouble(1));
|
|
if (probs[i] <= this.m_LowerLimitChance) probs[i] = this.m_LowerLimitChance;
|
|
if (probs[i] >= 1) probs[i] = 1;
|
|
}
|
|
this.m_Mutators.normalizeWeights();
|
|
}
|
|
|
|
InterfaceMutation[] mutators = this.m_Mutators.getSelectedMutators();
|
|
double pointer = RandomNumberGenerator.randomFloat(0, 1);
|
|
double dum = probs[0];
|
|
int index = 0;
|
|
while ((pointer > dum) && (index < probs.length-1)) {
|
|
index++;
|
|
dum += probs[index];
|
|
}
|
|
if (index == probs.length) index = RandomNumberGenerator.randomInt(0, probs.length-1);
|
|
//System.out.println("Using : " + mutators[index].getStringRepresentation());
|
|
// for (int i = 0; i < probs.length; i++) {
|
|
// System.out.println(""+mutators[i].getStringRepresentation()+" : "+ probs[i]);
|
|
// }
|
|
// System.out.println("");
|
|
mutators[index].mutate(individual);
|
|
}
|
|
|
|
/** This method allows you to perform either crossover on the strategy parameters
|
|
* or to deal in some other way with the crossover event.
|
|
* @param indy1 The original mother
|
|
* @param partners The original partners
|
|
*/
|
|
public void crossoverOnStrategyParameters(AbstractEAIndividual indy1, Population partners) {
|
|
for (int i = 0; i < this.m_Mutators.getSelectedMutators().length; i++) {
|
|
this.m_Mutators.getSelectedMutators()[i].crossoverOnStrategyParameters(indy1, partners);
|
|
}
|
|
}
|
|
|
|
/** This method allows you to get a string representation of the mutation
|
|
* operator
|
|
* @return A descriptive string.
|
|
*/
|
|
public String getStringRepresentation() {
|
|
return "EA mutation mixer";
|
|
}
|
|
|
|
/**********************************************************************************************************************
|
|
* These are for GUI
|
|
*/
|
|
/** This method allows the CommonJavaObjectEditorPanel to read the
|
|
* name to the current object.
|
|
* @return The name.
|
|
*/
|
|
public String getName() {
|
|
return "EA mutation mixer";
|
|
}
|
|
/** This method returns a global info string
|
|
* @return description
|
|
*/
|
|
public String globalInfo() {
|
|
return "This mmeta-mutation operator allows you to combine multiple alternative mutation operators.";
|
|
}
|
|
|
|
/** Choose the set of mutators.
|
|
* @param d The mutation operators.
|
|
*/
|
|
public void setMutators(PropertyMutationMixer d) {
|
|
this.m_Mutators = d;
|
|
}
|
|
public PropertyMutationMixer getMutators() {
|
|
return this.m_Mutators;
|
|
}
|
|
public String mutatorsTipText() {
|
|
return "Choose the set of mutators.";
|
|
}
|
|
|
|
/** Set the lower limit for the mutation step size with this method.
|
|
* @param d The mutation operator.
|
|
*/
|
|
public void setUseSelfAdaption(boolean d) {
|
|
this.m_UseSelfAdaption = d;
|
|
}
|
|
public boolean getUseSelfAdaption() {
|
|
return this.m_UseSelfAdaption;
|
|
}
|
|
public String useSelfAdaptionTipText() {
|
|
return "Use my implementation of self-adaption for the mutation mixer.";
|
|
}
|
|
|
|
/** Set the lower limit for the mutation step size with this method.
|
|
* @param d The mutation operator.
|
|
*/
|
|
public void setLowerLimitChance(double d) {
|
|
if (d < 0) d = 0;
|
|
this.m_LowerLimitChance = d;
|
|
}
|
|
public double getLowerLimitChance() {
|
|
return this.m_LowerLimitChance;
|
|
}
|
|
public String lowerLimitChanceTipText() {
|
|
return "Set the lower limit for the mutation chance.";
|
|
}
|
|
|
|
/** Set the value for tau1 with this method.
|
|
* @param d The mutation operator.
|
|
*/
|
|
public void setTau1(double d) {
|
|
if (d < 0) d = 0;
|
|
this.m_Tau1 = d;
|
|
}
|
|
public double getTau1() {
|
|
return this.m_Tau1;
|
|
}
|
|
public String tau1TipText() {
|
|
return "Set the value for tau1.";
|
|
}
|
|
}
|