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; }