/**
* Get an instance by a relative path.
*
* @param relPath
* @return
*/
public static PropertyFilePath getFilePathFromResource(String relPath) {
String fName = ReflectPackage.getResourcePathFromCP(relPath);
if (fName == null) {
return null;
} else {
return new PropertyFilePath(fName);
}
}
private void initProblemDefinition() {
this.m_Mocco.m_JPanelParameters.removeAll();
this.m_ProblemChooser = new JComboBox();
JComponent tmpC = new JPanel();
tmpC.setLayout(new BorderLayout());
Class[] altern = null;
try {
altern =
ReflectPackage.getAssignableClassesInPackage(
"eva2.server.go.problems",
Class.forName("eva2.server.go.problems.InterfaceMultiObjectiveDeNovoProblem"),
true,
true);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.m_ProblemChooser.setModel(new DefaultComboBoxModel(altern));
String objectName = (this.m_Mocco.m_State.m_OriginalProblem.getClass().getName());
this.m_ProblemChooser.getModel().setSelectedItem(objectName);
this.m_ProblemChooser.addActionListener(problemChanged);
JPanel tmpP = new JPanel();
tmpP.setLayout(new GridBagLayout());
GridBagConstraints gbc = new GridBagConstraints();
gbc.fill = GridBagConstraints.HORIZONTAL;
gbc.gridx = 0;
gbc.gridy = 0;
tmpP.add(
this.makeHelpText(
"Choose and parameterize the optimization problem to solve by means of MOCCO. "
+ "Please note that it is not necessary to include MOSO converters yet and that only problems complying "
+ "with the InterfaceMultiObjectiveDeNovoProblem can be optimized using the MOCCO approach."),
gbc);
gbc.gridx = 0;
gbc.gridy = 1;
tmpP.add(this.m_ProblemChooser, gbc);
this.m_Mocco.m_JPanelParameters.setLayout(new BorderLayout());
this.m_Mocco.m_JPanelParameters.add(tmpP, BorderLayout.NORTH);
JParaPanel paraPanel = new JParaPanel(this.m_Mocco.m_State.m_OriginalProblem, "MyGUI");
this.m_Mocco.m_JPanelParameters.add(paraPanel.makePanel(), BorderLayout.CENTER);
}
/**
* Prints formatted help output for a specific class.
*
* <p>If the class is an interface or abstract class additional information on assignable
* subclasses will be shown.
*
* @param clazz The class to show help for.
*/
private static void printHelpFor(Class<?> clazz) {
System.out.println(clazz.getName() + "\n");
if (clazz.isAnnotationPresent(Description.class)) {
Description description = clazz.getAnnotation(Description.class);
System.out.printf("%s\n\n", description.value());
}
/** In case we have an Abstract class or Interface show available sub types. */
if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) {
Class<?>[] subTypes =
ReflectPackage.getAssignableClassesInPackage(
clazz.getPackage().getName(), clazz, true, true);
if (subTypes.length > 0) {
System.out.printf("Available types for %s\n\n", clazz.getName());
for (Class<?> type : subTypes) {
if (Modifier.isAbstract(type.getModifiers())) {
continue;
}
Description description = clazz.getAnnotation(Description.class);
System.out.printf(
"\t\033[1m%s\033[0m (%s)\n",
type.getName(), StringTools.cutClassName(type.getName()));
if (description != null) {
System.out.printf("\t\t%s", description.value());
} else {
System.out.println("\t\tNo description available.");
}
}
System.out.println();
}
}
/** Get available parameters for this class and list them with their description. */
ParameterGenerator generator = new ParameterGenerator(clazz, false);
generator.generate();
Map<String, List<Parameter>> paramList = generator.getParameterList();
List<Parameter> parameters = paramList.get(clazz.getName());
if (parameters.size() > 0) {
System.out.println("Options:");
for (Parameter key : parameters) {
Class<?> type = key.getType();
String typeDefinition;
if (type.isEnum()) {
Enum[] enumConstants = (Enum[]) type.getEnumConstants();
typeDefinition = "{";
for (int i = 0; i < enumConstants.length; i++) {
typeDefinition += enumConstants[i].name();
if (i != enumConstants.length - 1) {
typeDefinition += ",";
}
}
typeDefinition += "}";
} else {
typeDefinition = key.getType().getName();
}
System.out.printf("\t\033[1m--%s\033[0m \033[4m%s\033[0m\n", key.getName(), typeDefinition);
System.out.printf("\t\t%s\n", key.getDescription());
}
}
System.out.print("\n\n");
}
@Override
public void optimize() {
// System.out.println("opt. called");
AbstractEAIndividual indy;
// if ((this.indyhash == null) || (this.indyhash.size() <1)) initialize();
for (int i = 0; i < this.population.size(); i++) {
indy = this.population.get(i);
if (!indy.hasData(gradientKey)) {
// System.out.println("new indy to hash");
// Hashtable history = new Hashtable();
int[] lock = new int[((InterfaceDataTypeDouble) indy).getDoubleData().length];
double[] wstepsize = new double[((InterfaceDataTypeDouble) indy).getDoubleData().length];
for (int li = 0; li < lock.length; li++) {
lock[li] = 0;
}
for (int li = 0; li < lock.length; li++) {
wstepsize[li] = 1.0;
}
double fitness = 0;
indy.putData(lockKey, lock);
indy.putData(lastFitnessKey, fitness);
indy.putData(stepSizeKey, globalinitstepsize);
indy.putData(wStepSizeKey, wstepsize);
// indyhash.put(indy, history);
} else {
// System.out.println("indy already in hash");
}
}
// System.out.println("hashtable built");
for (int i = 0; i < this.population.size(); i++) {
indy = this.population.get(i);
double[][] range = ((InterfaceDataTypeDouble) indy).getDoubleRange();
double[] params = ((InterfaceDataTypeDouble) indy).getDoubleData();
indy.putData(oldParamsKey, params);
int[] lock = (int[]) indy.getData(lockKey);
double indystepsize = (Double) indy.getData(stepSizeKey);
if ((this.optimizationProblem instanceof InterfaceFirstOrderDerivableProblem)
&& (indy instanceof InterfaceDataTypeDouble)) {
for (int iterations = 0; iterations < this.iterations; iterations++) {
double[] oldgradient =
indy.hasData(gradientKey) ? (double[]) indy.getData(gradientKey) : null;
double[] wstepsize = (double[]) indy.getData(wStepSizeKey);
double[] oldchange = null;
double[] gradient =
((InterfaceFirstOrderDerivableProblem) optimizationProblem)
.getFirstOrderGradients(params);
if ((oldgradient != null) && (wstepsize != null)) { // LOCAL adaption
for (int li = 0; li < wstepsize.length; li++) {
double prod = gradient[li] * oldgradient[li];
if (prod < 0) {
wstepsize[li] = wDecreaseStepSize * wstepsize[li];
} else if (prod > 0) {
wstepsize[li] = wIncreaseStepSize * wstepsize[li];
}
wstepsize[li] = (wstepsize[li] < localminstepsize) ? localminstepsize : wstepsize[li];
wstepsize[li] = (wstepsize[li] > localmaxstepsize) ? localmaxstepsize : wstepsize[li];
}
}
double[] newparams = new double[params.length];
indy.putData(gradientKey, gradient);
double[] change = new double[params.length];
if (indy.hasData(changesKey)) {
oldchange = (double[]) indy.getData(changesKey);
}
boolean dograddesc = (this.momentumterm) && (oldchange != null);
for (int j = 0; j < newparams.length; j++) {
if (lock[j] == 0) {
double tempstepsize = 1;
if (this.localStepSizeAdaption) {
tempstepsize *= wstepsize[j];
}
if (this.globalStepSizeAdaption) {
tempstepsize *= indystepsize;
}
double wchange =
signum(tempstepsize * gradient[j])
* Math.min(
maximumabsolutechange,
Math.abs(tempstepsize * gradient[j])); // indystepsize * gradient[j];
if (this.manhattan) {
wchange = this.signum(wchange) * tempstepsize;
}
if (dograddesc) {
wchange += this.momentumweigth * oldchange[j];
}
newparams[j] = params[j] - wchange;
if (newparams[j] < range[j][0]) {
newparams[j] = range[j][0];
}
if (newparams[j] > range[j][1]) {
newparams[j] = range[j][1];
}
// for (int g = 0; g < newparams.length; g++) {
// System.out.println("Param " + g +": " + newparams[g]);
// }
change[j] += wchange;
} else {
lock[j]--;
}
}
params = newparams;
indy.putData(changesKey, change);
} // end loop iterations
((InterfaceDataTypeDouble) indy).setDoubleGenotype(params);
} // end if ((this.problem instanceof InterfaceFirstOrderDerivableProblem) && (indy instanceof
// InterfaceDataTypeDouble)) {
else {
String msg =
"Warning, problem of type InterfaceFirstOrderDerivableProblem and template of type InterfaceDataTypeDouble is required for "
+ this.getClass();
EVAERROR.errorMsgOnce(msg);
Class<?>[] clsArr =
ReflectPackage.getAssignableClasses(
InterfaceFirstOrderDerivableProblem.class.getName(), true, true);
msg += " (available: ";
for (Class<?> cls : clsArr) {
msg = msg + " " + cls.getSimpleName();
}
msg += ")";
throw new RuntimeException(msg);
}
} // for loop population size
this.optimizationProblem.evaluate(this.population);
population.incrGeneration();
if (this.recovery) {
for (int i = 0; i < this.population.size(); i++) {
indy = this.population.get(i);
if (indy.getFitness()[0] > recoverythreshold) {
((InterfaceDataTypeDouble) indy)
.setDoublePhenotype((double[]) indy.getData(oldParamsKey));
double[] changes = (double[]) indy.getData(changesKey);
int[] lock = (int[]) indy.getData(lockKey);
int indexmaxchange = 0;
double maxchangeval = Double.NEGATIVE_INFINITY;
for (int j = 0; j < changes.length; j++) {
if ((changes[j] > maxchangeval) && (lock[j] == 0)) {
indexmaxchange = j;
maxchangeval = changes[j];
}
}
lock[indexmaxchange] = recoverylocksteps;
indy.putData(lockKey, lock);
} else {
}
}
this.optimizationProblem.evaluate(this.population);
population.incrGeneration();
}
if (this.globalStepSizeAdaption) {
// System.out.println("gsa main");
for (int i = 0; i < this.population.size(); i++) {
indy = this.population.get(i);
if (indy.getData(lastFitnessKey) != null) {
double lastfit = (Double) indy.getData(lastFitnessKey);
double indystepsize = (Double) indy.getData(stepSizeKey);
if (lastfit < indy.getFitness()[0]) { // GLOBAL adaption
indystepsize *= wDecreaseStepSize;
} else {
indystepsize *= wIncreaseStepSize;
}
indystepsize = (indystepsize > globalmaxstepsize) ? globalmaxstepsize : indystepsize;
indystepsize = (indystepsize < globalminstepsize) ? globalminstepsize : indystepsize;
indy.putData(stepSizeKey, indystepsize);
}
indy.putData(lastFitnessKey, indy.getFitness()[0]);
}
}
this.firePropertyChangedEvent(Population.NEXT_GENERATION_PERFORMED);
}