Hello everyone, I have been trying to resolve with ISRES the benchmark g11 of the paper (Runarsson,Yao) that originated that algorithm. For this benchmark, the authors declare they have solved the problem within a couple of hundreds of iterations, and they nail the result with high precision.
This is a 2d problem with equality constraints. I have set the tolerance both on the constraint and the stopping criterion to e^-6, which seems reasonable considering the bounds of the domain and the value of the objective function. To start with, I have set the intial guess to the solution, with 2% perturbation on x1. The algorithm never reaches convergence, but it loops until maxEvals is exceeded, no matter the value of maxEvals. Note that the solution I get is not far from the correct solution. I am surprised that the value of the objective function I get with some cout in the objective function leads to an almost caothic plot. NLOpt will only find a solution within a finite number of iteration if the tolerance is set to --at least-- e^-1. In this case, the variability of the results run after run is pretty high. Below, the .cpp file of the C++ code I am running, is there anything wrong in what I am doing? Thanks, Daniele ======== // number of iterations required for this run int optIterations = 0; // Set the objective function for tutorial g11 double Optimizer::myfunc_g11(unsigned n, const double *x, double *grad, void *my_func_data) { // Increment the number of iterations for each call of the objective function ++optIterations; // f(x) = (x1)^2 + ( x2 - 1 )^2 double f= ( x[0]*x[0] + (x[1]-1)*(x[1]-1) ); std::cout<<f<<std::endl; return f; } // Set the constraint function for benchmark g11: double Optimizer::myconstraint_g11(unsigned n, const double *x, double *grad, void *data) { // h(x)= x2 - (x1)^2 = 0 return x[1] - x[0] * x[0]; } void Optimizer::run_g11() { // Benchmark case 11: // f(x) = (x1)^2 + ( x2 - 1 )^2 // Subjected to : // h(x)= x2 - (x1)^2 = 0 //where −1 ≤ x1 ≤ 1 and −1 ≤ x2 ≤ 1 //The optimum solution is // x = (±1/sqrt(2),1/2) where f(x) = 0.75 // Set the dimension of this problem (result vector size) size_t dimension=2; // Instantiate a NLOpobject and set the ISRES "Improved Stochastic Ranking Evolution Strategy" // algorithm for nonlinearly-constrained global optimization ///GN_ISRES nlopt::opt opt(nlopt::GN_ISRES,dimension); // Set the and apply the lower and the upper bounds std::vector<double> lb(dimension),ub(dimension); lb[0] = -1; ub[0] = 1; lb[1] = -1; ub[1] = 1; // Set the bounds for the constraints opt.set_lower_bounds(lb); opt.set_upper_bounds(ub); // Set the objective function to be minimized (or maximized, using set_max_objective) opt.set_min_objective(myfunc_g11, NULL); // Set the constraint equations opt.add_equality_constraint(myconstraint_g11, NULL, 1e-1); // Set the relative tolerance opt.set_xtol_rel(1e-1); // Set the max number of evaluations and the initial population opt.set_maxeval(5000); opt.set_population(1000); // Set some initial guess. Make sure it is within the // bounds that have been set std::vector<double> xp(dimension); xp[0]= 1./sqrt(2); xp[1]= .51; std::vector<double> dx(dimension); opt.get_initial_step(xp, dx); for(size_t i=0; i<dx.size(); i++){ std::cout<<"dx["<<i<<"]= "<<dx[i]<<std::endl; } // Launch the optimization; negative retVal implies failure double minf; nlopt::result result = opt.optimize(xp, minf); if (result < 0) { printf("nlopt failed!\n"); } else { printf("found minimum after %d evaluations\n", optIterations); printf("found minimum at f(%g,%g) = %0.10g\n", xp[0],xp[1],minf); } } _______________________________________________ NLopt-discuss mailing list NLopt-discuss@ab-initio.mit.edu http://ab-initio.mit.edu/cgi-bin/mailman/listinfo/nlopt-discuss