int main(int nargs, char* args[]) { srand(time(NULL)); bopt_params par = initialize_parameters_to_default(); par.n_iterations = 190; par.n_inner_iterations = 250; par.n_iter_relearn = 50; //par.random_seed = 0; par.verbose_level = 0; par.noise = 1e-10; par.sigma_s = 1; par.sc_type = SC_ML; par.init_method = 3; strcpy(par.crit_name, "cLCB"); par.crit_params[0] = 0.125; par.n_crit_params = 1; par.force_jump = 0; strcpy(par.kernel.name, "kSEARD"); benchmark<BraninNormalized>(par, "branin"); benchmark<Hartmann6>(par, "hartmann6"); benchmark<Hartmann3>(par, "hartmann3"); benchmark<Rastrigin>(par, "rastrigin"); benchmark<Sphere>(par, "sphere"); benchmark<Ellipsoid>(par, "ellipsoid"); benchmark<GoldsteinPrice>(par, "goldsteinprice"); benchmark<SixHumpCamel>(par, "sixhumpcamel"); return 0; }
void minim_bayes(density_t *ndft) { int i; double minf; double *x; bayes_par par_input; nlopt_function_data function_data; bopt_params par; /* Initializing the bounds for the optimization. We need two vectors with size ipf.npar to parse them to bayesopt */ par_input.lb = (double *)malloc(ipf.npar*sizeof(double)); parse_double ("bayes_lb", par_input.lb); for(i = 1; i < ipf.npar; i++) par_input.lb[i] = par_input.lb[0]; par_input.ub = (double *)malloc(ipf.npar*sizeof(double)); parse_double ("bayes_ub", par_input.ub); for(i = 1; i < ipf.npar; i++) par_input.ub[i] = par_input.ub[0]; x = (double *)malloc(ipf.npar*sizeof(double)); for(i = 0; i < ipf.npar; i++) x[i] = gsl_vector_get(ipf.gamma, i); /* Initializing all the parameters to default, and then modifying them */ par = initialize_parameters_to_default(); /* The use of the auxiliar data.n_iter, data.init_samples and data.init_method parameters is caused by their par.* equivalents being defined as size_t instead of int, which caused some warnings and errors in the parser */ par.n_iterations = 190; parse_int("bayes_iter", &par_input.n_iter); par.n_iterations = par_input.n_iter; par.n_init_samples = 10; parse_int("bayes_init_samples", &par_input.init_samples); par.n_init_samples = par_input.init_samples; par.init_method = 1; parse_int("bayes_init_method", &par_input.init_method); par.init_method = par_input.init_method; par.random_seed = 0; par.verbose_level = 1; parse_int("bayes_verbose", &par.verbose_level); par.noise = 1e-10; parse_double("bayes_noise", &par.noise); par_input.learning = "L_MCMC"; parse_string("bayes_learning", &par_input.learning); set_learning(&par, par_input.learning); function_data.counter = 0; function_data.ndft = density_get_val(ndft); messages_basic("\n\n\nStarting the optimization.\n\n\n"); bayes_optimization(ipf.npar, nlopt_gfunction, &function_data, par_input.lb, par_input.ub, x, &minf, par); if(myid == 0) printf("Success: iterations = %d, G(gamma) = %15.10f\n", function_data.counter, minf); if(myid == 0) printf("gamma = "); if(myid == 0) {for(i = 0; i < ipf.npar; i++) printf("%.5f ", x[i]);} if(myid == 0) printf("\n"); for(i = 0; i < ipf.npar; i++) gsl_vector_set(ipf.gamma, i, x[i]); ipf_write(ipf, ipf_ref, "pot"); parallel_end(EXIT_SUCCESS); }
bopt_params getBoptParams(CommandLineOptions const &options) { bopt_params params = initialize_parameters_to_default(); params.n_init_samples = options.n_init_samples; params.n_iterations = options.n_iterations; params.n_iter_relearn = options.n_iter_relearn; params.noise = 1e-14; params.init_method = 2; return params; }
int main(int nargs, char *args[]) { bayesopt::Parameters par; if(nargs > 1) { if(!bayesopt::utils::ParamLoader::load(args[1], par)) { std::cout << "ERROR: provided file \"" << args[1] << "\" does not exist" << std::endl; return -1; } } else { par = initialize_parameters_to_default(); par.n_iterations = 100; par.n_init_samples = 2; par.n_iter_relearn = 1; par.random_seed = 10; //set_surrogate(&par,"sStudentTProcessNIG"); par.l_type = L_MCMC; par.sc_type = SC_MAP; par.verbose_level = 1; //bayesopt::utils::ParamLoader::save("bo_branin_display.txt", par); } boost::scoped_ptr<BraninNormalized> branin(new BraninNormalized(par)); GLOBAL_MATPLOT.init(branin.get(),2); vectord sv(2); sv(0) = 0.1239; sv(1) = 0.8183; GLOBAL_MATPLOT.setSolution(sv); sv(0) = 0.5428; sv(1) = 0.1517; GLOBAL_MATPLOT.setSolution(sv); sv(0) = 0.9617; sv(1) = 0.1650; GLOBAL_MATPLOT.setSolution(sv); glutInit(&nargs, args); glutCreateWindow(50,50,800,650); glutDisplayFunc( display ); glutReshapeFunc( reshape ); glutIdleFunc( idle ); glutMotionFunc( motion ); glutMouseFunc( mouse ); glutPassiveMotionFunc(passive); glutKeyboardFunc( keyboard ); glutMainLoop(); return 0; }
int main(int nargs, char *args[]) { bopt_params par = initialize_parameters_to_default(); par.n_iterations = 190; par.random_seed = 0; par.verbose_level = 1; par.noise = 1e-10; BraninNormalized branin(par); vectord result(2); branin.optimize(result); std::cout << "Result: " << result << "->" << branin.evaluateSample(result) << std::endl; branin.printOptimal(); return 0; }
int main(int nargs, char *args[]) { bopt_params par = initialize_parameters_to_default(); par.n_iterations = 190; par.noise = 1e-10; par.random_seed = 0; par.verbose_level = 1; ExampleCamelback camel(par); std::ofstream timelog; timelog.open("time_camel.log"); std::clock_t curr_t; std::clock_t prev_t = clock(); camel.initializeOptimization(); for (size_t ii = 0; ii < par.n_iterations; ++ii) { camel.stepOptimization(); curr_t = clock(); timelog << ii << "," << static_cast<double>(curr_t - prev_t) / CLOCKS_PER_SEC << std::endl; prev_t = curr_t; } timelog.close(); vectord result = camel.getFinalResult(); std::cout << "Result: " << result << "->" << camel.evaluateSample(result) << std::endl; camel.printOptimal(); return 0; }
int main(int nargs, char *args[]) { bayesopt::Parameters par; if(nargs > 1){ if(!bayesopt::utils::ParamLoader::load(args[1], par)){ std::cout << "ERROR: provided file \"" << args[1] << "\" does not exist" << std::endl; return -1; } } else{ par = initialize_parameters_to_default(); par.n_iterations = 190; par.random_seed = 0; par.verbose_level = 1; par.noise = 1e-10; //bayesopt::utils::ParamLoader::save("system_opt.txt", par); } SystemCallsBranin branin(par); vectord result(2); branin.optimize(result); std::cout << "Result: " << result << "->" << branin.evaluateSample(result) << std::endl; branin.printOptimal(); // Remove results.txt file std::string filename("results.txt"); if( remove( filename.c_str() ) == 0 ){ std::cout << "File \"" << filename << "\" successfully removed" << std::endl; } else{ std::cout << "Error: cannot remove \"" << filename << "\" file" << std::endl; } return 0; }
int main(int nargs, char *args[]) { int n = 6; // Number of dimensions // Common configuration // See parameters.h for the available options // If we initialize the struct with the DEFAUL_PARAMS, // the we can optionally change only few of them bopt_params par = initialize_parameters_to_default(); par.kernel.hp_mean[0] = KERNEL_THETA; par.kernel.hp_std[0] = 1.0; par.kernel.n_hp = 1; par.mean.coef_mean[0] = 0.0; par.mean.coef_std[0] = MEAN_SIGMA; par.mean.n_coef = 1; par.noise = DEFAULT_NOISE; par.surr_name = "sStudentTProcessJef"; par.n_iterations = 20; // Number of iterations par.n_init_samples = 20; /*******************************************/ size_t nPoints = 1000; randEngine mtRandom; matrixd xPoints(nPoints,n); vecOfvec xP; //Thanks to the quirks of Visual Studio, the following expression is invalid, //so we have to replace it by a literal. //WARNING: Make sure to update the size of the array if the number of points //or dimensions change. #ifdef _MSC_VER double xPointsArray[6000]; #else const size_t nPinArr = n*nPoints; double xPointsArray[nPinArr]; #endif bayesopt::utils::lhs(xPoints,mtRandom); for(size_t i = 0; i<nPoints; ++i) { vectord point = row(xPoints,i); xP.push_back(point); for(size_t j=0; j<n; ++j) { xPointsArray[i*n+j] = point(j); } } // Run C++ interface std::cout << "Running C++ interface" << std::endl; ExampleDisc opt(xP,par); vectord result(n); opt.optimize(result); // Run C interface std::cout << "Running C interface" << std::endl; double x[128], fmin[128]; bayes_optimization_disc(n, &testFunction, NULL, xPointsArray, nPoints, x, fmin, par); // Find the optimal value size_t min = 0; double minvalue = opt.evaluateSample(row(xPoints,min)); for(size_t i = 1; i<nPoints; ++i) { vectord point = row(xPoints,i); if (opt.evaluateSample(point) < minvalue) { min = i; minvalue = opt.evaluateSample(row(xPoints,min)); std::cout << i << "," << minvalue << std::endl; } } std::cout << "Final result C++: " << result << std::endl; std::cout << "Final result C: ("; for (int i = 0; i < n; i++ ) std::cout << x[i] << ", "; std::cout << ")" << std::endl; std::cout << "Optimal: " << row(xPoints,min) << std::endl; }
int main(int nargs, char *args[]) { bopt_params par = initialize_parameters_to_default(); par.verbose_level = 0; par.noise = 1e-10; par.force_jump = 30; std::ofstream log; std::clock_t start_t; /* Branin */ log.open("branin.log"); par.n_init_samples = 5; par.n_iterations = 195; for (size_t ii = 0; ii < 10; ++ii) { par.random_seed = ii; BraninNormalized branin(par); vectord result(2); start_t = clock(); branin.initializeOptimization(); for (size_t jj = 0; jj < par.n_iterations; ++jj) { branin.stepOptimization(); if (jj == 50) { result = branin.getFinalResult(); log << branin.evaluateSample(result) << ", "; } } result = branin.getFinalResult(); log << branin.evaluateSample(result) << ", "; log << static_cast<double>(clock() - start_t) / static_cast<double>(CLOCKS_PER_SEC) << std::endl; } log.close(); /* Camel */ log.open("camel.log"); par.n_init_samples = 5; par.n_iterations = 95; for (size_t ii = 0; ii < 10; ++ii) { par.random_seed = ii; ExampleCamelback camel(par); vectord result(2); vectord lb(2); lb(0) = -2; lb(1) = -1; vectord ub(2); ub(0) = 2; ub(1) = 1; camel.setBoundingBox(lb,ub); start_t = clock(); camel.initializeOptimization(); for (size_t jj = 0; jj < par.n_iterations; ++jj) { camel.stepOptimization(); if (jj == 50) { result = camel.getFinalResult(); log << camel.evaluateSample(result) << ", "; } } result = camel.getFinalResult(); log << camel.evaluateSample(result) << ", "; log << static_cast<double>(clock() - start_t) / static_cast<double>(CLOCKS_PER_SEC) << std::endl; } log.close(); /* Hart */ log.open("hart.log"); par.n_init_samples = 10; par.n_iterations = 190; for (size_t ii = 0; ii < 10; ++ii) { par.random_seed = ii; ExampleHartmann6 hart(par); vectord result(6); start_t = clock(); hart.initializeOptimization(); for (size_t jj = 0; jj < par.n_iterations; ++jj) { hart.stepOptimization(); if (jj == 50) { result = hart.getFinalResult(); log << hart.evaluateSample(result) << ", "; } } result = hart.getFinalResult(); log << hart.evaluateSample(result) << ", "; log << static_cast<double>(clock() - start_t) / static_cast<double>(CLOCKS_PER_SEC) << std::endl; } log.close(); /***********************************************************************/ par.n_init_samples = 2; par.n_iter_relearn = 1; par.l_type = L_MCMC; par.sc_type = SC_MAP; /* Branin */ log.open("branin_mcmc.log"); par.n_iterations = 198; for (size_t ii = 0; ii < 10; ++ii) { par.random_seed = ii; BraninNormalized branin(par); vectord result(2); start_t = clock(); branin.initializeOptimization(); for (size_t jj = 0; jj < par.n_iterations; ++jj) { branin.stepOptimization(); if (jj == 50) { result = branin.getFinalResult(); log << branin.evaluateSample(result) << ", "; } } result = branin.getFinalResult(); log << branin.evaluateSample(result) << ", "; log << static_cast<double>(clock() - start_t) / static_cast<double>(CLOCKS_PER_SEC) << std::endl; } log.close(); /* Camel */ log.open("camel_mcmc.log"); par.n_iterations = 98; for (size_t ii = 0; ii < 10; ++ii) { par.random_seed = ii; ExampleCamelback camel(par); vectord result(2); vectord lb(2); lb(0) = -2; lb(1) = -1; vectord ub(2); ub(0) = 2; ub(1) = 1; camel.setBoundingBox(lb,ub); start_t = clock(); camel.initializeOptimization(); for (size_t jj = 0; jj < par.n_iterations; ++jj) { camel.stepOptimization(); if (jj == 50) { result = camel.getFinalResult(); log << camel.evaluateSample(result) << ", "; } } result = camel.getFinalResult(); log << camel.evaluateSample(result) << ", "; log << static_cast<double>(clock() - start_t) / static_cast<double>(CLOCKS_PER_SEC) << std::endl; } log.close(); /* Hart */ log.open("hart_mcmc.log"); par.n_iterations = 198; for (size_t ii = 0; ii < 10; ++ii) { par.random_seed = ii; ExampleHartmann6 hart(par); vectord result(6); start_t = clock(); hart.initializeOptimization(); for (size_t jj = 0; jj < par.n_iterations; ++jj) { hart.stepOptimization(); if (jj == 50) { result = hart.getFinalResult(); log << hart.evaluateSample(result) << ", "; } } result = hart.getFinalResult(); log << hart.evaluateSample(result) << ", "; log << static_cast<double>(clock() - start_t) / static_cast<double>(CLOCKS_PER_SEC) << std::endl; } log.close(); return 0; }
bopt_params Parameters::generate_bopt_params() { bopt_params c_params = initialize_parameters_to_default(); c_params.n_iterations = n_iterations; c_params.n_inner_iterations = n_inner_iterations; c_params.n_init_samples = n_init_samples; c_params.n_iter_relearn = n_iter_relearn; c_params.init_method = init_method; c_params.random_seed = random_seed; c_params.verbose_level = verbose_level; strcpy(c_params.log_filename, log_filename.c_str()); c_params.load_save_flag = load_save_flag; strcpy(c_params.load_filename, load_filename.c_str()); strcpy(c_params.save_filename, save_filename.c_str()); strcpy(c_params.surr_name, surr_name.c_str()); c_params.sigma_s = sigma_s; c_params.noise = noise; c_params.alpha = alpha; c_params.beta = beta; c_params.sc_type = sc_type; c_params.l_type = l_type; c_params.l_all = l_all; c_params.epsilon = epsilon; c_params.force_jump = force_jump; strcpy(c_params.kernel.name, kernel.name.c_str()); //TODO (Javier): Should it be necessary to check size? for(size_t i=0; i<kernel.hp_mean.size(); i++){ c_params.kernel.hp_mean[i] = kernel.hp_mean[i]; } for(size_t i=0; i<kernel.hp_std.size(); i++){ c_params.kernel.hp_std[i] = kernel.hp_std[i]; } c_params.kernel.n_hp = kernel.hp_std.size(); strcpy(c_params.mean.name, mean.name.c_str()); for(size_t i=0; i<mean.coef_mean.size(); i++){ c_params.mean.coef_mean[i] = mean.coef_mean[i]; } for(size_t i=0; i<mean.coef_std.size(); i++){ c_params.mean.coef_std[i] = mean.coef_std[i]; } c_params.mean.n_coef = mean.coef_std.size(); for (size_t row = 0; row < input.noise_matrix.size1(); ++row) { for (size_t col = 0; col < input.noise_matrix.size2(); ++col) { c_params.input.noise[col + (row * input.noise_matrix.size1())] = input.noise_matrix(row,col); } } c_params.input.unscented_scale = input.unscented_scale; c_params.input.n_coef = input.noise_matrix.size1() * input.noise_matrix.size2(); c_params.unscented_outcome = unscented_outcome; strcpy(c_params.crit_name, crit_name.c_str()); for(size_t i=0; i<crit_params.size(); i++){ c_params.crit_params[i] = crit_params[i]; } c_params.n_crit_params = crit_params.size(); return c_params; }