void cma_es(Swarm &sw){
if(logCMAES){
printf("\n--------------------------------------------------------------\n");
printf("Repository (%d)\n", sw.repository.getActualSize());
for(int i=0;i<sw.repository.getActualSize();i++){
printVector(sw.repository.getSolution(i).decisionVector, decisionNumber);
printf("\n");
}
}
double sigmaPrev=sw.sigma;
myLearn(sw);
// if(fabs(sigmaPrev-sw.sigma) > 10000){
// fprintf(stderr, "\nWARNING!, sigma changed too much: %f -> %f. resetting...\n",sigmaPrev, sw.sigma); //shows warning message
// sw.init=true; //set the init flag, so all the CMA-ES variables are reset
// myLearn(sw); //learn again using the default values as base
// }
if(sw.sigma != sw.sigma || sw.sigma >= MAXDOUBLE){ //check for invalid numbers NaN or inf
fprintf(stderr, "WARNING!, sigma: %f. resetting...\n", sw.sigma); //shows warning message
// exit(1);
sw.init=true; //set the init flag, so all the CMA-ES variables are reset
myLearn(sw); //learn again using the default values as base
}
//four reset criteria as in the paper "injecting cma-es into moea/d"
//NoEffectCoord
for (int iKoo = 0; iKoo < decisionNumber; ++iKoo){
if (sw.mean[iKoo] == sw.mean[iKoo] + 0.2*sw.sigma*sqrt(sw.C[iKoo][iKoo])){
fprintf(stderr, "NoEffectCoordinate: standard deviation 0.2*%7.2e in coordinate %d without effect\n", sw.sigma*sqrt(sw.C[iKoo][iKoo]), iKoo); //shows warning message
sw.init=true; //set the init flag, so all the CMA-ES variables are reset
myLearn(sw); //learn again using the default values as base
break;
}
}
//NoEffectAxis
int iKoo;
for (int iAchse = 0; iAchse < decisionNumber; ++iAchse){
double fac = 0.1 * sw.sigma * sw.D[iAchse];
for (iKoo = 0; iKoo < decisionNumber; ++iKoo){
if (sw.mean[iKoo] != sw.mean[iKoo] + fac * sw.B[iKoo][iAchse])
break;
}
if (iKoo == decisionNumber){
/* t->sigma *= exp(0.2+t->sp.cs/t->sp.damps); */
fprintf(stderr, "NoEffectAxis: standard deviation 0.1*%7.2e in principal axis %d without effect\n", fac/0.1, iAchse);
sw.init=true; //set the init flag, so all the CMA-ES variables are reset
myLearn(sw); //learn again using the default values as base
break;
}
}
//TolXUp
double stopTolUpXFactor=1e3;
double initialStds=0.3;
int i;
for(i=0; i<decisionNumber; ++i) {
if (sw.sigma * sqrt(sw.C[i][i]) > stopTolUpXFactor * initialStds)
break;
}
if (i < decisionNumber) {
fprintf(stderr, "TolUpX: standard deviation increased by more than %7.2e, larger initial standard deviation recommended \n", stopTolUpXFactor);
sw.init=true; //set the init flag, so all the CMA-ES variables are reset
myLearn(sw); //learn again using the default values as base
}
//ConditionCov
double dMaxSignifKond=1e13;
if (rgdouMax(sw.D, decisionNumber) >= rgdouMin(sw.D, decisionNumber) * dMaxSignifKond) {
fprintf(stderr, "ConditionNumber: maximal condition number %7.2e reached. maxEW=%7.2e,minEW=%7.2e\n", dMaxSignifKond, rgdouMax(sw.D, decisionNumber), rgdouMin(sw.D, decisionNumber));
sw.init=true; //set the init flag, so all the CMA-ES variables are reset
myLearn(sw); //learn again using the default values as base
}
//************************************* RESAMPLE SOLUTIONS FROM THE GOOD FRONTS ******************************//
//re-learn and re-sample when errors in the covariance matrix are detected in the sampling phase
bool success=mySample(sw);
while(!success){
myLearn(sw);
success=mySample(sw);
fprintf(stderr,"Resample\n");
}
// Neighbor orderedSwarms[swarmNumber];
// for(int i=0;i<swarmNumber;i++){
// orderedSwarms[i].index=i;
// orderedSwarms[i].distance=swarms[i].modelQuality*-1;//inverted model quality because we will use the preexisting sort, that sorts based on the smallest value (distance)
// }
// std::sort(orderedSwarms, orderedSwarms+swarmNumber, neighborsComparator);
//
// // for(int i=0;i<swarmNumber;i++){
// // printf("swarm: %d has quality %f sz: %d\n", orderedSwarms[i].index, orderedSwarms[i].distance*-1, repGlobal->getActualSize());
// // }
// // printf("\n\n\n");
//
// bool good=false;
// for(int i=0;i<100;i++){
// if(sw.neighborhood[0].index == orderedSwarms[i].index){
// good=true;
// break;
// }
// }
//
// if(good){
// //re-learn and re-sample when errors in the covariance matrix are detected in the sampling phase
// bool success=mySampleReplacement(sw, 10);
// while(!success){
// myLearn(sw);
// success=mySampleReplacement(sw, 10);
// fprintf(stderr,"Resample\n");
// }
// }else{
// for(int i=0;i<sw.getSize();i++)
// sw.particles[i].solution.evalSolution=false;
// // //re-learn and re-sample when errors in the covariance matrix are detected in the sampling phase
// // bool success=mySample(sw);
// // while(!success){
// // myLearn(sw);
// // success=mySample(sw);
// // fprintf(stderr,"Resample\n");
// // }
// }
//************************************* END OF RESAMPLING SOLUTIONS FROM THE GOOD FRONTS ******************************//
if(logCMAES){
printf("\n\npop after \n\n");
for(int i=0; i<sw.getSize();i++){
//printVector(evo.rgrgx[i],N+2);
printVector(sw.particles[i].solution.decisionVector,decisionNumber);
printf("\n");
}
}
}
double * reinit(cmaes_t * evo, int lambda, int numDipoles)
{
int i, j, k, N;
double dtest, trace;
double *rgrgxdata;
/** Unknown if these are needed, most seem to be related to reading the init file (which we are removing) **/
evo->sp.rgsformat = (char **) new_void(55, sizeof(char *));
evo->sp.rgpadr = (void **) new_void(55, sizeof(void *));
evo->sp.rgskeyar = (char **) new_void(11, sizeof(char *));
evo->sp.rgp2adr = (double ***) new_void(11, sizeof(double **));
evo->sp.weigkey = (char *)new_void(7, sizeof(char));
/* All scalars: */
i = 0;
evo->sp.rgsformat[i] = " N %d"; evo->sp.rgpadr[i++] = (void *) &evo->sp.N;
evo->sp.rgsformat[i] = " seed %d"; evo->sp.rgpadr[i++] = (void *) &evo->sp.seed;
evo->sp.rgsformat[i] = " stopMaxFunEvals %lg"; evo->sp.rgpadr[i++] = (void *) &evo->sp.stopMaxFunEvals;
evo->sp.rgsformat[i] = " stopMaxIter %lg"; evo->sp.rgpadr[i++] = (void *) &evo->sp.stopMaxIter;
evo->sp.rgsformat[i] = " stopFitness %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.stStopFitness.val;
evo->sp.rgsformat[i] = " stopTolFun %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.stopTolFun;
evo->sp.rgsformat[i] = " stopTolFunHist %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.stopTolFunHist;
evo->sp.rgsformat[i] = " stopTolX %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.stopTolX;
evo->sp.rgsformat[i] = " stopTolUpXFactor %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.stopTolUpXFactor;
evo->sp.rgsformat[i] = " lambda %d"; evo->sp.rgpadr[i++] = (void *) &evo->sp.lambda;
evo->sp.rgsformat[i] = " mu %d"; evo->sp.rgpadr[i++] = (void *) &evo->sp.mu;
evo->sp.rgsformat[i] = " weights %5s"; evo->sp.rgpadr[i++] = (void *) evo->sp.weigkey;
evo->sp.rgsformat[i] = " fac*cs %lg";evo->sp.rgpadr[i++] = (void *) &evo->sp.cs;
evo->sp.rgsformat[i] = " fac*damps %lg"; evo->sp.rgpadr[i++] = (void *) &evo->sp.damps;
evo->sp.rgsformat[i] = " ccumcov %lg"; evo->sp.rgpadr[i++] = (void *) &evo->sp.ccumcov;
evo->sp.rgsformat[i] = " mucov %lg"; evo->sp.rgpadr[i++] = (void *) &evo->sp.mucov;
evo->sp.rgsformat[i] = " fac*ccov %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.ccov;
evo->sp.rgsformat[i] = " diagonalCovarianceMatrix %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.diagonalCov;
evo->sp.rgsformat[i] = " updatecov %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.updateCmode.modulo;
evo->sp.rgsformat[i] = " maxTimeFractionForEigendecompostion %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.updateCmode.maxtime;
evo->sp.rgsformat[i] = " resume %59s"; evo->sp.rgpadr[i++] = (void *) evo->sp.resumefile;
evo->sp.rgsformat[i] = " fac*maxFunEvals %lg"; evo->sp.rgpadr[i++] = (void *) &evo->sp.facmaxeval;
evo->sp.rgsformat[i] = " fac*updatecov %lg"; evo->sp.rgpadr[i++]=(void *) &evo->sp.facupdateCmode;
evo->sp.n1para = i;
evo->sp.n1outpara = i-2; /* disregard last parameters in WriteToFile() */
/* arrays */
i = 0;
evo->sp.rgskeyar[i] = " typicalX %d"; evo->sp.rgp2adr[i++] = &evo->sp.typicalX;
evo->sp.rgskeyar[i] = " initialX %d"; evo->sp.rgp2adr[i++] = &evo->sp.xstart;
evo->sp.rgskeyar[i] = " initialStandardDeviations %d"; evo->sp.rgp2adr[i++] = &evo->sp.rgInitialStds;
evo->sp.rgskeyar[i] = " diffMinChange %d"; evo->sp.rgp2adr[i++] = &evo->sp.rgDiffMinChange;
evo->sp.n2para = i;
/** End Unknown section **/
//First reset the strategy parameters (sp)
evo->sp.N=6*numDipoles;
evo->sp.seed=0;
evo->sp.xstart=NULL;
evo->sp.typicalXcase=0;
evo->sp.rgInitialStds = NULL;
evo->sp.rgDiffMinChange = NULL;
evo->sp.stopMaxFunEvals = -1;
evo->sp.stopMaxIter = -1;
evo->sp.facmaxeval = 1;
evo->sp.stStopFitness.flg = 1;
evo->sp.stStopFitness.val = 1e-5;
evo->sp.stopTolFun = 1e-12;
evo->sp.stopTolFunHist = 1e-13;
evo->sp.stopTolX = 0; /* 1e-11*insigma would also be reasonable */
evo->sp.stopTolUpXFactor = 1e3;
evo->sp.lambda=lambda;
evo->sp.mu=-1;
evo->sp.mucov = -1;
evo->sp.weights = NULL;
evo->sp.weigkey=malloc(5*sizeof(char));
strcpy(evo->sp.weigkey, "log\0");
evo->sp.cs = -1;
evo->sp.ccumcov = -1;
evo->sp.damps = -1;
evo->sp.ccov = -1;
evo->sp.diagonalCov = 0; /* default is 0, but this might change in future, see below */
evo->sp.updateCmode.modulo = -1;
evo->sp.updateCmode.maxtime = -1;
evo->sp.updateCmode.flgalways = 0;
evo->sp.facupdateCmode = 1;
strcpy(evo->sp.resumefile, "_no_");
//printf("reinit:0\n");
readpara_SupplementDefaults(&(evo->sp));
//printf("reinit:1\n");
//Now reset the state variables
evo->version = "3.11.00.beta";
evo->sp.seed = random_init( &evo->rand, (long unsigned int) evo->sp.seed);
N = evo->sp.N; /* for convenience */
//printf("reinit:2\n");
evo->sp.rgInitialStds = new_double(N);
evo->sp.xstart = new_double(N);
for (k=0;k<numDipoles;k++)
{
evo->sp.rgInitialStds[k*6+0] = 3.000000;
evo->sp.rgInitialStds[k*6+1] = 4.0;
evo->sp.rgInitialStds[k*6+2] = 5.0;
evo->sp.rgInitialStds[k*6+3] = 90.0;
evo->sp.rgInitialStds[k*6+4] = 90.0;
evo->sp.rgInitialStds[k*6+5] = 3.75;
evo->sp.xstart[k*6+0] = 6.000000;
evo->sp.xstart[k*6+1] = 8.0;
evo->sp.xstart[k*6+2] = 15.0;
evo->sp.xstart[k*6+3] = 90.0;
evo->sp.xstart[k*6+4] = 90.0;
evo->sp.xstart[k*6+5] = 0.5;
}
/* initialization */
for (i = 0, trace = 0.; i < N; ++i)
trace += evo->sp.rgInitialStds[i]*evo->sp.rgInitialStds[i];
evo->sigma = sqrt(trace/N); /* evo->sp.mueff/(0.2*evo->sp.mueff+sqrt(N)) * sqrt(trace/N); */
//printf("reinit:3\n");
evo->chiN = sqrt((double) N) * (1. - 1./(4.*N) + 1./(21.*N*N));
evo->flgEigensysIsUptodate = 1;
evo->flgCheckEigen = 0;
evo->genOfEigensysUpdate = 0;
timings_init(&evo->eigenTimings);
evo->flgIniphase = 0; /* do not use iniphase, hsig does the job now */
evo->flgresumedone = 0;
evo->flgStop = 0;
for (dtest = 1.; dtest && dtest < 1.1 * dtest; dtest *= 2.)
if (dtest == dtest + 1.)
break;
evo->dMaxSignifKond = dtest / 1000.; /* not sure whether this is really safe, 100 does not work well enough */
evo->gen = 0;
evo->countevals = 0;
evo->state = 0;
evo->dLastMinEWgroesserNull = 1.0;
evo->printtime = evo->writetime = evo->firstwritetime = evo->firstprinttime = 0;
evo->rgpc = new_double(N);
evo->rgps = new_double(N);
evo->rgdTmp = new_double(N+1);
evo->rgBDz = new_double(N);
evo->rgxmean = new_double(N+2); evo->rgxmean[0] = N; ++evo->rgxmean;
evo->rgxold = new_double(N+2); evo->rgxold[0] = N; ++evo->rgxold;
evo->rgxbestever = new_double(N+3); evo->rgxbestever[0] = N; ++evo->rgxbestever;
evo->rgout = new_double(N+2); evo->rgout[0] = N; ++evo->rgout;
evo->rgD = new_double(N);
evo->C = (double**)new_void(N, sizeof(double*));
evo->B = (double**)new_void(N, sizeof(double*));
evo->publicFitness = new_double(evo->sp.lambda);
evo->rgFuncValue = new_double(evo->sp.lambda+1);
evo->rgFuncValue[0]=evo->sp.lambda; ++evo->rgFuncValue;
evo->arFuncValueHist = new_double(10+(int)ceil(3.*10.*N/evo->sp.lambda)+1);
evo->arFuncValueHist[0] = (double)(10+(int)ceil(3.*10.*N/evo->sp.lambda));
evo->arFuncValueHist++;
//printf("reinit:4\n");
for (i = 0; i < N; ++i) {
evo->C[i] = new_double(i+1);
evo->B[i] = new_double(N);
}
evo->index = (int *) new_void(evo->sp.lambda, sizeof(int));
for (i = 0; i < evo->sp.lambda; ++i)
evo->index[i] = i; /* should not be necessary */
evo->rgrgx = (double **)new_void(evo->sp.lambda, sizeof(double*));
rgrgxdata = new_double(evo->sp.lambda*(N+2));
for (i = 0; i < evo->sp.lambda; ++i) {
evo->rgrgx[i] = &rgrgxdata[i*(N+2)];
evo->rgrgx[i][0] = N;
evo->rgrgx[i]++;
}
// printf("Arggg:%d\n",evo->sp.lambda*(N+2));
//printf("reinit:5\n");
/* Initialize newed space */
for (i = 0; i < N; ++i)
for (j = 0; j < i; ++j)
evo->C[i][j] = evo->B[i][j] = evo->B[j][i] = 0.;
for (i = 0; i < N; ++i)
{
evo->B[i][i] = 1.;
evo->C[i][i] = evo->rgD[i] = evo->sp.rgInitialStds[i] * sqrt(N / trace);
evo->C[i][i] *= evo->C[i][i];
evo->rgpc[i] = evo->rgps[i] = 0.;
}
//printf("reinit:6\n");
evo->minEW = rgdouMin(evo->rgD, N); evo->minEW = evo->minEW * evo->minEW;
evo->maxEW = rgdouMax(evo->rgD, N); evo->maxEW = evo->maxEW * evo->maxEW;
evo->maxdiagC=evo->C[0][0]; for(i=1;i<N;++i) if(evo->maxdiagC<evo->C[i][i]) evo->maxdiagC=evo->C[i][i];
evo->mindiagC=evo->C[0][0]; for(i=1;i<N;++i) if(evo->mindiagC>evo->C[i][i]) evo->mindiagC=evo->C[i][i];
/* set xmean */
for (i = 0; i < N; ++i)
{
evo->rgxmean[i] = evo->rgxold[i] = evo->sp.xstart[i];
}
//printf("reinit:7\n");
return evo->publicFitness;
}
