private double[] mutate(CMAParamSet params, double[] x, double[][] range, int count) {
int dim = range.length;
if (!Mathematics.isInRange(params.meanX, range)) { // TODO Im not sure why this can happen...
System.err.println("Error in MutateESRankMuCMA.mutate !");
Mathematics.projectToRange(params.meanX, range);
}
// System.out.println("--- In mutate!");
if (params != null && (params.firstAdaptionDone)) {
double[] sampl = new double[dim]; // generate scaled random vector (D * z)
for (int i = 0; i < dim; ++i) {
sampl[i] = Math.sqrt(params.eigenvalues[i]) * RNG.gaussianDouble(1.);
if (Double.isNaN(sampl[i])) sampl[i] = 0;
}
// System.out.println("Sampling around " + BeanInspector.toString(meanX));
/* add mutation (sigma * B * (D*z)) */
addMutationStep(params, x, sampl);
int cnt = 0;
while (!Mathematics.isInRange(x, range)) {
// % You may handle constraints here. You may either resample
// % arz(:,k) and/or multiply it with a factor between -1 and 1
// % (the latter will decrease the overall step size) and
// % recalculate arx accordingly. Do not change arx or arz in any
// % other way.
// multiply sampl by a no in [-1,1] and try again
double r; // actually we use [-1,-0.5] or [0.5, 1]
cnt++;
if (cnt > 10 * x.length) {
// well... lets give it up. Probably the meanX is close to the bounds in several
// dimensions
// which is unlikely to be solved by random sampling.
// if (!Mathematics.isInRange(params.meanX, range)) {
// System.err.println("Error in MutateESRankMuCMA.mutate !"); break;
// }
r = 0;
} else {
r = RNG.randomDouble(-0.5, 0.5);
if (Math.abs(r) < 0.5) r += Math.signum(r) * 0.5; // r is in [-1,-0.5] or [0.5,1]
}
// System.out.println("Reducing step by " + r + " for " +
// BeanInspector.toString(params.meanX));
Mathematics.svMult(r, sampl, sampl);
addMutationStep(params, x, sampl);
}
} else {
if (params == null) {
System.err.println(
"Error in MutateESRankMuCMA: parameter set was null! Skipping mutation...");
} // no valid meanX yet, so just do a gaussian jump with sigma
for (int i = 0; i < dim; ++i) {
x[i] += RNG.gaussianDouble(getSigma(params, i));
checkValidDouble(x[i]);
}
}
if (!Mathematics.isInRange(params.meanX, range)) {
System.err.println("Error B in MutateESRankMuCMA.mutate !");
}
if (TRACE_1) System.out.println("mutated indy: " + BeanInspector.toString(x));
return x;
}
/**
* Requires selected population to be sorted by fitness.
*
* @param params refering parameter set
* @param iterations number of iterations performed
* @param selected selected population
* @return true if the parameters seem ok or were corrected, false if new parameters must be
* produced
*/
private boolean testAndCorrectNumerics(
CMAParamSet params, int iterations, Population selected) { // not much left here
boolean corrected = true;
/* Flat Fitness, Test if function values are identical */
if (iterations > 1 && (selected.size() > 1)) {
// selected pop is sorted
if (nearlySame(
selected.getEAIndividual(0).getFitness(),
selected.getEAIndividual(selected.size() - 1).getFitness())) {
if (TRACE_1)
System.err.println(
"flat fitness landscape, consider reformulation of fitness, step-size increased");
params.sigma *= Math.exp(0.2 + params.c_sig / params.d_sig);
// sigma=0.1;
}
}
if (!checkValidDouble(params.sigma)) {
System.err.println("Error, unstable sigma!");
corrected = false;
// params.sigma=params.firstSigma; // MK TODO
// System.err.println(
}
/* Align (renormalize) scale C (and consequently sigma) */
/* e.g. for infinite stationary state simulations (noise
* handling needs to be introduced for that) */
double fac = 1.;
double minEig = 1e-12;
double maxEig = 1e8;
if (Mathematics.max(params.eigenvalues) < minEig)
fac = 1. / Math.sqrt(Mathematics.max(params.eigenvalues));
else if (Mathematics.min(params.eigenvalues) > maxEig)
fac = 1. / Math.sqrt(Mathematics.min(params.eigenvalues));
if (fac != 1.) {
// System.err.println("Scaling by " + fac);
params.sigma /= fac;
for (int i = 0; i < params.meanX.length; ++i) {
params.pathC[i] *= fac;
params.eigenvalues[i] *= fac * fac;
for (int j = 0; j <= i; ++j) {
params.mC.set(i, j, params.mC.get(i, j) * fac * fac);
if (i != j) params.mC.set(j, i, params.mC.get(i, j));
}
}
}
return corrected;
} // Test...
private double[] mutateOrig(CMAParamSet params, double[] x, double[][] range, int count) {
int dim = range.length;
int maxRetries;
if (checkRange) maxRetries = 100 * dim;
else maxRetries = 0; // take the first sample, not matter in or out of range
do { // this is a loop in case that the range needs to be checked and the current sampling fails
// to keep the range
if (params != null && (params.firstAdaptionDone)) {
double[] sampl = new double[dim]; // generate scaled random vector (D * z)
for (int i = 0; i < dim; ++i) {
sampl[i] = Math.sqrt(params.eigenvalues[i]) * RNG.gaussianDouble(1.);
if (Double.isNaN(sampl[i])) sampl[i] = 0;
}
// System.out.println("Sampling around " + BeanInspector.toString(meanX));
/* add mutation (sigma * B * (D*z)) */
for (int i = 0; i < dim; ++i) {
double sum = 0.;
for (int j = 0; j < dim; ++j) sum += params.mB.get(i, j) * sampl[j];
x[i] = params.meanX[i] + getSigma(params, i) * sum;
checkValidDouble(x[i]);
}
} else {
if (params == null) {
System.err.println(
"Error in MutateESRankMuCMA: parameter set was null! Skipping mutation...");
} // no valid meanX yet, so just do a gaussian jump with sigma
for (int i = 0; i < dim; ++i) {
x[i] += RNG.gaussianDouble(getSigma(params, i));
checkValidDouble(x[i]);
}
}
} while ((maxRetries--) > 0 && !(Mathematics.isInRange(x, range)));
if (checkRange && !(Mathematics.isInRange(x, range)))
return repairMutation(x, range); // allow some nice tries before using brute force
else return x;
}
/**
* 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.
*
* @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,
double[] center,
double[][] range,
double initialSigma) {
// those are from initialize:
params.firstAdaptionDone = false;
params.range = range;
int dim = params.range.length;
params.eigenvalues = new double[dim];
Arrays.fill(params.eigenvalues, 1.);
params.meanX = new double[dim];
params.pathC = new double[dim];
params.pathS = new double[dim];
params.mC = Matrix.identity(dim, dim);
params.mB = Matrix.identity(dim, dim);
// from adaptAfterSel
params.weights = initWeights(mu, lambda);
double muEff = getMuEff(params.weights, mu);
params.c_sig = (muEff + 2) / (muEff + dim + 3);
// c_u_sig = Math.sqrt(c_sig * (2.-c_sig));
params.d_sig = params.c_sig + 1 + 2 * Math.max(0, Math.sqrt((muEff - 1) / (dim + 1)) - 1);
if (initialSigma < 0) { // this means we scale the average range
if (initialSigma != -0.25 && (initialSigma != -0.5)) {
EVAERROR.errorMsgOnce("Warning, unexpected initial sigma in CMAParamSet!");
}
initialSigma = -initialSigma * Mathematics.getAvgRange(params.range);
}
if (initialSigma <= 0) {
EVAERROR.errorMsgOnce("warning: initial sigma <= zero! Working with converged population?");
initialSigma = 10e-10;
}
params.sigma = initialSigma;
// System.out.println("INitial sigma: "+sigma);
params.firstSigma = params.sigma;
// System.out.println("new center is " + BeanInspector.toString(center));
params.meanX = center; // this might be ok?
return params;
}
/**
* From Auger&Hansen, CEC '05, stopping criterion noeffectaxis.
*
* @param d
* @param gen
* @return
*/
public boolean testNoChangeAddingDevAxis(Population pop, double d, int gen) {
// if all(xmean == xmean + 0.1*sigma*BD(:,1+floor(mod(countiter,N))))
// i = 1+floor(mod(countiter,N));
// stopflag(end+1) = {'warnnoeffectaxis'};
CMAParamSet params = (CMAParamSet) pop.getData(cmaParamsKey);
int dim = params.meanX.length;
int k = gen % dim;
double[] ev_k = params.mB.getColumn(k);
Mathematics.svMult(
Math.sqrt(params.eigenvalues[k]), ev_k, ev_k); // this is now e_k*v_k = BD(:,...)
int i = 0;
boolean res = true;
while (res && (i < dim)) {
res = res && (params.meanX[i] == (params.meanX[i] + d * getSigma(params, i) * ev_k[i]));
i++;
}
if (TRACE_TEST) if (res) System.out.println("testNoChangeAddingDevAxis hit");
return res;
}
private double[] repairMutation(double[] x, double[][] range) {
EVAERROR.errorMsgOnce(
"Warning, brute-forcing constraints! Too large initial sigma? (pot. multiple errors)");
Mathematics.projectToRange(x, range);
return x;
}
/**
* Perform the main adaption of sigma and C using evolution paths. The evolution path is deduced
* from the center of the selected population compared to the old mean value. See Hansen&Kern 04
* for further information.
*
* @param oldGen
* @param selectedP
*/
public void adaptAfterSelection(Population oldGen, Population selectedP) {
Population selectedSorted =
selectedP.getSortedBestFirst(new AbstractEAIndividualComparator(-1));
int mu, lambda;
mu = selectedP.size();
lambda = oldGen.size();
int generation = oldGen.getGeneration();
if (mu >= lambda) {
// try to override by oldGen additional data:
if (oldGen.hasData(EvolutionStrategies.esMuParam))
mu = (Integer) oldGen.getData(EvolutionStrategies.esMuParam);
if (oldGen.hasData(EvolutionStrategies.esLambdaParam))
lambda = (Integer) oldGen.getData(EvolutionStrategies.esLambdaParam);
}
if (mu >= lambda) {
mu = Math.max(1, lambda / 2);
EVAERROR.errorMsgOnce(
"Warning: invalid mu/lambda ratio! Setting mu to lambda/2 = "
+ mu
+ ", lambda = "
+ lambda);
}
CMAParamSet params;
if (oldGen.getGeneration()
<= 1) { // init new param set. At gen < 1 we shouldnt be called, but better do it once too
// often
if (oldGen.hasData(cmaParamsKey))
params =
CMAParamSet.initCMAParams(
(CMAParamSet) oldGen.getData(cmaParamsKey),
mu,
lambda,
oldGen,
getInitSigma(oldGen));
else params = CMAParamSet.initCMAParams(mu, lambda, oldGen, getInitSigma(oldGen));
} else {
if (!oldGen.hasData(cmaParamsKey)) {
if (oldGen.getGeneration() > 1)
EVAERROR.errorMsgOnce("Error: population lost cma parameters. Incompatible optimizer?");
params = CMAParamSet.initCMAParams(mu, lambda, oldGen, getInitSigma(oldGen));
} else params = (CMAParamSet) oldGen.getData(cmaParamsKey);
}
if (lambda == 1
&& (oldGen.size() == 1)
&& (selectedP.size() == 1)
&& (oldGen.getEAIndividual(0).equals(selectedP.getEAIndividual(0)))) {
// nothing really happened, so do not adapt and just store default params
lastParams = (CMAParamSet) params.clone();
oldGen.putData(cmaParamsKey, params);
selectedP.putData(cmaParamsKey, params);
return;
}
if (TRACE_1) {
System.out.println("WCMA adaptGenerational **********");
// System.out.println("newPop measures: " +
// BeanInspector.toString(newPop.getPopulationMeasures()));
System.out.println("mu_eff: " + CMAParamSet.getMuEff(params.weights, mu));
System.out.println(params.toString());
System.out.println("*********************************");
}
double[] newMeanX = calcMeanX(params.weights, selectedSorted);
if (TRACE_1) System.out.println("newMeanX: " + BeanInspector.toString(newMeanX));
int dim = params.meanX.length;
double[] BDz = new double[dim];
for (int i = 0; i < dim; i++) {
/* calculate xmean and BDz~N(0,C) */
// Eq. 4 from HK04, most right term
BDz[i] =
Math.sqrt(CMAParamSet.getMuEff(params.weights, mu))
* (newMeanX[i] - params.meanX[i])
/ getSigma(params, i);
}
// if (TRACE_2) System.out.println("BDz is " + BeanInspector.toString(BDz));
double[] newPathS = params.pathS.clone();
double[] newPathC = params.pathC.clone();
double[] zVect = new double[dim];
/* calculate z := D^(-1) * B^(-1) * BDz into artmp, we could have stored z instead */
for (int i = 0; i < dim; ++i) {
double sum = 0.;
for (int j = 0; j < dim; ++j) {
sum += params.mB.get(j, i) * BDz[j]; // times B transposed, (Eq 4) in HK04
}
if (params.eigenvalues[i] < 0) {
EVAERROR.errorMsgOnce(
"Warning: negative eigenvalue in MutateESRankMuCMA! (possibly multiple cases)");
zVect[i] = 0;
} else {
zVect[i] = sum / Math.sqrt(params.eigenvalues[i]);
if (!checkValidDouble(zVect[i])) {
System.err.println("Error, infinite zVect entry!");
zVect[i] = 0; // TODO MK
}
}
}
/* cumulation for sigma (ps) using B*z */
for (int i = 0; i < dim; ++i) {
double sum = 0.;
for (int j = 0; j < dim; ++j) sum += params.mB.get(i, j) * zVect[j];
newPathS[i] =
(1. - params.c_sig) * params.pathS[i]
+ Math.sqrt(params.c_sig * (2. - params.c_sig)) * sum;
if (!checkValidDouble(newPathS[i])) {
System.err.println("Error, infinite pathS!");
}
}
// System.out.println("pathS diff: " + BeanInspector.toString(Mathematics.vvSub(newPathS,
// pathS)));
// System.out.println("newPathS is " + BeanInspector.toString(newPathS));
double psNorm = Mathematics.norm(newPathS);
double hsig = 0;
if (psNorm / Math.sqrt(1. - Math.pow(1. - params.c_sig, 2. * generation)) / expRandStepLen
< 1.4 + 2. / (dim + 1.)) {
hsig = 1;
}
for (int i = 0; i < dim; ++i) {
newPathC[i] =
(1. - getCc()) * params.pathC[i] + hsig * Math.sqrt(getCc() * (2. - getCc())) * BDz[i];
checkValidDouble(newPathC[i]);
}
// TODO missing: "remove momentum in ps"
if (TRACE_1) {
System.out.println("newPathC: " + BeanInspector.toString(newPathC));
System.out.println("newPathS: " + BeanInspector.toString(newPathS));
}
if (TRACE_1) System.out.println("Bef: C is \n" + params.mC.toString());
if (params.meanX == null) params.meanX = newMeanX;
updateCov(params, newPathC, newMeanX, hsig, mu, selectedSorted);
updateBD(params);
if (TRACE_2) System.out.println("Aft: C is " + params.mC.toString());
/* update of sigma */
double sigFact = Math.exp(((psNorm / expRandStepLen) - 1) * params.c_sig / params.d_sig);
if (Double.isInfinite(sigFact))
params.sigma *= 10.; // in larger search spaces sigma tends to explode after init.
else params.sigma *= sigFact;
if (!testAndCorrectNumerics(params, generation, selectedSorted)) {
// parameter seemingly exploded...
params =
CMAParamSet.initCMAParams(
params,
mu,
lambda,
params.meanX,
((InterfaceDataTypeDouble) oldGen.getEAIndividual(0)).getDoubleRange(),
params.firstSigma);
}
if (TRACE_1) {
System.out.println("sigma=" + params.sigma);
System.out.print("psLen=" + (psNorm) + " ");
outputParams(params, mu);
}
// take over data
params.meanX = newMeanX;
params.pathC = newPathC;
params.pathS = newPathS;
params.firstAdaptionDone = true;
lastParams = (CMAParamSet) params.clone();
oldGen.putData(cmaParamsKey, params);
selectedP.putData(cmaParamsKey, params);
// if (TRACE_2) System.out.println("sampling around " + BeanInspector.toString(meanX));
}
